SudokuGen3 | C# Online Compiler

SudokuGen3 by Megalogue

using System;
using System.Collections.Generic;
					
public class Program
{
	public static void Main()
	{
		Grid grid = new Grid(3, 3);
		
		//grid.FillSectorsWith(1);
		//grid.FillSectorsWith(2);
		//grid.FillSectorsWith(3);
		//grid.FillSectorsWith(4);
		grid.CreateSolution();
		grid.DrawGrid();
		//grid.GetCellAt(0, 0).DebugCell();
	}
	
	private void DrawGrid(Cell[,] grid)
	{
		for (int x = 0; x < grid.GetLength(0); x++)
		{
			for (int y = 0; y < grid.GetLength(1); y++)
			{
				Console.Write(grid[x, y].GetValue());
			}
			Console.WriteLine();
		}
	}
}

public class Grid
{
	Cell[,] cells;
	int sectorWidth;
	int sectorHeight;
	int[] valueCount;
	Random rand = new Random(3);
	
	public Grid(int widthIn, int heightIn)
	{
		sectorWidth = widthIn;
		sectorHeight = heightIn;
		valueCount = new int[(sectorWidth * sectorHeight) + 1]; //each index tracks the corresponding number of values currently in the grid; e.g. index 1 tracks the 1s
		
		cells = new Cell[sectorWidth * sectorHeight, sectorWidth * sectorHeight];
		
		for (int x = 0; x < cells.GetLength(0); x++)
		{
			for (int y = 0; y < cells.GetLength(1); y++)
			{
				cells[x, y] = new Cell(sectorWidth * sectorHeight);
			}
		}
	}
	
	public void DrawGrid()
	{
		for (int y = 0; y < cells.GetLength(1); y++)
		{
			for (int x = 0; x < cells.GetLength(0); x++)
			{
				if (x % sectorWidth == 0)
					Console.Write(" ");
				Console.Write(cells[x, y].GetValue() + " ");
			}
			Console.WriteLine();
			if ((y + 1) % sectorHeight == 0)
			{
				Console.WriteLine();
			}
		}
	}
	
	public int GetSize()
	{
		return cells.GetLength(0);
	}
	
	public Cell GetCellAt(int x, int y)
	{
		return cells[x, y];
	}
	
	public Cell[] GetSectorAt(int xIn, int yIn)
	{
		Cell[] sectorCells = new Cell[sectorWidth * sectorHeight];
		
		while (xIn % sectorWidth != 0)
			xIn--;
		while (yIn % sectorHeight != 0)
			yIn--;
		
		for (int x = 0; x < sectorWidth; x++)
		{
			for (int y = 0; y < sectorHeight; y++)
			{
				sectorCells[x + (y * sectorWidth)] = cells[xIn + x, yIn + y];
			}
		}
		
		return sectorCells;
	}
	
	public void FillCell(int x, int y, int intIn)
	{
		cells[x, y].ChooseOption(intIn);
		valueCount[intIn]++;
		RemoveFromColumn(x, intIn);
		RemoveFromRow(y, intIn);
		RemoveFromSector(x, y, intIn);
	} //"Filling a cell" actually means removing all of its options other than the given int.
	
	public bool RowHas(int rowY, int intIn)
	{
		bool result = false;
		
		for (int x = 0; x < sectorWidth * sectorHeight; x++)
		{
			if (cells[x, rowY].GetValue() == intIn)
				result = true;
		}
		
		return result;
	}
	
	public bool ColumnHas(int colX, int intIn)
	{
		bool result = false;
		
		for (int y = 0; y < sectorWidth * sectorHeight; y++)
		{
			if (cells[colX, y].GetValue() == intIn)
				result = true;
		}
		
		return result;
	}
	
	public bool SectorHas(int xIn, int yIn, int intIn)
	{
		Cell[] sectorCells = GetSectorAt(xIn, yIn);
		bool result = false;
		
		for (int i = 0; i < sectorCells.Length; i++)
		{
			if (sectorCells[i].GetValue() == intIn)
				result = true;
		}
		
		return result;
	}
	
	public void RemoveFromRow(int rowY, int intIn)
	{
		for (int x = 0; x < cells.GetLength(0); x++)
		{
			if (cells[x, rowY].GetValue() != intIn)
				cells[x, rowY].RemoveOption(intIn);
		}
	}
	
	public void RemoveFromColumn(int colX, int intIn)
	{
		for (int y = 0; y < cells.GetLength(1); y++)
		{
			if (cells[colX, y].GetValue() != intIn)
				cells[colX, y].RemoveOption(intIn);
		}
	}
	
	public void RemoveFromSector(int xIn, int yIn, int intIn)
	{
		Cell[] sectorCells = GetSectorAt(xIn, yIn);
		
		for (int i = 0; i < sectorCells.Length; i++)
		{
			if (!sectorCells[i].HasValue())
				sectorCells[i].RemoveOption(intIn);
		}
	}
	
	public void ClearAll(int intIn)
	{
		for (int x = 0; x < sectorWidth * sectorHeight; x++)
		{
			for (int y = 0; y < sectorWidth * sectorHeight; y++)
			{
				if (!cells[x, y].HasValue())
				{
					cells[x, y].AddOption(intIn);
				}
				else if (cells[x, y].GetValue() == intIn)
				{
					cells[x, y].FillOptions();
				}
			}
		}
		
		valueCount[intIn] = 0;
	}
	
	public List<int[]> GetCoordsWithOption(int intIn)
	{
		List<int[]> listOut = new List<int[]>();
		
		for (int x = 0; x < sectorWidth * sectorHeight; x++)
		{
			for (int y = 0; y < sectorWidth * sectorHeight; y++)
			{
				if (!cells[x, y].HasValue() && cells[x, y].HasOption(intIn))
				{
					listOut.Add(new int[] { x, y });
				}
			}
		}
		//Console.WriteLine("List of options for " + intIn + " was " + listOut.Count + " long");
		
		return listOut;
	} //returns a list of all coords in grid that are still empty.
	
	public void FillSectorNecessary(int secStartX, int secStartY, int intIn) //checks if a sector has a cell with a necessary value (e.g. the only cell that can have a 2), then fills it.
	{
		int optionCount = 0;
		
		for (int x = 0; x < sectorWidth; x++)
		{
			for (int y = 0; y < sectorHeight; y++)
			{
				if (!cells[secStartX + x, secStartY + y].HasValue() && cells[secStartX + x, secStartY + y].HasOption(intIn))
					optionCount++;
			}
		} //counts the available options for intIn in this sector; excludes already-filled cells
		
		if (optionCount == 1)
		{
			for (int x = 0; x < sectorWidth; x++)
			{
				for (int y = 0; y < sectorHeight; y++)
				{
					if (cells[secStartX + x, secStartY + y].HasOption(intIn))
					{
						FillCell(secStartX + x, secStartY + y, intIn);
						Console.WriteLine("Filled a necessary " + intIn + " at " + (secStartX + x) + ", " + (secStartY + y));
					}
				}
			}
		} //a cell is only filled if it's the only one in the sector that has intIn as an option
	}
	
	public void FillGridNecessary(int intIn)
	{
		for (int i = 0; i < sectorWidth * sectorHeight; i++)
		{
			for (int j = 0; j < sectorWidth * sectorHeight; j++)
			{
				int secStartX = (j % sectorWidth) * sectorWidth;
				int secStartY = (int)(j / sectorHeight) * sectorHeight;
				FillSectorNecessary(secStartX, secStartY, intIn);
			}
		}
	}
	
	public void FillSectorsWith(int intIn)
	{
		int max = 20;
		int safety = 0;
		
		while (valueCount[intIn] < sectorWidth * sectorHeight && safety < max)
		{
			ClearAll(intIn);
			int max2 = sectorWidth * sectorHeight;
			if (intIn == 8)
				max2 = 9;
			for (int i = 0; i < max2; i++)
			{
				//Console.WriteLine(GetCoordsWithOption(intIn).Count);
				List<int[]> coordOptions = GetCoordsWithOption(intIn);
				if (coordOptions.Count > 0)
				{
					int randIndex = rand.Next(0, coordOptions.Count);
					//Console.WriteLine(coordOptions.Count);
					int[] randCoord = coordOptions[randIndex];
					
					bool shouldFill = !cells[randCoord[0], randCoord[1]].HasValue() &&
						!RowHas(randCoord[1], intIn) && !ColumnHas(randCoord[0], intIn) && !SectorHas(randCoord[0], randCoord[1], intIn);
					if (shouldFill)
						FillCell(randCoord[0], randCoord[1], intIn);
				}
				FillGridNecessary(intIn);
			}
			safety++;
		}
	}
	
	public void CreateSolution()
	{
		int valueMax = sectorWidth * sectorHeight;
		
		for (int i = 1; i <= 8/*(sectorWidth * sectorHeight) - 1*/; i++)
		{
			FillSectorsWith(i);
			//FillMostRestrictedWith(i);
		}
	}
}

public class Cell
{
	int[] options;
	
	public Cell(int optionCount)
	{
		options = new int[optionCount];
		FillOptions();
	}
	
	public int GetOptionCount()
	{
		int result = 0;
		
		for (int i = 0; i < options.Length; i++)
		{
			if (options[i] != 0)
				result++;
		}
		
		return result;
	}
	
	public bool HasOption(int intIn)
	{
		bool result = false;
		
		for (int i = 0; i < options.Length; i++)
		{
			if (options[i] == intIn)
				result = true;
		}
		
		return result;
	}
	
	public bool HasValue()
	{
		if (GetOptionCount() == 1)
			return true;
		else
			return false;
	}
	
	public void FillOptions()
	{
		for (int i = 0; i < options.Length; i++)
		{
			options[i] = i + 1;
		}
	}
	
	public void AddOption(int intIn)
	{
		options[intIn - 1] = intIn;
	}
	
	public void RemoveOption(int intIn)
	{
		for (int i = 0; i < options.Length; i++)
		{
			if (options[i] == intIn)
				options[i] = 0;
		}
	}
	
	public void ChooseOption(int intIn)
	{
		for (int i = 0; i < options.Length; i++)
		{
			if (options.Length > 1 && options[i] != intIn)
			{
				//Console.WriteLine("Removing " + options[i]);
				options[i] = 0;
			}
		}
	}
	
	public int GetValue()
	{
		int result = 0;
		
		if (GetOptionCount() == 1)
		{
			for (int i = 0; i < options.Length; i++)
			{
				if (options[i] != 0)
					result = options[i];
			}
		}
		
		return result;
	}
	
	public void DebugCell()
	{
		for (int i = 0; i < options.Length; i++)
		{
			//if (options[i] != 0)
				Console.Write(options[i] + ", ");
		}
	}
}

​x
 
using System;
using System.Collections.Generic;
                    
public class Program
{
    public static void Main()
    {
        Grid grid = new Grid(3, 3);
        
        //grid.FillSectorsWith(1);
        //grid.FillSectorsWith(2);
        //grid.FillSectorsWith(3);
        //grid.FillSectorsWith(4);
        grid.CreateSolution();
        grid.DrawGrid();
        //grid.GetCellAt(0, 0).DebugCell();
    }
    
    private void DrawGrid(Cell[,] grid)
    {
        for (int x = 0; x < grid.GetLength(0); x++)
        {
            for (int y = 0; y < grid.GetLength(1); y++)
            {
                Console.Write(grid[x, y].GetValue());
            }
            Console.WriteLine();
        }
    }
}
​
public class Grid
{
    Cell[,] cells;
    int sectorWidth;
    int sectorHeight;
    int[] valueCount;
    Random rand = new Random(3);
    
    public Grid(int widthIn, int heightIn)
    {
        sectorWidth = widthIn;
        sectorHeight = heightIn;
        valueCount = new int[(sectorWidth * sectorHeight) + 1]; //each index tracks the corresponding number of values currently in the grid; e.g. index 1 tracks the 1s
        
        cells = new Cell[sectorWidth * sectorHeight, sectorWidth * sectorHeight];
        
        for (int x = 0; x < cells.GetLength(0); x++)
        {
            for (int y = 0; y < cells.GetLength(1); y++)
            {
                cells[x, y] = new Cell(sectorWidth * sectorHeight);
            }
        }
    }
    
    public void DrawGrid()
    {
        for (int y = 0; y < cells.GetLength(1); y++)
        {
            for (int x = 0; x < cells.GetLength(0); x++)
            {
                if (x % sectorWidth == 0)
                    Console.Write(" ");
                Console.Write(cells[x, y].GetValue() + " ");
            }
            Console.WriteLine();
            if ((y + 1) % sectorHeight == 0)
            {
                Console.WriteLine();
            }
        }
    }
    
    public int GetSize()
    {
        return cells.GetLength(0);
    }
    
    public Cell GetCellAt(int x, int y)
    {
        return cells[x, y];
    }
    
    public Cell[] GetSectorAt(int xIn, int yIn)
    {
        Cell[] sectorCells = new Cell[sectorWidth * sectorHeight];
        
        while (xIn % sectorWidth != 0)
            xIn--;
        while (yIn % sectorHeight != 0)
            yIn--;
        
        for (int x = 0; x < sectorWidth; x++)
        {
            for (int y = 0; y < sectorHeight; y++)
            {
                sectorCells[x + (y * sectorWidth)] = cells[xIn + x, yIn + y];
            }
        }
        
        return sectorCells;
    }
    
    public void FillCell(int x, int y, int intIn)
    {
        cells[x, y].ChooseOption(intIn);
        valueCount[intIn]++;
        RemoveFromColumn(x, intIn);
        RemoveFromRow(y, intIn);
        RemoveFromSector(x, y, intIn);
    } //"Filling a cell" actually means removing all of its options other than the given int.
    
    public bool RowHas(int rowY, int intIn)
    {
        bool result = false;
        
        for (int x = 0; x < sectorWidth * sectorHeight; x++)
        {
            if (cells[x, rowY].GetValue() == intIn)
                result = true;
        }
        
        return result;
    }
    
    public bool ColumnHas(int colX, int intIn)
    {
        bool result = false;
        
        for (int y = 0; y < sectorWidth * sectorHeight; y++)
        {
            if (cells[colX, y].GetValue() == intIn)
                result = true;
        }
        
        return result;
    }
    
    public bool SectorHas(int xIn, int yIn, int intIn)
    {
        Cell[] sectorCells = GetSectorAt(xIn, yIn);
        bool result = false;
        
        for (int i = 0; i < sectorCells.Length; i++)
        {
            if (sectorCells[i].GetValue() == intIn)
                result = true;
        }
        
        return result;
    }
    
    public void RemoveFromRow(int rowY, int intIn)
    {
        for (int x = 0; x < cells.GetLength(0); x++)
        {
            if (cells[x, rowY].GetValue() != intIn)
                cells[x, rowY].RemoveOption(intIn);
        }
    }
    
    public void RemoveFromColumn(int colX, int intIn)
    {
        for (int y = 0; y < cells.GetLength(1); y++)
        {
            if (cells[colX, y].GetValue() != intIn)
                cells[colX, y].RemoveOption(intIn);
        }
    }
    
    public void RemoveFromSector(int xIn, int yIn, int intIn)
    {
        Cell[] sectorCells = GetSectorAt(xIn, yIn);
        
        for (int i = 0; i < sectorCells.Length; i++)
        {
            if (!sectorCells[i].HasValue())
                sectorCells[i].RemoveOption(intIn);
        }
    }
    
    public void ClearAll(int intIn)
    {
        for (int x = 0; x < sectorWidth * sectorHeight; x++)
        {
            for (int y = 0; y < sectorWidth * sectorHeight; y++)
            {
                if (!cells[x, y].HasValue())
                {
                    cells[x, y].AddOption(intIn);
                }
                else if (cells[x, y].GetValue() == intIn)
                {
                    cells[x, y].FillOptions();
                }
            }
        }
        
        valueCount[intIn] = 0;
    }
    
    public List<int[]> GetCoordsWithOption(int intIn)
    {
        List<int[]> listOut = new List<int[]>();
        
        for (int x = 0; x < sectorWidth * sectorHeight; x++)
        {
            for (int y = 0; y < sectorWidth * sectorHeight; y++)
            {
                if (!cells[x, y].HasValue() && cells[x, y].HasOption(intIn))
                {
                    listOut.Add(new int[] { x, y });
                }
            }
        }
        //Console.WriteLine("List of options for " + intIn + " was " + listOut.Count + " long");
        
        return listOut;
    } //returns a list of all coords in grid that are still empty.
    
    public void FillSectorNecessary(int secStartX, int secStartY, int intIn) //checks if a sector has a cell with a necessary value (e.g. the only cell that can have a 2), then fills it.
    {
        int optionCount = 0;
        
        for (int x = 0; x < sectorWidth; x++)
        {
            for (int y = 0; y < sectorHeight; y++)
            {
                if (!cells[secStartX + x, secStartY + y].HasValue() && cells[secStartX + x, secStartY + y].HasOption(intIn))
                    optionCount++;
            }
        } //counts the available options for intIn in this sector; excludes already-filled cells
        
        if (optionCount == 1)
        {
            for (int x = 0; x < sectorWidth; x++)
            {
                for (int y = 0; y < sectorHeight; y++)
                {
                    if (cells[secStartX + x, secStartY + y].HasOption(intIn))
                    {
                        FillCell(secStartX + x, secStartY + y, intIn);
                        Console.WriteLine("Filled a necessary " + intIn + " at " + (secStartX + x) + ", " + (secStartY + y));
                    }
                }
            }
        } //a cell is only filled if it's the only one in the sector that has intIn as an option
    }
    
    public void FillGridNecessary(int intIn)
    {
        for (int i = 0; i < sectorWidth * sectorHeight; i++)
        {
            for (int j = 0; j < sectorWidth * sectorHeight; j++)
            {
                int secStartX = (j % sectorWidth) * sectorWidth;
                int secStartY = (int)(j / sectorHeight) * sectorHeight;
                FillSectorNecessary(secStartX, secStartY, intIn);
            }
        }
    }
    
    public void FillSectorsWith(int intIn)
    {
        int max = 20;
        int safety = 0;
        
        while (valueCount[intIn] < sectorWidth * sectorHeight && safety < max)
        {
            ClearAll(intIn);
            int max2 = sectorWidth * sectorHeight;
            if (intIn == 8)
                max2 = 9;
            for (int i = 0; i < max2; i++)
            {
                //Console.WriteLine(GetCoordsWithOption(intIn).Count);
                List<int[]> coordOptions = GetCoordsWithOption(intIn);
                if (coordOptions.Count > 0)
                {
                    int randIndex = rand.Next(0, coordOptions.Count);
                    //Console.WriteLine(coordOptions.Count);
                    int[] randCoord = coordOptions[randIndex];
                    
                    bool shouldFill = !cells[randCoord[0], randCoord[1]].HasValue() &&
                        !RowHas(randCoord[1], intIn) && !ColumnHas(randCoord[0], intIn) && !SectorHas(randCoord[0], randCoord[1], intIn);
                    if (shouldFill)
                        FillCell(randCoord[0], randCoord[1], intIn);
                }
                FillGridNecessary(intIn);
            }
            safety++;
        }
    }
    
    public void CreateSolution()
    {
        int valueMax = sectorWidth * sectorHeight;
        
        for (int i = 1; i <= 8/*(sectorWidth * sectorHeight) - 1*/; i++)
        {
            FillSectorsWith(i);
            //FillMostRestrictedWith(i);
        }
    }
}
​
public class Cell
{
    int[] options;
    
    public Cell(int optionCount)
    {
        options = new int[optionCount];
        FillOptions();
    }
    
    public int GetOptionCount()
    {
        int result = 0;
        
        for (int i = 0; i < options.Length; i++)
        {
            if (options[i] != 0)
                result++;
        }
        
        return result;
    }
    
    public bool HasOption(int intIn)
    {
        bool result = false;
        
        for (int i = 0; i < options.Length; i++)
        {
            if (options[i] == intIn)
                result = true;
        }
        
        return result;
    }
    
    public bool HasValue()
    {
        if (GetOptionCount() == 1)
            return true;
        else
            return false;
    }
    
    public void FillOptions()
    {
        for (int i = 0; i < options.Length; i++)
        {
            options[i] = i + 1;
        }
    }
    
    public void AddOption(int intIn)
    {
        options[intIn - 1] = intIn;
    }
    
    public void RemoveOption(int intIn)
    {
        for (int i = 0; i < options.Length; i++)
        {
            if (options[i] == intIn)
                options[i] = 0;
        }
    }
    
    public void ChooseOption(int intIn)
    {
        for (int i = 0; i < options.Length; i++)
        {
            if (options.Length > 1 && options[i] != intIn)
            {
                //Console.WriteLine("Removing " + options[i]);
                options[i] = 0;
            }
        }
    }
    
    public int GetValue()
    {
        int result = 0;
        
        if (GetOptionCount() == 1)
        {
            for (int i = 0; i < options.Length; i++)
            {
                if (options[i] != 0)
                    result = options[i];
            }
        }
        
        return result;
    }
    
    public void DebugCell()
    {
        for (int i = 0; i < options.Length; i++)
        {
            //if (options[i] != 0)
                Console.Write(options[i] + ", ");
        }
    }
}

Last Run:	6:14:42 pm
Compile:	0.13s
Execute:	0s
Memory:	32kb
CPU:	0s

View IL Code