将嵌套循环将复合数字放在列中

Question

我必须编写一个程序来打印出所有小于100的合数。我必须使用嵌套循环来完成这个程序。此外，这些值必须显示在每列包含 10 个数字的表中。

我已经尝试这个程序一个多星期了，我只是完全迷失了，我可以对此有所帮助吗？

我做了复合数字部分，但是您如何将数字放入每列中有 10 个数字的列中？这是代码：

import java.util.Scanner;
class SwitchStatements {
    public static void main(String[]Args) {
     for (int i = 0; i <= 100; i++) {
        for (int j = 2; j <= i/2; j++) {
            if (i % j == 0) {
               System.out.println(i);
               break;
            }
         }
      }
   }
}

Answer 1

你的意思是每行 10 个数字（即总共 10 列），还是每列 10 个数字？

假设你的意思是输出中的"表"大致看起来像这样（在这个例子中有 5 列）：

1  2  3  4  5 
11 12 13 14 15

那么我认为您要做的是跟踪您在这一行上打印了多少个数字，并且仅在打印了 10 个数字时才使用 System.out.println，否则System.out.print：

int numbersPrinted = 0;
for (int i = 0; i <= 100; i++) {
    for (int j = 2; j <= i/2; j++) {
        if (i % j == 0) {
            if (numbersPrinted < 9) {
                System.out.print(i + " ");
                numbersPrinted++;
            } else {
                System.out.println(i);
                numbersPrinted = 0;
            }
            break;
         }
     }
}

如果您希望数字整齐地排列，如果 i 小于 10（因此只有一个数字），则可以添加两个空格而不是一个空格。

如果你的意思是你想要像这样的每列十个数字（在我的例子中再次使用 5）：

1  2
3  4
5  6
7  8
9  10

然后，您需要每行打印（数字数/每列 10 个数字）列，因此无法像示例中那样在嵌套循环中打印它们。相反，您需要将它们添加到 ArrayList 或类似内容中，稍后在单独的循环中打印它们：

ArrayList<int> numbersToPrint = new ArrayList<int>();
...
if (i % j == 0) {
    numbersToPrint.add(i);
    break;
}
...
int numbersPerRow = (numbersToPrint.size()/10);
int numbersPrinted = 0;
for (int i : numbersToPrint) {
    if (numbersPrinted < (numbersPerRow - 1)) {
...

其余部分与我上面的第一个例子相同。

Answer 2

如果您确实想要每列中有 10 个数字，请检查此代码。它可以用更少的周期来完成，但会更难理解。我们在这里所做的是收集所有要列出的合数。以奇怪的顺序填充该列表中的二维数组（不是像往常那样逐行填充，而是逐列）。然后按通常的顺序在第三个周期中打印。

    public static void main(String[] args) {
    List<Integer> compositeNumbers = new ArrayList<>();
    for (int i = 0; i <= 100; i++) {
        for (int j = 2; j <= i / 2; j++) {
            if (i % j == 0) {
                compositeNumbers.add(i);
                break;
            }
        }
    }
    int n = compositeNumbers.size();
    int numberOfRows = 10;
    int maxNumberOfColumns = (n / numberOfRows) + 1;
    int[][] numbers = new int[numberOfRows][maxNumberOfColumns];
    for (int j = 0; j < maxNumberOfColumns; j++) {
        for (int i = 0; i < numberOfRows; i++) {
            int index = i + j * numberOfRows;
            if (index < n) {
                numbers[i][j] = compositeNumbers.get(index);
            }
        }
    }
    for (int i = 0; i < numberOfRows; i++) {
        for (int j = 0; j < maxNumberOfColumns; j++) {
            if (i + j * numberOfRows < n)
                System.out.print(String.format("% 3d", numbers[i][j]));
        }
        System.out.println();
    }
}

你会得到漂亮的输出：

  4 20 33 46 58 72 85 96
  6 21 34 48 60 74 86 98
  8 22 35 49 62 75 87 99
  9 24 36 50 63 76 88 100
 10 25 38 51 64 77 90
 12 26 39 52 65 78 91
 14 27 40 54 66 80 92
 15 28 42 55 68 81 93
 16 30 44 56 69 82 94
 18 32 45 57 70 84 95

Answer 3

已编辑以修复复合计算方法。

假设您正在寻找类似这样的东西：

 4    20    33    46    58    72    85    96
 6    21    34    48    60    74    86    98
 8    22    35    49    62    75    87    99
 9    24    36    50    63    76    88   100
10    25    38    51    64    77    90
12    26    39    52    65    78    91
14    27    40    54    66    80    92
15    28    42    55    68    81    93
16    30    44    56    69    82    94
18    32    45    57    70    84    95

第一步是将问题分为两部分。

1. 生成从 4 到 100 的所有合数。
2. 在列中显示所有合数。

你主要做了第一部分。 您的 for 循环配置中存在一些错误。

您可以将所有合数保存在列表<整数>中。

使用以下行计算列数：

    int columns = (compositeNumbers.size() + columnLength - 1)
            / columnLength;

由于您必须创建一整行才能打印它，因此在位置 0 处获取复合整数，然后在位置 10 处获取复合整数（假设每列 10 个数字）。 然后是位置 20 处的复合整数，依此类推，直到创建了整行。

最后几行的最后一列中可能没有数字。 在创建显示线时，您必须考虑到这一点。

这是将所有这些放在一起的代码。 计算复合数方法计算合数。 方法在列中显示复合数。

了解方法名称如何告诉您它们的作用。

package com.ggl.testing;
import java.util.ArrayList;
import java.util.List;
public class CompositeOutput {
    public static void main(String[] Args) {
        CompositeOutput compositeOutput = new CompositeOutput();
        List<Integer> compositeNumbers = compositeOutput
                .calculateCompositeNumbers();
        System.out.println(compositeOutput.displayCompositeNumbers(
                compositeNumbers, 10));
    }
    private List<Integer> calculateCompositeNumbers() {
        List<Integer> compositeNumbers = new ArrayList<>();
        for (int i = 4; i <= 100; i++) {
            boolean found = false;
            int maximum = Math.min(i / 2, 10);
            for (int j = 2; j <= maximum && !found; j++) {
                if (i % j == 0) {
                    compositeNumbers.add(Integer.valueOf(i));
                    found = true;
                }
            }
        }
        return compositeNumbers;
    }
    private String displayCompositeNumbers(List<Integer> compositeNumbers,
            int columnLength) {
        String lineSeparator = System.getProperty("line.separator");
        StringBuilder builder = new StringBuilder();
        int columns = (compositeNumbers.size() + columnLength - 1)
                / columnLength;
        for (int row = 0; row < columnLength; row++) {
            int tempIndex = row;
            for (int column = 0; column < columns; column++) {
                if (tempIndex < compositeNumbers.size()) {
                    int number = compositeNumbers.get(tempIndex);
                    builder.append(String.format("%6d", number));
                }
                tempIndex += columnLength;
            }
            builder.append(lineSeparator);
        }
        return builder.toString();
    }
}