Question

我正在学习Java，而且我对for循环的了解似乎很弱。

我应该致电printSquare(1, 5);。我想要的输出是：

我试过了：

public void printSquare(int min,int max){

    for(int i=min;i<=max;i++){
        for(int j=i;j<=max;j++){
          System.out.print(j);
        }
        System.out.println();
    }
}

给了我：

然后我尝试再插入2个循环，但它似乎不起作用。

如果你不给我完整的答案，我将不胜感激，因为这不是学习的方式。我更喜欢一些关于如何实现这一目标的线索。

Answer 1

您应该在i循环中添加一个嵌套循环，但在j循环之外。

应该是min到i-1。

Answer 2

尝试

public static void printSquare(int min, int max) {

    int x = max - min + 1;

    for (int i = min; i <= max; i++) {
        int counter = i;
        for (int j = 0; j < x; j++) {
            System.out.print(counter);
            counter = counter >= max ? min : counter + 1;
        }
        System.out.println();
    }
}

Answer 3

我认为你可以在i外面尝试第二个循环

public void printSquare(int min,int max){

    for(int i=min;i<=max;i++){

        for(int j=i;j<=max;j++){
          System.out.print(j);
        }
        for(int k=min;k<i;k++){
          System.out.print(k);
        }

    System.out.println();
  }
}

Answer 4

所以，似乎从8个答案中得到了解决方案。：）

我只想测试一下，看看哪个更快（我的）或3循环方法。

以下是代码（您无需以任何方式理解它），除了一种方法 - printSquare（int number），这是唯一与您相关的方法。其余的与卡尺框架有关 - 我用它来衡量一些结果。

import com.google.caliper.Param;
import com.google.caliper.Runner;
import com.google.caliper.SimpleBenchmark;



public class Measure extends SimpleBenchmark {
     public static void main(String[] args) {
         Runner.main(Measure.class, args);
     }

     @Param({"1"})
     private int mins;

     @Param({"4","7","9"})
     private int maxs;

    public void timePrintSquare3Loops(int reps){
        for(int i=0;i<reps;++i){
            printSquareTwo(mins, maxs);
        }
    }

    public void timePrintSquareMine(int reps){
        for(int i=0;i<reps;++i){
            printSquareOne(mins, maxs);
        }
    }

    public void timePrintSquareTwoLoops(int reps){
        for(int i=0;i<reps;++i){
            printSquareTwoLoops(mins, maxs);
        }
    }


    /**
     * the general solution with 3 loops
     */
     public void printSquareTwo(int min,int max){
         for(int i=min;i<=max;i++){
             for(int j=i;j<=max;j++) System.out.print(j);
             for(int k=min;k<i;k++)  System.out.print(k);           
         }
     }

    public static void printSquareTwoLoops(int min, int max) {
        int x = max - min + 1;
        for (int i = min; i <= max; i++) {
            int counter = i;
            for (int j = 0; j < x; j++) { 
                System.out.print(counter);
                counter = counter >= max ? min : counter + 1;
            }
            System.out.println();
        }
    }

    /**
     * If you know the number upfront. for example 345678.
     *    345678-3*10000=45678=>most significatDigit=3, difference = 45678. 
     *    number = 45678*10 + significatDigit=456783
     *    
     *    And so on..
     * 
     */
     public void printSquareOne(int min, int max){
         StringBuilder sb = new StringBuilder();
         for(int i=min;i<=max;++i){sb.append(i);}
             int number = Integer.valueOf(sb.toString());
             int howMany = (""+number).length();        
             for(int i=0;i<howMany;++i){
                 int pow = (int)Math.pow(10, (howMany-1));
                 int mostSignificantDigit = 0;
                 int intermediarResult = number;
                 do {
                     ++mostSignificantDigit;
                     intermediarResult = intermediarResult - pow;
                 } while (intermediarResult>pow);
                 number = intermediarResult * 10 + mostSignificantDigit;
                 System.out.println(number);
            }    
     }
}

我进行了一些测试。

编辑我还在测试中添加了@Arun P Johny方法。

这是输出：

 4      PrintSquare3Loops  32.4 =====
 4        PrintSquareMine  20.7 ===
 4    PrintSquareTwoLoops  38.4 ======
 4 PrintSquareCollections  31.8 =====
 7      PrintSquare3Loops  92.9 ==============
 7        PrintSquareMine  36.8 =====
 7    PrintSquareTwoLoops 102.6 ================
 7 PrintSquareCollections 104.8 ================
 9      PrintSquare3Loops 166.2 ==========================
 9        PrintSquareMine  41.7 ======
 9    PrintSquareTwoLoops 187.5 ==============================
 9 PrintSquareCollections 147.7 =======================

似乎一个接一个的3个循环对性能没有好处。我在这里谈论记忆，我相信我会使用更多。

Answer 5

看到这个逻辑，它执行所需的操作，它是通用的，适用于任何+ ve值min，max：

for(int i=min;i<=max;i++){
    for(int j=min;j<=max;j++){
        int val = (j + i - min);
            if (val >max ){
                val -= max - min + 1;
            }
            System.out.print(val);
        }
    }

Answer 6

我不赞成让学生全面实施，但这次我做了一些与OP建议不同的事情。希望他能学到一些东西。

public class RingGroupPrint {
  public static void printSquare(int min,int max){
    LinkedList<Integer> list = new LinkedList<Integer>();
    for (int a=min; a<=max; a++) {
      list.add(a);
    }

    for (int i= 0, amount = max-min +1; i<amount; i++ ){
      for (Integer val: list) {
        System.out.print(val);
      }
      list.offerLast(list.pollFirst());
      System.out.println();
    }
  }

  public static void main(String[] args) {
    printSquare(1, 5);
  }
}

我并不认为它比最简单的2实施更好或更好。它使用Java的集合，是一个很好的学习材料。我希望。

Answer 7

在代码中添加另一个循环。试试这个：

public void printSquare(int min, int max) {
        for (int i = min; i <= max; i++) {
            int j = i;
            for (j = i; j <= max; j++) {
                System.out.print(j);
            }
            for (int k = j - i, l = min; k < max; k++, l++) {
                System.out.print(l);
            }

            System.out.println();
        }
}

使用两个for循环输出组环值

7 个答案: