Обратные биты в количестве

Например, у меня есть двоичный номер 1011, который равен десятичной 11. Я хочу, чтобы местоположение бит-бит было таким, чтобы оно стало 1101, которое является десятичным 13. Вот код:

import java.util.*;
public class bits {
    public static void main(String[] args) {
        Scanner scnr=new Scanner(System.in);
        System.out.println("enter x:");
        int x=scnr.nextInt();
        int b=0;
        while (x!=0){
            b|=( x &1);
            x>>=1;
            b<<=1;
        }
        System.out.println(b);
    }
}

Но когда я вхожу в x 11, тогда он печатает 26. Какая ошибка?

Ответ 1

Вы меняете b один раз слишком много. Сначала сделайте смену (так что в первый раз, когда b == 0, он не имеет эффекта):

while (x!=0){
  b<<=1;
  b|=( x &1);
  x>>=1;
}

Ответ 2

Слегка оффтопик. Также есть возможность встроенных функций реверсирования бит Java.

См. http://java.sun.com/javase/6/docs/api/java/lang/Integer.html#reverse(int)

EDIT: предполагается, что вы используете Java 1.5 или новее.

Ответ 3

Используйте >>>= вместо >>=
Если вы хотите изменить подпись метода на public static byte reverse(byte in), это не будет работать с отрицательными значениями, потому что есть неявное преобразование в int.

Ответ 4

Программа не работает для ввода типа 1, 2

int reverseBits(int x)
    {
        int b = 0;
        while (x != 0)
        {
            b <<= 1;
            b |= ( x & 1);
            x >>= 1
        }
        return b;
    }

вход 1 выход 1, должен быть 8 справа? вход 2 выход 1, должен быть 4.

Ответ 5

b слишком часто смещается влево. Я ожидаю, что ввод 1 приведет к выводу 2. Переместите Shift на две строки вверх.

Ответ 6

вы переместили b один раз слишком много. попробуйте сдвинуть b влево, прежде чем делать | =:

    while (x!=0){
           b<<=1;
           b|=( x &1);
           x>>=1;

         }
   System.out.println(b);

Ответ 7

Вы переместили b на один раз больше, чем требуется. Добавьте b >>= 1 после цикла while.

Ответ 8

while(x!=0){
    b<<=1;
    b|=(x&1);
    x>>=1;
}

Ответ 9

Примечание для новичков: я использую шестнадцатеричные (0-9 и A-F), потому что одна шестнадцатеричная цифра отлично отображает 4 бинарных бита. Вместо записи 1010 я использую A (10 десятичных знаков). Вы можете сказать, что Java использует шестнадцатеричные (литералы), начиная с 0x, как в 0x0A.

Как указано выше, 1 должен выводить 8 (от 0001 до 1000). Поэтому вместо while (x!= 0) код должен сдвинуть первый бит до длины битов, необходимых в этом примере, это 4.

for (int i = 0; i < 4; ++i) { // not while (x!=0){
   b<<=1;
   b|=( x &1);
   x>>=1;
}
Hex convert 0-F: 0=0 1=8 2=4 3=C 4=2 5=A 6=6 7=E 8=1 9=9 A=5 B=D C=3 D=B E=7 F=F

Или полный 8-разрядный пример:

public static byte reverse(byte x) {
    byte b = 0;
    for (int i = 0; i < 8; ++i) {
        b<<=1;
        b|=( x &1);
        x>>=1;
      }
    return b;
}
public static void main(String args[]) {
    byte[] nums = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 
            (byte) 0xAA, (byte) 0xFE, (byte) 0xFF };
    for (byte b : nums) {
        System.out.printf("%02X=%02X ", b, reverse(b));
    }
    System.out.println();
}

Вывод:

00=00 01=80 02=40 03=C0 04=20 05=A0 06=60 07=E0 08=10
09=90 0A=50 0B=D0 0C=30 0D=B0 0E=70 0F=F0 10=08 11=88 AA=55 FE=7F FF=FF

Ответ 10

Результат в два раза больше, чем ожидалось, поэтому последняя операция сдвига влево (одна левая сдвиг удваивает значение) слишком велика.

Ответ 11

Можно безопасно использовать беззнаковый оператор сдвига вправо ( → > ) в цикле while, чтобы избежать опасности запуска в бесконечный цикл для чисел -ve.

while (x!=0){
  b<<=1;
  b|=( x &1);
  x>>>=1;
}

Ответ 12

Мои новые двоичные коды java-кода в целых числах, используя java с мощными манипуляциями с битами. Он работает с положительными, отрицательными и нулевыми значениями. Надеюсь, что это поможет.

public static int  reverseDigits(int num) throws Exception {
        if (num == 0) {         
            return Integer.MAX_VALUE | Integer.MIN_VALUE;
        }

        int count = Integer.SIZE * 8 - 1;
        int  reversed = num;        
        boolean positive = true;

        if (num < 0) {
            positive = false;
        }

        if (positive) num >>= 1;

        while(num != 0) {

            reversed <<= 1; 
            reversed |= (num & 1);          

            num >>>= 1;
            count--;            
        }

        if (positive) reversed <<= count;
        return reversed;
    }

Вы можете представлять биты в integer с моим другим кодом манипуляции с битами в java, какие нулевые изображения слева: fooobar.com/info/34465/...

Так как Integer.toBinaryString() скроет нули слева.

Металл |, |