Как нарисовать лестницу на Яве?
Я пытался сделать это на Java. И рисовать это сложно, по крайней мере, для меня.
В1 Напишите простую программу на 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("+---+");
}
}
И вот что он делает.
+---+
| | |
+---+---+
| | |
+---+---+---+
| | |
+---+---+---+---+
| | |
+---+---+---+---+---+
| | |
+---++---++---++---++---+
Может ли кто-нибудь помочь мне и помочь мне с моим кодом? Я бы хотел, чтобы кто-нибудь сказал мне, что не так и что нужно изменить.
6 ответов
Решение
Это мое решение проблемы. Спасибо за загадку;)
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(" ");
}
}
Вы можете использовать
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);
+---+
| |
+---+---+
| | |
+---+---+---+
| | | |
+---+---+---+---+
| | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
Вы можете представить лестницу как двумерный массив нулей и таких единиц :
[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]
Тогда вы можете представить непустые ячейки этого массива в виде почти квадрата , состоящего из двух строк: строки с верхней границей и строки с левой границей . Пустые ячейки - это всего лишь два ряда пространств одинаковой длины.
+---
|
Затем вы можете объединить ячейки каждой строки в одну строку и выводить их построчно. Результат состоит из двух частей: строк двухмерного массива с правой границей и строки нижней границы :
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-массива?
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("");
}
}
Я создал этот код, чтобы проиллюстрировать, как решать проблему и разбирать ее шаг за шагом, пока вы не сможете решить каждый шаг.
Вот результаты одного из многих моих тестов.
+---+
| |
+---+---+
| | |
+---+---+---+
| | | |
+---+---+---+---+
| | | | |
+---+---+---+---+---+
| | | | | |
+---+---+---+---+---+
Первое, что я сделал, - это создал метод создания пустого сегмента. Я использовал класс 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;
}
}
Еще один ответ, чтобы вы могли увидеть множество способов решения этой проблемы. Здесь используется единственный цикл рисования и избегается использование констант:
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, "+---", "| ", " ");
}