InfoView(text: "핸드폰 번호를 입력해주세요", imageName: "phone.fill")
        .previewLayout(.sizeThatFits)

Preview에서  요로코롬 하면 안됨....

Xcode15이상부터

#Preview(traits: .sizeThatFitsLayout) {
    InfoView(text: "핸드폰 번호를 입력해주세요", imageName: "phone.fill")
}

이렇게 해야 한다고 합니다라ㅏ

https://stackoverflow.com/questions/74429078/swiftui-preview-layout-size-that-fits-does-not-work

문제 설명

수웅이는 매달 주어진 음식을 빨리 먹는 푸드 파이트 대회를 개최합니다. 이 대회에서 선수들은 1대 1로 대결하며, 매 대결마다 음식의 종류와 양이 바뀝니다. 대결은 준비된 음식들을 일렬로 배치한 뒤, 한 선수는 제일 왼쪽에 있는 음식부터 오른쪽으로, 다른 선수는 제일 오른쪽에 있는 음식부터 왼쪽으로 순서대로 먹는 방식으로 진행됩니다. 중앙에는 물을 배치하고, 물을 먼저 먹는 선수가 승리하게 됩니다.

이때, 대회의 공정성을 위해 두 선수가 먹는 음식의 종류와 양이 같아야 하며, 음식을 먹는 순서도 같아야 합니다. 또한, 이번 대회부터는 칼로리가 낮은 음식을 먼저 먹을 수 있게 배치하여 선수들이 음식을 더 잘 먹을 수 있게 하려고 합니다. 이번 대회를 위해 수웅이는 음식을 주문했는데, 대회의 조건을 고려하지 않고 음식을 주문하여 몇 개의 음식은 대회에 사용하지 못하게 되었습니다.

예를 들어, 3가지의 음식이 준비되어 있으며, 칼로리가 적은 순서대로 1번 음식을 3개, 2번 음식을 4개, 3번 음식을 6개 준비했으며, 물을 편의상 0번 음식이라고 칭한다면, 두 선수는 1번 음식 1개, 2번 음식 2개, 3번 음식 3개씩을 먹게 되므로 음식의 배치는 "1223330333221"이 됩니다. 따라서 1번 음식 1개는 대회에 사용하지 못합니다.

수웅이가 준비한 음식의 양을 칼로리가 적은 순서대로 나타내는 정수 배열 food가 주어졌을 때, 대회를 위한 음식의 배치를 나타내는 문자열을 return 하는 solution 함수를 완성해주세요.

제한사항

• 2 ≤ food의 길이 ≤ 9
• 1 ≤ food의 각 원소 ≤ 1,000
• food에는 칼로리가 적은 순서대로 음식의 양이 담겨 있습니다.
• food[i]는 i번 음식의 수입니다.
• food[0]은 수웅이가 준비한 물의 양이며, 항상 1입니다.
• 정답의 길이가 3 이상인 경우만 입력으로 주어집니다.

입출력 예

입출력 예 설명

입출력 예 #1

• 문제 예시와 같습니다.

입출력 예 #2

• 두 선수는 1번 음식 3개, 3번 음식 1개를 먹게 되므로 음식의 배치는 "111303111"입니다.

import Foundation

func solution(_ food:[Int]) -> String {

    //정답 배열
    var res = ""
    
    //오른쪽 배열
    var half = ""
    
    //food접근
    for i in food.indices {
        //갯수만큼 문자열 생성,추가
        res += String(repeating: String(i), count: food[i] / 2)
    }
    //왼쪽 배열 뒤집어서 오른쪽배열만들기
    half = String(res.reversed())
    //물인 "0"추가
    res.append("0")
    
    //정답 배열에 오른쪽 배열 추가
    res.append(half)
    
    return res
}

https://github.com/kodecocodes/swift-algorithm-club

정의 

구조체와 클래스의 정의 구문은 비슷합니다. struct키워드로 구조를 소개하고 키워드로 클래스를 소개합니다 class. 둘 다 한 쌍의 중괄호 안에 전체 정의를 배치합니다.

struct SomeStructure {
    // structure definition goes here
}
class SomeClass {
    // class definition goes here
}

EX)

struct Resolution {
    var width = 0
    var height = 0
}
class VideoMode {
    var resolution = Resolution()
    var interlaced = false
    var frameRate = 0.0
    var name: String?
}

인스턴스를 생성하는 구문은 구조체와 클래스 모두 매우 유사합니다.

let someResolution = Resolution()
let someVideoMode = VideoMode()

모든 구조체에는 자동으로 생성된 멤버 단위 초기화가 있으며 이를 사용하여 새 구조체 인스턴스의 멤버 속성을 초기화할 수 있습니다. 새 인스턴스의 속성에 대한 초기 값은 이름으로 멤버별 이니셜라이저에 전달될 수 있습니다.

let vga = Resolution(width: 640, height: 480)

구조체와 달리 클래스 인스턴스는 기본 멤버 단위 초기화를 받지 않습니다. (초기화 initialization)

클래스는 참조 유형입니다.

값 유형과 달리 참조 유형은 변수나 상수에 할당되거나 함수에 전달될 때 복사되지 않습니다 . 복사본이 아니라 동일한 기존 인스턴스에 대한 참조가 사용됩니다.

let tenEighty = VideoMode()
tenEighty.resolution = hd
tenEighty.interlaced = true
tenEighty.name = "1080i"
tenEighty.frameRate = 25.0

frameRate를 30으로 바꿈

let alsoTenEighty = tenEighty
alsoTenEighty.frameRate = 30.0

import UIKit

struct Town{
    //프로퍼티
    let name = "Angelaland"
    var citizens = ["Angela", "Jack Bauer"]
    var resources = ["Gain" : 100, "Ore" :42, "Wool" : 75]
    
    //구조체 안의 리턴값 없는 메서드(구조체나 클래스 안에서의 정의)
    //독립실행형이고 어디선가 자유롭게 사용된다면 함수라고 정의 따라서 fortify는 메서드
    func fortify(){
        print ("Defences increased!")
    }
}


var myTown = Town() //Town개체를 myTown으로 사용

print(myTown.name) // 구조체의 name 출력
print("\(myTown.name) has \(myTown.resources["Gain"]!) bags of grain.")

myTown.citizens.append("Smith") //moTown의 citizens에 Smith추가
print(myTown.citizens.count) //citizens의 개수 출력

myTown.fortify()



//init사용
struct Town_initCase{
    //프로퍼티
    let name : String
    var citizens : [String]
    var resources : [String : Int]
    
    init(name : String, citizens : [String], resources : [String:Int]){
        self.name = name
        self.citizens = citizens
        self.resources = resources
    }
    
    //구조체 안의 리턴값 없는 메서드(구조체나 클래스 안에서의 정의)
    //독립실행형이고 어디선가 자유롭게 사용된다면 함수라고 정의 따라서 fortify는 메서드
    func fortify(){
        print ("Defences increased!")
    }
}

//init으로 Town_initCase 구조체 초기화
var anotherTown = Town_initCase(name: "Nameless Island", citizens: ["Tom"], resources: ["Coconuts" : 100])
anotherTown.citizens.append("Wilson")
print(anotherTown.citizens)

https://docs.swift.org/swift-book/documentation/the-swift-programming-language/classesandstructures#Definition-Syntax

특수한 문자열을 출력하려면 양끝에 #을 붙여주면된다.

import Foundation

print(#"!@#$%^&*(\'"<>?:;"#)
//!@#$%^&*(\'"<>?:; 그대로 출력됨.

 open API 사용을 위한 공부 시작~~~ 하겠습니다~~~

개발하는 정대리님의 영상 보면서 공부했습니다.(항상 좋은강의 감사드립니다.)

https://www.youtube.com/watch?v=WR4_KenX0G8 

API호출은 Unsplash사이트

https://unsplash.com/ko

사이트에서 회원가입을 진행한 후 개발자/API에 들어갑니다.

Your apps를 클릭하여 앱을 만들어 주시고

이렇게 따라오시면 API키 발급이 됩니다.

이렇게 API키가 만들어집니다.

Access Key를 활용하여 API를 호출합니다.

Unsplash의 Doucument에서

Search photos와 Search users를 사용하게됩니다.

API호출이 처음인 분들은 Postman을 사용하면 된다구 하시네요~

https://www.postman.com/

GET에 https://api.unsplash.com/search/photos? 을 입력한 후,

client_id에 Unsplash의 Access키를 넣어주시고

query에 고양이 검색을 위한 cat를 입력후 Send를 하면 밑의 body에 결과값이 나옵니다. 

저 주소들은 Unsplash에 cat을 검색하면 나오는 이미지와 같습니다.

여기까지 API호출을 이용하여 데이터를 가져와 보았고 이제 Alamofire를 사용하여 API호출을 해봅시닷!!

8
4
3
6
8
7
5
2
1

+
+
+
+
-
-
+
+
-
+
+
-
-
-
-
-

5
1
2
5
3
4

NO

제출 코드

import Foundation

public struct Stack<T>{
    private var elements = [T]()
    public init() {}
    
    public mutating func push(_ element: T){
        self.elements.append(element)
    }
    
    public mutating func pop() -> T? {
        let pop = self.elements.popLast()
        self.elements.removeLast()
        return pop
    }
    
    public mutating func poplast() {
        self.elements.removeLast()
    }
    
    public func top() -> T? {
            return self.elements.last
        }
}

var myStack = Stack<Int>()
var ansArr : [String] = []
var cnt = 1

let input = Int(readLine()!)!

for _ in 0 ..< input {
    let num = Int(readLine()!)!
    
    while cnt <= num{
        myStack.push(cnt)
        ansArr.append("+")
        cnt += 1
    }
    
    if myStack.top() == num{
        myStack.poplast()
        ansArr.append("-")
    }else{
        print("NO")
        exit(0)
    }
}

print(ansArr.joined(separator: "\n"))

Array

-Array는 멤버가 순서(인덱스)를 가진 리스트 형태의 컬렉션 타입입니다.

// 빈 Int Array 생성
var integers: Array<Int> = Array<Int>()

// 같은 표현
// var integers: Array<Int> = [Int]()
// var integers: Array<Int> = []
// var integers: [Int] = Array<Int>()
// var integers: [Int] = [Int]()
// var integers: [Int] = []
// var integers = [Int]()
Array 활용

integers.append(1)
integers.append(100)

// Int 타입이 아니므로 Array에 추가할 수 없습니다
//integers.append(101.1)

print(integers)	// [1, 100]

// 멤버 포함 여부 확인
print(integers.contains(100)) // true
print(integers.contains(99)) // false

// 멤버 교체
integers[0] = 99

// 멤버 삭제
integers.remove(at: 0)
integers.removeLast()
integers.removeAll()

// 멤버 수 확인
print(integers.count)

// 인덱스를 벗어나 접근하려면 익셉션 런타임 오류발생
//integers[0]

let을 이용하여 Array를 선언하면 불변 Array가 됩니다.

let immutableArray = [1, 2, 3]

// 수정이 불가능한 Array이므로 멤버를 추가하거나 삭제할 수 없습니다
//immutableArray.append(4)
//immutableArray.removeAll()

Dictionary

-Dictionary는 키 와 값 의 쌍으로 이루어진 컬렉션 타입입니다.

// Key가 String 타입이고 Value가 Any인 빈 Dictionary 생성
var anyDictionary: Dictionary<String, Any> = [String: Any]()

// 같은 표현
// var anyDictionary: Dictionary <String, Any> = Dictionary<String, Any>()
// var anyDictionary: Dictionary <String, Any> = [:]
// var anyDictionary: [String: Any] = Dictionary<String, Any>()
// var anyDictionary: [String: Any] = [String: Any]()
// var anyDictionary: [String: Any] = [:]
// var anyDictionary = [String: Any]()

-Dictionary 활용

// 키에 해당하는 값 할당
anyDictionary["someKey"] = "value"
anyDictionary["anotherKey"] = 100

print(anyDictionary) // ["someKey": "value", "anotherKey": 100]

// 키에 해당하는 값 변경
anyDictionary["someKey"] = "dictionary"
print(anyDictionary) ["someKey": "dictionary", "anotherKey": 100]

// 키에 해당하는 값 제거
anyDictionary.removeValue(forKey: "anotherKey")
anyDictionary["someKey"] = nil
print(anyDictionary)

-let을 사용하여 Dictionary를 선언하면 불변 Dictionary가 됩니다.

let emptyDictionary: [String: String] = [:]
let initalizedDictionary: [String: String] = ["name": "yagom", "gender": "male"]

// 불변 Dictionary이므로 값 변경 불가
//emptyDictionary["key"] = "value"

-키의 해당하는 값을 다른 변수나 상수에 할당하고자 할때는 옵셔널 타입 캐스팅 파트에서 다룹니다.

// "name"이라는 키에 해당하는 값이 없을 수 있으므로 
// String 타입의 값이 나올 것이라는 보장이 없습니다.
// 컴파일 오류가 발생합니다
let someValue: String = initalizedDictionary["name"]

Set

-Set은 순서가 없고, 멤버가 유일한 것을 보장하는 컬렉션 타입입니다.

-Set의 선언과 생성

// 빈 Int Set 생성
var integerSet: Set<Int> = Set<Int>()
integerSet.insert(1)
integerSet.insert(100)
integerSet.insert(99)
integerSet.insert(99)
integerSet.insert(99)

print(integerSet) // [100, 99, 1]
print(integerSet.contains(1)) // true
print(integerSet.contains(2)) // false

integerSet.remove(100)
integerSet.removeFirst()

print(integerSet.count) // 1
Set는 집합연산에 많이 활용됩니다

// Set는 집합 연산에 꽤 유용합니다
let setA: Set<Int> = [1, 2, 3, 4, 5]
let setB: Set<Int> = [3, 4, 5, 6, 7]

// 합집합
let union: Set<Int> = setA.union(setB)
print(union) // [2, 4, 5, 6, 7, 3, 1]

// 합집합 오름차순 정렬
let sortedUnion: [Int] = union.sorted()
print(sortedUnion) // [1, 2, 3, 4, 5, 6, 7]

// 교집합
let intersection: Set<Int> = setA.intersection(setB)
print(intersection) // [5, 3, 4]

// 차집합
let subtracting: Set<Int> = setA.subtracting(setB)
print(subtracting) // [2, 1]

생각해보기!

다음과 같은 경우에는 각각 어떤 컬렉션 타입을, 상수/변수 선언 중 어떤 것을 사용하면 유용할지 생각해 봅시다.

• 영어 알파벳 소문자를 모아두는 컬렉션 >> Array
• 책의 제목과 저자 정리를 위한 컬렉션 >> Dictionary
• 우리반 학생 명부 작성을 위한 컬렉션 >> Set?

https://blog.yagom.net/

10
6 3 2 10 10 10 -10 -10 7 3
8
10 9 -5 2 3 4 5 -10

3 0 0 1 2 0 0 2

실패코드 1트

func sequencial(_ array: [Int], num: Int) -> Int {
    var a = 0
    for element in array {
        if num == element {
            a += 1
        }
    }
    return a
}


var N = Int(readLine()!)!
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
var M = Int(readLine()!)!
let input_M = readLine()!.split(separator: " ").map{Int(String($0))!}

input_N.sort()

var arr = [Int]()
for i in 0..<M{
    arr.append(sequencial(input_N, num: input_M[i]))
}
print(arr.map{String($0)}.joined(separator: " "))

이진탐색으로 어떻게 해야할지 잘모르겠어서 완전탐색으로 하였다..

-> 당연히 시간초과 ㅋㅋㅌ ㅆ,,

실패코드 2트

func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
    let mid = Int((left + right) / 2)
    var count = 0
    
    if target == input_N[mid]{
        var midLeft = mid - 1
        count += 1
        while midLeft >= 0 && target == input_N[midLeft]{
            count += 1
            midLeft -= 1
        }
        var midRight = mid + 1
        while midRight < input_N.count && target == input_N[midRight]{
            count += 1
            midRight += 1
        }
        return count
    }
    
    if left > right || target < input_N[left] || target > input_N[right]{
        return count
    }
    
    if target > input_N[mid]{
        return binarySearch(mid + 1, right, target)
    }else if target<input_N[mid]{
        return binarySearch(left, mid - 1, target)
    }
    return count
}

var N = Int(readLine()!)!
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}
var M = Int(readLine()!)!
let input_M = readLine()!.split(separator: " ").map{Int(String($0))!}

input_N.sort()

var arr : [Int] = []
for i in input_M{
    arr.append(binarySearch(0 , N-1 , i))
}
print(arr.map{String($0)}.joined(separator: " "))

나름 이분탐색 사용하였지만 다시나는 시간초과,,, 무엇이 문제일까..?

다음에 알아보도록 하자....

실패코드 3트

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {
        
        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }

        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
    let mid = Int((left + right) / 2)
    var count = 0
    
    if target == input_N[mid]{
        var midLeft = mid - 1
        count += 1
        while midLeft >= 0 && target == input_N[midLeft]{
            count += 1
            midLeft -= 1
        }
        var midRight = mid + 1
        while midRight < input_N.count && target == input_N[midRight]{
            count += 1
            midRight += 1
        }
        return count
    }
    if left > right || target < input_N[left] || target > input_N[right]{
        return count
    }
    if target > input_N[mid]{
        return binarySearch(mid + 1, right, target)
    }else if target<input_N[mid]{
        return binarySearch(left, mid - 1, target)
    }
    return count
}


let fileIO = FileIO()
var input_N: [Int] = []
var input_M: [Int] = []

let N = fileIO.readInt()
for _ in 0..<N {
    input_N.append(fileIO.readInt())
}

let M = fileIO.readInt()
for _ in 0..<M {
    input_M.append(fileIO.readInt())
}

input_N.sort(by: <)

var result = ""
for i in input_M{
    let count = binarySearch(0 , N-1 , i)
    result += "\(count) "
}
print(result)

시간..초,,ㄱ..ㅘ....

딱알았다.. sort때문인거같으 이것만 다시해서 올려보겠습니다..ㅎ

4트ㅎㅎ

//import Foundation
//
//final class FileIO {
//    private let buffer:[UInt8]
//    private var index: Int = 0
//
//    init(fileHandle: FileHandle = FileHandle.standardInput) {
//
//        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
//    }
//
//    @inline(__always) private func read() -> UInt8 {
//        defer { index += 1 }
//
//        return buffer[index]
//    }
//
//    @inline(__always) func readInt() -> Int {
//        var sum = 0
//        var now = read()
//        var isPositive = true
//
//        while now == 10
//                || now == 32 { now = read() } // 공백과 줄바꿈 무시
//        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
//        while now >= 48, now <= 57 {
//            sum = sum * 10 + Int(now-48)
//            now = read()
//        }
//
//        return sum * (isPositive ? 1:-1)
//    }
//
//    @inline(__always) func readString() -> String {
//        var now = read()
//
//        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
//        let beginIndex = index-1
//
//        while now != 10,
//              now != 32,
//              now != 0 { now = read() }
//
//        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
//    }
//
//    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
//        var now = read()
//
//        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
//        let beginIndex = index-1
//
//        while now != 10,
//              now != 32,
//              now != 0 { now = read() }
//
//        return Array(buffer[beginIndex..<(index-1)])
//    }
//}

func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
    let mid = Int((left + right) / 2)
    var count = 0
    
    if target == input_N[mid]{
        var midLeft = mid - 1
        count += 1
        while midLeft >= 0 && target == input_N[midLeft]{
            count += 1
            midLeft -= 1
        }
        var midRight = mid + 1
        while midRight < input_N.count && target == input_N[midRight]{
            count += 1
            midRight += 1
        }
        return count
    }
    if left > right || target < input_N[left] || target > input_N[right]{
        return count
    }
    if target > input_N[mid]{
        return binarySearch(mid + 1, right, target)
    }else if target<input_N[mid]{
        return binarySearch(left, mid - 1, target)
    }
    return count
}


func quickSort(numArr : [Int]) -> [Int]{
    if numArr.count < 2{
        return numArr
    }
    
    let pivot = numArr[0]
    var left :[Int] = []
    var right :[Int] = []
    
    
    for i in 1..<numArr.count{
        if pivot > numArr[i]{
            left.append(numArr[i])
        }else if pivot < numArr[i] {
            right.append(numArr[i])
        }else if pivot == numArr[i]{
            left.insert(numArr[i], at: 0)
        }
    }
    return quickSort(numArr: left) + [pivot] + quickSort(numArr: right)
}



//let fileIO = FileIO()
//var input_N: [Int] = []
//var input_M: [Int] = []

//let N = fileIO.readInt()
let N = Int(readLine()!)!

//for _ in 0..<N {
//    input_N.append(fileIO.readInt())
//}
var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}

//let M = fileIO.readInt()
let M = Int(readLine()!)!
//for _ in 0..<M {
//    input_M.append(fileIO.readInt())
//}
var input_M = readLine()!.split(separator: " ").map{Int(String($0))!}

input_N = quickSort(numArr: input_N)

var result = ""

for i in input_M{
    let count = binarySearch(0 , N-1 , i)
    result += "\(count) "
}
print(result)

sort를 퀵정렬로 바꿨는뎀 요것도 시간초과네요..? ㅎㅎ 아 주석은 디버깅때문에 해뒀습니다.

이렇게 해보니 1트와 2트는 그냥 틀린것 같네요? ㅎㅎ (말로만 1트 2트지 수많은 트라이들이...)

다른분들은 lower upper 나눠서 하길래 나는 다른길을 걷고자 악바리로 한번에 해보려했지만 안되는것같네요?ㅎㅎ

아직 의지는 꺾이지 않았습니다.

제출코드 5트..

import Foundation

final class FileIO {
    private let buffer:[UInt8]
    private var index: Int = 0

    init(fileHandle: FileHandle = FileHandle.standardInput) {

        buffer = Array(try! fileHandle.readToEnd()!)+[UInt8(0)] // 인덱스 범위 넘어가는 것 방지
    }

    @inline(__always) private func read() -> UInt8 {
        defer { index += 1 }

        return buffer[index]
    }

    @inline(__always) func readInt() -> Int {
        var sum = 0
        var now = read()
        var isPositive = true

        while now == 10
                || now == 32 { now = read() } // 공백과 줄바꿈 무시
        if now == 45 { isPositive.toggle(); now = read() } // 음수 처리
        while now >= 48, now <= 57 {
            sum = sum * 10 + Int(now-48)
            now = read()
        }

        return sum * (isPositive ? 1:-1)
    }

    @inline(__always) func readString() -> String {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return String(bytes: Array(buffer[beginIndex..<(index-1)]), encoding: .ascii)!
    }

    @inline(__always) func readByteSequenceWithoutSpaceAndLineFeed() -> [UInt8] {
        var now = read()

        while now == 10 || now == 32 { now = read() } // 공백과 줄바꿈 무시
        let beginIndex = index-1

        while now != 10,
              now != 32,
              now != 0 { now = read() }

        return Array(buffer[beginIndex..<(index-1)])
    }
}

func lowerBound(_ left: inout Int,_ right: inout Int , _ target: Int) -> Int{
    while left < right{
        let mid = Int((left + right) / 2)
        if input_N[mid] < target {
            left = mid + 1
        }else if target <= input_N[mid] {
            right = mid
        }
    }
    return left
}

func upperBound(_ left: inout Int,_ right: inout Int , _ target: Int) -> Int{
    while left < right{
        let mid = Int((left + right) / 2)
        if input_N[mid] <= target{
            left = mid + 1
        }else if target < input_N[mid]{
            right = mid
        }
    }
    return right
}

func binarySearch(_ left: Int,_ right: Int , _ target: Int) -> Int{
    let mid = Int((left + right) / 2)
    var count = 0
    
    if target == input_N[mid]{
        var midLeft = mid - 1
        count += 1
        while midLeft >= 0 && target == input_N[midLeft]{
            count += 1
            midLeft -= 1
        }
        var midRight = mid + 1
        while midRight < input_N.count && target == input_N[midRight]{
            count += 1
            midRight += 1
        }
        return count
    }
    if left > right || target < input_N[left] || target > input_N[right]{
        return count
    }
    if target > input_N[mid]{
        return binarySearch(mid + 1, right, target)
    }else if target<input_N[mid]{
        return binarySearch(left, mid - 1, target)
    }
    return count
}


func quickSort(numArr : [Int]) -> [Int]{
    if numArr.count < 2{
        return numArr
    }
    
    let pivot = numArr[0]
    var left :[Int] = []
    var right :[Int] = []
    
    
    for i in 1..<numArr.count{
        if pivot > numArr[i]{
            left.append(numArr[i])
        }else if pivot < numArr[i] {
            right.append(numArr[i])
        }else if pivot == numArr[i]{
            left.insert(numArr[i], at: 0)
        }
    }
    return quickSort(numArr: left) + [pivot] + quickSort(numArr: right)
}




let fileIO = FileIO()
var input_N: [Int] = []
var input_M: [Int] = []

var N = fileIO.readInt()
//var N = Int(readLine()!)!

for _ in 0..<N {
    input_N.append(fileIO.readInt())
}
//var input_N = readLine()!.split(separator: " ").map{Int(String($0))!}

var M = fileIO.readInt()
//var M = Int(readLine()!)!
for _ in 0..<M {
    input_M.append(fileIO.readInt())
}
//var input_M = readLine()!.split(separator: " ").map{Int(String($0))!}

//input_N = quickSort(numArr: input_N)
input_N.sort()

var result = ""
var zero = 0
var N_real = N


for i in input_M{
    //let count = binarySearch(0 , N-1 , i)
    let up = upperBound(&zero, &N, i)
    zero = 0
    N = N_real
    let lo = lowerBound(&zero, &N, i)
    zero = 0
    N = N_real
    let count = up - lo
    //print(String((upperBound(&zero, &N, i)) - (lowerBound(&zero, &N, i))), terminator: " ")
    result += "\(count) "
}
print(result)

upper 랑 lower로 나누어서 하는걸로 타협을 보았고... 퀵정렬보다 sort()가 더 빠르다는것을 알았습니다..

lower과 upper의 함수를 쓸때 파라미터가 call by refference이므로 inout을 사용하여 0과 N을 다시넣어주었습니다..

이중탐색과 퀵정렬 함수는 사용하지 않았습니다! ㅎㅎ...

도움주신분

https://everycommit.tistory.com/33

- 모든 데이터 타입의 이름은  첫 글자를 대문자로 입력한다. 

- 모든 데이터 타입(Int, Float, Double, Bool, String, Array, Dictionary, Set 등)은 모두 Struct (구조체)를 기반으로 구현되어 있다.

(쉽게 설명하자면, 우리가 숫자를 표현하고 싶을 때 Int 라고 입력해서 바로 사용할 수 있도록 Swift에 미리 구조체 라는 것으로 만들어져 있다는 의미)

<-> Reference Type : class, function, closure 등

- 스위프트는 데이터 타입 엄격하게 관리하므로 암시적으로 이루어지는 데이터 타입의 변형으로부터 일어날 수 있는 예기치 않은 결과를 일으키는 경우를 방지해야 한다.

Bool

- true 와 false 만을 값으로 가지는 타입

var someBool: Bool = true
someBool = false
// someBool = 0 // 컴파일 오류발생
// someBool = 1 // 컴파일 오류발생

Int , UInt

- Int : 정수 타입. 현재는 기본적으로 64비트 정수형.

var someInt: Int = -100
// someInt = 100.1 // 컴파일 오류발생

-UInt : 양의 정수 타입. 현재는 기본적으로 64비트 양의 정수형

var someUInt: UInt = 100
// someUInt = -100 // 컴파일 오류발생
// someUInt = someInt // 컴파일 오류발생

Float, Double

-Float : 실수 타입. 32비트 부동소수형

var someFloat: Float = 3.14
someFloat = 3

-Double : 실수 타입. 64비트 부동소수형

var someDouble: Double = 3.14
someDouble = 3
// someDouble = someFloat // 컴파일 오류발생

Character, String

- Character : 문자 타입. 유니코드 사용. 큰따옴표("") 사용.

var someCharacter: Character = "🇰🇷"
someCharacter = "😄"
someCharacter = "가"
someCharacter = "A"
// someCharacter = "하하하" // 컴파일 오류발생
print(someCharacter)

-String : 문자열 타입. 유니코드 사용. 큰따옴표("") 사용.

var someString: String = "하하하 😄 "
someString = someString + "웃으면 복이와요"
print(someString)

// someString = someCharacter // 컴파일 오류발생

여러줄 문자열은 큰따옴표 세 개 사용.

someString = """
여러줄 문자열을
사용할 수 있습니다.
첫 줄에 겹따옴표 세 개,
마지막 줄에 겹따옴표 세 개를
사용하면 됩니다.
"""

someString = """
겹따옴표 세 개인 줄(첫줄, 끝줄)에서
줄 바꿈을 하지 않으면 오류가 발생합니다.
"""

/*
someString = """오류발생
오류발생"""
*/

생각해보기

let integer = 100 //정수형 Int Type
let floatingPoint = 12.34 // 실수형 Double Type
let apple = "A" // String

print(type(of: integer)) //Int
print(type(of: floatingPoint)) // Double
print(type(of: apple)) //String

Any

-swift의 모든 타입을 지칭하는 키워드

var someAny: Any = 100
someAny = "어떤 타입도 수용 가능합니다"
someAny = 123.12

Any 타입에 Double 자료를 넣어두었더라도 Any는 Double 타입이 아니기 때문에 할당할 수 없습니다.

명시적으로 타입을 변환해 주어야 합니다.

타입 변환은 차후에~

let someDouble: Double = someAny  // 컴파일 오류발생

AnyObject

모든 클래스 타입을 지칭하는 프로토콜(클래스와 프로토콜은 차후에~)

class SomeClass {}

var someAnyObject: AnyObject = SomeClass()

AnyObject는 클래스의 인스턴스만 수용 가능하기 때문에 클래스의 인스턴스가 아니면 할당할 수 없습니다.

someAnyObject = 123.12    // 컴파일 오류발생

nil

없음을 의미하는 키워드

다른 언어의 NULL, Null, null 등과 유사한 표현입니다.

아래 코드에서 someAny는 Any타입이고, someAnyObject는 AnyObject타입 이기 때문에

nil을 할당할 수 없습니다.

nil다루기는 옵셔널에서~

someAny = nil         // 컴파일 오류발생
someAnyObject = nil   // 컴파일 오류발생

도움주신 분들!

https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html

https://lxxyeon.tistory.com/

https://blog.yagom.net/