原文：
Given an integer, print the next smallest and next largest number that have the same number of 1 bits in their binary representation.
译文：
给定一个整数x，找出另外两个整数，这两个整数的二进制表示中1的个数和x相同， 其中一个是比x大的数中最小的，另一个是比x小的数中最大的。
对于这道题，我们先完成一个最朴素最直接的版本，以保证其正确性。 这个版本可以作为其它版本的验证工具。
什么方法是最直接的呢？给定一个数x，计算出它的二进制表示中1的个数为num， 然后x不断加1并计算其二进制表示中1的个数，当它再次等于num时， 就找到了比x大且二进制表示中1的个数相同的最小的数。类似地， 可以找到比x小且二进制表示中1的个数相同的最大的数，只不过x变为不断减1而已。
public static int nextInt(int m, int count) {
int max_int = ~(1<<31);
if(count == 0 || m == -1) {
return -1;
}
for(++m; count_one(m)!=count && m <= max_int; m++);
if(count_one(m) == count) {
return m;
} else {
return -1;
}
}
public static int preInt(int m, int count) {
int min_int = (1<<31);
if(count == 0 || m == -1) {
return -1;
}
for(--m; count_one(m)!=count && m >= min_int; m--);
if(count_one(m) == count) {
return m;
} else {
return -1;
}
}count_one函数的功能是计算一个数的二进制表示中1的个数，这个要怎么实现呢？ 一种方法是通过不断地移位判断最低位是否为1然后计数器累加，代码如下：
/**
* @param m
* @return
*
* 计算二进制表示法中1的个数
*
*/
public static int count_one(int m) {
int count = 0;
for(int i=0; i<32; i++) {
if((m & 1) == 1) {
count ++;
}
m = m>>1;
}
return count;
}
public static int count_one2(int m) {
m = (m & 0x55555555) + (m>>1 & 0x55555555);
m = (m & 0x33333333) + (m>>2 & 0x33333333);
m = (m & (0x0f0f0f0f)) + ((m >> 4) & (0x0f0f0f0f));
m = (m & (0x00ff00ff)) + ((m >> 8) & (0x00ff00ff));
m = (m & (0x0000ffff)) + ((m >> 16) & (0x0000ffff));
return m;
}总代码如下：
package chapter_5_BitManipulation;
import java.util.Scanner;
/**
*
* 给一个整数，打印两个数，并且他们的二进制表示中的1的个数和这个整数的一样，其中一个是比该数大的数中最小的，另一个是比该数小的数中最大的。
*
*/
public class Question_5_3 {
/**
* @param m
* @return
*
* 把int类型整数 转换成二进制表示法
*
*/
public static String tranceBinary(int m) {
StringBuilder result = new StringBuilder();
char str = ' ';
for(int i=0; i< 32; i++) {
if((m & 1) == 1) {
str = '1';
} else {
str = '0';
}
result.append("" + str);
m = m>>1;
}
return result.toString();
}
/**
* @param m
* @return
*
* 计算二进制表示法中1的个数
*
*/
public static int count_one(int m) {
int count = 0;
for(int i=0; i<32; i++) {
if((m & 1) == 1) {
count ++;
}
m = m>>1;
}
return count;
}
public static int count_one2(int m) {
m = (m & 0x55555555) + (m>>1 & 0x55555555);
m = (m & 0x33333333) + (m>>2 & 0x33333333);
m = (m & (0x0f0f0f0f)) + ((m >> 4) & (0x0f0f0f0f));
m = (m & (0x00ff00ff)) + ((m >> 8) & (0x00ff00ff));
m = (m & (0x0000ffff)) + ((m >> 16) & (0x0000ffff));
return m;
}
public static int nextInt(int m, int count) {
int max_int = ~(1<<31);
if(count == 0 || m == -1) {
return -1;
}
for(++m; count_one(m)!=count && m <= max_int; m++);
if(count_one(m) == count) {
return m;
} else {
return -1;
}
}
public static int preInt(int m, int count) {
int min_int = (1<<31);
if(count == 0 || m == -1) {
return -1;
}
for(--m; count_one(m)!=count && m >= min_int; m--);
if(count_one(m) == count) {
return m;
} else {
return -1;
}
}
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
scanner.nextLine();
while(num -- > 0) {
int m = scanner.nextInt();
scanner.nextLine();
int count = count_one(m);
String binary = tranceBinary(m);
System.out.format("%d 二进制表示 ：", m);
for(int i=31; i>=0; i--) {
System.out.format("%c", binary.charAt(i));
}
System.out.format("\n%d 二进制含有1个数 ：%d \n", m, count);
int nextInt = nextInt(m, count);
System.out.println("nextInt :" + nextInt);
int preInt = preInt(m, count);
System.out.println("preInt :" + preInt);
int count2 = count_one2(m);
System.out.format("\n%d 二进制含有1个数 ：%d \n", m, count2);
}
}
}
接下来考虑除了朴素方案外，有没有更高效的方案。假设给定的数的二进制表示为： 1101110，我们从低位看起，找到第一个1，从它开始找到第一个0，然后把这个0变为1， 比这个位低的位全置0，得到1110000，这个数比原数大，但比它少了两个1， 直接在低位补上这两个1，得到，1110011，这就是最终答案。 我们可以通过朴素版本来模拟这个答案是怎么得到的：
1101110->1101111->1110000->1110001->1110010->1110011
/**
* @param m
* @return
*
* 计算比当前大的数中二进制1的个数一样多
*
*/
public static int nextInt(int m) {
int bit = 0;
int curX = m;
int num = 0;
for(;(curX&1)!=1 && bit < 32;) {
bit ++;
curX = curX >>1;
}
for(;(curX&1)!=0 && bit < 32;) {
bit ++;
num ++;
curX = curX >>1;
}
if(bit == 31) {
return -1;
}
curX |= 1; // 最低位0设置为1
curX = curX << bit;
if(bit == 32) { // 1111100000
return 0;
}
int c = 1;
num --;
for(; num > 0;) {
curX = curX | c;
c = c << 1;
num --;
}
return curX;
}
public static int preInt(int m) {
int curX = m;
int bit = 0;
for(;(curX&1)!=0 && bit < 32;) {
bit ++;
curX >>= 1;
}
for(;(curX&1)!=1 && bit< 32;) {
bit ++;
curX >>= 1;
}
curX -= 1;
curX <<= bit;
if(bit == 32) curX = 0;
int num1 = count_one2(m) - count_one2(curX);
curX >>= bit;
for(; num1 > 0; curX = (curX<<1) | 1, --num1, --bit);
for(; bit > 0; curX <<= 1, --bit);
return curX;
}总代码如下：
package chapter_5_BitManipulation;
import java.util.Scanner;
/**
*
* 给一个整数，打印两个数，并且他们的二进制表示中的1的个数和这个整数的一样，其中一个是比该数大的数中最小的，另一个是比该数小的数中最大的。
*
*/
public class Question_5_3_2 {
/**
* @param m
* @return
*
* 把int类型整数 转换成二进制表示法
*
*/
public static String tranceBinary(int m) {
StringBuilder result = new StringBuilder();
char str = ' ';
for(int i=0; i< 32; i++) {
if((m & 1) == 1) {
str = '1';
} else {
str = '0';
}
result.append("" + str);
m = m>>1;
}
return result.toString();
}
/**
* @param m
* @return
*
* 计算比当前大的数中二进制1的个数一样多
*
*/
public static int nextInt(int m) {
int bit = 0;
int curX = m;
int num = 0;
for(;(curX&1)!=1 && bit < 32;) {
bit ++;
curX = curX >>1;
}
for(;(curX&1)!=0 && bit < 32;) {
bit ++;
num ++;
curX = curX >>1;
}
if(bit == 31) {
return -1;
}
curX |= 1; // 最低位0设置为1
curX = curX << bit;
if(bit == 32) { // 1111100000
return 0;
}
int c = 1;
num --;
for(; num > 0;) {
curX = curX | c;
c = c << 1;
num --;
}
return curX;
}
public static int preInt(int m) {
int curX = m;
int bit = 0;
for(;(curX&1)!=0 && bit < 32;) {
bit ++;
curX >>= 1;
}
for(;(curX&1)!=1 && bit< 32;) {
bit ++;
curX >>= 1;
}
curX -= 1;
curX <<= bit;
if(bit == 32) curX = 0;
int num1 = count_one2(m) - count_one2(curX);
curX >>= bit;
for(; num1 > 0; curX = (curX<<1) | 1, --num1, --bit);
for(; bit > 0; curX <<= 1, --bit);
return curX;
}
public static int count_one2(int m) {
m = (m & 0x55555555) + (m>>1 & 0x55555555);
m = (m & 0x33333333) + (m>>2 & 0x33333333);
m = (m & (0x0f0f0f0f)) + ((m >> 4) & (0x0f0f0f0f));
m = (m & (0x00ff00ff)) + ((m >> 8) & (0x00ff00ff));
m = (m & (0x0000ffff)) + ((m >> 16) & (0x0000ffff));
return m;
}
public static void main(String args[]) {
Scanner scanner = new Scanner(System.in);
int num = scanner.nextInt();
scanner.nextLine();
while(num -- > 0) {
int m = scanner.nextInt();
scanner.nextLine();
int count = count_one2(m);
String binary = tranceBinary(m);
System.out.format("%d 二进制表示 ：", m);
for(int i=31; i>=0; i--) {
System.out.format("%c", binary.charAt(i));
}
System.out.format("\n%d 二进制含有1个数 ：%d \n", m, count);
int nextInt = nextInt(m);
System.out.println("nextInt :" + nextInt);
String result = tranceBinary(nextInt);
System.out.format("nextInt %d 二进制表示 ：", nextInt);
for(int i=31; i>=0; i--) {
System.out.format("%c", result.charAt(i));
}
System.out.format("\n");
int preInt = preInt(m);
System.out.println("preInt :" + preInt);
String pre = tranceBinary(preInt);
System.out.format("nextInt %d 二进制表示 ：", preInt);
for(int i=31; i>=0; i--) {
System.out.format("%c", pre.charAt(i));
}
System.out.format("\n");
}
}
}
参考自：http://www.hawstein.com/posts/5.3.html
1046
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
