如何打印组合数量而不是实际组合？ Java

Question

I'd like to print the number of combination and not the actual combination of bits. How can I code that? I'm looking forward for some solution. Thank you!

The Task:

Write a program that accepts a number. This number corresponds to the number of bits to be taken into account. The program should then display on the screen how many binary combinations there are that do not consist of two adjacent 1s. For example, given a 3-bit number, there are 5 out of 8 possible combinations.

 import java.util.Scanner;

 public class BinaryS {

   public static String toString(char[] a) {
     String string = new String(a);
     return string;
   }

   static void generate(int k, char[] ch, int n) {

     if (n == k) {

       for (int i = 0; i < ch.length; i++) {}
       System.out.print(toString(ch) + " ");

       return;

     }

     // If the first Character is
     //Zero then adding**
     if (ch[n - 1] == '0') {
       ch[n] = '0';
       generate(k, ch, n + 1);
       ch[n] = '1';
       generate(k, ch, n + 1);
     }

     // If the Character is One
     // then add Zero to next**
     if (ch[n - 1] == '1') {

       ch[n] = '0';

       // Calling Recursively for the
       // next value of Array
       generate(k, ch, n + 1);

     }
   }

   static void fun(int k) {

     if (k <= 0) {
       return;
     }

     char[] ch = new char[k];

     // Initializing first character to Zero
     ch[0] = '0';

     // Generating Strings starting with Zero--
     generate(k, ch, 1);

     // Initialized first Character to one--
     ch[0] = '1';
     generate(k, ch, 1);

   }

   public static void main(String args[]) {
     System.out.print("Number: ");
     Scanner scanner = new Scanner(System.in);
     int k = scanner.nextInt();

     //Calling function fun with argument k
     fun(k);

   }
 }

The program actually works fine, my only problem is I would like to print the number of combinations and not the actual combination. For example for the input 3 we get 000 001 010 100 101 which is 5.

Answer 1

Unfortunately, your code has some problems. For one you have an empty forloop in the generate method. However, I can help you get the count by doing it a different way and printing the results. Forgetting about the loop that goes from 2 to 20 , here is what is going on. And this may not be most efficient way of finding the matches but for short runs it exposes the counts as a recognizable pattern (which could also be determined by mathematical analysis).

• first, create an IntPredicate that checks for adjacent one bits by masking the lower order two bits.
• Generate an IntStream from 0 to where n is the number of bits.
• then using aforementioned predicate with a filter count every value that does not contain two adjacent 1 bits.

IntPredicate NoAdjacentOneBits = (n)-> {
    while (n > 0) {
        if ((n & 3) == 3) {
            return false;
        }
        n>>=1;
    }
    return true;
};
        
for (int n = 1; n <= 20; n++) {
    long count = IntStream.range(0, (int) Math.pow(2, n))
            .filter(NoAdjacentOneBits).count();
    System.out.println("For n = " + n + " -> " + count);
}

prints (with annotated comments on first three lines)

For n = 1 -> 2  // not printed but would be 0 and 1
For n = 2 -> 3  // 00, 01, 10
For n = 3 -> 5  // 000, 001, 010, 100, 101
For n = 4 -> 8
For n = 5 -> 13
For n = 6 -> 21
For n = 7 -> 34
For n = 8 -> 55
For n = 9 -> 89
For n = 10 -> 144
For n = 11 -> 233
For n = 12 -> 377
For n = 13 -> 610
For n = 14 -> 987
For n = 15 -> 1597
For n = 16 -> 2584
For n = 17 -> 4181
For n = 18 -> 6765
For n = 19 -> 10946
For n = 20 -> 17711

The counts are directly related to the n th term of the Fibonacci Series that starts with 2 3 5 8. . .

So you really don't even need to inspect the values for adjacent bits. Just compute the related term of the series.