์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
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 |
- ํ์ด์ฌ ์ฑ๋ฆฐ์ง
- ํ์ด์ฌ
- ์๋ฐ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- Rust
- java
- ํ์ด์ฌ ์๊ณ ๋ฆฌ์ฆ
- ์๋ฐ ๊ฐ๋
- ubuntu
- ํ์ด์ฌ ์ฒผ๋ฆฐ์ง
- ๋ฐ์ดํฐ ํต์
- C
- OS
- Database
- ์ค๋ผํด
- ์๊ณ ๋ฆฌ์ฆ
- ์ด์์ฒด์
- ๋ฐฑ์ค
- Python challenge
- Reversing
- ์ค๋ผํดDB
- ๋ฐฑ์ค ๋ฌ์คํธ
- Python
- ๋ฌ์คํธ
- data communication
- ์ฐ๋ถํฌ
- ๋ฌ์คํธ ์์
- ์๋ฐ ๊ธฐ์ด
- Operating System
- ๋ฌ์คํธ ํ๋ก๊ทธ๋๋ฐ ๊ณต์ ๊ฐ์ด๋
- Today
- Total
IT’s Portfolio
[Algorithm] Baekjoon - ๋ฐ๋ณต๋ฌธ ๋จ๊ณ ๋ณธ๋ฌธ
๐ป 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๋ฅผ ํ ์ค์ ํ๋์ฉ ์์๋๋ก ์ถ๋ ฅํ๋ค.
๋ฉ๋ชจ๋ฆฌ ์ด๊ณผ ์ฝ๋
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)
- ๋นํธ ๋ฐ์ ์ฐ์ฐ์
~
๋ฅผ ์ฌ์ฉํ ์ฝ๋ - ๋นํธ ์ฐ์ฐ์์ ๋ํ ๊ธ(๋นํธ ๋ฐ์ ์ฐ์ฐ์์ 2์ ๋ณด์์ ๋ํ ์์ธํ ๊ธ ํฌํจ)
โ๏ธ 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
'Development Study > Python' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Python] Iterator (0) | 2022.11.28 |
---|---|
[Python] requests์ urllib (0) | 2022.11.18 |
[Python] ํ์ด์ฌ์ ๋ฌธ์์ด ํฌ๋ฉํ Ver.2 (0) | 2022.10.06 |
[Python] ๋นํธ ์ฐ์ฐ์ (0) | 2022.10.01 |
[Python] eval(), exec()์ ๋ํด์ (0) | 2022.08.16 |