알고리즘 문제를 풀 때 자주 사용하는 문법

1. Collection Type
2. String
3. Sort
4. Type
5. Casting
6. Iterator
7. Graph
8. Advanced Operator
9. Pow, Sqrt, Radix
10. Regex

Collection Type

• 기본

  /* 선언 */
  vardict=[String: Int]()
  /* 할당 */
  dict["A"]=0
  /* 키에 대한 기본값을 0으로 주고 특정 문자열이 나올 때마다 +1 */
  forstrin["a","b","c"]{dict[str, default:0]+=1}print(dict) // ["a": 1, "b": 1, "c": 1]
  /* 꺼내기 */
  letvalue=dict["A"]??0 // key가 없는 경우, nil을 리턴하기 때문에 ??으로 처리.
  /* 특정 value 기준 key 꺼내기 */
  letdict=[1:2,2:2,3:4]varanswer=[Int]()for(k, v)in dict {if v ==2{ answer.append(k)}}print(answer) // [1, 2]

• 응용

  /* 선언된 키에 번호 매기기 */
  letfruit=["apple","banana","melon"]letdict=Dictionary(uniqueKeysWithValues:zip(fruit,0..<3))
  // ["apple": 0, "banana": 1, "melon": 2]
  /* 번호 키에 모든 값 0으로 할당 */
  letdict=Dictionary(uniqueKeysWithValues:zip(0..<3,Array(repeating:0, count:3)))
  // [0: 0, 1: 1, 2: 2]
  /* 키에 값을 array로 그룹핑 */
  letdict=Dictionary(grouping: fruit){ $0 }
  // ["apple": ["apple"], "banana": ["banana"], "melon": ["melon"]]

String

• Hour to Second

  import Foundation
  func hToSecond(_ h:String)->Int{letsplit= h.components(separatedBy:":")leth=(Int(split[0])??0)*60*60letm=(Int(split[1])??0)*60lets=(Int(split[2])??0)return h + m + s
  }print(hToSecond("1:01:06")) // 3666

• String -> String Array

  letname="Seungmin"letnameArray= name.map{String($0)} // 각 요소를 String으로 형변환하지 않으면 Character 타입이 됨
  print(nameArray) // ["S","e","u","n","g","m","i","n"]

• String Array -> String

  letnameArray=["S","e","u","n","g","m","i","n"]letname= nameArray.joined()print(name) // Seungmin
  또는
  letname= nameArray.reduce("",+)print(name) // Seungmin

• String Array -> String 띄어쓰기 적용

  letarray=["a","b","c"]print(array.joined(separator:"")) // a b c

• 문자열을 다른 문자열로 바꾸기

  import Foundation
  varfruit="bananaApple"
  fruit = fruit.replacingOccurrences(of:"banana", with:"pine")print(fruit) // pineApple

• 모든 문자열이 특정 문자열인지 확인하기

  varallA="AAAAAA"if allA.allSatisfy({ $0 =="A"}){print("All A!") // All A!
  }

• String Array -> Two Dimensional String Array

  letstringArray=["010","0001","0101"]vararray= stringArray.map{ $0.map{String($0)}}print(array) // [["0","1","0"], ["0","0","0","1"], ["0","1","0","1"]]

• Two Dimensional String Array -> String

  letarray=[["0","1","0"],["0","0","0","1"],["0","1","0","1"]]print(array.map{ $0.joined()}.joined()) // 01000010101

• 문자열 반복

  letstr="Hi!"letstrs=String(repeating: str, count:5)print(strs) // Hi!Hi!Hi!Hi!Hi!

• 문자열이 알파벳인지 판별하는 변수 isAlpha 구현

  extensionString{varisAlpha:Bool{self.rangeOfCharacter(from:CharacterSet.letters.inverted)==nil}
  또는
  varisAlpha:Bool{guardlet value =Character(self).asciiValue else{returnfalse}if(value >=65 && value <=90) || (value >=97 && value <=122){returntrue}else{returnfalse}}}letletter="%"print(letter.isAlpha) // false

• 첫 번째 문자열을 대문자로 변경하는 변수 firstCharUppercase 구현

  extensionStringProtocol{varfirstCharUppercase:String{guardlet first = first else{return""}returnString(first).uppercased()+ dropFirst()}}letword="hello!"print(word.firstCharUppercase) // Hello!

• 문자열 indexing, start(with:), hasPrefix() 추가 예정

Sort

• 1차원 배열

  vararray:[Int]=[5,3,1,4]
  /* 오름차순 */
  array.sort()
  array.sort(by:<)
  array.sort{ $0 < $1 }

• 2차원 배열

  vararray:[[Int]]=[[5,1],[2,4],[3,5],[3,2]]
  /* 배열의 두 번째 인덱스 값을 기준으로 내림차순 정렬 */
  array.sort{$0[1]>$1[1]}
  /* 배열의 첫 번째 인덱스 값 오름차순 정렬 후, 같은 값은 두 번째 인덱스 값 내림차순 정렬 */
  array.sort{($0[0],$1[1])<($1[0],$0[1])}

Type

• Typealias

  // typealias로 모델을 생성하면 객체를 생성할 때, 파라미터 이름을 쓰지 않아도 됨.
  // 그러나 .0 .1로 접근해야하기 때문에 가독성이 떨어짐.
  typealiasPoint=(Int,Int)letpoint=Point(0,0)print(point.0, point.1) // 0, 0

• Struct

  // init에 argument label을 '_'로 줘서 typealias처럼 사용할 수 있음
  // 그러나 구현 시간이 typealias보다 오래 걸림
  structPoint{leti:Intletj:Intinit(_ i:Int, _ j:Int){self.i = i
  self.j = j
  }}letpoint=Point(0,0)print(point.i, point.j) // 0 0

Casting

• Character -> Int

  letstr="a"letintValue=Character(str).asciiValue!

• Character -> Int

  letn=65letstringValue=Character(UnicodeScalar(n)!)

Iterator

• 문자열 합쳐서 출력

  letstringArray:[[String]]=[["a","b","c"],["d","e","f"]]forstringin stringArray {print(string.joined())}
  // abc
  // def

• 두 시퀀스 반복 - zip 활용

  letfirstSequence=[1,2,3]letSecondSequence=[4,5,6]varresult=0forvinzip(firstSequence, SecondSequence){let(first, second)= v
  result += first * second
  }print(result) // 32

• 시퀀스의 특정 인덱스의 값만 추출

  // names 문자열 시퀀스에서 앞에서부터 5의 배수 번 째의 이름을 추출하고 싶을 때
  letnames=["nami","ahri","jayce","garen","ivern","vex","jinx"]print(stride(from:0, to: names.count, by:5).map{names[$0]}) // ["nami", "vex"]

Graph

• 두 노드의 연결을 띄어쓰기로 주어졌을 때

  /* 양방향 기준 */
  letn=Int(readLine()!)!
  varg=Array(repeating:[Int](), count: n +1)for_in0..<n! {letadj=readLine()!.split(separator:"").map{Int($0)!}g[adj[0]].append(adj[1])g[adj[1]].append(adj[0])}

Advanced Operator

• NOT Operator(~)

  letvalue=~0b00001111 // 11110000, -16

• AND Operator(&)

  letvalue=0b00001100&00000111 // 00000100, 4

• OR Operator(|)

  letvalue=0b00001100 | 00000111 // 00001111, 15

• XOR Operator(^)

  letvalue=0b00001111 ^ 0b00001101 // 00000010, 2

Pow, Sqrt, Radix

• pow

  import Foundation // Foundataion을 꼭 import 해야함
  // 연산하는 타입은 모두 Double이라는 걸 명심!
  letvalue:double=100.0print(pow(value,2.0)) // 10000.0

• sqrt

  letvalue:double=100.0print(sqrt(value,2.0)) // 10.0

• 10진수 -> 3진수

  vara=45print(String(a, radix:3)) // 1200

• 3진수 -> 10진수

  vara="1200"print(Int(a, radix:3)??0) // 45

• 2진수에서의 1의 개수

  letn=11 // 1011
  print(n.nonzeroBitCount) // 3

Regex

• 문자열에서 특정 문자열 삭제

  varstring="nice to meet you".replacingOccurrences(of:"[aeiou]", with:"", options:.regularExpression) // 모음 제거
  print(string) // nc t mt y