Создание всех возможных двоичных комбинаций

Question

Я пытаюсь сгенерировать все возможные бинарные комбинации для двух байтов ex.

 
00000000 00000001 
00000000 00000010 
00000000 00000011 

У меня есть класс, который я работаю, но его явно не работает вообще. Я не могу получить метод для возврата результата по мере его создания.

Я получил код ниже для правильной работы, но только для расчета 1 байт. Как бы это изменить, чтобы рассчитать все возможные результаты для 2 байтов?

 
package referenceCode;
 

public class BinaryGenerator {
 

private int val = 0; 
private int[] values = new int[]{0,1}; 





//This method converts the Binary Pattern output into a char[] so that it can be printed out to a file 
public int[] binaryPatternToString() { 
    int numBits = 8; 
    values[0] = 0; 
    values[1] = 1; 
    int[] returned = null; 

    for (int i = 1; i < numBits; i++) { 
     returned = binaryGenerator(i); 
     for (int j = 1; j < numBits; j++) { 
     } 
    } 
    return returned; 
} 

private int[] binaryGenerator(int iVal) { 
     int[] moreValues = new int[values.length * 2]; 
     int start = (int)Math.pow(2, iVal); 
     for (int j = 0; j < values.length; j++) { 
      moreValues[j * 2] = values[j] << 1; 
      moreValues[j * 2 + 1] = values[j] << 1 | 1; 
     } 
     values = moreValues; 

    for (int value : values) { 
      System.out.println(Integer.toBinaryString(value)); 
    } 
    return moreValues; 
}} 

Будет ли это быть лучшей идеей или более эффективным, чтобы сделать это рекурсивный метод вместо метода с цикл?

Answer 1

Как вы знаете, все java-целые числа основаны на двоичных числах. Таким образом, для 2 байтов максимальное число равно 2^16 = 65536. Просто пропустите все числа и получите их двоичные значения, при необходимости добавьте их в нуль и, наконец, сохраните их в списке. Это вернет все возможные 2-байтовые двоичные числа. Для большего количества байтов просто увеличивайте байтовую переменную.

Реализация:

int bytes = 2; 
int nBits = bytes * 8; 
int maxNumber = 1 << nBits; //this equals 2^nBits or in java: Math.pow(2,nbits) 
ArrayList<String> binaries = new ArrayList<>(); 
for (int i = 0; i < maxNumber; i++) { 
    String binary = Integer.toBinaryString(i); 
    while (binary.length() != nBits) { 
     binary = "0" + binary; 
    } 
    binaries.add(binary); 
} 
System.out.println(binaries); 

Байты и Nbits переменные включены просто для ясности.

Вы также можете использовать рекурсивный метод. Начните с пустой строкой и рекурсивно добавить 0 или 1 в начало строки и продолжаться до тех пор, пока вы достигли количества бит вы хотели:

public static ArrayList<String> getBinaries(int bits, String current) { 
    ArrayList<String> binaries = new ArrayList<>(); 

    if (current.length() == bits) { 
     binaries.add(current); 
     return binaries; 
    } 

    //pad a 0 and 1 in front of current; 
    binaries.addAll(getBinaries(bits, "0" + current)); 
    binaries.addAll(getBinaries(bits, "1" + current)); 

    return binaries; 
} 

Вы можете вызвать эту функцию: getBinaries(16,"") для 2 байт.

Answer 2

Я взял на себя смелость написать свою собственную версию, чтобы вы могли видеть более простой способ создания этих чисел.

Самая сложная часть здесь увеличивает список булевых элементов. В общем, это похоже на добавление 1. Вы увеличиваете свой слот, и если он уже был 1, вы переходите к слоту 10 с и так далее. В противном случае вы просто просматриваете все возможности, печатаете каждый из них.

import java.util.ArrayList; 
import java.util.List; 

public class Sandbox { 

    // list of booleans to represent each bit 
    private static List<Boolean> bytes = new ArrayList<>(); 

    public static void main(String[] args) { 
     // initialize the list to all false 
     for(int i = 0; i < 16; i++) { 
      bytes.add(false); 
     } 

     // calculate the number of permutations 
     int numPermutations = (int)Math.pow(2, 16); 

     // print the first permutation 
     print(); 

     // loop through all permutations 
     for(int i = 0; i < numPermutations; i++) { 
      // increment the 2 bytes 
      increment(); 

      // print the current permutation 
      print(); 
     } 
    } 

    /** 
    * Prints out the current permutation 
    */ 
    private static void print() { 
     // loop through the bytes 
     for(Boolean bool : bytes) { 
      // print 1 or 0 
      if(bool) 
       System.out.print(1); 
      else 
       System.out.print(0); 

     } 

     // end the line 
     System.out.println(); 
    } 

    /** 
    * Increment the bytes 
    */ 
    private static void increment() { 
     // set increment position to the end of the list 
     int position = bytes.size() - 1; 

     // loop through changing next digit if necessary, stopping 
     // if the front of the list is reached. 
     do { 
      bytes.set(position, !bytes.get(position)); 
     } while(!bytes.get(position--) && position >= 0); 
    } 
}