如何用Java绘制ASCII楼梯?

Question

我一直在尝试用Java完成这项工作。这是一个复杂的东西，至少对我来说。

Q1编写一个简单的Java程序，打印如下所示的楼梯或图形:

+---+
|   |
+---+---+
|   |   |
+---+---+---+
|   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

我已经想出了一个解决方案，但它还没有完成一半。这是我想出来的代码

public class DrawStairs {
public static final int HEIGHT = 5;
public static final int TOTALHEIGHT = HEIGHT * 5;
public static void main(String[] args) {
//Main Outer Loop
for (int i = 1; i <= HEIGHT; i++) {
//Loop for the spaces before, then print the head
for (int j = 1; j <= TOTALHEIGHT + (i * (-5)); j++) {
System.out.print(" ");
}
printTop();
//Loop for spaces after, then print asterisk
for (int j = 1; j <= (i - 1); j++) {
System.out.print("---+");
}
System.out.println(" ");
//Loop for the spaces before, then print the body
for (int j = 1; j <= TOTALHEIGHT + (i * (-5)); j++) {
System.out.print(" ");
}
printMiddle();
//Loop for spaces after, then print asterisk
for (int j = 1; j <= (i - 1) * 5; j++) {
System.out.print(" ");
}
//Loop for spaces before, then print the legs
for (int j = 1; j <= TOTALHEIGHT + (i * (-5)); j++) {
System.out.print(" ");
}
printBottom();
//Loop for spaces after, then print asterisk
for (int j = HEIGHT; j <= 0; --j) {
System.out.print("---+");
}
System.out.println("|");
}
// for loop for printing the floor of asterisks
for (int i = 1; i <= HEIGHT; i++) {
System.out.print("+---+");
}
}
public static void printTop() {
System.out.print("+---+");
}
public static void printMiddle() {
System.out.print("|   |");
}
public static void printBottom() {
// System.out.print("+---+");
}
}

这就是它的作用。

+---+ 
|   |                    |
+---+---+ 
|   |                    |
+---+---+---+ 
|   |                    |
+---+---+---+---+ 
|   |                    |
+---+---+---+---+---+ 
|   |                    |
+---++---++---++---++---+

谁能帮助我和指导我与我的代码?我想有人能告诉我哪里出了问题，哪里需要改进。

Answer 1

这是我对这个问题的解决方案。谢谢你的难题;)

public class Staircase {
public static final int SIZE = 5;
public static final int STAIR_WIDTH = 5;
public static final String TREAD = "-";
public static final String RISER = "|";
public static final String NOSING = "+";
public static final String HOLLOW = " ";
public static void main(String[] args)
{
StringBuilder step = new StringBuilder();
for (int i = 0; i < (STAIR_WIDTH - 2); ++i) { step.append(TREAD); }
StringBuilder hollow = new StringBuilder();
for (int i = 0; i < (STAIR_WIDTH - 2); ++i) { hollow.append(HOLLOW); }
StringBuilder tread = new StringBuilder();
for (int i = 0; i < SIZE; ++i) { tread.append(NOSING + step); }
tread.append(NOSING);
StringBuilder riser = new StringBuilder();
for (int i = 0; i < SIZE; ++i) { riser.append(RISER + hollow); }
riser.append(RISER);
for (int i = 0; i < SIZE; ++i) {
int offset = tread.length() - (((STAIR_WIDTH - 1) * i) + STAIR_WIDTH);
printSpaces(offset);
System.out.println(tread.substring(offset));
printSpaces(offset);
System.out.println(riser.substring(offset));
}
System.out.println(tread);
}
public static void printSpaces(int count)
{
for (int i = 0; i < count; ++i)
System.out.print(" ");
}
}

Answer 2

public class Staircase {
// You can change the height to any number and check
public static final int HEIGHT = 5;
public static void main(String[] args) {
Staircase stairs = new Staircase();
for (int j = 0; j < HEIGHT; j++) {
stairs.printSpace(j);
stairs.printTop(j);
stairs.printSpace(j);
stairs.printMiddle(j);
}
stairs.printTop(HEIGHT-1); // added for bottom line stairs 
}
public void printSpace(int j) {
for (int i = j; i < HEIGHT - 1; i++) {
System.out.print("   ");
}
}
public void printTop(int j) {
for (int k = 0; k <= j; k++) {
System.out.print("+--");
}
System.out.print("+");
System.out.println("");
}
public void printMiddle(int j) {
for (int k = 0; k <= j; k++) {
System.out.print("|  ");
}
System.out.print("|");
System.out.println("");
}
}

Answer 3

我创建这段代码是为了说明如何处理一个问题并一步一步地分解它，直到您可以解决每一步。

这是我众多测试结果中的一个。

+---+
|   |
+---+---+
|   |   |
+---+---+---+
|   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

我做的第一件事是创建一个方法来生成空白段。我使用StringBuilder类使构建线段和连接线段变得更容易。

一旦我让它工作，我创建方法来创建一个台阶(着陆)和一个托梁。

接下来，我创建了一个方法来创建一行输出。

最后，我创建了一个方法来创建整个楼梯。

是完整的可运行代码。它可能不是最有效的代码，但我希望它是最容易理解的代码之一。

public class Staircase {
public static void main(String[] args) {
Staircase sc = new Staircase();
System.out.println(sc.createStaircase(5));
}
public String createStaircase(int steps) {
StringBuilder builder = new StringBuilder();
int blankSteps = 0;
String step = createStepSegment();
String joist = createJoistSegment();
for (int i = 1; i <= steps; i++) {
blankSteps = Math.max(0, steps - i);
builder.append(createLine(step, steps, blankSteps));
builder.append(createLine(joist, steps, blankSteps));
}
builder.append(createLine(step, steps, blankSteps));
return builder.toString();
}
private StringBuilder createLine(String string, int steps, int blankSteps) {
StringBuilder builder = new StringBuilder();
int width = string.length() * blankSteps;
builder.append(createBlankSegment(width));
int boxSteps = steps - blankSteps;
for (int i = 0; i < boxSteps; i++) {
builder.append(string);
}
builder.append(string.charAt(0));
builder.append(System.lineSeparator());
return builder;
}
private String createStepSegment() {
return "+---";
}
private String createJoistSegment() {
return "|   ";
}
private StringBuilder createBlankSegment(int length) {
StringBuilder builder = new StringBuilder();
for (int i = 0; i < length; i++) {
builder.append(" ");
}
return builder;
}
}

Answer 4

又是一个答案，所以你可以看到很多很多解决这个问题的方法。这个使用了一个单一的绘制循环，并避免使用常量:

public static void drawStaircase(int steps, 
String stepTop, String stepLeft, String stepEmpty) {
String endOfTopStep = stepTop.substring(0,1);  // "+---" => "+"
String endOfMidStep = stepLeft.substring(0,1); // "|---" => "|"
for (int row=0; row<steps;row++) {
// paint a top-of-step row
for (int col=0; col<steps; col++) {
boolean isEmpty = row+col+1 < steps;
System.out.print(isEmpty ? stepEmpty : stepTop);
}
System.out.println(endOfTopStep);

// paint a middle-of-step row
for (int col=0; col<steps; col++) {
boolean isEmpty = row+col+1 < steps;
System.out.print(isEmpty ? stepEmpty : stepLeft);
}
System.out.println(endOfMidStep);
}
// paint bottom border
for (int col=0; col<steps; col++) {
System.out.print(stepTop);
}
System.out.println(endOfTopStep);
}
public static void main(String ...args) {
drawStaircase(4, "+---", "|   ", "    ");
}

Answer 5

您可以使用streams构建一个楼梯:

int m = 5;
String[] arr = IntStream.range(0, m).mapToObj(i -> {
String[] arr1 = new String[m];
String[] arr2 = new String[m];
String[] arr3 = new String[m];
IntStream.range(0, m).forEach(j -> {
if (i + j >= m - 1) {
if (j == m - 1) {
arr1[j] = "+---+";
arr2[j] = "|   |";
arr3[j] = "+---+";
} else {
arr1[j] = "+---";
arr2[j] = "|   ";
arr3[j] = "+---";
}
} else {
arr1[j] = "    ";
arr2[j] = "    ";
}
});
if (i == m - 1) {
return Stream.of(arr1, arr2, arr3);
} else {
return Stream.of(arr1, arr2);
}
}).flatMap(Function.identity())
.map(row -> String.join("", row))
.toArray(String[]::new);

// output
Arrays.stream(arr).forEach(System.out::println);

+---+
|   |
+---+---+
|   |   |
+---+---+---+
|   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+

Answer 6

你可以把一个楼梯表示成一个2d数组，里面有0和1，就像这样:

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

那么您可以将此数组的非空单元格表示为几乎正方形的，由两行组成:一行具有上边框，另一行具有左边框。空单元格就是两行长度相同的空格。

+---
|   

然后可以将每行的单元格连接成一行，并逐行输出。结果由两部分组成:2d数组的行，右边框和下边框行:

n=6
+---+
|   |
+---+---+
|   |   |
+---+---+---+
|   |   |   |
+---+---+---+---+
|   |   |   |   |
+---+---+---+---+---+
|   |   |   |   |   |
+---+---+---+---+---+---+
|   |   |   |   |   |   |
+---+---+---+---+---+---+

上网试试!

int n = 6;
// 2d array of zeros and ones
int[][] field = IntStream.range(0, n)
.mapToObj(i -> IntStream.range(0, n)
.map(j -> i + j < n - 1 ? 0 : 1)
.toArray())
.toArray(int[][]::new);

String[] staircase = Stream.concat(
// rows of a 2d array with a right border
Arrays.stream(field)
.map(row -> IntStream.range(0, n)
.mapToObj(i -> new String[]{
// upper row of square with an upper border
row[i] == 0 ? "    " : "+---"
// add a right border to the last element
+ (i < n - 1 ? "" : "+"),
// lower row of square with a left border
row[i] == 0 ? "    " : "|   "
// add a right border to the last element
+ (i < n - 1 ? "" : "|")})
// reduce Stream<String[]> to a single array String[]
.reduce((arr1, arr2) -> IntStream.range(0, 2)
.mapToObj(j -> arr1[j] + arr2[j])
.toArray(String[]::new))
.orElse(new String[]{}))
.flatMap(Arrays::stream),
// lower border row
Stream.of(IntStream.range(0, n)
.mapToObj(i -> "+---" + (i < n - 1 ? "" : "+"))
.collect(Collectors.joining())))
.toArray(String[]::new);

// output
System.out.println("n=" + n);
Arrays.stream(staircase).forEach(System.out::println);

---

^{参见:为2D数组制作边界的最佳方法?}