โ 2530 ์ธ๊ณต์ง๋ฅ ์๊ณ โ
A,B,C = map(int,input().split())
D = int(input())
cur = 3600*A + 60*B + C
after = cur + D
after %= 86400
print(after//3600, (after%3600//60), after%60)
๐ ์๊ณ ๊ด๋ จ ๋ฌธ์ ๋ ํญ์ ์, ๋ถ, ์ด ๊ด๋ จ ์ซ์ 3600๊ณผ 60์ ์ ์ ํ ์กฐํฉํด์ผ๋ง ํ ์ ์๋, ๊ฝค ๋๋ฆ ์๊ฐํด์ผ ํ๋ ๋ฌธ์ ์ด๋ค. H๋ 0๋ถํฐ 23, M๊ณผ S๋ 0๋ถํฐ 59๊น์ง์ ๋ฒ์๋ง ํ์ฉ ๊ฐ๋ฅํ๋ฏ๋ก ์ด์ ๋ง๊ฒ ์ฝ๋ฉ์ ํด์ผ ํ ํ์๊ฐ ์์! / ์ ํ์ด ์์ด๋์ด) ์ ์ด์ ์ด๋ก ๋ฐ๊พผ๋ค์, ํ๋ฃจ๊ฐ ๋์ด๊ฐ ๊ฒฝ์ฐ๋ฅผ ๋๋นํด 86400์ผ๋ก ๋๋ ๋๋จธ์ง๋ฅผ ๊ฐ์ง๊ณ ๋ค์, ์๋ถ์ด์ ๋ง๊ฒ ์ ๋ ฌ
๐ ๋ค๋ฅธ ํ์ด>
a, b, c = map(int, input().split())
d = int(input())
c += d
b += c//60
c %= 60
a += b//60
b %= 60
a %= 24
print(a, b, c)
→ ๋จ๊ณ์ ์ผ๋ก ์ด๋ถํฐ ์์ํด ๋ชซ๊ณผ ๋๋จธ์ง๋ก ๋ถ - ์ ์์ผ๋ก ์ ๋ฐ์ดํธ ํ๋ ์ฝ๋
โ 24356 ะงะะกะะะะะ โ
t1,m1,t2,m2=map(int,input().split())
a = 60*t1+m1
b = 60*t2+m2
if b >= a:
c = b-a
print(c,c//30,sep=' ')
else:
c = 1440-a+b
print(c,c//30,sep=' ')
๐ ์ ์ธ๊ณต์ง๋ฅ ์๊ณ์ ๋ง์ฐฌ๊ฐ์ง๋ก, ์๊ฐ ๋ฌธ์ ๋ ํ๊บผ๋ฒ์ ๋ถ์ด๋ ์ด๋ก ๋ฐ๊พธ์ด ๊ณ์ฐํ๋๊ฒ ๋ฌธ์ ํ์ด์ ๊ฐ๋จํ๋ค!
โ 8558 Silniaโ
๐ ์ ํ์ ์ธ ํฉํ ๋ฆฌ์ผ ๋ฌธ์
n = int(input())
if n == 0: print(1)
else:
i = 1
for n in range(1,n+1):
i *= n
print(i%10)
๐ ํฉํ ๋ฆฌ์ผ์ ์ผ์ ์๋ฆฌ๋ง ๊ตฌํ๋ค๋ ํน์ฑ์์, 10 ์ดํ๋ฅผ ๊ณฑํ๊ณ ๋์๋, ๊ณ์ ์ผ์ ์๋ฆฌ๋ 0์ด ๋๋ฏ๋ก ๋์ค์ break๋ฌธ์ ๊ฑธ์ด ๋ฐ๋ก for๋ฌธ์ ํ์ถํ๊ฒ๋ ์๊ฐ์ ์ ์ฝํ ์ ์๋ค (์๋ ์ฝ๋ ์ฐธ์กฐ!)
- ๊ธฐ์กด 248ms → 68ms -
n = int(input())
ans = 1
for i in range(1, n+1):
ans *= i
if ans % 10 == 0:
break
print(ans % 10)
โ 5532 ๋ฐฉํ์์ โ
import math
lst = [int(input()) for _ in range(5)]
print(lst[0]-max(math.ceil(lst[1]/lst[3]),math.ceil(lst[2]/lst[4])))
๐ ์ต๋ ํ๋ฃจ ๋ฅ๋ ฅ๋งํผ ๋ค ํ๊ณ ๋จ์ ๋๋จธ์ง ์๊ธฐ๋ฉด +1 → ์ด๋ math.ceil() ํจ์๋ก ํ๋ฒ์ ์ฌ์ฉ ๊ฐ๋ฅ!
โ 16430 ์ ๋ฆฌ์ ํฐโ
A,B = map(int,input().split())
print(B-A,B,sep=' ')
โ๏ธ ํฐ์ด ๊ฐ์ง๊ณ ์๋ ์น์ฆ์ ๋ฌด๊ฒ๋ B/(B-A)์ธ๋ฐ, ํด๋น ๋ถ์๊ฐ ๊ธฐ์ฝ๋ถ์์์ ์ฆ๋ช ํด์ผ ํ๋ค
โ๏ธ ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ ์ฆ๋ช
→ ์ ์ : A์ B๊ฐ ์๋ก์์ด๋ค. (์ฆ, A์ B์ ์ต๋๊ณต์ฝ์๋ 1์ด๋ค)
→ B-A = B*1 + (-A)๋ก, ์ ํด๋ฆฌ๋ ํธ์ ๋ฒ์ ์ํด B-A์ B์ ์ต๋๊ณต์ฝ์๋ B์ (-A)์ ์ต๋๊ณต์ฝ์์ ๊ฐ๋ค.
→ ์ ์ ๋ก A์ B์ ์ต๋๊ณต์ฝ์๊ฐ 1์ด๋ฏ๋ก, (-A)์ B์ ์ต๋๊ณต์ฝ์๋ 1์ด๊ธฐ ๋๋ฌธ์, B-A์ B์ ์ต๋๊ณต์ฝ์๋ 1, ์ฆ ์๋ก์์ธ ๊ด๊ณ!
→ ๋ฐ๋ผ์ B/(B-A)๋ก ํํ๋ ๋ถ์๋ ๊ธฐ์ฝ๋ถ์. ์ฆ๋ช ๋.
(๋๋ B-A์ B์ ์ต๋๊ณต์ฝ์๊ฐ 2์ด์์ด๋ผ ๊ฐ์ ํ๊ณ ๋ชจ์์์ ์ด๋์ด๋ด๋ ์ฆ๋ช ๋ฒ๋ ์๋ค)
โ 10250 ACM ํธํ โ
import math
def customer(h,w,n):
floor = (n%h if n%h != 0 else h)
ho = n/h
return str(floor)+str(math.ceil(ho)).zfill(2)
for _ in range(int(input())):
H,W,N = map(int, input().split())
print(customer(H,W,N))
โ๏ธ floor>
→ ์ธต ์๋ ์๋ N๊ฐ์์ ์ด floor ๊ฐ H๋ฅผ ๋๋ ๋๋จธ์ง๊ฐ ๋๋๋ฐ, ์ด ๋ ๋๋จธ์ง๊ฐ 0์ด ๋ ๊ฒฝ์ฐ 0์ธต์ด ์๋๋ผ N์ธต์ด ๋๋ ๊ฒ๋ง ์กฐ์ฌ
โ๏ธ ho>
→ ํธ ์๋ ์๋ N๊ฐ์์ ์ด floor ๊ฐ H๋ฅผ ๋๋ ๋ชซ์ด ๋๋ค. ์ด ๋ ๋ชซ์ด 1์ผ ๊ฒฝ์ฐ 01๋ก ๋ํ๋ด์ด์ผ ํ๋ฏ๋ก, ์ต๋ ๋์๋ฆฌ์ ๋ฒ์์ด๊ธฐ์ zfill(2)
โ๏ธ zfill(n) method โ๏ธ
string.zfill(len)
#'Required. A number specifying the desired length of the string'#
→ len ๊ฐ์๋งํผ์ ๋ฌธ์์ด์ด ๋ง๋ค์ด์ง๊ณ , ๊ธฐ์กด ๋ฌธ์์ด์ด ์ฐจ์งํ๋ ์๋ฆฌ ์ธ์ ๋ชจ๋ ์๋ฆฌ์ 0์ด ๋ค์ด๊ฐ๋ค. (๋ฌธ์์ด ์ ์๋ฆฌ์ 0์ด ์ฑ์์ง!)
ex) ์๋ ์์ ์ฐธ์กฐ
a = "hello"
b = "welcome to the jungle"
c = "10.000"
print(a.zfill(10)) #00000hello
print(b.zfill(10)) #welcome to the jungle
print(c.zfill(10)) #000010.000
โ 15080 Every Second Countsโ
start = list(map(int,input().split(':')))
end = list(map(int,input().split(':')))
st_am = 3600*start[0] + 60*start[1] + start[2]
end_am = 3600*end[0] + 60*end[1] + end[2]
if end_am >= st_am:
print(end_am-st_am)
else:
print(86400 - st_am + end_am)
โ๏ธ ์ ์ธ๊ณต์ง๋ฅ ์๊ณ ๋ฌธ์ ์ฒ๋ผ ์ ์ด์ ๋ชจ๋ ์ด๋ก ๋ฐ๊พธ์ด ๊น๋ํ ๊ณ์ฐํ๋๊ฒ ๋น ๋ฅด๋ค.
โ๏ธ ์ฒซ ํ์ด๋ ํ๋ ธ๋๋ฐ,
start = list(map(int,input().split(':')))
end = list(map(int,input().split(':')))
if end[0] >= start[0]:
print(3600*end[0] + 60*end[1] + end[2] - 3600*start[0] - 60*start[1] - start[2])
else:
print(86400 - 3600*start[0] - 60*start[1] - start[2] + 3600*end[0] + 60*end[1] + end[2])
→ ํญ์ ์ฝ๋ฉํ ๋ ์์ธ๋ฅผ ์๊ฐํด์ผ ํ๋๋ฐ, ์๋ฌด๋ฆฌ ์๊ฐ์ด ๊ฐ๋๋ผ๋, ๋ถ ์ด๋ก ๋ฐ์ก์ ๋ start๊ฐ end๋ณด๋ค ๋ ๋์ค์ธ ๊ฒฝ์ฐ๋ ์๊ธฐ ๋๋ฌธ์ x
โ 11943 ํ์ผ ์ฎ๊ธฐ๊ธฐโ
A,B=map(int,input().split())
C,D=map(int,input().split())
print(min(A+D,B+C))
โ๏ธ ๋ฌธ์ ๋ฅผ ์๋ง ์ดํดํ๋ฉด ๋งค์ฐ ์ฝ๊ฒ ํ๋ฆฌ๋ ๋ฌธ์ !
โ๏ธ ํ ๋ฐ๊ตฌ๋์๋ ์ฌ๊ณผ๋ง, ํ ์ชฝ์๋ ์ค๋ ์ง๊ฐ ์์ด์ผ ํ๋ฏ๋ก(๋๊ฐ์ ๋ฐฉํฅ์ผ๋ก) A+D์ ํ์๋งํผ ์ฎ๊ธฐ๊ฑฐ๋, ๊ทธ ๋ฐ๋๋ก B+C ํ์๋งํผ ์ฎ๊ธธ ์ ์๋ค. ์ด ๋ ๊ฐ์ง ์ต์ ์ค ์ต์๊ฐ์ด ์ ๋ต
โ 14173 Square Pastureโ
โ๏ธ ์ฃผ์ด์ง ๋ ์ง์ฌ๊ฐํ์ ๋ชจ๋ ์์ฐ๋ฅด๋ ์ต์ ๊ธธ์ด์ ์ ์ฌ๊ฐํ ๋ฉด์ ์ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค.
→ ์ผ๋จ x์ y์ถ ๋ฐ๋ก๋ฐ๋ก ์๊ฐํ๊ณ , ๊ฐ x์ y ์ค ์ต๋๊ฐ๊ณผ ์ต์๊ฐ์ ์ฐจ์ด๊ฐ ์ต์ ์ปค๋ฒํด์ผ ํ๋ ๋ชฉ์ฅ์ side ๊ธธ์ด
→ x์ถ ์ปค๋ฒ ์ต์ ๊ธธ์ด, y์ถ ์ปค๋ฒ ์ต์ ๊ธธ์ด ์ค ์ต๋๊ฐ์ด ๊ตฌํ๊ณ ์ ํ๋ ์ ์ฌ๊ฐํ ๋ชฉ์ฅ์ ์ต์ side ๊ธธ์ด
a,b,c,d=map(int,input().split())
e,f,g,h=map(int,input().split())
side = max(max(a,c,e,g)-min(a,c,e,g),max(b,d,f,h)-min(b,d,f,h))
print(side*side)
โ 1712 ์์ต๋ถ๊ธฐ์ โ
A,B,C = map(int, input().split())
if C == B:
print(-1)
else:
share = A//(C-B)
print(-1) if share < 0 else print(share+1)
โ๏ธ ์์ต๋ถ๊ธฐ์ , ์ฆ ์ต์ด๋ก ์ด์ต์ด ๋ฐ์ํ๋ ํ๋งค๋์ ์ถ๋ ฅํด์ผ ํ๋ฏ๋ก, ๊ทธ ํ๋งค๋์ x๋ผ ํ๋ฉด, A+Bx < Cx ์ง์ ์ด ๋๋, ์ฆ ์ด ๋น์ฉ๋ณด๋ค ์ด ํ๋งค๋์ด ๋ ํฐ ์ง์ ์ผ ๋์ x๋ฅผ ๊ตฌํด์ผ ํ๋ค.
โ๏ธ ์ฌ๊ธฐ์ C-B๋ฅผ ๋๋ ์ผ ํ๋ฏ๋ก, C=B์ผ ๋๋ ์์ต๋ถ๊ธฐ์ ์ด ์กด์ฌํ์ง ์์ -1 ์ถ๋ ฅ, ๊ทธ ์ธ์๋ ๋ชซ์ผ๋ก ๋๋ ๊ฒฐ๊ณผ์ 1์ ๋ํ๋ฉด ์ ๋ต์ด ๋์ด
โป ZeroDivisionError ๋ฐ์ํ ๋๋ฅผ ํญ์ ๋๋นํด, ๋ถ๋ชจ๊ฐ 0์ผ ๋์ ์ํฉ์ ๊ณ ๋ คํ ์ฝ๋๊น์ง ๊ผญ ์์ฑํ์ โป
โ 18414 X ใซๆใ่ฟใๅค (The Nearest Value) โ
โ๏ธ L์ด์ R์ดํ์ ์์ฐ์ ์ค ์ค์ ๋ก X์์ ์ ๋๊ฐ์ ์ฐจ๊ฐ ์ต์๊ฐ ๋๋ ์์ฐ์๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด๋ค.
→ X๊ฐ L์ด์ R์ดํ์ ๋ฒ์์ ๋ค์ด๊ฐ๋ค๋ฉด, X์ ๊ฐ์ฅ ๊ฐ๊น์ด ์๋ X ๊ทธ ์์ ์ด ๋๊ณ ,
→ X๊ฐ R ์ด๊ณผํ๋ค๋ฉด, X์ ๊ฐ์ฅ ๊ฐ๊น์ด ์๋ R์ด ๋๋ค.
→ ๋ฐ๋๋ก L ๋ฏธ๋ง์ด๋ผ๋ฉด L์ด ๋๋ค.
โ๏ธ ์ํ๋ฌธ์ ํด์๋ง ์ํ๋ฉด ok!
โ 25828 Corona Virus Testing โ
g,p,t=map(int,input().split())
print(2) if g*p > p*t+g else print(1) if g*p < p*t + g else print(0)
โ๏ธ ๊ฐ๊ฐ ๋ชจ๋ ๊ฒ์ฌํ ๊ฒฝ์ฐ g*p (๊ทธ๋ฃน์ * ๊ฐ ๊ทธ๋ฃน๋ณ ์ฌ๋์) ์ด๋, ๋๋ ๊ฐ ๊ทธ๋ฃน ๊ฒ์ฌ + positive๋ ์ฌ๋๋ง ๋ฐ๋ก g + p*t ๊ฐ์๋ก ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ์ ์๋ค. ๋ ์ผ์ด์ค์ ๋์๊ด๊ณ์ ๋ฐ๋ผ ํ์ ์ถ๋ ฅํ๋ฉด ๋!
โ 15051 Máquina de café โ
As = [int(input())for _ in range(3)]
a = 4*As[0]+2*As[1]
b = 2*As[0]+2*As[2]
c = 2*As[1]+4*As[2]
print(min(a,b,c))
โ๏ธ ์๋ฅผ ๋ค์ด 2์ธต์ ์ปคํผ๊ฐ ์์ด์ 1์ธต์์ ์ค๋ฅด๋ฝ๋ด๋ฆฌ๋ฝํ ๋ ์ด 1+1 = 2๋ถ์ ์๊ฐ์ด ์์๋๋ค๋ ์ ! ๊ฐ ์ผ์ด์ค๋ณ๋ก ์๊ฐ ๊ตฌํ๊ณ ์ต์๊ฐ!
โ 16600 Contemporary Art โ
import math
a=int(input())
print(math.sqrt(a)*4)
โ๏ธ ๋์ด๊ฐ ์ฃผ์ด์ง ์ํ์์ ์ ๊ณฑ๊ทผ์ ๊ตฌํ๋ค์, ๋๋ ๊ธธ์ด๋ฅผ ๊ตฌํ๊ธฐ ์ํด 4๋ก ๊ณฑํด์ฃผ๋ฉด ๋ฐ๋ก ๋!
โ 15610 Abbey Courtyard โ
print(int(input())**(1/2)*4)
โ๏ธ ์ 16600 ๋ฌธ์ ๋ ๋์ผ๋ฌธ์
โ 21591 Laptop Sticker โ
wc,hc,ws,hs=map(int,input().split())
if ws <= (wc-2) and hs <= (hc-2):
print(1)
else:
print(0)
โ๏ธ ์ ์์ผ๋ก 1cm ๊ฐ๊ฒฉ์ด ์์ด์ผ ํ๋ฏ๋ก ๊ฐ ๋ณ์์ -2๊น์ง ๋บ ๋ฒ์ ๋ด์ ์์ผ๋ฉด OK!
โ 25881 Electric Bill โ
f,a = map(int,input().split())
for _ in range(int(input())):
e = int(input())
c = (1000*f + (e-1000)*a if e > 1000 else e*f)
print(e,c,sep=' ')
โ๏ธ energy consumption์ด 1000์ ๋์ ๊ฒฝ์ฐ ๊ณผ๊ธ์ด ๋์ด ์ถ๊ฐ์๊ธ์ด ๋ถ๋ ์ํฉ๋ง ์ปจํธ๋กค
โ๏ธ ์ด ๋ ()์์ if๋ฌธ์ ํ ์ค๋ก ๋ฃ์ด ์ํ๋ ๊ฐ์ ๋ณ์์ ์ง์ด๋ฃ์ ์ ์์ (์ฝ๋ ํ ์ค ๊ธฐ์ต!)
โ 5575 ํ์ ์นด๋ โ
for _ in range(3):
h1,m1,s1,h2,m2,s2=map(int,input().split())
a = 3600*(h2-h1)+60*(m2-m1)+s2-s1
print(a//3600, a//60%60, (a%60))
โ๏ธ ์ด๋ก ๋ฐ๊พธ์์ ๋ ์๋ //3600, ๋ถ์ //60%60, ์ด๋ %60์์ ๊ผญ! ๊ธฐ์ตํ์
โ 20215 Cutting Corners โ
w,h=map(int,input().split())
print(w+h-(w**2+h**2)**(1/2))
โ๏ธ (์๋ ๊ทธ๋ฆผ) ํ๋์ ํ์ดํ๋ก ์๋ฅด๋ ๊ฒฝ์ฐ๋ณด๋ค, ๋ ๋นจ๊ฐ์ ํ์ดํ๋ก ์๋ฅผ ๋ ์ผ๋ง๋ ๋ ์๊ตฌ๋๋ ์ง ์์๋ณด๋ ๋ฌธ์ ! ์ฐ์ฐ๋ง ์ํ๋ฉด ok
โ 25784 Easy-to-Solve Expressions โ
a,b,c=map(int,input().split())
if a == (b+c) or b == (a+c) or c == (a+b):
print(1)
elif a == (b*c) or b == (a*c) or c == (a*b):
print(2)
else:
print(3)
โ๏ธ ๋ฏธ๋ฆฌ ์ ๋ ฌ(sorted)์ ํ ๋ค, ํฐ ์๊ฐ ๋ค๋ฅธ ๋ ์์ ํฉ์ธ์ง ๊ณฑ์ธ์ง์ ๋ฐ๋ผ ๊ตฌ๋ถํ๋ ๊ฒ ๋ ๊ฐ๋จํจ!
โ 21335 Another Eruption โ
import math
a = int(input())
r = (a/(math.pi))**(1/2)
print(2*math.pi*r)
โ๏ธ ์์ ๋์ด(pi*r*r)๊ฐ ์ฃผ์ด์ง๋ฉด → ์์ ๋๋ (2*pi*r)๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ! (์์ฃผ์จ pi๋ math.pi ์ฌ์ฉ)
โ 24087 ใขใคในใฏใชใผใ (Ice Cream) โ
import math
S=int(input())
A=int(input())
B=int(input())
if S > A:
print((math.ceil((S-A)/B))*100 + 250)
else:
print(250)
โ๏ธ ceil ํจ์ ์ฌ์ฉํ๋ฉด ๋จ - ๋ฒ์ ์ด๊ณผํ ๊ฒฝ์ฐ, ๋ฑ ๋ง์ ๊ฒฝ์ฐ ๋ ๊ฐ์ง ํจ๊ป ๊ณ ๋ ค
โ 21631 Checkers โ
w,b=map(int,input().split())
if w>=b:
print(b)
else:
print(w+1)
โ๏ธ
1) w๊ฐ์๊ฐ b๋ ๊ฐ๊ฑฐ๋ ๋ ๋ง๋ค๋ฉด, b๋ฅผ ๋งจ ์๊ณผ ๋์ ๋ฃ๊ณ , b๋ฅผ ๋ชจ๋ ๋ฐฐ์นํ ๋ค, ๊ทธ ์ฌ์ด์ w๋ฅผ ๋ชจ๋ ๋ฃ์ ์ ์์ด, b ๊ฐ์๊ฐ ๊ทธ๋๋ก stripe ๊ฐ์
2) b๊ฐ ๋ ๋ง๋ค๋ฉด, w๋ฅผ ๋จผ์ ๋ฐฐ์นํ๊ณ ๊ทธ ์ฌ์ด, ๊ทธ๋ฆฌ๊ณ ๋งจ ์์ ์๋๋ก ์ต๋ํ ๋ฃ์๋ ค๋ฉด w๊ฐ์ + 1๋งํผ ๋ฃ์ ์ ์์ผ๋ฏ๋ก w+1์ด stripe ๊ฐ์
โ๏ธ ์ํ์ ์ผ๋ก ๊ณต๊ฐ์ ์๊ฐํด์ผ ํ๋ ๋ฌธ์ !
โ 14264 ์ ์ก๊ฐํ๊ณผ ์ผ๊ฐํ โ
import math
L = int(input())
print((math.sqrt(3)/4)*(L**2))
โ๏ธ ๊ฒน์น์ง ์๊ฒ ์ธ ๊ฐ์ ๋๊ฐ์ ์ ๊ธ๋ ๋ฐฉ๋ฒ์ ๋ฑ ํ ๊ฐ์ง๋ง ์กด์ฌํ๊ณ , ๋๋ ๊ฒฐ๊ณผ์ ์ผ๊ฐํ๋ค ์ค ๊ฐ์ฅ ๋ฉด์ ์ด ์ต์์ธ ์ผ๊ฐํ์ ์๋ ๊ทธ๋ฆผ์์ ์ผ๊ฐํ ABCm์ด๋ค
โ๏ธ ๊ฐ ABCm์ 120๋์ด๋ฏ๋ก, ๋ฉด์ ์ ์ ๋ถ BCm * (์ ๋ถ AB*1/2*root(3)) * (1/2)! ๊ทธ๋๋ก ์ฝ๋๋ก ํ๋ฉด ๋๋ค
โ 25625 ์คํ๋ฒ์ค โ
x,y=map(int,input().split())
if y < x:
print(y+x)
else:
print(y%x)
์์ธ๋์ ๊ตฌ์ญ ------------------------------------------------------- ์ 2๊ณตํ๊ด
โ ๋ฒ์ค๊ฐ x๋ถ์ ์๊ฐ๋ณด๋ค ์งง๊ฒ y๋ถ ํ์ ๊ณตํ๊ด์ ๋์ฐฉํ๋ค๋ฉด, ๊ณตํ๊ด๊น์ง ๊ฐ๋ ์๊ฐ y + ๊ณตํ๊ด์์ ์์ธ๋์ ๊ตฌ์ญ์ผ๋ก ๊ฐ๋ ์๊ฐ x๋ฅผ ๋ํ ๊ฒฐ๊ณผ x+y๊ฐ ์ ๋ต
โก ๋ฒ์ค๊ฐ x๋ถ๋ณด๋ค ๋ ๊ธด y๋ถ ์ดํ์ ๊ณตํ๊ด์ ๋์ฐฉํ๋ค๋ฉด(y๋ 2x์ดํ), ๋จผ์ y%x๋ถ๋งํผ ์์ธ๋์ ๊ตฌ์ญ์ผ๋ก ๊ฐ ๋ค, x๋ถ ํ ๊ณตํ๊ด์ผ๋ก ๊ฐ๋ค. ๋ฏผ์ค์ด๋ ์์ธ๋์ ๊ตฌ์ญ์ ์์ผ๋ฏ๋ก y%x์ด ์ ๋ต
โ 9501 ๊ฟ์ ์ฐ์ฃผ์ฌํ โ
import sys
input = sys.stdin.readline
for _ in range(int(input())):
cnt = 0
N,D=map(int,input().split())
for _ in range(N):
vi,fi,ci=map(int,input().split())
if vi*(fi/ci) >= D:
cnt += 1
print(cnt)
โ๏ธ ์ฐ๋ฃ์(f)/์ฐ๋ฃ์๋น์จ(๋จ์์๊ฐ๋น์๋น์;c) = ์ฐ๋ฃ์๋น์๊ฐ
→ ์ฐ๋ฃ์๋น์๊ฐ * ์ต๊ณ ์๋(v)์ธ ๊ฑฐ๋ฆฌ๊ฐ์ด D์ด์์ด์ด์ผ๋ง ๊ฐ ์ ์๋ ์ฐ์ฃผ์ !
→ ๋ฐ๋ผ์ vi*(fi/ci) >= D๋ผ๋ ๋ถ๋ฑ์์ด ์ฑ๋ฆฝ
โ 24294 ะะ ะะะะะ โ
whs = [int(input()) for _ in range(4)]
print(2*(whs[1]+whs[3])+4+2*(max(whs[0],whs[2])))
โ๏ธ ๋ ๋์ด์ ํฉ์ ๋ ๋ฒ ๊ณฑํ๊ณ , ๊ฐ๋ก์ ๊ฒฝ์ฐ ์ต๋๊ฐ์ธ ๊ฐ๋ก๋ฅผ ๋ ๋ฒ ๊ณฑํ๋ฉด, ์ ๋ชจ์๋ฆฌ ๋๋จ 4๊ฐ ์ ์ฌ๊ฐํ์ด ๋จ์ผ๋ฏ๋ก ์ด๊ฒ๊น์ง ๋ํ๊ธฐ!
โ 24751 Betting โ
a=int(input())
print(100/a,100/(100-a),sep='\n')
โ๏ธ ์๊ธฐ ์์ ์ %๋๋น ์๋๋ฐฉ%์ธ ratio๋ฅผ ๊ตฌํ๋ ๋ฌธ์ ! ๋ถ์-๋ถ๋ชจ ๊ด๊ณ์ด๋ฉด ๋ฐ๋ก ํ ์ ์๋ค
โ 24183 Affischutskicket โ
a,b,c=map(int,input().split())
A = a*(0.0229*0.0324)*2*100
B = b*(0.0297*0.042)*2*100
C = c*(0.021*0.0297)*100
print(A+B+C)
โ๏ธ ๋จ์์ ์ฃผ์! C4๋ฅผ ์๋ก ๋ค๋ฉด
$A g = a g/m^2 * 0.229m * 0.324m * 2$
$(mm^2 → m^2$์ผ๋ก ์๋ง๊ฒ ๋ณํ ํ์!
โ 17210 ๋ฌธ๋ฌธ๋ฌธ โ
N=int(input())
s=input()
if N>=6:
print('Love is open door')
else:
l=[]
flag=False
while N>=1:
if s=='1':
if flag:
l.append(0)
flag=False
else:
l.append(1)
flag=True
else:
if flag:
l.append(1)
flag=False
else:
l.append(0)
flag=True
N-=1
print(*l[1:],sep='\n')
๐ข 6์ด์์ผ ๊ฒฝ์ฐ ํ์์ ์ง์ ์์น๊ฐ ๋ฌด์กฐ๊ฑด ์ซ์๊ฐ ๋ฌ๋ผ์ ๊ฐ๋ฅํ์ง ์๋ค, ๋๋จธ์ง๋ 0๊ณผ 1์ ๋ฒ๊ฐ์ ๊ฐ์ ์ถ๋ ฅ
'BOJ > ๐ฅ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
โ ์ ๋ ฌ ๊ธฐ์ด1 - 8๋ฌธ์ ()โ (2) | 2022.10.05 |
---|---|
โ Recursion Upper-Beginner - 3 Solvedโ (0) | 2022.09.27 |
โ Basics II - 50 Solvedโ (0) | 2022.09.08 |
โ Implementation Beginner I - 50 Solvedโ (0) | 2022.08.22 |
โ Number Theory Upper-Beginner I - 15 Solvedโ (0) | 2022.08.21 |
๋๊ธ