6077๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ง์ ํฉ ๊ตฌํ๊ธฐ
์ ์(1 ~ 100) 1๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ 1๋ถํฐ ๊ทธ ์๊น์ง ์ง์์ ํฉ์ ๊ตฌํด๋ณด์.
n = int(input())
sum = 0
for i in range(2, n+1):
if i % 2 == 0:
sum += i
print(sum)
6078๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ํ๋ ๋ฌธ์๊ฐ ์ ๋ ฅ๋ ๋๊น์ง ๋ฐ๋ณต ์ถ๋ ฅํ๊ธฐ
์๋ฌธ ์๋ฌธ์ 'q'๊ฐ ์ ๋ ฅ๋ ๋๊น์ง ์ ๋ ฅํ ๋ฌธ์๋ฅผ ๊ณ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
while(True):
c = input()
print(c)
if c == 'q':
break
6079๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ธ์ ๊น์ง ๋ํด์ผ ํ ๊น?
1, 2, 3 ... ์ ๊ณ์ ๋ํด ๋๊ฐ ๋,
๊ทธ ํฉ์ด ์
๋ ฅํ ์ ์(0 ~ 1000)๋ณด๋ค ๊ฐ๊ฑฐ๋ ์์ ๋๊น์ง๋ง ๊ณ์ ๋ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ฆ, 1๋ถํฐ n๊น์ง ์ ์๋ฅผ ๊ณ์ ๋ํด ๋๊ฐ๋ค๊ณ ํ ๋,
์ด๋๊น์ง ๋ํด์ผ ์ ๋ ฅํ ์๋ณด๋ค ๊ฐ๊ฑฐ๋ ์ปค์ง๋ ์ง๋ฅผ ์์๋ณด๊ณ ์ํ๋ ๋ฌธ์ ์ด๋ค.
n = int(input())
sum = 0
k = 1
while sum < n:
sum += k
k += 1
print(k-1)
6080๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ฃผ์ฌ์ 2๊ฐ ๋์ง๊ธฐ
1๋ถํฐ n๊น์ง, 1๋ถํฐ m๊น์ง ์ซ์๊ฐ ์ ํ ์๋ก ๋ค๋ฅธ ์ฃผ์ฌ์ 2๊ฐ๋ฅผ ๋์ก์ ๋,
๋์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ถ๋ ฅํด๋ณด์.
n, m = map(int, input().split())
for i in range(1, n+1):
for j in range(1, m+1):
print(i, j)
6081๋ฒ : [๊ธฐ์ด-์ข ํฉ] 16์ง์ ๊ตฌ๊ตฌ๋จ ์ถ๋ ฅํ๊ธฐ
16์ง์(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F)๋ฅผ ๋ฐฐ์ด ์์ผ์ด๋ 16์ง์๋ผ๋ฆฌ ๊ณฑํ๋ 16์ง์ ๊ตฌ๊ตฌ๋จ?์ ๋ํด์ ๊ถ๊ธํด์ก๋ค.
A, B, C, D, E, F ์ค ํ๋๊ฐ ์
๋ ฅ๋ ๋, 1๋ถํฐ F๊น์ง ๊ณฑํ 16์ง์ ๊ตฌ๊ตฌ๋จ์ ๋ด์ฉ์ ์ถ๋ ฅํด๋ณด์. (๋จ, A ~ F ๊น์ง๋ง ์
๋ ฅ๋๋ค.)
n = int(input(), 16)
for i in range(1, 16):
print("%X" % n, "*", "%X" % i, "=", "%X" % (n*i), sep="")
6082๋ฒ : [๊ธฐ์ด-์ข ํฉ] 3 6 9 ๊ฒ์์ ์์ด ๋์
์น๊ตฌ๋ค๊ณผ ํจ๊ป 3 6 9 ๊ฒ์์ ํ๋ ์์ผ์ด๋ ์ฆ์ ์ค์ ๋๋ฌธ์ ๊ณ์ํด์ ๋ฒ์น์ ๋ฐ๊ฒ ๋์๋ค.
3 6 9 ๊ฒ์์ ์์ด ๋๊ธฐ ์ํ 369 ๋ง์คํฐ ํ๋ก๊ทธ๋จ์ ์์ฑํด ๋ณด์.
- 3 6 9 ๊ฒ์์?
์ฌ๋ฌ ์ฌ๋์ด ์์๋ฅผ ์ ํ ํ, ์์๋๋ก ์๋ฅผ ๋ถ๋ฅด๋ ๊ฒ์์ด๋ค.
๋ง์ฝ 3, 6, 9 ๊ฐ ๋ค์ด๊ฐ ์๋ฅผ ์์ ์ด ๋ถ๋ฌ์ผ ํ๋ ์ํฉ์ด๋ผ๋ฉด, ์๋ฅผ ๋ถ๋ฅด๋ ๋์ "๋ฐ์(X)" ๋ฅผ ์ณ์ผ ํ๋ค.
33๊ณผ ๊ฐ์ด 3,6,9๊ฐ ๋ ๋ฒ ๋ค์ด๊ฐ ์ ์ผ๋, "์ง์ง"๊ณผ ๊ฐ์ด ๋ฐ์๋ฅผ ๋ ๋ฒ ์น๋ ํํ๋ ์๋ค.
n = int(input())
for i in range(1, n+1):
if (i % 10 == 3) or (i % 10 == 6) or (i % 10 == 9):
print("X", end=' ')
else:
print(i, end=' ')
# end=' ' : ์ถ๋ ฅ ํ ๊ณต๋ฐฑ๋ฌธ์(๋น์นธ, ' ')๋ก ๋๋
6083๋ฒ : [๊ธฐ์ด-์ข ํฉ] ๋น ์์ด ์ ๋ง๋ค๊ธฐ
๋นจ๊ฐ(red), ์ด๋ก(green), ํ๋(blue) ๋น์ ์์ด ์ฌ๋ฌ ๊ฐ์ง ๋ค๋ฅธ ์ ๋น์ ๋ง๋ค์ด ๋ด๋ ค๊ณ ํ๋ค.
๋นจ๊ฐ(r), ์ด๋ก(g), ํ๋(b) ๊ฐ ๋น์ ๊ฐ์ง์๊ฐ ์ฃผ์ด์ง ๋,
์ฃผ์ด์ง rgb ๋น๋ค์ ์์ด ๋ง๋ค ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์กฐํฉ(r g b)๊ณผ ๋ง๋ค ์ ์๋ ์์ ๊ฐ์ง ์๋ฅผ ๊ณ์ฐํด๋ณด์.
r, g, b = map(int, input().split())
count = 0
for i in range(0, r):
for j in range(0, g):
for k in range(0, b):
print(i, j, k)
count += 1
print(count)
6084๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์๋ฆฌ ํ์ผ ์ ์ฅ์ฉ๋ ๊ณ์ฐํ๊ธฐ
๋ น์ํ ์๊ฐ(์ด) s๊ฐ ์ฃผ์ด์ง ๋, ํ์ํ ์ ์ฅ ์ฉ๋์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์๋ฆฌ๊ฐ ์ปดํจํฐ์ ์ ์ฅ๋ ๋์๋ ๋์งํธ ๋ฐ์ดํฐํ ๋์ด ์ ์ฅ๋๋ค.
๋ง์ดํฌ๋ฅผ ํตํด 1์ด์ ์ ๊ฒ๋ ์์ญ ๋ฒ, ๋ง๊ฒ๋ ์๋ง ๋ฒ ์๋ฆฌ์ ๊ฐ์ฝ์ ์ฒดํฌํ๊ณ ,
ํ ๋ฒ์ฉ ์ฒดํฌํ ๋ ๋ง๋ค ๊ทธ ๊ฐ์ ์ ์๊ฐ์ผ๋ก ๋ฐ๊พธ์ด ์ ์ฅํ๋ ๋ฐฉ์์ผ๋ก ์๋ฆฌ๋ฅผ ํ์ผ๋ก ์ ์ฅํ ์ ์๋ค.
๊ฐ์ ์ ์ฅํ ๋์๋ ๋นํธ๋ฅผ ์ฌ์ฉํ๋ ์ ๋์ ๋ฐ๋ผ ์ธ์ธํ ๋
น์ ์ ๋๋ฅผ ๊ฒฐ์ ํ ์ ์๊ณ ,
์ข์ฐ(์คํ
๋ ์ค) ์ฑ๋๋ก ์ ์ฅํ๋ฉด 2๋ฐฐ… 5.1์ฑ๋์ด๋ฉด 6๋ฐฐ์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๊ณ ,
๋
น์ ์๊ฐ์ด ๊ธธ๋ฉด ๊ทธ ๋งํผ ๋ ๋ง์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ค.
1์ด ๋์ ๋ง์ดํฌ๋ก ์๋ฆฌ๊ฐ์ฝ์ ์ฒดํฌํ๋ ํ์๋ฅผ h
(ํค๋ฅด์ฏ, Hz ๋ 1์ด์ ๋ช ๋ฒ? ์ฒดํฌํ๋๊ฐ๋ฅผ ์๋ฏธํ๋ค.)
ํ ๋ฒ ์ฒดํฌํ ๊ฐ์ ์ ์ฅํ ๋ ์ฌ์ฉํ๋ ๋นํธ์๋ฅผ b
(2๋นํธ๋ฅผ ์ฌ์ฉํ๋ฉด 0 ๋๋ 1 ๋ ๊ฐ์ง, 16๋นํธ๋ฅผ ์ฌ์ฉํ๋ฉด 65536๊ฐ์ง..)
์ข์ฐ ๋ฑ ์๋ฆฌ๋ฅผ ์ ์ฅํ ํธ๋ ๊ฐ์์ธ ์ฑ๋ ๊ฐ์๋ฅผ c
(๋ชจ๋
ธ๋ 1๊ฐ, ์คํ
๋ ์ค๋ 2๊ฐ์ ํธ๋์ผ๋ก ์ ์ฅํจ์ ์๋ฏธํ๋ค.)
์ค์ ๋ก, ์ผ๋ฐ์ ์ธ CD ์์ง(44.1KHz, 16bit, ์คํ
๋ ์ค)๋ก 1์ด ๋์ ์ ์ฅํ๋ ค๋ฉด
44100 * 16 * 2 * 1 bit์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ฐ,
44100*16*2*1/8/1024/1024 ๋ก ๊ณ์ฐํ๋ฉด ์ฝ 0.168 MB ์ ๋๊ฐ ํ์ํ๋ค.
์ด๋ ๊ฒ ๋
น์ํ๋ ๋ฐฉ์์ PCM(Pulse Code Modulation) ๋ฐฉ๋ฒ์ด๋ผ๊ณ ํ๋๋ฐ,
์์ถํ์ง ์์ ์์ํ(raw) ์๋ฆฌ ๋ฐ์ดํฐ ํ์ผ์ ๋ํ์ ์ผ๋ก *.wav ๊ฐ ์๋ค.
**
8 bit(๋นํธ) = 1byte(๋ฐ์ดํธ) # 8bit=1Byte
1024 Byte(210 byte) = 1KB(ํฌ๋ก ๋ฐ์ดํธ) # 1024Byte=1KB
1024 KB(210 KB) = 1MB(๋ฉ๊ฐ ๋ฐ์ดํธ)
1024 MB(210 MB) = 1GB(๊ธฐ๊ฐ ๋ฐ์ดํธ)
1024 GB(210 GB) = 1TB(ํ
๋ผ ๋ฐ์ดํธ)
# h๋ 48,000์ดํ, b๋ 32์ดํ(๋จ, 8์ ๋ฐฐ์), c๋ 5์ดํ, s๋ 6,000์ดํ์ ์์ฐ์
# h : 1์ด ๋์ ๋ง์ดํฌ๋ก ์๋ฆฌ๊ฐ์ฝ์ ์ฒดํฌํ๋ ํ์
# b : ํ ๋ฒ ์ฒดํฌํ ๊ฐ์ ์ ์ฅํ ๋ ์ฌ์ฉํ๋ ๋นํธ์
# c : ์ข์ฐ ๋ฑ ์๋ฆฌ๋ฅผ ์ ์ฅํ ํธ๋ ๊ฐ์์ธ ์ฑ๋ ๊ฐ์
# s : ๋
น์ํ ์๊ฐ(์ด)
h, b, c, s = map(int, input().split())
# ํ์ํ ์ ์ฅ ๊ณต๊ฐ์ MB ๋จ์๋ก ๋ฐ๊พธ์ด ์ถ๋ ฅ (์์์ ์ฒซ์งธ ์๋ฆฌ๊น์ง)
print(format((h * b * c * s) / 8 / 1024 / 1024, ".1f"), "MB")
6085๋ฒ : [๊ธฐ์ด-์ข ํฉ] ๊ทธ๋ฆผ ํ์ผ ์ ์ฅ์ฉ๋ ๊ณ์ฐํ๊ธฐ
์ด๋ฏธ์ง์ ๊ฐ๋ก ํด์๋ w, ์ธ๋ก ํด์๋ h, ํ ํฝ์
์ ์ ์ฅํ๊ธฐ ์ํ ๋นํธ b ๊ฐ ์ฃผ์ด์ง ๋,
์์ถํ์ง ์๊ณ ์ ์ฅํ๊ธฐ ์ํด ํ์ํ ์ ์ฅ ์ฉ๋์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด ๋ณด์.
์ด๋ฏธ์ง๊ฐ ์ปดํจํฐ์ ์ ์ฅ๋ ๋์๋ ๋์งํธ ๋ฐ์ดํฐํ ๋์ด ์ ์ฅ๋๋ค.
๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ์ผ๋ก๋ ๊ทธ๋ฆผ์ ๊ตฌ์ฑํ๋ ํ ์ (pixel, ํฝ์
)์ ์์์
๋นจ๊ฐ(r), ์ด๋ก(g), ํ๋(b)์ 3๊ฐ์ง์ ๋น์ ์ธ๊ธฐ ๊ฐ์ผ๋ก ๋ฐ๋ก ๋ณํํ์ฌ ์ ์ฅํ๋ ๊ฒ์ธ๋ฐ,
์๋ฅผ ๋ค์ด r, g, b ๊ฐ ์์ ๋ํด์ 8๋นํธ(0~255, 256๊ฐ์ง ๊ฐ๋ฅ)์ฉ์ ์ฌ์ฉํ๋ค๊ณ ํ๋ฉด,
ํ ์ ์ ์์์ 3๊ฐ์ง r, g, b์ 8๋นํธ+8๋นํธ+8๋นํธ๋ก ์ด 24๋นํธ๋ก ํํํด์
์ด 2^24 ๊ฐ์ง์ ์๋ก ๋ค๋ฅธ ๋น์ ์๊น์ ์ฌ์ฉํ ์ ์๋ ๊ฒ์ด๋ค.
๊ทธ๋ ๊ฒ ์ ์ฅํ๋ ์ ์ ๋ชจ์ ํ๋์ ํฐ ์ด๋ฏธ์ง๋ฅผ ์ ์ฅํ ์ ์๊ฒ ๋๋๋ฐ,
1024 * 768 ์ฌ์ด์ฆ์ ๊ฐ ์ ์ ๋ํด 24๋นํธ๋ก ์ ์ฅํ๋ฉด ๊ทธ ์ด๋ฏธ์ง๋ฅผ ์ ์ฅํ๊ธฐ ์ํ
์ ์ฅ ์ฉ๋์ ๊ณ์ฐํ ์ ์๋ค.
์ด๋ ๊ฒ ์ด๋ฏธ์ง์ ์๋(raw) ๋ฐ์ดํฐ๋ฅผ ์์ถํ์ง ์๊ณ ๊ทธ๋๋ก ์ ์ฅํ๋ ๋ํ์ ์ธ ์ด๋ฏธ์ง ํ์ผ์ด
*.bmp ํ์ผ์ด๋ฉฐ, ๋นํธ๋ก ๊ทธ๋ฆผ์ ๊ตฌ์ฑํ๋ค๊ณ ํ์ฌ ๋นํธ๋งต ๋ฐฉ์ ๋๋ ๋์คํฐ ๋ฐฉ์์ด๋ผ๊ณ ํ๋ค.
์๋ฅผ ๋ค์ด
์ผ๋ฐ์ ์ธ 1024 * 768 ์ฌ์ด์ฆ(ํด์๋)์ ๊ฐ์ ์ ๋ํด
24๋นํธ(rgb ๊ฐ๊ฐ 8๋นํธ์ฉ 3๊ฐ)๋ก ์ ์ฅํ๋ ค๋ฉด
1024 * 768 * 24 bit์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ฐ,
1024*768*24/8/1024/1024 ๋ก ๊ณ์ฐํ๋ฉด ์ฝ 2.25 MB ์ ๋๊ฐ ํ์ํ๋ค.
์ค์ ๊ทธ๋ฐ์ง ํ์ธํ๊ณ ์ถ๋ค๋ฉด, ๊ฐ๋จํ ๊ทธ๋ฆผ ํธ์ง/์์ ํ๋ก๊ทธ๋จ์ ํตํด ํ์ธํ ์ ์๋ค.
**
8 bit(๋นํธ) = 1byte(๋ฐ์ดํธ) # 8bit=1Byte
1024 Byte(210 byte) = 1KB(ํฌ๋ก ๋ฐ์ดํธ) # 1024Byte=1KB
1024 KB(210 KB) = 1MB(๋ฉ๊ฐ ๋ฐ์ดํธ)
1024 MB(210 MB) = 1GB(๊ธฐ๊ฐ ๋ฐ์ดํธ)
1024 GB(210 GB) = 1TB(ํ
๋ผ ๋ฐ์ดํธ)
# w, h๋ ๋ชจ๋ ์ ์์ด๊ณ 1~1024, b๋ 40์ดํ์ 4์ ๋ฐฐ์
# ์ด๋ฏธ์ง์ ๊ฐ๋ก ํด์๋ w, ์ธ๋ก ํด์๋ h, ํ ํฝ์
์ ์ ์ฅํ๊ธฐ ์ํ ๋นํธ b
w, h, b = map(int, input().split())
# ํ์ํ ์ ์ฅ ๊ณต๊ฐ์ MB ๋จ์๋ก ๋ฐ๊พธ์ด ์ถ๋ ฅ (์์์ ๋์งธ ์๋ฆฌ๊น์ง)
print(format((w * h * b) / 8 / 1024 / 1024, ".2f"), "MB")
6086๋ฒ : [๊ธฐ์ด-์ข ํฉ] ๊ฑฐ๊ธฐ๊น์ง! ์ด์ ๊ทธ๋ง~
1, 2, 3 ... ์ ์์๋๋ก ๊ณ์ ๋ํด ํฉ์ ๋ง๋๋๋ฐ,
๊ทธ ํฉ์ด ์
๋ ฅํ ์ ์๋ณด๋ค ์์ ๋์๋ง ๊ณ์ ๋ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ฆ, 1๋ถํฐ n๊น์ง ์ ์๋ฅผ ํ๋์ฉ ๋ํด ํฉ์ ๋ง๋๋๋ฐ,
์ด๋๊น์ง ๋ํด์ผ ์
๋ ฅํ ์๋ณด๋ค ๊ฐ๊ฑฐ๋ ์ปค์ง๋์ง ์์๋ณด๊ณ ์ ํ๋ ๋ฌธ์ ์ด๋ค.
ํ์ง๋ง, ์ด๋ฒ์๋ ๊ทธ ๋ ๊น์ง์ ํฉ์ ์ถ๋ ฅํด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด, 57์ ์
๋ ฅํ๋ฉด
1+2+3+...+8+9+10=55์์ ๊ทธ ๋ค์ ์์ธ 11์ ๋ํด 66์ด ๋ ๋,
๊ทธ ๊ฐ 66์ด ์ถ๋ ฅ๋์ด์ผ ํ๋ค.
# for๋ฌธ ํ์ด
n = int(input())
sum = 0
for i in range(1, n+1):
if sum >= n:
break
sum += i
print(sum)
# while๋ฌธ ํ์ด
n = int(input())
sum = 0
k = 1
while True:
if sum >= n:
break
sum += k
k += 1
print(sum)
6087๋ฒ : [๊ธฐ์ด-์ข ํฉ] 3์ ๋ฐฐ์๋ ํต๊ณผ
1๋ถํฐ ์
๋ ฅํ ์ ์๊น์ง 1์ฉ ์ฆ๊ฐ์์ผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋,
3์ ๋ฐฐ์์ธ ๊ฒฝ์ฐ๋ ์ถ๋ ฅํ์ง ์๋๋ก ๋ง๋ค์ด๋ณด์.
์๋ฅผ ๋ค๋ฉด, 1 2 4 5 7 8 10 11 13 14 ... ์ ๊ฐ์ด ์ถ๋ ฅํ๋ ๊ฒ์ด๋ค.
n = int(input())
for i in range(1, n+1):
if i % 3 == 0:
continue # ๋ค์ ๋ฐ๋ณต ๋จ๊ณ๋ก ๋์ด๊ฐ
print(i, end=" ")
6088๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ ๋์ดํ๊ธฐ1
์์ ๊ฐ(a), ๋ฑ์ฐจ(d), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์ ๋ ฅ๋ ๋ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์ด๋ค ๊ท์น์ ๋ฐ๋ผ ์๋ฅผ ์์๋๋ก ๋์ดํ ๊ฒ์ ์์ด(sequences)์ด๋ผ๊ณ ํ๋ค.
์๋ฅผ ๋ค์ด
1 4 7 10 13 16 19 22 25 ... ์
1๋ถํฐ ์์ํด ์ด์ ์ ๋ง๋ ์์ 3์ ๋ํด ๋ค์ ์๋ฅผ ๋ง๋ ์์ด์ด๋ค.
์ด๋ฌํ ๊ฒ์ ์ํ์์๋ ์๋ค ์๋ค์ ์ฐจ์ด๊ฐ ๊ฐ๋ค๊ณ ํ์ฌ
๋ฑ์ฐจ(์ฐจ์ด๊ฐ ๊ฐ๋ค์ ํ๋ฌธ ๋ง) ์์ด์ด๋ผ๊ณ ํ๋ค. (๋ฑ์ฐจ์์ด : arithmetic progression/sequence)
์์ด์ ์๊ฒ ๋ ์์ผ์ด๋ ๊ฐ์๊ธฐ ๊ถ๊ธํด์ก๋ค.
"๊ทธ๋ผ.... 123๋ฒ์งธ ๋์ค๋ ์๋ ๋ญ๊น?"
์์ผ์ด๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด ๋ ํฐ ์๋ ์๋์ผ๋ก ๊ณ์ฐํ๊ณ ์ถ์ด์ก๋ค.
# ์์ ๊ฐ a, ๋ฑ์ฐจ์ ๊ฐ d, ๋ช ๋ฒ์งธ ์ ์ธ์ง๋ฅผ ์๋ฏธํ๋ ์ ์ n
a, d, n = map(int, input().split())
print(a + (d * (n-1)))
# for๋ฌธ ์ฌ์ฉ (๋ชจ๋ฒ๋ต์ copy)
a,d,n=input().split()
a=int(a)
d=int(d)
n=int(n)
s=a
for i in range(2, n+1):
s+=d
print(s)
6089๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ ๋์ดํ๊ธฐ2
์์ ๊ฐ(a), ๋ฑ๋น(r), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์ ๋ ฅ๋ ๋ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์ด๋ค ๊ท์น์ ๋ฐ๋ผ ์๋ฅผ ์์๋๋ก ๋์ดํ ๊ฒ์ ์์ด(sequences)์ด๋ผ๊ณ ํ๋ค.
์๋ฅผ ๋ค์ด
2 6 18 54 162 486 ... ์
2๋ถํฐ ์์ํด ์ด์ ์ ๋ง๋ ์์ 3์ ๊ณฑํด ๋ค์ ์๋ฅผ ๋ง๋ ์์ด์ด๋ค.
์ด๋ฌํ ๊ฒ์ ์ํ์์๋ ์๋ค ์๋ค์ ๋น์จ์ด ๊ฐ๋ค๊ณ ํ์ฌ
๋ฑ๋น(๋น์จ์ด ๊ฐ๋ค์ ํ๋ฌธ ๋ง) ์์ด์ด๋ผ๊ณ ํ๋ค. (๋ฑ๋น์์ด : geometric progression/sequence)
๋ฑ๋น ์์ด์ ์๊ฒ๋ ์์ผ์ด๋ ๊ฐ์๊ธฐ ๊ถ๊ธํด์ก๋ค.
"๊ทธ๋ผ.... 13๋ฒ์งธ ๋์ค๋ ์๋ ๋ญ๊น?"
์์ผ์ด๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด ๋ ํฐ ์๋ ์๋์ผ๋ก ๊ณ์ฐํ๊ณ ์ถ์ด์ก๋ค.
# ์์ ๊ฐ a, ๋ฑ๋น์ ๊ฐ r, ๋ช ๋ฒ์งธ ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์ n
a, r, n = map(int, input().split())
print(a * (r ** (n-1)))
# for๋ฌธ ์ฌ์ฉ (๋ชจ๋ฒ๋ต์ copy)
a, r, n = input().split()
a = int(a)
r = int(r)
n = int(n)
for i in range(1, n) :
a = a*r
print(a)
6090๋ฒ : [๊ธฐ์ด-์ข ํฉ] ์ ๋์ดํ๊ธฐ3
์์ ๊ฐ(a), ๊ณฑํ ๊ฐ(m), ๋ํ ๊ฐ(d), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์ ๋ ฅ๋ ๋, n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์ด๋ค ๊ท์น์ ๋ฐ๋ผ ์๋ฅผ ์์๋๋ก ๋์ดํ ๊ฒ์ ์์ด(sequences)์ด๋ผ๊ณ ํ๋ค.
์๋ฅผ ๋ค์ด
1 -1 3 -5 11 -21 43 ... ์
1๋ถํฐ ์์ํด ์ด์ ์ ๋ง๋ ์์ -2๋ฅผ ๊ณฑํ ๋ค์ 1์ ๋ํด ๋ค์ ์๋ฅผ ๋ง๋ ์์ด์ด๋ค.
์ด๋ฐ ์ด์ํ ์์ด์ ์๊ฒ ๋ ์์ผ์ด๋ ๋ ๊ถ๊ธํด์ก๋ค.
"๊ทธ๋ผ.... 13๋ฒ์งธ ๋์ค๋ ์๋ ๋ญ๊น?"
์์ผ์ด๋ ๋ฌผ๋ก ์ํ์ ์์ฃผ ์ํ์ง๋ง ์ด๋ฐ ๋ฌธ์ ๋ ๋ณธ ์ ์ด ๊ฑฐ์ ์์๋ค...
๊ทธ๋์ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด ๋ ํฐ ์๋ ์๋์ผ๋ก ๊ณ์ฐํ๊ณ ์ถ์ด์ก๋ค.
# ์์ ๊ฐ a, ๊ณฑํ ๊ฐ m, ๋ํ ๊ฐ d, ๋ช ๋ฒ์งธ ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์ n
a, m, d, n = map(int, input().split())
for i in range(1, n):
a = a * m + d
print(a)
6091๋ฒ : [๊ธฐ์ด-์ข ํฉ] ํจ๊ป ๋ฌธ์ ํธ๋ ๋
์จ๋ผ์ธ ์ฑ์ ์์คํ
์๋ ์ด๋ฑํ์, ์ค๊ณ ๋ฑํ์, ๋ํ์, ๋ํ์์, ์ผ๋ฐ์ธ, ๊ตฐ์ธ, ํ๋ก๊ทธ๋๋จธ, ํ์ฝ๋ ๋ฑ ์์ฃผ ๋ง์ ์ฌ๋๋ค์ด ๋ค์ด์ ๋ฌธ์ ๋ฅผ ํ๊ณ ์๋๋ฐ, ์ค์๊ฐ ์ฑ์ ์ ๋ณด๋ ๋ฉ๋ด์ ์ฑ์ ๊ธฐ๋ก(Judge Status)์ ํตํด ์ดํด๋ณผ ์ ์๋ค.
์! ์ฌ๊ธฐ์...์ ๊น.. ๊ฐ์ ๋ ๋์์ ๊ฐ์
ํ 3๋ช
์ ์ฌ๋๋ค์ด ์จ๋ผ์ธ ์ฑ์ ์์คํ
์ ๋ค์ด์ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ ์ง๊ฐ ๋งค์ฐ ๊ท์น์ ์ด๋ผ๊ณ ํ ๋, ๋ค์ ๋ชจ๋ ํจ๊ป ๋ฌธ์ ๋ฅผ ํ๊ฒ ๋๋ ๊ทธ๋ ์ ์ธ์ ์ผ๊น?
์๋ฅผ ๋ค์ด 3๋ช
์ด ๊ฐ์ ๋ ๊ฐ์
/๋ฑ์
ํ๊ณ , ๊ฐ๊ฐ 3์ผ๋ง๋ค, 7์ผ๋ง๋ค, 9์ผ๋ง๋ค ํ ๋ฒ์ฉ ๋ค์ด์จ๋ค๋ฉด, ์ฒ์ ๊ฐ์
ํ๊ณ 63์ผ ๋ง์ ๋ค์ 3๋ช
์ด ํจ๊ป ๋ฌธ์ ๋ฅผ ํ๊ฒ ๋๋ค.
- ์ ๋ ฅ : ๊ฐ์ ๋ ๋์์ ๊ฐ์ ํ ์ธ์ 3๋ช ์ด ๊ท์น์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋, ๋ฐฉ๋ฌธ ์ฃผ๊ธฐ๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์ ๋ ฅ๋๋ค. (๋จ, ์ ๋ ฅ๊ฐ์ 100์ดํ์ ์์ฐ์์ด๋ค.)
- ์ถ๋ ฅ : 3๋ช ์ด ๋ค์ ๋ชจ๋ ํจ๊ป ๋ฐฉ๋ฌธํด ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ ๋ (๋์ ๊ฐ์ /๋ฑ์ ํ ๋ฉฐ์น ํ?)์ ์ถ๋ ฅํ๋ค.
a, b, c = map(int, input().split())
d = 1
while d%a or d%b or d%c:
d += 1
print(d)