Java 如何在Nim游戏中反转输出？

所以我有NIM游戏程序。基本上，有四堆，两个玩家必须不断地从堆中取石头，直到其中一个输。现在我的堆在输出中是这样的

董事会：[1,2,3,4]

XXX | XXX代表一块石头，其中一列代表一堆 但我需要修改它，使它看起来像这样

                        XXX|XXX
                XXX|XXX XXX|XXX
        XXX|XXX XXX|XXX XXX|XXX
XXX|XXX XXX|XXX XXX|XXX XXX|XXX

这是我的密码

System.out.print("");
for(int i = 0; i < 4; i++) {
    //System.out.println(i);
    for(int j = 0; j < numbers[i];j++) {
        //System.out.println(j);
        System.out.print(" XXX|XXX ");
    }
    System.out.println(" ");
}

---

建议？

首先，将您的输出想象为一个虚拟的2D

字符串

数组，正如@gmdev在他的：

接下来，你需要找出你的最高桩有多高。在Java 8或更高版本中，有一种方法可以做到这一点：

int tallestPileLevel = Arrays.stream(numbers).max().getAsInt();

然后一次渲染一行虚拟二维阵列

外环向下延伸至堆积层，内环打印：

• 空气（

  ”

  ）-->如果

  i

  -th堆未达到当前

  水平

• 石头（

  “XXX | XXX”

  ）-->

下面是一个工作示例：

import java.util.*;
public class PrintNim {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4};
        int tallestPileLevel = Arrays.stream(numbers).max().getAsInt();
        
        String stone = " XXX|XXX ";
        String air   = "         ";
        
        for (int level = tallestPileLevel; level > 0; level--) {
            for(int i = 0; i < numbers.length; i++) {
                if (numbers[i] < level) {
                    System.out.print(air);
                }
                else {
                    System.out.print(stone);
                }
            }
            System.out.println();
        }
    }
}

import java.util.*；
公共类PrintNim{
公共静态void main（字符串[]args）{
int[]数字={1,2,3,4}；
int-tallestpillevel=Arrays.stream（numbers）.max（）.getAsInt（）；
String stone=“XXX | XXX”；
字符串air=“”；
对于（int级别=TallestPilleLevel；级别>0；级别--）{
for（int i=0；i

使用另一个

for

循环设置堆叠石头所需的空间。我做了一根和一石一样长的绳子。for循环将该字符串重复3次，然后重复两次，以此类推

我添加了代码注释来帮助解释

public static void main(String[] args) {
    System.out.print("");
    int[] numbers = {1, 2, 3, 4};
    int[] spaceNum = {3, 2, 1, 0}; //to stack the x's you need 3 spaces, then 2, etc.
    String spaces = "         "; //length of 1 stone, i.e " XXX|XXX "
    
    for(int i = 0; i < 4; i++) {
        //this loop uses sapceNum to decide how far to indent before the next loop writes the stones
        for(int k = spaceNum[i]; k > 0; k--) {
            System.out.print(spaces);
        }
        for(int j = 0; j < numbers[i]; j++) {
            System.out.print(" XXX|XXX ");
        }
        System.out.println(" ");
    }
}

---

也许你可以删除你的问题，因为它似乎是这个问题的重复。你假设最高的桩的高度总是4。如果桩的高度没有被排序呢？您将如何使用您的逻辑打印以下桩阵列：

[1,4,3,2]

？@JanezKuhar我刚刚看到这条评论，很抱歉延迟回复。我可以很容易地创建一个函数来反转

numbers

数组，并使用for循环将其写入

spaceNum

，但由于它只是为一个游戏设置一个棋盘，所以我认为这个数字是固定的。我不想把OP和多余的代码混为一谈。

import java.util.*;
public class PrintNim {
    public static void main(String[] args) {
        int[] numbers = {1, 2, 3, 4};
        int tallestPileLevel = Arrays.stream(numbers).max().getAsInt();
        
        String stone = " XXX|XXX ";
        String air   = "         ";
        
        for (int level = tallestPileLevel; level > 0; level--) {
            for(int i = 0; i < numbers.length; i++) {
                if (numbers[i] < level) {
                    System.out.print(air);
                }
                else {
                    System.out.print(stone);
                }
            }
            System.out.println();
        }
    }
}

public static void main(String[] args) {
    System.out.print("");
    int[] numbers = {1, 2, 3, 4};
    int[] spaceNum = {3, 2, 1, 0}; //to stack the x's you need 3 spaces, then 2, etc.
    String spaces = "         "; //length of 1 stone, i.e " XXX|XXX "
    
    for(int i = 0; i < 4; i++) {
        //this loop uses sapceNum to decide how far to indent before the next loop writes the stones
        for(int k = spaceNum[i]; k > 0; k--) {
            System.out.print(spaces);
        }
        for(int j = 0; j < numbers[i]; j++) {
            System.out.print(" XXX|XXX ");
        }
        System.out.println(" ");
    }
}

                            XXX|XXX  
                   XXX|XXX  XXX|XXX  
          XXX|XXX  XXX|XXX  XXX|XXX  
 XXX|XXX  XXX|XXX  XXX|XXX  XXX|XXX