Java中的二进制猜测游戏

我正在尝试创建一个猜测游戏，它接受用户的输入。我的问题是，当用户猜错时，必须显示二进制数的正确数字，以此类推

然而，我对输出的顺序和长度有问题

我需要什么：

Scanner scan = new Scanner(System.in);

        // Generating a random number between 1-16
        int randomNum = (int) (Math.random() * 16 + 1);
        int original = randomNum;
        System.out.println("Random num generated: " + randomNum);

        // Converting the random number to a binary number
        System.out.print("Random number in binary: ");
        int[] binary = new int[8];
        int originalBinary = 0;
        int index = 0;
        int count = 0;

        while (randomNum > 0) {
            binary[index++] = randomNum % 2;
            randomNum /= 2;
        }
        for (int i = index - 1; i >= 0; i--) {
            count++;

            System.out.print(binary[i]);
            originalBinary = binary[i];
        }
        System.out.println("\n***********************************");

        // System.out.print("\nPlease enter a guess: ");
        int guess = scan.nextInt();
        int digitsToReveal = 0;

        while (guess != original && digitsToReveal != binary.length) {

            System.out.print("\nPlease enter another number: ");
            guess = scan.nextInt();
            System.out.println(reveal(binary, digitsToReveal++));

        }

    }

    public static String reveal(int[] arr, int reveal) {
        StringBuilder str = new StringBuilder();
        for (int i = 1; i < arr.length; i++) {
            if (i >= arr.length - reveal) {
                str.append(arr[i]);
            } else {
                str.append("-");
            }

        }
        return str.toString();
    }
}

生成的随机值：11

要猜测的二进制数：

1011

显示给用户：

---

第一次猜错后显示：

--1

第二次错误猜测后显示：

--11

第三次错误猜测后显示：

-011

第四次错误猜测后显示：

1011

我得到的：

Scanner scan = new Scanner(System.in);

        // Generating a random number between 1-16
        int randomNum = (int) (Math.random() * 16 + 1);
        int original = randomNum;
        System.out.println("Random num generated: " + randomNum);

        // Converting the random number to a binary number
        System.out.print("Random number in binary: ");
        int[] binary = new int[8];
        int originalBinary = 0;
        int index = 0;
        int count = 0;

        while (randomNum > 0) {
            binary[index++] = randomNum % 2;
            randomNum /= 2;
        }
        for (int i = index - 1; i >= 0; i--) {
            count++;

            System.out.print(binary[i]);
            originalBinary = binary[i];
        }
        System.out.println("\n***********************************");

        // System.out.print("\nPlease enter a guess: ");
        int guess = scan.nextInt();
        int digitsToReveal = 0;

        while (guess != original && digitsToReveal != binary.length) {

            System.out.print("\nPlease enter another number: ");
            guess = scan.nextInt();
            System.out.println(reveal(binary, digitsToReveal++));

        }

    }

    public static String reveal(int[] arr, int reveal) {
        StringBuilder str = new StringBuilder();
        for (int i = 1; i < arr.length; i++) {
            if (i >= arr.length - reveal) {
                str.append(arr[i]);
            } else {
                str.append("-");
            }

        }
        return str.toString();
    }
}

生成的随机值：11

要猜测的二进制数：

1011

显示给用户：

----

第一次错误猜测后显示：

----0

第二次错误猜测后显示：

----00

第三次错误猜测后显示：

--000

第四次错误猜测后显示：

--0000

第五次错误猜测后显示：

--10000

第六次错误猜测后显示：

-010000

第七次错误猜测后显示：

1010000

我的代码：

Scanner scan = new Scanner(System.in);

        // Generating a random number between 1-16
        int randomNum = (int) (Math.random() * 16 + 1);
        int original = randomNum;
        System.out.println("Random num generated: " + randomNum);

        // Converting the random number to a binary number
        System.out.print("Random number in binary: ");
        int[] binary = new int[8];
        int originalBinary = 0;
        int index = 0;
        int count = 0;

        while (randomNum > 0) {
            binary[index++] = randomNum % 2;
            randomNum /= 2;
        }
        for (int i = index - 1; i >= 0; i--) {
            count++;

            System.out.print(binary[i]);
            originalBinary = binary[i];
        }
        System.out.println("\n***********************************");

        // System.out.print("\nPlease enter a guess: ");
        int guess = scan.nextInt();
        int digitsToReveal = 0;

        while (guess != original && digitsToReveal != binary.length) {

            System.out.print("\nPlease enter another number: ");
            guess = scan.nextInt();
            System.out.println(reveal(binary, digitsToReveal++));

        }

    }

    public static String reveal(int[] arr, int reveal) {
        StringBuilder str = new StringBuilder();
        for (int i = 1; i < arr.length; i++) {
            if (i >= arr.length - reveal) {
                str.append(arr[i]);
            } else {
                str.append("-");
            }

        }
        return str.toString();
    }
}

Scanner scan=新的扫描仪（System.in）；
//生成1-16之间的随机数
int randomNum=（int）（Math.random（）*16+1）；
int-original=randomNum；
System.out.println（“生成的随机数：+randomNum”）；
//将随机数转换为二进制数
系统输出打印（“二进制随机数：”；
int[]二进制=新的int[8]；
int originalBinary=0；
int指数=0；
整数计数=0；
while（randomNum>0）{
二进制[index++]=randomNum%2；
randomNum/=2；
}
对于（int i=index-1；i>=0；i--）{
计数++；
系统输出打印（二进制[i]）；
原始二进制=二进制[i]；
}
System.out.println（“\n*******************************************”）；
//System.out.print（“\n请输入猜测：”）；
int guess=scan.nextInt（）；
int digitsToReveal=0；
while（guess！=original&&digitsToReveal！=binary.length）{
System.out.print（“\n请输入另一个数字：”）；
guess=scan.nextInt（）；
System.out.println（discover（二进制，digitsToReveal++）；
}
}
公共静态字符串分隔符（int[]arr，int分隔符）{
StringBuilder str=新的StringBuilder（）；
对于（int i=1；i=arr.length-分隔缝）{
str.append（arr[i]）；
}否则{
str.append（“-”）；
}
}
return str.toString（）；
}
}

请注意，

二进制

数组按与打印相反的顺序存储整数位。也就是说，

二进制[0]

是最高有效位。例如，对于数字13（二进制1101），数组如下所示：

[1, 0, 1, 1, 0, 0, 0, 0]

打印整数的二进制版本时，可以正确地反向读取数组：

for (int i = index - 1; i >= 0; i--) {
    System.out.print(binary[i]);
}

因此，在

显示

中，您也应该反向读取数组：

public static String reveal(int[] arr, int reveal) {
    StringBuilder str = new StringBuilder();
    for (int i = 1; i < arr.length; i++) {
        if (i >= arr.length - reveal) {
            // note the change here:
            str.append(arr[arr.length - i - 1]);
        } else {
            str.append("-");
        }

    }
    return str.toString();
}

公共静态字符串显示（int[]arr，int-reveal）{
StringBuilder str=新的StringBuilder（）；
对于（int i=1；i=arr.length-分隔缝）{
//请注意此处的更改：
str.append（arr[arr.length-i-1]）；
}否则{
str.append（“-”）；
}
}
return str.toString（）；
}

您应该访问

arr.length-i-1

，而不是

i

另外，请注意，长度为5的数组可以充分存储1到16之间的数字，不需要使用长度为8的数组

---

---

我不知道这是否是有意的，但您没有透露最重要的位。

因为您将二进制数按与

二进制

数组变量相反的顺序存储

编号：

11

二进制：

1011

数组：

[1,1,0,1,0,0,0]

我通过在while循环中使用

7

和

index--

启动

index

变量，最后将其存储到二进制数组的第一个元素来解决这个问题。我编辑

digitToReveals=1

并将

reveal

调用方法移动到while循环的第一行，这将显示自第一次错误猜测以来的数字

import java.util.Scanner；//导入Scanner类
公共类二进制文件{
公共静态void main（字符串[]args）{
扫描仪扫描=新扫描仪（System.in）；
//生成1-16之间的随机数
int randomNum=（int）（Math.random（）*16+1）；
int-original=randomNum；
System.out.println（“生成的随机数：+randomNum”）；
//将随机数转换为二进制数
系统输出打印（“二进制随机数：”；
int[]二进制=新的int[8]；
int指数=7；
while（randomNum>0）{
二进制[索引--]=随机数%2；
randomNum/=2；
}
对于（int i=index+1；i<8；i++）{
系统输出打印（二进制[i]）；
}
System.out.println（“\n*******************************************”）；
System.out.print（“\n请输入猜测：”）；
int guess=scan.nextInt（）；
int digitsToReveal=1；
while（guess！=original&&digitsToReveal！=binary.length）{
System.out.println（discover（二进制，digitsToReveal++）；
System.out.print（“\n请输入另一个数字：”）；
guess=scan.nextInt（）；
}
if（guess==原始）System.out.print（“\nYes！”）；
else系统输出打印（“\n不幸运：（”）；
}
公共静态字符串分隔符（int[]arr，int分隔符）{