느낀점
이분탐색을 공부한 후 정렬 문제를 풀어보니
배열을 미리 정렬하는 과정을 통해
문제에 주어진 조건을 고려하지 않아도 되는 상황을 만들게 되는 것 같다

K번째수

배열 쪼개기 array[1...2]
마지막 인덱스 endIndex, 첫번째 인덱스 startIndex (1부터 시작한다)

import Foundation

func solution(_ array:[Int], _ commands:[[Int]]) -> [Int] {
    return commands.map({(key) in
        return array[(key[0]-1)...(key[1]-1)].sorted()[key[2]-1]
    })
}

import Foundation

func solution(_ array:[Int], _ commands:[[Int]]) -> [Int] {
    let testCase: Int = commands.count
    var mutableArray:[Int] = array
    var answer: [Int] = []

    for i in 0 ... testCase-1 {
        let first = commands[i][0]
        let second = commands[i][1]
        let index = commands[i][2]
        let newArray = mutableArray[first-1...second-1].sorted()
        let answerValue = newArray[index-1]
        answer.append(answerValue)
    }

    return answer
}

---

가장 큰 수

https://caution-dev.tistory.com/4
https://tngusmiso.tistory.com/25

// +로 문자열 결합해보기
print("a"+"b")      //ab
let a = 123
print("\(123)"+"b") //123b

// 스트링으로 변환해서 610, 106을 생성한 후 내림차순으로 정렬하기
let sorted = numbers.sorted {"\($0)\($1)" > "\($1)\($0)"}   //[6, 2, 10]

// 첫번째가 0인 경우는 [0, 0] 뭐 이런 경우이고, "00"이 아니라 "0"을 리턴해야한다
if sorted[0] == 0 {
    return "0"
}

return sorted.reduce("") { $0 + "\($1)" }   // 스트링으로 출력하기
//let b = sorted.map{String($0)}.joined() //상동

---

H-Index

큰수가 기준이라면 내림차순으로 먼저 정렬할 수 있는데 그걸 생각 못한 것 같다

https://kocensd.github.io/프로그래머스-H-Index(Swift)/
https://mungto.tistory.com/27

func solution(_ citations:[Int]) -> Int {
    let n = citations.count //n편
    
    let sortedCitations = citations.sorted(by: >)
    
    for (i, element) in sortedCitations.enumerated() {
        if i >= element {
            return i
        }
    }
    
    // 인용횟수가 논문개수보다 많은 경우 [10, 50, 100]
    return citations.count
}

함수형 프로그래밍

https://velog.io/@msi753/함수형-프로그래밍-스위프트
https://velog.io/@msi753/함수형-프로그래밍-2-스위프트
https://velog.io/@msi753/함수형-프로그래밍-3-맵-필터-리듀스-스위프트
https://velog.io/@msi753/함수형-프로그래밍-4-모나드-스위프트

와 문법만 공부하면 진짜 기억이 하나도 안나는 구나...😅
그렇다고 안할수도 없고...😂

코딩테스트에서 쓸만한 걸 정리해보자

클로저의 축약

문맥을 이용한 타입 유추

let reversed: [String] = names.sorted() { (first, second) in
    return first > second
}

단축 인자 이름

let reversed: [String] = names.sorted() {
    return $0 > $1
}

💥 암시적 반환 표현 (한 줄 일 때)

let reversed: [String] = names.sorted() { $0 > $1 }

연산자 함수(>)

>가 함수 이름

public func > <T: Comparable>(lhs: T, rhs: T) -> Bool
let reversed: [String] = names.sorted(by: >)

맵

//후행 클로저 사용
doubledNumbers = numbers.map { $0 * 2 }

let evenNumber: [Int] = [0, 2, 4, 6, 8]
let oddNumber: [Int] = [1, 3, 5, 7, 9]
let multiplyTwo: (Int) -> Int = { $0 * 2}

let doubledEvenNumber = evenNumber.map(multiplyTwo)
let doubledOddNumber = oddNumber.map(multiplyTwo)

리듀스

결합Combine
초깃값이 주어진다.

let numbers: [Int] = [1, 2, 3, 4, 5, 6, 7]

var result: Int = numbers.filter { $0.isMultiple(of: 2) }.map{ $0 * 3 }.reduce(0) { $0 + $1 }
print(result)   //36

var array = [1,2,3,4]
array.reduce(0, +) // 숫자 합이 나타남. 문자열 합치기도 가능

map, joined

필터

forEach