3-sep037

[sep037]

🔗 문제 링크

접미사 배열

그냥 생각 할 시간들 덜 쓰시라고 정렬 .. 가져왔어요

✔️ 소요된 시간

5분 ㅋ

✨ 수도 코드

성의없어보일수잇지만..

1. 문자열을 입력받는다.

2. 빈 배열을 만든다. (슬라이싱 결과를 담을 배열)

3. 문자열 길이만큼 반복하면서:
   a. 현재 인덱스부터 끝까지 문자열을 슬라이싱한다.
   b. 슬라이싱한 문자열을 배열에 추가한다.

4. 배열을 정렬한다.

5. 배열의 모든 요소를 출력한다.

📚 새롭게 알게된 내용

저는 그냥 sort가 모든 문자열 상대로 정렬하는지를 까먹고
그냥 첫 글자 정렬하고 그 다음 두 번째 정렬하고 그랬다가 그냥 sort 함수 사용했어용
어케 이걸 까먹지 ?

[bishoe01]

저는 removeFirst() 사용해줬는데, String.index사용해서 slice하신게 더 swift다운느낌이네요..!
이거로 성능비교를 한번해봤는데 아래 더 자세히 남겨보도록 하겠습니다 !

[YooGyeongMo]

@bishoe01 헤이헤이 finn~ 역시 직이네예 밑에 코드 보고왔는데예 제가 문자열 풀때는 type(of:) 다 찍어보는 편입니다요 !!

그래서 문자열 슬라이싱으로 우째 안될까 ?? 해서 보니 역시나 str[startIndex...]으로 가능하던데 이게 Substring이더라구요

그래서 첫 배열을 [Substring] 으로 해주고 O(N)으로 되게 한번 해봤는데 통과 되었으예

import Foundation

let str = readLine()!

var strArray: [Substring] = []

for i in 0..<str.count {
    let startIndex = str.index(str.startIndex, offsetBy: i)
    strArray.append(str[startIndex...])
//    print(type(of:str[startIndex...]))
}

for item in strArray.sorted(){
    print(item)
}

비슷하려나요 ? 벤치마킹 가능하신가예 ?

[giljihun]

저는 dropFirst() 를 사용해봤는데요.

dropFirst()는 앞 문자를 건너뛴 Substring을 리턴하기 때문에 즉시 복사가 일어나진 않지만,
그걸 다시 String()으로 변환해서 저장하게 되면, 그 시점에서만 복사가 발생하게 됩니다.
그래서 처음엔 이 방식이 최선이겠구나? 싶었는데.

말씀하신 removeFirst() 방식이 COW 조건에서 포인터만 이동하는 식으로 처리돼서
실제로는 더 빠를 수 있다는 점은 정말 좋은 내용이네요.

이것이 deep dive!군요.

[alstjr7437]

오호 다들 인덱스나 dropFirst를 사용하셨군요

저는 suffix로 뽑아내줬습니다!

for i in 1...S.count {
    words.append(String(S.suffix(i)))
}

[YooGyeongMo]

@alstjr7437 와 suffix prefix에 대한 글을 써놓고도 그걸 하... 저의 이 하찮은 중생의 머리통을 한 번 탁 ! 치고 억! 하니 이해해버리네욧

[bishoe01]

설명 편의상 함수이름을 제 이름으로 했어요 !

func finn(_ str: String) {
    var answer: [String] = [str]
    var changableStr = str

    for _ in 0 ..< str.count - 1 {
        changableStr.removeFirst()
        answer.append(changableStr)
    }

    answer.sort()

    for item in answer {
        print(item)
    }
}

저는 answer배열에다가 문제에서 의도한대로 앞에 하나씩
removeFirst()를 통해서 앞에서 한글자씩 떼먹으면서 배열에 넣고 sorting으로 돌렸어요!

일반적으로는 앞에서 떼어가면 O(N)만큼 이제 뒤에애들이 땡겨져와야하는것으로 알아서, 당연히 제 코드가 글로니코드보다 느리다고 생각을 했는데요..!

let alphabet = "abcdefghijklmnopqrstuvwxyz"
let testInput = String((0 ..< 4000).map { i in
    alphabet[alphabet.index(alphabet.startIndex, offsetBy: i % alphabet.count)]
})

var totalFinn = 0.0
var totalGlowny = 0.0

for _ in 0 ..< 100 {
    var start = CFAbsoluteTimeGetCurrent()
    finn(testInput)
    var end = CFAbsoluteTimeGetCurrent()
    totalFinn += (end - start)

    start = CFAbsoluteTimeGetCurrent()
    glowny(testInput)
    end = CFAbsoluteTimeGetCurrent()
    totalGlowny += (end - start)
}
print("Finn 평균: \(totalFinn / 100)초")
print("Glowny 평균: \(totalGlowny / 100)초")

이거로 이제 벤치마킹을 돌려봤거든요!
알파벳 순서대로 반복되는 4000자 길이의 문자열을 활용한 것으로 돌려봤습니다!
(1000자는 너무 느린것같아서 10000자까지 늘렸더니 이게 너무 값이 안나오길래 대강 4천자 정도로 합의를 봤습니다..)

그랬더니 결과값이 아래와 같이 나오더라구요..!

Finn 평균: 0.009801552295684815초
Glowny 평균: 0.023117616176605224초

String.index자체가 앞에서 차례대로 보니까 O(i)기도 하고,
String(suffix)할때 이게 또 복사하는 값이 많이든다고 하더라구요..!

Substring to String 여기에서 Substring to String 섹션 보시면 어떻게 String()이 동작하는지 설명이 되어있습니다..! 저도 복잡해서 완전 이해는 못했는데,

1. 원본 문자열 참조하고
2. startIndex, endIndex 슬라이스하고
3. 슬라이스한 버퍼를 새로 복사해서 String을 만든대용

---

처음엔 제가 사용한 removeFirst()이 일반적으로는 느릴 거라고 생각했어요. String()까지 복잡도는 생각안해주기도 했고..
배열처럼 앞에서 값을 제거하면 뒤에 있는 모든 요소를 한 칸씩 땡겨야 하니까 비효율적인 방식이잖아요? 뒤에서 빼는것보다.. 그래서 좀 알아보다가 COW라는 키워드에 대해서 조금 알아봤습니다..

Swift의 String (Array,Dictionary,Set도 가능) 은 내부적으로 Copy-on-Write(COW)가 적용될 수 있다고 하는데요..! COW 관련 블로그
근데 해당 문자열의 참조가 유일하다면, removeFirst()를 써도 COW가 일어나지않고, 그냥 슬라이스 시작 포인터만 한 칸 옮기는 식으로 매우 빠르게 처리할 수 있더라고요.

이럴 땐 시간복잡도가 O(N)이 아니라, 거의 O(1)에 가깝게 동작할 수도 있다네요 ! (신기)
요약하면 복사하지 않는 이상, 수정까지는 매우 빠르게 처리될 수 있다의 맥락? 정도로 이해해주시면 좋을 것 같아요. <그만큼 복사하는데에 리소스가 덜든다는 개념>

물론 그렇다고 해서 COW가 안 일어난다 -> 무조건 빠르다는 건 또 아니라네요...(잘모르느 분야라서 많이 헷갈리는데 느낌만 봐주시길..)
COW로 새로 복사된 버퍼가 오히려 더 캐시 친화적인 구조가 될 수도 있고,
접근 패턴에 따라 성능이 뒤집히는 경우도 존재한다합니닷..

저도 블로그여러개랑 GPT선생님이랑 여러개 뒤지면서 좀 도움이 되었으면해서 써봤는데 좀 중구난방인것 같네요..
첨부한 링크 보시고 도움이 되었면합니다..! 틀렸다면 지적도 부탁드려요..!

추가

isKnownUniquelyReferenced
로 참조가 하나인지 알 수 있음

[MuchanKim]

이번 주차부터는 타임어택으로 한번 풀어보려고해요. 기존에 네이밍이나 모듈로 따로 빼는게 시간을 더 쓰는 것 같기도해서.. 무튼 이 문제는 20분?정도 걸린 것 같습니다. 다른분들 코드보면 아직 Swift답지않게 푸는 것 같네요..ㅎ.ㅎ

전 2차원 반복문으로 풀었습니다. 먼저 0..., 1... 으로 인덱스를 슬라이싱 하려고 했고 익숙한 방법으로 푼 것 같아요. 마카로니씨의 startIndex가 저한테 j라고 보면 되고, 저는 j부터 순회해서 문자를 더해서 문자열을 만들어 줬어요.

결론은.. 메모리효율이나 속도 둘 다 생각하지 못한 코드라고 볼 수 있겠습니다.

+ 길이 forEach 잘 활용하길래 저도 써봤습메다.

import Foundation

// 문자열 배열으로 받고 앞 글자 하나씩 날리면서 단어 만들어 주면 될 듯.
// 그리고 만든 단어 리스트 오름차순 sort

let n = Array(readLine()!.lowercased())
var res: [String] = []

for i in 0..<n.count {
    var word: String = ""
    
    for j in i..<n.count {
        word += String(n[j])
    }
    res.append(word)
}

res.sort(by: <)

res.forEach { i in print(i) }

[MuchanKim]

핀 말대로 swift다운 느낌의 코드인 것 같아요! 시작 인덱스 잡아주고 범위연산자 써주는거 좋네요! 직관적이면서도 간결합니다.
칭찬해 마카로니

전 문자 순회하면서 문자를 새로 만들어줬는데 비효율적인 것 같다는 생각이드네요.. 코드는 전체 리뷰에 달겠습니다..!

[YooGyeongMo]

forEach를 쓰시다니 역시 구현왕 무찬킴 무우 !!! sort(by:<) 진짜 {} () 이런식으로 내부 조건들을 손쉽게 스위프티하게 변경하던데 무우에게 배워갑니다.

[MuchanKim]

진짜 별거 아닌데 저는 sort가 기본적으로 오름차순이지만 항상 by:<로 썼던 것 같아요. 근데 불필요 한 것 같네요! 저도 간결하게 sort()로 표현 해야겠습니다.

res.sort(by: <)

[giljihun]

"오히려 좋아"

[MuchanKim]

"그런가?"

[YooGyeongMo]

포로리야 포로리야 아니아니 글로리야 글로리야 ~~~ 언냐랑 코드 겁나 비슷

[YooGyeongMo]

글로니 ~~~~ 요!!

리얼루 정말루 ~ 언냐랑 코드가 비슷한데 뭐 거진 똑같다고 할 수 있겠으예

import Foundation

let str = readLine()!

var strArray: [String] = [str]

for i in 1..<str.count {
    let startIndex = str.index(str.startIndex, offsetBy: i)
    let substring = String(str[startIndex...])
    strArray.append(substring)
}

for item in strArray.sorted(){
    print(item)
}

그런데 뭔가 저 String으로 한번 더 복사해주는게 메모리랑 시간 복잡도상 중첩이 되는거 같아서 print(type(of:))를 겁나 찍어보니

역시나 str[startIndex...] 는 Substring이라는 타입이 존재하더군요 ! 그래서 첫번째 요소부터 다 집어넣는다 생각하고 배열을 애초에 Substring으로 선언하고 풀어보니 들어가더라구요 !!!

import Foundation

let str = readLine()!

var strArray: [Substring] = []

for i in 0..<str.count {
    let startIndex = str.index(str.startIndex, offsetBy: i)
    strArray.append(str[startIndex...])
//    print(type(of:str[startIndex...]))
}

for item in strArray.sorted(){
    print(item)
}

Xcode 자동완성쓰니 item 추천해서 썼는데 글로니도 그런거였나요? 크크 ㅋㅋ

[YooGyeongMo]

https://eunjin3786.tistory.com/458 substring 관련글인데 참고 하시면 좋을듯합니다 ㅎㅎ

[giljihun]

print(type(of:) 찍는 습관 존경합니다 데미갓..ㅜㅜ

[MuchanKim]

짤 너무 웃겨요 ㅋㅋㅋㅋ

[sep037]

ㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋㅋ 아니 ㅠㅠㅠ
근데 저는 문제 풀면서 저렇게 시간이 얼마나 될까 .. ? 는 초과 됐을 때나 확인하는데 진짜 대박적

[YooGyeongMo]

@giljihun @MuchanKim @sep037 요시!! 이쿠죠 !!!

[giljihun]

저는 일단 걍 이렇게 하면 되나? 하고 무지성으로 풀어보고
코드를 줄여보는 연습을 좀 더 해봤습니다!

제출했던코드

/* MARK: - SOLUTION
 
 명사언어학
 파생어를 만드는 형태소의 하나. 어떤 단어의 끝에 붙어 새로운 단어가 되게 하는 말. `가위질'의 `-질' 따위. 끝가지. 뒷가지. 발가지. 접미어. 〈북〉 뒤붙이. ↔접두사.
 
 -> 뭐지 이거. '접미사'라는 표현을 써도 되는 문젠가
 */

import Foundation

guard let S = readLine() else { exit(0) }

let chars = Array(S)
var result: [String] = []

for i in 0..<chars.count {
    var temp = ""
    for j in i..<chars.count {
        temp += String(chars[j])
    }
    result.append(temp)
}

print(result.sorted().joined(separator: "\n"))

dropFirst() 활용해보기

import Foundation

guard let S = readLine() else { exit(0) }

let chars = Array(S)
var result: [String] = []

for i in 0..<S.count {
    result.append(String(S.dropFirst(i)))
}

print(result.sorted().joined(separator: "\n"))

기존 이중포문은 매 루프마다 새로운 문자열을 생성하는데
dropFirst()를 쓰니 String() 변환을 할 때만 복사가 발생해서 훨씬 성능은 좋을 것 같고 직관적이죠.

번외1

import Foundation

guard let S = readLine() else { exit(0) }

let chars = Array(S)
var result: [String] = []

print((0..<S.count).map { String(S.dropFirst($0)) }.sorted().joined(separator: "\n"))

번외2

import Foundation

guard let S = readLine() else { exit(0) }

let chars = Array(S)
var result: [String] = []

(0..<S.count).map { String(S.dropFirst($0)) }.sorted().forEach { print($0) }

이건 forEach로 print를 불러서 .joined를 안쓰면서 극한으로 줄이기 ㅎㅎ

[giljihun]

Swift의 String.index를 잘 활용한 문제고 풀이도 깔끔하네열 ~. ~

사소한 부분인데, 저는

let num = N.count 

부분이 조금은 추상적이지 않나 싶습니다!
length, stringLength 이런건 어떨까요??

[giljihun]

var array: [String] = []

도 결국 리턴용이라면 result나 answer도 괜찮아보이구요!
혹은, 구조를 설명한다면 suffixes?이런거도 좋을 것 같습니다~!!

[sep037]

뭐야 이 멋쟁이는

[YooGyeongMo]

@giljihun dropfirst(), ropfirst(),opfirst(),pfirst(),first(),irst(),rst(),st(),t()

[alstjr7437]

아니 쉬운 문제에 뭐이리 코멘트가 많지 하고 보니까
여러가지 인덱스와 removeFirst 등 deep Dive의 향연이 있엇군요!!

마지막에 읽어서 다들 재밌었습니다!!

저는 suffix로 문자를 뽑아줬어요!

let S = readLine()!
var words: [String] = []

for i in 1...S.count {
    words.append(String(S.suffix(i)))
}

words.sort()

for word in words {
    print(word)
}

[alstjr7437]

오호 다들 인덱스나 dropFirst를 사용하셨군요

저는 suffix로 뽑아내줬습니다!

for i in 1...S.count {
    words.append(String(S.suffix(i)))
}