๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ
๐Ÿ“– Problem Solution/Programmers

2020 KAKAO BLIND RECRUITMENT ๋ฌธ์ž์—ด ์••์ถ• Swift

by Fomagran ๐Ÿ’ป 2020. 3. 28.
728x90
๋ฐ˜์‘ํ˜•

๋ฌธ์ œ ์„ค๋ช…

๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ ์ „๋ฌธ๊ฐ€๊ฐ€ ๋˜๊ณ  ์‹ถ์€ ์–ดํ”ผ์น˜๋Š” ๋ฌธ์ž์—ด์„ ์••์ถ•ํ•˜๋Š” ๋ฐฉ๋ฒ•์— ๋Œ€ํ•ด ๊ณต๋ถ€๋ฅผ ํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค. ์ตœ๊ทผ์— ๋Œ€๋Ÿ‰์˜ ๋ฐ์ดํ„ฐ ์ฒ˜๋ฆฌ๋ฅผ ์œ„ํ•œ ๊ฐ„๋‹จํ•œ ๋น„์†์‹ค ์••์ถ• ๋ฐฉ๋ฒ•์— ๋Œ€ํ•ด ๊ณต๋ถ€๋ฅผ ํ•˜๊ณ  ์žˆ๋Š”๋ฐ, ๋ฌธ์ž์—ด์—์„œ ๊ฐ™์€ ๊ฐ’์ด ์—ฐ์†ํ•ด์„œ ๋‚˜ํƒ€๋‚˜๋Š” ๊ฒƒ์„ ๊ทธ ๋ฌธ์ž์˜ ๊ฐœ์ˆ˜์™€ ๋ฐ˜๋ณต๋˜๋Š” ๊ฐ’์œผ๋กœ ํ‘œํ˜„ํ•˜์—ฌ ๋” ์งง์€ ๋ฌธ์ž์—ด๋กœ ์ค„์—ฌ์„œ ํ‘œํ˜„ํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ๊ณต๋ถ€ํ•˜๊ณ  ์žˆ์Šต๋‹ˆ๋‹ค.
๊ฐ„๋‹จํ•œ ์˜ˆ๋กœ aabbaccc์˜ ๊ฒฝ์šฐ 2a2ba3c(๋ฌธ์ž๊ฐ€ ๋ฐ˜๋ณต๋˜์ง€ ์•Š์•„ ํ•œ๋ฒˆ๋งŒ ๋‚˜ํƒ€๋‚œ ๊ฒฝ์šฐ 1์€ ์ƒ๋žตํ•จ)์™€ ๊ฐ™์ด ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ, ์ด๋Ÿฌํ•œ ๋ฐฉ์‹์€ ๋ฐ˜๋ณต๋˜๋Š” ๋ฌธ์ž๊ฐ€ ์ ์€ ๊ฒฝ์šฐ ์••์ถ•๋ฅ ์ด ๋‚ฎ๋‹ค๋Š” ๋‹จ์ ์ด ์žˆ์Šต๋‹ˆ๋‹ค. ์˜ˆ๋ฅผ ๋“ค๋ฉด, abcabcdede์™€ ๊ฐ™์€ ๋ฌธ์ž์—ด์€ ์ „ํ˜€ ์••์ถ•๋˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค. ์–ดํ”ผ์น˜๋Š” ์ด๋Ÿฌํ•œ ๋‹จ์ ์„ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด ๋ฌธ์ž์—ด์„ 1๊ฐœ ์ด์ƒ์˜ ๋‹จ์œ„๋กœ ์ž˜๋ผ์„œ ์••์ถ•ํ•˜์—ฌ ๋” ์งง์€ ๋ฌธ์ž์—ด๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š”์ง€ ๋ฐฉ๋ฒ•์„ ์ฐพ์•„๋ณด๋ ค๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, ababcdcdababcdcd์˜ ๊ฒฝ์šฐ ๋ฌธ์ž๋ฅผ 1๊ฐœ ๋‹จ์œ„๋กœ ์ž๋ฅด๋ฉด ์ „ํ˜€ ์••์ถ•๋˜์ง€ ์•Š์ง€๋งŒ, 2๊ฐœ ๋‹จ์œ„๋กœ ์ž˜๋ผ์„œ ์••์ถ•ํ•œ๋‹ค๋ฉด 2ab2cd2ab2cd๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์œผ๋กœ 8๊ฐœ ๋‹จ์œ„๋กœ ์ž˜๋ผ์„œ ์••์ถ•ํ•œ๋‹ค๋ฉด 2ababcdcd๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ์œผ๋ฉฐ, ์ด๋•Œ๊ฐ€ ๊ฐ€์žฅ ์งง๊ฒŒ ์••์ถ•ํ•˜์—ฌ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋Š” ๋ฐฉ๋ฒ•์ž…๋‹ˆ๋‹ค.

๋‹ค๋ฅธ ์˜ˆ๋กœ, abcabcdede์™€ ๊ฐ™์€ ๊ฒฝ์šฐ, ๋ฌธ์ž๋ฅผ 2๊ฐœ ๋‹จ์œ„๋กœ ์ž˜๋ผ์„œ ์••์ถ•ํ•˜๋ฉด abcabc2de๊ฐ€ ๋˜์ง€๋งŒ, 3๊ฐœ ๋‹จ์œ„๋กœ ์ž๋ฅธ๋‹ค๋ฉด 2abcdede๊ฐ€ ๋˜์–ด 3๊ฐœ ๋‹จ์œ„๊ฐ€ ๊ฐ€์žฅ ์งง์€ ์••์ถ• ๋ฐฉ๋ฒ•์ด ๋ฉ๋‹ˆ๋‹ค. ์ด๋•Œ 3๊ฐœ ๋‹จ์œ„๋กœ ์ž๋ฅด๊ณ  ๋งˆ์ง€๋ง‰์— ๋‚จ๋Š” ๋ฌธ์ž์—ด์€ ๊ทธ๋Œ€๋กœ ๋ถ™์—ฌ์ฃผ๋ฉด ๋ฉ๋‹ˆ๋‹ค.

์••์ถ•ํ•  ๋ฌธ์ž์—ด s๊ฐ€ ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ์œ„์— ์„ค๋ช…ํ•œ ๋ฐฉ๋ฒ•์œผ๋กœ 1๊ฐœ ์ด์ƒ ๋‹จ์œ„๋กœ ๋ฌธ์ž์—ด์„ ์ž˜๋ผ ์••์ถ•ํ•˜์—ฌ ํ‘œํ˜„ํ•œ ๋ฌธ์ž์—ด ์ค‘ ๊ฐ€์žฅ ์งง์€ ๊ฒƒ์˜ ๊ธธ์ด๋ฅผ return ํ•˜๋„๋ก solution ํ•จ์ˆ˜๋ฅผ ์™„์„ฑํ•ด์ฃผ์„ธ์š”.

์ œํ•œ์‚ฌํ•ญ

  • s์˜ ๊ธธ์ด๋Š” 1 ์ด์ƒ 1,000 ์ดํ•˜์ž…๋‹ˆ๋‹ค.
  • s๋Š” ์•ŒํŒŒ๋ฒณ ์†Œ๋ฌธ์ž๋กœ๋งŒ ์ด๋ฃจ์–ด์ ธ ์žˆ์Šต๋‹ˆ๋‹ค.

์ž…์ถœ๋ ฅ ์˜ˆ

s result
"aabbaccc" 7
"ababcdcdababcdcd" 9
"abcabcdede" 8
"abcabcabcabcdededededede" 14
"xababcdcdababcdcd" 17

ํ’€์ด: ์šฐ์„  s๋ฅผ ๊ฐ€์žฅ ํฐ ๋‹จ์œ„๋กœ ๋Š๋Š” ๊ฑด ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆด์„ ๋•Œ ๋‚˜๋ˆ ์ง€๋ƒ์ด๋‹ค. ๊ทธ๋ž˜์„œ ๋ฐ”๊นฅ์ชฝ while๋ฌธ์˜ ์กฐ๊ฑด์—”

a๋ฅผ s.count/2๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์„ ๋•Œ๋งŒ ๋ฐ˜๋ณตํ•˜๋ผ๊ณ  ์„ค์ •ํ•ด๋‘์—ˆ๋‹ค. ๊ทธ๋ฆฌ๊ณ  a๋ฅผ 1์”ฉ ์ฆ๊ฐ€์‹œ์ผœ์ฃผ์–ด ๋ช‡๊ฐœ๋กœ ์งœ๋ฅผ์ง€๋ฅผ ์ฆ๊ฐ€์‹œ์ผœ์ค€๋‹ค.

๊ทธ๋ฆฌ๊ณค ์•ˆ์ชฝ while๋ฌธ์€ x๋ผ๋Š” ๋ณ€์ˆ˜๊ฐ€ a๋งŒํผ s๋ฅผ ์ฐจ๋ก€์ฐจ๋ก€ ๋ณด๋Š”๋ฐ s์˜ ๊ธธ์ด๋ฅผ ๋„˜์–ด๊ฐ€๋ฉด ์•ˆ์ชฝ while๋ฌธ์˜ ์กฐ๊ฑด์œผ๋กœ ์„ค์ •ํ–ˆ๋‹ค.

๊ทธ๋ฆฌ๊ณค suffix๋ฅผ ์ด์šฉํ•˜์—ฌ s์—์„œ x๋งŒํผ ์ด๋™ํ•œ ๊ธ€์ž ๋บ€ ๊ฒƒ์„ ๊ธฐ๋กํ•˜๋Š” remainder์— ์ €์žฅ

๊ทธ๋ฆฌ๊ณ  prefix๋ฅผ ์ด์šฉํ•˜์—ฌ s์—์„œ x๋งŒํผ ์ด๋™ํ•œ ๊ธ€์ž๋ฅผ prefix์— ์ €์žฅํ–ˆ๋‹ค. 

๊ทธ๋ฆฌ๊ณค pre๋ผ๋Š” ๋ณ€์ˆ˜์—” ์ „ prefix์˜ ๋ฌธ์ž์™€ ํ˜„์žฌ prefix๋ฅผ ๋น„๊ตํ•˜์—ฌ ๊ฐ™๋‹ค๋ฉด count๋ฅผ +1ํ•ด์ฃผ๊ณ  x๋Š” a๋งŒํผ ๋”ํ•ด์ค€ ๋’ค continue๋ฅผ ํ•ด์ค€๋‹ค.

๋งŒ์•ฝ ๋‹ค๋ฅด๋ฉด answer์— count์™€ ๊ทธ ์ „ ๋ฌธ์ž๋ฅผ ๋”ํ•ด์ค€๋‹ค. ํ•˜์ง€๋งŒ count๊ฐ€ ๋ณ€ํ™”์—†์ด 1์ด๋ผ๋ฉด ๊ทธ๋ƒฅ answer์— pre๋งŒ ๋”ํ•ด์ค€๋‹ค.

๊ทธ๋ฆฌ๊ณ  ๋งˆ์ง€๋ง‰์— x๊ฐ€ a๋งŒํผ ๋”ํ•ด์ ธ์„œ s.count๋ฅผ ๋„˜์–ด๊ฐ”์ง€๋งŒ s์— ๋‚จ์•„์žˆ๋Š” ๋ฌธ์ž๋ฅผ ๋งˆ์ € ๋”ํ•ด์ฃผ๊ธฐ ์œ„ํ•ด

answer์— s.suffix9(s.count-(x-a)๋ฅผ ๋”ํ•ด์ค€๋‹ค.

๊ทธ๋ฆฌ๊ณค answerarr๋ผ๋Š” answer์˜ ํฌ๊ธฐ๋ฅผ ๋ฐฐ์—ด์— ๋‹ด์•„์ค€๋‹ค.

๊ทธ๋ฆฌ๊ณ  min()์„ ์ด์šฉํ•ด answerarr์˜ ๊ฐ€์žฅ ์ž‘์€ ์ˆ˜๋ฅผ ๋ฐ˜ํ™˜ํ•ด์ค€๋‹ค.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
import Foundation
 
func solution(_ s:String-> Int {
    var answerarr = [Int]()
    var a = 0
    while a <= s.count/2 {
        var x = 0
        var count = 1
        var pre = ""
        var answer = ""
        a += 1
        while x <= s.count {
            let remainder = s.suffix(s.count-x)
            let prefix = remainder.prefix(a)
            if pre == prefix {
                count += 1
                x += a
                continue
            }
            if count > 1 {
                answer += "\(count)\(pre)"
            }
            answer += pre
            pre = String(prefix)
            count = 1
            x += a
        }
        answer += String(s.suffix(s.count-(x-a)))
    }
    return answerarr.min()!
}
http://colorscripter.com/info#e" target="_blank" style="color:#e5e5e5text-decoration:none">Colored by Color Scripter
728x90
๋ฐ˜์‘ํ˜•

๋Œ“๊ธ€