์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€๋ฅผ ์œ„ํ•ด ์ฝ”๋“œ์—… ์‚ฌ์ดํŠธ(https://codeup.kr/)์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค.

๋ธ”๋กœ๊ทธ์— ์˜ฌ๋ผ์˜จ ๋ชจ๋“  ์ฝ”๋“œ๋Š” ํŒŒ์ด์ฌ(Python)์œผ๋กœ ์ž‘์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.   

 

Python์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ ์‚ฌ์ดํŠธ๋กœ ์ด๋™ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. 

https://codeup.kr/problemsetsol.php?psid=33 

 

๋ฌธ์ œ์ง‘ / Python ๊ธฐ์ดˆ 100์ œ

 

codeup.kr

 

6095 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ๋ฐ”๋‘‘ํŒ์— ํฐ ๋Œ ๋†“๊ธฐ(์„ค๋ช…)(py)

๊ธฐ์ˆ™์‚ฌ ์ƒํ™œ์„ ํ•˜๋Š” ํ•™๊ต์—์„œ ์–ด๋–ค ๊ธˆ์š”์ผ(์ „์› ๊ท€๊ฐ€์ผ)์—๋Š” ๋ชจ๋‘ ์ง‘์œผ๋กœ ๊ท€๊ฐ€๋ฅผ ํ•œ๋‹ค.

์˜ค๋žœ๋งŒ์— ์ง‘์— ๊ฐ„ ์˜์ผ์ด๋Š” ์•„๋ฒ„์ง€์™€ ํ•จ๊ป˜ ๋‘๋˜ ๋งค์šฐ ํฐ ์˜ค๋ชฉ์— ๋Œ€ํ•ด์„œ ์ƒ๊ฐํ•ด ๋ณด๋‹ค๊ฐ€
"๋ฐ”๋‘‘ํŒ์— ๋Œ์„ ์˜ฌ๋ฆฐ ๊ฒƒ์„ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ํ•  ์ˆ˜ ์žˆ์„๊นŒ?"ํ•˜๊ณ  ์ƒ๊ฐํ•˜์˜€๋‹ค.

๋ฐ”๋‘‘ํŒ(19 * 19)์— n๊ฐœ์˜ ํฐ ๋Œ์„ ๋†“๋Š”๋‹ค๊ณ  ํ•  ๋•Œ,
n๊ฐœ์˜ ํฐ ๋Œ์ด ๋†“์ธ ์œ„์น˜๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

๋ฆฌ์ŠคํŠธ๊ฐ€ ๋“ค์–ด์žˆ๋Š” ๋ฆฌ์ŠคํŠธ๋ฅผ ๋งŒ๋“ค๋ฉด?
๊ฐ€๋กœ๋ฒˆํ˜ธ, ์„ธ๋กœ๋ฒˆํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ด 2์ฐจ์› ํ˜•ํƒœ์˜ ๋ฐ์ดํ„ฐ์ฒ˜๋Ÿผ ์‰ฝ๊ฒŒ ๊ธฐ๋กํ•˜๊ณ  ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
๋ฆฌ์ŠคํŠธ์ด๋ฆ„[๋ฒˆํ˜ธ][๋ฒˆํ˜ธ] ํ˜•์‹์œผ๋กœ ์ €์žฅ๋˜์–ด์žˆ๋Š” ๊ฐ’์„ ์ฝ๊ณ  ์“ธ ์ˆ˜ ์žˆ๊ณ , ๋” ํ™•์žฅํ•œ n์ฐจ์›์˜ ๋ฆฌ์ŠคํŠธ๋„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.

d=[]
for i in range(20) : 
  d.append([])
  for j in range(20) :  
    d[i].append(0)

์œ„์™€ ๊ฐ™์ด, ๋ชจ๋‘ 0์ด ์ฑ„์›Œ์ง„ 2์ฐจ์› ๋ฆฌ์ŠคํŠธ๋ฅผ ๋งŒ๋“œ๋Š” ์ฝ”๋“œ๋ฅผ ์•„๋ž˜์™€ ๊ฐ™์€ ๋ฐฉ๋ฒ•์œผ๋กœ ์งง๊ฒŒ ๋งŒ๋“ค ์ˆ˜๋„ ์žˆ๋‹ค.
... [0 for j in range(20)]  #20๊ฐœ์˜ 0์ด ๋“ค์–ด๊ฐ„ [0, 0, 0, ... , 0, 0, 0] ๋ฆฌ์ŠคํŠธ 
์•„๋ž˜์ฒ˜๋Ÿผ ์ž‘์„ฑํ•˜๋ฉด ์œ„์™€ ๊ฐ™์€ ๋ฆฌ์ŠคํŠธ๊ฐ€ 20๊ฐœ๊ฐ€ ๋“ค์–ด๊ฐ„ ๋ฆฌ์ŠคํŠธ๋ฅผ ํ•œ ๋ฒˆ์— ๋งŒ๋“ค์–ด ์ค€๋‹ค.

d = [[0 for j in range(20)] for i in range(20)]

์ด๋Ÿฌํ•œ ๋ฆฌ์ŠคํŠธ ์ƒ์„ฑ ๋ฐฉ์‹์„ List Comprehensions ๋ผ๊ณ  ํ•œ๋‹ค.

 

โ–ท ํ•ด์„ค

์ด๋ฒˆ ๋ฌธ์ œ์—์„œ ๋‹ค๋ฃจ๋Š” ๋ฐ”๋‘‘ํŒ์„ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” 2์ฐจ์› ๋ฐฐ์—ด์ด ํ•„์š”ํ•˜๋‹ค.

2์ฐจ์› ๋ฐฐ์—ด์„ ํ‘œํ˜„ํ•˜๊ธฐ ์œ„ํ•ด์„œ๋‘๊ฐœ์˜ for๋ฌธ์ด ์‚ฌ์šฉ๋˜์—‡๋Š”๋ฐ board๋ฅผ ์„ ์–ธํ• ๋•Œ์ฒ˜๋Ÿผ ํ•œ์ค„๋กœ ์“ฐ๋Š” ๊ฒƒ๋„ ๊ฐ€๋Šฅํ•˜๊ณ  ์ถœ๋ ฅํ• ๋•Œ ์ฒ˜๋Ÿผ for๋ฌธ์„ ๋‚˜์—ดํ•ด์„œ ์“ฐ๋Š” ๋ฐฉ์‹๋„ ์žˆ๋‹ค

n = int(input())

board = [[0 for col in range(19)]for row in range(19)]

for _ in range(n):
    x, y = map(int, input().split())
    board[x-1][y-1] = 1

for col in range(19):
    for row in range(19):
        print(board[col][row], end=" ")
    print()

 

6096 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ๋ฐ”๋‘‘์•Œ ์‹ญ์ž ๋’ค์ง‘๊ธฐ(py)

๋ถ€๋ชจ๋‹˜์„ ๊ธฐ๋‹ค๋ฆฌ๋˜ ์˜์ผ์ด๋Š” ๊ฒ€์ •/ํฐ ์ƒ‰ ๋ฐ”๋‘‘์•Œ์„ ๋ฐ”๋‘‘ํŒ์— ๊ฝ‰ ์ฑ„์›Œ ๊น”์•„ ๋†“๊ณ  ๋†€๋‹ค๊ฐ€...

"์‹ญ(+)์ž ๋’ค์ง‘๊ธฐ๋ฅผ ํ•ด๋ณผ๊นŒ?"ํ•˜๊ณ  ์ƒ๊ฐํ–ˆ๋‹ค.

์‹ญ์ž ๋’ค์ง‘๊ธฐ๋Š”
๊ทธ ์œ„์น˜์— ์žˆ๋Š” ๋ชจ๋“  ๊ฐ€๋กœ์ค„ ๋Œ์˜ ์ƒ‰์„ ๋ฐ˜๋Œ€(1->0, 0->1)๋กœ ๋ฐ”๊พผ ํ›„, 
๋‹ค์‹œ ๊ทธ ์œ„์น˜์— ์žˆ๋Š” ๋ชจ๋“  ์„ธ๋กœ์ค„ ๋Œ์˜ ์ƒ‰์„ ๋ฐ˜๋Œ€๋กœ ๋ฐ”๊พธ๋Š” ๊ฒƒ์ด๋‹ค.
์–ด๋–ค ์œ„์น˜๋ฅผ ๊ณจ๋ผ ์ง‘์ž ๋’ค์ง‘๊ธฐ๋ฅผ ํ•˜๋ฉด, ๊ทธ ์œ„์น˜๋ฅผ ์ œ์™ธํ•œ ๊ฐ€๋กœ์ค„๊ณผ ์„ธ๋กœ์ค„์˜ ์ƒ‰์ด ๋ชจ๋‘ ๋ฐ˜๋Œ€๋กœ ๋ฐ”๋€๋‹ค.

๋ฐ”๋‘‘ํŒ(19 * 19)์— ํฐ ๋Œ(1) ๋˜๋Š” ๊ฒ€์ • ๋Œ(0)์ด ๋ชจ๋‘ ๊ฝ‰ ์ฑ„์›Œ์ ธ ๋†“์—ฌ์žˆ์„ ๋•Œ,
n๊ฐœ์˜ ์ขŒํ‘œ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ ์‹ญ(+)์ž ๋’ค์ง‘๊ธฐํ•œ ๊ฒฐ๊ณผ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

๋ฆฌ์ŠคํŠธ๊ฐ€ ๋“ค์–ด์žˆ๋Š” ๋ฆฌ์ŠคํŠธ๋ฅผ ๋งŒ๋“ค๋ฉด?
๊ฐ€๋กœ๋ฒˆํ˜ธ, ์„ธ๋กœ๋ฒˆํ˜ธ๋ฅผ ์‚ฌ์šฉํ•ด 2์ฐจ์› ํ˜•ํƒœ์˜ ๋ฐ์ดํ„ฐ์ฒ˜๋Ÿผ ์‰ฝ๊ฒŒ ๊ธฐ๋กํ•˜๊ณ  ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
๋ฆฌ์ŠคํŠธ์ด๋ฆ„[๋ฒˆํ˜ธ][๋ฒˆํ˜ธ] ํ˜•์‹์œผ๋กœ ์ €์žฅ๋˜์–ด์žˆ๋Š” ๊ฐ’์„ ์ฝ๊ณ  ์“ธ ์ˆ˜ ์žˆ๋‹ค.

 

โ–ท ํ•ด์„ค

์ด๋ฒˆ์—๋Š” board์˜ ๋ชจ๋“  ํ–‰์„ ์ง์ ‘ ์ž…๋ ฅ๋ฐ›๊ธฐ ์œ„ํ•ด์„œ for๋ฌธ์„ ์ด์šฉํ•ด ๊ฐ ์ค„๋งˆ๋‹ค list๋ฅผ ๋ฐ›์€๋’ค board์— appendํ•ด์ค€๋‹ค.

์‹ญ์ž ๋’ค์ง‘๊ธฐ๋ฅผ ํ•˜๊ธฐ์œ„ํ•ด์„œ๋Š” ๊ฐ€๋กœ ๋จผ์ € 0์ด๋ฉด 1๋กœ 1์ด๋ฉด 0์œผ๋กœ ๋ณ€๊ฒฝํ•œ ๋’ค ์„ธ๋กœ์˜ ๊ฐ’๋„ ๊ฐ™์€ ๋™์ž‘์„ ์ง„ํ–‰ํ•˜๋ฉด ๋œ๋‹ค

board = []

for col in range(19):
    row = list(map(int, input().split()))
    board.append(row)

n = int(input())

for _ in range(n):
    x, y = map(int, input().split())

    for i in range(19):
        if board[x-1][i] == 1:
            board[x-1][i] = 0
        else:
            board[x-1][i] = 1

    for j in range(19):
        if board[j][y-1] == 1:
            board[j][y-1] = 0
        else:
            board[j][y-1] = 1

for col in range(19):
    for row in range(19):
        print(board[col][row], end=" ")
    print()

 

6097 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ์„คํƒ•๊ณผ์ž ๋ฝ‘๊ธฐ(py)

๋ถ€๋ชจ๋‹˜๊ณผ ํ•จ๊ป˜ ๋†€๋Ÿฌ๊ฐ„ ์˜์ผ์ด๋Š”
์„คํƒ•๊ณผ์ž(์„คํƒ•์„ ๋…น์—ฌ ๋ฌผ๊ณ ๊ธฐ ๋“ฑ์˜ ๋ชจ์–‘์„ ๋งŒ๋“  ๊ฒƒ) ๋ฝ‘๊ธฐ๋ฅผ ๋ณด๊ฒŒ ๋˜์—ˆ๋‹ค.

๊ธธ์ด๊ฐ€ ๋‹ค๋ฅธ ๋ช‡ ๊ฐœ์˜ ๋ง‰๋Œ€๋ฅผ ๋ฐ”๋‘‘ํŒ๊ณผ ๊ฐ™์€ ๊ฒฉ์žํŒ์— ๋†“๋Š”๋ฐ,

๋ง‰๋Œ€์— ์žˆ๋Š” ์„คํƒ•๊ณผ์ž ์ด๋ฆ„ ์•„๋ž˜์— ์žˆ๋Š” ๋ฒˆํ˜ธ๋ฅผ ๋ฝ‘์œผ๋ฉด ์„คํƒ•๊ณผ์ž๋ฅผ ๊ฐ€์ ธ๊ฐ€๋Š” ๊ฒŒ์ž„์ด์—ˆ๋‹ค.
(์ž‰์–ด, ๋ถ•์–ด, ์šฉ ๋“ฑ ์—ฌ๋Ÿฌ ๊ฐ€์ง€๊ฐ€ ์ ํ˜€์žˆ๋‹ค.)

 

๊ฒฉ์žํŒ์˜ ์„ธ๋กœ(h), ๊ฐ€๋กœ(w), ๋ง‰๋Œ€์˜ ๊ฐœ์ˆ˜(n), ๊ฐ ๋ง‰๋Œ€์˜ ๊ธธ์ด(l),
๋ง‰๋Œ€๋ฅผ ๋†“๋Š” ๋ฐฉํ–ฅ(d:๊ฐ€๋กœ๋Š” 0, ์„ธ๋กœ๋Š” 1)๊ณผ
๋ง‰๋Œ€๋ฅผ ๋†“๋Š” ๋ง‰๋Œ€์˜ ๊ฐ€์žฅ ์™ผ์ชฝ ๋˜๋Š” ์œ„์ชฝ์˜ ์œ„์น˜(x, y)๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ,

๊ฒฉ์žํŒ์„ ์ฑ„์šด ๋ง‰๋Œ€์˜ ๋ชจ์–‘์„ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ณด์ž.

 

โ–ท ํ•ด์„ค

์ด๋ฒˆ ๋ฌธ์ œ์—์„œ๋Š” ์‹ ๊ฒฝ์จ์•ผ ํ•  ๊ฐ’์ด ๋งŽ์•„์ง„๋‹ค. h์™€ w๋กœ ๋ฐฐ์—ด์˜ ํฌ๊ธฐ๊ฐ€ ์ง€์ •๋˜์—ˆ์œผ๋ฉฐ l์˜ ๊ธธ์ด๋งŒํผ 2์ฐจ์› ๋ฐฐ์—ด์— ์ฒดํฌํ•ด์ค˜์•ผํ•œ๋‹ค๋Š” ์กฐ๊ฑด์ด ์ƒ๊ฒผ๋‹ค.

์ด๋ฅผ ํ•ด๊ฒฐํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๊ฐ€์žฅ ์ฒ˜์Œ l์ด ๋†“์ธ ์œ„์น˜๊ฐ€ ๊ฐ€๋กœ์ธ์ง€ ์„ธ๋กœ์ธ์ง€ ๊ตฌ๋ถ„ํ•œ๋‹ค.

์ดํ›„ for๋ฌธ์˜ ์‹œ์ž‘์ ์„ ๊ฐ€๋กœ์ผ ๊ฒฝ์šฐ ์ง€์ •๋œ y์ง€์ ์—์„œ ๋ถ€ํ„ฐ l์˜ ํฌ๊ธฐ๋งŒํผ ์ฑ„์ƒ‰ํ•˜๊ณ , ์„ธ๋กœ์ผ ๊ฒฝ์šฐ ์ง€์ •๋œ x์ง€์ ์—์„œ ๋ถ€ํ„ฐ l์˜ ํฌ๊ธฐ๋งŒํผ ์ฑ„์ƒ‰ํ•˜๋ฉด ๋œ๋‹ค.

h, w = map(int, input().split())
board = [[0 for row in range(w)] for col in range(h)]

n = int(input())
for _ in range(n):
    l, d, x, y = map(int, input().split())

    # ๊ฐ€๋กœ i์˜ ๊ฐ’๋งŒ ๋ณ€๊ฒฝ
    if d == 0:
        for i in range(y-1, w):
            if l != 0:
                board[x - 1][i] = 1
                l -= 1
    # ์„ธ๋กœ j์˜ ๊ฐ’๋งŒ ๋ณ€๊ฒฝ
    elif d == 1:
        for j in range(x-1, h):
            if l != 0:
                board[j][y - 1] = 1
                l -= 1

for col in range(h):
    for row in range(w):
        print(board[col][row], end=" ")
    print()

 

6098 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ์„ฑ์‹คํ•œ ๊ฐœ๋ฏธ(py)

์˜์ผ์ด๋Š” ์ƒ๋ช…๊ณผํ•™์— ๊ด€์‹ฌ์ด ์ƒ๊ฒจ ์™•๊ฐœ๋ฏธ๋ฅผ ์—ฐ๊ตฌํ•˜๊ณ  ์žˆ์—ˆ๋‹ค.

์™•๊ฐœ๋ฏธ๋ฅผ ์œ ์‹ฌํžˆ ์‚ดํŽด๋ณด๋˜ ์ค‘ ํŠน๋ณ„ํžˆ ์„ฑ์‹คํ•ด ๋ณด์ด๋Š” ๊ฐœ๋ฏธ๊ฐ€ ์žˆ์—ˆ๋Š”๋ฐ,
๊ทธ ๊ฐœ๋ฏธ๋Š” ๊ฐœ๋ฏธ๊ตด์—์„œ ๋‚˜์™€ ๋จน์ด๊นŒ์ง€ ๊ฐ€์žฅ ๋น ๋ฅธ ๊ธธ๋กœ ์ด๋™ํ•˜๋Š” ๊ฒƒ์ด์—ˆ๋‹ค.

๊ฐœ๋ฏธ๋Š” ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์›€์ง์ด๋‹ค๊ฐ€ ๋ฒฝ์„ ๋งŒ๋‚˜๋ฉด ์•„๋ž˜์ชฝ์œผ๋กœ ์›€์ง์—ฌ ๊ฐ€์žฅ ๋น ๋ฅธ ๊ธธ๋กœ ์›€์ง์˜€๋‹ค.
(์˜ค๋ฅธ์ชฝ์— ๊ธธ์ด ๋‚˜ํƒ€๋‚˜๋ฉด ๋‹ค์‹œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์›€์ง์ธ๋‹ค.)

์ด์— ํ˜ธ๊ธฐ์‹ฌ์ด ์ƒ๊ธด ์˜์ผ์ด๋Š” ๊ทธ ๊ฐœ๋ฏธ๋ฅผ ๋ฏธ๋กœ ์ƒ์ž์— ๋„ฃ๊ณ  ์‚ดํŽด๋ณด๊ธฐ ์‹œ์ž‘ํ•˜์˜€๋‹ค.

๋ฏธ๋กœ ์ƒ์ž์— ๋„ฃ์€ ๊ฐœ๋ฏธ๋Š” ๋จน์ด๋ฅผ ์ฐพ์•˜๊ฑฐ๋‚˜, ๋” ์ด์ƒ ์›€์ง์ผ ์ˆ˜ ์—†์„ ๋•Œ๊นŒ์ง€
์˜ค๋ฅธ์ชฝ ๋˜๋Š” ์•„๋ž˜์ชฝ์œผ๋กœ๋งŒ ์›€์ง์˜€๋‹ค.

๋ฏธ๋กœ ์ƒ์ž์˜ ๊ตฌ์กฐ๊ฐ€ 0(๊ฐˆ ์ˆ˜ ์žˆ๋Š” ๊ณณ), 1(๋ฒฝ ๋˜๋Š” ์žฅ์• ๋ฌผ)๋กœ ์ฃผ์–ด์ง€๊ณ ,
๋จน์ด๊ฐ€ 2๋กœ ์ฃผ์–ด์งˆ ๋•Œ, ์„ฑ์‹คํ•œ ๊ฐœ๋ฏธ์˜ ์ด๋™ ๊ฒฝ๋กœ๋ฅผ ์˜ˆ์ƒํ•ด๋ณด์ž.

๋‹จ, ๋งจ ์•„๋ž˜์˜ ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ์— ๋„์ฐฉํ•œ ๊ฒฝ์šฐ, ๋” ์ด์ƒ ์›€์ง์ผ ์ˆ˜ ์—†๋Š” ๊ฒฝ์šฐ, ๋จน์ด๋ฅผ ์ฐพ์€ ๊ฒฝ์šฐ์—๋Š”
๋”์ด์ƒ ์ด๋™ํ•˜์ง€ ์•Š๊ณ  ๊ทธ ๊ณณ์— ๋จธ๋ฌด๋ฅธ๋‹ค๊ณ  ๊ฐ€์ •ํ•œ๋‹ค.

๋ฏธ๋กœ ์ƒ์ž์˜ ํ…Œ๋‘๋ฆฌ๋Š” ๋ชจ๋‘ ๋ฒฝ์œผ๋กœ ๋˜์–ด ์žˆ์œผ๋ฉฐ,
๊ฐœ๋ฏธ์ง‘์€ ๋ฐ˜๋“œ์‹œ (2, 2)์— ์กด์žฌํ•˜๊ธฐ ๋•Œ๋ฌธ์— ๊ฐœ๋ฏธ๋Š” (2, 2)์—์„œ ์ถœ๋ฐœํ•œ๋‹ค.

 

โ–ท ํ•ด์„ค

๊ฐœ๋ฏธ๋Š” ๋ฌด์กฐ๊ฑด ์˜ค๋ฅธ์ชฝ(y+1)์ด๋‚˜ ์•„๋ž˜(x+1)๋กœ๋งŒ ์›€์ง์ธ๋‹ค.

๋˜ํ•œ ๋ฏธ๋กœ๋Š” ๋ฒฝ์œผ๋กœ ๊ฐ์‹ธ ์žˆ๊ธฐ ๋•Œ๋ฌธ์— ์˜ค๋ฅธ์ชฝ๊ณผ ์•„๋ž˜๊ฐ€ ๋ชจ๋‘ 1์ด๋ฉด ๋”์ด์ƒ ๊ฐˆ๊ณณ์ด ์—†๋Š” ๊ฑธ ์˜๋ฏธํ•œ๋‹ค.

์ฆ‰ ์šฐ๋ฆฌ๊ฐ€ ๋ฐ˜๋ณต๋ฌธ์„ ํƒˆ์ถœํ•˜๊ธฐ ์œ„ํ•œ ๋‘ ์กฐ๊ฑด์€ y+1๊ณผ x+1์ด ๋ชจ๋‘ 1์ด๊ฑฐ๋‚˜ ๋จน์ด๋ฅผ ๋จน์€ ๊ฒฝ์šฐ์ด๋‹ค.

์ง€๊ธˆ๊นŒ์ง€ ๋ง๋กœ ์ •์˜ํ–ˆ๋˜ ๋‚ด์šฉ์„ ์ฝ”๋“œ๋กœ ํ‘œํ˜„ํ•ด ๋ณด์ž.

board = []
for col in range(10):
    row = list(map(int, input().split()))
    board.append(row)

x, y = 1, 1

while True:
    if board[x][y] == 2:
        board[x][y] = 9
        break
    else:
        board[x][y] = 9

    if board[x][y+1] == 1 and board[x+1][y] == 1:
        break

    if board[x][y+1] != 1:
        y += 1
    elif board[x+1][y] != 1:
        x += 1

for col in range(10):
    for row in range(10):
        print(board[col][row], end=" ")
    print()

 

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€๋ฅผ ์œ„ํ•ด ์ฝ”๋“œ์—… ์‚ฌ์ดํŠธ(https://codeup.kr/)์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค.

๋ธ”๋กœ๊ทธ์— ์˜ฌ๋ผ์˜จ ๋ชจ๋“  ์ฝ”๋“œ๋Š” ํŒŒ์ด์ฌ(Python)์œผ๋กœ ์ž‘์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.   

 

Python์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ ์‚ฌ์ดํŠธ๋กœ ์ด๋™ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. 

https://codeup.kr/problemsetsol.php?psid=33 

 

๋ฌธ์ œ์ง‘ / Python ๊ธฐ์ดˆ 100์ œ

 

codeup.kr

 

6091 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ํ•จ๊ป˜ ๋ฌธ์ œ ํ‘ธ๋Š” ๋‚ (์„ค๋ช…)(py)

๋ฐ˜์ธ, ๊ตฐ์ธ, ํ”„๋กœ๊ทธ๋ž˜๋จธ, ํƒ‘์ฝ”๋” ๋“ฑ ์•„์ฃผ ๋งŽ์€ ์‚ฌ๋žŒ๋“ค์ด ๋“ค์–ด์™€ ๋ฌธ์ œ๋ฅผ ํ’€๊ณ  ์žˆ๋Š”๋ฐ,

์‹ค์‹œ๊ฐ„ ์ฑ„์  ์ •๋ณด๋Š” ๋ฉ”๋‰ด์˜ ์ฑ„์ ๊ธฐ๋ก(Judge Status)์„ ํ†ตํ•ด ์‚ดํŽด๋ณผ ์ˆ˜ ์žˆ๋‹ค.

์ž! ์—ฌ๊ธฐ์„œ...์ž ๊น..
๊ฐ™์€ ๋‚  ๋™์‹œ์— ๊ฐ€์ž…ํ•œ 3๋ช…์˜ ์‚ฌ๋žŒ๋“ค์ด ์˜จ๋ผ์ธ ์ฑ„์ ์‹œ์Šคํ…œ์— ๋“ค์–ด์™€ ๋ฌธ์ œ๋ฅผ ํ‘ธ๋Š” ๋‚ ์งœ๊ฐ€
๋งค์šฐ ๊ทœ์น™์ ์ด๋ผ๊ณ  ํ•  ๋•Œ, ๋‹ค์‹œ ๋ชจ๋‘ ํ•จ๊ป˜ ๋ฌธ์ œ๋ฅผ ํ’€๊ฒŒ ๋˜๋Š” ๊ทธ๋‚ ์€ ์–ธ์ œ์ผ๊นŒ?

์˜ˆ๋ฅผ ๋“ค์–ด 3๋ช…์ด ๊ฐ™์€ ๋‚  ๊ฐ€์ž…/๋“ฑ์—…ํ•˜๊ณ , ๊ฐ๊ฐ 3์ผ๋งˆ๋‹ค, 7์ผ๋งˆ๋‹ค, 9์ผ๋งˆ๋‹ค
ํ•œ ๋ฒˆ์”ฉ ๋“ค์–ด์˜จ๋‹ค๋ฉด, ์ฒ˜์Œ ๊ฐ€์ž…ํ•˜๊ณ  63์ผ ๋งŒ์— ๋‹ค์‹œ 3๋ช…์ด ํ•จ๊ป˜ ๋ฌธ์ œ๋ฅผ ํ’€๊ฒŒ ๋œ๋‹ค.

๊ฐ‘์ž๊ธฐ ํžŒํŠธ?
์™ ์ง€ ์–ด๋ ค์›Œ ๋ณด์ด์ง€ ์•Š๋Š”๊ฐ€?
์ˆ˜ํ•™์—์„œ ๋ฐฐ์šด ์ตœ์†Œ๊ณต๋ฐฐ์ˆ˜๋ฅผ ์ƒ๊ฐํ•œ ์‚ฌ๋žŒ๋“ค๋„ ์žˆ์„ ๊ฒƒ์ด๋‹ค. ํ•˜์ง€๋งŒ, ์ •๋ณด์—์„œ ๋ฐฐ์šฐ๊ณ  ๊ฒฝํ—˜ํ•˜๋Š”
์ •๋ณด๊ณผํ•™์˜ ์„ธ์ƒ์€ ๋•Œ๋•Œ๋กœ ์ปดํ“จํ„ฐ์˜ ํž˜์„ ๋นŒ๋ ค ๊ฐ„๋‹จํ•œ ๋ฐฉ๋ฒ•์œผ๋กœ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๊ฒŒ ํ•œ๋‹ค.

์•„๋ž˜์˜ ์ฝ”๋“œ๋ฅผ ์ฝ๊ณ  ์ดํ•ดํ•œ ํ›„ ๋„์ „ํ•ด ๋ณด์ž.
day๋Š” ๋‚  ์ˆ˜, a/b/c๋Š” ๋ฐฉ๋ฌธ ์ฃผ๊ธฐ์ด๋‹ค.

 

๋ฌผ๋ก , ์•„์ฃผ ๋งŽ์€ ๋‹ค์–‘ํ•œ ๋ฐฉ๋ฒ•์ด ์žˆ์„ ์ˆ˜ ์žˆ๋‹ค.

์ •๋ณด๊ณผํ•™์˜ ๋ฌธ์ œํ•ด๊ฒฐ์— ์žˆ์–ด์„œ ์ •๋‹ต์€?
ํ•˜๋‚˜๊ฐ€ ์•„๋‹ˆ๋ผ ์ฃผ์–ด์ง„ ์‹œ๊ฐ„/๊ธฐ์–ต๊ณต๊ฐ„์œผ๋กœ ์ •ํ™•ํ•œ ๊ฒฐ๊ณผ๋ฅผ ์–ป์„ ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๋ฐฉ๋ฒ•์ด๋‹ค.

๋”ฐ๋ผ์„œ, ๋ชจ๋“  ๋ฌธ์ œ๋“ค์—๋Š” ์ •๋‹ต์ด ํ•˜๋‚˜๋ฟ๋งŒ์ด ์•„๋‹ˆ๋‹ค.
์ƒˆ๋กœ์šด, ๋” ๋น ๋ฅธ, ๋” ๊ฐ„๋‹จํ•œ ๋ฐฉ๋ฒ•์„ ๋‹ค์–‘ํ•˜๊ฒŒ ์ƒ๊ฐํ•ด๋ณด๊ณ  ์—ฌ๋Ÿฌ๊ฐ€์ง€ ๋ฐฉ๋ฒ•์œผ๋กœ ๋„์ „ํ•ด ๋ณผ ์ˆ˜ ์žˆ๋‹ค.

 

โ–ท ํ•ด์„ค

a์™€ b, c ๋ชจ๋‘ ๊ฐ™์ด ๋“ค์–ด์˜ค๋Š” ๋‚ ์—๋Š” day์™€ ๋‚˜๋ˆŒ ๊ฒฝ์šฐ 0์ด ๋‚˜์˜จ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด a=3, b=7, c=9 ์ผ ๊ฒฝ์šฐ 63์ด ์ •๋‹ต์ด ๋˜๋Š”๋ฐ 63์„ 3์œผ๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๊ฐ€ 0, 63์„ 7๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๊ฐ€ 0, 63์„ 9๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๊ฐ€ 0์ด ๋œ๋‹ค๋Š” ํŠน์ง•์„ ๊ฐ€์ง„๋‹ค.

์ด ๋ฐฉ๋ฒ•์„ ์ด์šฉํ•ด ๋ฐ˜๋ณต๋ฌธ์ด ๋๋‚˜๋Š” ์กฐ๊ฑด์„ ๊ฑธ ์ˆ˜ ์žˆ๋‹ค

a, b, c = map(int, input().split())

day = 1
while True:
    if day % a == 0 and day % b == 0 and day % c == 0:
        break
    day += 1

print(day)

 

6092 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ์ด์ƒํ•œ ์ถœ์„ ๋ฒˆํ˜ธ ๋ถ€๋ฅด๊ธฐ1(์„ค๋ช…)(py)

์ •๋ณด ์„ ์ƒ๋‹˜์€ ์ˆ˜์—…์„ ์‹œ์ž‘ํ•˜๊ธฐ ์ „์— ์ด์ƒํ•œ ์ถœ์„์„ ๋ถ€๋ฅธ๋‹ค.

์„ ์ƒ๋‹˜์€ ์ถœ์„๋ถ€๋ฅผ ๋ณด๊ณ  ๋ฒˆํ˜ธ๋ฅผ ๋ถ€๋ฅด๋Š”๋ฐ,
ํ•™์ƒ๋“ค์˜ ์–ผ๊ตด๊ณผ ์ด๋ฆ„์„ ๋นจ๋ฆฌ ์ตํžˆ๊ธฐ ์œ„ํ•ด ๋ฒˆํ˜ธ๋ฅผ ๋ฌด์ž‘์œ„(๋žœ๋ค)์œผ๋กœ ๋ถ€๋ฅธ๋‹ค.

๊ทธ๋ฆฌ๊ณ  ์–ผ๊ตด๊ณผ ์ด๋ฆ„์ด ์ž˜ ๊ธฐ์–ต๋˜์ง€ ์•Š๋Š” ํ•™์ƒ๋“ค์€ ๋ฒˆํ˜ธ๋ฅผ ์—ฌ๋Ÿฌ ๋ฒˆ ๋ถˆ๋Ÿฌ
์ด๋ฆ„๊ณผ ์–ผ๊ตด์„ ๋นจ๋ฆฌ ์ตํžˆ๋ ค๊ณ  ํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

์ถœ์„ ๋ฒˆํ˜ธ๋ฅผ n๋ฒˆ ๋ฌด์ž‘์œ„๋กœ ๋ถˆ๋ €์„ ๋•Œ, ๊ฐ ๋ฒˆํ˜ธ(1 ~ 23)๊ฐ€ ๋ถˆ๋ฆฐ ํšŸ์ˆ˜๋ฅผ ๊ฐ๊ฐ ์ถœ๋ ฅํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

- d = []              #์–ด๋–ค ๋ฐ์ดํ„ฐ ๋ชฉ๋ก(list) ์„ ์ˆœ์„œ๋Œ€๋กœ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•ด ์•„๋ฌด๊ฒƒ๋„ ์—†๋Š” ๋ฆฌ์ŠคํŠธ ๋ณ€์ˆ˜ ๋งŒ๋“ค๊ธฐ
- d.append(๊ฐ’)  #d ๋ฆฌ์ŠคํŠธ์˜ ๋งˆ์ง€๋ง‰์— ์›ํ•˜๋Š” ๊ฐ’์„ ์ถ”๊ฐ€(append)ํ•ด ๋„ฃ์Œ 
- d[a[i]] += 1     #2์ค‘ ๋ฆฌ์ŠคํŠธ ์ฐธ์กฐ : ๋งŒ์•ฝ a[i]์˜ ๊ฐ’์ด 1์ด์—ˆ๋‹ค๋ฉด? d[1] += 1 ์ด ์‹คํ–‰๋˜๋Š” ๊ฒƒ์ด๋‹ค. 1๋ฒˆ ์นด์šดํŠธ 1๊ฐœ ์ฆ๊ฐ€..

์–ด๋–ค ๊ฐ’์„ ๊ธฐ๋กํ–ˆ๋‹ค๊ฐ€ ๋‹ค์‹œ ์‚ฌ์šฉํ•  ํ•„์š”๊ฐ€ ์žˆ์„ ๋•Œ, ํ•„์š”ํ•œ ๋ณ€์ˆ˜(variable)๋ฅผ ๋งŒ๋“ค์–ด ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ฒ˜๋Ÿผ,
์—ฌ๋Ÿฌ ๊ฐœ์˜ ๊ฐ’์„ ํ•˜๋‚˜๋กœ ๋ฌถ์–ด ๋ชฉ๋ก์œผ๋กœ ๊ธฐ๋กํ–ˆ๋‹ค๊ฐ€ ๋‹ค์‹œ ์‚ฌ์šฉํ•  ํ•„์š”๊ฐ€ ์žˆ์„ ๋•Œ, ๋ฆฌ์ŠคํŠธ(list)๋ฅผ ๋งŒ๋“ค์–ด ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
๋ฆฌ์ŠคํŠธ๋Š” ๋ณ€์ˆ˜๋“ค์„ ๋ชจ์•„ ๋†“์€ ๋ณ€์ˆ˜๋ผ๊ณ  ์ƒ๊ฐํ•  ์ˆ˜๋„ ์žˆ๊ณ , ์ฐธ์กฐ๋ฒˆํ˜ธ๋ฅผ ์ด์šฉํ•ด ๊ฐ„๋‹จํ•˜๊ณ  ํŽธ๋ฆฌํ•˜๊ฒŒ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

 

โ–ท ํ•ด์„ค

nlist๋Š” n๋ฒˆ ๋ถ€๋ฅธ ํ•™์ƒ๋“ค์˜ ๊ฐ’์„ ํ•œ ์ค„๋กœ ๋ฐ›์€ ๋’ค ๋ฆฌ์ŠคํŠธ ํ˜•์‹์œผ๋กœ ์ €์žฅํ•œ๋‹ค.

์šฐ๋ฆฌ๋Š” ์ด 23๋ช…์˜ ํ•™์ƒ์ด ์žˆ๋Š”๊ฑธ ์•Œ๊ณ  ์žˆ์œผ๋ฏ€๋กœ 23๋ฒˆ์งธ ์ธ๋ฑ์Šค๊นŒ์ง€ 0์ธ students๋ฆฌ์ŠคํŠธ๋ฅผ ์ดˆ๊ธฐํ™” ์‹œํ‚จ๋‹ค.

์ดํ›„ ์ด ์ด๋ฆ„์„ ๋ถ€๋ฅธ ํšŸ์ˆ˜๋งŒํผ ๋ฐ˜๋ณต๋ฌธ์„ ๋Œ๋ฉฐ nlist์˜ ๊ฐ’์„ ๊บผ๋‚ด์˜จ ๋’ค ์ด๋ฆ„์ด ๋ถˆ๋Ÿฌ์ง„ ํ•™์ƒ์˜ list์˜ ๊ฐ’์„ 1 ๋”ํ•ด์ค€๋‹ค.

๋งˆ์ง€๋ง‰์œผ๋กœ ํ˜ธ์ถœ ๋œ ํšŸ์ˆ˜๋ฅผ ๋ชจ๋‘ ์ถœ๋ ฅํ•˜๋ฉด ๋œ๋‹ค

n = int(input())
nlist = list(map(int, input().split()))

students = [0 for _ in range(23)]

for i in range(n):
    students[nlist[i]-1] += 1

for i in range(23):
    print(students[i], end=" ")

 

6093 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ์ด์ƒํ•œ ์ถœ์„ ๋ฒˆํ˜ธ ๋ถ€๋ฅด๊ธฐ2(py)

์ •๋ณด ์„ ์ƒ๋‹˜์€ ์ˆ˜์—…์„ ์‹œ์ž‘ํ•˜๊ธฐ ์ „์— ์ด์ƒํ•œ ์ถœ์„์„ ๋ถ€๋ฅธ๋‹ค.

ํ•™์ƒ๋“ค์˜ ์–ผ๊ตด๊ณผ ์ด๋ฆ„์„ ๋นจ๋ฆฌ ์ตํžˆ๊ธฐ ์œ„ํ•ด ๋ฒˆํ˜ธ๋ฅผ ๋ฌด์ž‘์œ„(๋žœ๋ค)์œผ๋กœ ๋ถ€๋ฅด๋Š”๋ฐ,
์˜์ผ์ด๋Š” ์„ ์ƒ๋‹˜์ด ๋ถ€๋ฅธ ๋ฒˆํ˜ธ๋“ค์„ ๊ธฐ์–ตํ•˜๊ณ  ์žˆ๋‹ค๊ฐ€ ๊ฑฐ๊พธ๋กœ ๋ถˆ๋Ÿฌ๋ณด๋Š” ๊ฒƒ์„ ํ•ด๋ณด๊ณ  ์‹ถ์–ด์กŒ๋‹ค.

์ถœ์„ ๋ฒˆํ˜ธ๋ฅผ n๋ฒˆ ๋ฌด์ž‘์œ„๋กœ ๋ถˆ๋ €์„ ๋•Œ, ๋ถ€๋ฅธ ๋ฒˆํ˜ธ๋ฅผ ๊ฑฐ๊พธ๋กœ ์ถœ๋ ฅํ•ด ๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

python์—์„œ๋Š” list๋ฅผ stack๋Œ€์‹  ์ด์šฉํ•˜๊ธฐ๋„ ํ•œ๋‹ค. ์ด๋Ÿฐ ํŠน์ง•์„ ๊ฐ€์ง€๊ณ  pop์„ ํ•˜๊ฒŒ ๋˜๋ฉด ๋งจ๋’ค์˜ ๊ฐ’์ด ๋น ์ ธ๋‚˜์˜ค๊ณ  list์—์„œ๋Š” ์‚ญ์ œ๊ฐ€ ๋œ๋‹ค. ์ด ๋ฐฉ๋ฒ•์„ ํ†ตํ•ด nlist๊ฐ€ ๋นŒ๋•Œ๊นŒ์ง€ ๊ฐ’์„ popํ•˜๋ฉด ๋ฒˆํ˜ธ๊ฐ€ ๊ฑฐ๊พธ๋กœ ์ถœ๋ ฅ๋œ๋‹ค.

 

n = int(input())
nlist = list(map(int, input().split()))

while nlist:
    print(nlist.pop(), end=" ")

 

6094 : [๊ธฐ์ดˆ-๋ฆฌ์ŠคํŠธ] ์ด์ƒํ•œ ์ถœ์„ ๋ฒˆํ˜ธ ๋ถ€๋ฅด๊ธฐ3(py)

์ •๋ณด ์„ ์ƒ๋‹˜์€ ์˜ค๋Š˜๋„ ์ด์ƒํ•œ ์ถœ์„์„ ๋ถ€๋ฅธ๋‹ค.

์˜์ผ์ด๋Š” ์˜ค๋Š˜๋„ ๋‹ค๋ฅธ ์ƒ๊ฐ์„ ํ•ด๋ณด์•˜๋‹ค.
์ถœ์„ ๋ฒˆํ˜ธ๋ฅผ ๋‹ค ๋ถ€๋ฅด์ง€๋Š” ์•Š์€ ๊ฒƒ ๊ฐ™์€๋ฐ... ๊ฐ€์žฅ ๋น ๋ฅธ ๋ฒˆํ˜ธ๊ฐ€ ๋ญ์˜€์ง€?

์ถœ์„ ๋ฒˆํ˜ธ๋ฅผ n๋ฒˆ ๋ฌด์ž‘์œ„๋กœ ๋ถˆ๋ €์„ ๋•Œ, ๊ฐ€์žฅ ๋น ๋ฅธ ๋ฒˆํ˜ธ๋ฅผ ์ถœ๋ ฅํ•ด ๋ณด์ž.

๋‹จ, 
์ฒซ ๋ฒˆ์งธ ๋ฒˆํ˜ธ์™€ ๋งˆ์ง€๋ง‰ ๋ฒˆํ˜ธ๊ฐ€ ๋ช‡ ๋ฒˆ์ธ์ง€๋Š” ์•„๋ฌด๋„ ๋ชจ๋ฅธ๋‹ค.
์Œ์ˆ˜(-) ๋ฒˆํ˜ธ, 0๋ฒˆ ๋ฒˆํ˜ธ๋„ ์žˆ์„ ์ˆ˜ ์žˆ๋‹ค.

์ฐธ๊ณ 
๋ฆฌ์ŠคํŠธ์— ์ถœ์„ ๋ฒˆํ˜ธ๋ฅผ ๊ธฐ๋กํ•ด ๋‘์—ˆ๋‹ค๊ฐ€, ๊ทธ ์ค‘์—์„œ ๊ฐ€์žฅ ์ž‘์€ ๊ฐ’์„ ์ฐพ์•„๋‚ด๋ฉด ๋œ๋‹ค.
๊ทธ๋Ÿฐ๋ฐ, ๊ฐ€์žฅ ์ž‘์€ ๊ฐ’์€ ์–ด๋–ป๊ฒŒ ์–ด๋–ค ๊ฒƒ๊ณผ ๋น„๊ตํ•˜๊ณ , ์–ด๋–ป๊ฒŒ ์ฐพ์•„์•ผ ํ• ๊นŒ?

 

โ–ท ํ•ด์„ค

์ด์ƒํ•œ ์ถœ์„ ๋ฒˆํ˜ธ ๋ถ€๋ฅด๊ธฐ๋ฅผ ํ’€๊ธฐ ์œ„ํ•ด์„œ๋Š” list์—์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š” ํ•จ์ˆ˜๋ฅผ ์ ๊ทน ํ™œ์šฉํ•˜๋ฉด ๋œ๋‹ค.

์ด๋ฒˆ ๋ฌธ์ œ๋Š” ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ •๋ ฌํ•˜๋Š” sort๋ฅผ ์ด์šฉํ•˜๋ฉด ๊ฐ„๋‹จํ•˜๊ฒŒ ํ’€์ˆ˜ ์žˆ๋‹ค. sort๋กœ ์ •๋ ฌ๋œ ๊ฐ’ ์ค‘ ๋งจ ์•ž์˜ ๊ฐ’์ธ 0๋ฒˆ์งธ ๊ฐ’์„ ์ถœ๋ ฅํ•˜๋ฉด ๊ทธ list์•ˆ์—์„œ ๊ฐ€์žฅ ์ž‘์€ ๊ฐ’์„ ์•Œ ์ˆ˜ ์žˆ๋‹ค.  

n = int(input())
nlist = list(map(int, input().split()))

nlist.sort()

print(nlist[0])

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€๋ฅผ ์œ„ํ•ด ์ฝ”๋“œ์—… ์‚ฌ์ดํŠธ(https://codeup.kr/)์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค.

๋ธ”๋กœ๊ทธ์— ์˜ฌ๋ผ์˜จ ๋ชจ๋“  ์ฝ”๋“œ๋Š” ํŒŒ์ด์ฌ(Python)์œผ๋กœ ์ž‘์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.   

 

Python์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ ์‚ฌ์ดํŠธ๋กœ ์ด๋™ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. 

https://codeup.kr/problemsetsol.php?psid=33 

 

๋ฌธ์ œ์ง‘ / Python ๊ธฐ์ดˆ 100์ œ

 

codeup.kr

 

6086 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ๊ฑฐ๊ธฐ๊นŒ์ง€! ์ด์ œ ๊ทธ๋งŒ~(์„ค๋ช…)(py)

1, 2, 3 ... ์„ ์ˆœ์„œ๋Œ€๋กœ ๊ณ„์† ๋”ํ•ด ํ•ฉ์„ ๋งŒ๋“œ๋Š”๋ฐ,
๊ทธ ํ•ฉ์ด ์ž…๋ ฅํ•œ ์ •์ˆ˜๋ณด๋‹ค ์ž‘์„ ๋™์•ˆ๋งŒ ๊ณ„์† ๋”ํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

์ฆ‰, 1๋ถ€ํ„ฐ n๊นŒ์ง€ ์ •์ˆ˜๋ฅผ ํ•˜๋‚˜์”ฉ ๋”ํ•ด ํ•ฉ์„ ๋งŒ๋“œ๋Š”๋ฐ,
์–ด๋””๊นŒ์ง€ ๋”ํ•ด์•ผ ์ž…๋ ฅํ•œ ์ˆ˜๋ณด๋‹ค ๊ฐ™๊ฑฐ๋‚˜ ์ปค์ง€๋Š”์ง€ ์•Œ์•„๋ณด๊ณ ์ž ํ•˜๋Š” ๋ฌธ์ œ์ด๋‹ค.

ํ•˜์ง€๋งŒ, ์ด๋ฒˆ์—๋Š” ๊ทธ ๋•Œ ๊นŒ์ง€์˜ ํ•ฉ์„ ์ถœ๋ ฅํ•ด์•ผ ํ•œ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด, 57์„ ์ž…๋ ฅํ•˜๋ฉด
1+2+3+...+8+9+10=55์—์„œ ๊ทธ ๋‹ค์Œ ์ˆ˜์ธ 11์„ ๋”ํ•ด 66์ด ๋  ๋•Œ,
๊ทธ ๊ฐ’ 66์ด ์ถœ๋ ฅ๋˜์–ด์•ผ ํ•œ๋‹ค.

 

โ–ท ์ฐธ๊ณ 

์กฐ๊ฑด๋ฌธ์ด๋‚˜ ๋ฐ˜๋ณต๋ฌธ์˜ ์ฝ”๋“œ๋ธ”๋ก ์•ˆ์—์„œ break ๊ฐ€ ์‹คํ–‰๋˜๋ฉด,
๋ฐ˜๋ณต์‹คํ–‰์„ ์ค‘๋‹จ(break)ํ•˜๊ณ , ๊ฐ€์žฅ ๊ฐ€๊นŒ์šด ๋ฐ˜๋ณต ๋ธ”๋ก์˜ ๋ฐ–์œผ๋กœ ๋น ์ ธ๋‚˜๊ฐ„๋‹ค.

 

โ–ท ํ•ด์„ค

while๋ฌธ์˜ ์กฐ๊ฑด์ด ๊ฑฐ์ง“์ผ ๊ฒฝ์šฐ ๋ฐ˜๋ณต๋ฌธ์„ ๋น ์ ธ๋‚˜์˜ค๊ฒŒ ๋œ๋‹ค. ๊ทธ๋ž˜์„œ sum์ด n๋ณด๋‹ค ์ž‘์„๊ฒฝ์šฐ ์ฐธ์ด ๋˜๋ฏ€๋กœ ์ปค์ง€๊ธฐ ์ „๊นŒ์ง€๋Š ๋ฐ˜๋ณต๋ฌธ์ด ์ž‘๋™ํ•˜๊ฒŒ ๋œ๋‹ค.

์ดํ›„ c๋ผ๋Š” ๊ฐ’๊ณผ sum์„ ํ†ตํ•ด c๋Š” ๋งค ๋ฐ˜๋ณต๋งˆ๋‹ค 1์”ฉ ์ฆ๊ฐ€ํ•˜๊ณ  sum์€ ์ฆ๊ฐ€๋œ ๊ฐ’์ด ๋”ํ•ด์ง€๋Š” ์ฝ”๋“œ๋ฅผ ๊ตฌํ˜„ํ–ˆ๋‹ค

n = int(input())

c = 1
sum = 0
while sum < n:
   sum += c
   c += 1

print(sum)

 

6087 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ์ง์ˆ˜ ํ•ฉ ๊ตฌํ•˜๊ธฐ(์„ค๋ช…)(py)

1๋ถ€ํ„ฐ ์ž…๋ ฅํ•œ ์ •์ˆ˜๊นŒ์ง€ 1์”ฉ ์ฆ๊ฐ€์‹œ์ผœ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜๋˜,
3์˜ ๋ฐฐ์ˆ˜์ธ ๊ฒฝ์šฐ๋Š” ์ถœ๋ ฅํ•˜์ง€ ์•Š๋„๋ก ๋งŒ๋“ค์–ด๋ณด์ž.

์˜ˆ๋ฅผ ๋“ค๋ฉด,
1 2 4 5 7 8 10 11 13 14 ...
์™€ ๊ฐ™์ด ์ถœ๋ ฅํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

 

โ–ท ์ฐธ๊ณ 

์กฐ๊ฑด๋ฌธ์ด๋‚˜ ๋ฐ˜๋ณต๋ฌธ์˜ ์ฝ”๋“œ๋ธ”๋ก ์•ˆ์—์„œ continue ๊ฐ€ ์‹คํ–‰๋˜๋ฉด,
๋ฐ˜๋ณต ๋ธ”๋ก ์•ˆ์— ์žˆ๋Š” ๋‚˜๋จธ์ง€ ๋ถ€๋ถ„์„ ์‹คํ–‰ํ•˜์ง€ ์•Š๊ณ , ๋‹ค์Œ ๋ฐ˜๋ณต ๋‹จ๊ณ„๋กœ ๋„˜์–ด๊ฐ„๋‹ค.
์ฆ‰, ๋ฐ˜๋ณต ๋ธ”๋ก์˜ ๋‚˜๋จธ์ง€ ๋ถ€๋ถ„์€ ์‹คํ–‰๋˜์ง€ ์•Š๊ณ , ๋‹ค์Œ ๋‹จ๊ณ„์˜ ๋ฐ˜๋ณต์„ ๊ณ„์†(continue)ํ•˜๋Š” ๊ฒƒ์ด๋‹ค.

 

โ–ท ํ•ด์„ค

๋งŒ์•ฝ i๊ฐ€ 3์˜ ๋ฐฐ์ˆ˜๋ผ๋ฉด if๋ฌธ์— ๊ฑธ๋ ค์„œ continue๋˜๊ธฐ ๋•Œ๋ฌธ์— ๋ฐ‘์˜ ์ฝ”๋“œ๊ฐ€ ๋‚จ์•„์žˆ์–ด๋„ ๋‹ค์Œ i๋กœ ๋„˜์–ด๊ฐ€๊ฒŒ ๋œ๋‹ค.

๊ทธ๋ž˜์„œ ๋ฐ‘์˜ print๋ฌธ์€ else๋กœ ๋ฌถ์–ด์ฃผ์ง€ ์•Š์•„๋„ 3์˜ ๋ฐฐ์ˆ˜๊ฐ€ ์•„๋‹Œ ๊ฐ’๋งŒ ์ถœ๋ ฅํ•œ๋‹ค

n = int(input())

for i in range(1, n+1):
    if i % 3 == 0:
        continue
    print(i, end = " ")

 

6088 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ์ˆ˜ ๋‚˜์—ดํ•˜๊ธฐ1(py)

์–ด๋–ค ๊ทœ์น™์— ๋”ฐ๋ผ ์ˆ˜๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ๋‚˜์—ดํ•œ ๊ฒƒ์„ ์ˆ˜์—ด(sequences)์ด๋ผ๊ณ  ํ•œ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด
1 4 7 10 13 16 19 22 25 ... ์€
1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ด์ „์— ๋งŒ๋“  ์ˆ˜์— 3์„ ๋”ํ•ด ๋‹ค์Œ ์ˆ˜๋ฅผ ๋งŒ๋“  ์ˆ˜์—ด์ด๋‹ค.
์ด๋Ÿฌํ•œ ๊ฒƒ์„ ์ˆ˜ํ•™์—์„œ๋Š” ์•ž๋’ค ์ˆ˜๋“ค์˜ ์ฐจ์ด๊ฐ€ ๊ฐ™๋‹ค๊ณ  ํ•˜์—ฌ

๋“ฑ์ฐจ(์ฐจ์ด๊ฐ€ ๊ฐ™๋‹ค์˜ ํ•œ๋ฌธ ๋ง) ์ˆ˜์—ด์ด๋ผ๊ณ  ํ•œ๋‹ค. (๋“ฑ์ฐจ์ˆ˜์—ด : arithmetic progression/sequence)
์ˆ˜์—ด์„ ์•Œ๊ฒŒ ๋œ ์˜์ผ์ด๋Š” ๊ฐ‘์ž๊ธฐ ๊ถ๊ธˆํ•ด์กŒ๋‹ค.

"๊ทธ๋Ÿผ.... 123๋ฒˆ์งธ ๋‚˜์˜ค๋Š” ์ˆ˜๋Š” ๋ญ˜๊นŒ?"

์˜์ผ์ด๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด ๋” ํฐ ์ˆ˜๋„ ์ž๋™์œผ๋กœ ๊ณ„์‚ฐํ•˜๊ณ  ์‹ถ์–ด์กŒ๋‹ค.

์‹œ์ž‘ ๊ฐ’(a), ๋“ฑ์ฐจ(d), ๋ช‡ ๋ฒˆ์งธ์ธ์ง€๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์ •์ˆ˜(n)๊ฐ€ ์ž…๋ ฅ๋  ๋•Œ
n๋ฒˆ์งธ ์ˆ˜๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ณด์ž.

 

โ–ท ํ•ด์„ค

n๋ฒˆ ๋งŒํผ a์— d๋ฅผ ๋”ํ•˜๋Š” ์‹์„ ์ฝ”๋“œ๋กœ ์ž‘์„ฑํ•˜๋ฉด ๋œ๋‹ค.

a, d, n = map(int, input().split())

for i in range(1, n):
    a += d

print(a)

 

6089 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ์ˆ˜ ๋‚˜์—ดํ•˜๊ธฐ2(py)

์–ด๋–ค ๊ทœ์น™์— ๋”ฐ๋ผ ์ˆ˜๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ๋‚˜์—ดํ•œ ๊ฒƒ์„ ์ˆ˜์—ด(sequences)์ด๋ผ๊ณ  ํ•œ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด
2 6 18 54 162 486 ... ์€
2๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ด์ „์— ๋งŒ๋“  ์ˆ˜์— 3์„ ๊ณฑํ•ด ๋‹ค์Œ ์ˆ˜๋ฅผ ๋งŒ๋“  ์ˆ˜์—ด์ด๋‹ค.

์ด๋Ÿฌํ•œ ๊ฒƒ์„ ์ˆ˜ํ•™์—์„œ๋Š” ์•ž๋’ค ์ˆ˜๋“ค์˜ ๋น„์œจ์ด ๊ฐ™๋‹ค๊ณ  ํ•˜์—ฌ
๋“ฑ๋น„(๋น„์œจ์ด ๊ฐ™๋‹ค์˜ ํ•œ๋ฌธ ๋ง) ์ˆ˜์—ด์ด๋ผ๊ณ  ํ•œ๋‹ค. (๋“ฑ๋น„์ˆ˜์—ด : geometric progression/sequence)

๋“ฑ๋น„ ์ˆ˜์—ด์„ ์•Œ๊ฒŒ๋œ ์˜์ผ์ด๋Š” ๊ฐ‘์ž๊ธฐ ๊ถ๊ธˆํ•ด์กŒ๋‹ค.
"๊ทธ๋Ÿผ.... 13๋ฒˆ์งธ ๋‚˜์˜ค๋Š” ์ˆ˜๋Š” ๋ญ˜๊นŒ?"
์˜์ผ์ด๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด ๋” ํฐ ์ˆ˜๋„ ์ž๋™์œผ๋กœ ๊ณ„์‚ฐํ•˜๊ณ  ์‹ถ์–ด์กŒ๋‹ค.

์‹œ์ž‘ ๊ฐ’(a), ๋“ฑ๋น„(r), ๋ช‡ ๋ฒˆ์งธ์ธ์ง€๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์ •์ˆ˜(n)๊ฐ€ ์ž…๋ ฅ๋  ๋•Œ
n๋ฒˆ์งธ ์ˆ˜๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ณด์ž.

โ–ท ํ•ด์„ค

6088๊ณผ ๋น„์Šทํ•˜์ง€๋งŒ ์ด๋ฒˆ์—” ์ˆ˜์—ด์ด r๋งŒํผ ๊ณฑํ•œ ๊ฐ’์ด ๋‹ค์Œ ์ˆ˜๋กœ ๋“ค์–ด์˜ค๊ฒŒ ๋œ๋‹ค.  

a, r, n = map(int, input().split())

for i in range(1, n):
    a *= r

print(a)

 

6090 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ์ˆ˜ ๋‚˜์—ดํ•˜๊ธฐ3(py)

์–ด๋–ค ๊ทœ์น™์— ๋”ฐ๋ผ ์ˆ˜๋ฅผ ์ˆœ์„œ๋Œ€๋กœ ๋‚˜์—ดํ•œ ๊ฒƒ์„ ์ˆ˜์—ด(sequences)์ด๋ผ๊ณ  ํ•œ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด
1 -1 3 -5 11 -21 43 ... ์€
1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•ด ์ด์ „์— ๋งŒ๋“  ์ˆ˜์— -2๋ฅผ ๊ณฑํ•œ ๋‹ค์Œ 1์„ ๋”ํ•ด ๋‹ค์Œ ์ˆ˜๋ฅผ ๋งŒ๋“  ์ˆ˜์—ด์ด๋‹ค.

์ด๋Ÿฐ ์ด์ƒํ•œ ์ˆ˜์—ด์„ ์•Œ๊ฒŒ ๋œ ์˜์ผ์ด๋Š” ๋˜ ๊ถ๊ธˆํ•ด์กŒ๋‹ค.
"๊ทธ๋Ÿผ.... 13๋ฒˆ์งธ ๋‚˜์˜ค๋Š” ์ˆ˜๋Š” ๋ญ˜๊นŒ?"

์˜์ผ์ด๋Š” ๋ฌผ๋ก  ์ˆ˜ํ•™์„ ์•„์ฃผ ์ž˜ํ•˜์ง€๋งŒ ์ด๋Ÿฐ ๋ฌธ์ œ๋Š” ๋ณธ ์ ์ด ๊ฑฐ์˜ ์—†์—ˆ๋‹ค...
๊ทธ๋ž˜์„œ ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด ๋” ํฐ ์ˆ˜๋„ ์ž๋™์œผ๋กœ ๊ณ„์‚ฐํ•˜๊ณ  ์‹ถ์–ด์กŒ๋‹ค.

์‹œ์ž‘ ๊ฐ’(a), ๊ณฑํ•  ๊ฐ’(m), ๋”ํ•  ๊ฐ’(d), ๋ช‡ ๋ฒˆ์งธ์ธ์ง€๋ฅผ ๋‚˜ํƒ€๋‚ด๋Š” ์ •์ˆ˜(n)๊ฐ€ ์ž…๋ ฅ๋  ๋•Œ,
n๋ฒˆ์งธ ์ˆ˜๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ๋งŒ๋“ค์–ด๋ณด์ž.

 

โ–ท ํ•ด์„ค

์œ„์˜ ์‹๊ณผ ์œ ์‚ฌํ•˜์ง€๋งŒ a์— ๊ณฑํ•œ ๋’ค ๋”ํ•˜๋Š” ์—ฐ์‚ฐ์„ ์ˆ˜ํ–‰ํ•ด์„œ ๋‹ต์„ ๊ตฌํ•œ๋‹ค.

a, m, d, n = map(int, input().split())

for i in range(1, n):
    a = a * m + d

print(a)

 

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ณต๋ถ€๋ฅผ ์œ„ํ•ด ์ฝ”๋“œ์—… ์‚ฌ์ดํŠธ(https://codeup.kr/)์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ์‹œ์ž‘ํ•ฉ๋‹ˆ๋‹ค.

๋ธ”๋กœ๊ทธ์— ์˜ฌ๋ผ์˜จ ๋ชจ๋“  ์ฝ”๋“œ๋Š” ํŒŒ์ด์ฌ(Python)์œผ๋กœ ์ž‘์„ฑ๋˜์–ด ์žˆ์Šต๋‹ˆ๋‹ค.   

 

Python์˜ ๊ธฐ์ดˆ 100์ œ๋ฅผ ํ™•์ธํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋‹ค์Œ ์‚ฌ์ดํŠธ๋กœ ์ด๋™ํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค. 

https://codeup.kr/problemsetsol.php?psid=33 

 

๋ฌธ์ œ์ง‘ / Python ๊ธฐ์ดˆ 100์ œ

 

codeup.kr

 

6081 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] 16์ง„์ˆ˜ ๊ตฌ๊ตฌ๋‹จ ์ถœ๋ ฅํ•˜๊ธฐ(py)

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 ๊นŒ์ง€๋งŒ ์ž…๋ ฅ๋œ๋‹ค.)

 

โ–ท ์ฐธ๊ณ 

print('%X'%n)    #n์— ์ €์žฅ๋˜์–ด์žˆ๋Š” ๊ฐ’์„ 16์ง„์ˆ˜(hexadecimal) ํ˜•ํƒœ๋กœ ์ถœ๋ ฅ
์ž‘์€ ๋”ฐ์˜ดํ‘œ 2๊ฐœ๋ฅผ ์‚ฌ์šฉํ•ด์„œ print(..., sep='') ์œผ๋กœ ์ถœ๋ ฅํ•˜๋ฉด, ๊ณต๋ฐฑ์—†์ด ๋ชจ๋‘ ๋ถ™์—ฌ ์ถœ๋ ฅ๋œ๋‹ค.
์ž‘์€ ๋”ฐ์˜ดํ‘œ 2๊ฐœ '' ๋˜๋Š” ํฐ ๋”ฐ์˜ดํ‘œ 2๊ฐœ "" ๋Š” ์•„๋ฌด ๋ฌธ์ž๋„ ์—†๋Š” ๋นˆ๋ฌธ์ž์—ด(empty string)์„ ์˜๋ฏธํ•œ๋‹ค.

 

 

โ–ท ํ•ด์„ค

16์ง„์ˆ˜๋กœ ์ž…๋ ฅ๋ฐ›๋Š” ๋ฐฉ๋ฒ•๊ณผ print์‹œ ํ‘œํ˜„๋ฒ•์„ ์ด์šฉํ•˜๋ฉด ์‰ฝ๊ฒŒ ํ’€์ˆ˜์žˆ๋‹ค.

16์ง„์ˆ˜๋กœ ๊ฐ’์„ ์ž…๋ ฅ๋ฐ›๊ธฐ ์œ„ํ•ด์„œ๋Š” int()ํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•ด 16์ง„์ˆ˜๋กœ ๊ฐ’์„ ๋ฐ›๋Š”๋‹ค.

์ดํ›„ 16์ง„์ˆ˜๋ฅผ ์ถœ๋ ฅํ•˜๊ธฐ ์œ„ํ•ด %X๋กœ ๊ฐ ๊ฐ’์„ ํฌ๋งทํŒ… ํ•œ๋‹ค.  

hexNum = int(input(), 16)

for i in range(1, 16):
    print("%X*%X=%X"%(hexNum, i, hexNum*i))

 

6082 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] 3 6 9 ๊ฒŒ์ž„์˜ ์™•์ด ๋˜์ž(์„ค๋ช…)(py)

์นœ๊ตฌ๋“ค๊ณผ ํ•จ๊ป˜ 3 6 9 ๊ฒŒ์ž„์„ ํ•˜๋˜ ์˜์ผ์ด๋Š” ์žฆ์€ ์‹ค์ˆ˜ ๋•Œ๋ฌธ์— ๊ณ„์†ํ•ด์„œ ๋ฒŒ์น™์„ ๋ฐ›๊ฒŒ ๋˜์—ˆ๋‹ค.
3 6 9 ๊ฒŒ์ž„์˜ ์™•์ด ๋˜๊ธฐ ์œ„ํ•œ 369 ๋งˆ์Šคํ„ฐ ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด ๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

3 6 9 ๊ฒŒ์ž„์€?
์—ฌ๋Ÿฌ ์‚ฌ๋žŒ์ด ์ˆœ์„œ๋ฅผ ์ •ํ•œ ํ›„, ์ˆœ์„œ๋Œ€๋กœ ์ˆ˜๋ฅผ ๋ถ€๋ฅด๋Š” ๊ฒŒ์ž„์ด๋‹ค.
๋งŒ์•ฝ 3, 6, 9 ๊ฐ€ ๋“ค์–ด๊ฐ„ ์ˆ˜๋ฅผ ์ž์‹ ์ด ๋ถˆ๋Ÿฌ์•ผ ํ•˜๋Š” ์ƒํ™ฉ์ด๋ผ๋ฉด, ์ˆ˜๋ฅผ ๋ถ€๋ฅด๋Š” ๋Œ€์‹  "๋ฐ•์ˆ˜(X)" ๋ฅผ ์ณ์•ผ ํ•œ๋‹ค.
33๊ณผ ๊ฐ™์ด 3,6,9๊ฐ€ ๋‘ ๋ฒˆ ๋“ค์–ด๊ฐ„ ์ˆ˜ ์ผ๋•Œ, "์ง์ง"๊ณผ ๊ฐ™์ด ๋ฐ•์ˆ˜๋ฅผ ๋‘ ๋ฒˆ ์น˜๋Š” ํ˜•ํƒœ๋„ ์žˆ๋‹ค. 

 

โ–ท ํ•ด์„ค

์ž…๋ ฅ๋ฐ›์€ ๊ฐ’๊นŒ์ง€ ๋ฐ˜๋ณต๋ฌธ์ด ๋Œ๊ธฐ ์œ„ํ•ด์„œ๋Š” ์ž…๋ ฅ๋ฐ›์€ ๊ฐ’ + 1์˜ ๊ฐ’์„ range์˜ ๊ฐ’์œผ๋กœ ์ „๋‹ฌ๋ฐ›์•„์•ผํ•œ๋‹ค. ๋˜ํ•œ range์˜ ์‹œ์ž‘๊ฐ’์€ 0์ด๋ฏ€๋กœ 1์ด๋ž€ ๊ฐ’์„ ์ง€์ •ํ•ด์•ผํ•œ๋‹ค.

๋ฒ”์œ„๋ฅผ ์ง€์ •ํ•œ ๋’ค์—๋Š” ๋ฐ˜๋ณต๋ฌธ๋™์•ˆ 10์œผ๋กœ ๋‚˜๋ˆด์„ ๋•Œ ๋‚˜๋จธ์ง€ ๊ฐ’์ด 3์ด๋‚˜ 6, 9 ์ผ๋•Œ X๊ฐ€ ์ถœ๋ ฅ๋˜๋„๋ก ์กฐ๊ฑด๋ฌธ์„ ์ง€์ •ํ•˜๋ฉด ๋œ๋‹ค. if ~ elif ~ else๋กœ ๋‚˜ํƒ€ ๋‚ผ ์ˆ˜๋„ ์žˆ์ง€๋งŒ ์ด ๊ฒฝ์šฐ or๋กœ ์…‹ ์ค‘ ํ•˜๋‚˜๋ผ๋„ ์ฐธ์ด๋ฉด ์กฐ๊ฑด์ด ์‹คํ–‰๋˜๋„๋ก ์ฝ”๋“œ๋ฅผ ๊ตฌ์„ฑํ–ˆ๋‹ค.

num = int(input())

for n in range(1, num+1):
    if n % 10 == 3 or n % 10 == 6 or n % 10 == 9:
        print("X", end=" ")
    else:
        print(n, end=" ")

 

6083 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ๋น› ์„ž์–ด ์ƒ‰ ๋งŒ๋“ค๊ธฐ(์„ค๋ช…)(py)

๋นจ๊ฐ•(red), ์ดˆ๋ก(green), ํŒŒ๋ž‘(blue) ๋น›์„ ์„ž์–ด ์—ฌ๋Ÿฌ ๊ฐ€์ง€ ๋‹ค๋ฅธ ์ƒ‰ ๋น›์„ ๋งŒ๋“ค์–ด ๋‚ด๋ ค๊ณ  ํ•œ๋‹ค.

๋นจ๊ฐ•(r), ์ดˆ๋ก(g), ํŒŒ๋ž‘(b) ๊ฐ ๋น›์˜ ๊ฐ€์ง“์ˆ˜๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ,
์ฃผ์–ด์ง„ rgb ๋น›๋“ค์„ ์„ž์–ด ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋ชจ๋“  ๊ฒฝ์šฐ์˜ ์กฐํ•ฉ(r g b)๊ณผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ์ƒ‰์˜ ๊ฐ€์ง“ ์ˆ˜๋ฅผ ๊ณ„์‚ฐํ•ด๋ณด์ž.  

 

โ–ท ์ฐธ๊ณ 

๋ชจ๋‹ˆํ„ฐ, ์Šค๋งˆํŠธํฐ๊ณผ ๊ฐ™์€ ๋””์Šคํ”Œ๋ ˆ์ด์—์„œ ๊ฐ ํ”ฝ์…€์˜ ์ƒ‰์„ ๋งŒ๋“ค์–ด๋‚ด๊ธฐ ์œ„ํ•ด์„œ r, g, b ์ƒ‰์„ ์กฐํ•ฉํ•  ์ˆ˜ ์žˆ๋‹ค.
ํ”ฝ์…€(pixel)์€ ๊ทธ๋ฆผ(picture)์„ ๊ตฌ์„ฑํ•˜๋Š” ์…€(cell)์—์„œ ์ด๋ฆ„์ด ๋งŒ๋“ค์–ด์กŒ๋‹ค.

 

โ–ท ํ•ด์„ค

r, g, b ๊ฐ ๊ฐ’์„ ๋‚˜๋ˆ  ๋ฐ˜๋ณต๋ฌธ์„ ์‚ฌ์šฉํ•˜๋ฉด ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋‹ค.

๊ฐ ๋ฐ˜๋ณต๋ฌธ์ด ๋„๋Š” ์ˆœ์„œ๋Š” b → g  → r ์ด๋ฏ€๋กœ rgb ์ˆœ์„œ๋Œ€๋กœ ์˜ค๋ฆ„์ฐจ์ˆœ ์ •๋ ฌ์ด ๊ฐ€๋Šฅํ•ด์ง„๋‹ค.

๋งˆ์ง€๋ง‰์œผ๋กœ ์ด ๊ฐฏ์ˆ˜์— ๋Œ€ํ•ด์„œ ๊ตฌํ•ด์•ผ ํ•˜๋ฏ€๋กœ cnt๋ผ๋Š” ๋ณ€์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ฐ€์žฅ ๋งˆ์ง€๋ง‰ print๋ฌธ์ด ๋‚˜์˜ฌ๋•Œ๋งˆ๋‹ค cnt์˜ ๊ฐ’์„ 1 ๋”ํ•ด์ค€๋‹ค.

r, g, b = map(int, input().split())

cnt = 0
for i in range(r):
    for j in range(g):
        for k in range(b):
            print(i, j, k)
            cnt += 1

print(cnt)

 

6084 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ์†Œ๋ฆฌ ํŒŒ์ผ ์ €์žฅ์šฉ๋Ÿ‰ ๊ณ„์‚ฐํ•˜๊ธฐ(py)

์†Œ๋ฆฌ๊ฐ€ ์ปดํ“จํ„ฐ์— ์ €์žฅ๋  ๋•Œ์—๋Š” ๋””์ง€ํ„ธ ๋ฐ์ดํ„ฐํ™” ๋˜์–ด ์ €์žฅ๋œ๋‹ค.

๋งˆ์ดํฌ๋ฅผ ํ†ตํ•ด 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 ์ •๋„๊ฐ€ ํ•„์š”ํ•˜๋‹ค.

์ด๋ ‡๊ฒŒ ๋…น์Œํ•˜๋Š” ๋ฐฉ์‹์„ 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์™€ b, c, s๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ h*b*c*s/8/1024/1024 ๋‹ค์Œ์‹์— ๋Œ€์ž…ํ•˜๋ฉด ์›ํ•˜๋Š” ์ €์žฅ๊ณต๊ฐ„์„ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค.

๋‹จ, ์กฐ๊ฑด์— ์†Œ์ˆซ์  ์ฒซ๋ฒˆ์งธ ์ž๋ฆฌ๊นŒ์ง€๋ผ๋Š” ์กฐ๊ฑด์ด ๋ถ™์—ˆ์œผ๋ฏ€๋กœ float์˜ ์ถœ๋ ฅํ˜•์‹์„ ์ง€์ •ํ•ด์ค˜์•ผ๋งŒ ์ •๋‹ต์ด ๋‚˜์˜จ๋‹ค.  

h, b, c, s = map(int , input().split())

# ์ €์žฅ๊ณต๊ฐ„ = h * b * c * s / ๋ฉ”๊ฐ€๋ฐ”์ดํŠธ
# ๋ฉ”๊ฐ€๋ฐ”์ดํŠธ = 8 ๋น„ํŠธ / 1024 ๋ฐ”์ดํŠธ / 1024 ํ‚ฌ๋กœ๋ฐ”์ดํŠธ
save = float(h * b * c * s / 8 / 1024 / 1024)

print("%.1f MB"%save)

 

6085 : [๊ธฐ์ดˆ-์ข…ํ•ฉ] ๊ทธ๋ฆผ ํŒŒ์ผ ์ €์žฅ์šฉ๋Ÿ‰ ๊ณ„์‚ฐํ•˜๊ธฐ(py)

์ด๋ฏธ์ง€๊ฐ€ ์ปดํ“จํ„ฐ์— ์ €์žฅ๋  ๋•Œ์—๋„ ๋””์ง€ํ„ธ ๋ฐ์ดํ„ฐํ™” ๋˜์–ด ์ €์žฅ๋œ๋‹ค.

๊ฐ€์žฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐฉ๋ฒ•์œผ๋กœ๋Š” ๊ทธ๋ฆผ์„ ๊ตฌ์„ฑํ•˜๋Š” ํ•œ ์ (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 ํŒŒ์ผ์ด๋ฉฐ, ๋น„ํŠธ๋กœ ๊ทธ๋ฆผ์„ ๊ตฌ์„ฑํ•œ๋‹ค๊ณ  ํ•˜์—ฌ ๋น„ํŠธ๋งต ๋ฐฉ์‹ ๋˜๋Š” ๋ž˜์Šคํ„ฐ ๋ฐฉ์‹์ด๋ผ๊ณ  ํ•œ๋‹ค.

์ด๋ฏธ์ง€์˜ ๊ฐ€๋กœ ํ•ด์ƒ๋„ w, ์„ธ๋กœ ํ•ด์ƒ๋„ h, ํ•œ ํ”ฝ์…€์„ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•œ ๋น„ํŠธ b ๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ,
์••์ถ•ํ•˜์ง€ ์•Š๊ณ  ์ €์žฅํ•˜๊ธฐ ์œ„ํ•ด ํ•„์š”ํ•œ ์ €์žฅ ์šฉ๋Ÿ‰์„ ๊ณ„์‚ฐํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด ๋ณด์ž.

์˜ˆ๋ฅผ ๋“ค์–ด
์ผ๋ฐ˜์ ์ธ 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(ํ…Œ๋ผ ๋ฐ”์ดํŠธ)

โ–ท ํ•ด์„ค

6084์™€ ๊ฐ™์€ ๋ฐฉ๋ฒ•์œผ๋กœ ๋ฌธ์ œ๋ฅผ ํ’€๋ฉด๋œ๋‹ค.

์šฐ๋ฆฌ๋Š” w์™€ h, b๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ w*h*b/8/1024/1024 ๋‹ค์Œ์‹์— ๋Œ€์ž…ํ•˜๋ฉด ์›ํ•˜๋Š” ์ €์žฅ๊ณต๊ฐ„์„ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค.

๋‹จ, ์กฐ๊ฑด์— ์†Œ์ˆซ์  ๋‘๋ฒˆ์งธ ์ž๋ฆฌ๊นŒ์ง€๋ผ๋Š” ์กฐ๊ฑด์ด ๋ถ™์—ˆ์œผ๋ฏ€๋กœ float์˜ ์ถœ๋ ฅํ˜•์‹์„ ์ง€์ •ํ•ด์ค˜์•ผ๋งŒ ์ •๋‹ต์ด ๋‚˜์˜จ๋‹ค.

w, h, b = map(int, input().split())

# ์ €์žฅ๊ณต๊ฐ„ = w, h, b / ๋ฉ”๊ฐ€๋ฐ”์ดํŠธ
# ๋ฉ”๊ฐ€๋ฐ”์ดํŠธ = 8 ๋น„ํŠธ / 1024 ๋ฐ”์ดํŠธ / 1024 ํ‚ฌ๋กœ๋ฐ”์ดํŠธ
bmp = float(w * h * b / 8 / 1024 / 1024)

print("%.2f MB"%bmp)

+ Recent posts