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

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

 

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

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

 

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

 

codeup.kr

 

6056 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ์ฐธ/๊ฑฐ์ง“์ด ์„œ๋กœ ๋‹ค๋ฅผ ๋•Œ์—๋งŒ ์ฐธ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

2๊ฐœ์˜ ์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’(True/False) ์ด ์„œ๋กœ ๋‹ค๋ฅผ ๋•Œ์—๋งŒ True ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

์ฐธ ๊ฑฐ์ง“์ด ์„œ๋กœ ๋‹ค๋ฅผ ๋•Œ์—๋งŒ True ๋กœ ๊ณ„์‚ฐํ•˜๋Š” ๋…ผ๋ฆฌ์—ฐ์‚ฐ์„ XOR(exclusive or, ๋ฐฐํƒ€์  ๋…ผ๋ฆฌํ•ฉ) ์—ฐ์‚ฐ์ด๋ผ๊ณ ๋„ ๋ถ€๋ฅธ๋‹ค.

๋…ผ๋ฆฌ์—ฐ์‚ฐ์ž๋Š” ์‚ฌ์น™(+, -, *, /) ์—ฐ์‚ฐ์ž์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์—ฌ๋Ÿฌ ๋ฒˆ ์ค‘๋ณตํ•ด์„œ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋Š”๋ฐ, 
์‚ฌ์น™ ์—ฐ์‚ฐ์ž์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๊ณ„์‚ฐ ์ˆœ์„œ๋ฅผ ํ‘œ์‹œํ•˜๊ธฐ ์œ„ํ•ด ๊ด„ํ˜ธ ( )๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๊ณ„์‚ฐ ์ˆœ์„œ๋ฅผ ๋ช…ํ™•ํ•˜๊ฒŒ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ˆ˜ํ•™ ์‹์—์„œ๋Š” ์†Œ๊ด„ํ˜ธ (), ์ค‘๊ด„ํ˜ธ {}, ๋Œ€๊ด„ํ˜ธ []๋ฅผ ์‚ฌ์šฉํ•˜๊ธฐ๋„ ํ•˜์ง€๋งŒ, ํ”„๋กœ๊ทธ๋ž˜๋ฐ์–ธ์–ด์—์„œ๋Š” ์†Œ๊ด„ํ˜ธ ( ) ๋งŒ ์‚ฌ์šฉํ•œ๋‹ค.

๋ถˆ ๋Œ€์ˆ˜(boolean algebra)๋Š” ์ˆ˜ํ•™์ž ๋ถˆ์ด ๋งŒ๋“ค์–ด๋‚ธ ๊ฒƒ์œผ๋กœ True(์ฐธ)/False(๊ฑฐ์ง“) ๊ฐ’๋งŒ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌ๊ฐ’๊ณผ ๊ทธ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ์—ฐ์‚ฐ์„ ๋‹ค๋ฃฌ๋‹ค.

 

โ–ท ํ•ด์„ค

๋ฐฐํƒ€์  ๋…ผ๋ฆฌํ•ฉ์ธ XOR์˜ ๊ฒฝ์šฐ ๋‘ ๊ฐ’์ด ๊ฐ™์€ ๊ฒฝ์šฐ False๊ฐ€ ๋‚˜์˜จ๋‹ค.

์ฆ‰, a์™€ b๊ฐ€ ๋ชจ๋‘ True์ด๊ฑฐ๋‚˜ False์ธ ๊ฒฝ์šฐ๋ฅผ ์ œ์™ธํ•œ ๊ฒฝ์šฐ์ธ a๋Š” True์ง€๋งŒ b๋Š” False์ธ ๊ฒฝ์šฐ๋‚˜ a๋Š” False์ง€๋งŒ b๋Š” True์ธ ๊ฒฝ์šฐ์— ์ตœ์ข… ๊ฒฐ๊ณผ๋กœ True๋ฅผ ๊ฐ€์ง„๋‹ค.

์œ„์˜ ํ‘œ์™€ ๊ฐ™์ด ์ „๊ฐœํ•˜๊ฒŒ ๋˜๋ฉด ์ •์ƒ์ ์œผ๋กœ XOR์„ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค. 

a, b = input().split()

boolA = bool(int(a))
boolB = bool(int(b))

print((boolA and (not boolB)) or (not boolA and (boolB)))

 

6057 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ์ฐธ/๊ฑฐ์ง“์ด ์„œ๋กœ ๊ฐ™์„ ๋•Œ์—๋งŒ ์ฐธ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

2๊ฐœ์˜ ์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’(True/False) ์ด ์„œ๋กœ ๊ฐ™์„ ๋•Œ์—๋งŒ True ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

โ–ท ํ•ด์„ค

๋จผ์ € ์ž…๋ ฅ๋ฐ›์€ ๊ฐ’์˜ bool ๊ฐ’์„ ๊ตฌํ•œ๋’ค ๊ด€๊ณ„ ์—ฐ์‚ฐ์ž๋ฅผ ํ†ตํ•ด ๋‘ ๊ฐ’์ด ๊ฐ™์€์ง€ ๋น„๊ตํ•˜๋ฉด ๋œ๋‹ค.

๋‹ค์Œ๊ณผ ๊ฐ™์ด == ์—ฐ์‚ฐ์ž๋ฅผ ์ด์šฉํ•˜๊ฒŒ ๋˜๋ฉด True, True์˜ ๊ฒฝ์šฐ๋‚˜ False, False์˜ ๊ฒฝ์šฐ์—๋งŒ True๊ฐ€ ์ถœ๋ ฅ๋œ๋‹ค.

๋˜๋Š” ์œ„์˜ ํ‘œ์™€ ๊ฐ™์ด not๊ณผ and์™€ or์„ ์ด์šฉํ•˜๋ฉด ๋‹ต์„ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค.

a, b = input().split()

boolA = bool(int(a))
boolB = bool(int(b))

print(boolA == boolB)
a, b = input().split()

boolA = bool(int(a))
boolB = bool(int(b))

print(((not boolA) and (not boolB)) or (boolA and boolB))

6058 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ๋‘˜ ๋‹ค ๊ฑฐ์ง“์ผ ๊ฒฝ์šฐ๋งŒ ์ฐธ ์ถœ๋ ฅํ•˜๊ธฐ(py)

2๊ฐœ์˜ ์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’(True/False) ์ด ๋ชจ๋‘ False ์ผ ๋•Œ์—๋งŒ True ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ํ•ด์„ค

(not boolA) and (not boolB)์™€ not (boolA and boolB)๋Š” ๊ฐ™์€ ์˜๋ฏธ๋ฅผ ๊ฐ€์ง€๊ณ  ์žˆ๋‹ค.

a, b = input().split()

boolA = bool(int(a))
boolB = bool(int(b))

print((not boolA) and (not boolB))

 

6059 : [๊ธฐ์ดˆ-๋น„ํŠธ๋‹จ์œ„๋…ผ๋ฆฌ์—ฐ์‚ฐ] ๋น„ํŠธ๋‹จ์œ„๋กœ NOT ํ•˜์—ฌ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

์ž…๋ ฅ ๋œ ์ •์ˆ˜๋ฅผ ๋น„ํŠธ๋‹จ์œ„๋กœ ์ฐธ/๊ฑฐ์ง“์„ ๋ฐ”๊พผ ํ›„ ์ •์ˆ˜๋กœ ์ถœ๋ ฅํ•ด๋ณด์ž.
๋น„ํŠธ๋‹จ์œ„(bitwise)์—ฐ์‚ฐ์ž ~ ๋ฅผ ๋ถ™์ด๋ฉด ๋œ๋‹ค.(~ : tilde, ํ‹ธ๋“œ๋ผ๊ณ  ์ฝ๋Š”๋‹ค.)

๋น„ํŠธ๋‹จ์œ„(bitwise) ์—ฐ์‚ฐ์ž๋Š”,
~(bitwise not), &(bitwise and), |(bitwise or), ^(bitwise xor),
<<(bitwise left shift), >>(bitwise right shift) ๊ฐ€ ์žˆ๋‹ค.

์˜ˆ๋ฅผ ๋“ค์–ด 1์ด ์ž…๋ ฅ๋˜์—ˆ์„ ๋•Œ ์ €์žฅ๋˜๋Š” 1์„ 32๋น„ํŠธ 2์ง„์ˆ˜๋กœ ํ‘œํ˜„ํ•˜๋ฉด
        00000000 00000000 00000000 00000001 ์ด๊ณ ,
~1์€ 11111111 11111111 11111111 11111110 ๊ฐ€ ๋˜๋Š”๋ฐ ์ด๋Š” -2๋ฅผ ์˜๋ฏธํ•œ๋‹ค.

 

โ–ท ์ฐธ๊ณ 

์ปดํ“จํ„ฐ์— ์ €์žฅ๋˜๋Š” ๋ชจ๋“  ๋ฐ์ดํ„ฐ๋“ค์€ 2์ง„์ˆ˜ ํ˜•ํƒœ๋กœ ๋ฐ”๋€Œ์–ด ์ €์žฅ๋œ๋‹ค.
0๊ณผ 1๋กœ๋งŒ ๊ตฌ์„ฑ๋˜๋Š” ๋น„ํŠธ๋‹จ์œ„๋“ค๋กœ ๋ณ€ํ™˜๋˜์–ด ์ €์žฅ๋˜๋Š”๋ฐ,
์–‘์˜ ์ •์ˆ˜๋Š” 2์ง„์ˆ˜ ํ˜•ํƒœ๋กœ ๋ฐ”๋€Œ์–ด ์ €์žฅ๋˜๊ณ , ์Œ์˜ ์ •์ˆ˜๋Š” "2์˜ ๋ณด์ˆ˜ ํ‘œํ˜„"๋ฐฉ๋ฒ•์œผ๋กœ ์ €์žฅ๋œ๋‹ค.

์–‘์˜ ์ •์ˆ˜ 5๋ฅผ 32๋น„ํŠธ๋กœ ์ €์žฅํ•˜๋ฉด, 

5์˜ 2์ง„์ˆ˜ ํ˜•ํƒœ์ธ 101์ด 32๋น„ํŠธ๋กœ ๋งŒ๋“ค์–ด์ ธ
00000000 00000000 00000000 00000101
๋กœ ์ €์žฅ๋œ๋‹ค.(๊ณต๋ฐฑ์€ ๋ณด๊ธฐ ํŽธํ•˜๋„๋ก ์ž„์˜๋กœ ๋ถ„๋ฆฌ)

32๋น„ํŠธ ํ˜•์˜ ์ •์ˆ˜ 0์€
00000000 00000000 00000000 00000000

๊ทธ๋ฆฌ๊ณ  -1์€ 0์—์„œ 1์„ ๋” ๋นผ๊ณ  32๋น„ํŠธ๋งŒ ํ‘œ์‹œํ•˜๋Š” ํ˜•ํƒœ๋กœ
11111111 11111111 11111111 11111111 ๋กœ ์ €์žฅ๋œ๋‹ค.

-2๋Š” -1์—์„œ 1์„ ๋” ๋นผ๋ฉด ๋œ๋‹ค.
11111111 11111111 11111111 11111110 ๋กœ ์ €์žฅ๋œ๋‹ค.

์ด๋Ÿฌํ•œ ๋‚ด์šฉ์„ ๊ฐ„๋‹จํžˆ ํ‘œํ˜„ํ•˜๋ฉด, ์ •์ˆ˜ n์ด๋ผ๊ณ  ํ•  ๋•Œ,

~n = -n - 1
-n = ~n + 1 ๊ณผ ๊ฐ™์€ ๊ด€๊ณ„๋กœ ํ‘œํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

์ด ๊ด€๊ณ„๋ฅผ ๊ทธ๋ฆผ์œผ๋กœ ๊ทธ๋ ค๋ณด๋ฉด ๋งˆ์น˜ ์›ํ˜•์œผ๋กœ ์ˆ˜๋“ค์ด ์ƒ๋Œ€์ ์œผ๋กœ ๋ฐฐ์น˜๋œ ๊ฒƒ๊ณผ ๊ฐ™๋‹ค.

 

a = int(input())
print(~a)

 

6060 : [๊ธฐ์ดˆ-๋น„ํŠธ๋‹จ์œ„๋…ผ๋ฆฌ์—ฐ์‚ฐ] ๋น„ํŠธ๋‹จ์œ„๋กœ AND ํ•˜์—ฌ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

์ž…๋ ฅ๋œ ์ •์ˆ˜ ๋‘ ๊ฐœ๋ฅผ ๋น„ํŠธ๋‹จ์œ„๋กœ and ์—ฐ์‚ฐํ•œ ํ›„ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ •์ˆ˜๋กœ ์ถœ๋ ฅํ•ด๋ณด์ž.
๋น„ํŠธ๋‹จ์œ„(bitwise)์—ฐ์‚ฐ์ž &๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ๋œ๋‹ค.(and, ampersand, ์•ฐํผ์„ผ๋“œ๋ผ๊ณ  ์ฝ๋Š”๋‹ค.)

 

๋น„ํŠธ๋‹จ์œ„(bitwise)์—ฐ์‚ฐ์ž๋Š”,
~(bitwise not), &(bitwise and), |(bitwise or), ^(bitwise xor),
<<(bitwise left shift), >>(bitwise right shift) ๊ฐ€ ์žˆ๋‹ค.

 

โ–ท ์ฐธ๊ณ 

์˜ˆ๋ฅผ ๋“ค์–ด 3๊ณผ 5๊ฐ€ ์ž…๋ ฅ๋˜์—ˆ์„ ๋•Œ๋ฅผ ์‚ดํŽด๋ณด๋ฉด
3       : 00000000 00000000 00000000 00000011
5       : 00000000 00000000 00000000 00000101
3 & 5 : 00000000 00000000 00000000 00000001
์ด ๋œ๋‹ค.

๋น„ํŠธ๋‹จ์œ„ and ์—ฐ์‚ฐ์€ ๋‘ ๋น„ํŠธ์—ด์ด ์ฃผ์–ด์กŒ์„ ๋•Œ,
๋‘˜ ๋‹ค 1์ธ ๋ถ€๋ถ„์˜ ์ž๋ฆฌ๋งŒ 1๋กœ ๋งŒ๋“ค์–ด์ฃผ๋Š” ๊ฒƒ๊ณผ ๊ฐ™๋‹ค.

์ด ์—ฐ์‚ฐ์„ ์ด์šฉํ•˜๋ฉด ์–ด๋–ค ๋น„ํŠธ์—ด์˜ ํŠน์ • ๋ถ€๋ถ„๋งŒ ๋ชจ๋‘ 0์œผ๋กœ๋„ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š”๋ฐ
192.168.0.31   : 11000000.10101000.00000000.00011111
255.255.255.0 : 11111111.11111111.11111111.00000000

๋‘ ๊ฐœ์˜ ip ์ฃผ์†Œ๋ฅผ & ์—ฐ์‚ฐํ•˜๋ฉด
192.168.0.0 :     110000000.10101000.0000000.00000000 ์„ ๊ณ„์‚ฐํ•  ์ˆ˜ ์žˆ๋‹ค.

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

์ด๋Ÿฌํ•œ ๋น„ํŠธ๋‹จ์œ„ ์—ฐ์‚ฐ์€ ๋น ๋ฅธ ๊ณ„์‚ฐ์ด ํ•„์š”ํ•œ ๊ทธ๋ž˜ํ”ฝ์ฒ˜๋ฆฌ์—์„œ
๋งˆ์Šคํฌ์—ฐ์‚ฐ(ํŠน์ • ๋ถ€๋ถ„์„ ๊ฐ€๋ฆฌ๊ณ  ์ถœ๋ ฅํ•˜๋Š”)์„ ์ˆ˜ํ–‰ํ•˜๋Š” ๋ฐ์—๋„ ํšจ๊ณผ์ ์œผ๋กœ ์‚ฌ์šฉ๋œ๋‹ค.

 

a, b = input().split()
print(int(a) & int(b))

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

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

 

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

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

 

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

 

codeup.kr

 

6051 : [๊ธฐ์ดˆ-๋น„๊ต์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋น„๊ตํ•˜๊ธฐ4(์„ค๋ช…)(py)

๋‘ ์ •์ˆ˜(a, b)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
a์˜ ๊ฐ’์ด b์˜ ๊ฐ’๊ณผ ์„œ๋กœ ๋‹ค๋ฅด๋ฉด True ๋ฅผ, ๊ฐ™์œผ๋ฉด False ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

์–ด๋–ค ๊ฐ’์„ ๋น„๊ตํ•˜๊ธฐ ์œ„ํ•ด ๋น„๊ต/๊ด€๊ณ„(comparison/relational) ์—ฐ์‚ฐ์ž(operator)๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž != ๋Š”
์™ผ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’์ด ์˜ค๋ฅธ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’์ด ์„œ๋กœ ๋‹ค๋ฅธ ๊ฒฝ์šฐ True(์ฐธ)๋กœ ๊ณ„์‚ฐํ•˜๊ณ ,
๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ์—๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋„ ์ผ๋ฐ˜์ ์ธ ์‚ฌ์น™์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์ฃผ์–ด์ง„ ๋‘ ์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๊ณ ,
๊ทธ ๊ฒฐ๊ณผ๋ฅผ True(์ฐธ), ๋˜๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•ด์ฃผ๋Š” ์—ฐ์‚ฐ์ž์ด๋‹ค.
๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋Š” <, >, <=, >=, ==(๊ฐ™๋‹ค), !=(๋‹ค๋ฅด๋‹ค) 6๊ฐœ๊ฐ€ ์žˆ๋‹ค.

 

โ–ท ํ•ด์„ค

!๋Š” ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฌธ๋ฒ•์—์„œ ๋ถ€์ •์˜ ์˜๋ฏธ๋กœ ์“ฐ์ธ๋‹ค. 

๊ทธ๋ž˜์„œ !๊ฐ€ ๊ฐ™๋‹ค๋Š” ์˜๋ฏธ์ธ =์™€ ๊ฐ™์ด ์‚ฌ์šฉ๋˜๋ฉด ==์˜ ๋ฐ˜๋Œ€์ธ ๋ถ€์ •์˜ ์˜๋ฏธ์ธ ๊ฐ™์ง€์•Š๋‹ค(!=)๊ฐ€ ๋œ๋‹ค

a, b = input().split()
print(int(a) != int(b))

 

6052 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ์ •์ˆ˜ ์ž…๋ ฅ๋ฐ›์•„ ์ฐธ ๊ฑฐ์ง“ ํ‰๊ฐ€ํ•˜๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜๊ฐ€ ์ž…๋ ฅ๋˜์—ˆ์„ ๋•Œ, True/False ๋กœ ํ‰๊ฐ€ํ•ด์ฃผ๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

bool( ) ์„ ์ด์šฉํ•˜๋ฉด ์ž…๋ ฅ๋œ ์‹์ด๋‚˜ ๊ฐ’์„ ํ‰๊ฐ€ํ•ด ๋ถˆ ํ˜•์˜ ๊ฐ’(True ๋˜๋Š” False)์„ ์ถœ๋ ฅํ•ด์ค€๋‹ค.
์‹์ด๋‚˜ ๊ฐ’์„ ๊ณ„์‚ฐํ•ด์„œ ๊ฒฐ๊ณผ๊ฐ’์ด ๋งŒ๋“ค์–ด์ง€๋Š” ๊ฒƒ์„ ํ‰๊ฐ€(evaluate)๋ผ๊ณ  ํ•œ๋‹ค. 

python ์–ธ์–ด์—์„œ ์ •์ˆ˜๊ฐ’ 0์€ False(๊ฑฐ์ง“)๋กœ ํ‰๊ฐ€๋˜๊ณ , ๊ทธ ์™ธ์˜ ๊ฐ’๋“ค์€ ๋ชจ๋‘ True(์ฐธ)๋กœ ํ‰๊ฐ€๋œ๋‹ค.


๋ถˆ ๋Œ€์ˆ˜(boolean algebra)๋Š” ์ˆ˜ํ•™์ž ๋ถˆ์ด ๋งŒ๋“ค์–ด๋‚ธ ๊ฒƒ์œผ๋กœ True(์ฐธ)/False(๊ฑฐ์ง“) ๊ฐ’๋งŒ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌ๊ฐ’๊ณผ ๊ทธ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ์—ฐ์‚ฐ์„ ๋‹ค๋ฃฌ๋‹ค.

 

โ–ท ํ•ด์„ค

์ฐธ๊ณผ ๊ฑฐ์ง“์„ ๋น„๊ตํ•˜๊ธฐ ์œ„ํ•ด์„œ boolํ•จ์ˆ˜๋ฅผ ์ด์šฉํ•˜๋ฉด๋œ๋‹ค.

boolํ•จ์ˆ˜๋Š” 0๊ณผ ๋นˆ๋ฌธ์ž์—ด ''๊ฐ™์€ ๊ฐ’์„ ์ œ์™ธํ•œ ๋ชจ๋“  ๊ฐ’์„ True๋กœ ๊ฐ€์ง„๋‹ค.

n = int(input())
print(bool(n))

 

6053 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ์ฐธ ๊ฑฐ์ง“ ๋ฐ”๊พธ๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’์„ ๋ฐ˜๋Œ€๋กœ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

a = bool(int(input()))
์™€ ๊ฐ™์€ ํ˜•ํƒœ๋กœ ๊ฒน์ณ ์ž‘์„ฑํ•˜๋ฉด, ํ•œ ๋ฒˆ์— ํ•œ ๋‹จ๊ณ„์”ฉ ๊ณ„์‚ฐ/์ฒ˜๋ฆฌ/ํ‰๊ฐ€๋œ๋‹ค.
์œ„์™€ ๊ฐ™์€ ๋ช…๋ น๋ฌธ์˜ ๊ฒฝ์šฐ input( ), int( ), bool( ) ์ˆœ์„œ๋กœ ํ•œ ๋ฒˆ์— ํ•œ ๋‹จ๊ณ„์”ฉ ๊ณ„์‚ฐ/์ฒ˜๋ฆฌ/ํ‰๊ฐ€๋œ๋‹ค.

์–ด๋–ค ๋ถˆ ๊ฐ’์ด๋‚˜ ๋ณ€์ˆ˜์— not True, not False, not a ์™€ ๊ฐ™์€ ๊ณ„์‚ฐ์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

์ฐธ ๋˜๋Š” ๊ฑฐ์ง“์˜ ๋…ผ๋ฆฌ๊ฐ’์„ ์—ญ(๋ฐ˜๋Œ€)์œผ๋กœ ๋ฐ”๊พธ๊ธฐ ์œ„ํ•ด์„œ not ์˜ˆ์•ฝ์–ด(reserved word, keyword)๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

์ด๋Ÿฌํ•œ ๋…ผ๋ฆฌ์—ฐ์‚ฐ์„ NOT ์—ฐ์‚ฐ(boolean NOT)์ด๋ผ๊ณ ๋„ ๋ถ€๋ฅด๊ณ ,
ํ”„๋ผ์ž„ '(๋ฌธ์ž ์˜ค๋ฅธ์ชฝ ์œ„์— ์ž‘์€ ๋”ฐ์˜ดํ‘œ), ๋ฐ”(๊ธฐํ˜ธ ์œ„์— ๊ฐ€๋กœ ๋ง‰๋Œ€), ๋ฌธ์ž ์˜ค๋ฅธ์ชฝ ์œ„์— c(์—ฌ์ง‘ํ•ฉ, complement) ๋“ฑ์œผ๋กœ ํ‘œ์‹œํ•œ๋‹ค.
๋ชจ๋‘ ๊ฐ™์€ ์˜๋ฏธ์ด๋‹ค.

์ฐธ, ๊ฑฐ์ง“์˜ ๋…ผ๋ฆฌ๊ฐ’ ์ธ ๋ถˆ(boolean) ๊ฐ’์„ ๋‹ค๋ฃจ์–ด์ฃผ๋Š” ์˜ˆ์•ฝ์–ด๋Š” not, and, or ์ด ์žˆ๊ณ ,
๋ถˆ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ๋…ผ๋ฆฌ(not, and, or) ์—ฐ์‚ฐ ๊ฒฐ๊ณผ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ True ๋˜๋Š” False ์˜ ๋ถˆ ๊ฐ’์œผ๋กœ ๊ณ„์‚ฐ ๋œ๋‹ค.

์ •์ˆ˜๊ฐ’ 0์€ False ์ด๊ณ , ๋‚˜๋จธ์ง€ ์ •์ˆ˜ ๊ฐ’๋“ค์€ True ๋กœ ํ‰๊ฐ€๋œ๋‹ค.
๋นˆ ๋ฌธ์ž์—ด "" ๋‚˜ ''๋Š” False ์ด๊ณ , ๋‚˜๋จธ์ง€ ๋ฌธ์ž์—ด๋“ค์€ True ๋กœ ํ‰๊ฐ€๋œ๋‹ค.

๋ถˆ ๋Œ€์ˆ˜(boolean algebra)๋Š” ์ˆ˜ํ•™์ž ๋ถˆ์ด ๋งŒ๋“ค์–ด๋‚ธ ๊ฒƒ์œผ๋กœ True(์ฐธ)/False(๊ฑฐ์ง“) ๊ฐ’๋งŒ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌ๊ฐ’๊ณผ ๊ทธ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ์—ฐ์‚ฐ์„ ๋‹ค๋ฃฌ๋‹ค.

 

โ–ท ํ•ด์„ค

๋น„๊ต๊ด€๊ณ„ ์—ฐ์‚ฐ์ž์˜ ๊ฒฐ๊ณผ๋‚˜ boolํ•จ์ˆ˜์˜ ๊ฒฐ๊ณผ์˜ ๋ฐ˜๋Œ€ ๊ฐ’์„ ๊ตฌํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” not ์˜ˆ์•ฝ์–ด๋ฅผ ์ด์šฉํ•œ๋‹ค.

n = int(input())
print(not bool(n))

 

6054 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ๋‘˜ ๋‹ค ์ฐธ์ผ ๊ฒฝ์šฐ๋งŒ ์ฐธ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

2๊ฐœ์˜ ์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’์ด ๋ชจ๋‘ True ์ผ ๋•Œ์—๋งŒ True ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

and ์˜ˆ์•ฝ์–ด๋Š” ์ฃผ์–ด์ง„ ๋‘ ๋ถˆ ๊ฐ’์ด ๋ชจ๋‘ True ์ผ ๋•Œ์—๋งŒ True ๋กœ ๊ณ„์‚ฐํ•˜๊ณ , ๋‚˜๋จธ์ง€ ๊ฒฝ์šฐ๋Š” False ๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.
์ด๋Ÿฌํ•œ ๋…ผ๋ฆฌ์—ฐ์‚ฐ์„ AND ์—ฐ์‚ฐ(boolean AND)์ด๋ผ๊ณ ๋„ ๋ถ€๋ฅด๊ณ , · ์œผ๋กœ ํ‘œ์‹œํ•˜๊ฑฐ๋‚˜ ์ƒ๋žตํ•˜๋ฉฐ, ์ง‘ํ•ฉ ๊ธฐํ˜ธ ∩(๊ต์ง‘ํ•ฉ, intersection)๋กœ ํ‘œ์‹œํ•˜๊ธฐ๋„ ํ•œ๋‹ค. 
๋ชจ๋‘ ๊ฐ™์€ ์˜๋ฏธ์ด๋‹ค.

์ฐธ, ๊ฑฐ์ง“์˜ ๋…ผ๋ฆฌ๊ฐ’ ์ธ ๋ถˆ(boolean) ๊ฐ’์„ ๋‹ค๋ฃจ์–ด์ฃผ๋Š” ์˜ˆ์•ฝ์–ด๋Š” not, and, or ์ด ์žˆ๊ณ ,
๋ถˆ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ๋…ผ๋ฆฌ(not, and, or) ์—ฐ์‚ฐ ๊ฒฐ๊ณผ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ True ๋˜๋Š” False ์˜ ๋ถˆ ๊ฐ’์œผ๋กœ ๊ณ„์‚ฐ๋œ๋‹ค.

๋ถˆ ๋Œ€์ˆ˜(boolean algebra)๋Š” ์ˆ˜ํ•™์ž ๋ถˆ์ด ๋งŒ๋“ค์–ด๋‚ธ ๊ฒƒ์œผ๋กœ True(์ฐธ)/False(๊ฑฐ์ง“) ๊ฐ’๋งŒ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌ๊ฐ’๊ณผ ๊ทธ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ์—ฐ์‚ฐ์„ ๋‹ค๋ฃฌ๋‹ค.

 

โ–ท ํ•ด์„ค

๋‘ ๊ฐ’์ด ๋ชจ๋‘ ์ฐธ์ผ ๋•Œ์—๋งŒ True๋ฅผ ๊ฐ€์ง€๋Š” AND ์—ฐ์‚ฐ์„ ์ด์šฉํ•˜๋ฉด ๋‘ ๊ฐ’์ด ๋ชจ๋‘ ์ฐธ์ธ์ง€ ์•Œ ์ˆ˜ ์žˆ๋‹ค.

์ฐธ๊ณ ๋กœ ๋Œ€๋ถ€๋ถ„์˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฌธ๋ฒ•์€ python๊ณผ๋Š” ๋‹ฌ๋ฆฌ AND๋ฅผ &&๋กœ ํ‘œํ˜„ํ•œ๋‹ค.

a, b = input().split()

a = int(a)
b = int(b)
print(bool(a) and bool(b))

 

6055 : [๊ธฐ์ดˆ-๋…ผ๋ฆฌ์—ฐ์‚ฐ] ํ•˜๋‚˜๋ผ๋„ ์ฐธ์ด๋ฉด ์ฐธ ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

2๊ฐœ์˜ ์ •์ˆ˜๊ฐ’์ด ์ž…๋ ฅ๋  ๋•Œ,
๊ทธ ๋ถˆ ๊ฐ’์ด ํ•˜๋‚˜๋ผ๋„ True ์ผ ๋•Œ์—๋งŒ True ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

or ์˜ˆ์•ฝ์–ด๋Š” ์ฃผ์–ด์ง„ ๋‘ ๋ถˆ ๊ฐ’ ์ค‘์—์„œ ํ•˜๋‚˜๋ผ๋„ True ์ด๋ฉด True ๋กœ ๊ณ„์‚ฐํ•˜๊ณ , ๋‚˜๋จธ์ง€ ๊ฒฝ์šฐ๋Š” False ๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.
์ด๋Ÿฌํ•œ ๋…ผ๋ฆฌ์—ฐ์‚ฐ์„ OR ์—ฐ์‚ฐ(boolean OR)์ด๋ผ๊ณ ๋„ ๋ถ€๋ฅด๊ณ , + ๋กœ ํ‘œ์‹œํ•˜๊ฑฐ๋‚˜, ์ง‘ํ•ฉ ๊ธฐํ˜ธ ∪(ํ•ฉ์ง‘ํ•ฉ, union)๋กœ ํ‘œ์‹œํ•˜๊ธฐ๋„ ํ•œ๋‹ค.
๋ชจ๋‘ ๊ฐ™์€ ์˜๋ฏธ์ด๋‹ค.

์ฐธ, ๊ฑฐ์ง“์˜ ๋…ผ๋ฆฌ๊ฐ’ ์ธ ๋ถˆ(boolean) ๊ฐ’์„ ๋‹ค๋ฃจ์–ด์ฃผ๋Š” ์˜ˆ์•ฝ์–ด๋Š” not, and, or ์ด ์žˆ๊ณ ,
๋ถˆ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ๋…ผ๋ฆฌ(not, and, or) ์—ฐ์‚ฐ ๊ฒฐ๊ณผ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ True ๋˜๋Š” False ์˜ ๋ถˆ ๊ฐ’์œผ๋กœ ๊ณ„์‚ฐ๋œ๋‹ค.

๋ถˆ ๋Œ€์ˆ˜(boolean algebra)๋Š” ์ˆ˜ํ•™์ž ๋ถˆ์ด ๋งŒ๋“ค์–ด๋‚ธ ๊ฒƒ์œผ๋กœ True(์ฐธ)/False(๊ฑฐ์ง“) ๊ฐ’๋งŒ ๊ฐ€์ง€๋Š” ๋…ผ๋ฆฌ๊ฐ’๊ณผ ๊ทธ ๊ฐ’๋“ค ์‚ฌ์ด์˜ ์—ฐ์‚ฐ์„ ๋‹ค๋ฃฌ๋‹ค.

โ–ท ํ•ด์„ค

๋‘ ๊ฐ’ ์ค‘ ํ•˜๋‚˜๋ผ๋„ ์ฐธ์ธ ๊ฒฝ์šฐ True๋ฅผ ๊ฐ€์ง€๋Š” OR ์—ฐ์‚ฐ์„ ์ด์šฉํ•˜๋ฉด ๋‘ ๊ฐ’ ์ค‘ ํ•˜๋‚˜๋ผ๋„ ์ฐธ์ธ์ง€ ์•Œ ์ˆ˜ ์žˆ๋‹ค.

์ฐธ๊ณ ๋กœ ๋Œ€๋ถ€๋ถ„์˜ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ๋ฌธ๋ฒ•์€ python๊ณผ๋Š” ๋‹ฌ๋ฆฌ OR์„ ||๋กœ ํ‘œํ˜„ํ•œ๋‹ค.

a, b = input().split()

a = int(a)
b = int(b)
print(bool(a) or bool(b))

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

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

 

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

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

 

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

 

codeup.kr

 

6046 : [๊ธฐ์ดˆ-๋น„ํŠธ์‹œํ”„ํŠธ์—ฐ์‚ฐ] ์ •์ˆ˜ 1๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ 2๋ฐฐ ๊ณฑํ•ด ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜ 1๊ฐœ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ 2๋ฐฐ ๊ณฑํ•ด ์ถœ๋ ฅํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

*2 ๋ฅผ ๊ณ„์‚ฐํ•œ ๊ฐ’์„ ์ถœ๋ ฅํ•ด๋„ ๋˜์ง€๋งŒ,
์ •์ˆ˜๋ฅผ 2๋ฐฐ๋กœ ๊ณฑํ•˜๊ฑฐ๋‚˜ ๋‚˜๋ˆ„์–ด ๊ณ„์‚ฐํ•ด ์ฃผ๋Š” ๋น„ํŠธ๋‹จ์œ„์‹œํ”„ํŠธ์—ฐ์‚ฐ์ž <<, >>๋ฅผ ์ด์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.
์ปดํ“จํ„ฐ ๋‚ด๋ถ€์—๋Š” 2์ง„์ˆ˜ ํ˜•ํƒœ๋กœ ๊ฐ’๋“ค์ด ์ €์žฅ๋˜๊ธฐ ๋•Œ๋ฌธ์—,
2์ง„์ˆ˜ ํ˜•ํƒœ๋กœ ์ €์žฅ๋˜์–ด ์žˆ๋Š” ๊ฐ’๋“ค์„ ์™ผ์ชฝ(<<)์ด๋‚˜ ์˜ค๋ฅธ์ชฝ(>>)์œผ๋กœ
์ง€์ •ํ•œ ๋น„ํŠธ ์ˆ˜๋งŒํผ ๋ฐ€์–ด์ฃผ๋ฉด 2๋ฐฐ์”ฉ ๋Š˜์–ด๋‚˜๊ฑฐ๋‚˜ 1/2๋กœ ์ค„์–ด๋“œ๋Š”๋ฐ,

์™ผ์ชฝ ๋น„ํŠธ์‹œํ”„ํŠธ(<<)๊ฐ€ ๋  ๋•Œ์—๋Š” ์˜ค๋ฅธ์ชฝ์— 0์ด ์ฃผ์–ด์ง„ ๊ฐœ์ˆ˜๋งŒํผ ์ถ”๊ฐ€๋˜๊ณ ,
์˜ค๋ฅธ์ชฝ ๋น„ํŠธ์‹œํ”„ํŠธ(>>)๊ฐ€ ๋  ๋•Œ์—๋Š” ์™ผ์ชฝ์— 0(0 ๋˜๋Š” ์–‘์˜ ์ •์ˆ˜์ธ ๊ฒฝ์šฐ)์ด๋‚˜ 1(์Œ์˜ ์ •์ˆ˜์ธ ๊ฒฝ์šฐ)์ด ๊ฐœ์ˆ˜๋งŒํผ ์ถ”๊ฐ€๋˜๊ณ ,
๊ฐ€์žฅ ์˜ค๋ฅธ์ชฝ์— ์žˆ๋Š” 1๋น„ํŠธ๋Š” ์‚ฌ๋ผ์ง„๋‹ค.

 

โ–ท ์˜ˆ์‹œ

n = 10
print(n<<1)  #10์„ 2๋ฐฐ ํ•œ ๊ฐ’์ธ 20 ์ด ์ถœ๋ ฅ๋œ๋‹ค.
print(n>>1)  #10์„ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆˆ ๊ฐ’์ธ 5 ๊ฐ€ ์ถœ๋ ฅ๋œ๋‹ค.
print(n<<2)  #10์„ 4๋ฐฐ ํ•œ ๊ฐ’์ธ 40 ์ด ์ถœ๋ ฅ๋œ๋‹ค.
print(n>>2)  #10์„ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆˆ ํ›„ ๋‹ค์‹œ ๋ฐ˜์œผ๋กœ ๋‚˜๋ˆˆ ๊ฐ’์ธ 2 ๊ฐ€ ์ถœ๋ ฅ๋œ๋‹ค.

์ •์ˆ˜ 10์˜ 2์ง„์ˆ˜ ํ‘œํ˜„์€ ... 1010 ์ด๋‹ค.
10 << 1 ์„ ๊ณ„์‚ฐํ•˜๋ฉด ... 10100 ์ด ๋œ๋‹ค ์ด ๊ฐ’์€ 10์ง„์ˆ˜๋กœ 20์ด๋‹ค.
10 >> 1 ์„ ๊ณ„์‚ฐํ•˜๋ฉด ... 101 ์ด ๋œ๋‹ค. ์ด ๊ฐ’์€ 10์ง„์ˆ˜๋กœ 5์ด๋‹ค.

n = 10 ๊ณผ ๊ฐ™์ด ํ‚ค๋ณด๋“œ๋กœ ์ž…๋ ฅ๋ฐ›์ง€ ์•Š๊ณ  ์ง์ ‘ ์ž‘์„ฑํ•ด ๋„ฃ์€ ์ฝ”๋“œ์—์„œ, ์ˆซ์ž๋กœ ์‹œ์ž‘ํ•˜๋Š” ๋‹จ์–ด(์‹๋ณ„์ž, identifier)๋Š” ์ž๋™์œผ๋กœ ์ˆ˜๋กœ ์ธ์‹๋œ๋‹ค.  

n = 10 ์—์„œ 10 ์€ 10์ง„์ˆ˜ ์ •์ˆ˜ ๊ฐ’์œผ๋กœ ์ธ์‹๋œ๋‹ค.
๋ณ€์ˆ˜ n ์— ๋ฌธ์ž์—ด์„ ์ €์žฅํ•˜๊ณ  ์‹ถ๋‹ค๋ฉด, n = "10" ๋˜๋Š” n = '10'์œผ๋กœ ์ž‘์„ฑํ•ด ๋„ฃ์œผ๋ฉด ๋˜๊ณ ,

 

n = 10.0 ์œผ๋กœ ์ž‘์„ฑํ•ด ๋„ฃ์œผ๋ฉด ์ž๋™์œผ๋กœ ์‹ค์ˆ˜ ๊ฐ’์œผ๋กœ ์ €์žฅ๋œ๋‹ค.
n = 0o10 ์œผ๋กœ ์ž‘์„ฑํ•ด ๋„ฃ์œผ๋ฉด 8์ง„์ˆ˜(octal) 10์œผ๋กœ ์ธ์‹๋˜์–ด 10์ง„์ˆ˜ 8๊ฐ’์ด ์ €์žฅ๋˜๊ณ ,
n = 0xf ๋‚˜ n = 0XF ์œผ๋กœ ์ž‘์„ฑํ•ด ๋„ฃ์œผ๋ฉด 16์ง„์ˆ˜(hexadecimal) F๋กœ ์ธ์‹๋˜์–ด 10์ง„์ˆ˜ 15๊ฐ’์œผ๋กœ ์ €์žฅ๋œ๋‹ค.

** python์—์„œ ์‹ค์ˆ˜ ๊ฐ’์— ๋Œ€ํ•œ ๋น„ํŠธ์‹œํ”„ํŠธ ์—ฐ์‚ฐ์€ ํ—ˆ์šฉ๋˜์ง€ ์•Š๊ณ  ์˜ค๋ฅ˜๊ฐ€ ๋ฐœ์ƒํ•œ๋‹ค.
(์‹ค์ˆ˜ ๊ฐ’๋„ ์ปดํ“จํ„ฐ ๋‚ด๋ถ€์ ์œผ๋กœ๋Š” 2์ง„์ˆ˜ ํ˜•ํƒœ๋กœ ์ €์žฅ๋˜๊ณ  ๋น„ํŠธ์‹œํ”„ํŠธ ์ฒ˜๋ฆฌ๊ฐ€ ๋  ์ˆ˜ ์žˆ์ง€๋งŒ, python ์—์„œ๋Š” ํ—ˆ์šฉํ•˜์ง€ ์•Š๋Š”๋‹ค.)

 

n = int(input())
print(n*2)
n = int(input())
print(n<<1)

 

6047 : [๊ธฐ์ดˆ-๋น„ํŠธ์‹œํ”„ํŠธ์—ฐ์‚ฐ] 2์˜ ๊ฑฐ๋“ญ์ œ๊ณฑ ๋ฐฐ๋กœ ๊ณฑํ•ด ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜ 2๊ฐœ(a, n)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ a๋ฅผ 2โฟ๋ฐฐ ๊ณฑํ•œ ๊ฐ’์œผ๋กœ ์ถœ๋ ฅํ•ด๋ณด์ž.
0 <= a <= 10, 0 <= n <= 10

 

โ–ท ์ฐธ๊ณ 

์˜ˆ๋ฅผ ๋“ค์–ด 1 3 ์ด ์ž…๋ ฅ๋˜๋ฉด 1์„ 2³(=8)๋ฐฐ ํ•˜์—ฌ ์ถœ๋ ฅํ•œ๋‹ค.

 

โ–ท ํ•ด์„ค

๋น„ํŠธ ์‹œํ”„ํŠธ ์—ฐ์‚ฐ์„ ์ด์šฉํ•˜๋ฉด ๋ฐ˜๋ณต๋ฌธ ์—†์ด๋„ 2์˜ n์Šน์„ ์‰ฝ๊ฒŒ ๊ตฌํ•  ์ˆ˜ ์žˆ๋‹ค.

 

a, n = input().split()

a = int(a)
n = int(n)

print(a<<n)

 

6048 : [๊ธฐ์ดˆ-๋น„๊ต์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋น„๊ตํ•˜๊ธฐ1(์„ค๋ช…)(py)

๋‘ ์ •์ˆ˜(a, b)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
a๊ฐ€ b๋ณด๋‹ค ์ž‘์œผ๋ฉด True ๋ฅผ, a๊ฐ€ b๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™์œผ๋ฉด False ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

์–ด๋–ค ๊ฐ’์„ ๋น„๊ตํ•˜๊ธฐ ์œ„ํ•ด ๋น„๊ต/๊ด€๊ณ„(comparison/relational) ์—ฐ์‚ฐ์ž(operator)๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž < (less than sign) ๋Š”
์™ผ์ชฝ์˜ ๊ฐ’์ด ์˜ค๋ฅธ์ชฝ ๊ฐ’ ๋ณด๋‹ค ์ž‘์€ ๊ฒฝ์šฐ True(์ฐธ)๋กœ ๊ณ„์‚ฐํ•˜๊ณ ,
๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ์—๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋„ ์ผ๋ฐ˜์ ์ธ ์‚ฌ์น™์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์ฃผ์–ด์ง„ ๋‘ ์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๊ณ ,
๊ทธ ๊ฒฐ๊ณผ๋ฅผ True(์ฐธ), ๋˜๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•ด ์ฃผ๋Š” ์—ฐ์‚ฐ์ž์ด๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋Š” <, >, <=, >=, ==(๊ฐ™๋‹ค), !=(๋‹ค๋ฅด๋‹ค) 6๊ฐœ๊ฐ€ ์žˆ๋‹ค.

True(์ฐธ) ๋˜๋Š” False(๊ฑฐ์ง“) ๊ฐ’์œผ๋กœ๋งŒ ํ‘œํ˜„ํ•˜๊ณ  ์ €์žฅํ•˜๋Š” ๊ฐ’์„ ๋ถˆ(bool)/๋ถˆ๋ฆฌ์–ธ(boolean) ๊ฐ’์ด๋ผ๊ณ  ํ•œ๋‹ค.
์ •์ˆ˜, ์‹ค์ˆ˜, ๋ฌธ์ž, ๋ฌธ์ž์—ด๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ๋˜ ๋‹ค๋ฅธ ํ˜•ํƒœ์˜ ๋ฐ์ดํ„ฐํ˜•(data type)์ด๋‹ค.

 

โ–ท ํ•ด์„ค

๋น„๊ต ์—ฐ์‚ฐ์ž๋ฅผ ์ด์šฉํ•˜๋ฉด ๊ทธ ๊ฒฐ๊ณผ๊ฐ€ True๋‚˜ False๋กœ ๋‚˜์˜จ๋‹ค.

๋น„๊ต ์—ฐ์‚ฐ์ž๋Š” ์ฃผ๋กœ ๋ฐ˜๋ณต๋ฌธ๊ณผ ์กฐ๊ฑด๋ฌธ์— ์‚ฌ์šฉ๋˜๊ณ  ์žˆ๋‹ค.

a, b = input().split()

print(int(a)<int(b))

 

6049 : [๊ธฐ์ดˆ-๋น„๊ต์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋น„๊ตํ•˜๊ธฐ2(์„ค๋ช…)(py)

๋‘ ์ •์ˆ˜(a, b)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
a์™€ b์˜ ๊ฐ’์ด ๊ฐ™์œผ๋ฉด True ๋ฅผ, ๊ฐ™์ง€ ์•Š์œผ๋ฉด False ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

์–ด๋–ค ๊ฐ’์„ ๋น„๊ตํ•˜๊ธฐ ์œ„ํ•ด ๋น„๊ต/๊ด€๊ณ„(comparison/relational) ์—ฐ์‚ฐ์ž(operator)๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž == (equal sign 2๊ฐœ) ๋Š”
์™ผ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’๊ณผ ์˜ค๋ฅธ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’์ด ๊ฐ™์€ ๊ฒฝ์šฐ True(์ฐธ)๋กœ ๊ณ„์‚ฐํ•˜๊ณ ,
๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ์—๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋„ ์ผ๋ฐ˜์ ์ธ ์‚ฌ์น™์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์ฃผ์–ด์ง„ ๋‘ ์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๊ณ ,
๊ทธ ๊ฒฐ๊ณผ๋ฅผ True(์ฐธ), ๋˜๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•ด ์ฃผ๋Š” ์—ฐ์‚ฐ์ž์ด๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋Š” <, >, <=, >=, ==(๊ฐ™๋‹ค), !=(๋‹ค๋ฅด๋‹ค) 6๊ฐœ๊ฐ€ ์žˆ๋‹ค.

** ์ˆ˜ํ•™์—์„œ ์™ผ์ชฝ๊ณผ ์˜ค๋ฅธ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ€ ๊ฐ™์Œ(๋™์น˜)์„ ๋‚˜ํƒ€๋‚ด๋Š” ๊ธฐํ˜ธ =(equal sign) 1๊ฐœ๋Š”
ํ”„๋กœ๊ทธ๋ž˜๋ฐ์–ธ์–ด์—์„œ๋Š” ์ „ํ˜€ ๋‹ค๋ฅธ ์˜๋ฏธ๋กœ ์‚ฌ์šฉ๋œ๋‹ค.

a = 1 ์™€ ๊ฐ™์€ ํ‘œํ˜„์€ a์™€ 1์˜ ๊ฐ’์ด ๊ฐ™๋‹ค๋Š” ์˜๋ฏธ๊ฐ€ ์•„๋‹ˆ๋ผ
์˜ค๋ฅธ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’์ธ 1์„ ์™ผ์ชฝ์˜ ๋ณ€์ˆ˜ a์— ์ €์žฅํ•˜๋ผ๋Š” ์˜๋ฏธ์ด๋‹ค.

 

โ–ท ํ•ด์„ค

'๊ฐ™๋‹ค'๋ฅผ ์šฐ๋ฆฌ๋Š” '=' ๋ถ€ํ˜ธ๋กœ ์‚ฌ์šฉํ•˜์ง€๋งŒ ๋ฌธ๋ฒ•์—์„œ '='๋Š” ๋Œ€์ž…์—ฐ์‚ฐ์ž๋กœ ์‚ฌ์šฉ๋˜๊ณ  ์žˆ์œผ๋ฏ€๋กœ ์ˆ˜์˜ ๋™์น˜๋ฅผ ์˜๋ฏธํ•˜๋Š” "๊ฐ™๋‹ค(๋™์น˜)"๋Š” "=="์œผ๋กœ ์‚ฌ์šฉํ•˜๊ณ  ์žˆ๋‹ค.

๋™์น˜๋ฅผ ํ™•์ธํ•˜๋Š” ์—ฐ์‚ฐ์ž๋Š” ๊ด€๊ณ„ ์—ฐ์‚ฐ์ž์ด๋ฏ€๋กœ ๊ฒฐ๊ณผ๊ฐ€ True์™€ False๊ฐ€ ๋‚˜์˜จ๋‹ค. 

a, b = input().split()
print(int(a) == int(b))

 

6050 : [๊ธฐ์ดˆ-๋น„๊ต์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋น„๊ตํ•˜๊ธฐ3(์„ค๋ช…)(py)

๋‘ ์ •์ˆ˜(a, b)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
b์˜ ๊ฐ’์ด a์˜ ๊ฐ’ ๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™์œผ๋ฉด True ๋ฅผ, ๊ฐ™์ง€ ์•Š์œผ๋ฉด False ๋ฅผ ์ถœ๋ ฅํ•˜๋Š” ํ”„๋กœ๊ทธ๋žจ์„ ์ž‘์„ฑํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

์–ด๋–ค ๊ฐ’์„ ๋น„๊ตํ•˜๊ธฐ ์œ„ํ•ด ๋น„๊ต/๊ด€๊ณ„(comparison/relational) ์—ฐ์‚ฐ์ž(operator)๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž <= ๋Š”
์˜ค๋ฅธ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’์ด ์™ผ์ชฝ์˜ ๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’๋ณด๋‹ค ํฌ๊ฑฐ๋‚˜ ๊ฐ™์€ ๊ฒฝ์šฐ True(์ฐธ)๋กœ ๊ณ„์‚ฐํ•˜๊ณ ,
๊ทธ ์™ธ์˜ ๊ฒฝ์šฐ์—๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•œ๋‹ค.

<=, >= ์—ฐ์‚ฐ์ž๋Š” ๊ฐ™์Œ(==)์„ ํฌํ•จํ•œ๋‹ค. ๋”ฐ๋ผ์„œ “์ž‘๋‹ค/ํฌ๋‹ค” ๊ฑฐ๋‚˜ "๊ฐ™๋‹ค”๋Š” ์˜๋ฏธ๋ฅผ ๊ฐ€์ง„๋‹ค.
์ž‘๋‹ค(<)/ํฌ๋‹ค(>)/๋‹ค๋ฅด๋‹ค(!) ๊ธฐํ˜ธ๋Š” ๋“ฑํ˜ธ(=)์™€ ํ•จ๊ป˜ ์™ผ์ชฝ์— ๋ถ™์—ฌ์จ์•ผ ํ•œ๋‹ค.

๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋„ ์ผ๋ฐ˜์ ์ธ ์‚ฌ์น™์—ฐ์‚ฐ์ž์ฒ˜๋Ÿผ ์ฃผ์–ด์ง„ ๋‘ ์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐ์„ ์ˆ˜ํ–‰ํ•˜๊ณ ,
๊ทธ ๊ฒฐ๊ณผ๋ฅผ True(์ฐธ), ๋˜๋Š” False(๊ฑฐ์ง“)๋กœ ๊ณ„์‚ฐํ•ด์ฃผ๋Š” ์—ฐ์‚ฐ์ž์ด๋‹ค.
๋น„๊ต/๊ด€๊ณ„์—ฐ์‚ฐ์ž๋Š” <, >, <=, >=, ==(๊ฐ™๋‹ค), !=(๋‹ค๋ฅด๋‹ค) 6๊ฐœ๊ฐ€ ์žˆ๋‹ค.

 

โ–ท ํ•ด์„ค

์ˆ˜๊ฐ€ ์ž‘์€์ง€ ํฐ์ง€๋งŒ์„ ๊ตฌํ•˜๋Š”๊ฑฐ์—์„œ ๋‚˜์•„๊ฐ€ ์ž‘๊ฑฐ๋‚˜ ๊ฐ™์€์ง€, ์ž‘๊ฑฐ๋‚˜ ํฐ์ง€๋ฅผ ๊ตฌํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š” >=, <=์™€ ๊ฐ™์ด ๋Œ€์†Œ๊ตฌ๋ถ„ ๋’ค์— =์„ ๋ถ™์—ฌ์ค€๋‹ค.

๋น„๊ต ์—ฐ์‚ฐ์ž์ด๋ฏ€๋กœ ๊ฒฐ๊ณผ๊ฐ€ True์™€ False๊ฐ€ ๋‚˜์˜จ๋‹ค. 

a, b = input().split()

print(int(a) <= int(b))

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

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

 

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

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

 

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

 

codeup.kr

 

6041 : [๊ธฐ์ดˆ-์‚ฐ์ˆ ์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€ ๊ณ„์‚ฐํ•˜๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜ 2๊ฐœ(a, b) ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ a๋ฅผ b๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๋ฅผ ์ถœ๋ ฅํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

python ์–ธ์–ด์—์„œ๋Š” ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ์—ฐ์‚ฐ์ž(%, remainder)๋ฅผ ์ œ๊ณตํ•œ๋‹ค.
a%b ์™€ ๊ฐ™์ด ์ž‘์„ฑํ•˜๋ฉด, a๋ฅผ b๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€(remainder)๋ฅผ ๊ณ„์‚ฐํ•ด์ค€๋‹ค.
๋‚˜๋จธ์ง€ ์—ฐ์‚ฐ(modulus, mod ์—ฐ์‚ฐ)์€ ์ˆ˜ํ•™์ž ๊ฐ€์šฐ์Šค๊ฐ€ ์ƒ๊ฐํ•ด ๋‚ธ ์—ฐ์‚ฐ์œผ๋กœ,
์–ด๋–ค ์ˆ˜๋ฅผ ๋‹ค๋ฅธ ์ˆ˜๋กœ ๋‚˜๋ˆ„๊ณ  ๋‚œ ํ›„ ๋‚จ๋Š” ๋‚˜๋จธ์ง€๋ฅผ ๊ณ„์‚ฐํ•˜๋Š” ์—ฐ์‚ฐ์ด๋‹ค.

์‹ค์ˆ˜๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€๊ฐ€ ์–ด๋–ป๊ฒŒ ๊ณ„์‚ฐ๋ ์ง€๋„ ์ƒ๊ฐํ•ด๋ณด์ž.

 

 

โ–ท ํ•ด์„ค

์ฝ”๋“œ๋ฅผ ์งค๋•Œ ๋‚˜๋จธ์ง€๋ฅผ ๊ตฌํ•˜๋Š” %๋Š” ์ž์ฃผ ์‚ฌ์šฉ๋œ๋‹ค.

์ฃผ๋กœ ์‚ฌ์šฉ๋˜๋Š” ๋ฐฉ๋ฒ•์œผ๋กœ๋Š” ํ™€์ˆ˜๋Š” 2๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€ ๊ฐ’์ด 1 ์ด๋ฏ€๋กœ  n % 2 == 1 ์ง์ˆ˜๋Š” 2๋กœ ๋‚˜๋ˆˆ ๋‚˜๋จธ์ง€ ๊ฐ’์ด 0 ์ด๋ฏ€๋กœ n % 2 == 0์ด ๋œ๋‹ค. 

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

print(c)

 

6042 : [๊ธฐ์ดˆ-๊ฐ’๋ณ€ํ™˜] ์‹ค์ˆ˜ 1๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ์†Œ์ˆซ์ ์ดํ•˜ ์ž๋ฆฌ ๋ณ€ํ™˜ํ•˜๊ธฐ(์„ค๋ช…)(py)

์‹ค์ˆ˜ 1๊ฐœ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
์†Œ์ˆซ์  ์ดํ•˜ ๋‘ ๋ฒˆ์งธ ์ž๋ฆฌ๊นŒ์ง€์˜ ์ •ํ™•๋„๋กœ ๋ฐ˜์˜ฌ๋ฆผํ•œ ๊ฐ’์„ ์ถœ๋ ฅํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

format(์ˆ˜, ".2f") ๋ฅผ ์‚ฌ์šฉํ•˜๋ฉด ์›ํ•˜๋Š” ์ž๋ฆฌ๊นŒ์ง€์˜ ์ •ํ™•๋„๋กœ ๋ฐ˜์˜ฌ๋ฆผ ๋œ ์‹ค์ˆ˜ ๊ฐ’์„ ๋งŒ๋“ค์–ด ์ค€๋‹ค.

์—ฌ๊ธฐ์„œ ๋งŒ๋“ค์–ด์ง„ ๊ฐ’์€ ์†Œ์ˆ˜์  ์•„๋ž˜ 3๋ฒˆ์งธ ์ž๋ฆฌ์—์„œ ๋ฐ˜์˜ฌ๋ฆผํ•œ ๊ฐ’์ด๋‹ค.

์ปดํ“จํ„ฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‹ค์ˆ˜ ๋ณ€ํ™˜์ด๋‚˜ ์‹ค์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ณ„์‚ฐ์€
์ •ํ™•ํ•˜๊ฒŒ ๋ณ€ํ™˜๋˜๊ฑฐ๋‚˜ ๊ณ„์‚ฐ๋˜๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, ๊ฑฐ์˜ ๋ชจ๋‘ ๊ทผ์‚ฌ๊ฐ’์œผ๋กœ ๊ณ„์‚ฐ๋˜๋Š” ๊ฒƒ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ๋‹ค. 

์‹ค์ˆ˜๊ฐ€ ์ปดํ“จํ„ฐ๋กœ ์ €์žฅ๋˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋””์ง€ํ„ธ๋ฐฉ์‹์œผ๋กœ 2์ง„ ์ •์ˆ˜ํ™”๋˜์–ด ์ €์žฅ๋˜์–ด์•ผ ํ•˜๋Š”๋ฐ,
๊ทธ ๊ณผ์ •์—์„œ ์•„์ฃผ ์ž‘์€ ๋ถ€๋ถ„์ด ์ €์žฅ๋˜์ง€ ์•Š๊ณ  ์‚ฌ๋ผ์ง€๋Š” ์ž˜๋ฆผ(truncation) ์˜ค์ฐจ๊ฐ€ ์ž์ฃผ ๋ฐœ์ƒํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

 

โ–ท ํ•ด์„ค

ํฌ๋งทํŒ… ๋ฐฉ๋ฒ•์œผ๋กœ ์‹ค์ˆ˜์˜ ํ‘œํ˜„๋ฐฉ์‹์„ ์ •ํ•  ์ˆ˜ ์žˆ๋‹ค.

์‹ค์ˆ˜์˜ ํฌ๋งทํŒ…์€ format(0.222222, ".4f") ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ด์šฉํ•˜๋ฉด ์†Œ์ˆ˜์  ์•„๋ž˜ 5์ž๋ฆฌ์—์„œ ๋ฐ˜์˜ฌ๋ฆผํ•œ ๊ฐ’์ธ ์†Œ์ˆ˜์  4์ž๋ฆฌ ๊นŒ์ง€์˜ ๊ฒฐ๊ณผ์ธ 0.2222๊ฐ€ ๋‚˜์˜จ๋‹ค.

 

python 3๋ถ€ํ„ฐ๋Š” format์˜ ๊ฒฝ์šฐ str์—์„œ ์ž์ฃผ ์‚ฌ์šฉ๋œ๋‹ค. str.format(๋ฌธ์ž์—ด ์ค‘๊ฐ„์— ๋“ค์–ด๊ฐˆ ๋ฌธ์ž,...)

"Python {} Hello {} ".format(3, "World")

๋‹ค์Œ๊ณผ ๊ฐ™์ด ๋ฌธ์ž์—ด์˜ ์ค‘๊ด„ํ˜ธ({})๋ถ€๋ถ„์— formatํ•จ์ˆ˜์— ๋„ฃ์€ ๊ฐ’์ด ์ฐจ๋ก€๋Œ€๋กœ ๋“ค์–ด๊ฐ„๋‹ค.

์‰ผํ‘œ(,)๋กœ ๋“ค์–ด๊ฐˆ ๋ฌธ์ž๋ฅผ ๊ตฌ๋ถ„ํ•˜๋ฉฐ ์ˆซ์ž์˜ ๊ฒฝ์šฐ ๋”ฐ์˜ดํ‘œ(")๋ฅผ ์ƒ๋žตํ•ด๋„ ๋˜์ง€๋งŒ ๋ฌธ์ž๋Š” ๋ฐ˜๋“œ์‹œ ๋”ฐ์˜ดํ‘œ๋กœ ๊ตฌ๋ถ„ํ•ด์•ผํ•œ๋‹ค. 

f = float(input())
print(format(f,".2f"))

 

6043 : [๊ธฐ์ดˆ-์‚ฐ์ˆ ์—ฐ์‚ฐ] ์‹ค์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ๋‚˜๋ˆˆ ๊ฒฐ๊ณผ ๊ณ„์‚ฐํ•˜๊ธฐ(py)

์‹ค์ˆ˜ 2๊ฐœ(f1, f2)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„
f1 ์„ f2 ๋กœ ๋‚˜๋ˆˆ ๊ฐ’์„ ์ถœ๋ ฅํ•ด๋ณด์ž. ์ด ๋•Œ ์†Œ์ˆซ์  ๋„ท์งธ์ž๋ฆฌ์—์„œ ๋ฐ˜์˜ฌ๋ฆผํ•˜์—ฌ ๋ฌด์กฐ๊ฑด ์†Œ์ˆซ์  ์…‹์งธ ์ž๋ฆฌ๊นŒ์ง€ ์ถœ๋ ฅํ•œ๋‹ค.

 

โ–ท ์ฐธ๊ณ 

python ์–ธ์–ด์—๋Š” ๋‚˜๋ˆ—์…ˆ(division)์„ ๊ณ„์‚ฐํ•˜๋Š” ์—ฐ์‚ฐ์ž(/)๊ฐ€ ์žˆ๋‹ค.

์ปดํ“จํ„ฐ ํ”„๋กœ๊ทธ๋ž˜๋ฐ์—์„œ ์‹ค์ˆ˜ ๋ณ€ํ™˜์ด๋‚˜ ์‹ค์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜๋Š” ๊ณ„์‚ฐ์€ 
์ •ํ™•ํ•˜๊ฒŒ ๋ณ€ํ™˜๋˜๊ฑฐ๋‚˜ ๊ณ„์‚ฐ๋˜๋Š” ๊ฒƒ์ด ์•„๋‹ˆ๋ผ, ๊ฑฐ์˜ ๋ชจ๋‘ ๊ทผ์‚ฌ๊ฐ’์œผ๋กœ ๊ณ„์‚ฐ๋˜๋Š” ๊ฒƒ์ด๋ผ๊ณ  ํ•  ์ˆ˜ ์žˆ๋‹ค.  

์‹ค์ˆ˜๊ฐ€ ์ปดํ“จํ„ฐ๋กœ ์ €์žฅ๋˜๊ธฐ ์œ„ํ•ด์„œ๋Š” ๋””์ง€ํ„ธ๋ฐฉ์‹์œผ๋กœ 2์ง„ ์ •์ˆ˜ํ™”๋˜์–ด ์ €์žฅ๋˜์–ด์•ผ ํ•˜๋Š”๋ฐ, 
๊ทธ ๊ณผ์ •์—์„œ ์•„์ฃผ ์ž‘์€ ๋ถ€๋ถ„์ด ์ €์žฅ๋˜์ง€ ์•Š๊ณ  ์‚ฌ๋ผ์ง€๋Š” ์ž˜๋ฆผ(truncation) ์˜ค์ฐจ๊ฐ€ ์ž์ฃผ ๋ฐœ์ƒํ•˜๊ธฐ ๋•Œ๋ฌธ์ด๋‹ค.

๊ณ„์‚ฐ ๊ฒฐ๊ณผ๊ฐ’ ์ค‘์—์„œ ๋ฏฟ์„ ์ˆ˜ ์žˆ๋Š” ์ˆซ์ž์˜ ๊ฐœ์ˆ˜๋ฅผ ์˜๋ฏธํ•˜๋Š”, ์œ ํšจ์ˆซ์ž์— ๋Œ€ํ•ด ์ฐพ์•„๋ณด์ž. 
๊ณผํ•™์‹คํ—˜์—์„œ ์˜จ๋„๋‚˜ ๋ถ€ํ”ผ๋ฅผ ์ธก์ •ํ•  ๋•Œ์—๋„ ์œ ํšจ์ˆซ์ž๋Š” ์ค‘์š”ํ•˜๋‹ค. 

 

โ–ท ํ•ด์„ค

์ด๋ฒˆ ๋ฌธ์ œ์—์„œ๋Š” ์•ž์—์„œ ๋ฐฐ์› ๋˜ ๋‘ ์ˆ˜์˜ ์—ฐ์‚ฐ๊ณผ ์‹ค์ˆ˜์˜ ํฌ๋งทํŒ…์— ๋Œ€ํ•ด์„œ ๋‹ค๋ฃจ๊ณ  ์žˆ๋‹ค.

๋ฌธ์ œ๋ฅผ ํ’€๊ธฐ ์œ„ํ•ด ์ž…๋ ฅ๋ฐ›์€ ๊ฐ’์„ floatํ˜•์œผ๋กœ ๋ฐ”๊พธ๋Š” ํ˜•๋ณ€ํ™˜์„ ํ•œ๋’ค ๋‘ ์‹ค์ˆ˜๋ฅผ ๋‚˜๋ˆ  ์ค€๋‹ค ์ดํ›„ format์„ ํ†ตํ•ด ์†Œ์ˆ˜์  ์•„๋ž˜ 3์ž๋ฆฌ๋งŒ ์ถœ๋ ฅํ•˜๋ฉด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์žˆ๋‹ค.

f1, f2 = input().split()
result = float(f1) / float(f2)

print(format(result, '.3f'))

 

6044 : [๊ธฐ์ดˆ-์‚ฐ์ˆ ์—ฐ์‚ฐ] ์ •์ˆ˜ 2๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ์ž๋™ ๊ณ„์‚ฐํ•˜๊ธฐ(py)

์ •์ˆ˜ 2๊ฐœ(a, b)๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ ํ•ฉ, ์ฐจ, ๊ณฑ, ๋ชซ, ๋‚˜๋จธ์ง€, ๋‚˜๋ˆˆ ๊ฐ’์„ ์ž๋™์œผ๋กœ ๊ณ„์‚ฐํ•ด๋ณด์ž.
๋‹จ 0 <= a, b <= 2147483647, b๋Š” 0์ด ์•„๋‹ˆ๋‹ค.

 

โ–ท ํ•ด์„ค

python์—์„œ ์“ธ ์ˆ˜ ์žˆ๋Š” ์‚ฐ์ˆ ์—ฐ์‚ฐ์— ๋Œ€ํ•ด์„œ ๋ชจ๋‘ ๊ตฌํ•˜๋ฉด ๋œ๋‹ค.

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

a, b = input().split()

a = int(a)
b = int(b)

add = a + b # ํ•ฉ Add
sub = a - b # ์ฐจ Subtract
mul = a * b # ๊ณฑ Multiply
q = a // b  # ๋ชซ Quotient
mod = a % b # ๋‚˜๋จธ์ง€ Modulo
div = a / b # ๋‚˜๋ˆ—์…ˆ Divide

print(add)
print(sub)
print(mul)
print(q)
print(mod)
print(format(div,".2f"))

 

6045 : [๊ธฐ์ดˆ-์‚ฐ์ˆ ์—ฐ์‚ฐ] ์ •์ˆ˜ 3๊ฐœ ์ž…๋ ฅ๋ฐ›์•„ ํ•ฉ๊ณผ ํ‰๊ท  ์ถœ๋ ฅํ•˜๊ธฐ(์„ค๋ช…)(py)

์ •์ˆ˜ 3๊ฐœ๋ฅผ ์ž…๋ ฅ๋ฐ›์•„ ํ•ฉ๊ณผ ํ‰๊ท ์„ ์ถœ๋ ฅํ•ด๋ณด์ž.

 

โ–ท ์ฐธ๊ณ 

๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„๋œ ํ•œ ์ค„๋กœ ๊ฐ’๋“ค์„ ์ž…๋ ฅ๋ฐ›๊ธฐ ์œ„ํ•ด์„œ๋Š”
a, b, c = input().split()
๊ณผ ๊ฐ™์€ ๋ฐฉ๋ฒ•์ด ๊ฐ€๋Šฅํ•˜๊ณ ,

๊ณต๋ฐฑ์œผ๋กœ ๊ตฌ๋ถ„ํ•ด ๋‘ ๊ฐ’์„ ์ถœ๋ ฅํ•˜๊ธฐ ์œ„ํ•ด์„œ๋Š”
print(d, e)
์™€ ๊ฐ™์€ ๋ฐฉ๋ฒ•์ด ๊ฐ€๋Šฅํ•˜๋‹ค.

์ž˜๋ผ๋‚ธ ๊ฐ’๋“ค์€ ๊ทธ ๊ฐ’์˜ ํŠน์„ฑ(์ •์ˆ˜, ์‹ค์ˆ˜, ๋ฌธ์ž, ๋ฌธ์ž์—ด ...)์— ๋”ฐ๋ผ ๋ช…ํ™•ํ•˜๊ฒŒ ๋ณ€ํ™˜์‹œํ‚จ ํ›„ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹๋‹ค.

python ํ”„๋กœ๊ทธ๋ž˜๋ฐ์„ ์ฒ˜์Œ ๋ฐฐ์šธ ๋•Œ ์ข‹์€ ์Šต๊ด€(๋‹จ๊ณ„)
1. ์ž…๋ ฅ๋œ ๋ฌธ์ž์—ด์„ ์ •ํ™•ํ•˜๊ฒŒ ์ž˜๋ผ๋‚ธ๋‹ค.(๊ณต๋ฐฑ, ์ค„๋ฐ”๊ฟˆ, ๊ตฌ๋ถ„๋ฌธ์ž ๋“ฑ์— ๋”ฐ๋ผ ์ •ํ™•ํ•˜๊ฒŒ ์ž˜๋ผ๋‚ธ๋‹ค.)
2. ์ž˜๋ผ๋‚ธ ๋ฐ์ดํ„ฐ๋“ค์„ ๋ฐ์ดํ„ฐํ˜•์— ๋งž๊ฒŒ ๋ณ€ํ™˜ํ•ด ๋ณ€์ˆ˜์— ์ €์žฅํ•œ๋‹ค. (์ •์ˆ˜, ์‹ค์ˆ˜, ๋ฌธ์ž, ๋ฌธ์ž์—ด ๋“ฑ์— ๋”ฐ๋ผ ์ •ํ™•ํ•˜๊ฒŒ ๋ณ€ํ™˜ํ•œ๋‹ค.)
3. ๊ฐ’์„ ์ €์žฅํ–ˆ๋‹ค๊ฐ€ ๋‹ค์‹œ ์‚ฌ์šฉํ•˜๊ธฐ ์œ„ํ•ด, ๋ณ€์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ฐ’์„ ์ €์žฅํ•˜๊ณ , ๋ณ€์ˆ˜๋ฅผ ์ด์šฉํ•ด ๊ณ„์‚ฐ์„ ํ•œ๋‹ค.
4. ์›ํ•˜๋Š” ๊ฒฐ๊ณผ ๊ฐ’์„ ํ•„์š”ํ•œ ํ˜•ํƒœ๋กœ ๋งŒ๋“ค์–ด ์ถœ๋ ฅํ•œ๋‹ค.(๊ณต๋ฐฑ, ์ค„๋ฐ”๊ฟˆ, ๊ตฌ๋ถ„์ž, ๋“ฑ์— ๋”ฐ๋ผ ์›ํ•˜๋Š” ํ˜•ํƒœ๋กœ ๋งŒ๋“ค์–ด ์ถœ๋ ฅํ•œ๋‹ค.)

 

โ–ท ํ•ด์„ค

๊ฐ’์„ ๋ชจ๋‘ ๋”ํ•œ ๋’ค ์ž…๋ ฅ ๋ฐ›๋Š” ๋ณ€์ˆ˜์˜ ๊ฐฏ์ˆ˜์ธ 3์œผ๋กœ ๋‚˜๋ˆ ์ฃผ๋ฉด ํ‰๊ท ์„ ์–ป์„ ์ˆ˜ ์žˆ๋‹ค.

๋‹จ, ์ „์˜ ๋ฌธ์ œ์™€ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์ถœ๋ ฅ์กฐ๊ฑด์ด ๋ถ™์–ด์žˆ๋Š”๊ฑธ ํ™•์ธํ•  ์ˆ˜ ์žˆ๋‹ค. ๊ทธ๋ž˜์„œ ํ‰๊ท ์„ ๊ตฌํ• ๋•Œ ํฌ๋งทํŒ…์„ ํ†ตํ•ด ์†Œ์ˆ˜์  ๋‘๋ฒˆ์งธ ์ž๋ฆฌ๊นŒ์ง€ ์ถœ๋ ฅํ•ด์•ผํ•œ๋‹ค.

 

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋ฅผ ํ’€๋•Œ ์ฝ๊ณ  ๋ฐ”๋กœ ํ‘ธ๋Š”๊ฒƒ ๋ณด๋‹ค๋Š” ๋ฌธ์ œ์˜ ์•„๋ž˜์— ์ ํ˜€์žˆ๋Š” ์ž…๋ ฅํ˜•์‹๊ณผ ์ถœ๋ ฅํ˜•์‹์„ ๋ฐ˜๋“œ์‹œ ํ™•์ธํ•˜๊ณ  ์ฝ”๋“œ๋ฅผ ์งœ๋Š” ์Šต๊ด€์„ ๋“ค์—ฌ์•ผ ๋ฌธ์ œ๊ฐ€ ํ‹€๋ฆฌ๋Š” ๊ฒฝ์šฐ๋ฅผ ์ค„์ผ ์ˆ˜ ์žˆ๋‹ค.

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

sum = int(a) + int(b) + int(c)

print(sum, format(sum/3,'.2f'))

 

+ Recent posts