์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | 4 | |||
5 | 6 | 7 | 8 | 9 | 10 | 11 |
12 | 13 | 14 | 15 | 16 | 17 | 18 |
19 | 20 | 21 | 22 | 23 | 24 | 25 |
26 | 27 | 28 | 29 | 30 | 31 |
- Android Studio
- url
- http method
- Factory Method Pattern
- ๊ฐ์ฒด์งํฅํ๋ก๊ทธ๋๋ฐ
- ๊ธฐ์ด100์
- IOC
- AndroidStudio
- OOP
- fontstyle
- 2024-08-20
- menutab
- Kotlin
- uri
- datepicker
- ์ฑ์ฉํ์ ํ
- ํ๋ IT&E
- di
- Python
- 2024-08-21
- tcp
- swagger
- reflection
- OpenAPI
- URN
- FACTORY
- ์ด๋ ธํ ์ด์
- udp
- ์ฝ๋์
- Dialog
dingdong coding
[ 6077 - 6091 ] ์ข ํฉ ๋ณธ๋ฌธ
# ๊ฐ๋ ๋ณต๊ธฐ์ฉ
[ 6077 ] ์ง์ ํฉ ๊ตฌํ๊ธฐ
n = int(input()) #5 ์ ์ 1๊ฐ๊ฐ ์
๋ ฅ
s = 0
for i in range(n):
if i%2 == 0:
s += i
print(s) #6 1๋ถํฐ ๊ทธ ์๊น์ง ์ง์๋ง ํฉํด ์ถ๋ ฅ
[ 6078 ] ์ํ๋ ๋ฌธ์๊ฐ ์ ๋ ฅ๋ ๋๊น์ง ๋ฐ๋ณต ์ถ๋ ฅ
๋ฌธ์ ์๋ฌธ ์๋ฌธ์ 'q'๊ฐ ์
๋ ฅ๋ ๋๊น์ง ์
๋ ฅํ ๋ฌธ์๋ฅผ ๊ณ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ ๋ ฅ ๋ฌธ์๋ค์ด 1๊ฐ์ฉ ๊ณ์ํด์ ์ ๋ ฅ๋๋ค.
์ถ๋ ฅ ์๋ฌธ ์๋ฌธ์ 'q'๊ฐ ์ ๋ ฅ๋ ๋๊น์ง ์ ๋ ฅํ ๋ฌธ์๋ฅผ ๊ณ์ ์ถ๋ ฅํ๋ค.
# ํ์ด 1
while True:
x=input()
print(x)
if x=='q':
break
# ํ์ด 2
a = 1
while a!='q':
a = input()
print(a)
[ 6079 ] ์ธ์ ๊น์ง ๋ํด์ผ ํ ๊น?
๋ฌธ์ 1, 2, 3 ... ์ ๊ณ์ ๋ํด ๋๊ฐ ๋, ๊ทธ ํฉ์ด ์ ๋ ฅํ ์ ์(0 ~ 1000)๋ณด๋ค ๊ฐ๊ฑฐ๋ ์์ ๋๊น์ง๋ง ๊ณ์ ๋ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
์ ๋ ฅ ์ ์ 1๊ฐ๊ฐ ์ ๋ ฅ๋๋ค. ex) 55
์ถ๋ ฅ 1, 2, 3, 4, 5 ... ๋ฅผ ์์๋๋ก ๊ณ์ ๋ํด ํฉ์ ๋ง๋ค์ด๊ฐ๋ค๊ฐ, ์ ๋ ฅ๋ ์ ์์ ๊ฐ๊ฑฐ๋ ์ปค์ก์ ๋, ๋ง์ง๋ง์ ๋ํ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค. ex) 10
# ํ์ด 1
n = int(input())
sum = 0
result = 0
while sum < n:
result = result + 1
sum = sum + result
print(result)
# ํ์ด 2
n = int(input())
sum = 0
result = 0
for i in range(n):
if sum < n:
result = result + 1
sum +=result
print(result)
[ 6080 ] ์ฃผ์ฌ์ 2๊ฐ ๋์ง๊ธฐ
๋ฌธ์ 1๋ถํฐ n๊น์ง, 1๋ถํฐ m๊น์ง ์ซ์๊ฐ ์ ํ ์๋ก ๋ค๋ฅธ ์ฃผ์ฌ์ 2๊ฐ๋ฅผ ๋์ก์ ๋, ๋์ฌ ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์ถ๋ ฅํด๋ณด์.
์
๋ ฅ ์๋ก ๋ค๋ฅธ ์ฃผ์ฌ์ 2๊ฐ์ ๋ฉด์ ๊ฐ์ n, m์ด ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค. ๋จ, n, m์ 10์ดํ์ ์์ฐ์
ex) 2 3
์ถ๋ ฅ ๋์ฌ ์ ์๋ ์ฃผ์ฌ์์ ์ซ์๋ฅผ ํ ์ธํธ์ฉ ์ค์ ๋ฐ๊ฟ ๋ชจ๋ ์ถ๋ ฅํ๋ค. ์ฒซ ๋ฒ์งธ ์๋ n, ๋ ๋ฒ์งธ ์๋ m์ผ๋ก ๊ณ ์ ํด 1๋ถํฐ ์ค๋ฆ์ฐจ์ ์์๋ก ์ถ๋ ฅํ๋๋ก ํ๋ค.
ex) 1 1
1 2
1 3
2 1
2 2
2 3
n, m = input().split()
n = int(n)
m = int(m)
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 ๊น์ง๋ง ์
๋ ฅ๋๋ค.)
์
๋ ฅ 16์ง์๋ก ํ ์๋ฆฌ ์๊ฐ ์
๋ ฅ๋๋ค. ๋จ, A ~ F ๊น์ง๋ง ์
๋ ฅ๋๋ค.
ex) B
์ถ๋ ฅ ์ ๋ ฅ๋ 16์ง์์ 1~F๊น์ง ์์๋๋ก ๊ณฑํ, 16์ง์ ๊ตฌ๊ตฌ๋จ์ ์ค์ ๋ฐ๊ฟ ์ถ๋ ฅํ๋ค. ๊ณ์ฐ ๊ฒฐ๊ณผ๋ 16์ง์๋ก ์ถ๋ ฅํด์ผ ํ๋ค.
ex) B*1=B
B*2=16
...
B*E=9A
B*F=A5
# ํ์ด 1
a = input()
n = int(a, 16)
result = int('F', 16)
for i in range(1, result+1):
print('%X'%n, '*%X'%i, '=%X'%(n*i), sep='')
# ํ์ด 2
n = int(input(), 16)
for i in range(1, 16) :
print('%X'%n, '*%X'%i, '=%X'%(n*i), sep='')
print('%X'%n) #n์ ์ ์ฅ๋์ด์๋ ๊ฐ์ 16์ง์(hexadecimal) ํํ๋ก ์ถ๋ ฅ
์์ ๋ฐ์ดํ 2๊ฐ๋ฅผ ์ฌ์ฉํด์ print(..., sep='') ์ผ๋ก ์ถ๋ ฅํ๋ฉด, ๊ณต๋ฐฑ์์ด ๋ชจ๋ ๋ถ์ฌ ์ถ๋ ฅ๋๋ค.
์์ ๋ฐ์ดํ 2๊ฐ '' ๋๋ ํฐ ๋ฐ์ดํ 2๊ฐ "" ๋ ์๋ฌด ๋ฌธ์๋ ์๋ ๋น๋ฌธ์์ด(empty string)์ ์๋ฏธํ๋ค.
[ 6082 ] 3 6 9 ๊ฒ์์ ์์ด ๋์
๋ฌธ์ ์น๊ตฌ๋ค๊ณผ ํจ๊ป 3 6 9 ๊ฒ์์ ํ๋ ์์ผ์ด๋ ์ฆ์ ์ค์ ๋๋ฌธ์ ๊ณ์ํด์ ๋ฒ์น์ ๋ฐ๊ฒ ๋์๋ค. 3 6 9 ๊ฒ์์ ์์ด ๋๊ธฐ ์ํ 369 ๋ง์คํฐ ํ๋ก๊ทธ๋จ์ ์์ฑํด ๋ณด์.
์ฌ๋ฌ ์ฌ๋์ด ์์๋ฅผ ์ ํ ํ, ์์๋๋ก ์๋ฅผ ๋ถ๋ฅด๋ ๊ฒ์์ด๋ค. ๋ง์ฝ 3, 6, 9 ๊ฐ ๋ค์ด๊ฐ ์๋ฅผ ์์ ์ด ๋ถ๋ฌ์ผ ํ๋ ์ํฉ์ด๋ผ๋ฉด, ์๋ฅผ ๋ถ๋ฅด๋ ๋์ "๋ฐ์(X)" ๋ฅผ ์ณ์ผ ํ๋ค. 33๊ณผ ๊ฐ์ด 3,6,9๊ฐ ๋ ๋ฒ ๋ค์ด๊ฐ ์ ์ผ๋, "์ง์ง"๊ณผ ๊ฐ์ด ๋ฐ์๋ฅผ ๋ ๋ฒ ์น๋ ํํ๋ ์๋ค.
์
๋ ฅ 30 ๋ณด๋ค ์์ ์ ์ 1๊ฐ๊ฐ ์
๋ ฅ๋๋ค. (1 ~ 29)
ex) 9
์ถ๋ ฅ 1 ๋ถํฐ ๊ทธ ์๊น์ง ์์๋๋ก ๊ณต๋ฐฑ์ ๋๊ณ ์๋ฅผ ์ถ๋ ฅํ๋๋ฐ, 3 ๋๋ 6 ๋๋ 9๊ฐ ํฌํจ ๋์ด์๋ ์์ธ ๊ฒฝ์ฐ, ๊ทธ ์ ๋์ ์๋ฌธ ๋๋ฌธ์ X ๋ฅผ ์ถ๋ ฅํ๋ค.
ex) 1 2 X 4 5 X 7 8 X
# ํ์ด 1
n = input()
n = int(n)
for i in range(1, n+1):
if (i%10 == 3) or (i%10 ==6) or (i%10 == 9) :
print("X", end=' ')
elif ( (i%10 == 3) or (i%10 ==6) or (i%10 == 9) ) and (i%3==0):
print("์ง์ง", end=' ')
else:
print(i, end=' ') # #์ถ๋ ฅ ํ ๊ณต๋ฐฑ๋ฌธ์(๋น์นธ, ' ')๋ก ๋๋
# ํ์ด 2
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=' ')
[ 6083 ] ๋น ์์ด ์ ๋ง๋ค๊ธฐ
๋ฌธ์ ๋นจ๊ฐ(red), ์ด๋ก(green), ํ๋(blue) ๋น์ ์์ด ์ฌ๋ฌ ๊ฐ์ง ๋ค๋ฅธ ์ ๋น์ ๋ง๋ค์ด ๋ด๋ ค๊ณ ํ๋ค. ๋นจ๊ฐ(r), ์ด๋ก(g), ํ๋(b) ๊ฐ ๋น์ ๊ฐ์ง์๊ฐ ์ฃผ์ด์ง ๋, ์ฃผ์ด์ง rgb ๋น๋ค์ ์์ด ๋ง๋ค ์ ์๋ ๋ชจ๋ ๊ฒฝ์ฐ์ ์กฐํฉ(r g b)๊ณผ ๋ง๋ค ์ ์๋ ์์ ๊ฐ์ง ์๋ฅผ ๊ณ์ฐํด๋ณด์.
์ ๋ ฅ ๋นจ๋ นํ(r, g, b) ๊ฐ ๋น์ ๊ฐ์ง์๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์ ๋ ฅ๋๋ค. ์๋ฅผ ๋ค์ด, 3 3 3 ์ ๋นจ๋ นํ ๋น์ ๋ํด์ ๊ฐ๊ฐ 0~2๊น์ง 3๊ฐ์ง ์์ด ์์์ ์๋ฏธํ๋ค.
์ถ๋ ฅ ๋ง๋ค ์ ์๋ rgb ์์ ์ ๋ณด๋ฅผ ์ค๋ฆ์ฐจ์(๊ณ๋จ์ ์ฌ๋ผ๊ฐ๋ ์, 12345... abcde..., ๊ฐ๋๋ค๋ผ๋ง...)์ผ๋ก
์ค์ ๋ฐ๊ฟ ๋ชจ๋ ์ถ๋ ฅํ๊ณ , ๋ง์ง๋ง์ ๊ทธ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
# ํ์ด 1
r, g, b = input().split()
r = int(r)
g = int(g)
b = int(b)
n = 0
for i in range(r):
for j in range(g):
for k in range(b):
print(i, j, k)
n += 1
print(n)
# ํ์ด 2
r, g, b = input().split()
r = int(r)
g = int(g)
b = int(b)
s = r*g*b
for i in range(r):
for j in range(g):
for k in range(b):
print(i, j, k)
print(s)
[ 6084 ] ์๋ฆฌ ํ์ผ ์ ์ฅ์ฉ๋ ๊ณ์ฐ
๋ฌธ์ ์๋ฆฌ๊ฐ ์ปดํจํฐ์ ์ ์ฅ๋ ๋์๋ ๋์งํธ ๋ฐ์ดํฐํ ๋์ด ์ ์ฅ๋๋ค. ๋ง์ดํฌ๋ฅผ ํตํด 1์ด์ ์ ๊ฒ๋ ์์ญ ๋ฒ, ๋ง๊ฒ๋ ์๋ง ๋ฒ ์๋ฆฌ์ ๊ฐ์ฝ์ ์ฒดํฌํ๊ณ , ํ ๋ฒ์ฉ ์ฒดํฌํ ๋ ๋ง๋ค ๊ทธ ๊ฐ์ ์ ์๊ฐ์ผ๋ก ๋ฐ๊พธ์ด ์ ์ฅํ๋ ๋ฐฉ์์ผ๋ก ์๋ฆฌ๋ฅผ ํ์ผ๋ก ์ ์ฅํ ์ ์๋ค. ๊ฐ์ ์ ์ฅํ ๋์๋ ๋นํธ๋ฅผ ์ฌ์ฉํ๋ ์ ๋์ ๋ฐ๋ผ ์ธ์ธํ ๋
น์ ์ ๋๋ฅผ ๊ฒฐ์ ํ ์ ์๊ณ , ์ข์ฐ(์คํ
๋ ์ค) ์ฑ๋๋ก ์ ์ฅํ๋ฉด 2๋ฐฐ… 5.1์ฑ๋์ด๋ฉด 6๋ฐฐ์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๊ณ , ๋
น์ ์๊ฐ์ด ๊ธธ๋ฉด ๊ทธ ๋งํผ ๋ ๋ง์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ค.
1์ด ๋์ ๋ง์ดํฌ๋ก ์๋ฆฌ๊ฐ์ฝ์ ์ฒดํฌํ๋ ํ์๋ฅผ h
(ํค๋ฅด์ฏ, Hz ๋ 1์ด์ ๋ช ๋ฒ? ์ฒดํฌํ๋๊ฐ๋ฅผ ์๋ฏธํ๋ค.)
ํ ๋ฒ ์ฒดํฌํ ๊ฐ์ ์ ์ฅํ ๋ ์ฌ์ฉํ๋ ๋นํธ์๋ฅผ b
(2๋นํธ๋ฅผ ์ฌ์ฉํ๋ฉด 0 ๋๋ 1 ๋ ๊ฐ์ง, 16๋นํธ๋ฅผ ์ฌ์ฉํ๋ฉด 65536๊ฐ์ง..)
์ข์ฐ ๋ฑ ์๋ฆฌ๋ฅผ ์ ์ฅํ ํธ๋ ๊ฐ์์ธ ์ฑ๋ ๊ฐ์๋ฅผ c
(๋ชจ๋
ธ๋ 1๊ฐ, ์คํ
๋ ์ค๋ 2๊ฐ์ ํธ๋์ผ๋ก ์ ์ฅํจ์ ์๋ฏธํ๋ค.)
๋ น์ํ ์๊ฐ(์ด) s๊ฐ ์ฃผ์ด์ง ๋, ํ์ํ ์ ์ฅ ์ฉ๋์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์..
์ค์ ๋ก, ์ผ๋ฐ์ ์ธ CD ์์ง(44.1KHz, 16bit, ์คํ
๋ ์ค)๋ก 1์ด ๋์ ์ ์ฅํ๋ ค๋ฉด
44100 * 16 * 2 * 1 bit์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ฐ,
44100*16*2*1/8/1024/1024 ๋ก ๊ณ์ฐํ๋ฉด ์ฝ 0.168 MB ์ ๋๊ฐ ํ์ํ๋ค.
์
๋ ฅ h, b, c, s ๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค. h๋ 48,000์ดํ, b๋ 32์ดํ(๋จ, 8์๋ฐฐ์), c๋ 5์ดํ, s๋ 6,000์ดํ์ ์์ฐ์์ด๋ค.
์ถ๋ ฅ ํ์ํ ์ ์ฅ ๊ณต๊ฐ์ MB ๋จ์๋ก ๋ฐ๊พธ์ด ์ถ๋ ฅํ๋ค. ๋จ, ์์์ ์ฒซ์งธ ์๋ฆฌ๊น์ง์ ์ ํ๋๋ก ์ถ๋ ฅํ๊ณ MB๋ฅผ ๊ณต๋ฐฑ์ ๋๊ณ ์ถ๋ ฅํ๋ค.
# ํ์ด1
h, b, c, s = input().split()
print(format(int(h)*int(b)*int(c)*int(s)/8/1024/1024, '.1f'),"MB")
# ํ์ด2
h, b, c, s = input().split()
h = int(h)
b = int(b)
c = int(c)
s = int(s)
result = h*b*c*s/8/1024/1024
print(format(result, ".1f"),"MB")
# ํ์ด3
h, b, c, s = input().split()
h = int(h)
b = int(b)
c = int(c)
s = int(s)
print(round(h*b*c*s/8/1024/1024, 1), "MB")
[ 6085 ] ๊ทธ๋ฆผ ํ์ผ ์ ์ฅ์ฉ๋ ๊ณ์ฐ
๋ฌธ์ ์ด๋ฏธ์ง์ ๊ฐ๋ก ํด์๋ w, ์ธ๋ก ํด์๋ h, ํ ํฝ์
์ ์ ์ฅํ๊ธฐ ์ํ ๋นํธ b ๊ฐ ์ฃผ์ด์ง ๋, ์์ถํ์ง ์๊ณ ์ ์ฅํ๊ธฐ ์ํด ํ์ํ ์ ์ฅ ์ฉ๋์ ๊ณ์ฐํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด ๋ณด์.
์๋ฅผ ๋ค์ด ์ผ๋ฐ์ ์ธ 1024 * 768 ์ฌ์ด์ฆ(ํด์๋)์ ๊ฐ์ ์ ๋ํด 24๋นํธ(rgb ๊ฐ๊ฐ 8๋นํธ์ฉ 3๊ฐ)๋ก ์ ์ฅํ๋ ค๋ฉด 1024 * 768 * 24 bit์ ์ ์ฅ๊ณต๊ฐ์ด ํ์ํ๋ฐ, 1024*768*24/8/1024/1024 ๋ก ๊ณ์ฐํ๋ฉด ์ฝ 2.25 MB ์ ๋๊ฐ ํ์ํ๋ค.
์
๋ ฅ w, h, b ๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค. ๋จ, w, h๋ ๋ชจ๋ ์ ์์ด๊ณ 1~1024 ์ด๋ค. b๋ 40์ดํ์ 4์ ๋ฐฐ์์ด๋ค.
์ถ๋ ฅ ํ์ํ ์ ์ฅ ๊ณต๊ฐ์ MB ๋จ์๋ก ๋ฐ๊พธ์ด ์ถ๋ ฅํ๋ค. ๋จ, ์์์ ์ ์งธ ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผํ์ฌ ๋์งธ ์๋ฆฌ๊น์ง ์ถ๋ ฅํ๋ค.
w, h, b = input().split() #1024 768 24
w = int(w)
h = int(h)
b = int(b)
s = w*h*b/8/1024/1024
print(format(s,".2f"),"MB") #2.25 MB
[ 6086 ] ๊ฑฐ๊ธฐ๊น์ง! ์ด์ ๊ทธ๋ง~
๋ฌธ์ 1, 2, 3 ... ์ ์์๋๋ก ๊ณ์ ๋ํด ํฉ์ ๋ง๋๋๋ฐ, ๊ทธ ํฉ์ด ์ ๋ ฅํ ์ ์๋ณด๋ค ์์ ๋์๋ง ๊ณ์ ๋ํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์. ์ฆ, 1๋ถํฐ n๊น์ง ์ ์๋ฅผ ํ๋์ฉ ๋ํด ํฉ์ ๋ง๋๋๋ฐ ์ด๋๊น์ง ๋ํด์ผ ์ ๋ ฅํ ์๋ณด๋ค ๊ฐ๊ฑฐ๋ ์ปค์ง๋์ง ์์๋ณด๊ณ ์ ํ๋ ๋ฌธ์ ์ด๋ค. ํ์ง๋ง, ์ด๋ฒ์๋ ๊ทธ ๋ ๊น์ง์ ํฉ์ ์ถ๋ ฅํด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด, 57์ ์ ๋ ฅํ๋ฉด 1+2+3+...+8+9+10=55์์ ๊ทธ ๋ค์ ์์ธ 11์ ๋ํด 66์ด ๋ ๋, ๊ทธ ๊ฐ 66์ด ์ถ๋ ฅ๋์ด์ผ ํ๋ค.
์
๋ ฅ ์ธ์ ๊น์ง ํฉ์ ๊ณ์ฐํ ์ง, ์ ์ 1๊ฐ๋ฅผ ์
๋ ฅ๋ฐ๋๋ค. ๋จ, ์
๋ ฅ๋๋ ์์ฐ์๋ 100,000,000์ดํ์ด๋ค.
์ถ๋ ฅ 1, 2, 3, 4, 5 ... ์์๋๋ก ๊ณ์ ๋ํด๊ฐ๋ค๊ฐ, ๊ทธ ํฉ์ด ์ ๋ ฅ๋ ์ ์๋ณด๋ค ์ปค์ง๊ฑฐ๋ ๊ฐ์์ง๋ ๊ฒฝ์ฐ, ๊ทธ ๋๊น์ง์ ํฉ์ ์ถ๋ ฅํ๋ค.
# ํ์ด1
n = int(input())
sum = 0
t = 0
while True:
if sum < n:
t += 1
sum += t
else:
break
print(sum)
# ํ์ด2
n = int(input())
sum = 0
p = 0
while True:
sum += p
p += 1
if sum >= n:
break
print(sum)
[ 6087 ] 3์ ๋ฐฐ์๋ ํต๊ณผ
๋ฌธ์ 1๋ถํฐ ์
๋ ฅํ ์ ์๊น์ง 1์ฉ ์ฆ๊ฐ์์ผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ๋, 3์ ๋ฐฐ์์ธ ๊ฒฝ์ฐ๋ ์ถ๋ ฅํ์ง ์๋๋ก ๋ง๋ค์ด๋ณด์. ์๋ฅผ ๋ค๋ฉด,
1 2 4 5 7 8 10 11 13 14 ... ์ ๊ฐ์ด ์ถ๋ ฅํ๋ ๊ฒ์ด๋ค.
์
๋ ฅ ์ ์ 1๊ฐ๋ฅผ ์
๋ ฅ๋ฐ๋๋ค. (1 ~ 100)
์ถ๋ ฅ 1๋ถํฐ ์
๋ ฅํ ์ ์๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋๊น์ง 1์ฉ ์ฆ๊ฐ์์ผ ์ถ๋ ฅํ๋ 3์ ๋ฐฐ์๋ ์ถ๋ ฅํ์ง ์๋๋ค.
# ํ์ด 1
n = int(input())
for i in range(1, n+1):
if (i%3 != 0):
print(i, end=' ')
# ํ์ด 2
n = int(input())
for i in range(1, n+1) :
if i%3==0 :
continue #๋ค์ ๋ฐ๋ณต ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค.
print(i, end=' ')
์กฐ๊ฑด๋ฌธ์ด๋ ๋ฐ๋ณต๋ฌธ์ ์ฝ๋๋ธ๋ก ์์์ continue ๊ฐ ์คํ๋๋ฉด, ๋ฐ๋ณต ๋ธ๋ก ์์ ์๋ ๋๋จธ์ง ๋ถ๋ถ์ ์คํํ์ง ์๊ณ , ๋ค์ ๋ฐ๋ณต ๋จ๊ณ๋ก ๋์ด๊ฐ๋ค. ์ฆ, ๋ฐ๋ณต ๋ธ๋ก์ ๋๋จธ์ง ๋ถ๋ถ์ ์คํ๋์ง ์๊ณ , ๋ค์ ๋จ๊ณ์ ๋ฐ๋ณต์ ๊ณ์(continue)ํ๋ ๊ฒ์ด๋ค.
[ 6088 ] ์ ๋์ดํ๊ธฐ1
๋ฌธ์ ์์ ๊ฐ(a), ๋ฑ์ฐจ(d), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์
๋ ฅ๋ ๋ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์
๋ ฅ ์์ ๊ฐ(a), ๋ฑ์ฐจ์ ๊ฐ(d), ๋ช ๋ฒ์งธ ์ ์ธ์ง๋ฅผ ์๋ฏธํ๋ ์ ์(n)๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค.(๋ชจ๋ 0 ~ 100)
์ถ๋ ฅ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ค.
a, d, n = input().split() #1 3 5
a = int(a)
d = int(d)
n = int(n)
t = a
for i in range(1, n): # 1 ~ n-1
t += d # 4 -> 7 -> 10 -> 13
print(t) #13
[ 6089 ] ์ ๋์ดํ๊ธฐ2
๋ฌธ์ ์์ ๊ฐ(a), ๋ฑ๋น(r), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์
๋ ฅ๋ ๋ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์
๋ ฅ ์์ ๊ฐ(a), ๋ฑ๋น์ ๊ฐ(r), ๋ช ๋ฒ์งธ ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค.(๋ชจ๋ 0 ~ 10)
์ถ๋ ฅ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ค.
a, r, n = input().split() #2 3 7
a = int(a)
r = int(r)
n = int(n)
t = a
for i in range(1, n): # 1 ~ n-1
t *= r
print(t) # 6 -> 18 -> 54 -> ,,, -> 1458
print(t) #1458
[ 6090 ] ์ ๋์ดํ๊ธฐ3
๋ฌธ์ ์์ ๊ฐ(a), ๊ณฑํ ๊ฐ(m), ๋ํ ๊ฐ(d), ๋ช ๋ฒ์งธ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ์ ๋ ฅ๋ ๋, n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ๋ง๋ค์ด๋ณด์.
์
๋ ฅ ์์ ๊ฐ(a), ๊ณฑํ ๊ฐ(m), ๋ํ ๊ฐ(d), ๋ช ๋ฒ์งธ ์ธ์ง๋ฅผ ๋ํ๋ด๋ ์ ์(n)๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค.(a, m, d๋ -50 ~ +50, n์ 10์ดํ์ ์์ฐ์)
์ถ๋ ฅ n๋ฒ์งธ ์๋ฅผ ์ถ๋ ฅํ๋ค.
a, m, d, n = input().split() #2 3 7
a = int(a)
m = int(m)
d = int(d)
n = int(n)
t = a
for i in range(1, n):
t = (t * m) + d
print(t)
[ 6091 ] ํจ๊ป ๋ฌธ์ ํธ๋ ๋
๋ฌธ์ ์จ๋ผ์ธ ์ฑ์ ์์คํ
์๋ ์ด๋ฑํ์, ์ค๊ณ ๋ฑํ์, ๋ํ์, ๋ํ์์, ์ผ๋ฐ์ธ, ๊ตฐ์ธ, ํ๋ก๊ทธ๋๋จธ, ํ์ฝ๋ ๋ฑ ์์ฃผ ๋ง์ ์ฌ๋๋ค์ด ๋ค์ด์ ๋ฌธ์ ๋ฅผ ํ๊ณ ์๋๋ฐ, ์ค์๊ฐ ์ฑ์ ์ ๋ณด๋ ๋ฉ๋ด์ ์ฑ์ ๊ธฐ๋ก(Judge Status)์ ํตํด ์ดํด๋ณผ ์ ์๋ค.
์! ์ฌ๊ธฐ์...์ ๊น..
๊ฐ์ ๋ ๋์์ ๊ฐ์
ํ 3๋ช
์ ์ฌ๋๋ค์ด ์จ๋ผ์ธ ์ฑ์ ์์คํ
์ ๋ค์ด์ ๋ฌธ์ ๋ฅผ ํธ๋ ๋ ์ง๊ฐ ๋งค์ฐ ๊ท์น์ ์ด๋ผ๊ณ ํ ๋, ๋ค์ ๋ชจ๋ ํจ๊ป ๋ฌธ์ ๋ฅผ ํ๊ฒ ๋๋ ๊ทธ๋ ์ ์ธ์ ์ผ๊น?
์๋ฅผ ๋ค์ด 3๋ช
์ด ๊ฐ์ ๋ ๊ฐ์
/๋ฑ์
ํ๊ณ , ๊ฐ๊ฐ 3์ผ๋ง๋ค, 7์ผ๋ง๋ค, 9์ผ๋ง๋ค ํ ๋ฒ์ฉ ๋ค์ด์จ๋ค๋ฉด, ์ฒ์ ๊ฐ์
ํ๊ณ 63์ผ ๋ง์ ๋ค์ 3๋ช
์ด ํจ๊ป ๋ฌธ์ ๋ฅผ ํ๊ฒ ๋๋ค.
์
๋ ฅ ๊ฐ์ ๋ ๋์์ ๊ฐ์
ํ ์ธ์ 3๋ช
์ด ๊ท์น์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋, ๋ฐฉ๋ฌธ ์ฃผ๊ธฐ๊ฐ ๊ณต๋ฐฑ์ ๋๊ณ ์
๋ ฅ๋๋ค. (๋จ, ์
๋ ฅ๊ฐ์ 100์ดํ์ ์์ฐ์์ด๋ค.)
์ถ๋ ฅ 3๋ช
์ด ๋ค์ ๋ชจ๋ ํจ๊ป ๋ฐฉ๋ฌธํด ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ ๋ (๋์ ๊ฐ์
/๋ฑ์
ํ ๋ฉฐ์น ํ?)์ ์ถ๋ ฅํ๋ค.
a, b, c = input().split() #3 7 9
a = int(a)
b = int(b)
c = int(c)
d = 1 #day
while d%a!=0 or d%b!=0 or d%c!=0:
d+=1
if d%a==0 and d%b==0 and d%c==0:
break
print(d) #63
'๐ตCoding Test > CodeUp' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ์ฝ๋์ ] Greedy (0) | 2022.02.13 |
---|---|
[ 6092 - 6098 ] ๋ฆฌ์คํธ (0) | 2022.01.19 |
[ 6065 - 6076 ] ์ ํ์คํ๊ตฌ์กฐ, ๋ฐ๋ณต์คํ๊ตฌ์กฐ (0) | 2022.01.18 |
[ 6048 - 6064 ] ๋น๊ต์ฐ์ฐ, ๋ ผ๋ฆฌ์ฐ์ฐ, ๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ, 3ํญ์ฐ์ฐ (0) | 2022.01.17 |
[ 6032 - 6041, 6043 - 6047 ] ์ฐ์ ์ฐ์ฐ, ๋นํธ์ํํธ์ฐ์ฐ (0) | 2022.01.14 |