코딩 테스트(swift) - 스위프트 문법 정리

swift 문법들을 정리한 문서입니다! 현재에도 계속 추가하고 있으며, 만약 현재 문서에는 없지만 유용한 문법들이 있다면 댓글로 적어주시면 감사드리겠습니다!!

 

 

 

기본 입력 받기

// return String
var input = readLine()!

// return Int
var input = Int(readLine()!)!

 

"1 2 3 4 5"와 같은 공백 있는 숫자 입력 받기

// split - return: [SubString] 
var nums = readLine()!.split(separator: " ").map {Int($0)!} 

// components - return: [String] -> import Foundation 필수
var nums = readLine()!.components(separatedBy: " ").map {Int($0)!}

// FileIO, 입력받으면서 리스트에 바로 추가하기
array.append((file.readInt(), file.readInt()))

 

SubString vs String

SubSequence는 SubString의 별명이다.

 

SubString은 다음과 같은 특징을 가지고 있다.

• split() 이나 prefix(), split() 등 과 같은 메서드를 사용해서 문자열에서 가져온 부분문자열 타입입니다.
• String에서 사용하는 대부분의 메서드를 가지고 있으며 String과 같은 방법으로 사용할 수 있습니다.
• 원래 문자열이나 다른 하위 문자열을 저장하는데 사용되는 메모리의 일부를 다시 사용합니다.

참고: https://appleceo.github.io/2019/06/20/substring/

 

split & component

split

split의 공식문서를 살펴보면 다음과 같이 3가지 파라미터들을 사용할 수 있다.

func split(
    separator: Self.Element,
    maxSplits: Int = Int.max,
    omittingEmptySubsequences: Bool = true
) -> [Self.SubSequence]

 1. separator

매개변수를 받아서 해당 인자를 기준으로 쪼개주는 역할을 한다.

let str = "hello world"
let splitStr = str.split(separator: " ")

 

2. maxSplits

Int 타입으로 문자열을 분리하는 횟수를 뜻한다. 앞의 separator인자를 기준으로 몇 번을 쪼개는가를 뜻한다.

 

let str = "have a nice day"
let splitStr = str.split(separator: " ", maxSplits: 2)

//출력 결과: ["have", "a" , "nice day"]

 

-> 이러한 split의 return타입은 "subString"이다.

 

 

components

func components(separatedBy separator: String) -> [String]

 components 메서드는 split과 다르게 매개변수가 하나밖에 없다. 이러한 components 메서드를 사용하기 위해서는 Foundation 라이브러리를 import해주어야만 한다.

import Foundation

let str = "have a nice day"
let componentsStr = str.components(separatedBy: " ")

//출력 결과 : ["have", "a", "nice", "day"]

  이러한 components는 split과 다르게 return타입이 "String"이다

 

 

 

 

 

 

 

"12345"와 같은 공백 없는 숫자를 배열로 입력 받기

// Int
var nums = Array(readLine()!).map {Int(String($0))!}

// String
var nums = Array(readLine()!).map {String($0)}

// FileIO
let nums = [file.readInt(), file.readInt()]

 

문자열을 char배열로 변환하기

var firstArr = first.map {$0}
print(firstArr)

//first가 "cat"이라면 firstArr에는 {"c","a","t"} 가 됨

 

 

문자열에 특정 문자 바꾸기

// import Foundation 필수
let str = "ung!chun!"
let str2 = str.replacingOccurrences(of: "!", with: "?")
print(str2) // ung?chun?

 

replacingOccurences & components 활용

//s = "{{2},{2,1},{2,1,3},{2,1,3,4}}" 일때 ["2", "2,1", "2,1,3", "2,1,3,4"]와 같이 바꾸기

s = s.replacingOccurrences(of: "{", with: "")    
let tupleStrings = s.components(separatedBy: "},").map({$0.replacingOccurrences(of: "}", with: "")})
    
print(tupleStrings)

 

 

개행없는 print

print("Hello", terminator:"")

 

반복문 시간복잡도 순서

for loop > reduce > forEach > map (for loop이 가장 빠르고 map이 가장 느림)

forEach

let nums: [Int] = [1, 2, 3, 4]

nums.forEach {
	print($0) // 1 2 3 4
}

 

배열 뒤에서부터 접근하기

for i in array.reversed() {
	print(i)
}
//reversed()를 사용하면 배열의 뒤에서부터 접근할 수 있다

 

절대값

// 11
abs(-11)

 

제곱

let value = 3.0 

// 9.0
pow(value, 2) 

 

자릿수 더하기

// n = 123, return = 6
String(n).map{ String($0)}.reduce(0){ $0 + Int($1)! }

 

* reduce에 대한 설명은 아래 고차함수 참고

 

배열 요소에 접근하기

var array = [1, 2, 3, 4, 5]

// [2, 3, 4]
array[1...3]    

 

Array, Set, Dictionary 설명 참조

* https://junstar92.tistory.com/259

 

배열에 요소 추가하기

var array = [1, 2, 3]

array.append(4) // [1, 2, 3, 4]
array.append(contentsOf: [5, 6, 7]) // [1, 2, 3, 4, 5, 6, 7]

 

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

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

 

 

1차원 배열 선언

let arr = [Int]() 

let arr = Array(repeating: 0, count: 5) 
let arr = [Int](repeating: 0, count: 5)

 

2차원 배열 선언

let arr = [[Int]]() 

let arr = Array(repeating: Array(repeating: 0, count: 3), count: 5) 
let arr = [[Int]](repeating: [Int](repeating: 0, count: 3), count: 5)

 

요소가 (Int, Int)인 배열 선언

var conferences = [(Int, Int)]()
// 코딩테스트 백준 1931 참고

 

 

map

var string = ["1","2","3","4"]

// [1,2,3,4] 각 원소를 전부 Int로 맵핑
string.map { Int($0)! } 

 

map & filter & reduce

※ 고차 함수란?

- 매개변수로 함수를 갖는 함수

- 맵, 필터, 리듀스 등이 있습니다.

- 이런 고차 함수들은 알고리즘을 공부할 때 readLine을 통해 입력받은 값을 정리하는 데 사용이 되기 때문에 확실히 알고 가는 게 좋을 거 같습니다.

 

1. map

자신을 호출할 때 매개변수로 전달된 함수를 실행하여 결과를 다시 반환하는 함수입니다.

- 배열, 딕셔너리, 세트, 옵셔널 등의 환경(?)에서 사용을 할 수 있습니다.

- 맵의 원리는 컨테이너가 담고 있던 각각의 값을 매개변수를 통해 받은 함수에 적용을 한 후 다시 컨테이너에 포장하여 반환을 합니다.
근데 여기서 중요한 것은 기존 컨테이너의 값은 변경이 되지 않고 새로운 컨테이너가 생성되어 반환이 됩니다.

 

※ 문법

- container.map( f(x) ) => return값을 새로운 컨테이너에 f(container의 각 요소)가 리턴됩니다.

- map 함수는 for_in 함수를 변형해서 사용할 수 있습니다. 그럼 둘의 차이는 무엇일까요?

코드의 재사 용면에서 용이하고 컴파일러 최적화에서 성능의 차이가 좀 있습니다. 또, 다중 스레드일 때 컨테이너의 값이 스레드에서 변경되는 시점에 다른 스레드에서도 동시에 값을 변경하려고 하면 똑같은 값을 둘 다 변경하려고 하는 부작용을 막을 수 있습니다.

 

- map의 예시를 봐보겠습니다.

* 코드 설명

•  doubleNumber는 number 배열 값을 * 2 씩 해줘서 리턴을 해줘 새로운 int형 배열의 doubleNumber 배열 변수에 넣는 것입니다.
• returnString은 각 number 배열 값을 " " 안에 넣어주어 String으로 변환하고 return 함으로써 returnString 배열 변수에 들어가게 됩니다.

 

- 다시 말해 map은 뒤에 컨테이너에 담고 있는 코드를 실행해 새로운 컨테이너로 생성해 값을 넣어준다고 생각을 하면 됩니다. 

 

- 위의 예시는 간결화를 하지 않은 코드입니다. map도 뒤의 클로저 함수들을 클로저처럼 간결화를 할 수 있습니다.

한번 간결화를 해보겠습니다.

* 코드 설명

• 클로저 안에 매개변수를 사용하지 않는다면 생략을 할 수 있습니다.
   대신 $0, $1... 을 사용하여 클로저의 인자 값을 참조할 수 있습니다.
• 반환 키워드인 return을 생략할 수 있습니다.
• 후행 클로저를 사용할 수 있습니다.

클로저를 map에 사용을 할 수도 있습니다.

 

아 이걸 어떻게 설명을 해야 하지.... 그냥 말로 하려고 하니깐 제가 써도 무슨 말인지 모르겠네요 ㅠㅠㅠㅠ

 

코드를 보고 한번 설명해보겠습니다.

* 코드 설명

•  인자 값을 * 2 해주는 multiple 클로저를 선언을 해줬습니다. 이 클로저를 map안에서 사용을 할 수 있습니다.
•  밖에서 클로저를 설정해주면 같은 기능을 여러 번 사용할 수도 있습니다.

 

- 배열뿐만 아니라 다른 딕셔너리 등 다른 데서 쓰이는 것도 한번 봐보겠습니다.

* 코드 설명

•  딕셔너리에서 사용을 하면 key값, value값 따로따로 구분해서 출력을 할 수도 있습니다.
•  세트에서 사용을 하면 다른 것과 같이 * 2 등 연산 작업을 할 수 있습니다.
•  range에 해당하는 값들을 map을 통해서 * 2 연산 작업을 할 수 있습니다.

 필터(filter) 란?

 

- 컨테이너 내부의 값을 걸러서 추출하는 역할을 합니다. 말 그대로 필터 하는 거예요 ㅎㅎ

- 앞에서 설명한 map같이 기존 값을 변경하는 게 아니라 특정한 조건에 맞춰 걸러진다고 생각을 하시면 됩니다.

- filter의 반환 타입은 Bool이므로 해당 값을 포함할 거면 true를 거를꺼면 false를 반환하면 됩니다.

 

간단한 어느 배열의 짝수 홀수를 filter을 통해 나누는 것을 보겠습니다.

* 코드 설명

• . filter을 통해서 해당 값이 참인 것만 새로운 컨테이너 배열에 추가되고 그렇지 않으면 새로운 컨테이너 배열에 추가되지 않는 것을 볼 수 있습니다.
• 형태는 map과 같습니다. return값을 보면 2를 나눈 나머지가 0이면 포함하므로 짝수이고 밑에 있는 것은 2로 나눈 나머지가 0아 아니므로 홀수가 되는 형식입니다.

놀랍게도 맵과 필터를 같이 사용을 할 수 있습니다. 놀. 랍. 죠.? 그럼 한번 예시를 봐보겠습니다.

 

* 코드 설명

• mapNumber는 numbers배열을 map 한 것으로 * 2를 해주고 반환한 값을 받습니다.
• evenNumber는 mapNumber배열을 filter 한 것으로 해당 배열을 % 2 == 0 을한 조건을 통해 짝수 값만 filter 해 반환한 값을 받습니다.

이렇게 map과 filter를 사용할 수 있지만 따로따로 구현을 해줘 보기에도 복잡하고 그럽니다.... 그래서 이렇게 따로따로 실행시켜주는 거보다 같이 체인처럼 연결하여 사용을 할 수가 있습니다.

* 코드 설명

• mixNumber는 map과 filter를 모두 한 번에 처리하는 배열입니다.
• 코드 실행 순서는 왼쪽에서 오른쪽으로부터 즉 map부터 실행이 됩니다.
• 훨씬 더 간결하고 보기 쉬운 것을 알 수 있습니다.

 리듀스(reduce) 란?

 

- 리듀스는 컨테이너 내부의 콘텐츠를 하나로 합하는 기능을 실행하는 고차 함수입니다.

- 만약 배열이 있다면 리듀스를 통해 배열의 모든 값을 전달 인자로 전달받은 클로저의 연산 결과로 합해줍니다.

 

- 리듀스는 총 2가지 형태가 있습니다.

※리듀스의 총 2가지 형태

• 첫 번째 형태
  - 클로저가 각 요소를 전달받아 연산한 후 값을 다음 클로저 실행을 위해 반환하며 컨테이너를 순환합니다. 모든 순회가 끝나면 리듀스의 최종 결과값이 처음 매개변수에 있는 값에 저장됩니다.
• 두 번째 형태
  - 컨테이너를 순환하며 클로저가 실행이 되지만 클로저가 따로 결괏값을 반환하지 않는 형태

 

우선 리듀스의 첫 번째 형태에 대해 살펴보겠습니다.

 

* 코드 설명

•  코드를 보면 reduce의 두번째 매개변수에서 result는 앞에 있는 첫번째 매개변수 ( 0 )이 되고 next는 그다음 배열 값이 됩니다.
•  이해가 안 되시면 밑에 result, next 값 출력되신 걸 보시면 이해하시길 편할 것 같습니다. result는 첫 번째 0 값 next는 그다음 값 1이 되고 이 두 개가 더해지는 게 다음 실행될 때 result가 되는 것을 볼 수 있습니다.
• 결과적으로 하나하나 더해져서 reduce의 첫 번째 매개변수에 쌓이고 최종적으로 마지막 두 개(result, next)의 합이 합쳐지는 게 return 하게 됩니다.
• 뺄셈도 마찬가지겠죠?

이제 이것은 길게 늘린 거니깐 위 코드를 축약해보겠습니다.

 

* 코드 설명

• 크게 값이 달라진 것이 없습니다. 축약을 했기 때문이죠 단지. reduce(0)에 초깃값을 설정해주고 클로저로 계속 값을 구해 해당 값을 업데이트해주는 것입니다.
• map, filter랑 비슷한 것 같으면서 뭔가 다르네요 ㅎㅎ

리듀스의 두 번째 형태를 봐보겠습니다. 

* 코드 설명

• 첫 번째 형태랑 제일 큰 차이점은 return을 하지 않는다는 것입니다. 반환하지 않고 내부에서 값을 계속 변경하고 있는 것을 보실 수 있습니다.
• 어떤 특성 때문에 return을 하지 않고 내부에서 값을 변경하는 것일까요?
   바로 inout이라는 입출력 매개변수 때문입니다. 이것을 이용하면 해당 함수 컨테이너 밖에서도 바뀐 값을 적용시킬 수 있습니다. 따라서  inout 한 result 매개변수가 내부에서 값을 계속 변경되면서 into 매개변수 값을 변경하기 때문입니다. 

※ inout 매개변수란?

- 함수에서 직접 파라미터로 접근을 할 수 있게 해주는 것으로 함수 밖의 변수의 주소 값으로 직접 접근을 하수 있게 해주는 기능입니다. 

- 만약 inout을 매개변수에 포함한 함수를 호출할 때는 &변수명을 넣어줘야 합니다.

( 그 이유는 변수의 주소를 보내줘야 하니깐 그렇습니다. )

 

 

지금까지 고차 함수에 대해 알아봤습니다. 우선 큰 개념은 매개변수 함수를 갖는 함수라고 생각하면 될 거 같습니다

 

var a = ["1","2","3","4"]
print(a.map{Int(($0))!})
//출력결과 : [1, 2, 3, 4]


var b = a.filter{$0 == "2"}
print(b)
//출력결과 : ["2"]


var c = a.reduce("", +)
print(c)
//출력결과 : 1234

 

filter

var array = [1,2,3,4]

// [2,4] 조건에 맞는 수만 뽑아냄
array.filter { $0 % 2 == 0 } 

---

reduce

var array = [1,2,3,4]

// 숫자 합이 나타남. 문자열 합치기도 가능
array.reduce(0, +) 

---

joined()

var brands = ["Dell", "HP", "Apple"]

// DellHPApple
var result1 = brands.joined()

// Dell HP Apple
var result2 = brands.joined(separator:" ")

// Dell, HP, Apple
var result3 = brands.joined(separator:", ")

---

flatMap(), compactMap()

let array1 = [1, nil, 3, nil, 5, 6, 7]
let flatMapTest1 = array1.flatMap{ $0 }
let compactMapTest1 = array1.compactMap { $0 }

// flatMapTest1 : [1, 3, 5, 6, 7]
// compactMapTest1 : [1, 3, 5, 6, 7]

• 1차원 배열에서는 둘 다 동일한 결과를 나타내지만 Swift 4.1 부터는 1차원 배열에서 nil을 제거하고 옵셔널 바인딩을 하고싶을때는 flatMap 말고 compactMap을 사용하라고 한다.

let array2: [[Int?]] = [[1, 2, 3], [nil, 5], [6, nil], [nil, nil]]
let flatMapTest2 = array2.flatMap { $0 }
let compactMapTest2 = array2.compactMap { $0 }

// flatMapTest2 : [Optional(1), Optional(2), Optional(3), nil, Optional(5), Optional(6), nil, nil, nil]
// compactMapTest2 : [[Optional(1), Optional(2), Optional(3)], [nil, Optional(5)], [Optional(6), nil], [nil, nil]]

• flatMapt과 compactMap은 nil을 제거하지않고 1차원 배열일때만 nil 제거
• flatMap은 2차원배열을 1차원배열로 flatten 하게 만들어주는 반면, compactMap은 1차원 배열로 만들지 않습니다. -> 2차원 배열을 1차원으로 만들때는 flatMap 사용

let array2: [[Int?]] = [[1, 2, 3], [nil, 5], [6, nil], [nil, nil]]
let flatMapTest2 = array2.flatMap { $0 }.compactMap{ $0 }

// flatMapTest2 : [1, 2, 3, 5, 6]

• flatMap 으로 flatten 하게 만들고 compactMap 으로 처리하면 편하게 2차원 배열을 옵셔널 바인딩 한 1차원 배열로 출력 가능

let array3 = [[[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]]

let flatMapTest3 = array3.flatMap { $0 }
// [[1], [2, 3], [4, 5, 6], [7, 8, 9, 10]]

let doubleflatMapTest3 = flatMapTest3.flatMap { $0 }
// [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

• 3차원 배열도 flatMap 2번 사용하면 flatten 하게 처리 가능

---

Set

• 정렬되지 않은 컬렉션
• 중복 허용 x
• 해시를 통해 값을 저장해서 배열에 비해 검색 속도가 빠르다. (저장되는 자료형은 Hashable 프로토콜 준수해야함)

// 생성
var tempSet: Set<Int> = []
var tempSet = Set<Int>()

var tempSet: Set<Int> = [1, 2, 5, 0]

let count: Int = tempSet.count            // Set 갯수 확인 : 4
let isEmpty: Bool = tempSet.isEmpty       // Set 비었는지 확인 : false

tempSet.contains(1)                    // true
tempSet.contains(10)                   // false

// insert : 값을 추가하고, 추가된 결과를 튜플로 리턴 (중복이면 false, 추가된 값)
tempSet.insert(1)                // (false, 1)
tempSet.insert(10)               // (true, 10)
 
// update : 값이 존재하지 않으면 추가 후 nil 리턴, 존재할 경우 덮어쓰기 후 덮어쓰기 전 값 리턴
tempSet.update(with: 1)          // Optioanl(1)
tempSet.update(with: 120)        // nil

// remove() : 한 가지 요소 삭제할 때 사용, 삭제 후 삭제한 값 return (없는 요소 삭제 시 nil 리턴)
tempSet.remove(1)              // Optional(1)
tempSet.remove(10)             // nil
 
// removeAll() : 전체 요소 삭제
tempSet.removeAll()  

---

dictionary

// 생성
var dict: [String: Int] = [:]  
var dict = [String: Int]()

// 갯수 확인
let count: Int = dict.count
let isEmpty: Bool = dict.isEmpty

var dict = ["height": 165, "age" : 100]

let height = dict["height"] // Optional(165)
let weight = dict["weight"] // nil

dict["weight"] = 100 // 해당 Key가 없다면, 추가 (insert)
dict["height"] = 200 // 해당 Key가 있다면, Value 덮어쓰기 (update)                                

dict["weight"] = nil // 해당 Key가 없어도 에러 안남
dict["height"] = nil // 해당 Key가 있다면, 해당 Key-Value 삭제
dict.removeAll() // 전체 삭제

dict.keys // "height, "age"
dict.keys.sorted() // "age", "height

dict.values // 165, 100
dict.values.sorted() // 100, 165

dict.sorted(by: {$0.value > $1.value})

dict.filter(condition) // 해당 클로저를 만족하는 요소만 모아서 새 딕셔너리로 리턴 

var v = [[Int]]()
var xDic = [Int: Int]()
xDic[v[i][0]]
let x = xDic.filter {$0.value < 2}.keys
ans.append(contentsOf: xDic.values.filter {$0 < 2})

 

nan check

- NaN은 "숫자가 아님" 이라는 뜻

- 필자는 dictionary value값에 값을 넣지 않았을 때에 NaN 값이 등장할 경우 해당 메서드를 사용해 dictionary를 수정해준 경험이 있다.

let d = 3.0
let isNan = d.isNaN // False

let d = Double.NaN
let isNan = d.isNaN // True

 

 

dictionary sort

1. Key를 기준으로 Dictionary 정렬하기

let dic: [Int: Int] = [1: 100, 2: 200, 3: 300]
let sortedDic = dic.sorted { $0.0 > $1.0 }

// $0, $1은 각 딕셔너리 원소를 의미
// .0은 그 원소의 첫 번째 친구, 즉 키값을 의미

2. Value를 기준으로 Dictionary 정렬하기

let dic: [Int: Int] = [1: 100, 2: 200, 3: 300]
let sortedDic = dic.sorted { $0.1 > $1.1 }

3. Value를 기준으로 정렬하는데, Value값이 같은 경우 Key값을 이용해 정렬하기

let dic: [Int: Int] = [1: 10, 2: 10, 3: 30, 4: 40]
let sortedDic = dic.sorted {
                                    if $0.1 == $1.1 {
                                         return $0.0 > $1.0
                                     }
                                     return $0.1 < $1.1 }

---

2차원 배열 정렬하기

var arr = [[0, 3], [1, 9], [2, 6]]
let sortedArray = arr.sorted(by: {$0[1] < $1[1] }) // 각 배열 두 번째 수 기준으로 오름차순
let sortedArray = arr.sorted(by: {$0.1 < $1.1 }) // 같은 결과
print(sortedArray) // [[0, 3], [2, 6], [1, 9]]

---

init (repeating: count: )

// 수박수박수박수박
let watermelon4 = String(repeating: "수박", count: 4)
print(watermelon4)

// [false, false, false, false, false]
let liar = Array(repeating: false, count: 5)
print(liar)

배열안에 담긴 숫자만큼 일일이 print하면 매번 print하는 것도 상당히 느리기때문에 시간초과 되는 경우가 많은데 String - init ( repeating: count: ) 로 한번에 만들어서 String에 저장해서 출력하면 시간초과를 막을 수 있다. -> 수 정렬하기 3 참고

var answer = ""
// \n 이용해서 한 줄에 하나씩 출력
answer += String(repeating: "\(value)\n", count: countValue)
// 공백 이용해서 한 줄에 띄어서 출력
answer += String(repeating: "\(value) ", count: countValue)
// 한 줄에 붙여서 출력
answer += String(repeating: "\(value)", count: countValue)
print(answer)

---

최대공약수, 최소공배수

// 최대공약수
func GCD(max: Int, min: Int) -> Int {
    let remain = max % min
    if remain == 0 {
        return min
    } else {
        return GCD(max: min, min: remain)
    }
}

// 최소공배수
func LCM(max: Int, min: Int) -> Int {
    return max * min / GCD(max: max, min: min)
}

---

9월 2일 추가

     *

    **

   ***

  ****

*****

-> 다음과 같은 문자열을 출력할 때 

let n = Int(readLine()!)!
for i in 1...n{
    print(String(repeating: " ", count: n-i) + String(repeating: "*", count: i))   
}

이런식으로 String(repeating: , count)를 사용할 수 있다.

Stride() 함수

흔히 사용하는 for문의 형식

for i in 0...5 {
	print(i)
}

// 0 1 2 3 4 5 가 출력되어진다.

-> i가 1씩 증가됨. 그렇다면 i의 값을 1씩 말고 원하는 만큼 증가시키는 방법은 무엇일까?

-> Stride() 사용.

 

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

//0 2 4 6 8 출력

from인 0부터 to인 10전까지 by에 해당하는 값인 2씩 i 값이 증가하게 된다.

to 대신 through를 사용하면 10까지 포함. (to는 10을 포함하지 않는다)

 

heap / 우선순위 큐

• MinHeap : 블로그

스위프트 | "(최소)힙 구현"하기 (Swift5 | Heap - MinHeap)

 

 

 

접두어, 접미어 확인

prefix(_:), suffix(_:)

맨 앞 또는 뒤에서 몇번째 글자까지 오는 접두어나 접미어를 확인할 수 있다. 반환형은 Substring이다.

let str = "aBcDeF"

// 접두어 (앞에서부터 몇 글자)
print(str.prefix(3)) // aBc
print(str.prefix(4)) // aBcD

// 접미어 (뒤에서부터 몇 글자)
print(str.suffix(1)) // F
print(str.suffix(2)) // eF

hasPrefix(_:), hasSuffix(_:)

접두어나 접미어가 주어진 문자열과 일치하는지 확인할 수 있다. 반환형은 Bool 이다.

let str = "aBcDeF"

// 접두어 (앞에서부터 몇 글자)
print(str.hasPrefix("a"))  // true
print(str.hasPrefix("aB")) // true
print(str.hasPrefix("ab")) // false

// 접미어 (뒤에서부터 몇 글자)
print(str.hasSuffix("F"))  // true
print(str.hasSuffix("DeF")) // true
print(str.hasSuffix("FeD")) // false

 

 

2진수 관련 함수

nonzeroBitCount

Int형 변수를 2진수로 바꾸고 0이 아닌 수의 개수를 리턴해준다.

var num = 9
print(num.nonzeroBitCount) //2 출력

 

 

문자열 접근

배열에서 썼던 first, last는 문자열에서도 다음과 같이 사용이 가능하다.

var a = "hello"
print(a.first) //h 출력
print(a.last)  //o 출력