[Swift] 코딩테스트에 필요한 문법 총정리

문자열/컬렉션

문자열/배열

✅ 배열 초기화

https://developer.apple.com/documentation/swift/array

// Shortened forms are preferred
var emptyDoubles: [Double] = []
var emptyDoubles = Array<Double>()
var emptyDoubles = [Double]()

// The full type name is also allowed
var emptyFloats: Array<Float> = Array()

var numbers = [1, 2, 3, 4 ,5]
var answer = Array(numbers[1...3])
print(answer)
// Prints "[2, 3, 4]"

var ex_4 = Array(1...10)
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 

✅ 배열 슬라이싱 (Python처럼 반복문을 사용하지 않고 반복문을 슬라이싱하는 코드가 가능하다.)

https://daewonyoon.tistory.com/480

SWIFT 기초] 배열 슬라이싱 python과 swift 비교

 

✅ 반복된 원소로 이루어진 배열/문자열 초기화

- Array/String(repeating: count:)

var digitCounts = Array(repeating: 0, count: 10)
//위와 같음 
var digitCounts = [Int](repeating: 0, count: 10)
print(digitCounts)
// Prints "[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]"

var answer = ""
for i in "hello" {
    answer += String(repeating: i, count: 3)
}
print(answer) //"hhheeelllooo"

var digits = Array(repeating: [1, 2, 3], count:3).flatMap { $0 } //2차원 배열 -> 1차원 배열
// [1, 2, 3, 1, 2, 3, 1, 2, 3]

 

✅ N개의 빈 리스트로 이루어진 빈 2차원 배열 초기화

var graph:[[Int]] = Array(repeating: [], count: N)

 

✅ 문자열/배열 인덱스 함수 정리

startIndex : 문자열/배열의 첫번째 인덱스

endIndex  : 문자열/배열의 마지막 인덱스 (주의할 점은 마지막 인덱스!가 아니라 마지막인덱스 + 1 이므로 마지막 인덱스를 접근하려면 -1을 해야함)

index(Array.Index, offsetBy: Int) : 인자로 들어온 인덱스와 offsetBy 차이만큼 떨어진 인덱스

index(of: element) : element가 array에 포함된 인덱스 반환 -> 없다면 nil 반환
firstIndex(of: element), lastIndex(of: element) : 인자로 들어온 element가 배열에서 등장하는 첫번째 인덱스, 마지막 인덱스

firstIndex(where: { 클로저 }) : 클로저 조건을 만족하는 첫번째 인덱스

swapAt(Self.Index, Self.Index) : 배열에서 index1과 index2에 해당하는 요소를 서로 바꾸는 메소드

 

 

✅ 문자열에서 또 하나의 부분 문자열 만들기

let string = "aabbaccc"
let startIndex = string.index(string.startIndex, offsetBy: 0)
let endIndex = string.index(string.startIndex, offsetBy: 2)

print(string[startIndex...endIndex]) //aab
print(string[startIndex..<endIndex]) //aa

 

✅ 배열/문자열 첫번째/마지막 원소

https://developer.apple.com/documentation/swift/array/first

https://developer.apple.com/documentation/swift/string/first

 

Array/String.first : 첫번째 원소 (없으면 nil)

ArrayString.last : 마지막 원소 (없으면 nil)

 

✅ 문자열 인덱스로 접근을 자주할 때 - extension 활용 ⭐

extension String {
    subscript(index: Int) -> Character {
        if index >= 0 { return self[self.index(self.startIndex, offsetBy: index)] }
        else {
            let revIndex = self.count + index //swift는 인덱스 음수에 대응이 안되므로 이에 대응하기 위함
            return self[self.index(self.startIndex, offsetBy: revIndex)]
        }
    }
}

 

✅ 배열/문자열 추가 / 제거 / 교체 ⭐

[추가]

append(element) : 배열 끝에 인자 element를 추가하는 메소드

append(contentsOf: Array): 배열 끝에 인자의 array element를 추가하는 메소드

array += [element] : 배열 끝에 배열 원소 추가해서 합침

insert(element, at : index) : 배열의 index 자리에 인자의 element를 추가하는 메소드

insert(contentsOf: Array, at: index): 배열의 index 자리에 인자의 array element를 추가하는 메소드

 

[제거]

remove(at: index) -> Element : 배열 index 자리의 element를 제거 후, 제거된 element를 반환하는 메소드

 

removeFirst(n: 생략 가능) -> Element : 배열의 첫번째 element를 제거 후, 제거 된 element를 반환하는 메소드

n을 지정하면 처음부터 차례대로 n개 만큼 삭제

removeLast(n: 생략 가능) -> Element : 배열의 마지막 element를 제거 후, 제거 된 element를 반환하는 메소드

n을 지정하면 뒤에서부터 차례대로 n개 삭제

 

vs

dropFirst(n: 생략갸능) / dropLast(n: 생략가능): 원본 배열을 변화시키지 않고 항목을 제거한 배열을 반환함

 

https://velog.io/@jee/Swift%EC%9D%98-dropLast-popLast-removeLast-%EC%9D%98-%EC%B0%A8%EC%9D%B4

Swift의 dropLast(), popLast(), removeLast() 의 차이

 

removeAll(클로저: 생략가능) : (클로저 조건을 만족하는) 모든 element 제거

popLast() -> Element  : removeLast와 기능은 같지만, 옵셔널이라는 데에 차이가 있음 (nil값일 수도 있는 경우 이 메소드 사용)

배열에 원하는 값 index 찾아서 삭제하기

if let index = array.firstIndex(where: {$0 == value}) {
	array.remove(at: index)
}

 

array[범위] = []

alphabet = ["A", "B", "C", "D", "E", "F", "G"]

// 요소 삭제
alphabet[0...2] = []

// alphabet : ["D", "E", "F", "G"]

 

[교체]

array[범위] = [element]

alphabet = ["A", "B", "C", "D", "E", "F", "G"]

// 요소 교체하기
alphabet[0] = "a"

// 범위를 교체하기
alphabet[0...2] = ["x", "y", "z"]

// alphabet: ["x", "y", "z", "D", "E", "F", "G"]

 

✅ 배열과 문자열은 '+' 연산자로 합치기가 가능하다!

 

✅ 배열 관련 주요 함수

https://developer.apple.com/documentation/swift/array/contains(_:)

- contains(element) : 특정 요소를 포함하는지에 대한 bool 값 반환

contains(where: { 클로저 }) : 클로저를 통해 조건을 걸어 특정 요소의 포함여부를 확인할 수 있다.

 

- allSatisfy(closer) : 클로저의 조건을 모두 만족하는지에 대한 bool 값 반환

- max(클로저 : 생략가능) / min(클로저 : 생략가능) : 최대값 / 최소값 반환 -> 없으면 nil

var input = [1, 2, 3, 4, 5]
var importants = input.map { (find: false, num: $0) }

var num_max = importants.max(by: { $0.num < $1.num })!.num

//튜플 안의 num끼리 비교하여 max값을 반환해줌

 

- String.range(of: 문자열): String에 문자열이 포함되어있으면 해당 포함된 범위 반환

let greeting = "hello yuri"
var range = greeting.range(of: "yuri")!  // yuri가 포함되어있는 범위

greeting[range]   // yuri

 

✅ 오름차순/내림차순 정렬

 

sort() : 정렬 / sorted(): 반환값이 있는 정렬

내림차순 정렬 : sort(by: >), sorted(by: >)

-> 문자열의 경우 알파벳 사전순 기준으로 정렬한다.

 

sort를 사용할 수 있다면 sort를 사용하는게 더 빠르다.

 

🔥 sorted { 조건문 }

ex) 절댓값이 큰 순서대로 나열

numlist.sorted { abs(n-$0) > abs(n-$1) }

 

ex) 절댓값이 작은 순서대로이면서, 같다면 더 큰값을 앞에 배치하는 순서대로 나열

    var num_list = numlist.sorted { t1, t2 in 
         if abs(n-t1) == abs(n-t2) {
              return t1 > t2
         }
              return abs(n-t1) < abs(n-t2) 
        }
        
        // 위와 아래 둘다 같은 표현
    var num_list = numlist.sorted { abs(n-$0) == abs(n-$1) ? $0 > $1 : abs(n-$0) < abs(n-$1) }
    return num_list

ex) 알파벳 소문자로 이루어진 N개의 단어가 들어오면 아래와 같은 조건에 따라 정렬하는 프로그램을 작성하시오.

1. 길이가 짧은 것부터
2. 길이가 같으면 사전 순으로 (같으면 조건을 먼저 걸기)

var array = 문자 배열.map { ($0, $0.count)}
array.sort(by: { first, second in
  if first.1 == second.1 {
    return first.0 < second.0
  }
  else{
    return first.1 < second.1
  }
})
// 위, 아래 둘다 같은 표현
array.sort(by: { $0.1 == $1.1 ? $0.0 < $1.0 : $0.1 < $1.1 })

 

✅ 배열/문자열 뒤집기

Array.reversed() / 문자열의 경우 String(Array.reversed()) 로 감싸주어야 문자열로 사용 가능

 

✅ 문자열 쪼개기

https://green1229.tistory.com/318

Swift의 문자열 처리 (split vs components)

1) split(separator: Character(구분자)) -> [Self.SubSequence]

반환이 Array가 아니므로 array로 변환해줘야함

 

- 구분자 여러개

split(whereSeparator: { $0 == 구분자1 } || { $0 == 구분자2 }) -> [Self.SubSequence]

 

2) components(separatedBy: String(구분자)) -> [String]

 

- 구분자 여러개

components(separatedBy: [구분자1, 구분자 2....]) -> [String]

 

 

✅ 배열 <-> 문자열 변환

   문자열 -> [Character] : Array(String)

    문자열 -> [String] : 문자열.map { String($0) }

    배열 -> 문자열 : joined(separator: 구분자 -> 생략하면 default는 구분자 "") / String()으로 감싸기

* 한줄에 원소 하나씩 출력하는 문자열 : joined(separator:"\n")

let answer = "Hi, I'm yuri"
let answerarr = answer.components(separatedBy: " ")
let answerString = answerarr.joined(separator: "") // =answerarr.joined()
= String(answerarr)

print(answerarr[0]) //"Hi,"
print(answerString) //"Hi,I'myuri"

let arr = ["1", "2", "3", "4", "5", "6", "7"]
print(arr.joined(separator:"\n")) //배열을 한줄에 하나씩 출력하는 문자열로 변환

//1
2
3
4
5
6
7

 

✅ string 일부 문자 치환

replacingOccurrences(of: String, with: String) -> String / of를 with로 (of가 없으면 안바꿈)

let my_string = "abcdef"
let letter = "f"

my_string.replacingOccurrences(of: letter, with:"")

print(my_string.replacingOccurrences(of: letter, with: "") //"abcde"

 

✅ Character 정수, 문자 판별

isNumber : 해당 character가 정수인지에 대한 bool 값

isLetter : 해당 character가 문자인지에 대한 bool 값

isUppercase : 해당 character가 대문자인지에 대한 bool 값

isLowercase : 해당 character가 소문자인지에 대한 bool 값

 

✅ String 소문자 <-> 대문자 변환

 

문자열 전체 대문자 변환 : uppercased()

문자열 전체 소문자 변환 : lowercased()

문자열 전체 대문자로 시작하는 문자열로 변환 : capitalized()

 

✅ string 포맷

- String(format: " ", Int) -> String

import Foundation //필수!

print(String(format: "%d", 12)) // 12
print(String(format: "[%d]", 12345)) // "[12345]\n" // 필요한 자릿수 만큼만 출력
print(String(format: "%03d", 12)) // "012" -> 3자리, 앞에 0

String(format: "%.3f", 38.99535) // 38.995 -> 소수점 아래 3자리

 

✅ 문자열끼리 비교 연산자를 통해 비교가 가능하다. (Ascii code로 비교 -> 참고 링크)

print("Yuri" > "yuri") // false
print("yuri" == "yuri") // true
print("05:00" < "06:00") // true

 

✅ 배열 인덱스, 요소 한꺼번에 접근

enumerated() : 인덱스, 인덱스에 맞는 요소 한꺼번에 접근하는방법

https://developer.apple.com/documentation/swift/array/enumerated()

let str = "ABCDE"
for (i, e) in str.enumerated() {
    print("\(i) - \(e)")
}

// 0 - A
// 1 - B
// 2 - C
// 3 - D
// 4 - E


for tuple in str.enumerated() {
	print("\(tuple.0) - \(tuple.1)")
    // print("\(tuple.offset) - \(tuple.element)")
}

for tuple in str.enumerated().reversed() { // 거꾸로 인덱스, 요소 차례대로 접근
	print("\(tuple.0) - \(tuple.1)")
}
// 4 - E
....
// 0 - A

 

enumerated()에서 인덱스, 요소 따로 접근하는 방법
인덱스 : $0.offset / $0.0 , 요소 : $0.element / $0.1

str.enumerated().forEach({
    print($0.offset, $0.element)
})

// 0 A
// 1 B
// 2 C
// 3 D
// 4 E

 

✅ 2차원 배열 -> 1차원 배열 변환

let 2darr : [[Int]] = [[1,2,3],[4,5,6],[7,8,9]]
let 1darr = Array(arr.joined())
let 1darr = 2darr.flatMap { $0 }

 

✅ 알파벳(String형) -> 정수 변환 (순서)

알파벳은 총 26개이다.

- 소문자 : index = Int(UnicodeScalar(String)!.value) - Int(UnicodeScalar("A").value)

- 대문자: index = Int(UnicodeScalar(String)!.value) - Int(UnicodeScalar("a").value)

 

✅ 정수 -> 알파벳 변환 (순서)

- 소문자: String(UnicodeScalar(97 + index)!) 
- 대문자: String(UnicodeScalar(65 + index)!) 

 

✅ prefix, sufix

let strData = "hello유리!!"

// [prefix : 시작 기준으로 지정한 문자 개수 출력]
let startData = strData.prefix(5)
print(startData)  // hello

// [suffix : 종료 기준으로 지정한 문자 개수 출력]
let endData = strData.suffix(4)
print(endData) // 유리!!


let numbers = [1, 2, 3, 4, 5]
print(numbers.prefix(2))
// Prints "[1, 2]"
print(numbers.prefix(10))
// Prints "[1, 2, 3, 4, 5]"

let numbers = [1, 2, 3, 4, 5]
print(numbers.suffix(2))
// Prints "[4, 5]"
print(numbers.suffix(10))
// Prints "[1, 2, 3, 4, 5]"

 

✅ String.hasPrefix, hasSuffix -> Bool : 앞에서, 뒤에서부터 탐색했을 때 문자열을 포함하는지

var hello = "Hello"
var greeting = "Hello My name is Yuri"

print(hello.hasPrefix("He")) //true
print(hello.hasPrefix("HE")) //false

print(greeting.hasPrefix("Hello ")) //true
print(greeting.hasPrefix("Yuri")) //false

print(hello.hasSuffix("llo")) //true

 

✅ String/Array.starts(with: ) -> Bool : 문자열/배열이 특정 sequence로 시작하는지 판단하는 함수

"123456".starts(with: "12")
[1, 2, 3, 4, 5].starts(with: [1, 3])

 

✅ trimmingCharacters(in: ) : 양 끝에 특정 문자열 제거

// 방법 1
var string = " 공백이 있는 문자열 "
let trimString = string.trimmingCharacters(in: [" "])
print(string)
print(trimString)

// 방법 2
var string = " 공백이 있는 문자열 "
let trimString = string.trimmingCharacters(in: .whitespaces)
print(string)
print(trimString)

// 에시 3 new_id에서 마침표(.)가 처음이나 끝에 위치한다면 제거합니다.
newid = newid.trimmingCharacters(in: ["."])

var someString = "?Swift!"
var removedString = someString.trimmingCharacters(in: ["?","!"])
print(removedString) // "Swift"


someString = "?Swi!ft!"
removedString = someString.trimmingCharacters(in: ["?","!"])
print(removedString)  // Swi!ft -> 앞 뒤만 제거하는 기능

 

딕셔너리

✅ 딕셔너리 초기화

// 단축문법
var words: [String: String] = [:]

// 정식문법
var words: Dictionary<String, String>

// 빈 딕셔너리 생성
let emptyDic1: Dictionary<Int, String> = [:]
let emptyDic2 = Dictionary<Int, String>()
let emptyDic3 = [Int: String]()
let emptyDic4:[Int:String] = [:]

 

✅ 딕셔너리 안에 배열, 딕셔너리가 중첩으로 들어갈 수 있다.

// 딕셔너리의 중첩 사용

var dict1 = [String: [String]]()       

dict1["arr1"] = ["A", "B", "C"]
dict1["arr2"] = ["D", "E", "F"]

var dict2 = [String: [String: Int]]()     // 딕셔너리 안에 딕셔너리가 들어갈 수 있다.

dict2["dic1"] = ["name": 1, "age": 2]
dict2["dic2"] = ["name": 2, "age": 4]

 

✅ 딕셔너리 value 접근 및 기본값

서브스크립트 문법 + key값을 활용하여 접근

// 딕셔너리
dic = ["A": "Apple", "B": "Banana", "C": "City"]

dic["A"]        // nil의 가능성 (key에 해당하는 값이 없을 수도 있고, key가 없을 수도 있으므로) =====> String?(옵셔널)
if let value = dic["A"]{  // 옵셔널 바인딩을 통해서 꺼내옴
    print(value) // "Apple"
}
print(dic["Q"]) // nil --> 오류가 나지는 않음

if let a = dic["A"] {    // 옵셔널 바인딩
    print(a)
} else {
    print("Not found")
}

print(dic["Q", default: "Queen"]) // nil을 발생할 확률이 없도록 기본값 지정 -> 딕셔너리에 없으므로 기본값 반환함

 

✅ 딕셔너리 기본값 활용하여 딕셔너리 편리하게 초기화하기

- default: 기본값

  let input = readLine()!.map { String($0) }
  var dic:[String:Int] = [:]

  input.forEach { dic[$0, default: 0] += 1 }
  input.reduce(into: [:], { $0[$1, default: 0] += 1}) //$0 : 빈 딕셔너리, $1: input의 원소

 

✅ 딕셔너리 업데이트 / 제거

words = [:]

words["B"] = "Banana"  // 동일한 키가 없으면 ===> 추가하기

words["B"] = "Blue"    // 동일한 키가 있으면 ===> 기존 밸류 덮어쓰기

words["B"] = nil // B에 해당하는 value 값 제거

words["C"] = nil // 존재하지 않는 key값의 value를 제거하여도 에러가 일어나지 X

words.removeAll() // 딕셔너리 모두 제거 ([:])

 

✅ 딕셔너리 반복문

let myDict = [1: "One", 2: "Two", 3: "Three"]

for (key, value) in myDict {
    print(key, value)
}

for key in myDict.keys {
    print(key) //[1, 2, 3]
}

for value in myDict.values {
    print(value) //["One", "two", "Three"]
}

 

✅ 딕셔너리 정렬

var scoreDict: [Int: Int] = [1: 90, 2: 50, 3: 30, 4: 100]
// key 값 기준으로 정렬
let keySortedDict = scoreDict.sorted(by: {$0.0 < $1.0}) (=scoreDict.sorted(by: {$0.key < $1.key})
print(keySortedDict)
// [(key: 1, value: 90), (key: 2, value: 50), (key: 3, value: 30), (key: 4, value: 100)]

// value 값 기준으로 정렬
let valueSortedDict = scoreDict.sorted(by: {$0.1 < $1.1}) (=scoreDict.sorted(by: {$0.value < $1.value })
print(valueSortedDict)
// [(key: 3, value: 30), (key: 2, value: 50), (key: 1, value: 90), (key: 4, value: 100)]

=> 여기서 주의할 점은, 정렬한 결과값이 딕셔너리가 아니라 (key, value) named tuple로 이루어진 배열이라는 점이다.

=> 정렬한 결과값에서 특정 튜플의 key나 혹은 value를 얻고싶다면, 위와 같은 예시의 경우 valueSortedDict[0].key / valueSorted[1].value 이런식으로 접근하면 된다.

 

✅ 딕셔너리 키/값 최대/최소값

- dictionary.keys.max() / dictionary.values.min()

- dictionary.keys.min() / dictionary.values.min()

 

✅ 딕셔너리 그룹화

Dictionary.init(grouping: array) { 기준 (ex: $0.team) }

https://poisonf2.tistory.com/75

 

ex) [1, 2, 3, 3, 3, 4]를 위와 같이 묶으면?

-> [4: [4], 3: [3, 3, 3], 2: [2], 1: [1]]

-> 기준이 key로 오고, 해당 key 기준에 해당하는 모든 멤버들이 value로 오게됨

 

세트

https://devyul.tistory.com/entry/Swift-데이터-타입-고급-튜플-컬렉션-열거형

[Swift] 데이터 타입 고급 (튜플, 컬렉션, 열거형)

배열에서 중복을 제거하고 싶을 때, 중복 없는 자료형을 만들고 싶을 때, 순서나 key가 중요하지 않고 검색이 빠르게 중요하다면 Set를 사용하는 것이 용이하다. (시간복잡도가 O(1)임!)

 

기타

✅ print문 활용

print(_, separator: , terminator: )

separator: 출력할 때 어떤 구분자를 넣어서 출력할 것인지? (기본값 빈문자열), terminator: 출력할 때 어떤 형식으로 마칠것인지? (기본값 개행문자 \n)

 

✅ 고차함수 (map, filter, reduce, compactMap)

속도가 굉장히 느려서 많이 쓰는게 좋지는 않다. (쓰는것과 안쓰는것이 차이가 많이남)

for 문을 활용할 수 있다면 최대한 for 문을 활용하는 것이 좋으며 특히 반복문 안에서 사용하는 것은 지양

 

https://yagom.github.io/swift_basic/contents/22_higher_order_function/

https://velog.io/@un1945/Swift-%EA%B3%A0%EC%B0%A8%ED%95%A8%EC%88%98-Higher-order-Function

각각의 애플 공식문서 참고

 

1) map

주어진 클로저를 시퀀스 요소에 매핑한 결과를 포함하는 배열을 반환

ex)

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let lowercaseNames = cast.map { $0.lowercased() }
// 'lowercaseNames' == ["vivien", "marlon", "kim", "karl"]
let letterCounts = cast.map { $0.count }
// 'letterCounts' == [6, 6, 3, 4]

// numbers의 각 요소에 9 곱하기

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
let multiplyArray: [Int] = numbers.map { $0 * 9 }

print(multiplyArray)
// [9, 18, 27, 36, 45, 54, 63, 72, 81]

 

2) filter

주어진 조건자를 만족하는 시퀀스의 요소를 순서대로 포함하는 배열을 반환

ex)

let cast = ["Vivien", "Marlon", "Kim", "Karl"]
let shortNames = cast.filter { $0.count < 5 }
print(shortNames)
// Prints "["Kim", "Karl"]"

 

3) reduce

주어진 클로저를 사용하여 시퀀스의 요소를 결합한 결과를 반환합니다.

func reduce<Result>(
    _ initialResult: Result,
    _ nextPartialResult: (Result, Self.Element) throws -> Result
) rethrows -> Result

ex)

// 각 요소의 합 구하기

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let sum = numbers.reduce(0, +)

print(sum)
// 55

// 각 요소의 합 구하기

let numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
let sum = numbers.reduce(0) { $0 + $1 }

print(sum)
// 55

1부터 n까지 모두 곱함 -> (1...n).reduce(1, *)

//cipher 문자열의 요소를 하나씩 접근하여 하나의 문자열로 만드는 코드
cipher.enumerated().reduce("") { $0 + String($1.element) }

 

4) compactMap

컨테이너의 각 요소를 조건을 지정하여 호출할 때, nil 이 아닌 배열을 반환합니다.

조건에 의해 변환한 배열에서 nil값을 제거한 배열 (mapping한 결과에서 nil 값을 제거해준다고 생각하면 될듯?)

let possibleNumbers = ["1", "2", "three", "///4///", "5"]

let compactMapped = possibleNumbers.compactMap { str in Int(str) }
// [1, 2, 5]

 

5) flatMap

조건에 의해 변환한 배열 반환

 

💡 compactMap 과의 차이점

compactMap은 조건에 맞지 않는 값인 nil 값을 제거한 배열을 return해주지만, flatMap은 nil을 포함해서 반환함

compactMap은 2차원 배열을 변환했을 때 그대로 2차원 배열이지만, flatMap은 2차원 배열을 변환했을 때 1차원 배열로 바꿔줌 (flat하게 바꿔준다고 보면 될듯)

 

✅ 반복문 - for 문, while 문, repeat-while문

for문

for x in 1...10 {
	print(x)
}
//여기서 인자 x는 필요하지 않는 경우 생략할 수 있다.
//예를들어 10번을 반복해서 곱하고 싶을 경우 와일드카드 패턴을 활용하여 아래와 같이 작성할 수 있다.

for _ in 1...10 { // _ : 와일드카드 패턴
	result = result * 2
}

for i in (1...5).reversed() {
	print(i)
}
//역순 출력
/*
5
4
3
2
1
*/

 

while문

var x = 1

while x<=10 {
	print(x)
    x+=1
}

 

repeat-while 문 (프로그래밍 언어에서 do-while 문과 동일)

var x = 1

repeat {
	print(x)
    x+=1
} while x <= 10

 

✅ 일정 step을 건너뛰어서 반복하는 for 문 / 거꾸로 순회할 수 있는 for문 - stride

stride(from: to: by: ) //여기서 중요한 점은 to를 포함하지 않는다는 것이다. (to 전까지임) 

for i in stride(from:0, to:10, by:2){
	print(i) //0, 2, 4, 6, 8
}

for i in stride(from:2, to:0, by:-1){
	print(i) //2, 1
}

Array(stride(from:0, to:10, by:2) //[0, 2, 4, 6, 8]

 

✅ 소수점, 절댓값 관련 함수

 

https://blog.naver.com/PostView.nhn?isHttpsRedirect=true&blogId=daeqws4&logNo=221379226257&parentCategoryNo=&categoryNo=88&viewDate=&isShowPopularPosts=true&from=search

 

ceil(i) : i의 올림한 값

floor(i) : i의 내림한 값

round(i) : i의 반올림 값

trunc(i) : i의 소수점 부분을 버림한 값

abs(i) : i의 절댓값

 

✅ 제곱근, 제곱

 

제곱 : pow(_: Float, _: Float) -> Float -> 편하게 i*i*i 이런식으로 하는게 더 좋을듯.

제곱근 : sqrt(_: Double) -> Double

 

✅ 최대값, 최소값

 

최대값 : max(a, b) -> a, b중 큰 값 반환

최소값 : min(a,b) -> a, b중 작은 값 반환

 

*정수 모든 범위의 최대값 : Int.max (주로 특정 범위 중 최소값 찾을 때 유용)

정수 모든 범위 중 최소값 : Int.min (주로 특정 범위 중 최대값 찾을 때 유용)

 

✅ 2진수, 10진수, 16진수 변환

10진수 -> 2/8/16진수 : String(int, radix:2/8/16)

2진수 -> 10진수 : Int(String, radix: 2)!

 

-> 라이브러리 사용 안하고 변환하기 (10 -> 2, 8진수)

func radixChange(_ num: Int, _ radix: Int) -> String {
    if num == 0 {
        return "0"
    }
    var nums = [String]()
    var number = num
    while number != 0 {
        let digit = number % radix
        number /= radix
        nums.append(String(digit))
    }
    return nums.reversed().joined()
}

 

✅ 프로그램 중도에 종료

프로그램 실행 도중, 중단시키고싶을 때 exit(0) 을 쓴다.

유의할 점은 Foundation 반드시 Import!

 

✅ range ~= B : B가 range 안에 포함되어있는가? 에 대한 bool값 반환 (패턴 매칭 연산자)

~= : B가 앞 범위 안에 포함되어있는지에 대한 bool값을 반환해주는 연산자이다.

    if (0...S).contains(time) {

	} else if (E...Q).contains(time) {

	}
   // ----- 위 아래가 둘다 같은 표현임 -------
    if (0...S) ~= time {

    }
    
    else if e...q ~= time  {
    
    }

 

reference

https://tngusmiso.tistory.com/46

https://babbab2.tistory.com/113

https://poisonf2.tistory.com/75