์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ์ํด ์ฝ๋์ ์ฌ์ดํธ(https://codeup.kr/)์ ๊ธฐ์ด 100์ ๋ฅผ ์์ํฉ๋๋ค.
๋ธ๋ก๊ทธ์ ์ฌ๋ผ์จ ๋ชจ๋ ์ฝ๋๋ ํ์ด์ฌ(Python)์ผ๋ก ์์ฑ๋์ด ์์ต๋๋ค.
Python์ ๊ธฐ์ด 100์ ๋ฅผ ํ์ธํ๊ธฐ ์ํด์๋ ๋ค์ ์ฌ์ดํธ๋ก ์ด๋ํ๋ฉด ๋ฉ๋๋ค.
https://codeup.kr/problemsetsol.php?psid=33
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))
'๊ณต๋ถ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ฝ๋์ ํ์ด์ฌ(Python) ๊ธฐ์ด 100์ - 6066๋ฒ ~ 6070๋ฒ (0) | 2021.06.18 |
---|---|
์ฝ๋์ ํ์ด์ฌ(Python) ๊ธฐ์ด 100์ - 6061๋ฒ ~ 6065๋ฒ (0) | 2021.06.18 |
์ฝ๋์ ํ์ด์ฌ(Python) ๊ธฐ์ด 100์ - 6051๋ฒ ~ 6055๋ฒ (0) | 2021.06.18 |
์ฝ๋์ ํ์ด์ฌ(Python) ๊ธฐ์ด 100์ - 6046๋ฒ ~ 6050๋ฒ (0) | 2021.06.18 |
์ฝ๋์ ํ์ด์ฌ(Python) ๊ธฐ์ด 100์ - 6041๋ฒ ~ 6045๋ฒ (0) | 2021.06.17 |