Question

所以作为标题，我从Eclipse和cmd命令运行我的Magic Square程序得到了不同的结果。日食没有意义。

enter image description here

（在日食中句子的位置“错误的数字......”应该是错的）

任何人都知道如何修复它？非常感谢！

    import java.util.HashSet;
    import java.util.Scanner;
    import java.util.Set;
    public class MagicSquare{
    // the two-dimensional array to restore my own magic square.
    private int[][] myMagicSquare;
    private int n;


    public MagicSquare(){
    }

    /**
     * Function: this constructor takes and positive, odd integer parameter to generate a new 
     * magic square.</br>   
     * @param n the length of magic square</br>
     * @throws IllegalArgumentException for negative or even parameter. 
     * Preston Jul 5, 20151:15:40 AM</br>
     */
    public MagicSquare(int n){
        //throws runtime error.
        if(!rangeCheck(n)){
            throw new IllegalArgumentException("Illegal number"); 
        }else{
            // create my magic square array with length of given integer. 
            this.n = n;
            myMagicSquare = new int[n][n];
            // generate the magic square.
            createMagicSquare();
        }
    }

    /**
     * 
     * Function: this constructor takes a 2D array as a parameter. If the 2D array can generate
     * a magic square, then put the values into <i>my magic square</i></br>, if not then throws
     * the exception.   
     * @param newMagicSquare the tested 2D array</br>
     * @throws IllegalArgumentException
     * Preston Jul 5, 20151:23:10 AM</br>
     */
    public MagicSquare(int[][] newMagicSquare){
        this.n = newMagicSquare.length;
        // determine whether or not the 2D array can generate a magic square.
        if(isMagic(newMagicSquare))
            myMagicSquare = newMagicSquare;
        else
            throw new IllegalArgumentException("This is not a magic square");
    }
    /**
     * 
     * Function:Range check for the input of magic square length</br>   
     * @param n the length of magic square
     * @return true if the length is a positive, odd number</br>
     * Preston Jul 5, 20152:53:29 PM</br>
     */
    private static boolean rangeCheck(int n){
        return !((n>0&&n%2==0)||n<=0);
    }

    /**
     * 
     * Function: return the magic number of the magic square.</br>  
     * @return the value magic number.</br>
     * Preston Jul 5, 20151:29:02 AM</br>
     */
    private int getMagicNumber(){
        return (n*(n*n+1))/2;   
    }

    /**
     * 
     * Function: For challenging level: check if all numbers for 1 to n*n only appeared once
     * in the given 2D array.</br>  
     * @param temp the temporary 2D array as parameter.
     * @return true if all numbers from 1 to n*n only appeared once</br>
     * Preston Jul 5, 20151:30:03 AM</br>
     */
    private static boolean noRepeatedNum(int[][] temp){
        int n = temp.length;
        // Set up the standard Set for comparison. 
        Set<Integer> standardSet = new HashSet<>();
        for(int i=1;i<=n*n;i++){
            standardSet.add(i);
        }
        // the Set made of all numbers from temp. All repeated numbers show only once in Set.
        Set<Integer> arraySet = new HashSet<>();
        for(int[] x : temp){
            for(int a : x){
                arraySet.add(a);
            }
        }
        // return if two Sets are equal.
        return arraySet.equals(standardSet);
    }
    /**
     * 
     * Function: Check if the given 2D array can consist a magic square</br>    
     * @param temp a parameter 2D array.
     * @return true if numbers in the parameter array could consist a magic square</br>
     * Preston Jul 5, 20151:36:44 AM</br>
     */
    private static boolean isMagic(int[][] temp){
        //store the return value
        boolean isMagic = true;
        int tempN = temp.length;
        int magicNumber = (tempN*(tempN*tempN+1))/2;
        // accumulator for two diagonals
        int diagonalOneSum = 0;
        int diagonalTwoSum = 0;
        // check rows and columns
        for(int i=0; i<tempN;i++){
            int rowSum = 0;
            int columnSum = 0;
            for(int j=0;j<tempN;j++){
                // single-row sum
                rowSum += temp[i][j];
                // single-column sum
                columnSum += temp[j][i];
            }
            if(rowSum!=magicNumber||columnSum!=magicNumber){
                isMagic = false;
                // return false immediately if there's inequality. Save calculations and performance.
                return isMagic;
            }
        }
        // counter for the second diagonal
        int diagonalTwoCounter = tempN-1;
        // sum of two diagonals
        for(int i=0;i<temp.length;i++){
            diagonalOneSum += temp[i][i];
            diagonalTwoSum += temp[diagonalTwoCounter][diagonalTwoCounter];
            diagonalTwoCounter--;
        }
        if(diagonalOneSum!=magicNumber||diagonalTwoSum!=magicNumber){
            isMagic = false;
            return isMagic;
        }
        // check if there are repeated numbers in the pretty magic square already.
        return noRepeatedNum(temp);
    }

    /**
     * 
     * Function: check if the position of the number in the magic square is at boundary</br>    
     * @param boundary the row OR column number of the position
     * @return true if the value of<code>boundary</code> is zero</br>
     * Preston Jul 5, 20151:53:24 PM</br>
     */
    private boolean Boundary(int boundary){
        return boundary==0;
    }
    /**
     * 
     * Function: Put numbers from 1 to n*n into my own 2D array using Siamese Method.</br>
     * Preston Jul 5, 20153:20:56 PM</br>
     */
    private void createMagicSquare(){
        // starting Row number -> middle
        int startRow = this.n/2;
        // starting Column number -> the first column
        int startColumn = 0;
        // start to put number from 2
        int startNum = 2;
        // put 1 in the starting position
        myMagicSquare[startRow][startColumn] = 1;

        while(startNum<=n*n){   
            // the positions on upper boundary
            if(Boundary(startRow)&&!Boundary(startColumn)){
                myMagicSquare[n-1][startColumn-1] = startNum;
                startRow = n-1;
                startColumn -= 1;
            }
            // the positions on left boundary
            else if(Boundary(startColumn)&&!Boundary(startRow)){
                myMagicSquare[startRow-1][n-1] = startNum;
                startRow -= 1;
                startColumn = n-1;
            }
            // upper left corner.
            else if(Boundary(startRow)&&Boundary(startColumn)){
                myMagicSquare[startRow][startColumn+1] = startNum;
                startColumn += 1;
            }
            else{
                // if the coming position is filled with number.
                if(myMagicSquare[startRow-1][startColumn-1]!=0){
                    myMagicSquare[startRow][startColumn+1] = startNum; 
                    startColumn += 1;
                }
                // general movement
                else{
                    myMagicSquare[startRow-1][startColumn-1] = startNum;
                    startRow -= 1;
                    startColumn -= 1;
                }
            }
            startNum++;
        }
    }

    public String toString() {
        // align my 2D array.
        return toString(myMagicSquare);
    }

    /**
     * 
     * Function:align the numbers in the parameter 2D array pretty</br> 
     * @param temp the parameter 2D array.
     * @return the beautifully aligned String</br>
     * Preston Jul 5, 20153:26:15 PM</br>
     */
    public static String toString(int[][] temp){
        int largestNum = 0;
        // get the largest number in temp.
        for(int[] x : temp){
            for(int a : x){
                if(a>=largestNum)
                    largestNum = a;
            }
        }
        // how many digits does the biggest number have?
        int longestDigit = String.valueOf(largestNum*largestNum).length();
        // store the final String
        StringBuilder printOut  = new StringBuilder();
        printOut.append('\n');

        for(int[] x : temp){
            for(int a : x){
                // space between each number
                printOut.append('\t');
                // add spaces for alignment.
                for(int i=0;i<longestDigit-String.valueOf(a).length();i++){
                    printOut.append(" ");
                }
                printOut.append(String.valueOf(a));
            }
            printOut.append('\n').append('\n');
        }
        // return the big String
        return printOut.toString();
    }

    /**
     * 
     * Function: the main function scans user input as the length of 2D array to make my
     * own magic square. If the <code>userInput</code> is out of range, print out the error
     * message and ask for the number again. Enter the code 0 to exit.</br> 
     * @param args</br>
     * Preston Jul 5, 20153:28:57 PM</br>
     */
    public static void main(String[] args) {
        int userInput;
        do{
            // title
            System.out.println("Enter a positive, odd number");
            System.out.print("Exit code is 0, enter 0 to quit: ");
            // user input
            userInput = new Scanner(System.in).nextInt();
            // if the userInput is out of range, show error message.
            if(rangeCheck(userInput)){
                MagicSquare m = new MagicSquare(userInput);
                System.out.println(m.toString());
            }else
                if(userInput==0)
                    System.out.println("The magic square is not generated. QUIT");
                else
                    System.err.println("Wrong number: Please enter a positive, odd number");
            // restart 
            System.out.println("-------------------");
        }while(userInput != 0);  // enter 0 to exit.        

    }

}

Answer 1

上述问题的原因是eclipse中处理stdout和stderr的错误。Follow this link。（不确定这是否已修复。）

我也试图重现这个问题，但在某些情况下会发生这种情况，在某些情况下，输出和错误输出显示在正确的位置。

只是为了检查： -

你可能在第一次运行eclipse时遇到这个问题，所以不要退出代码，再次尝试使用错误的数字（即2/4/6 ......）;你可能会看到错误和输出被正确打印。

从Eclipse和cmd运行的结果不同？ Java程序 - 魔术广场

1 个答案: