์ผ | ์ | ํ | ์ | ๋ชฉ | ๊ธ | ํ |
---|---|---|---|---|---|---|
1 | 2 | 3 | ||||
4 | 5 | 6 | 7 | 8 | 9 | 10 |
11 | 12 | 13 | 14 | 15 | 16 | 17 |
18 | 19 | 20 | 21 | 22 | 23 | 24 |
25 | 26 | 27 | 28 | 29 | 30 | 31 |
- mariadb
- tcp ์ธ๊ทธ๋จผํธ
- ์๋น์ค ํ๋ฆฌ๋ฏธํฐ๋ธ
- ๊ฐ๋ฐ์์ทจ์
- ํฐ์คํ ๋ฆฌ์ฑ๋ฆฐ์ง
- ํ ํฐ ๋ฒ์ค
- ์ฐ๋ถํฌdb
- ํ๋ ์ ๊ตฌ์กฐ
- ์์๋ฒํธ
- ์ฃผ๊ธฐ์ ํธ
- i-type
- git merge
- ํญํด99
- ๋ฐ์ดํฐ ์ ์ก
- ๋น์ฃผ๊ธฐ์ ํธ
- leetcode
- ํ๋ก์ด๋์์
- ์ค๋ฅ๊ฒ์ถ
- tcp ํ๋กํ ์ฝ
- well known ํฌํธ
- reducible
- xv6
- 99ํด๋ฝ
- ์ค๋ ๋
- til
- ์ฝ๋ฉํ ์คํธ์ค๋น
- ์ค๋ฅ์ ์ด
- IEEE 802
- ์ค๋ธ์
- ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ
- Today
- Total
Unfazedโ๏ธ๐ฏ
2์ ์ ๊ณฑ์ ํ๋ณ, ์๊ฑฐ๋ ๊ฐ์ ์๋ค ์ค ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์ ๊ตฌํ๊ธฐ ๋ณธ๋ฌธ
2์ ์ ๊ณฑ์ ํ๋ณ, ์๊ฑฐ๋ ๊ฐ์ ์๋ค ์ค ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์ ๊ตฌํ๊ธฐ
9taetae9 2024. 1. 17. 15:092์ ์ ๊ณฑ์์ธ์ง ํ๋ณํ๊ธฐ
public class PowerOfTwoChecker {
public static boolean isPowerOfTwo(int n) {
return n > 0 && (n & (n - 1)) == 0;
}
public static void main(String[] args) {
System.out.println(isPowerOfTwo(1)); // true
System.out.println(isPowerOfTwo(2)); // true
System.out.println(isPowerOfTwo(16)); // true
System.out.println(isPowerOfTwo(18)); // false
}
}
2์ ์ ๊ณฑ์๋ ์ด์ง์๋ก ํํํ์ ๋, 1 ๋ค์ 0๋ง ์ฌ๋ฌ ๊ฐ ์๋ ํํ๋ฅผ ๊ฐ์ง๋ค. (์: 1, 10, 100, 1000, ...). ์ด๋ฌํ ํน์ฑ์ ํ์ฉํ์ฌ ์๋์ ๊ฐ์ ๋ก์ง์ ๊ตฌํํ ์ ์๋ค.
(n & (n-1)) == 0;
์ด์ง์ 1000์์ 1์ ๋นผ๋ฉด ์ด์ง์ 0111์ด ๋๊ธฐ ๋๋ฌธ์ 1000 & 0111 == 0 ์ฆ, ๊ฐ์๋ฆฌ์ ์ซ์๊ฐ ๋ฌด์กฐ๊ฑด ๋ฌ๋ผ์ง๋ค๋ ํน์ฑ์ด ์๋ค. ๋ฐ๋ผ์ ๋นํธ and ์ฐ์ฐ์ ์ํํ์ ๋ 0์ด ๋์ค๊ฒ ๋๋ค.
์ฃผ์ด์ง ์ซ์๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์ ์ฐพ๊ธฐ (right shift ์ฐ์ฐ ํ์ฉ)
public static long findLargestPowerOfTwoLessThanOrEqual(long n) {
n |= n >> 1;
n |= n >> 2;
n |= n >> 4;
n |= n >> 8;
n |= n >> 16;
n |= n >> 32;
return (n + 1) >> 1;
}
์ฃผ์ด์ง ์ ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์๋ค ์ค ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์๋ฅผ ์ฐพ๊ธฐ ์ํด์ ์ฐ์ 2์ ์ ๊ณฑ์ ํน์ง์ ์์์ผํ๋ค. ์์์๋ ๋งํ๋ฏ์ด 2์ ์ ๊ณฑ์๋ ์ด์ง์๋ก ํํํ์ ๋, 1 ๋ค์ 0๋ง ์ฌ๋ฌ ๊ฐ ์๋ ํํ๋ฅผ ๊ฐ์ง๋ค. (์: 1, 10, 100, 1000, ...).
๊ทธ๋์ ํด๋น ์ ๋ณด๋ค ๊ฐ๊ฑฐ๋ ์์ ์๋ค ์ค ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด์ ํด๋น ์ ์ด์ง ํํ์ ์ต์์ ๋นํธ 1์ ์ ์ธํ ํ์ ๋นํธ๋ค์ด 0์ด๋ฉด ๋๋ค.
ex) 101101 ๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์ค ๊ฐ์ฅ ํฐ 2์ ์ ๊ณฑ์๋ 100000์ด ๋๋ค.
111111 => 100000
10101 => 1000
1010 => 1000
1011 => 1000
์ฆ ์ฐ๋ฆฌ์ ๋ชฉํ๋ ์ต์์ ๋นํธ 1์ ์ ์ธํ ํ์๋นํธ๋ค์ด 0์ธ ์๋ฅผ ๋ฐํํ๋ ๊ฒ์ด๋ค.
์ด๋ฅผ ์ํด ์ฐ์ ์ฃผ์ด์ง ์ n์ ์ต์์ ๋นํธ 1๋ถํฐ ์ตํ์ ๋นํธ๊น์ง ๋ชจ๋ 1๋ก ๋ง๋ ๋ค. ex) 1001010 => 1111111
์ด์ ์ต์์ ๋นํธ 1์ ์ ์ธํ ํ์ ๋นํธ ๋ชจ๋ 1๋ค์ 0์ผ๋ก ๋ง๋ค์ด ์ฃผ๋ฉด ๋๋๋ฐ ์ด๋ ๋จ์ํ 1์ ๋ํด์ฃผ๋ฉด ๋๋ค.
1111111 + 1 => 10000000
์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฒ์ 0์ด ํ๋ ์ ์ ์ด์ง์(1000000)์ด๋ฏ๋ก right shift 1 (>>1 ์ฐ์ฐ)์ ํตํด ๊ตฌํ ์ ์๋ค.
10000000 >> 1 => 1000000
์ฃผ์ด์ง ์ n์ ์ต์์ ๋นํธ 1๋ถํฐ ์ตํ์ ๋นํธ๊น์ง ๋ชจ๋ 1๋ก ๋ง๋๋ ๊ณผ์ ์ ์กฐ๊ธ ๋ ์์ธํ ์ค๋ช ํด๋ณด๋ฉด
n |= n >> 1; // ์ฒซ ๋จ๊ณ์์ ์์ 2๋นํธ๊ฐ 1์ด ๋๋ค
n |= n >> 2; // ์์ 2๋นํธ๊ฐ 1์ด๋ฏ๋ก 2๋ฒ ์ฌํํธ ์ฐ์ฐ์ ํ๋ค bitwise or ์ฐ์ฐ์ ํด์ฃผ๋ฉด ์์ 4๋นํธ๊ฐ 1์ด๋๋ค.
n |= n >> 4; // ์์ 4๋นํธ๊ฐ 1์ด๋ฏ๋ก 4๋ฒ ์ฌํํธ ์ฐ์ฐ์ ํด์ค๋ค bitwise or ์ฐ์ฐ์ ํด์ฃผ๋ฉด ์์ 8๋นํธ๊ฐ 1์ด๋๋ค.
n |= n >> 8; // ์์ 8๋นํธ๊ฐ 1์ด๋ฏ๋ก 8๋ฒ ์ฌํํธ ์ฐ์ฐ์ ํด์ค๋ค bitwise or ์ฐ์ฐ์ ํด์ฃผ๋ฉด ์์ 16๋นํธ๊ฐ 1์ด๋๋ค.
n |= n >> 16; // ์์ 16๋นํธ๊ฐ 1์ด๋ฏ๋ก 16๋ฒ ์ฌํํธ ์ฐ์ฐ์ ํด์ค๋ค bitwise or ์ฐ์ฐ์ ํด์ฃผ๋ฉด ์์ 32๋นํธ๊ฐ 1์ด๋๋ค.
n |= n >> 32; // ์์ 32๋นํธ๊ฐ 1์ด๋ฏ๋ก 32๋ฒ ์ฌํํธ ์ฐ์ฐ์ ํด์ค๋ค bitwise or ์ฐ์ฐ์ ํด์ฃผ๋ฉด ์์ 64๋นํธ๊ฐ 1์ด๋๋ค.
์ด๋ฅผ ํตํด ์์ long ๋ฒ์(2^63-1 ๊น์ง)์ ๋ชจ๋ ์๋ฅผ ์ปค๋ฒํ๋ฉฐ ์ต์์ ๋นํธ 1๋ถํฐ ํ์ ๋นํธ๋ค์ ๋ชจ๋ 1๋ก ๋ง๋ค์ ์๋ค.
์์ฉ๋ฌธ์
https://www.hackerrank.com/challenges/counter-game/problem
Counter game | HackerRank
Louise and Richard play a game, find the winner of the game.
www.hackerrank.com
'๋ฌธ์ ํด๊ฒฐ (PS) > ๊ธฐ์ตํด๋ ๊ฒ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์ด์ง ํ์] int mid = left + (right - left) / 2; (0) | 2025.02.01 |
---|---|
|a - b| = |c - d| ์ ๋๊ฐ ์ฐจ์ด๊ฐ ๊ฐ์ ๊ฒฝ์ฐ ํ์ฉํ๊ธฐ (0) | 2024.09.19 |
10์ ์ ๊ณฑ์์ ๋ชจ๋๋ก 9 ์ฐ์ฐ์ ํ์ฉ, ๋์งํธ ๋ฃจํธ(์๋ฆฟ์๊ทผ), repeated digital sum (0) | 2024.01.13 |
๋ฐฐ์ ํ์ ๋ฒ (0) | 2024.01.13 |
๋ถ๋ถ ์์ด (0) | 2023.12.22 |