[swift] Array

배열의 길이

let nums = [1,2,3]
print(nums.count)
//3


//비어있는지 확인
print(nums.isEmpty)
//false

배열 요소 접근

//subscript 문법 사용
let fruits = ["Apple", "Banana","Melon"]
print(fruits[0])  //배열 비어있을 때 인덱스로 접근하면 에러 발생
//Apple


// 범위
let fruits = ["Apple", "Banana","Melon"]
print(fruits[0...1])
//["Apple", "Banana"]


let fruits = ["Apple", "Banana","Melon"]
//정수 인덱스 대신 속성으로 제공하는 인덱스 사용하면 더 안전한 코드
print(fruits[fruits.startIndex])
//Apple
print(fruits[fruits.index(before: fruits.endIndex)])
//Melon

//옵셔널이라서 배열 비어있으면 nil리턴, 더 안전하다
let fruits = ["Apple", "Banana","Melon"]
print(fruits.first)
//Optional("Apple")
print(fruits.last)
//Optional("Melon")


//강제 언래핑
let fruits = ["Apple", "Banana","Melon"]
print(fruits.first!)
//Apple
print(fruits.last!)
//Melon


let list = ["A","B","C","D","E"]
print(list[2...])
//["C", "D", "E"]


let list = ["A","B","C","D","E"]

print(list.prefix(3)) //배열 시작부분부터 전달한 개수만큼 새로운 배열 리턴
//["A", "B", "C"]
print(list.prefix(30)) //인덱스가 아니라 최대 개수라서 문제없이 실행된다.
//["A", "B", "C", "D", "E"]
print(list.prefix(upTo:3)) //인덱스 전달(전달한거 미포함)
//["A", "B", "C"]
print(list.prefix(through: 3)) //인덱스 전달(전달한거 포함)
//["A", "B", "C", "D"]

//조건을 지정하고 싶을 때, 요소가 C와 같지 않을 때까지 추출
let r = list.prefix { $0 != "C"}
print(r)
//["A", "B"]


//뒤에서 추출
print(list.suffix(3)) //뒤에서부터 3개를 리턴
//["C", "D", "E"]
print(list.suffix(from: 3)) //3번 인덱스부터 마지막까지 추출
//["D", "E"]

repeating을 이용한 배열 초기화

let zero = [(String(repeating: "0", count: 3))]
print(zero)
//["000"]

let zero2 = (Array(repeating: "0", count: 3))
print(zero2)
//["0", "0", "0"]

let zero3 = [(Array(repeating: "0", count: 3))]
print(zero3)
//[["0", "0", "0"]]

 

배열에 요소 추가

var alphabet = ["A","B","C"]

alphabet.append("E")
print(alphabet)
//["A", "B", "C", "E"]

//여러개 동시 추가
alphabet.append(contentsOf: ["F","G"])
print(alphabet)
//["A", "B", "C", "E", "F", "G"]

//중간에 추가 오버헤드가 있다.
alphabet.insert("D", at: 3)
print(alphabet)
//["A", "B", "C", "D", "E", "F", "G"]


//배열 시작 부근에 추가
alphabet.insert(contentsOf: ["a","b","c"], at: 0)
print(alphabet)
//["a", "b", "c", "A", "B", "C", "D", "E", "F", "G"]

//요소 바꾸기
//subscript
alphabet[0...2] = ["x","y","z"]
print(alphabet)
//["x", "y", "z", "A", "B", "C", "D", "E", "F", "G"]

//메소드로 요소 바꾸기
alphabet.replaceSubrange(0...2, with: ["x"])
print(alphabet)
//["x", "A", "B", "C", "D", "E", "F", "G"]

//삭제
alphabet[0..<1] = []
print(alphabet)
//["A", "B", "C", "D", "E", "F", "G"]

배열 요소 삭제

var alphabet = ["A","B","C","D","E","F","G"]
let rm = alphabet.remove(at: 2) // 범위 넘어선 것을 지정하면 인덱스 초과 에러
print(rm)
//C
print(alphabet)
//["A", "B", "D", "E", "F", "G"]

let first = alphabet.removeFirst() //맨 앞 값 지우고 지운 값 반환, 빈 배열일 때 하면 에러
print(first)
//A
print(alphabet)
//["B", "D", "E", "F", "G"]

alphabet.removeFirst(2) // removeFirst()처럼 지운 값 반환하지 않음
print(alphabet)
//["E", "F", "G"]

alphabet.removeAll()
print(alphabet)
//[]

print(alphabet.popLast()) //옵셔널
//빈 배열이라면 nil

alphabet = ["A","B","C","D","E","F","G"]
let last = alphabet.removeLast() // 빈 배열이라면 에러 발생, 마지막 요소 지우고 지운거 반환
print(last)
//G
print(alphabet)
//["A", "B", "C", "D", "E", "F"]

alphabet.removeSubrange(0...2)
print(alphabet)
//["D", "E", "F"]

alphabet[0...2]=[]
print(alphabet)
//[]



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

//drop은 원본 값을 수정하지 않음, 원본을 복사해서 새로운 배열을 만들고 거기에서 삭제한 후 남은 배열 리턴
let d1 = alphabet.dropFirst()
print(d1)
//["B", "C", "D", "E", "F", "G"]
let d2 = alphabet.dropFirst(3)
print(d2)
//["D", "E", "F", "G"]
print(alphabet)
//["A", "B", "C", "D", "E", "F", "G"]

let r = alphabet.drop{ $0 != "C" } //클로저에서 리턴하는 값이 트루일 때 계속 drop
print(r)
//["C", "D", "E", "F", "G"]
print(alphabet)
//["A", "B", "C", "D", "E", "F", "G"]

배열 비교

let a = ["A","B","C"]
let b = ["a","b","c"]

print(a == b) //false
print(a != b) //true

//메소드로 비교
print(a.elementsEqual(b)) //false

배열 검색

let randomNumbers = [1,2,3,1,4,5,2,6,7,5,0]
print(randomNumbers.min()) //옵셔널임
//Optional(0)

let a = ["a","b","c"]
print(a.min()!) //아스키 코드가 가장 작은 거 리턴
//a

// 크기를 어떻게 판단할지 직접 구현 가능
//randomNumbers.min(by: <#T##(Int, Int) throws -> Bool#>)

//가장 큰 값
print(randomNumbers.max()!)
//7

//배열에 값 있는지 확인
print(randomNumbers.contains(1))
//true

//배열에 값 있는지 확인 - 클로저 - 값이 짝수일 때 true 리턴
print(randomNumbers.contains{ $0.isMultiple(of: 2)})
//true

//없으면 nil, 가장 먼저 검색된 짝수 2
print(randomNumbers.first{ $0.isMultiple(of: 2)})
//Optional(2)

//없으면 nil, 가장 먼저 검색된 짝수 2의 인덱스
print(randomNumbers.firstIndex{ $0.isMultiple(of: 2)})
//Optional(1) (인덱스)

//없으면 nil,첫번째로 검색된 값의 인덱스 리턴
print(randomNumbers.firstIndex(of: 7))
//Optional(8)

//앞에서부터
print(randomNumbers.firstIndex(of: 5))
//Optional(5)

//뒤에서 부터
print(randomNumbers.lastIndex(of: 5))
//Optional(9)

배열 정렬하기

let randomNumbers = [1,2,3,1,4,5,2,6,7,5,0]
var sorted_randomNumbers:[Int]
//오름차순 정렬
sorted_randomNumbers=randomNumbers.sorted() 

print(randomNumbers)
//[1, 2, 3, 1, 4, 5, 2, 6, 7, 5, 0]
print(sorted_randomNumbers)
//[0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7]

//내림차순 정렬
sorted_randomNumbers=randomNumbers.sorted {$0>$1}
print(sorted_randomNumbers)
//[7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 0]

• 원본 배열은 바뀌지 않는다.
• sorted는 새로운 복사본을 만들어서 정렬한 다음에 리턴한다.

 

let randomNumbers = [1,2,3,1,4,5,2,6,7,5,0]
//원본을 변경하려면 var로 선언되어 있어야 함
var mutableNums = randomNumbers
//오름차순 정렬
mutableNums.sort()
print(mutableNums)
//[0, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7]

//원본 뒤집기
mutableNums.reverse()
print(mutableNums)
//[7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 0]

//전달한 인덱스에 있는 요소들을 서로 바꿔줌
mutableNums.swapAt(0, 1)
print(mutableNums)
//[6, 7, 5, 5, 4, 3, 2, 2, 1, 1, 0]


//실행할 때 마다 매번 순서가 달라진다
mutableNums.shuffle()
print(mutableNums)
//[5, 6, 2, 4, 5, 2, 7, 1, 3, 0, 1]

• 원본 배열이 바뀐다.
• sort는 원본을 정렬한다.

정렬 조건이 두 개일 때

// 2차원 배열 예시
var array = [
    [1, 2, 3],
    [4, 5],
    [6, 7, 8, 9],
    [10, 11],
    [12, 13, 14]
]

// 배열을 정렬하는 함수
func sort2DArray(_ arr: inout [[Int]]) {
    arr.sort {
        // 첫 번째 기준: 배열의 길이를 내림차순으로 정렬
        if $0.count != $1.count {
            return $0.count > $1.count
        }
        // 두 번째 기준: 배열의 길이가 같다면 배열 내의 가장 큰 값을 기준으로 내림차순 정렬
        let max0 = $0.max() ?? 0
        let max1 = $1.max() ?? 0
        return max0 > max1
    }
}