金字塔在java中

Question

我想在java中 打印金字塔的數字看起來是這樣的： -

    9 
        8 9 8 
       7 8 9 8 7 
       6 7 8 9 8 7 6 
      5 6 7 8 9 8 7 6 5 
      4 5 6 7 8 9 8 7 6 5 4 
     3 4 5 6 7 8 9 8 7 6 5 4 3 
     2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 
    1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 

我一直在尋找辦法來解決這個在互聯網上，我碰到這個偶然發現：

class Pyramid { 

    public static void main(String[] args) { 

    int x = 7; 

    for (int i = 1; i <= x; i++) { 

     for (int j = 1; j <= x - i; j++) 
      System.out.print(" "); 

     for (int k = i; k >= 1; k--) 
      System.out.print((k >= 10) ?+ k : " " + k); 

     for (int k = 2; k <=i; k++) 
      System.out.print((k >= 10) ?+ k : " " + k); 
     System.out.println(); 
    } 
    } 
} 

任何人都可以請幫我理解這一點嗎？ 在這裏，我已經想出了： - 外部循環增加到7，同時內部j循環增加到x - i 這是第一次迭代的外部循環6，然後5 ...和所以...... 所以基本上金字塔的左側只是一個倒空的空白三角形。

我有麻煩搞清楚什麼是在其他兩個嵌套循環發生和奇怪的看着若 - 否則打印報表

Answer 1

內部的部件讓我們通過這一步一步來。 正如你已經想到的那樣，x是代表金字塔高度的變量。

那麼，你也正確地發現，第一循環創建數字

第二圈，現在會寫數字的左半部分的當前行的縮進，但如果我這樣做是正確，它將從最高的數字開始並遞減，然後第三個循環會再次遞增數字，創建一個與您正在尋找的金字塔略有不同的金字塔。

現在，您稱之爲奇怪的if-else部分是三元條件運算符，並且它們在此代碼中履行的唯一目的是在金字塔包含數字> =時修復數字間距， 10通過省略號碼的前導空格。 :)

Answer 2

這是作業。你會自己去學習，而不是盲目地抄襲別人的作品。

開始具有類似，但更簡單的問題：

* 
    *** 
    ***** 
******* 

您可以打印三角形嗎？編寫你自己的代碼，並測試它是否正常工作。

現在修改代碼以打印用數字代替星號：

1 
    123 
    12345 
1234567 

您可以打印三角形嗎？編寫你自己的代碼，並測試它是否正常工作。

現在再次修改您的代碼來解決最終的問題。通過首先解決類似但更容易的問題來解決難題通常更容易。通過重用代碼，您可以從解決方案構建一個簡單的問題，解決更復雜的問題。

通過一切手段合併來自您找到的代碼的想法和技巧，但不要盲目複製它。使用他們的代碼中的優點，編寫自己的自己的代碼。

Answer 3

在這裏我們去

public class Pyramid { 
    public static void main(String[] args) { 

     int[] arry = new int[10]; 
     for (int i = 1; i <= 9; i++) 
      arry[i] = i; 
     int index = 0; 
     for (int i = 9; i > 0; i--) { 
      int loop = 1, tempLoop = 0; 

      for (int k = 0; k < 9; k++) { 
       if (k < (9 - index)) 
        System.out.print(" "); 
       else 
        System.out.print(arry[k] + " "); 
      } 

      for (int k = 9; k >= i && (tempLoop++) <= index; k--){ 
       System.out.print(arry[k] + " "); 
      } 
      index++; 
      System.out.println(); 
     } 
    } 
} 

Answer 4

由於任務看在現實中很複雜很容易。開始時可能看起來很難。因爲你在考慮最終結果而不是關於指導結果的路線。

要改變我們可以使用舊的編碼規則，divide and conquer。本書告訴我們，在複雜問題中找到相似的東西，可以將主要問題簡化爲我們能夠執行的簡單任務。換句話說，我們在很少人看來，解決了我們的大問題，這可以很容易地解決，最後我們將小結果付諸大局。

所以，最好從你的問題開始。

問題1：如何打印pytamind數字？

因爲我們不知道，所以讓我們專注於別的東西。

爲了提高我們的觀察，我們可以添加一些細節bacground

1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 
0 _ _ _ _ _ _ _ _ 9 _ _ _ _ _ _ _ _ 
1 _ _ _ _ _ _ _ 8 9 8 _ _ _ _ _ _ _ 
2 _ _ _ _ _ _ 7 8 9 8 7 _ _ _ _ _ _ 
3 _ _ _ _ _ 6 7 8 9 8 7 6 _ _ _ _ _ 
4 _ _ _ _ 5 6 7 8 9 8 7 6 5 _ _ _ _ 
5 _ _ _ 4 5 6 7 8 9 8 7 6 5 4 _ _ _ 
6 _ _ 3 4 5 6 7 8 9 8 7 6 5 4 3 _ _ 
7 _ 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 _ 
8 1 2 3 4 5 6 7 8 9 8 7 6 5 4 3 2 1 

現在是觀察的時間。

從這個觀察我們可以想出以下想法。

Idead：金字塔形是兩個三角形的結構。

結論：寫一半這種金字塔比較容易。所以讓我們回到酸味問題。 Q2：如何編寫看起來像三角形的序列號？

這真的很簡單，我們只需要兩個循環，第一個循環將負責行的另一列。

for(int column = 1; column <= 9; column++) { 
for(int row = 1; row <= 9; row++) { 
    if(column ## row) { // Observe what will happen if we use == or <= or > or <> 
     System.out.print(row); 
    } else { 
    System.out.print(" "); 
    } 
} 
System.out.println(' '); 

}

當你完成你的第一個任務，你將能夠打印在screean數字squers，triagles，線。

所以，當我們知道如何打印一個三角形是這樣的：

r 

c 1 2 3 4 5 6 7 8 9 
    1 _ _ _ _ _ _ _ _ 9 
    2 _ _ _ _ _ _ _ 8 9 
    3 _ _ _ _ _ _ 7 8 9 
    4 _ _ _ _ _ 6 7 8 9 
    5 _ _ _ _ 5 6 7 8 9 
    6 _ _ _ 4 5 6 7 8 9 
    7 _ _ 3 4 5 6 7 8 9 
    8 _ 2 3 4 5 6 7 8 9 
    9 1 2 3 4 5 6 7 8 9 

我們應該修改你的代碼，會更適合，通常在計算機世界運營從零不是一個開始。

r 

c 0 1 2 3 4 5 6 7 8 
    0 _ _ _ _ _ _ _ _ 9 
    1 _ _ _ _ _ _ _ 8 9 
    2 _ _ _ _ _ _ 7 8 9 
    3 _ _ _ _ _ 6 7 8 9 
    4 _ _ _ _ 5 6 7 8 9 
    5 _ _ _ 4 5 6 7 8 9 
    6 _ _ 3 4 5 6 7 8 9 
    7 _ 2 3 4 5 6 7 8 9 
    8 1 2 3 4 5 6 7 8 9 

當你成功了，我們暫時停下來想一想。

爲什麼我們不得不爲每一行重複所有這些操作？如果我們可以放置一些有價值的東西，那麼我們不必再考慮和計算它們，只需要將整個結果寫入屏幕即可。

這個問題的解決方案是數組和應用程序的概念，被稱爲dynamic programing。在這種方法中，我們試圖記住一些將用於未來操作的東西。

因此，蠕蟲只需將數字分配給數組而不是打印它們即可。

[ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [9] 
[ ] [ ] [ ] [ ] [ ] [ ] [ ] [8] [9] 
[ ] [ ] [ ] [ ] [ ] [ ] [7] [8] [9] 
[ ] [ ] [ ] [ ] [ ] [6] [7] [8] [9] 
[ ] [ ] [ ] [ ] [5] [6] [7] [8] [9] 
[ ] [ ] [ ] [4] [5] [6] [7] [8] [9] 
[ ] [ ] [3] [4] [5] [6] [7] [8] [9] 
[ ] [2] [3] [4] [5] [6] [7] [8] [9] 
[1] [2] [3] [4] [5] [6] [7] [8] [9] 

在，你應該用代碼想出了這樣

int[] array = new int[9]; 

    for(int column = array.length; column > 0 ; column--) { 
     for(int row = 0; row <= array.length; row++) { 
      if(column == row) { 
       array[row-1] = column; 
      } 
     } 
     System.out.println(Arrays.toString(array)); 
    } 

那麼，什麼是從該代碼清楚，是我們每一個步驟中使用只設定一個值。這是呈現如下

9 [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [9] -Step one we put nine 
    8 [ ] [ ] [ ] [ ] [ ] [ ] [ ] [8] [ ] -Step two we put eight 
    7 [ ] [ ] [ ] [ ] [ ] [ ] [7] [ ] [ ] 
    6 [ ] [ ] [ ] [ ] [ ] [6] [ ] [ ] [ ] 
    5 [ ] [ ] [ ] [ ] [5] [ ] [ ] [ ] [ ] 
    4 [ ] [ ] [ ] [4] [ ] [ ] [ ] [ ] [ ] 
    3 [ ] [ ] [3] [ ] [ ] [ ] [ ] [ ] [ ] 
    2 [ ] [2] [ ] [ ] [ ] [ ] [ ] [ ] [ ] 
    1 [1] [ ] [ ] [ ] [ ] [ ] [ ] [ ] [ ] 

經過九個步驟，我們將用數字填充整個陣列。

我們仍然缺少的是屏幕上的結果。爲此，我們應該在每一步中打印整個數組。首先我們應該從左到右打印，然後從開始打印。

而且是些魔術的代碼看起來應該是這樣

public static void pyramide(int levels) { 

    int[] tab = new int[levels]; 

    for(int row = tab.length; row > 0; row--) { 

     tab[row-1] = row; 

     //Print left 
     for(int i=0; i < tab.length; i++) { 
      if(tab[i] != 0) { 
       System.out.print(tab[i]); 
      } else { 
       System.out.print(' '); 
      } 
     } 
     //Print right 
     for(int i= tab.length-2; i >= row - 1; i--) { 
      if(tab[i] != 0) { 
       System.out.print(tab[i]); 
      } 
     } 

     System.out.println(""); 

    } 

} 

Answer 5

在這裏，在另外兩個嵌套的循環：

for (int k = i; k >= 1; k--) 
System.out.print((k >= 10) ?+ k : " " + k); 

for (int k = 2; k <=i; k++) 
System.out.print((k >= 10) ?+ k : " " + k); 

如果條件k>=10爲真，則k將顯示與價值如果它是假的，那麼它將顯示空間k的值。

Answer 6

public class PrintInterviewPyramid 
{ 
    public static void main(String[] args) 
    { 
      int n=8; 
      for(int i=1;i<n;i=i+2) 
      { 
       for(int j=1;j<i+1;j++) 
       { 
       System.out.println(" "+j);    
       }    
      } 
     System.out.println(""); 
    } 
    } 

Answer 7

for (int i = length - 1; i >= 1; i--) 
    { 

     String front = ""; 
     String back = ""; 
     int space = (length - i) - 1; 
     while (space >= 0) { 
      System.out.print(" "); 
      space--; 
     } 
     for (int j = i; j != 0; j--) { 
      front = j + front; 
      if (j != i) { 
       back = back + j; 
      } 
     } 
     System.out.println(front + back); 
    } 

Answer 8

認爲兩種模式。

第一種圖案，左右打印。

第二個圖案，打印每一行並檢查與打印起始點的間距。

public class NumberPyraimd { 

public static void main(String[] args){ 


    int part = 2; 
    int stage = 5; // set tree stage. 


    if (part == 2){ 
     int cnt = 0; 
     // thinking two part. 
     for (int i = stage; i > 0; i--){ 
      for (int j = 1; j <= stage; j++){ 
       if (stage - j <= cnt){ 
        System.out.print(j+" "); 
       }else{ 
        System.out.print(" "); 
       } 

      } 

      for (int k = stage; k >0 ; k--){ 
       if (k != stage){ 
       if (stage- cnt <= k){ 
        System.out.print(k+" "); 
       }else{ 
        System.out.print(" "); 
       } 
       } 

      } 

      System.out.println(""); 
      cnt++; 
     } 
    }else if (part == 1){// think whole lines. 
     int gap = 0; 

     for (int j = 0; j < stage; j++){ 
      for (int i = 1;i<=stage*2;i++){ 
       if (Math.abs(i-stage) <= gap){ 
        System.out.print(stage-gap+" "); 
       }else 
        System.out.print(" "); 

      } 
      System.out.println(""); 
      gap++; 
     } 
    } 
} 
} 

Answer 9

將此視爲面試的潛在問題，並希望嘗試使用Java 8的流方法實現它。解決方案如下：

import java.util.ArrayList; 
import java.util.List; 
import java.util.stream.IntStream; 

public class App { 
    public static void main(String[] args) { 
     int min = 1; 
     int max = 9; 

     List<List<String>> pyramid = new ArrayList<>(); 

     IntStream.iterate(max, i -> i - 1).limit(max) 
       .forEach(s -> { 
        List<String> pyramidRow = new ArrayList<>(); 
        IntStream.rangeClosed(min, max) 
          .forEach(j -> { 
           if (j < s) pyramidRow.add(" "); 
           else pyramidRow.add(String.valueOf(j)); 
          }); 
        IntStream.iterate(max - 1, i -> i - 1).limit(max-1) 
          .forEach(j -> { 
           if (j < s) pyramidRow.add(" "); 
           else pyramidRow.add(String.valueOf(j)); 
          }); 
        pyramid.add(pyramidRow); 
       }); 

     pyramid.stream() 
       .forEach(pyra -> { 
        pyra.forEach(System.out::print); 
        System.out.println(); 
      }); 
    } 
}