๋ฌธ์ ์ค๋ช
๋ ์ ์ a, b๊ฐ ์ฃผ์ด์ก์ ๋ a์ b ์ฌ์ด์ ์ํ ๋ชจ๋ ์ ์์ ํฉ์ ๋ฆฌํดํ๋ ํจ์, solution์ ์์ฑํ์ธ์.
์๋ฅผ ๋ค์ด a = 3, b = 5์ธ ๊ฒฝ์ฐ, 3 + 4 + 5 = 12์ด๋ฏ๋ก 12๋ฅผ ๋ฆฌํดํฉ๋๋ค.
์ ํ ์กฐ๊ฑด
- a์ b๊ฐ ๊ฐ์ ๊ฒฝ์ฐ๋ ๋ ์ค ์๋ฌด ์๋ ๋ฆฌํดํ์ธ์.
- a์ b๋ -10,000,000 ์ด์ 10,000,000 ์ดํ์ธ ์ ์์ ๋๋ค.
- a์ b์ ๋์๊ด๊ณ๋ ์ ํด์ ธ์์ง ์์ต๋๋ค.
์ ์ถ๋ ฅ ์
a | b | return |
3 | 5 | 12 |
3 | 3 | 3 |
5 | 3 | 12 |
๋ด ๋ฌธ์ ํ์ด
func solution(_ a:Int, _ b:Int) -> Int64 {
let largeN : Int
let smallN : Int
var result = 0
if a > b {
largeN = a
smallN = b
}
else if b > a {
largeN = b
smallN = a
}
else {
return Int64(a)
}
for i in smallN...largeN {
result += i
}
return Int64(result)
}
- ์ ๋ ฅ ๋ฐ์ ๋ ์์ค ๋ ํฐ ์์ ์์ ์๋ฅผ ํ๋ณํด์ฃผ์๊ณ , ๋ ์๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ๋ฐ๋ก a๋ฅผ ์ถ๋ ฅ, ๊ฐ์ง ์์ ๋๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์์ ์๋ถํฐ ํฐ ์๊น์ง ๋์ ํ์ฌ ์ถ๋ ฅํด์ฃผ์๋ค.
์ธ์์ ์ธ ํ์ด
func solution(_ a:Int, _ b:Int) -> Int64 {
return Array((a < b) ? a...b : b...a).reduce(0, +)
}
- Array, reduce ์ด์ฉํด์ ํผ ํ์ด๋ฅผ ๋ฐ๊ฒฌํ๋ค,,! ์์ ๊น๋ํ๋ค,,
- ๊ทผ๋ฐ ๋ง์ ๋๋ ค๋ณด๋๊น ๋ฐํ์ ์๋ฌ ์๋ฉ,,ใ ๋ฐฐ์ด์ ์์ฑํด์ ํ๋ค๋ ๊ฒ ์์ฒด๊ฐ ์๊ฐ์ ๋๋ฌด ๋ง์ด ์ก์๋จน๋ ๋ฏ ํ๋ค.
- ๊ทธ๋๋ Array ์ฌ์ฉํด์ ๋ง๋ ์์ด ๋ฐฐ์ธ ์ ์ด ๋ง์ ๊ฒ ๊ฐ์ ๊ฐ์ ธ์๋ดค๋ค.
๐ก ํผ๋๋ฐฑ
- ์ฝ๋๊ฐ ์กฐ๊ธ ๊ฐ๊ฒฐํ์ง ๋ชปํ ๊ฒ ๊ฐ์์,, ๋ ์ข์ ๋ฐฉ๋ฒ์ ์ฐพ์๋ด์ผ๊ฒ ๋ค.!
๐ [ ์ถ๊ฐ ] 1์ฃผ์ผ ํ ๋ค์ ํ์ด๋ณด๊ธฐ
func solution(_ a:Int, _ b:Int) -> Int64 {
var result = 0
if a > b {
for i in b...a {
result += i
}
}
else {
for i in a...b {
result += i
}
}
return Int64(result)
}
- a > b์ผ ๊ฒฝ์ฐ, ๋ฐ๋์ผ ๊ฒฝ์ฐ๋ฅผ ๋๋ ์ ๊ณ์ฐํด์คฌ๊ณ , for๋ฌธ์ผ๋ก ๋์ ํ ๊ฐ์ ๊ตฌํด์คฌ๋ค.
- ์ฒซ ๋ฒ์งธ ํ์ด๋ณด๋ค ํจ์ฌ ๊ฐ๊ฒฐํ๊ณ ๊ฐ๋ ์ฑ ์ธก๋ฉด์์๋ ์ข์ ๋ฏ ํ๋ค!
โ๐ [ ๋! ์ถ๊ฐ ] 1์ฃผ์ผ ํ ๋ ๋ค์ ํ์ด๋ณด๊ธฐ
func solution(_ a:Int, _ b:Int) -> Int64 {
var sum = 0
for i in (a > b ? b...a : a...b) { sum += i }
return Int64(sum)
}
- ์ง์ง 200๋ฐฐ ๊น๋ํด์ก๋ค..ใ ๊ฐ๊ฒฉ
- for๋ฌธ์์ ๋ฒ์๋ก ์กฐ๊ฑด์์ ์ ์ ์ ์๋ค๋ ๊ฒ์ ์ค๋ ์๊ฒ ๋์ด์,, ํ๋ฒ ํ์ฉํด๋ดค๋ค.!
๋ฌธ์
๋๊ธ