2024. 3. 6. 12:02, ๐กAlgorithm
๋ฐ์ํ
๋ฌธ์
https://school.programmers.co.kr/learn/courses/30/lessons/12934
์ ๊ทผ
- if๋ฌธ์ผ๋ก ๋ถ๊ธฐ ์ฒ๋ฆฌํ๊ณ ์ ๊ณฑ๊ทผ์ ๊ตฌํ๋ ์กฐ๊ฑด๋ง ์ ๊ตฌํ๋ฉด ๋ ๊ฒ ๊ฐ์๋ค.
- ๋์ถฉ ์๋์ ๊ฐ์ ๋๋?
// ๊ตฌ์
class Solution {
fun solution(n: Long): Long {
if(์ ๊ณฑ์์ธ์ง ๊ตฌํ๋ ํ๋ณ ์){
return (x+1)(x+1)
} else {
return -1
}
return 0
}
}
- ์ ๊ณฑ์์ธ์ง ์๋์ง ํ๋ณํ๋ ๋ฐฉ์์ ๋ํ ์๊ฐ์ด ์ค๋ ๊ฑธ๋ ธ๋ค.
- ์ ๊ณฑ๊ทผ์ ๊ตฌํ๋ ํจ์๊ฐ ์์ ๊ฒ ๊ฐ์์ง๋ง, ํ ๋ฒ ๋ด๊ฐ ์๋ ํจ์์ ๋ฌธ๋ฒ์ ํ ๋๋ก ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌ์ฑํ๊ณ ์ถ์๋ค.
- ์กฐ์ ์๋์์ ์ ๊ณฑ์๋ฅผ ๊ตฌํ๋ ๋ฐฉ์ ( 2๋ก ๋๋๊ณ 1๋ถํฐ ์ฐจ๋ก๋๋ก ๋บ ๋ค ์์๊ฐ ๋์ ๋ ์๋ ๋นผ๋ ค๋ ์์ ๋น๊ต)
โ ๋๋ฌด ํ๋ก๊ทธ๋จ์ ๋นํจ์จ์ ์ธ ๊ณ์ฐ์์ผ ๊ฒ ๊ฐ์์ ํจ์ค - i๋ฅผ 1๋ถํฐ (n/2)๊น์ง ๋๋ฆฌ๋ฉด์ ๊ทธ ์์ ์ ๊ณฑ๊ณผ ๋ค์ด์จ n์ ๋น๊ตํ๋ ๋ฐฉ์
โ ์ด๊ฒ๋ ํ๋ก๊ทธ๋จ์ ์์ฒญ ๋นํจ์จ์ ์ธ ๊ณ์ฐ์ ๋ง์ด ํ ๊ฒ ๊ฐ์ - i๋ฅผ 1๋ถํฐ (n/2)๊น์ง ๋๋ฆฌ๋ฉด์ n์ ๊ทธ ์๋ก ๋๋ด์ ๋ i์ธ ๊ฒฝ์ฐ๋ฅผ ์ฐพ๋ ๋ฐฉ์
โ ํ ๋ฒ ์ด ๋ฐฉ์์ ์ ์ฉํด๋ณด๊ธฐ๋ก ์๋ํ๋ค.
// ํ
์คํธ 13, 18 ์คํจ
class Solution {
fun solution(n: Long): Long {
for(i in 1 .. n/2){
if(n / i == i){
return (i+1) * (i+1)
break
}
if (i == n/2) return -1
}
return 0
}
}
// ์ ์ฒด ์ฑ๊ณต, BUT ๋๋ฆผ
class Solution {
fun solution(n: Long): Long {
for (i in 1..n) {
if (i * i == n) {
return (i + 1) * (i + 1)
}
}
return -1
}
}
- ์ฒ์์ Longํ์์ i๊ฐ (i+1)(i+1)์ ์ปดํ์ผ ํ ์ ์์๋๋ฐ, (i+1)*(i+1) ๋ก ์์ ํด์ฃผ์ด์ผ ํ๋ค.
- ์๊ฐ๋ ์ค๋ ๊ฑธ๋ฆด๋ฟ๋๋ฌ, ์ํ๊น๊ฒ๋ ํ ์คํธ 13, ํ ์คํธ 18์์ ์คํจํ๋ค.
- ์ธ ๋ฒ์งธ ๋ฐฉ์์ ๋ฒ๋ฆฌ๊ณ ๋ ๋ฒ์งธ ๋ฐฉ์์ ์ฐจ์ฉํ๋ ํด๊ฒฐ๋์์ง๋ง, ๋๋ฌด ์คํ ์๊ฐ์ด ๋๋ฆฌ๊ณ ๋นํจ์จ์ ์ด์๋ค.
- ๊ทผ๋ณธ์ ์ผ๋ก ์ด๋ ๊ฒ ๋ง๋ ์๋๊ฒ ์์์
์ผ๋ก ๊ณ์ฐํ๋ ๊ฒ ๋ต์ผ๋ฆฌ๋ ์๋ค๋ ์๊ฐ์ด ๋ค์๊ณ ,
ํ์ Float๋ Double๋ก ๋ณํํด์ ์ ๊ณฑ ํจ์์ธ pow()๋ฅผ ์ฌ์ฉํด์ผ ํ์ง ์์๊น... ์ถ๋ค๊ฐ
๊ฒฐ๊ตญ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ์ฐพ์๋ณด๊ฒ ๋์๋ค. - sqrt(sqaure root)์ pow(power)๋ฅผ ์ด์ฉํ ๊ฐ๋จํ ํ์ด์๋ค.
์ฑ๊ณต ์ฝ๋
import kotlin.math.*
class Solution {
fun solution(n: Long): Long {
val a = sqrt(n.toDouble()).toLong()
return if (a * a == n) (a + 1)*(a + 1) else -1
}
}
์ค๋ช
- import kotlin.math.* ๋ฅผ ๋ฃ์ด์ค๋ค.
- ์ ๊ณฑ๊ทผ์ ๊ตฌํ๋ sqrt() ํจ์๋ฅผ ์ด์ฉํ๋ค.
- ์ ๊ณฑ์ ๊ตฌํ๋ pow() ํจ์๋ฅผ ์ด์ฉํ ์๋ ์๋ค.
- ์ฐธ๊ณ ๋ก sqrt(), pow() ์ธ์๋ค๊ณผ ๋ฐํํ์ Double ํ์ด๋ฏ๋ก ์ด์ ์ ์ฌ์ฉํ ๋ ์ฃผ์ํ์ฌ์ผ ํ๋ค.
- toDouble()๋ก ํ๋ณํ์ ํ๊ณ ์ ๊ณฑ๊ทผ์ ๊ตฌํด์ค ๋ค, ๋ค์ ์ ์ํ์ผ๋ก toLong()์ ํ์๋ค.
- ์ ๊ณฑ๊ทผ์ด ์ ์์๋ค๋ฉด a * a == n ์ด ๋์ด ๋ต์ด ์ ์์ ์ผ๋ก ์ถ๋ ฅ๋๊ณ , ์๋๋ฉด -1์ด ์ถ๋ ฅ๋๋ค.
๋ค๋ฅธ ๋ฐฉ๋ฒ
import kotlin.math.*
class Solution {
fun solution(n: Long): Long {
val sqrt = sqrt(n.toDouble())
return if(sqrt % 1.0 == 0.0) {
(sqrt + 1).pow(2.0).toLong()
} else {
-1
}
}
}
- ํ์ด ์ฝ๋์ ๋ฌ๋ฆฌ sqrt()์ pow()๋ฅผ ๋ชจ๋ ์ด ์ฝ๋์ด๋ค.
- sqrt๋ฅผ 1.0์ผ๋ก ๋๋ด์ ๋ ๋๋จธ์ง๊ฐ ์๋ค๋ฉด ๋ฌธ์ ์์ ์ํ๋ ์ ์ ์ ๊ณฑ๊ทผ์ ๊ฐ์ง ์์ด๋ค.
๋ฐ์ํ
๐ฌ C O M M E N T