Problem
Solution
1. a์ ์๋ ์ซ์๋ค์ ๊ฐฏ์๋ฅผ ์ธ์ค๋ค.
์ซ์๋ค์ ๊ฐฏ์๋ฅผ ์ธ์ฃผ๋ ์ด์ ๋ ๊ฐฏ์๊ฐ ๋ง์ ์ซ์๋ก ์ ๋ ฌํ์ฌ ์๊ฐ ์ด๊ณผ๋ฅผ ๋ง๊ธฐ ์ํด์ ์ ๋๋ค.
func countNumbers(a:[Int]) -> [Int:Int] {
var countDic:[Int:Int] = [:]
for n in a {
if countDic[n] == nil {
countDic[n] = 1
}else {
countDic[n]! += 1
}
}
return countDic
}
2. ๊ฐ ์ซ์๋ค์ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ์์ด ๊ธธ์ด๋ฅผ ๊ตฌํด์ค๋ค.
๊ฐ๋จํ๊ฒ ์ค๋ช ํ๋ฉด ๊ฐ ์ซ์๋ค์ ์ ๋ค๋ฅผ ๋น๊ตํด์ค๋๋ค.
๋ง์ฝ ์๊ณผ ๋ค ์ค ํ๋๋ผ๋ ํ์ฌ ์ซ์์ ๊ฐ์ง ์์ ์ซ์๊ฐ ์๋ค๋ฉด +2 ํด์ค๋๋ค.
๊ทธ ๋ค์ ํด๋น ์ซ์๋ฅผ ํ์ฌ ์ซ์๋ก ๋ฐ๊ฟ์ค๋๋ค.
func findLongSubsequence(n:Int,a:[Int]) -> Int {
var numbers = a
var length:Int = 0
if a[0] == n && a[1] != n {
length += 2
numbers[1] = n
}
for i in 1..<numbers.count-1 {
if a[i] == n {
if numbers[i-1] != n {
numbers[i-1] = n
length += 2
}else if numbers[i+1] != n {
numbers[i+1] = n
length += 2
}
}
}
if numbers[a.count-1] == n && numbers[a.count-2] != n {
length += 2
}
return length
}
3. ๊ฐ ์ซ์๋ค์ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ์์ด ๊ธธ์ด ์ค ๊ฐ์ฅ ๊ธด ๊ฒ์ ๋ฐํํ๋ค.
์๊ฐ ์ด๊ณผ๋ฅผ ๋ง๊ธฐ ์ํด ์ซ์์ ๊ฐฏ์๊ฐ ๋ ๋ง์ ๊ฒ์ผ๋ก ์ ๋ ฌํ ๋ค์ ์ํ์ ์งํํฉ๋๋ค.
๋ง์ฝ answer๋ณด๋ค ์ซ์์ ๊ฐฏ์ * 2๊ฐ ๋ ์๋ค๋ฉด answer๋ณด๋ค ๋ ํด ์๊ฐ ์์ผ๋ฏ๋ก ๋ค์์ผ๋ก ๋์ด๊ฐ์ค๋๋ค.
func findMaxLength(a:[Int]) -> Int {
var answer:Int = 0
let sortCounts = countNumbers(a: a).sorted{$0.value > $1.value}
for dic in sortCounts {
if dic.value * 2 < answer { continue }
let length = findLongSubsequence(n:dic.key, a:a)
answer = max(answer,length)
}
return answer
}
Source Code
P.S
์ฒ์์ ๊ฐ์ฅ ์ซ์์ ๊ฐฏ์๊ฐ ๋ง์ ๊ฒ์ ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ์์ด์ ์ฐพ์์ ๋ฐํํ๋ค.
๊ทผ๋ฐ ๊ณ์ ํ ์คํธ ์ผ์ด์ค 28๋ฒ์ด ํ๋ ธ๋ค...
๊ทธ๋์ ์ง๋ฌธํ๊ธฐ๋ฅผ ํตํด ๋ดค๋๋ ๋ง์ฝ ์ด๋ ๊ฒ a๊ฐ ์ฃผ์ด์ก์๊ฒฝ์ฐ -> [4, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 1, 0, 3]
1์ด ๊ฐ์ฅ ๋ง์ง๋ง ๊ฐ์ฅ ๊ธด ๋ถ๋ถ ์์ด์ 0์ ์ด์ฉํด์ ๋ง๋ค์ด์ผ ํ๋ค...
๊ทธ๋์ ๊ฒฐ๊ตญ ๋ชจ๋ ์ซ์๋ฅผ ํ์ธํด๋ด์ผ ํ์๋ค..
๋๊ธ