Thread: In a bit of a pickle, unsure of what I should do

Well I'm writing this for fun, no it's not homework.
So anyway, it's basically a Sudoku Solver.
I intend to have it solve a Sudoku by finding obvious pairs;
As in naked pairs : Solving Sudoku
That's a naked pair; A cell with only 1 possible number.
So far I have a Cell class, and withing that class I have a method that creates 81 instances of itself:

And then it occured to me;
How on Earth would I assign it values;
I was brainstorming, and thought that perhaps there could be a method that scans a row, returns an array of the nonzero numbers in the row, same for the column, and a 3*3 region, or box.


I'm not sure how I would code that, seeing as I am a O.K. programmer, I could use a little help, and if someone could just help me out by giving me some idea on how to do this, code etc, that would be great!
This is not homework, I code in my free time. Help would be very appreciated

import java.util.ArrayList;
 
 
public class Cell {
boolean isnull=false;
int value;
int xloc;
int yloc;
int possiblevalues[] = new int[] {1,2,3,4,5,6,7,8,9};
Cell[] cellarray = new Cell[81];
ArrayList signs = new ArrayList(40);
 
 
public void assignvaluesandloc(){
	int x = 0;
	Cell[] cellarray = new Cell[81];
	GetDataMethods g = new GetDataMethods();
		int currentnumber = 0;
		for (int row = 0; row <= 8; row++)
		{
		     for(int col = 0; col <= 8; col++)
		     {
		    	cellarray[x] = new Cell();
		        cellarray[x].value=g.newboard[row][col];
		        cellarray[x].xloc=row;
		        cellarray[x].yloc=col;
		        x++;
 
		     	}
		     }
	 	}
			public void getcellvalue(){
 
			}
	    }

It might be easier to use a two dimensional array here, as it more accurately represents a Sudoku square.

public class Sudoku {
 
    private Cell[][] square = new Cell[9][9];
 
    public void initialize() {
        // set the initial values of some of the Cells
    }
 
    public void solve() {
        // write your solving algorithm here
    }
 
    public void print() {
        // print your square
    }
 
    public static void main(String[] args) {
        Sudoku puzzle = new Sudoku();
        puzzle.initalize();
        puzzle.print();
        puzzle.solve();
        puzzle.print();
    }
 
}
 
public class Cell {
 
    public int value;
 
    public List<Integer> possibleValues = new ArrayList<Integer>();
 
}

Oh I don't know if you know, but I have another file representing the whole board.
Why the two dimensional array?
EDIT:
Oh wait you are referring to the 3*3 portion of a board?
I was hoping to somehow eliminate the possible values by scanning rows/columns.
I'm not sure where this is going

Heres another file

public class GetDataMethods {
	int emptycells[];
	//The Sudoku
    int[][] newboard = {{0,0,0,0,6,0,0,0,9},
                        {0,6,0,0,0,0,3,0,1},
                        {2,0,0,0,0,9,8,0,0},
                        {1,9,6,0,0,2,0,0,8},
                        {0,0,0,3,0,8,0,0,0},
                        {8,0,0,9,0,0,1,7,5},
                        {0,0,1,7,0,0,0,0,4},
                        {6,0,7,0,0,0,0,8,0},
                        {4,0,0,0,9,0,0,0,0}};
//The Possible Values
public int possibilityboard[][];
int value;
 
public int getnumbersinrow(int row,int[][]board){
int x = 0;
for(int y = 0; y<=8;y++){
if(board[row][y]!=0){
 
}
}
	return x;
}
public boolean isinrow(int number, int col){
	for(int x = 0;x<=8;x++){
		if(newboard[col][x]==number){
		return true;
 
		}
	}
	return false;
	}
 
public boolean isincol(int number, int row){
for(int x =0;x<=8;x++){
if(newboard[row][x]==number){
return true;
}
	}
		return false;
	}
}

From the looks of it, you already are using a two dimensional array...

Since that's the case, why are you creating an array of Cells of size 81?

Oh good point.
Well this project is supposed to be completely different in the end, It will load the sudoku from a file, and I was thinking perhaps first it should be in an array, then the array should be copied with it's values to the appropriate objects.
What do you suggest I should do?

I would still do it the way I started doing it above.

I would make the file look like this:

1,2:4
4,9:8
x,y:z

where 1 is the horizontal position (the x value, or the first value in the array call) and 2 is the vertical position (the y value, or the second value in the array call) and the number the semi-colon (in this case, 4) is the value of the cell.

So,

public void initialize(File file) {
    BufferedReader in = new BufferedReader(new FileReader(file));
    for (each line of the file) {
        split it so x is the first, y is the second, and z is the third;
        square[x][y] = new Cell(z);
    }
}

Alright, well so far that sounds good.
I'll modify my program and adjust it to fit what you said.
However, how would you approach removing and adding possible values.

Do you mean adding possible values to solve the puzzle? Well, I am not an expert sudoku puzzle solver, so I am not exactly sure how to proceed at the moment. How would you solve the puzzle in your head?

Ok well here's what I mean:
Every cell in the sudoku puzzle has possible values;
As in
Say we have part of a puzzle

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

the x can't have 7 8 9 as possiblities, because they are in the same row.
So basically, it's like saying the following numbers can go inside the little cell, or x, and work fine.
Most of them have 1 possible value, so they will then be assigned a value, then a chain reaction will make other cells 1 possible value, eventually solving the puzzle.

Do you have any ideas?

Half of the fun of coding is the thought that goes into it ;-)

Originally Posted by helloworld922

The simplest solution? Brute force Soduko's are simple enough they can be solved in a fraction of a second by computers via brute force.

No, not really.
The harder ones take more time
I'd rather use the simple logic, although idk.
Do you know what is causing the null pointer exception though?

Oh an my null pointer error:
Exception in thread "main" java.lang.NullPointerException
at runprogram.findemptycells(runprogram.java:28)
at runprogram.runprogram(runprogram.java:20)
at runprogram.main(runprogram.java:16)