스도쿠 생성기 : ArrayOutOfBoundsException

Question

이 프로젝트에서는 9 x 3 스도쿠 보드와 9 x 3 서브 글리드가있는 프로그램을 작성하려고합니다. 헤더 행과 열을 a와 i로 나열합니다. 이 프로그램이 제대로 컴파일하지만 실행을 쳤을 때, 그것은 다음과 같은 오류 제공 :이 제출되면 이제

java.lang.ArrayIndexOutOfBoundsException: 0 
at Sudoku.main(Sudoku.java:218) 
at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
at sun.reflect.NativeMethodAccessorImpl.invoke(Unknown Source) 
at sun.reflect.DelegatingMethodAccessorImpl.invoke(Unknown Source) 
at java.lang.reflect.Method.invoke(Unknown Source) 
at `enter code here`edu.rice.cs.drjava.model.compiler.JavacCompiler.runCommand(JavacCompiler.java:272) 

을, 채점 프로그램은 rowsComplete(), columnsComplete() 및 isComplete() 방법이 잘못 print()했다 내 것을 주장하고, 내 main()이 java.util.NoSuchElementException입니다. 나는 이것이 왜 일어나고 있는지 혼란 스럽다. 다음은 자바 코드뿐 아니라 메소드가 정확히 무엇을해야하는지에 대한 노트입니다. main 방법에서

import java.util.Scanner; 
import java.io.File; 
import java.io.FileNotFoundException; 

public class Sudoku 
{ 
public static final int SIZE = 9; 
public static final int SUBGRID = 3; 
public int[][] game; 
public int[][] originalGame; 
public Sudoku(String puzzleFile) 
{ 
    try 
    { 
     game = new int[SIZE][SIZE]; 
     originalGame = new int[SIZE][SIZE]; 
     File file = new File(puzzleFile); 
     Scanner in = new Scanner(file); 
     int i = 0; 
     int j = 0; 
     int k; 
     for (i = 0; i<SIZE; i++){ 
      for (j = 0; j<SIZE; j++){ 
       k = in.nextInt(); 
       game[i][j]=k; 
       originalGame[i][j] = k; 
      } 

     } 
    } 
    catch (FileNotFoundException e) 
    { 
     System.out.println("FileNotFound: " + e.getMessage()); 
    } 
} 

public void setZero(int[] array) 
{ 
    int i = 0; 
    for (i = 0; i < array.length; i++) 
    { 
     array[i] = 0; 
    } 
} 
/** 
* This method determines whether the ints 1-9 are present exactly 
* once in each row. Sets valSeen[i] = 1 if it sees i. If at any 
* point valSeen[i] is already 1, the rows are not complete because of 
* duplicate entries. 
* 
* If game[x][y] == -1, there is a blank entry so the row cannot be complete. 
* 
* @param valSeen: an array of ints that serve as flags to indicate whether 
*     their entry has been seen before or not. 
* 
* returns: true if each digit 1-9 is present in the row exactly once, else false 
**/ 
public boolean rowsComplete(int[] valSeen) 
{  
    int temp; 
    int k = 0; 
    for(int rows = 0; rows<SIZE; rows++){ 
     for(int cols = 0; cols<SIZE; cols++){ 
      if(game[rows][cols]==-1) 
       return false; 
      temp = game[rows][cols]; 
      valSeen[temp-1]++; 
     } 
     for(k=0; k<valSeen.length; k++){ 
      if(valSeen[k]!=1) 
       return false; 
      else return true; 
     } 
     setZero(valSeen); 
    } 
    return true; 
} 
/** 
* This method determines whether the ints 1-9 are present exactly 
* once in each column. Sets valSeen[i] = 1 if it sees i. If at any 
* point valSeen[i] is already 1, the rows are not complete because of 
* duplicate entries. 
* 
* If game[x][y] == -1, there is a blank entry so the row cannot be complete. 
* 
* @param valSeen: an array of ints that serve as flags to indicate whether 
*     their entry has been seen before or not. 
* 
* returns: true if each digit 1-9 is present in the column exactly once, else false 
**/ 
public boolean columnsComplete(int[] valSeen) 
{ 
    int temp; 
    int k = 0; 
    for(int cols = 0; cols<SIZE; cols++){ 
     for(int rows = 0; rows<SIZE; rows++){ 
      if(game[rows][cols]==-1) 
       return false; 
      temp = game[rows][cols]; 
      valSeen[temp-1]++; 
     } 
     for(k=0; k<valSeen.length; k++){ 
      if(valSeen[k]!=1) 
       return false; 
      else return true; 
     } 
     setZero(valSeen); 
    } 
    return true; 
} 
/** 
* This method determines whether the ints 1-9 are present exactly 
* once in each subgrid. Sets valSeen[i] = 1 if it sees i. If at any 
* point valSeen[i] is already 1, the rows are not complete because of 
* duplicate entries. 
* 
* If game[x][y] == -1, there is a blank entry so the row cannot be complete. 
* 
* @param valSeen: an array of ints that serve as flags to indicate whether 
*     their entry has been seen before or not. 
* 
* returns: true if each digit 1-9 is present in each subgrid exactly once, else false 
**/ 
public boolean subgridsComplete(int[] valSeen) 
{ 
    int temp; 
    for(int rows=0; rows<SIZE; rows+=3){ 
     for (int cols=0; cols<SIZE; cols+=3){ 
      for(int subrows=0; subrows<SUBGRID; subrows++){ 
       for (int subcols=0; subcols<SUBGRID; subcols++){ 
        temp= game[rows+subrows][cols+subcols]; 
        if(temp==-1) 
         return false; 
        else 
         valSeen[temp-1]++; 
       } 
      } 
      for(int k=0; k<valSeen.length; k++){ 
       if(valSeen[k]!=1) 
        return false; 
       else return true; 
      } 
      setZero(valSeen); 
     } 
    } 
    return true; 
} 
// Create the array valSeen here. I suggest making it = new int[SIZE+1]. 
// That way, it will have indexes 0-9, so the ints 1-9 can go into indexes 
// 1-9 instead of mapping them to 0-8 by subtracting 1. 

// Call rowsComplete(), columnsComplete(), and subgridsComplete(). 
// Be SURE to initialize valSeen to 0 before each method call by using setZero(). 
public boolean isComplete() 
{ 
    int [] valSeen = new int[SIZE+1]; 
    setZero(valSeen); 
    if(rowsComplete(valSeen) && columnsComplete(valSeen) && subgridsComplete(valSeen)) 
     return true; 
    else 
     return false; 
} 

public String makeHeader() 
{ 
    String header = " "; 
    for (int x = 97; x<106; x++) 
     header += ((char)x) + " | " + " "; 
    return header; 
} 
/** 
* Prints out the grid. Each entry has a space to either side, columns are separated by '|' 
* within the grid/between the header and the grid but not externally. See the specification 
* for a detailed example. -1 is replaced with '_'. 
* 
* Remember that 'a' + 1 = 'b' 
* 
* Prints the grid to standard out. 
**/ 
public void print() 
{ 
    System.out.println(makeHeader()); 
    for(int rows=0; rows<SIZE; rows++){ 
     System.out.print(" "+(char)('a'+rows)); 
     for (int cols=0; cols<SIZE; cols++){ 
      if (game[rows][cols]==-1) 
       System.out.print(" | _"); 
      else 
       System.out.print(" | "+game[rows][cols]); 
     } 
     System.out.println(); 
    } 
} 
public void move(String row, String col, int val) 
{ 
    int rowNumber = ((int)(row.charAt(0)-97)); 
    int columnNumber = ((int)(col.charAt(0)-97)); 
    if(originalGame[rowNumber][columnNumber]==-1) 
     game[rowNumber][columnNumber]=val; 
} 

public static void main(String[] args) 
{ 
    Sudoku puzzle = new Sudoku(args[0]); 
    Scanner s = new Scanner(System.in); 
    System.out.println(""); 
    boolean gameplay = true; 
    while (gameplay){ 
     puzzle.print(); 
     if(puzzle.isComplete()){ 
      System.out.println("Puzzle Complete!"); 
      gameplay=false; 
     } else { 
      System.out.println("Puzzle Incomplete!"); 
      System.out.println("Enter new value <row col val> :"); 
      String rowv = s.next(); 
      String colv = s.next(); 
      int valv = s.nextInt(); 
      puzzle.move(rowv, colv, valv); 
     } 
    } 
} 
} 

Answer 1

,

Sudoku puzzle = new Sudoku(args[0]); 

여러분의 프로그램은 사용자로부터 촬영되는 Sudoku를 초기화하는 인수가 필요합니다.

은 프로그램을 시작할 때 매개 변수로 주어진 프로그램에 대한 인수 배열입니다. 당신은 당신이 인수를 사용하여 프로그램을 실행해야합니다 귀하의 Sudoku.class

java Sudoku argument 

로

당신이 프로그램을 위해, 당신은 (당신이 Sudoku.main에서