๊ด€๋ฆฌ ๋ฉ”๋‰ด

IT’s Portfolio

[Algorithm] Baekjoon - ๋ฐ˜๋ณต๋ฌธ ๋‹จ๊ณ„ ๋ณธ๋ฌธ

Development Study/Python

[Algorithm] Baekjoon - ๋ฐ˜๋ณต๋ฌธ ๋‹จ๊ณ„

f1r3_r41n 2022. 10. 12. 15:42
728x90
๋ฐ˜์‘ํ˜•

๐Ÿ’ป Baekjoon Loop Stage

โš™๏ธ Multiplication Table

Q. N์„ ์ž…๋ ฅ๋ฐ›์€ ๋’ค, ๊ตฌ๊ตฌ๋‹จ N๋‹จ์„ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค. ์ถœ๋ ฅ ํ˜•์‹์— ๋งž์ถฐ์„œ ์ถœ๋ ฅํ•˜๋ฉด ๋œ๋‹ค.

Input. ์ฒซ์งธ ์ค„์— N์ด ์ฃผ์–ด์ง„๋‹ค. N์€ 1๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๊ณ , 9๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™๋‹ค.

Output. ์ถœ๋ ฅํ˜•์‹๊ณผ ๊ฐ™๊ฒŒ N1๋ถ€ํ„ฐ N9๊นŒ์ง€ ์ถœ๋ ฅํ•œ๋‹ค.

N = int(input())
for i in range(1,10): print(f'{N} * {i} = {N*i}')
N=n=int(input())
exec("print(N, '*', n//N, '=', n); n+=N;"*9)

โš™๏ธ Two Integer

Q. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค์˜ ๊ฐœ์ˆ˜ T๊ฐ€ ์ฃผ์–ด์ง„๋‹ค.
๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

Output. ๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

T = int(input()); exec("print(eval('+'.join(input())));"*T)
T = int(input())
cnt = 0

while T>cnt:
    A, B = map(int, input().split())
    print(A+B)
    cnt+=1

โš™๏ธ Sum

Q. n์ด ์ฃผ์–ด์กŒ์„ ๋•Œ, 1๋ถ€ํ„ฐ n๊นŒ์ง€ ํ•ฉ์„ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— n (1 โ‰ค n โ‰ค 10,000)์ด ์ฃผ์–ด์ง„๋‹ค.

Output. 1๋ถ€ํ„ฐ n๊นŒ์ง€ ํ•ฉ์„ ์ถœ๋ ฅํ•œ๋‹ค.

print(sum(range(1, int(input())+1)))

โš™๏ธ Receipt

Q. ์ค€์›์ด๋Š” ์ €๋ฒˆ ์ฃผ์— ์‚ด๋ฉด์„œ ์ฒ˜์Œ์œผ๋กœ ์ฝ”์ŠคํŠธ์ฝ”๋ฅผ ๊ฐ€ ๋ดค๋‹ค. ์ •๋ง ๋ฉ‹์กŒ๋‹ค.
๊ทธ๋Ÿฐ๋ฐ, ๋ช‡ ๊ฐœ ๋‹ด์ง€๋„ ์•Š์•˜๋Š”๋ฐ ์ˆ˜์ƒํ•˜๊ฒŒ ๋†’์€ ๊ธˆ์•ก์ด ๋‚˜์˜ค๋Š” ๊ฒƒ์ด๋‹ค!
์ค€์›์ด๋Š” ์˜์ˆ˜์ฆ์„ ๋ณด๋ฉด์„œ ์ •ํ™•ํ•˜๊ฒŒ ๊ณ„์‚ฐ๋œ ๊ฒƒ์ด ๋งž๋Š”์ง€ ํ™•์ธํ•ด๋ณด๋ ค ํ•œ๋‹ค.
์˜์ˆ˜์ฆ์— ์ ํžŒ,
1. ๊ตฌ๋งคํ•œ ๊ฐ ๋ฌผ๊ฑด์˜ ๊ฐ€๊ฒฉ๊ณผ ๊ฐœ์ˆ˜
2. ๊ตฌ๋งคํ•œ ๋ฌผ๊ฑด๋“ค์˜ ์ด ๊ธˆ์•ก
์„ ๋ณด๊ณ , ๊ตฌ๋งคํ•œ ๋ฌผ๊ฑด์˜ ๊ฐ€๊ฒฉ๊ณผ ๊ฐœ์ˆ˜๋กœ ๊ณ„์‚ฐํ•œ ์ด ๊ธˆ์•ก์ด ์˜์ˆ˜์ฆ์— ์ ํžŒ ์ด ๊ธˆ์•ก๊ณผ ์ผ์น˜ํ•˜๋Š”์ง€ ๊ฒ€์‚ฌํ•ด๋ณด์ž.

Input. ์ฒซ์งธ ์ค„์—๋Š” ์˜์ˆ˜์ฆ์— ์ ํžŒ ์ด ๊ธˆ์•ก X๊ฐ€ ์ฃผ์–ด์ง„๋‹ค.
๋‘˜์งธ ์ค„์—๋Š” ์˜์ˆ˜์ฆ์— ์ ํžŒ ๊ตฌ๋งคํ•œ ๋ฌผ๊ฑด์˜ ์ข…๋ฅ˜์˜ ์ˆ˜ N์ด ์ฃผ์–ด์ง„๋‹ค.
์ดํ›„ N๊ฐœ์˜ ์ค„์—๋Š” ๊ฐ ๋ฌผ๊ฑด์˜ ๊ฐ€๊ฒฉ a์™€ ๊ฐœ์ˆ˜ b๊ฐ€ ๊ณต๋ฐฑ์„ ์‚ฌ์ด์— ๋‘๊ณ  ์ฃผ์–ด์ง„๋‹ค.

Output. ๊ตฌ๋งคํ•œ ๋ฌผ๊ฑด์˜ ๊ฐ€๊ฒฉ๊ณผ ๊ฐœ์ˆ˜๋กœ ๊ณ„์‚ฐํ•œ ์ด ๊ธˆ์•ก์ด ์˜์ˆ˜์ฆ์— ์ ํžŒ ์ด ๊ธˆ์•ก๊ณผ ์ผ์น˜ํ•˜๋ฉด Yes๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค. ์ผ์น˜ํ•˜์ง€ ์•Š๋Š”๋‹ค๋ฉด No๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

Limit. 1 โ‰ค X โ‰ค 1,000,000,000
1 โ‰ค N โ‰ค 100
1 โ‰ค a โ‰ค 1,000,000
1 โ‰ค b โ‰ค 10

X, _, *e = open(0)
X = int(X)
for line in e: a, b = map(int, line.split()); X-=a*b
print("YNeos"[X!=0::2])
X = int(input())
N = int(input())

sum = 0

for _ in range(N):
    a, b = map(int, input().split())
    sum += a*b

print("Yes" if X==sum else "No")

โš™๏ธ Quick Sum

Q. ๋ณธ๊ฒฉ์ ์œผ๋กœ for๋ฌธ ๋ฌธ์ œ๋ฅผ ํ’€๊ธฐ ์ „์— ์ฃผ์˜ํ•ด์•ผ ํ•  ์ ์ด ์žˆ๋‹ค. ์ž…์ถœ๋ ฅ ๋ฐฉ์‹์ด ๋Š๋ฆฌ๋ฉด ์—ฌ๋Ÿฌ ์ค„์„ ์ž…๋ ฅ๋ฐ›๊ฑฐ๋‚˜ ์ถœ๋ ฅํ•  ๋•Œ ์‹œ๊ฐ„์ดˆ๊ณผ๊ฐ€ ๋‚  ์ˆ˜ ์žˆ๋‹ค๋Š” ์ ์ด๋‹ค.
Python์„ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋‹ค๋ฉด, input ๋Œ€์‹  sys.stdin.readline์„ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
๋‹จ, ์ด๋•Œ๋Š” ๋งจ ๋์˜ ๊ฐœํ–‰๋ฌธ์ž๊นŒ์ง€ ๊ฐ™์ด ์ž…๋ ฅ๋ฐ›๊ธฐ ๋•Œ๋ฌธ์— ๋ฌธ์ž์—ด์„ ์ €์žฅํ•˜๊ณ  ์‹ถ์„ ๊ฒฝ์šฐ .rstrip()์„ ์ถ”๊ฐ€๋กœ ํ•ด ์ฃผ๋Š” ๊ฒƒ์ด ์ข‹๋‹ค.
๋˜ํ•œ ์ž…๋ ฅ๊ณผ ์ถœ๋ ฅ ์ŠคํŠธ๋ฆผ์€ ๋ณ„๊ฐœ์ด๋ฏ€๋กœ, ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋ฅผ ์ „๋ถ€ ์ž…๋ ฅ๋ฐ›์•„์„œ ์ €์žฅํ•œ ๋’ค ์ „๋ถ€ ์ถœ๋ ฅํ•  ํ•„์š”๋Š” ์—†๋‹ค. ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋ฅผ ํ•˜๋‚˜ ๋ฐ›์€ ๋’ค ํ•˜๋‚˜ ์ถœ๋ ฅํ•ด๋„ ๋œ๋‹ค.

Input. ์ฒซ ์ค„์— ํ…Œ์ŠคํŠธ์ผ€์ด์Šค์˜ ๊ฐœ์ˆ˜ T๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. T๋Š” ์ตœ๋Œ€ 1,000,000์ด๋‹ค. ๋‹ค์Œ T์ค„์—๋Š” ๊ฐ๊ฐ ๋‘ ์ •์ˆ˜ A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. A์™€ B๋Š” 1 ์ด์ƒ, 1,000 ์ดํ•˜์ด๋‹ค.

Output. ๊ฐ ํ…Œ์ŠคํŠธ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ํ•œ ์ค„์— ํ•˜๋‚˜์”ฉ ์ˆœ์„œ๋Œ€๋กœ ์ถœ๋ ฅํ•œ๋‹ค.

์ฐธ๊ณ ํ•˜๊ธฐ 1

์ฐธ๊ณ ํ•˜๊ธฐ 2

๋ฉ”๋ชจ๋ฆฌ ์ดˆ๊ณผ ์ฝ”๋“œ

T = int(input())
exec("print(eval('+'.join(sys.stdin.readline().rstrip().split())));"*T)
  • ์ž…๋ ฅ๊ฐ’์„ ๊ณ„์† ์ฝ๊ณ  ๋ฉ”๋ชจ๋ฆฌ์— ์ €์žฅํ•˜๊ธฐ์— ๋ฉ”๋ชจ๋ฆฌ ์ดˆ๊ณผ๊ฐ€ ๋œฌ ๊ฒƒ์ด ์•„๋‹๊นŒํ•˜๋Š” ์ถ”์ธก์ž„
  • ์ด ์ฝ”๋“œ์—์„œ sys.stdin์ด ์•„๋‹Œ open(0)์„ ์‚ฌ์šฉํ•˜๋ฉด ํŒŒ์ผ ๊ฐ์ฒด๋ฅผ ๋‹ซ์ง€ ์•Š์•˜๋‹ค๋Š” ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•จ

๊ธฐ๋ณธ ์ฝ”๋“œ

import sys

T = int(input())

for _ in range(T):
    A, B = sys.stdin.readline().rstrip().split()
    print(int(A) + int(B))
  • ๋ฌด๋‚œํ•œ ํ†ต๊ณผ ์ฝ”๋“œ์ž„

์ˆ์ฝ”๋“œ

import sys

for n in [*sys.stdin][1:]:
    print(sum(map(int, n.split())))
  • sys๋ฅผ ์‚ฌ์šฉํ•˜์ง€ ์•Š๊ณ  open(0) ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•ด๋„ ๊ดœ์ฐฎ์€ ๊ฒƒ ๊ฐ™๋‹ค. ๋ฐ˜๋ณตํ•ด์„œ ํŒŒ์ผ์„ ์—ฌ๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๊ธฐ ๋•Œ๋ฌธ์— ํŒŒ์ผ ๊ฐ์ฒด๋ฅผ ๋‹ซ์•„์•ผ ํ•œ๋‹ค๋Š” ํ•„์ˆ˜ ์กฐ๊ฑด๋„ ํ”ผํ•  ์ˆ˜ ์žˆ์–ด๋ณด์ž„

โš™๏ธ Sum 2

Q. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Output. ๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค "Case #x: "๋ฅผ ์ถœ๋ ฅํ•œ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค. ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค ๋ฒˆํ˜ธ๋Š” 1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•œ๋‹ค.

๋‚ด ํ’€์ด

import sys

T=0
for n in [*sys.stdin][1:]:
    T+=1
    print(f"Case #{T}:", sum(map(int, n.split())))
  • ๊ตณ์ด sys ๋ชจ๋“ˆ์„ importํ•˜์—ฌ ์‚ฌ์šฉํ•  ํ•„์š”๋Š” ์—†๊ณ  open(0)์œผ๋กœ ์น˜ํ™˜ํ•˜์—ฌ ์‚ฌ์šฉํ•ด๋„ ๊ดœ์ฐฎ์„ ๊ฒƒ๊ฐ™๋‹ค.

๊ธฐ๋ณธ ์ฝ”๋“œ

import sys

T = int(input())

for x in range(T):
    A, B = sys.stdin.readline().rstrip().split()
    print(f"Case #{x+1}: {int(A)+int(B)}")

โš™๏ธ Sum 3

Q. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค์˜ ๊ฐœ์ˆ˜ T๊ฐ€ ์ฃผ์–ด์ง„๋‹ค.
๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

Output. ๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค "Case #x: A + B = C" ํ˜•์‹์œผ๋กœ ์ถœ๋ ฅํ•œ๋‹ค. x๋Š” ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค ๋ฒˆํ˜ธ์ด๊ณ  1๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋ฉฐ, C๋Š” A+B์ด๋‹ค.

T = 0

for A,_,B,_ in [*open(0)][1:]:
    T+=1
    print(f"Case #{T}: {A} + {B} = {int(A)+int(B)}")

โš™๏ธ Star

Q. ์ฒซ์งธ ์ค„์—๋Š” ๋ณ„ 1๊ฐœ, ๋‘˜์งธ ์ค„์—๋Š” ๋ณ„ 2๊ฐœ, N๋ฒˆ์งธ ์ค„์—๋Š” ๋ณ„ N๊ฐœ๋ฅผ ์ฐ๋Š” ๋ฌธ์ œ

Input. ์ฒซ์งธ ์ค„์— N(1 โ‰ค N โ‰ค 100)์ด ์ฃผ์–ด์ง„๋‹ค.

Output. ์ฒซ์งธ ์ค„๋ถ€ํ„ฐ N๋ฒˆ์งธ ์ค„๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ ๋ณ„์„ ์ถœ๋ ฅํ•œ๋‹ค.

๋‚ด ํ’€์ด

N=n=int(input()); exec("n-=1;print('*'*(N-n));"*N)
  • exec๋ฅผ ์‚ฌ์šฉ

์ˆ์ฝ”๋“œ

for i in range(int(input())): print('*'*-~i)

โš™๏ธ Star 2

Q. ์ฒซ์งธ ์ค„์—๋Š” ๋ณ„ 1๊ฐœ, ๋‘˜์งธ ์ค„์—๋Š” ๋ณ„ 2๊ฐœ, N๋ฒˆ์งธ ์ค„์—๋Š” ๋ณ„ N๊ฐœ๋ฅผ ์ฐ๋Š” ๋ฌธ์ œ
ํ•˜์ง€๋งŒ, ์˜ค๋ฅธ์ชฝ์„ ๊ธฐ์ค€์œผ๋กœ ์ •๋ ฌํ•œ ๋ณ„(์˜ˆ์ œ ์ฐธ๊ณ )์„ ์ถœ๋ ฅํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— N(1 โ‰ค N โ‰ค 100)์ด ์ฃผ์–ด์ง„๋‹ค.

Output. ์ฒซ์งธ ์ค„๋ถ€ํ„ฐ N๋ฒˆ์งธ ์ค„๊นŒ์ง€ ์ฐจ๋ก€๋Œ€๋กœ ๋ณ„์„ ์ถœ๋ ฅํ•œ๋‹ค.

์ถœ๋ ฅ์˜ˆ์ œ
    *
   **
  ***
 ****
*****
N=int(input())

for i in range(N):
    print(f"{'*'*(i+1):>{N}}")

โš™๏ธ Less than X

Q. ์ •์ˆ˜ N๊ฐœ๋กœ ์ด๋ฃจ์–ด์ง„ ์ˆ˜์—ด A์™€ ์ •์ˆ˜ X๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ด๋•Œ, A์—์„œ X๋ณด๋‹ค ์ž‘์€ ์ˆ˜๋ฅผ ๋ชจ๋‘ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— N๊ณผ X๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (1 โ‰ค N, X โ‰ค 10,000)
๋‘˜์งธ ์ค„์— ์ˆ˜์—ด A๋ฅผ ์ด๋ฃจ๋Š” ์ •์ˆ˜ N๊ฐœ๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. ์ฃผ์–ด์ง€๋Š” ์ •์ˆ˜๋Š” ๋ชจ๋‘ 1๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๊ณ , 10,000๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ์ •์ˆ˜์ด๋‹ค.

Output. X๋ณด๋‹ค ์ž‘์€ ์ˆ˜๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ์ˆœ์„œ๋Œ€๋กœ ๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•ด ์ถœ๋ ฅํ•œ๋‹ค. X๋ณด๋‹ค ์ž‘์€ ์ˆ˜๋Š” ์ ์–ด๋„ ํ•˜๋‚˜ ์กด์žฌํ•œ๋‹ค.

N, X, *A = map(int, open(0).read().split())
for i in A:
    i<X!=print(i, end=" ")

โš™๏ธ Sum 4

Q. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ž…๋ ฅ์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.
๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)
์ž…๋ ฅ์˜ ๋งˆ์ง€๋ง‰์—๋Š” 0 ๋‘ ๊ฐœ๊ฐ€ ๋“ค์–ด์˜จ๋‹ค.

Output. ๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

for A,_,B,_ in [*open(0)]:
    int(A)+int(B)!=0==print(f"{int(A)+int(B)}")

while์„ ์‚ฌ์šฉํ•œ ์ˆ์ฝ”๋“œ

while A:=eval("+".join(input())):print(A)

โš™๏ธ Sum 5

Q. ๋‘ ์ •์ˆ˜ A์™€ B๋ฅผ ์ž…๋ ฅ๋ฐ›์€ ๋‹ค์Œ, A+B๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ž…๋ ฅ์€ ์—ฌ๋Ÿฌ ๊ฐœ์˜ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ๋‹ค.
๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋Š” ํ•œ ์ค„๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์œผ๋ฉฐ, ๊ฐ ์ค„์— A์™€ B๊ฐ€ ์ฃผ์–ด์ง„๋‹ค. (0 < A, B < 10)

Output. ๊ฐ ํ…Œ์ŠคํŠธ ์ผ€์ด์Šค๋งˆ๋‹ค A+B๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

Code 1

for A,_,B,_ in [*open(0)]:
    print(int(A)+int(B))

Code 2

for i in open(0):
    print(sum(map(int, i.split())))

Short Code

for i in open(0):
    print(sum(b'%a'%i)%24)
  • ๋ฐ”์ดํŠธ ๊ฐ์ฒด๋ฅผ ์‚ฌ์šฉํ•œ ํ’€์ด๋ฒ•

โš™๏ธ Plus Cycle

Q. 0๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๊ณ , 99๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ์ •์ˆ˜๊ฐ€ ์ฃผ์–ด์งˆ ๋•Œ ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์—ฐ์‚ฐ์„ ํ•  ์ˆ˜ ์žˆ๋‹ค.
๋จผ์ € ์ฃผ์–ด์ง„ ์ˆ˜๊ฐ€ 10๋ณด๋‹ค ์ž‘๋‹ค๋ฉด ์•ž์— 0์„ ๋ถ™์—ฌ ๋‘ ์ž๋ฆฌ ์ˆ˜๋กœ ๋งŒ๋“ค๊ณ , ๊ฐ ์ž๋ฆฌ์˜ ์ˆซ์ž๋ฅผ ๋”ํ•œ๋‹ค.
๊ทธ ๋‹ค์Œ, ์ฃผ์–ด์ง„ ์ˆ˜์˜ ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ ์ž๋ฆฌ ์ˆ˜์™€ ์•ž์—์„œ ๊ตฌํ•œ ํ•ฉ์˜ ๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ ์ž๋ฆฌ ์ˆ˜๋ฅผ ์ด์–ด ๋ถ™์ด๋ฉด ์ƒˆ๋กœ์šด ์ˆ˜๋ฅผ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋‹ค.
๋‹ค์Œ ์˜ˆ๋ฅผ ๋ณด์ž.
26๋ถ€ํ„ฐ ์‹œ์ž‘ํ•œ๋‹ค. 2+6 = 8์ด๋‹ค. ์ƒˆ๋กœ์šด ์ˆ˜๋Š” 68์ด๋‹ค. 6+8 = 14์ด๋‹ค. ์ƒˆ๋กœ์šด ์ˆ˜๋Š” 84์ด๋‹ค. 8+4 = 12์ด๋‹ค. ์ƒˆ๋กœ์šด ์ˆ˜๋Š” 42์ด๋‹ค. 4+2 = 6์ด๋‹ค. ์ƒˆ๋กœ์šด ์ˆ˜๋Š” 26์ด๋‹ค.
์œ„์˜ ์˜ˆ๋Š” 4๋ฒˆ๋งŒ์— ์›๋ž˜ ์ˆ˜๋กœ ๋Œ์•„์˜ฌ ์ˆ˜ ์žˆ๋‹ค. ๋”ฐ๋ผ์„œ 26์˜ ์‚ฌ์ดํด์˜ ๊ธธ์ด๋Š” 4์ด๋‹ค.
N์ด ์ฃผ์–ด์กŒ์„ ๋•Œ, N์˜ ์‚ฌ์ดํด์˜ ๊ธธ์ด๋ฅผ ๊ตฌํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•˜์‹œ์˜ค.

Input. ์ฒซ์งธ ์ค„์— N์ด ์ฃผ์–ด์ง„๋‹ค. N์€ 0๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™๊ณ , 99๋ณด๋‹ค ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€ ์ •์ˆ˜์ด๋‹ค.

Output. ์ฒซ์งธ ์ค„์— N์˜ ์‚ฌ์ดํด ๊ธธ์ด๋ฅผ ์ถœ๋ ฅํ•œ๋‹ค.

cycle_num = 0
N=n=input()
while 1:
    if len(N) == 1:
        N=n="0%s"%N
    result = str(int(N[0]) + int(N[1]))
    N = N[-1]+result[-1]
    cycle_num+=1
    if N==n: print(cycle_num); break
728x90
๋ฐ˜์‘ํ˜•
Comments