BOJ/๐Ÿฅˆ

โ˜…Math & Geometry Upper-Intermediate I - 5 Solvedโ˜…

metamong 2023. 1. 26.

โ˜… 1002 ํ„ฐ๋ › โ˜…

 

for _ in range(int(input())):
    x1, y1, r1, x2, y2, r2 = map(int, input().split())
    
    d = (x1-x2)**2 + (y1-y2)**2

    if d > (r1+r2)**2: print(0)
    elif d == (r1+r2)**2: print(1)
    elif (r1+r2)**2 > d > (r1-r2)**2: print(2)
    else:
        if r1!=r2:
            if d == (r1-r2)**2: print(1)
            else:print(0)
        else:print(-1)

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ๋‘ ์›์˜ ์œ„์น˜ ๊ด€๊ณ„์— ๋”ฐ๋ฅธ ๋‘ ์› ๊ต์ ์˜ ๊ฐœ์ˆ˜

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ๋‘ ์›์˜ ์œ„์น˜ ๊ด€๊ณ„๋Š” ํฌ๊ฒŒ 6๊ฐ€์ง€๋กœ ๋‚˜๋‰œ๋‹ค.

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ๋‘ ์›์˜ ์ค‘์‹ฌ ์‚ฌ์ด์˜ ๊ฑฐ๋ฆฌ๋ฅผ ๊ธฐ์ค€์œผ๋กœ 6๊ฐ€์ง€๋ฅผ ์ž์„ธํ•˜๊ฒŒ ๋‚˜๋ˆŒ ์ˆ˜ ์žˆ๋‹ค.

(๋‘ ์›์˜ ์ค‘์‹ฌ ์‚ฌ์ด์˜ ๊ฑฐ๋ฆฌ๋ฅผ d๋ผ๊ณ  ํ•˜๊ณ , ๋‘ ์›์˜ ๋ฐ˜์ง€๋ฆ„์„ ๊ฐ๊ฐ r1, r2๋ผ๊ณ  ํ•˜๋ฉด)

โ‘  d > (r1+r2) - ๋‘ ์›์ด ์•„์˜ˆ ๋งŒ๋‚˜์ง€ ์•Š์Œ - ๊ต์  0๊ฐœ 

 

โ‘ก d = (r1+r2) - ๋‘ ์›์ด ์„œ๋กœ ์™ธ์ ‘ํ•จ - ๊ต์  1๊ฐœ

 

โ‘ข (r1+r2) > d > |r1-r2| - ๋‘ ์›์ด ๊ฒน์นจ - ๊ต์  2๊ฐœ

 

→ ์•„๋ž˜ 3๊ฐ€์ง€ |r1-r2| >= d์ธ ๊ฒฝ์šฐ ์ค‘์—์„œ

โ‘ฃ r1 = r2 - ๋‘ ์›์ด ์•„์˜ˆ ๊ฒน์นจ - ๊ต์  ๋ฌด์ˆ˜ํžˆ ๋งŽ์Œ

 

โ‘ค r1 ≠ r2์ด๊ณ  d = |r1-r2| - ํ•œ ์›์ด ๋‹ค๋ฅธ ์›์— ๋‚ด์ ‘ํ•จ - ๊ต์  1๊ฐœ

โ‘ฅ r1 ≠ r2์ด๊ณ  |r1-r2| > d - ํ•œ ์›์ด ๋‹ค๋ฅธ ์›์— ๋“ค์–ด๊ฐ - ๊ต์  0๊ฐœ


โ˜… 13908 ๋น„๋ฐ€๋ฒˆํ˜ธ โ˜…

 

from math import factorial

def combination(a,b): #aCb
    return factorial(a)//(factorial(b)*factorial(a-b))

n,m=map(int,input().split())
if m>0:input()
ans=10**n
for i in range(1,m+1):
    ans+=(((-1)**i)*(combination(m,i))*((10-i)**n))
print(ans)

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ BF๋กœ ํ’€ ์ˆ˜ ์žˆ์œผ๋‚˜, ํฌํ•จ๊ณผ ๋ฐฐ์ œ์˜ ์›๋ฆฌ๋กœ ์ ‘๊ทผํ•ด ํ’€์–ด๋ณด์ž!

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ n๊ฐœ์˜ ์ž๋ฆฌ์ˆ˜์—์„œ m๊ฐœ์˜ ์„œ๋กœ ๋‹ค๋ฅธ ์ˆซ์ž๊ฐ€ ํฌํ•จ๋œ ๋น„๋ฐ€๋ฒˆํ˜ธ์˜ ์ˆ˜์ธ ์ •๋‹ต์„ A๋ผ๊ณ  ํ•˜๋ฉด, ํฌํ•จ๊ณผ ๋ฐฐ์ œ์˜ ์›๋ฆฌ์— ์˜ํ•ด

A = 10^n - mC1x(9^n) + mC2x(8^n) - mC3x(7^n) + ... 

 

โ‘  ์ „์ฒด ๊ฒฝ์šฐ์˜์ˆ˜ 10^n

โ‘ก m๊ฐœ ์ˆซ์ž ์ข…๋ฅ˜ ๊ฐ๊ฐ 1๊ฐœ์”ฉ๋งŒ ๋น„๋ฐ€๋ฒˆํ˜ธ์— ๋“ค์–ด๊ฐ€์ง€ ์•Š์„ ๊ฒฝ์šฐ๋Š” 9^n์ด๊ณ , ์ด๋ฅผ ์ „์ฒด ๊ฒฝ์šฐ์˜ ์ˆ˜์—์„œ ๋นผ์•ผ ํ•จ

(๋น„๋ฐ€๋ฒˆํ˜ธ์—๋Š” ์ด๋ฅผ ํฌํ•จํ•ด์•ผ ํ•˜๋ฏ€๋กœ) - mC1๋งŒํผ ๊ฒฝ์šฐ์˜ ์ˆ˜ ์กด์žฌ

โ‘ข ์—ฌ๊ธฐ์„œ, ๊ณตํ†ต์ ์œผ๋กœ ๋นผ์ง„ ๋ถ€๋ถ„์ด ์žˆ์œผ๋ฏ€๋กœ (์˜ˆ๋ฅผ ๋“ค๋ฉด 4์ž๋ฆฌ ์ˆ˜์—์„œ ๊ฐ๊ฐ 3๊ณผ 4๊ฐ€ ์•ˆ๋“ค์–ด๊ฐ„ ๊ฒฝ์šฐ๋ฅผ ๋บ์„ ๋•Œ, ์˜ˆ๋ฅผ ๋“ค์–ด 1256์€ ๋‘ ๋ฒˆ ๋นผ์ง),

ํฌํ•จ๊ณผ ๋ฐฐ์ œ์˜ ์›๋ฆฌ์— ์˜ํ•ด ๊ฒน์นœ ๋ถ€๋ถ„์„ ๋‹ค์‹œ ๋”ํ•ด์ค˜์•ผ ํ•จ - ์ด๋Š” mC2๊ฐœ์˜ ๊ฐ€์ง“์ˆ˜์—์„œ, ์ด์ œ ๋‘ ๊ฐœ๊ฐ€ ๊ณตํ†ต์ ์œผ๋กœ ์•ˆ๋“ค์–ด๊ฐ„ ๊ฒฝ์šฐ 8^n์„ ๊ณฑํ•œ ๊ฒฝ์šฐ์˜ ์ˆ˜๋ฅผ ๋‹ค์‹œ ๋”ํ•ด์คŒ

โ‘ฃ ์ด์  , ํฌํ•จ๊ณผ ๋ฐฐ์ œ์˜ ์›๋ฆฌ์— ์˜ํ•ด ์„ธ ๊ฐœ์˜ ์ˆซ์ž๊ฐ€ ๋‹ค์‹œ ๋”ํ•ด์คฌ์œผ๋ฏ€๋กœ, ๋นผ์ค˜์•ผ ํ•จ - ์ด๋ ‡๊ฒŒ ๋ฐ˜๋ณต

 

mCn = (n!)/(r!(m-n)!)

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ์œ„ A๋ฅผ ๋‹ค์‹œ ์ •๋ฆฌํ•ด๋ณด์ž๋ฉด,


โ˜… 2477 ์ฐธ์™ธ๋ฐญ โ˜…

 

def get_area(pos,K,h,w,sh,sw,i):
    w = i[pos][1]
    h = i[pos-1][1]

    if pos==5: sh = h-i[0][1]
    else: sh = h-i[pos+1][1]
    
    if 4<=pos: sw = i[pos-4][1]
    else: sw = i[pos+2][1]

    return (K*(h*w-sh*sw))

K=int(input())
n=0
i=[]
ds=[]

for _ in range(6):
    d,l=map(int,input().split())
    i.append((d,l))
    ds.append(d)

ds.sort()

if ds==[1,1,2,3,3,4]: n=2
elif ds==[1,2,2,3,4,4]: n=1
elif ds==[1,2,2,3,3,4]: n=4
else: n=3

pos = [pair[0] for pair in i].index(n)


print(get_area(pos,K,0,0,0,0,i))

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ์ด 4๊ฐ€์ง€ ๋ชจ์–‘์˜ ์ฐธ์™ธ๋ฐญ์ด ์ฃผ์–ด์ ธ ์žˆ๊ณ , ๋™์„œ๋‚จ๋ถ ๋ฐฉํ–ฅ์„ ๊ฐ๊ฐ 1234๋กœ ํ–ˆ์„ ๋•Œ, ๊ฐ ์ฐธ์™ธ๋ฐญ์˜ ๊ธด ๊ฐ€๋กœ๊ธธ์ด๋ฅผ pos ๋ณ€์ˆ˜์— ๋„ฃ๊ณ , ์ด๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์•ž ๋’ค ๋ฐฉํ–ฅ์— ๋”ฐ๋ฅธ ๋ณ€ ๊ธธ์ด๋ฅผ ์ด์šฉํ•ด ํฐ ์ง์‚ฌ๊ฐํ˜• ๋„“์ด - ์ž‘์€ ์ง์‚ฌ๊ฐํ˜• ๋„“์ด๋ฅผ ๊ตฌํ•œ๋‹ค

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ์—ฌ๋Ÿฌ if๋ฌธ์œผ๋กœ ์ƒํ™ฉ์— ๋”ฐ๋ผ ์ƒ๊ฐํ•ด์•ผ ํ•˜๋Š” ๊ธฐํ•˜ํ•™ ๋ฌธ์ œ

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ํฐ ์ง์‚ฌ๊ฐํ˜•์˜ ๊ฐ€๋กœ์™€ ์„ธ๋กœ ๊ธธ์ด๋ฅผ ๊ฐ๊ฐ i์™€ j๋กœ index()๋ฅผ ์ด์šฉํ•ด ๊ตฌํ•˜๊ณ , ์ด๋กœ๋ถ€ํ„ฐ index ๊ธฐ์ค€ 3์”ฉ ๋–จ์–ด์ง„ ๊ฒŒ ์ž‘์€ ์ง์‚ฌ๊ฐํ˜•์˜ ๊ฐ€๋กœ์™€ ์„ธ๋กœ์ž„์„ idea๋กœ ์•Œ์•„์ฑ„๋ฉด ์•„๋ž˜์™€ ๊ฐ™์ด ๋งค์šฐ ๊ฐ„๋‹จํ•˜๊ฒŒ ์ฝ”๋”ฉ ๊ฐ€๋Šฅ! (์ด ๋•Œ index + 3์— ์˜ค๋ฅ˜๊ฐ€ ๋‚˜์ง€ ์•Š๊ฒŒ๋” ์ผ๋ถ€๋Ÿฌ ๋˜‘๊ฐ™์€ ์ˆซ์ž๋ฅผ ๋ถ™์—ฌ list๋ฅผ 2๋ฐฐ๋กœ ํ•ด์ค€๋‹ค. - idea ๊ธฐ์–ตํ•˜๊ธฐ)

n=int(input())
x=[int(input().split()[1])for _ in range(6)]*2
i=x.index(max(x))
j=x.index(max(x[i-1],x[i+1]))
print(n*(x[i]*x[j]-x[i+3]*x[j+3]))

โ˜… 7908 Will It Stop? โ˜…

import math
n = int(input())
if int(math.log(n,2)) == math.log(n,2):
    print('TAK')
else:
    print('NIE')

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ์†Œ์ธ์ˆ˜๋ถ„ํ•ด ๊ฒฐ๊ณผ 2๋กœ๋งŒ ์ด๋ฃจ์–ด์ง„ ์ˆ˜, ์ฆ‰ 2์˜ ์ œ๊ณฑ์ˆ˜๋ผ๋ฉด ๊ฒฐ๊ตญ n์ด 1์ด ๋˜๋ฏ€๋กœ TAK ์ถœ๋ ฅ / ๊ทธ๋ ‡์ง€ ์•Š๊ณ  2๊ฐ€ ์•„๋‹Œ ๋‹ค๋ฅธ ์†Œ์ธ์ˆ˜๊ฐ€ ์กด์žฌํ•œ๋‹ค๋ฉด ๋ฌด์กฐ๊ฑด ๋ฌดํ•œ๋ฐ˜๋ณต๋ฌธ์— ๊ฑธ๋ ค์„œ NIE ์ถœ๋ ฅ.

 

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ๋ชจ๋“  ์ž์—ฐ์ˆ˜๋Š” 2^k*p(p๋Š” ์†Œ์ˆ˜ ๋˜๋Š” 1)๋กœ ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ๋Š”๋ฐ, p๊ฐ€ 1์ธ ๊ฒฝ์šฐ 2์˜ ์ œ๊ณฑ์ˆ˜์ด๋ฏ€๋กœ ์ด ๋•Œ๋Š” TAK ์ถœ๋ ฅ / p๊ฐ€ 1์ด ์•„๋‹Œ ์†Œ์ˆ˜์ธ ๊ฒฝ์šฐ ์–ธ์  ๊ฐ€๋Š” p ํ™€์ˆ˜๋กœ ์ธํ•ด n์ด 3*n+3์œผ๋กœ ์—ฐ์‚ฐ๋˜๋Š” ๋ถ€๋ถ„์— ๊ฑธ๋ฆฌ๊ฒŒ ๋˜๊ณ , ์ฆ‰ 3์ด ๊ณฑํ•ด์ง€๋ฏ€๋กœ 3์ด ์ง€์›Œ์ง€์ง€ ์•Š๊ฒŒ ๋˜๊ธฐ์—(3์˜ ๋ฐฐ์ˆ˜ ์œ ์ง€) ๋ฌดํ•œ๋ฐ˜๋ณต๋ฌธ์— ๊ฐ‡ํ˜€์„œ NIE ์ถœ๋ ฅ


โ˜… 13662 Elevador โ˜…

๐Ÿคฝ๐Ÿป‍โ™‚๏ธ ์ฃผ์–ด์ง„ ์ง์‚ฌ๊ฐํ˜•์—์„œ ๋‘ ์›์„ ๋„ฃ์„ ์ˆ˜ ์žˆ๋Š” ์ง€ ํŒ๋ณ„ํ•˜๋Š” ๊ธฐํ•˜ํ•™ ๋ฌธ์ œ

: ์œ„ ๋‘ ์›์˜ ๋ฐ˜์ง€๋ฆ„์„ r1, r2๋ผ ํ•˜๊ณ  ์ง์‚ฌ๊ฐํ˜•์˜ ๊ฐ€๋กœ ๊ธธ์ด๋ฅผ W, ์„ธ๋กœ ๊ธธ์ด๋ฅผ H๋ผ ํ•˜์ž(์™ผ์ชฝ ์› A, ์˜ค๋ฅธ์ชฝ ์› B). A๋ฅผ ์ง์‚ฌ๊ฐํ˜•์˜ ์™ผ์ชฝ ์œ„์— ์ตœ๋Œ€ํ•œ ๋ฐฐ์น˜ํ•˜๊ณ , B๋ฅผ ์ง์‚ฌ๊ฐํ˜•์˜ ์˜ค๋ฅธ์ชฝ ์•„๋ž˜์— ์ตœ๋Œ€ํ•œ ๋ฐฐ์น˜ํ•˜์ž. ๊ทธ๋Ÿฌ๋ฉด A์˜ ์ค‘์‹ฌ ์ขŒํ‘œ E๋Š” (r1,H-r1) / B์˜ ์ค‘์‹ฌ ์ขŒํ‘œ G๋Š” (W-r2,r2). ๋‘ ์›์ด ์ง์‚ฌ๊ฐํ˜• ์•ˆ์— ๋“ค์–ด๊ฐ€๋ ค๋ฉด ๋‘ ์›์˜ ์ค‘์‹ฌ ์‚ฌ์ด์˜ ๊ฑฐ๋ฆฌ๊ฐ€ ์ตœ์†Œ (r1+r2)๋ณด๋‹ค๋Š” ํฌ๊ฑฐ๋‚˜ ๊ฐ™์•„์•ผ ํ•œ๋‹ค. (๊ทธ๋ฆผ ๋งํฌ)

: ์ผ๋‹จ ๋‘ ์› ์ค‘ ํฐ ์›์˜ ์ง€๋ฆ„์ด ๊ฐ€๋กœ ๊ธธ์ด, ์„ธ๋กœ ๊ธธ์ด ์ค‘ ์ตœ์†Ÿ๊ฐ’๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์•„์•ผ ํ•˜๊ณ , ์œ„ ๋ถ€๋“ฑ์‹์„ ๋งŒ์กฑํ•˜๋ฉด ๋‘ ์›์„ ์ง์‚ฌ๊ฐํ˜•์— ๋„ฃ๊ธฐ ๊ฐ€๋Šฅ!

import sys
input=sys.stdin.readline

while 1:
    H,W,r1,r2=map(int,input().split())
    if (H,W,r1,r2) == (0,0,0,0):
        break
    if min(H,W) >= max(2*r1,2*r2):
        if ((W-r1-r2)**2 + (H-r1-r2)**2) >= (r1+r2)**2:
            print('S')
        else:
            print('N')
    else:
        print('N')

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

๋Œ“๊ธ€