2024. 4. 15. 10:54, ๐กAlgorithm
๋ฐ์ํ
๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/12930
์ ๊ทผ
- 1. ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋จ์ด๋ฅผ ๋๋์ด ์ ์ฅํ๋ค. : split(" ").map { it }
- 2. ๋๋์ด์ง ๋จ์ด๋ง๋ค ์ง์ ์ธ๋ฑ์ค๋ ๋๋ฌธ์๋ก ๋ณํํ๋ ์กฐ๊ฑด์์ ์์ฑํ๋ค. : toUpperCase(), toLowerCase()
- 3. ๋ณํ๋ ๋จ์ด๋ฅผ ๋ค์ ๊ณต๋ฐฑ์ ๋ฃ์ด ํฉ์ณ ๋ฆฌํดํ๋ค.
- ์ฌ๊ธฐ์์ ์๋ฌธ์ ์ 1๋ฒ์์ ๋๋์ด์ง ๋จ์ด๊ฐ ์ด ๋ช ๊ฐ์ธ์ค ์๊ณ ๋ฐฐ์ด์ ๋ฏธ๋ฆฌ ์ ์ธํ๋จ ๋ง์ธ๊ฐ?
๊ทธ๋ฆฌ๊ณ 3๋ฒ์์ ๋ค์ ๊ทธ ๊ฐ์๋งํผ ๊ณต๋ฐฑ์ ๋ฃ์ด ์ด๋ป๊ฒ ํฉ์น๋จ ๋ง์ธ๊ฐ?
์ฑ๊ณต ์ฝ๋
class Solution {
fun solution(s: String): String =
s.split(" ").joinToString(" ") {
it.mapIndexed { i, c ->
when (i % 2) {
0 -> c.toUpperCase()
else -> c.toLowerCase()
}
}.joinToString("")
}
}
์ค๋ช
- s.split(" ").joinToString(" ")
- split()์ ์ด์ฉํ์ฌ ๊ณต๋ฐฑ ๋จ์๋ก ๋จ์ด๋ฅผ ๋์ด์ ๊ฐ ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
- joinToString์ผ๋ก split์ด ๋ง๋ ๋ฐฐ์ด์ ๋ฌธ์์ด๋ก ๋ฐ๊พธ์ด์ค๋ค.
- joinToString() ๊ดํธ ๋ถ๋ถ์ separator ๋ก ์ฌ๊ธฐ์ ๊ตฌ๋ถ์๋ฅผ ์ ํด์ค ์ ์๋ค. - it.mapIndexed { i, c -> ... }.joinToString("")
- 1๋ก ๊ตฌ๋ถ๋ ๊ฐ๊ฐ์ ๋ฐฐ์ด(it) ๋ง๋ค mapIndexed๋ฅผ ์ฌ์ฉํ์ฌ, ์ง์์ธ๋ฑ์ค๋ ๋๋ฌธ์, ํ์์ธ๋ฑ์ค๋ ์๋ฌธ์๋ก ๋ง๋ ๋ค.
- mapIndexed ํจ์๋ ๋ฌธ์์ด์ ๊ฐ ๋ฌธ์์ ๋ํด ์ธ๋ฑ์ค์ ๋ฌธ์๋ฅผ ์ ๋ ฅ์ผ๋ก ๋ฐ์ ํจ์๋ฅผ ์ ์ฉํ๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์๋ก์ด ๋ฆฌ์คํธ๋ก ๋ฐํํ๋ฏ๋ก ๋ค์ joinToString("") ์ผ๋ก ๋ค์ ์ด์ด์ค๋ค.
๐กsplit
- ๊ดํธ์์ ๊ตฌ๋ถ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ฌธ์์ด์ ๋ถ๋ฆฌํ์ฌ ๋ฐฐ์ด๋ก ๋ฐํํ๋ ํจ์
- ์ฃผ์ด์ง ๋ฌธ์์ด์ ํน์ ๊ตฌ๋ถ์๋ฅผ ๊ธฐ์ค์ผ๋ก ๋๋๊ณ ๊ฐ๊ฐ์ ๋ถ๋ถ์ ๋ฐฐ์ด์ ์ ์ฅํ๋ ๊ฒ์ด๋ผ๊ณ ํ ์ ์์
val str = "apple banana orange"
val parts = str.split(" ")
println(parts) // [apple, banana, orange]
- ์ ์์์์๋ str ๋ฌธ์์ด์ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋๋์ด parts ๋ฐฐ์ด์ ์ ์ฅํจ
- ๊ฒฐ๊ณผ์ ์ผ๋ก parts ๋ฐฐ์ด์๋ "apple", "banana", "orange" ์ธ ๊ฐ์ ๋ฌธ์์ด์ด ๋ค์ด์์
val str = "apple,banana,orange,grape"
val fruits = str.split(",", limit = 2)
println(fruits) // [apple, banana, orange, grape]
- split ํจ์์ ๋ ๋ฒ์งธ ์ธ์๋ก๋ ์ ํ๋ ๊ฐ์์ ๋ถ๋ฆฌ๋ฅผ ์ง์ ํ ์ ์์ผ๋ฉฐ, ์ด๋ฅผ ํตํด ๋๋ ๋ฌธ์์ด์ ์ต๋ ๊ฐ์๋ฅผ ์ง์
- ์ ์์์์๋ limit ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ์ฌ ์ต๋ ๋ ๊ฐ์ ๋ถ๋ถ์ผ๋ก ๋ฌธ์์ด์ ๋ถ๋ฆฌ
- ๊ฒฐ๊ณผ์ ์ผ๋ก fruits ๋ฐฐ์ด์๋ "apple", "banana,orange,grape" ๋ ๊ฐ์ ๋ฌธ์์ด์ด ๋ค์ด์์
๐กtoLowerCase(), toUpperCase()
val str = "Hello, World!"
val lowerCaseStr = str.toLowerCase()
println(lowerCaseStr) // ์ถ๋ ฅ: hello, world!
val upperCaseStr = str.toUpperCase()
println(upperCaseStr) // ์ถ๋ ฅ: HELLO, WORLD!
- ๋ฌธ์์ด์ ๋์๋ฌธ์๋ฅผ ๋ณํ
- ์ด ๋ฉ์๋๋ค์ ๋ฌธ์์ด์ ๋ณ๊ฒฝํ์ง ์๊ณ ์๋ก์ด ๋ฌธ์์ด์ ๋ฐํํ๊ธฐ ๋๋ฌธ์, ์๋ณธ ๋ฌธ์์ด์ ๊ทธ๋๋ก ์ ์ง๋จ
๐กmapIndexed()
fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
val list = listOf("apple", "banana", "orange")
// ๊ฐ ์์์ ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฌธ์์ด์ ๊ธธ์ด์ ํจ๊ป ๋ฌธ์์ด์ ๋ณํ
val result = list.mapIndexed { index, element ->
"$index: ${element.toUpperCase()}(${element.length})"
}
println(result) // ์ถ๋ ฅ: [0: APPLE(5), 1: BANANA(6), 2: ORANGE(6)]
- ์ปฌ๋ ์ ์ ๊ฐ ์์์ ๋ํด ์ธ๋ฑ์ค์ ํจ๊ป ์์ ํ ์ ์๋๋ก ํด์ฃผ๋ ํจ์
- ๊ฐ ์์์ ๋ํด ์ธ๋ฑ์ค๋ฅผ ํฌํจํ์ฌ ์ง์ ๋ ๋ณํ ํจ์๋ฅผ ์ ์ฉํ ์ ์์
- ๋งค๊ฐ๋ณ์(transfrom): ์์์ ์ธ๋ฑ์ค์ ๋ํด ์ ์ฉํ ๋ณํ ํจ์. ์ธ๋ฑ์ค์ ์์๋ฅผ ๋งค๊ฐ๋ณ์๋ก ๋ฐ๊ณ ๋ณํ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํ
- ๋ฐํ๊ฐ: ๋ณํ๋ ์์๋ก ์ด๋ฃจ์ด์ง ์๋ก์ด ๋ฆฌ์คํธ์ ์ ์ฅ๋์ด ๋ฐํ
๋ค๋ฅธ ๋ฐฉ๋ฒ
class Solution {
fun solution(s: String): String {
var answer = ""
var idxInWord = 0
for (c in s) {
if (c==' ') {
answer += " "
idxInWord = 0
} else {
idxInWord++
if (idxInWord%2 != 0) {
answer += c.toUpperCase()
} else {
answer += c.toLowerCase()
}
}
}
return answer
}
}
- mapIndexed() ๋ฑ์ ๊ฐ๋ ์ด ์์ ๋, ๋ด๊ฐ ๊ตฌ์ํ๋ ์๊ณ ๋ฆฌ์ฆ๊ณผ ๊ฐ์ด ํ์ดํ๋ ๋ฐฉ์์ด๋ค.
- for๋ฌธ์ผ๋ก (c in s) ์กฐ๊ฑด์ ์
๋ ฅํ์ฌ s๊ฐ ์ด๋ ๊ธธ์ด์ ๋จ์ด์ธ์ง ์ ์ ์์ด๋ ๊ตฌํํ ์ ์๋ค.
์ ๋ ๊ฒ ๊ตฌํํ๋ฉด ์คํธ๋ง s ์์ ์๋ char ํ๋ํ๋๊ฐ ๊บผ๋ด์ง๋ค.
๋ฐ์ํ
๐ฌ C O M M E N T