๋นํธ๋ง์คํน
์ปดํจํฐ๋ ๋ด๋ถ์ ์ผ๋ก ๋ชจ๋ ์๋ฃ๋ฅผ ์ด์ง์๋ก ํํํ๋ค. ์ด๋ฐ ํน์ฑ์ ์ด์ฉํด ์ ์์ ์ด์ง์ํํ์ ์๋ฃ๊ตฌ์กฐ๋ก ์ฐ๋ ๊ธฐ๋ฒ
๋นํธ๋ง์คํฌ๋ฅผ ์ด์ฉํ๋ฉด ๋ ๋น ๋ฅธ ์ํ์๊ฐ, ๋ ๊ฐ๊ฒฐํ ์ฝ๋, ๋ ์ ์ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ค.
๋นํธ ์ฐ์ฐ์
๋นํธ๋ง์คํน์ ๊ธฐ๋ณธ์ ์ผ๋ก ๋นํธ๋ฅผ ๋ค๋ค์ผ ํ๋ฏ๋ก, ๋นํธ ์ฐ์ฐ์์ ๋ํด์ ๋จผ์ ์์๋ณด์.
a & b | a์ ๋ชจ๋ ๋นํธ์ b์ ๋ชจ๋ ๋นํธ๋ฅผ AND ์ฐ์ฐํ๋ค. ๋๋ค 1์ด๋ผ๋ฉด 1, ์๋๋ฉด 0 |
ex) 100 & 111 = 100 |
a | b | a์ ๋ชจ๋ ๋นํธ์ b์ ๋ชจ๋ ๋นํธ๋ฅผ OR ์ฐ์ฐํ๋ค. ๋๋ค 0์ด๋ผ๋ฉด 0, ์๋๋ฉด 1 |
ex) 010 | 111 = 111 |
a ^ b | a์ ๋ชจ๋ ๋นํธ์ b์ ๋ชจ๋ ๋นํธ๋ฅผ XOR ์ฐ์ฐํ๋ค. ๋์ด ๋ค๋ฅด๋ค๋ฉด 1, ์๋๋ฉด 0 |
ex) 011 ^ 101 = 110 |
~a | a์ ๋ชจ๋ ๋นํธ์ NOT ์ฐ์ฐ์ ํ๋ค. 0์ด๋ฉด 1, 1์ด๋ฉด 0 |
ex) a = 011 ~a = 100 |
a << b | a๋ฅผ b๋นํธ ๋งํผ ์ผ์ชฝ์ผ๋ก ์ํํธ |
ex) a = 001 a << 2 = 100 |
a >> b | a๋ฅผ b๋นํธ ๋งํผ ์ค๋ฅธ์ชฝ์ผ๋ก ์ํํธ |
ex) a = 100 a >> 2 = 001 |
์งํฉ์ ํํ
๋นํธ๋ง์คํฌ๋ฅผ ํํํ๋ฉด ์งํฉ์ ์ฝ๊ฒ ํํํ ์ ์๋ค.
๋ํ, ์งํฉ์ ์์๋ฅผ ์ถ๊ฐ, ์ญ์ ํ๋ ๋ฑ ๋ค์ํ ์ฐ์ฐ์ ๋น ๋ฅด๊ฒํ ์ ์๋ค.
์์์ ๊ฐ์๊ฐ N์ธ ์งํฉ์ด ์๋ค๊ณ ํ๋ฉด, ๊ฐ ์์๋ฅผ 0 ~ (N-1)๋ฒ๊น์ง ๋ฒํธ๋ฅผ ๋ถ์ฌํ๊ณ
๋ฒํธ์ ํด๋นํ๋ ๋นํธ๊ฐ 1์ด๋ฉด ์์ ํฌํจ, 0์ด๋ฉด ๋ถํฌํจ์ด๋ผ๊ณ ํ๋ค๋ฉด ๋นํธ๋ฅผ ์ด์ฉํด ํํํ ์ ์๋ค.
์๋ฅผ ๋ค์ด, { A, B, C, D, E, F, G } ์งํฉ์ด ์๋ค๊ณ ํด๋ณด์.
์ด 7๊ฐ ์์๊ฐ ์กด์ฌํ๋๊น ์ฐ๋ฆฌ๋ 7๊ฐ์ ๋นํธ๋ก ์งํฉ์ ํํํ ์ ์๋ค. 1011011 ์ด๋ฐ์์ผ๋ก..
๊ฐ ์์๋ง๋ค ๋นํธ๋ฅผ ํ๋์ฉ ๋์์์ผ์ ์์๊ฐ ์กด์ฌํ๋ฉด 1, ์๋๋ฉด 0์ผ๋ก ํํํด๋ณด์.
{A} ๋ผ๋ ๋ถ๋ถ์งํฉ์ 64 - 1000000(2)๋ก ํํํ๊ณ { C, F } ๋ 18 - 0010010(2) ๋ก ํํํ ๊ฒ์ด๋ค.
์์ ์ถ๊ฐ
ํ์ฌ ์ํ cur์ด ์์ ๋, p๋ฒ ์์๋ฅผ ์ถ๊ฐํ๋ค๊ณ ํด๋ณด์.
๊ทธ๋ ๋ค๋ฉด ํ์ฌ ์ํ cur์์ p๋ฒ ๋นํธ๋ฅผ 1๋ก ๋ฐ๊ฟ์ค์ผํ๋ค.
๋นํธ์ฐ์ฐ์ '|' ๋ฅผ ํ์ฉํ๋ฉด ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค.
cur = cur | (1<<p)
์์ ์ญ์
์์ ์ญ์ ๋ p๋ฒ ๋นํธ๋ฅผ 0์ผ๋ก ๋ฐ๊ฟ์ค์ผํ๋ค.
cur = cur & ~(1 << p)
1<<p๋ฅผ ํตํด์ p๋ฒ ๋นํธ๋ง 1, ๋๋จธ์ง๋ 0์ผ๋ก ๋ง๋ ๋ค.
๊ทธ ํ, ~์ฐ์ฐ์ ํตํด p๋ฒ ๋นํธ๋ง 0, ๋๋จธ์ง๋ 1๋ก ๋ง๋ค๊ณ & ์ฐ์ฐ์ ์งํํ๋ฉด p๋ฒ ๋นํธ๋ง 0์ผ๋ก ๋ฐ๋๊ณ ๋๋จธ์ง๋ cur๊ณผ ๋์ผํ๊ฒ ์ ์งํ๋ค.
์์ ํ ๊ธ
์์ ํ ๊ธ์ p๋ฒ ๋นํธ๊ฐ 1์ด๋ฉด 0, 0์ด๋ฉด 1์ด๋ค.
ํ์ฌ ์ํ์์ p๋ฒ ์์๊ฐ ์๋ค๋ฉด ์ญ์ ํ๊ณ , ์๋ค๋ฉด ์ถ๊ฐํ๋ค.
cur = cur ^ (1<<p)
^ ์ฐ์ฐ์ ๋ค๋ฅด๋ค๋ฉด 1 ๊ฐ์ผ๋ฉด 0์ผ๋ก ์ฐ์ฐํ๋ค. ๋น๊ตํ ๊ฐ(1<<idx)์ 00100์ด๋ค.
3๋ฒ์งธ ์์๊ฐ 0์ด์๊ธฐ ๋๋ฌธ์ 1๋ก ๋ฐ๋์๋ค.
์งํฉ ์ฐ์ฐ
๋นํธ๋ง์คํน์ ์ด์ฉํ๋ฉด ํฉ, ๊ต, ์ฐจ์งํฉ ๋ฑ์ ์ฝ๊ฒ ๊ตฌํ ์ ์๋ค.
- a | b : ํฉ์งํฉ
- a & b : ๊ต์งํฉ
- a & ~b : a์์ b๋ฅผ ๋บ ์ฐจ์งํฉ
- a ^ b : a์ b ์ค ํ๋์๋ง ํฌํจ๋ ์์๋ค์ ์งํฉ
์งํฉ์ ํฌ๊ธฐ ๊ตฌํ๊ธฐ
์งํฉ์ ํฌ๊ธฐ๋ฅผ ๊ตฌํ๋ ค๋ฉด, ํ์ฌ 1๋ก ์ผ์ ธ์๋ ๋นํธ์ ์๋ฅผ countํด์ผํ๋ค.
๋ฐ๋ผ์, ๋ชจ๋ ๋นํธ๋ฅผ ์ํํด์ผํ๊ณ ์ฌ๊ท์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ด ๊ตฌํํ ์ ์๋ค.
func countBit(_ x: Int) -> Int {
if x == 0 { return 0 }
return x % 2 + countBit(x / 2)
}
๋ชจ๋ ๋ถ๋ถ์งํฉ ์ํํ๊ธฐ
์ด๋ค ์งํฉ์ ๋ชจ๋ ๋ถ๋ถ์งํฉ์ ์ํํ๋ ๊ณผ์ ๋ ๊ฐ๋จํ๊ฒ ๊ตฌํํ ์ ์๋ค.
func processSubsets(of set: Int) {
var subset = set
while subset != 0 {
// subset์ set์ ๋ถ๋ถ์งํฉ ์ค ํ๋.
// ์ฌ๊ธฐ์ ๋ถ๋ถ์งํฉ ์ฒ๋ฆฌ ๋ก์ง์ ์์ฑํ๋ค.
subset = (subset - 1) & set
}
}
์๋ฅผ ๋ค์ด ์งํฉ์์ A, B, C, D ์ค { A, B, D } ๋ฅผ ํฌํจํ ์งํฉ์ ์๊ฐํด๋ณด์.
๋ชจ๋ ๋ถ๋ถ ์งํฉ์ ๊ณต์งํฉ์ ์ ์ธํ๊ณ {A}, {B}, {D}, {A, D}, {B, D}, {A, B, D} ๊ฐ ์กด์ฌํ๋ค.
๋นํธ๋ก ํํํ๋ฉด ์๋์ ๊ฐ๋ค.
- {A, B, D} : 1101
- {A, B} : 1100
- {A, D} : 1001
- {B, D} : 0101
- {A} : 1000
- {B} : 0100
- {D} : 0001
์ด์ ๊ตฌํํ ์ฝ๋๋ฅผ ๋ฐ๋ผ๊ฐ๋ณด์.
subset | (subset-1) | (subset-1) & set(1101) | |
A B D | 1101 | 1100 | 1100 |
A B | 1100 | 1011 | 1001 |
A D | 1001 | 1000 | 1000 |
A | 1000 | 0111 | 0101 |
B D | 0101 | 0100 | 0100 |
B | 0100 | 0011 | 0001 |
D | 0001 | 0000 | 0000 |
while ๋ฌธ์ ํตํด ๋ถ๋ถ์งํฉ์ ๋ค ์ํํ๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
'๐ป CS > ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Swift] ์ด์งํ์(Binary Search) (0) | 2023.05.17 |
---|---|
[Swift] ๋ฐฑํธ๋ํน (0) | 2023.05.09 |
[Swift] ๋์ ๊ณํ๋ฒ (Dynamic Programming) ์ดํดํ๊ธฐ (0) | 2023.04.12 |
[Swift] ๊ทธ๋ฆฌ๋(Greedy) ์๊ณ ๋ฆฌ์ฆ (0) | 2023.04.04 |
[Swift] (๋ถํ ์ ๋ณต) ํต ์ ๋ ฌ ๊ตฌํํด๋ณด๊ธฐ (0) | 2023.04.03 |