2024. 3. 19. 14:44, ๐กAlgorithm
๋ฐ์ํ
๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/12903
์ ๊ทผ
- s์ ๊ธธ์ด ๋๋๊ธฐ 2๋ฅผ ๋ด๋ฆผํ์ฌ ๋ณ์ x๋ก ์ง์ ํ๊ณ , ์ง์์ธ ๊ฒฝ์ฐ s[x-1], s[x] ์ถ๋ ฅ / ํ์์ธ ๊ฒฝ์ฐ s[x] ์ถ๋ ฅ
- ์์ ๋ฐฉ๋ฒ์ ๊ตฌ์ํ๊ณ ์๋์ ์ฝ๋๋ฅผ ์์ฑํ์ผ๋ ๋ฌธ๋ฒ์ ๋ง์ง ์์ ์ค๋ฅ๊ฐ ๋ฌ๋ค.
๊ตฌ์, ์คํจํ ์ฝ๋
import kotlin.math.*
class Solution {
fun solution(s: String): String {
val x = s.floor(s.length/2)
return if(s.length % 2 == 0) s[x-1] //, s[x]
else s[x]
}
}
- floor() ํจ์์ ์๋ชป๋ ์ฌ์ฉ
์ฃผ์ด์ง ์ฝ๋์์ floor() ํจ์๋ ์๋ชป๋ ์ฉ๋๋ก ์ฌ์ฉ๋์๋ค. floor() ํจ์๋ ์ฃผ์ด์ง ์ซ์ ์ดํ์ ๊ฐ์ฅ ํฐ ์ ์๋ฅผ ๋ฐํํ๋ ํจ์์ด์ง๋ง, ์ฌ๊ธฐ์๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๋ฐ์ผ๋ก ๋๋ ๊ฐ์ ์์์ ์ดํ๋ก ๋ฒ๋ฆฌ๋ ค๋ ์๋๋ก ์ฌ์ฉ๋์๋ค. ํ์ง๋ง Kotlin์ floor() ํจ์๋ ์ค์ํ์ ๋์์ผ๋ก ๋์ํ๊ธฐ ๋๋ฌธ์ ์ด๋ ๊ฒ ์ฌ์ฉํ ์ ์๋ค. - ๋ฐฐ์ด ์์์ ๋ํ ์ ๊ทผ
s๋ ๋ฌธ์์ด์ด๋ฏ๋ก ๋ฐฐ์ด ํํ๋ก ์ง์ ์ ๊ทผํ ์ ์๋ค. ๋ฐ๋ผ์ s[x-1] ๋๋ s[x]์ ๊ฐ์ ํํ๋ก ์ ๊ทผํ ์ ์๋ค. - ์๋ชป๋ ๋ฐํ ํ์
ํจ์์ ๋ฐํ ํ์ ์ String์ผ๋ก ์ ์ธ๋์์ง๋ง, ์กฐ๊ฑด๋ฌธ์์๋ Char ๋๋ String์ด ์๋ ๊ฐ์ ๋ฐํํ๊ณ ์๋ค.
์ฑ๊ณต ์ฝ๋
class Solution {
fun solution(s: String): String {
val x = s.length / 2 //์ ์ ๋๋๊ธฐ ์ ์๋ ์ ์, s์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋
return if(s.length % 2 == 0) s.substring(x-1,x+1) //์ง์: ์ธ๋ฑ์ค x-1๋ถํฐ x+1 ๋ฏธ๋ง๊น์ง ์ถ๋ ฅ (x-1, x)
else s[x].toString() //ํ์: ๊ทธ๋๋ก ์ถ๋ ฅ
}
}
์ค๋ช
- val x = s.length / 2
์ฃผ์ด์ง s์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋ x์ ์ ์ฅํ๋ค. (์ ์ ๋๋๊ธฐ ์ ์์ด๋ฏ๋ก ๋ฐ๋ก ์ฌ๋ฆผ์ด๋ ๋ด๋ฆผ์ฒ๋ฆฌ๋ฅผ ํ ๊ฒ์ด ์๋ค.) - return if(s.length % 2 == 0) s.substring(x-1, x+1)
s์ ๊ธธ์ด๊ฐ ์ง์์ธ ๊ฒฝ์ฐ s์ x-1๋ถํฐ x+1 ๋ฏธ๋ง๊น์ง ๋ฆฌํดํ๋ค. - else s[x].toString()
s์ ๊ธธ์ด๊ฐ ํ์์ธ ๊ฒฝ์ฐ ๊ทธ๋๋ก ์ถ๋ ฅํ๋ค.
๐ก substring()
- ๋ฌธ์์ด์์ ๋ถ๋ถ ๋ฌธ์์ด์ ์ถ์ถํ๋ ๋ฐ ์ฌ์ฉ
- substring(startIndex: Int): ์์ ์ธ๋ฑ์ค๋ถํฐ ๋ฌธ์์ด์ ๋๊น์ง์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํ
- substring(startIndex: Int, endIndex: Int): ์์ ์ธ๋ฑ์ค๋ถํฐ ์ข
๋ฃ ์ธ๋ฑ์ค ์ ๊น์ง์ ๋ถ๋ถ ๋ฌธ์์ด์ ๋ฐํ
์ฐธ๊ณ ๋ก ์์ ์ธ๋ฑ์ค๋ ํฌํจ๋์ง๋ง, ์ข ๋ฃ ์ธ๋ฑ์ค๋ ํฌํจ๋์ง ์๋๋ค. (๋ฏธ๋ง) - ์ฒซ ๋ฒ์งธ ๋ฌธ์์ ์ธ๋ฑ์ค๋ 0
๋ค๋ฅธ ๋ฐฉ๋ฒ
class Solution {
fun solution(s: String) =
with(s) { substring(length / 2 - 1 + (length % 2) .. length / 2) }
}
- with(s)
with()์ Kotlin ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณตํ๋ ํ์ฅ ํจ์ ์ค ํ๋๋ค. ์ด ํจ์๋ ์์ ๊ฐ์ฒด๋ฅผ ์ง์ ํ์ฌ ์์ ๊ฐ์ฒด์ ๋ฒ์ ๋ด์์ ์ฝ๋ ๋ธ๋ก์ ์คํํ ์ ์๊ฒ ํด์ค๋ค. ๊ฐ๋จํ ๋งํด, with ํจ์๋ ํน์ ๊ฐ์ฒด์ ๋ํด ์ํ๋๋ ์์ ์ ๋ธ๋ก ์์์ ์งง๊ฒ ํํํ ์ ์๋๋ก ํด์ค๋ค. with(s)๋ ๋ฌธ์์ด s๋ฅผ ์์ ๊ฐ์ฒด๋ก ์ฌ์ฉํ๊ณ , ์ค๊ดํธ {} ๋ธ๋ก ๋ด์์ s์ ๋ํ ์์ ์ ์ํํ์ฌ ์ฝ๋๋ฅผ ๊ฐ๊ฒฉํ๊ฒ ์์ฑํ ์ ์๋ค. - length / 2
์ฃผ์ด์ง ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์์ด์ ์ค์ ์์น๊ฐ ๋๋ค. - - 1 + (length % 2)
๋ง์ฝ ๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ํ์์ธ ๊ฒฝ์ฐ, ์ค์์ ์๋ ๋ฌธ์์ ์ธ๋ฑ์ค๋ฅผ ์ฐพ๊ธฐ ์ํด 1์ ๋นผ์ค๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ฌธ์์ด์ ์ค์ ์์น๊ฐ ๋๋ค. (์ง์์ ํ์ ๋ชจ๋ ์ฒ๋ฆฌ) - .. length / 2
๋ฌธ์์ด์ ์ค์์ ์์นํ ์ธ๋ฑ์ค๋ถํฐ ๋ฌธ์์ด์ ๋๊น์ง์ ๋ฒ์๋ฅผ ์ง์ ํ๋ค. - ์ด ๋ชจ๋ ๋ฒ์๋ฅผ ์ฌ์ฉํ substring() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ค์์ ์๋ ๋ฌธ์๋ ๋ฌธ์์ด์ ์ถ์ถํ๋ค.
class Solution {
fun solution(s: String) = s.slice(((s.length - 1) / 2)..(s.length / 2))
}
- slice()๋ฅผ ์ด์ฉํ ํ์ด๋ค.
- (s.length - 1) / 2
๋ฌธ์์ด์ ๊ธธ์ด์์ 1์ ๋บ ํ 2๋ก ๋๋๋ค.
๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ํ์์ธ ๊ฒฝ์ฐ ์ค์๊ฐ์ด๋ฉฐ, ์ง์์ธ ๊ฒฝ์ฐ ๋ฌธ์์ด์ ์ค์ ์์น ์ค ์ฒซ ๋ฒ์งธ ๋ฌธ์์ ์ธ๋ฑ์ค๊ฐ ๋๋ค. - s.length / 2
๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ 2๋ก ๋๋๋ค.
๋ฌธ์์ด์ ๊ธธ์ด๊ฐ ํ์์ธ ๊ฒฝ์ฐ ์ค์๊ฐ์ด๋ฉฐ, ์ง์์ธ ๊ฒฝ์ฐ ๋ฌธ์์ด์ ์ค์ ์์น ์ค ๋ ๋ฒ์งธ ๋ฌธ์์ ์ธ๋ฑ์ค๊ฐ ๋๋ค. - s.slice(...)
๋ฌธ์์ด์ ํน์ ๋ฒ์์ ํด๋นํ๋ ๋ถ๋ถ ๋ฌธ์์ด์ ์ถ์ถํ์ฌ ๋ฐํํ๋ค.
๋ฐ์ํ
๐ฌ C O M M E N T