๐น 3. Binary Search & Bitwise Operations
05. ๋นํธ ์กฐ์
[ ๋นํธ ์กฐ์์ ํ ๋ ์์์ผ ํ ์ฌ์ค๋ค๊ณผ ํธ๋ฆญ๋ค ]
(0s: ๋ชจ๋ ๋นํธ๊ฐ 0์ธ ๊ฐ, 1s: ๋ชจ๋ ๋นํธ๊ฐ 1์ธ ๊ฐ)
[ 2์ ๋ณด์์ ์์ ]
์ปดํจํฐ๋ ์ผ๋ฐ์ ์ผ๋ก ์ ์๋ฅผ ์ ์ฅํ ๋ 2์ ๋ณด์ ํํ๋ก ์ ์ฅํ๋ค.
์์์ ๊ฒฝ์ฐ ๋ฌธ์ ๊ฐ ์์ง๋ง, ์์๋ฅผ ํํํ ๋๋ ์ ๋๊ฐ์ ๋ถํธ๋นํธ(sign bit)๋ฅผ 1๋ก ์ธํ ํ ๋ค 2์ ๋ณด์๋ฅผ ์ทจํ ํํ๋ก ํํํ๋ค.
์์
4๋นํธ๋ก ํํ๋ ์ ์ -3
โ ๋งจ ์์ 1์ ๋ถํธ๋นํธ, -3์ ์ ๋๊ฐ์ธ 3์ 8($=2^3$)์ ๋ํ ๋ณด์๋ 5์ด๋ฏ๋ก 2์ง์๋ก ํํํ๋ฉด 101
๋ฐ๋ผ์ 4๋นํธ๋ก ํํํ๋ฉด 1101์ด ๋๋ค.
[ ์ฐ์ ์ฐ์ธก ์ํํธ vs ๋ ผ๋ฆฌ์ฐ์ธก ์ํํธ ]
์ฐ์ ์ฐ์ธก ์ํํธ(arithmetic right shift)
- ๊ธฐ๋ณธ์ ์ผ๋ก 2๋ก ๋๋ ๊ฒฐ๊ณผ์ ๊ฐ๋ค.
๋นํธ๋ฅผ ์์ผ๋ก ์ฎ๊ธด๋ค. ๋จ, ๋ถํธ๋นํธ๋ ๋ฐ๊พธ์ง ์๋๋ค.
๋ฐ๋ผ์ ์ด ์ฐ์ฐ์ ๋๋ต ๊ฐ์ 2๋ก ๋๋ ํจ๊ณผ๊ฐ ์๊ณ , ยป ์ฐ์ฐ๊ณผ ๊ฐ๋ค.
๋ ผ๋ฆฌ ์ฐ์ธก ์ํํธ(logical right shift)
- ์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก ๋นํธ๋ฅผ ์ฎ๊ธธ ๋ ๋ณด์ด๋ ๊ฒ์ฒ๋ผ ์์ง์ธ๋ค.
๋นํธ๋ฅผ ์์ผ๋ก ์ฎ๊ธด ํ ์ต์์ ๋นํธ(most significant bit)์ 0์ ๋ฃ๋๋ค.
์ฆ, ยป> ์ฐ์ฐ๊ณผ ๊ฐ๋ค.
์์
x = -93242, count = 40์ผ ๋ ์๋ ํจ์๋ ์ด๋ป๊ฒ ๋์ํ ๊น?
๋ ผ๋ฆฌ ์ํํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ต์์ ๋นํธ์ 0์ ๋ฐ๋ณต์ ์ผ๋ก ์ฑ์ ๋ฃ์ผ๋ฏ๋ก ๊ฒฐ๊ณผ์ ์ผ๋ก 0์ด ๋ ๊ฒ์ด๋ค.
์ฐ์ ์ํํธ๋ฅผ ์ฌ์ฉํ๋ฉด ์ต์์ ๋นํธ์ 1์ ๋ฐ๋ณต์ ์๋ก ์ฑ์ ๋ฃ๊ฒ ๋๋ฏ๋ก ๊ฒฐ๊ณผ์ ์ผ๋ก -1์ด ๋ ๊ฒ์ด๋ค. (๋ชจ๋ ๋นํธ๊ฐ 1๋ก ์ฑ์์ ธ ์์ผ๋ฉด -1์ด ๋๋ค.)
[ ๊ธฐ๋ณธ์ ์ธ ๋นํธ ์กฐ์: ๋นํธ๊ฐ ํ์ธ ๋ฐ ์ฑ์๋ฃ๊ธฐ ]
๋นํธ๊ฐ ํ์ธ
1
2
3
boolean getBit(int num, int i) {
return ((num & (1 << i)) != 0);
}
- 1์ i๋นํธ๋งํผ ์ํํธํด์ 00010000๊ณผ ๊ฐ์ ๊ฐ์ ๋ง๋ ๋ค.
AND ์ฐ์ฐ์ ํตํด num์ i๋ฒ์งธ ๋นํธ๋ฅผ ๋บ ๋๋จธ์ง ๋นํธ๋ฅผ ๋ชจ๋ ์ญ์ ํ ๋ค, ์ด ๊ฐ์ 0๊ณผ ๋น๊ตํ๋ค.
๋ง์ฝ ์ด ๊ฐ์ด 0์ด ์๋๋ผ๋ฉด num์ i๋ฒ์งธ ๋นํธ๋ 1์ด์ด์ผ ํ๊ณ , 0์ด๋ผ๋ฉด i๋ฒ์งธ ๋นํธ๋ 0์ด์ด์ผ ํ๋ค.
๋นํธ๊ฐ ์ฑ์๋ฃ๊ธฐ
1
2
3
int setBit(int num, int i) {
return num | (1 << i);
}
- setBit๋ 1์ i๋นํธ๋งํผ ์ํํธํด์ 00010000๊ณผ ๊ฐ์ ๊ฐ์ ๋ง๋ ๋ค.
OR ์ฐ์ฐ์ ํตํด num์ i๋ฒ์งธ ๋นํธ๊ฐ์ ๋ฐ๊พผ๋ค.
i๋ฒ์งธ๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋นํธ๋ค์ 0๊ณผ OR ์ฐ์ฐ์ ํ๊ฒ ๋๋ฏ๋ก num์ ์๋ฌด ์ํฅ์ ๋ผ์น์ง ์๋๋ค.
๋นํธ๊ฐ ์ญ์ ํ๊ธฐ
1
2
3
4
int clearBit(int num, int i) {
int mask = ~(1 << i);
return num & mask;
}
์ด ๋ฉ์๋๋ setBit๋ฅผ ๊ฑฐ์ ๋ฐ๋๋ก ํ ๊ฒ๊ณผ ๊ฐ๋ค.
- NOT ์ฐ์ฐ์๋ฅผ ์ด์ฉํด (00010000)์ 1101111๊ณผ ๊ฐ์ด ๋ง๋ ๋ค.
num๊ณผ AND ์ฐ์ฐ์ ์ํํ๋ค.
๊ทธ๋ฌ๋ฉด ๋๋จธ์ง ๋นํธ์ ๊ฐ์ ๋ณํ์ง ์์ ์ฑ num์ i๋ฒ์งธ ๋นํธ๊ฐ๋ง ์ญ์ ๋๋ค.
์ต์์ ๋นํธ์์ i๋ฒ์งธ ๋นํธ๊น์ง ๋ชจ๋ ์ญ์ ํ๋ ค๋ฉด?
1
2
3
4
int clearBitsMSBthroughI(int num, int i) {
int mask = (1 << i) - 1;
return num & mask;
}
(1 << i)
๋ก i๋ฒ์งธ ๋นํธ๋ฅผ 1๋ก ์ธํ ํ๋ค.์ด ๊ฐ์์ 1์ ๋บ๋ค.
๊ทธ๋ฌ๋ฉด i๋ฒ์งธ ๋นํธ ๋ฐ์ ๋ชจ๋ 1๋ก ์ธํ ๋๊ณ ๊ทธ ์๋ก๋ ๋ชจ๋ 0์ผ๋ก ์ธํ ๋๋ค.
- ์ด mask ๊ฐ๊ณผ num์ AND ์ฐ์ฐํ๋ฉด ํ์ i๊ฐ์ ๋นํธ๋ฅผ ๋บ ๋๋จธ์ง ๋นํธ๋ฅผ ๋ชจ๋ ์ญ์ ํ ์ ์๋ค.
i๋ฒ์งธ ๋นํธ์์ 0๋ฒ์งธ ๋นํธ๊น์ง ๋ชจ๋ ์ญ์ ํ๋ ค๋ฉด?
1
2
3
4
int clearBitsIthrough0(int num, int i) {
int mask = (-1 << (i + 1));
return num & mask;
}
๋ชจ๋ ๋นํธ๊ฐ 1๋ก ์ธํ ๋ -1์ ์ผ์ชฝ์ผ๋ก i+1๋งํผ ์ํํธํ๋ค.
๊ทธ๋ฌ๋ฉด i๋ฒ์งธ ๋นํธ ์๋ก๋ ๋ชจ๋ 1๋ก ์ธํ ๋๊ณ ํ์ i๊ฐ ๋นํธ๋ ๋ชจ๋ 0์ผ๋ก ์ธํ ๋๋ค.
๋นํธ๊ฐ ๋ฐ๊พธ๊ธฐ
i๋ฒ์งธ ๋นํธ๊ฐ์ v๋ก ๋ฐ๊พธ๊ณ ์ถ๋ค๋ฉด?
1
2
3
4
5
int updateBit(int num, int i, boolean bitIs1) {
int value = bitIs1 ? 1 : 0;
int mask = ~(1 << i);
return (num & mask) | (value << i);
}
- 11101111๊ณผ ๊ฐ์ ๊ฐ์ ์ด์ฉํด(i=4๋ผ๊ณ ํ๋ฉด) i๋ฒ์งธ ๋นํธ๊ฐ์ ์ญ์ ํด์ผ ํ๋ค.
์ฐ๋ฆฌ๊ฐ ๋ฐ๊พธ๊ณ ์ ํ๋ ๊ฐ v๋ฅผ ์ผ์ชฝ์ผ๋ก i๋ฒ ์ํํธํ๋ค.
๊ทธ๋ฌ๋ฉด i๋ฒ์งธ ๋นํธ๊ฐ์ v๊ฐ ๋ ๊ฒ์ด๊ณ ๋๋จธ์ง๋ ๋ชจ๋ 0์ด ๋ ๊ฒ์ด๋ค.
- OR ์ฐ์ฐ์ ์ด์ฉํด i๋ฒ์งธ ๋นํธ๊ฐ์ v๋ก ๋ฐ๊ฟ์ค๋ค.
10. ์ ๋ ฌ๊ณผ ํ์
[ ์ด์ง ํ์ ]
: ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์์ x๋ฅผ ์ฐพ๊ณ ์ ํ ๋ ์ฌ์ฉ
- ์ค๊ฐ ์์์ x๋ฅผ ๋น๊ตํ๋ค.
- x๊ฐ ๋ ์๋ค๋ฉด ์ผ์ชฝ ์ ๋ฐ์, x๊ฐ ๋ ํฌ๋ค๋ฉด ์ค๋ฅธ์ชฝ ์ ๋ฐ์ ์ฌํ์ํ๋ค.
์ ๊ณผ์ ์ x๋ฅผ ์ฐพ๊ฑฐ๋ ๋ถ๋ถ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 0์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.