[๋ฐฑ์ค 23972] ์ ๋ง์ ์ ์ (Swift)
์ ๋ง์๊ฒ K์์ ์ง๋ถํ์ ๋, ์ง๋ถํ๊ณ ๋จ์ ๊ธ์ก์ N๋ฐฐ๋ก ๋ง๋ค์ด ์ค๋ค.
์ด๋ ์ต์ ์ผ๋ง๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ์ํด๋ฅผ ๋ณด์ง ์๋์ง ์๊ณ ์ถ๋ค.
K์ N์ด ์ฃผ์ด์ก์ ๋, ์ํด๋ฅผ ๋ณด์ง ์๊ธฐ ์ํด ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ ์ต์ ๊ธ์ก X๋ฅผ ์ถ๋ ฅํ๋ค.
๋จ, ํญ์ ๋ฏผ์ฃผ๊ฐ ์ํด๋ฅผ ๋ณด๊ฒ ๋๋ค๋ฉด -1์ ์ถ๋ ฅํ๋ค.
- K, N, X๋ ์ ์์ฌ์ผ ํ๋ค.
- 1 โค K, N โค 200,000,000
ํ์ด
๋ฐฉ์ ์๊น์ง๋ ๋์ถํ๋๋ฐ ๋ฐ๋ก๋ฅผ ํต๊ณผํ์ง ๋ชปํด์ ๋ค๋ฅธ ์ฌ๋๋ค์ ํ์ด๋ฅผ ๋ณด๊ณ ํ์๋ค.ใ
์๋ ๋์ด X๋ผ๊ณ ํ๋ค๋ฉด, ๋ฌธ์ ์ ์กฐ๊ฑด๋๋ก ์์ ์์ฑํ์ ๋
(X - K) * N
์ด ๋๊ณ , ์ด ๊ธ์ก์ด ์๋์ ๋ X๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์์ผ ํ๋ค.
๋ฐ๋ผ์ (X - K) * N = X
์ X๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
์ ์์ X๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ฆฌํ๋ฉด X = (N * K) / (N - 1)
์ด ๋๋ค. N๊ณผ K๋ ๋ฌธ์ ์์ ์ฃผ์ด์ง๋ฏ๋ก ์ฝ๊ฒ ๊ตฌํ ์ ์๋ค.
์ด๋ X์ ์์์ ์ดํ ๊ฐ์ด ์๊ธฐ๋ฉด, X๋ ์ ์์ฌ์ผ ํ๋ค๋ ์กฐ๊ฑด ๋๋ฌธ์ ๊ฐ์ ์ฌ๋ฆผํด ์ฃผ์ด์ผ ํ๋ค.
๋ฐ๋ผ์ Swift์์๋ (N * K) % (N - 1)
์ ๊ฐ์ด 0์ด ์๋ ๋, X์ 1์ ๋ํด ์ฃผ๋ ์์ผ๋ก ์ฒ๋ฆฌํ๋ค.
๋ง์ง๋ง์ผ๋ก โํญ์ ์ํด๋ฅผ ๋ณด๊ฒ ๋๋ ๊ฒฝ์ฐโ ๋ N = 1 ์ผ ๋์ด๋ค. (= ๊ทธ๋ฅ ์ ๋ง์๊ฒ ๊ธฐ๋ถํ๋ ๊ฒฝ์ฐ..)
N์ด ์ ์์ด๊ณ 1 ์ด์์ ๊ฐ์ด๋ฏ๋ก, 1์ธ ๊ฒฝ์ฐ๋ง ์์ธ์ฒ๋ฆฌ๋ฅผ ํด์ฃผ๋ฉด ๋๋จธ์ง ๊ฒฝ์ฐ๋ X์ด์์ ์ต์๊ธ์ก๋ง ๊ฐ์ง๊ณ ์๋ค๋ฉด ํญ์ ์ด๋์ ๋ณด๊ฒ ๋๋ค.
๋ฐ๋ผ์ N์ด 1์ผ ๋๋ ๋ฐฉ์ ์ ๊ณ์ฐ ์์ด ๊ทธ๋ฅ -1์ ์ถ๋ ฅํ๋๋ก ์กฐ์นํด ์ค๋ค.
let inputArr = readLine()!.split(separator: " ").map { Int($0)! }
let k = inputArr[0]
let n = inputArr[1]
var answer = 0
if n == 1 {
answer = -1
} else {
answer = (n * k) / (n - 1)
if (n * k) % (n - 1) != 0 {
answer += 1
}
}
print(answer)
๋ฐ๋ก : K = N = 10 ์ผ ๋์ ๊ฐ์ด, K์ N์ด ๊ฐ์ ๊ฒฝ์ฐ. ๊ทธ๋ฆฌ๊ณ N์ด 1์ธ ๊ฒฝ์ฐ.
์ฒ์ ๊ณ์ฐํ ๋์๋ ๋๋์ ์ ์์์ ์ดํ ์๋ฆฌ์๊ฐ ์๊ธฐ๋ ๊ฒ ๋๋ฌธ์ Int๊ฐ ์๋ Double๋ก ๋ค๋ฃจ๋ ค๊ณ ํ๋๋ฐ, ์ฌ๊ธฐ์ ๋ง์ด ํค๋ฉจ๋ค.
๊ทธ๋ฆฌ๊ณ ํญ์ ์ํด๋ฅผ ๋ณด๊ฒ ๋๋ ๊ฒฝ์ฐ๊ฐ ์ด๋ค ๊ฒฝ์ฐ์ธ์ง ๋ ์ฌ๋ฆฌ์ง ๋ชปํด์ ๊ฒฐ๊ตญ ๋ต์ ๋ณด๊ฒ ๋ ๊ฒ ๊ฐ๋ค.
์ญ์ ๋ฌธ์ ์ ์กฐ๊ฑด์ ์ ์ฝ์ด์ผ๊ฒ ๋ค๊ณ ์๊ฐํ๋ค๐ฅฒโผ๏ธ