Example #1
0
int main(int argc, char *argv[]) {

  // Welcome the user to the program
  cout << "\n\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
  cout << "Welcome to Jon's Sudoku solver." << endl;
  cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n" << endl;

  // If the user passed the puzzle file as an argument, run with it.
  if (argv[1]) {

    // Call Puzzle constructor passing it the name of the file
    Puzzle sudoku( argv[1] );

    // Now go through the print and solve steps/commands
    printAndSolve( sudoku );

  // Else if the didn't pass the program a puzzle to solve, ask them for 
  // a puzzle filename
  } else {
    string filename;
    cout << "No puzzle file was passed to the program as an argument." << endl;
    cout << "Please enter the filename of the puzzle you wish to solve." << endl;
    cout << ">> ";
    cin >> filename;

    // Call Puzzle constructor passing it the name of the file
    Puzzle sudoku( filename );

    // Now go through the print and solve steps/commands
    printAndSolve( sudoku );

  }
  
  return 0;
}
Example #2
0
int		main(int argc, char **argv)
{
	char **grid;

	if (error_check(argc, argv))
	{
		print_error();
		return (0);
	}
	grid = set_grid_parameters(argv);
	if (grid == NULL)
		print_error();
	sudoku(grid);
	if (grid[9] == ERROR)
		print_error();
	else
	{
		grid[9] = UNIQUE;
		if (sudoku(grid) && check_solution(grid))
			print_grid(grid);
		else
			print_error();
	}
	free(grid);
	return (0);
}
Example #3
0
int next(int ar[][n*n],int row,int col)
{   int x;
    if(col<=(n*n-2))
    {x=sudoku(ar,row,col+1);return x;}
    else if(row<=(n*n-2))
    {x=sudoku(ar,row+1,0);return x;}
    else 
    return 1;
    }
Example #4
0
int main()
{
    std::vector< std::vector<int> > data =
    {
        {0,0,0, 0,0,0, 0,1,2},
        {0,0,0, 0,3,5, 0,0,0},
        {0,0,0, 6,0,0, 0,7,0},

        {7,0,0, 0,0,0, 3,0,0},
        {0,0,0, 4,0,0, 8,0,0},
        {1,0,0, 0,0,0, 0,0,0},

        {0,0,0, 1,2,0, 0,0,0},
        {0,8,0, 0,0,0, 0,4,0},
        {0,5,0, 0,0,0, 6,0,0},
    };

    if(sudoku(data))
    {
        printout_sudoku(data);
    }
    else
    {
        std::cout << "Failed to find a solution" << std::endl;
    }
    return  0;
}
Example #5
0
int		main(int argc, char **argv)
{
	char	**sudo_tb;
	int		index;
	int		index_malloc;

	index_malloc = 0;
	if (argc == 10 && is_valid_number(argv) == 1)
	{
		index = 0;
		sudo_tb = (char**)malloc(9 * sizeof(char*));
		while (index_malloc < 9)
		{
			sudo_tb[index_malloc] = (char*)malloc(10 * sizeof(char));
			index_malloc++;
		}
		copy_sudo(argv, sudo_tb);
		if (is_valid_char(argv) == 1 && sudoku(sudo_tb, 0))
			print_sudoku(sudo_tb);
		else
			write(1, "Erreur\n", 7);
		free_grid(sudo_tb);
	}
	else
		write(1, "Errer\n", 7);
	return (0);
}
Example #6
0
int main() {
    FILE *ifp;
    ifp = fopen("sudoku.txt", "r");
    
    if (ifp == NULL)
    {
       printf("Couldn't open sudoku.txt input file!\n");
       return 0;
    }
    
    int sud[81] = {0};
    int index = 0;
    fscanf(ifp, "%d", &sud[index]);
    while(!feof(ifp))
    {
       index++;
       if (index > 81)
       {
          printf("sudoku.txt contains more than 81 digits! Sudoku is invalid.\n");
          return 0;
       }
       fscanf(ifp, "%d", &sud[index]);
    }
    
    if (index < 81)
    {
       printf("sudoku.txt contains less than 81 digits! Sudoku is invalid.\n");
       return 0;
    }

    fclose(ifp);
    sudoku(sud);
    printSudoku(sud);
    return 0;
}
Example #7
0
int	sudoku(char **puzzle)
{
	int		row;
	int		col;
	char	num;

	if (!find_dot_pos(puzzle, &row, &col))
	{
		return (1);
	}
	num = '1';
	while (num <= '9')
	{
		if (possible_find(puzzle, row, col, num))
		{
			puzzle[row][col] = num;
			if (sudoku(puzzle))
			{
				return (1);
			}
			puzzle[row][col] = '.';
		}
		num++;
	}
	return (0);
}
Example #8
0
int main()
{  int i,j;
    printf("Enter the order of the puzzle\n");
     scanf("%d",&n);
     int length=n*n;
     int ar[length][length],a[length];
     printf("Enter the puzzle\n");
     for(i=0;i<n*n;i++)
     {
                       for(j=0;j<n*n;j++)
                       {
                                         scanf("%d",&ar[i][j]);
                                         }
     }
     for(i=0;i<n*n;i++)
     {a[i]=i+1;}
      int  c=sudoku(ar,0,0);
        if(c==0)
          printf("\nThe sudoku is not solvable");
    for(i=0;i<n*n;i++)
     {
                       for(j=0;j<n*n;j++)
                       {
                                         printf(" %d ",ar[i][j]);
                                         }
                                         printf("\n");
     }

                                         
}
Example #9
0
int
main (int argc, char *argv[])
{
  int code;
  TParams tp = {.mat1.add = NULL,.mat2.add = NULL };
  if ((code = processParams (&tp, argc, argv)) != RET_OK)
    {
      errmsg (code);
      return EXIT_FAILURE;
    };
  switch (tp.function)
    {
    case 0:
      errmsg (RET_OK);
      break;
    case 1:
      code = sucet (&(tp.mat1), &(tp.mat2));
      break;
    case 2:
      code = sucin (&(tp.mat1), &(tp.mat2));
      break;
    case 3:
      code = submatrix (&(tp.mat1), &(tp.mat2));
      break;
    case 4:
      code = crot (&(tp.mat1));
      break;
    case 5:
      code = plough (&(tp.mat1));
      break;
    case 6:
      code = sudoku (&(tp.mat1));
      break;
    default:
      return EXIT_FAILURE;
    }

  if (tp.mat1.add != NULL)
    {
      freeMat (&(tp.mat1));
    }


  if (tp.mat2.add != NULL)
    {
      freeMat (&(tp.mat2));
    }


  if (code != RET_OK)
    {
      errmsg (code);
      return EXIT_FAILURE;
    }

  return EXIT_SUCCESS;
}
Example #10
0
int main()
{
  /* matriz que guarda o tabuleiro */
  int tabuleiro[9][9] = {{0}};
  if (sudoku(tabuleiro))
    imprime(tabuleiro);
  else
    printf("Sem solucao\n");
  return 0;
}
Example #11
0
int main(int argc, char **argv)
{
    try {
        clock_t begin_time, summary_time = clock();

        begin_time = clock();
        Photo sudoku("9.jpg");
        std::cout << "Open image: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        // 1) Resize
        begin_time = clock();
        sudoku.resize(512, 512);
        std::cout << "Resizing: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        // 2) Binarization
        begin_time = clock();
        Filter::AdaptiveBinarization(sudoku, 4, 0.04);
        std::cout << "Adaptive Binarization: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        GridRecognition recognition(sudoku);

        // 3) Rotate
        begin_time = clock();
        double angle = recognition.getHorizontalAngle();
        std::cout << "getHorizontalAngle: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;
        sudoku.rotate(angle);
        std::cout << "getHorizontalAngle + Rotation: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        // 4) Crop
        begin_time = clock();
        Rectangle grid = recognition.getGridCoords();
        std::cout << "getGridCoords: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;
        sudoku.crop(grid.x, grid.y, grid.width, grid.height);
        std::cout << "getGridCoords + crop: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        // 5) Split digits
        begin_time = clock();
        vector< Point > points = recognition.getLinesCrossPoints();
        std::cout << "getLinesCrossPoints: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;
        recognition.splitOnDigits(points, "digits");
        std::cout << "getLinesCrossPoints + splitOnDigits: " << double(clock() - begin_time) / CLOCKS_PER_SEC << " sec." << std::endl;

        sudoku.save("test.jpg");

        std::cout << "Summary: " << double(clock() - summary_time) / CLOCKS_PER_SEC << " sec." << std::endl;
    } catch(Magick::Exception &error_) { 
        std::cout << "Caught exception: " << error_.what() << std::endl; 

        system("pause");
        return 1; 
    }

    system("pause");
    return 0;
}
Example #12
0
void Sudoku::process(std::istream& input, std::ostream& output) {
  std::vector<std::string> lines;
  std::copy(std::istream_iterator<std::string>(input),
            std::istream_iterator<std::string>(),
            std::back_inserter(lines));
  int count = 0;
  int total = lines.size();
  for (auto& line: lines) {
    Sudoku sudoku(line);
    sudoku.solve();
    output << sudoku;
    count++;
    progress_bar(count, total);
  }
  std::cout << std::endl;
}
Example #13
0
int main(int argc, char *argv[]) {
    // Do not set processor affinity here. It prevents threads from
    // running on multiple cores.

    // Actually, a data pointer and a pointer to a function are not convertible.
    // This depends on x64 ABI specific behavior.
    static_assert(sizeof(uintptr_t) == sizeof(&PrintPattern), "Unexpected uintptr_t size");
    static_assert(sizeof(sudokuXmmPrintFunc) == sizeof(uintptr_t), "Unexpected sudokuXmmPrintFunc size");
    sudokuXmmPrintFunc = reinterpret_cast<uintptr_t>(&PrintPattern);

    if (!SudokuLoader::CanLaunch(argc, argv)) {
        std::cout << "Cannot solve sudoku maps, counting only\n";
        return 1;
    }

    SudokuLoader sudoku(argc, argv, &std::cin, &std::cout);
    return sudoku.Exec();
}
Example #14
0
bool sudoku(std::vector< std::vector<int> >& data)
{
    int x, y;
    if(!find_free_position(data, x, y))//the sudoku is fully filled now
        return true;
    else
    {
        //get all free positions and iterate
        for(int i = 1; i <= 9; i++)
        {
            if(no_violation(data, x, y, i))
            {
                data[x][y]=i;
                if(sudoku(data))
                    return true;
                data[x][y] = 0;
            }
        }
        return false;//all possibility fails
    }
}
Example #15
0
t_bool	sudoku(char **grid)
{
	int		row;
	int		col;
	char	num;

	if (grid[9] == ERROR)
		return (TRUE);
	if (!find_empty_square(grid, &row, &col))
		return (is_unique_solution(grid));
	num = '1';
	while (num <= '9')
	{
		if (valid_guess(grid, row, col, num))
		{
			grid[row][col] = num;
			if (sudoku(grid))
				return (TRUE);
			grid[row][col] = EMPTY;
		}
		num++;
	}
	return (FALSE);
}