Sudoku Project in VS 2010

• Download source - 66.9 KB

Introduction

This application tries to solve any Sudoku game. It applies all basic Sudoku logic to discover missing numbers:

1. Test of possible numbers in a cell by scanning all possibilities in that cell's row, column and square.
2. For each row, column and square, scan all numbers (from 1 to 9) to fit a number in its cell (for example: In the third row, number 5 can only be in the second cell because none of the other cells support it.)
3. Finally, if no searches of the previous types are found, trial and error starting in those cells that have least number of possibilities.

I made a YouTube playlist of the entire project. I was recording and writing the code at the same time.

Background

Almost twelve (about 2000) years ago, I encountered the Sudoku game and it was love at first sight. I was studying Math in Faculdade de Ciências da Universidade do Porto (Portugal), and immediately I made an application to solve it (I programmed in Visual Basic 6 since I was 17). That application solved it with no problem. Now in 2013, for the first time, I'm unemployed since my degree (Portuguese economy sucks) and I decided to make a "remake" of that application because I've seen some bad Sudoku applications (by design). Because I've been teaching C#, SQL, and Math these last years, I think I can make a good app...

Using the Code

The app consists of:

• A set of classes representing the Sudoku Game and structure
• A control named SudokuControl to present the game.

The classes that I've created are SudokuGame, SudokuCell, SudokuLine, SudokuColumn, SudokuSquare and an abstract class SudokuCellGroup that represents any set of nine SudokuCells. For that reason, SudokuLine, SudokuColumn, and SudokuSquare inherit from this class. Each of these classes have methods to validate the Sudoku game, to search for unknown numbers, etc.

Here is the code for SudokuCellGroup:

using System;
using System.Collections.Generic;
using System.Text;
namespace Sudoku
{
    public abstract class SudokuCellGroup
    {
        public abstract SudokuCell this[int index]
        {
            get;
        }
        public SudokuGame Game { get; set; }
        public SudokuCellGroup(SudokuGame game)
        {
            this.Game = game;
        }
        public bool Validate()
        {
            List<int> ints = new List<int>();
            for (int i = 0; i < 9; i++)
            {
                if (this[i].HasValue)
                {
                    if (ints.Contains(this[i].Value))
                        return false;
                    else
                        ints.Add(this[i].Value);
                }
            }
            return true;
        }
        public List<SudokuCell> GetPossibleCells(int value)
        {
            List<SudokuCell> cls = new List<SudokuCell>();
            for (int i = 0; i < 9; i++)
                if (this[i].GetPossibleValues().Contains(value))
                    cls.Add(this[i]);
            return cls;
        }
   }
}

Here is the code for SudokuCell that returns the possible numbers to place in that cell in a given moment:

public List<int> GetPossibleValues()
{
    List<int> lst = new List<int>();
    if (!this.HasValue)
    {
        lst.Add(1); lst.Add(2); lst.Add(3); lst.Add(4); lst.Add(5);
        lst.Add(6); lst.Add(7); lst.Add(8); lst.Add(9);

        for (int i = 0; i < 9; i++)
        {
            SudokuCell item = this.Line[i];
                
            if (item != this)
                if (item.HasValue)
                    if (lst.Contains(item.Value))
                        lst.Remove(item.Value);
        }

        for (int i = 0; i < 9; i++)
        {
            SudokuCell item = this.Column[i];
            if (item != this)
                if (item.HasValue)
                    if (lst.Contains(item.Value))
                        lst.Remove(item.Value);
        }
        for (int i = 0; i < 9; i++)
        {
            SudokuCell item = this.Square[i];
                
            if (item != this)
                if (item.HasValue)
                    if (lst.Contains(item.Value))
                        lst.Remove(item.Value);
        }
    }

    return lst;
}

History

Current version. No changes made. The project can be downloaded fully here.