[Swift]Swift 요약 정리 /초보자를 위한 코테 / 코딩테스트 / 요약 / 총 정리 / 기초 정리 / 코테 입문

알고리즘 코딩 테스트를 위한 Swift 요약 정리 

---

입력(Input)

Line 단위로 읽어오기.

let value = readLine()

Line단위로 읽어오는데, 공백(Space)으로 구분되어 있는 입력
ex) Input = 1 2 3 4  

let nums = readLine()!.split(seperator:" ")  // String.SubSequence Type [map]으로 커버 가능
let nums = readLine()!.components(seperatedBy:" ") // String Type [import Foundation] 필수.

var arr = [Int]()
var arr : [Int] = []
var arr : Array<Int> = []
 
var arr2 = [[Int]]()

var arr = Array(1...5) // [1,2,3,4,5]
var arr = Array(repeating: 1, count: 5) // [1,1,1,1,1)
 
let arr2: [[Int]] = Array(repeating:Array(repeating:1, count: 5), count: 3) 
// 안쪽 count가 행, 바깥 count가 열
arr2[i][j]

var arr = [1,3,2,4]
 
arr.sort()        // 오름차순 [1,2,3,4]
arr.sort(by: >) // 내림차순 [4,3,2,1]
//sort() - 원본 순서변경으로 배열정렬
//sorted() - 원본 변경없이 정렬한 배열을 반환.

var array3D: [[[Int]]] = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
// array3D[0] 은 [[1, 2], [3, 4]] 를 참조하고 array3D[0][1] 은 [3, 4] 그리고 array3D[0][1][1] 은 값 4를 참조

---

배열 명령어 정리

var arr = [1,2,3,4,5]
 
arr = [] //[]
// arr is now an empty array, but is still of type [Int]
 
arr = [1,2,3,4,5] // [1,2,3,4,5]
 
arr.append(6) // [1,2,3,4,5,6]
// arr now contains 1 value of type Int
 
// 인덱스로 원소 확인
arr[2] // 3
 
// 원소로 인덱스 확인 (옵셔널, 값이 없으면 오류)
arr.firstIndex(of: 3)! // 2
 
// 인덱스로 원소 지우기
arr.remove(at: 2) // [1,2,4,5,6]
 
// 맨 뒤 원소를 지우고 return (옵셔널이 아님, 배열이 비어있으면 에러)
arr.removeLast() // [1,2,4,5]
 
// 특정 인덱스에 원소 넣기
arr.insert(3, at: 2) // [1,2,3,4,5]
 
// 특정 원소 있는지 체크 bool type
arr.contains(3) // true
 
// 순서 반전
arr.reverse() // [5,4,3,2,1]
 
// 첫 원소를 지우고 return (옵셔널이 아님, 배열이 비어있으면 에러)
arr.removeFirst() // [4,3,2,1]
 
// 첫 원소 return (옵셔널, 값이 없으면 오류)
arr.first! // 4
 
// 마지막 원소 지우고 return (옵셔널, 배열이 비어있으면 return nil)
arr.popLast()!
 
// 마지막 원소 return (옵셔널)
arr.last!
 
// 원소의 최대값, 최소값 (옵셔널)
var min = arr.min()! // 1
var max = arr.max()! // 5
 
// 모든 원소 지우기
arr.removeAll()
 
// 조건을 만족하는 모든 원소 지우기 
arr.removeAll(where: {$0 % 2 == 0}) 
//arr.removeAll{$0 % 2 == 0} // 위 코드 함축
 
// 원소 스왑
arr.swapAt(_:, _:)

맵핑(map)

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

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

증감(reduce)

var array = [1,2,3,4]array.reduce("", +)// 문자열 합
array.reduce(0, +) // 숫자 합

배열 인덱스(index), 값(value) 순회 참조

var arr = [1,2,3]
for n in arr {
    print(n)
}
 
for (index, value) in arr.enumerated() {
    print("\(index), \(value)")
}
 
for i in 0..<arr.count {
    print(arr[i])
}
 
for i in arr.indices {
    print(arr[i])
}

배열 뒤집기(reverse) 순회 참조

var arr = [1,2,3]
arr.reverse()
 
// 순회 참조 가능
for n in arr{
    print(n)
}
 
print(arr[0])

let str = ["str", "ing", "!"]
var string = str.joined() // "string!"
string = str.joined(separator: " ") // str ing !
string = str.joined(separator: ", ") // str, ing, !
string = str.joined(separator: "a") // strainga!
 

var str = "string"
str = str.capitalized  // 첫번째만 대문자로 변경 "Abcdef" import Foundation 필수
str = str.uppercased() // 전체 대문자로 변경 "ABCDEF"
str = str.lowercased() // 전체 소문자로 변경 "abcdef

import Foundation
var str = "asap"
var str2 = str.replacingOccurrences(of: "a", with: "b")
print(str)  // 원본에 영향 없음
print(str2) // bbcdef

import Foundation
var str = "string"
str.contains("g")  // true
str.contains("st") // true
str.contains("ring") // true
str.contains("sti") // false
 

import Foundation
 
// 문자열 원소 접근
var str = "as soon as posible"
//str[0] // 직접 접근 불가능, String 인덱스로 접근가능
str[str.startIndex] // "a" 시작 원소
let secondIndex = str.index(after: str.startIndex) // 2번째 원소
let second = str[secondIndex]
let endIndex = str.index(before: str.endIndex) // 마지막 원소
 
// n번째 문자 가져오기 n == 3
var index = str.index(str.startIndex, offsetBy: 3 - 1)
str[index] // "c"
 
// 일정 범위의 문자열만 가져오기
let sub = str[str.startIndex...index] // "abc"
 
// 특정 character replace
str.replacingOccurrences(of:" ", with:"+") // import Foundation 필수
 
// 특정 원소 값으로 인덱스 찾기 (옵셔널 값) 해당하는 원소값이 없으면 에러
str.firstIndex(of: "n")!
 
// subString 구하는 법 특정 원소 첫 return 까지
let substring = str[str.startIndex...str.firstIndex(of: "n")!]

작은 따옴표 (') 큰따옴표 (")

print("작은 따옴표는 \' 큰 따옴표는 \" ")

let n: Int8 = 0x0f  // 0b00001111
let k: Int8 = 60    // 0b00111100
 
n.nonzeroBitCount   // 4
k.nonzeroBitCount   // 4
 
~n      // 0b11110000 == -16
~k      // 0b11000011 == -61
n & k   // 0b00001100 == 12
n | k   // 0b00111111 == 63
n ^ k   // 0b00110011 == 51
n << 1  // 0b00011110 == 30
k >> 1  // 0b00011110 == 30
n > k ? print(0) : print(1) // 1

앱 종료

exit(0)

무한 루프

while true {
                 ...
}

repeat {
     ....
} while

수학(Math) 기본

거듭 제곱

import Foundation
pow(2.0, 3.0) // 2.0^3.0 (double type)
pow(2,3) // 2^3 (decimal type)

제곱근

sqrt(4.0) // double type
sqrt(16)  // double type

Decimal Type -> Int Type

import Foundation
type(of: pow(2.0, 3.0)) // 2.0^3.0 (double type)
type(of: pow(2,3)) // 2^3 (decimal type)
type(of: (pow(2,3) as NSDecimalNumber).intValue) // Int.Type

Int, Int64 = 2^8 - 1 (9223372036854775807) // 19자리
Int32      = 2^6 - 1  (2147483647)         // 10자리
Float      = 소수점 6자리까지 표현 가능
Double     = 소수점 15자리까지 표현 가능

진수, 진법 변경

// 10진수 -> 16(N)진법
String(30, radix: 16)
// 2(N)진법 -> 10진수
Int("11100110", radix: 2)!

abs(-55) // 55

For문에서 원하는 수치만큼 증감이 필요한 경우
to / through 사용

import Foundation
 
stride(from:1, to:5, by:2)      // open range..5 불포함 1,3 까지만
stride(from:1, through:5, by:2)  // closed range..5 포함 1,3,5까지
 
for even in stride(from:2, to:100, by:2){
    print(even)
}
 
for odd in stride (from: 99, through: 1, by: -2){
    print(odd)
}

딕셔너리(Dictionary)

var dic: [Int:String] = [:]
var dic = [Int:String]()
var dic = [1:"a", 2:"b", 3:"c"]
 
var aDic: [String: Int] = ["Alex": 31, "Paul": 39]
var aDic: Dictionary<String, Int> = ["Alex": 31, "Paul": 39] // 같은 표현
 
dic.updateValue("d", forKey: 4) // key가 없으면 nil
dic[4] = "e"                    // key가 없으면 추가
print(dic)
 
aDic["Paul"] = 50     // 값. 변경
aDic["Chan"] = 20     // 값 추가
 
for (key, value) in dic {
      print(key)            // 1,2,3
      print(value)          // a,b,c
} // Dictionary는 순서가 없음
 
dic.removeValue(forKey: 4) // 해당 키값 삭제
dic.removeAll() // 모든 키값 삭제
// Key를 바꿔야하는 경우 삭제 후 추가 해줘야 한다.
 
var sort = dic.sorted(by: { $0.key < $1.key })
var sort = dic.sorted(by: { $0.value < $1.value })

---

처음 발행 날짜 20210902
마지막 업데이트 날짜 20210916