半金字塔倒矩阵模式

Question

如何用这样的循环创建一个倒置的半金字塔？

预期输出

5 5 5 5 5 4 3 2 1
5 4 4 4 4 3 2 1
5 4 3 3 3 2 1
5 4 3 2 2 1
5 4 3 2 1

我的代码像这样

public static void main(String[] args) {

        int N = 5;
        for (int i = 1; i <= N; i++)
        {
            for (int j = 1; j <= N; j++)
            {
                int min = i < j ? i : j;
                System.out.print(N - min + 1 + " ");
            }
            for (int k = N-1; k >=1; k --) {
                System.out.print(k + " ");
            }
            System.out.println();
        }

}

和我的输出像这样

5 5 5 5 5 4 3 2 1
5 4 4 4 4 4 3 2 1
5 4 3 3 3 4 3 2 1
5 4 3 2 2 4 3 2 1
5 4 3 2 1 4 3 2 1

Answer 1

您的嵌套循环需要 3 层：

遍历行：

5 5 5 5 5 4 3 2 1  ┐
5 4 4 4 4 3 2 1    ┤
5 4 3 3 3 2 1      ┤  Loop 1
5 4 3 2 2 1        ┤
5 4 3 2 1          ┘

循环数字值：

    ┌─────┬─┬─┬─┐     Loop 2
┌───┴───┐
5 5 5 5 5 4 3 2 1
5 4 4 4 4 3 2 1
5 4 3 3 3 2 1
5 4 3 2 2 1
5 4 3 2 1
└─┴─┴─┴─┘             Loop 2

遍历数字值的重复：

    ┌─────...
┌─┬─┼─┬─┐             Loop 3
5 5 5 5 5 4 3 2 1
5 4 4 4 4 3 2 1
5 4 3 3 3 2 1
5 4 3 2 2 1
5 4 3 2 1

祝你编码顺利，因为它看起来像是你需要完成的作业。

因为我不能单独离开这样一个简单的挑战，这里有一个解决方案。我添加了逻辑以便它可以处理大于 9 的金字塔大小，然后压缩代码以使其模糊一点。

static void printHalfPyramidInverted(int n) {
    String f, fmt = " %" + Integer.toString(n).length() + "d";
    for (int k, j, i = n; i > 0; i--, System.out.println())
        for (f = fmt.substring(1), j = n; j > 0; j--)
            for (k = (i == j ? j : 1); k > 0; k--, f = fmt)
                System.out.printf(f, j);
}

输出（尺寸 5）

5 5 5 5 5 4 3 2 1
5 4 4 4 4 3 2 1
5 4 3 3 3 2 1
5 4 3 2 2 1
5 4 3 2 1

输出（尺寸 9）

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

输出（尺寸 15）

15 15 15 15 15 15 15 15 15 15 15 15 15 15 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1
15 14 14 14 14 14 14 14 14 14 14 14 14 14 14 13 12 11 10  9  8  7  6  5  4  3  2  1
15 14 13 13 13 13 13 13 13 13 13 13 13 13 13 12 11 10  9  8  7  6  5  4  3  2  1
15 14 13 12 12 12 12 12 12 12 12 12 12 12 12 11 10  9  8  7  6  5  4  3  2  1
15 14 13 12 11 11 11 11 11 11 11 11 11 11 11 10  9  8  7  6  5  4  3  2  1
15 14 13 12 11 10 10 10 10 10 10 10 10 10 10  9  8  7  6  5  4  3  2  1
15 14 13 12 11 10  9  9  9  9  9  9  9  9  9  8  7  6  5  4  3  2  1
15 14 13 12 11 10  9  8  8  8  8  8  8  8  8  7  6  5  4  3  2  1
15 14 13 12 11 10  9  8  7  7  7  7  7  7  7  6  5  4  3  2  1
15 14 13 12 11 10  9  8  7  6  6  6  6  6  6  5  4  3  2  1
15 14 13 12 11 10  9  8  7  6  5  5  5  5  5  4  3  2  1
15 14 13 12 11 10  9  8  7  6  5  4  4  4  4  3  2  1
15 14 13 12 11 10  9  8  7  6  5  4  3  3  3  2  1
15 14 13 12 11 10  9  8  7  6  5  4  3  2  2  1
15 14 13 12 11 10  9  8  7  6  5  4  3  2  1

Answer 2

您可以从底部开始构造并注意中间是如何变化的（在 i 次添加 i）。
每行都是从右到左组装的。（适当调整）最后）
使用额外的数据结构可以使一些任务更容易。

public class TestPyramid {

    public static void main(String[] args) {
         int N = 6;
         int next = N;
         List<String> list = new ArrayList<String>();
         for(int i=1;i<=N;i++)
         {
            List<Integer> line=new ArrayList<Integer>();
            for(int j=1;j<=N;j++)
            {
                //middle
                if(next-N+2==j)
                {
                    for(int k=1;k<next-N+1;k++)
                    {
                        line.add(i);
                    }
                }
                
                line.add(j);
            }   
            if(i==N)
            {
                for(int k=1;k<next-N+1;k++)
                {
                    line.add(i);
                }
            }
            
            next++;
            
            String adaptedLine = line.stream().map(t->String.valueOf(t)).collect(Collectors.joining(" "));
            StringBuilder sb = new StringBuilder(adaptedLine);
            list.add(sb.reverse().toString());
            
         }
        Collections.reverse(list);
        list.forEach(System.out::println);
    }
}

输出：

6 6 6 6 6 6 5 4 3 2 1
6 5 5 5 5 5 4 3 2 1
6 5 4 4 4 4 3 2 1
6 5 4 3 3 3 2 1
6 5 4 3 2 2 1
6 5 4 3 2 1

注意：If N>=10然后反向行应该适当调整，因为10在当前版本01中是

String adaptedLine = line.stream().
                          sorted(Collections.reverseOrder()).                         
                          map(t>String.valueOf(t)).
                          collect(Collectors.joining(" "));

半金字塔倒矩阵模式

half pyramid inverted with matrix pattern

java

for-loop

nested-loops

预期输出