6046๋ฒ : [๊ธฐ์ด-๋นํธ์ํํธ์ฐ์ฐ] ์ ์ 1๊ฐ ์ ๋ ฅ๋ฐ์ 2๋ฐฐ ๊ณฑํด ์ถ๋ ฅํ๊ธฐ
์ ์ 1๊ฐ๋ฅผ ์ ๋ ฅ๋ฐ์ 2๋ฐฐ ๊ณฑํด ์ถ๋ ฅํด๋ณด์.
*2 ๋ฅผ ๊ณ์ฐํ ๊ฐ์ ์ถ๋ ฅํด๋ ๋์ง๋ง,
์ ์๋ฅผ 2๋ฐฐ๋ก ๊ณฑํ๊ฑฐ๋ ๋๋์ด ๊ณ์ฐํด ์ฃผ๋ ๋นํธ๋จ์์ํํธ์ฐ์ฐ์ <<, >>๋ฅผ ์ด์ฉํ ์ ์๋ค.
์ปดํจํฐ ๋ด๋ถ์๋ 2์ง์ ํํ๋ก ๊ฐ๋ค์ด ์ ์ฅ๋๊ธฐ ๋๋ฌธ์,
2์ง์ ํํ๋ก ์ ์ฅ๋์ด ์๋ ๊ฐ๋ค์ ์ผ์ชฝ(<<)์ด๋ ์ค๋ฅธ์ชฝ(>>)์ผ๋ก
์ง์ ํ ๋นํธ ์๋งํผ ๋ฐ์ด์ฃผ๋ฉด 2๋ฐฐ์ฉ ๋์ด๋๊ฑฐ๋ 1/2๋ก ์ค์ด๋๋๋ฐ,
์ผ์ชฝ ๋นํธ์ํํธ(<<)๊ฐ ๋ ๋์๋ ์ค๋ฅธ์ชฝ์ 0์ด ์ฃผ์ด์ง ๊ฐ์๋งํผ ์ถ๊ฐ๋๊ณ ,
์ค๋ฅธ์ชฝ ๋นํธ์ํํธ(>>)๊ฐ ๋ ๋์๋ ์ผ์ชฝ์ 0(0 ๋๋ ์์ ์ ์์ธ ๊ฒฝ์ฐ)์ด๋ 1(์์ ์ ์์ธ ๊ฒฝ์ฐ)์ด ๊ฐ์๋งํผ ์ถ๊ฐ๋๊ณ ,
๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ 1๋นํธ๋ ์ฌ๋ผ์ง๋ค.
- 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์ด๋ค.
- ์ ์ 10์ 2์ง์ ํํ์ ... 1010 ์ด๋ค.
** python์์ ์ค์ ๊ฐ์ ๋ํ ๋นํธ์ํํธ ์ฐ์ฐ์ ํ์ฉ๋์ง ์๊ณ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค. (์ค์ ๊ฐ๋ ์ปดํจํฐ ๋ด๋ถ์ ์ผ๋ก๋ 2์ง์ ํํ๋ก ์ ์ฅ๋๊ณ ๋นํธ์ํํธ ์ฒ๋ฆฌ๊ฐ ๋ ์ ์์ง๋ง, python ์์๋ ํ์ฉํ์ง ์๋๋ค.)
print(int(input()) << 1)
6047๋ฒ : [๊ธฐ์ด-๋นํธ์ํํธ์ฐ์ฐ] 2์ ๊ฑฐ๋ญ์ ๊ณฑ ๋ฐฐ๋ก ๊ณฑํด ์ถ๋ ฅํ๊ธฐ
์ ์ 2๊ฐ(a, b)๋ฅผ ์
๋ ฅ๋ฐ์ a๋ฅผ 2^b๋ฐฐ ๊ณฑํ ๊ฐ์ผ๋ก ์ถ๋ ฅํด๋ณด์.
0 <= a <= 10, 0 <= b <= 10
a, b = map(int, input().split())
print(a << b)
6048๋ฒ : [๊ธฐ์ด-๋น๊ต์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ๋น๊ตํ๊ธฐ1
๋ ์ ์(a, b)๋ฅผ ์
๋ ฅ๋ฐ์
a๊ฐ b๋ณด๋ค ์์ผ๋ฉด True ๋ฅผ, a๊ฐ b๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด False ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(a < b)
# ์ด๋ค ๊ฐ์ ๋น๊ตํ๊ธฐ ์ํด ๋น๊ต/๊ด๊ณ(comparison/relational) ์ฐ์ฐ์(operator)๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
# print(123 < 456) #๋น๊ต ์ฐ์ฐ์ < ์ ๊ณ์ฐ ๊ฒฐ๊ณผ์ธ True(์ฐธ)๊ฐ ์ถ๋ ฅ๋๋ค.
6049๋ฒ : [๊ธฐ์ด-๋น๊ต์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ๋น๊ตํ๊ธฐ2
๋ ์ ์(a, b)๋ฅผ ์
๋ ฅ๋ฐ์
a์ b์ ๊ฐ์ด ๊ฐ์ผ๋ฉด True ๋ฅผ, ๊ฐ์ง ์์ผ๋ฉด False ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(a == b)
6050๋ฒ : [๊ธฐ์ด-๋น๊ต์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ๋น๊ตํ๊ธฐ3
๋ ์ ์(a, b)๋ฅผ ์
๋ ฅ๋ฐ์
b์ ๊ฐ์ด a์ ๊ฐ ๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด True ๋ฅผ, ๊ฐ์ง ์์ผ๋ฉด False ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(a <= b)
6051๋ฒ : [๊ธฐ์ด-๋น๊ต์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ๋น๊ตํ๊ธฐ4
๋ ์ ์(a, b)๋ฅผ ์
๋ ฅ๋ฐ์
a์ ๊ฐ์ด b์ ๊ฐ๊ณผ ์๋ก ๋ค๋ฅด๋ฉด True ๋ฅผ, ๊ฐ์ผ๋ฉด False ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(a != b)
6052๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ์ ์ ์ ๋ ฅ๋ฐ์ ์ฐธ ๊ฑฐ์ง ํ๊ฐํ๊ธฐ
์ ์๊ฐ ์ ๋ ฅ๋์์ ๋, True/False ๋ก ํ๊ฐํด์ฃผ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
print(bool(int(input())))
# bool( ) ์ ์ด์ฉํ๋ฉด ์
๋ ฅ๋ ์์ด๋ ๊ฐ์ ํ๊ฐํด ๋ถ ํ์ ๊ฐ(True ๋๋ False)์ ์ถ๋ ฅํด์ค๋ค.
# ์์ด๋ ๊ฐ์ ๊ณ์ฐํด์ ๊ฒฐ๊ณผ๊ฐ์ด ๋ง๋ค์ด์ง๋ ๊ฒ์ ํ๊ฐ(evaluate)๋ผ๊ณ ํ๋ค.
# python ์ธ์ด์์ ์ ์๊ฐ 0์ False(๊ฑฐ์ง)๋ก ํ๊ฐ๋๊ณ , ๊ทธ ์ธ์ ๊ฐ๋ค์ ๋ชจ๋ True(์ฐธ)๋ก ํ๊ฐ๋๋ค.
6053๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ์ฐธ ๊ฑฐ์ง ๋ฐ๊พธ๊ธฐ
์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ์ ๋ฐ๋๋ก ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
print(not bool(int(input())))
# ์ฐธ ๋๋ ๊ฑฐ์ง์ ๋
ผ๋ฆฌ๊ฐ์ ์ญ(๋ฐ๋)์ผ๋ก ๋ฐ๊พธ๊ธฐ ์ํด์ not ์์ฝ์ด(reserved word, keyword)๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
6054๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ๋ ๋ค ์ฐธ์ผ ๊ฒฝ์ฐ๋ง ์ฐธ ์ถ๋ ฅํ๊ธฐ
2๊ฐ์ ์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ์ด ๋ชจ๋ True ์ผ ๋์๋ง True ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(bool(a) and bool(b))
# and ์์ฝ์ด๋ ์ฃผ์ด์ง ๋ ๋ถ ๊ฐ์ด ๋ชจ๋ True ์ผ ๋์๋ง True ๋ก ๊ณ์ฐํ๊ณ , ๋๋จธ์ง ๊ฒฝ์ฐ๋ False ๋ก ๊ณ์ฐํ๋ค.
6055๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ํ๋๋ผ๋ ์ฐธ์ด๋ฉด ์ฐธ ์ถ๋ ฅํ๊ธฐ
2๊ฐ์ ์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ์ด ํ๋๋ผ๋ True ์ผ ๋์๋ง True ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(bool(a) or bool(b))
# or ์์ฝ์ด๋ ์ฃผ์ด์ง ๋ ๋ถ ๊ฐ ์ค์์ ํ๋๋ผ๋ True ์ด๋ฉด True ๋ก ๊ณ์ฐํ๊ณ , ๋๋จธ์ง ๊ฒฝ์ฐ๋ False ๋ก ๊ณ์ฐํ๋ค.
6056๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ์ฐธ/๊ฑฐ์ง์ด ์๋ก ๋ค๋ฅผ ๋์๋ง ์ฐธ ์ถ๋ ฅํ๊ธฐ
2๊ฐ์ ์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ(True/False) ์ด ์๋ก ๋ค๋ฅผ ๋์๋ง True ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print((bool(a) and not bool(b)) or (not bool(a) and bool(b)))
# ์ฐธ ๊ฑฐ์ง์ด ์๋ก ๋ค๋ฅผ ๋์๋ง True ๋ก ๊ณ์ฐํ๋ ๋
ผ๋ฆฌ์ฐ์ฐ์ XOR(exclusive or, ๋ฐฐํ์ ๋
ผ๋ฆฌํฉ) ์ฐ์ฐ์ด๋ผ๊ณ ๋ ๋ถ๋ฅธ๋ค.
6057๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ์ฐธ/๊ฑฐ์ง์ด ์๋ก ๊ฐ์ ๋์๋ง ์ฐธ ์ถ๋ ฅํ๊ธฐ
2๊ฐ์ ์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ(True/False) ์ด ์๋ก ๊ฐ์ ๋์๋ง True ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print((bool(a) and bool(b)) or (not bool(a) and not bool(b)))
6058๋ฒ : [๊ธฐ์ด-๋ ผ๋ฆฌ์ฐ์ฐ] ๋ ๋ค ๊ฑฐ์ง์ผ ๊ฒฝ์ฐ๋ง ์ฐธ ์ถ๋ ฅํ๊ธฐ
2๊ฐ์ ์ ์๊ฐ์ด ์ ๋ ฅ๋ ๋, ๊ทธ ๋ถ ๊ฐ(True/False) ์ด ๋ชจ๋ False ์ผ ๋์๋ง True ๋ฅผ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์.
a, b = map(int, input().split())
print(not(bool(a) or bool(b)))
6059๋ฒ : [๊ธฐ์ด-๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ] ๋นํธ๋จ์๋ก NOT ํ์ฌ ์ถ๋ ฅํ๊ธฐ
์
๋ ฅ ๋ ์ ์๋ฅผ ๋นํธ๋จ์๋ก ์ฐธ/๊ฑฐ์ง์ ๋ฐ๊พผ ํ ์ ์๋ก ์ถ๋ ฅํด๋ณด์.
๋นํธ๋จ์(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 ๊ณผ ๊ฐ์ ๊ด๊ณ๋ก ํํํ ์ ์๋ค.
print(~int(input()))
6060๋ฒ : [๊ธฐ์ด-๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ] ๋นํธ๋จ์๋ก AND ํ์ฌ ์ถ๋ ฅํ๊ธฐ
์
๋ ฅ๋ ์ ์ ๋ ๊ฐ๋ฅผ ๋นํธ๋จ์๋ก and ์ฐ์ฐํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ์ถ๋ ฅํด๋ณด์.
๋นํธ๋จ์(bitwise)์ฐ์ฐ์ &๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.(and, ampersand, ์ฐํผ์ผ๋๋ผ๊ณ ์ฝ๋๋ค.)
- ์๋ฅผ ๋ค์ด 3๊ณผ 5๊ฐ ์
๋ ฅ๋์์ ๋๋ฅผ ์ดํด๋ณด๋ฉด
3 : 00000000 00000000 00000000 00000011
5 : 00000000 00000000 00000000 00000101
3 & 5 : 00000000 00000000 00000000 00000001 - ๋นํธ๋จ์ and ์ฐ์ฐ์ ๋ ๋นํธ์ด์ด ์ฃผ์ด์ก์ ๋, ๋ ๋ค 1์ธ ๋ถ๋ถ์ ์๋ฆฌ๋ง 1๋ก ๋ง๋ค์ด์ฃผ๋ ๊ฒ๊ณผ ๊ฐ๋ค.
a, b = map(int, input().split())
print(a & b)
6061๋ฒ : [๊ธฐ์ด-๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ] ๋นํธ๋จ์๋ก OR ํ์ฌ ์ถ๋ ฅํ๊ธฐ
์
๋ ฅ๋ ์ ์ ๋ ๊ฐ๋ฅผ ๋นํธ๋จ์๋ก or ์ฐ์ฐํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ์ถ๋ ฅํด๋ณด์.
๋นํธ๋จ์(bitwise) ์ฐ์ฐ์ |(or, vertical bar, ๋ฒํฐ์ปฌ๋ฐ)๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
** | ์ ํ์ดํ(pipe)์ฐ์ฐ์๋ผ๊ณ ๋ ๋ถ๋ฆฌ๋ ๊ฒฝ์ฐ๊ฐ ์๋ค.
- ์๋ฅผ ๋ค์ด 3๊ณผ 5๊ฐ ์
๋ ฅ๋์์ ๋๋ฅผ ์ดํด๋ณด๋ฉด
3 : 00000000 00000000 00000000 00000011
5 : 00000000 00000000 00000000 00000101
3 | 5 : 00000000 00000000 00000000 00000111 - ๋นํธ๋จ์ or ์ฐ์ฐ์ ๋ ์ค ํ๋๋ผ๋ 1์ธ ์๋ฆฌ๋ฅผ 1๋ก ๋ง๋ค์ด์ฃผ๋ ๊ฒ๊ณผ ๊ฐ๋ค.
a, b = map(int, input().split())
print(a | b)
6062๋ฒ : [๊ธฐ์ด-๋นํธ๋จ์๋ ผ๋ฆฌ์ฐ์ฐ] ๋นํธ๋จ์๋ก XOR ํ์ฌ ์ถ๋ ฅํ๊ธฐ
์
๋ ฅ๋ ์ ์ ๋ ๊ฐ๋ฅผ ๋นํธ๋จ์๋ก xor ์ฐ์ฐํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ ์๋ก ์ถ๋ ฅํด๋ณด์.
๋นํธ๋จ์(bitwise) ์ฐ์ฐ์ ^(xor, circumflex/caret, ์์ปดํ๋ ์ค/์นด๋ฆฟ)๋ฅผ ์ฌ์ฉํ๋ฉด ๋๋ค.
- (์ฃผ์) ^์ ์ํ์์์ ๊ฑฐ๋ญ์ ๊ณฑ(power)์ ๋ํ๋ด๋ ๊ธฐํธ์ ๋ชจ์์ ๊ฐ์ง๋ง, ์ธ์ด์์๋ ์ ํ ๋ค๋ฅธ ๋ฐฐํ์ ๋ ผ๋ฆฌํฉ(xor, ์๋ก ๋ค๋ฅผ ๋ 1)์ ์๋ฏธ๋ฅผ ๊ฐ์ง๋ค.
- ์๋ฅผ ๋ค์ด 3๊ณผ 5๊ฐ ์
๋ ฅ๋์์ ๋๋ฅผ ์ดํด๋ณด๋ฉด
3 : 00000000 00000000 00000000 00000011
5 : 00000000 00000000 00000000 00000101
3 ^ 5 : 00000000 00000000 00000000 00000110
a, b = map(int, input().split())
print(a ^ b)
6063๋ฒ : [๊ธฐ์ด-3ํญ์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ํฐ ๊ฐ ์ถ๋ ฅํ๊ธฐ
์ ๋ ฅ๋ ๋ ์ ์(a, b) ์ค ํฐ ๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์. ๋จ, 3ํญ ์ฐ์ฐ์ ์ฌ์ฉํ๋ค.
- 3๊ฐ์ ์์๋ก ์ด๋ฃจ์ด์ง๋ 3ํญ ์ฐ์ฐ์ "x if C else y" ์ ํํ๋ก ์์ฑ์ด ๋๋ค.
- C : True ๋๋ False ๋ฅผ ํ๊ฐํ ์กฐ๊ฑด์(conditional expression) ๋๋ ๊ฐ
- x : C์ ํ๊ฐ ๊ฒฐ๊ณผ๊ฐ True ์ผ ๋ ์ฌ์ฉํ ๊ฐ
- y : C์ ํ๊ฐ ๊ฒฐ๊ณผ๊ฐ True ๊ฐ ์๋ ๋ ์ฌ์ฉํ ๊ฐ
a, b = map(int, input().split())
print(a if(a>=b) else b)
6064๋ฒ : [๊ธฐ์ด-3ํญ์ฐ์ฐ] ์ ์ 2๊ฐ ์ ๋ ฅ๋ฐ์ ๊ฐ์ฅ ์์ ๊ฐ ์ถ๋ ฅํ๊ธฐ
์ ๋ ฅ๋ ๋ ์ ์(a, b) ์ค ๊ฐ์ฅ ์์ ๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ณด์. ๋จ, 3ํญ ์ฐ์ฐ์ ์ฌ์ฉํ๋ค.
3ํญ ์ฐ์ฐ์ ์์ฃผ ์ฌ์ฉ๋์ง๋ ์์ง๋ง, ๋ณต์กํ ๊ณ์ฐ์์ด๋ ์กฐ๊ฑด ์ฒ๋ฆฌ, ๋น๊ต ๊ตฌ์กฐ๋ฅผ ๊ฐ๋จํ ํํํ ์ ์๊ฒ ํด์ค๋ค.
a, b, c = map(int, input().split())
min = (a if a<b else b) if ((a if a<b else b)<c) else c
print(min)