Sudoku : kompiluje się, ale nie pokazuje już rozwiązanego sudoku

0

Witam, przychodzę z problemem takim jak w temacie. Program po kompilacji i uruchomieniu nie pokazuje rozwiązania, tylko nierozwiązane sudoku.

main.cpp

#include <iostream>
#include "funkcje.h"

using namespace std;

int tab[9][9]
{
    {3, 0, 6, 5, 0, 8, 4, 0, 0},
    {5, 2, 0, 0, 0, 0, 0, 0, 0},
    {0, 8, 7, 0, 0, 0, 0, 3, 1},
    {0, 0, 3, 0, 1, 0, 0, 8, 0},
    {9, 0, 0, 8, 6, 3, 0, 0, 5},
    {0, 5, 0, 0, 9, 0, 6, 0, 0},
    {1, 3, 0, 0, 0, 0, 2, 5, 0},
    {0, 0, 0, 0, 0, 0, 0, 7, 4},
    {0, 0, 5, 2, 0, 6, 3, 0, 0}

};

 bool sudoku() // wyszukuje puste miejsca i wstawia odpowiednia liczbe 
{
     int wiersz=0, kolumna=0;

    if (!puste_miejsce(wiersz, kolumna))
        return true;
    for (int liczba = 1; liczba <= 9; liczba++)
    {
        if (miejsce(wiersz, kolumna, liczba))
        {
            tab[wiersz][kolumna] = liczba;
            if (sudoku())
            {
                return true;
            }
            else
                tab[wiersz][kolumna] = 0;
        }
    }
    return false;
}

 void wstawsudoku() // tworzymy sudoku
 {
     for (int wiersz = 0; wiersz < 9; wiersz++)
     {
         for (int kolumna = 0; kolumna < 9; kolumna++)
         {
             if (kolumna == 3 || kolumna == 6)

                 cout << " | ";
                 cout << tab[wiersz][kolumna] << " ";

         }
            if (wiersz == 2 || wiersz == 5)
             {
                 cout<< endl;
                 for (int i = 0; i < 9; i++)
                    cout << "---";

             }
            cout<< endl;
     }

 }

int main()
{

    if (sudoku() == true)
        wstawsudoku();

}

funkcje.cpp

#include "funkcje.h"

bool szukanie_w_kolumnie(const int& kolumna, const int& liczba) // sprawdzamy czy w kolumnie już liczba czy nie
{
    for (int wiersz = 0; wiersz < 9; wiersz++)
    {
        if (tab[wiersz][kolumna] == liczba)
            return true;
        else
            return false;   

    }

}

bool szukanie_w_wierszu( const int& wiersz, const int& liczba)//sprawdzamy czy w wierszu już liczba czy nie
{
    for (int kolumna = 0; kolumna < 9; kolumna++)
    {
        if (tab[wiersz][kolumna] == liczba)
            return true;
        else
            return false;   
    }

}

bool szukanie_w_kwadracie(const int& kwadrat_kolumna, const int& kwadrat_wiersz, const int& liczba) // sprawdzamy czy w kwadracie 3x3 jest juz liczba czy nie
{
    for (int kolumna = 0; kolumna < 3; kolumna++)
    {
        for (int wiersz = 0; wiersz < 3; wiersz++)
        {
            if (tab[wiersz + kwadrat_wiersz][kolumna + kwadrat_kolumna] == liczba)
                return true;
            else
                return false;   
        } 

    }

}

bool puste_miejsce(const int& kolumna, const int& wiersz) //szukamy pustego miejsca w sudoku
{
    for (int wiersz = 0; wiersz < 9; wiersz++)
    {
        for (int kolumna = 0; kolumna < 9; kolumna++)
        {
            if (tab[wiersz][kolumna] == 0)
                return true;
            else
                return false;   

        }

    }

}

bool miejsce(const int& wiersz, const int& kolumna,  const int& liczba) // sprawdza czy mozna wstawic liczbe do danego miejsca
{
    return !szukanie_w_wierszu(wiersz, liczba) && !szukanie_w_kolumnie(kolumna, liczba) && !szukanie_w_kwadracie(wiersz - wiersz % 3, kolumna - kolumna % 3, liczba);
}

funkcje.h

#pragma once
#ifndef FUNKCJEH
#define FUNKCJEH

extern int tab[9][9];

bool szukanie_w_kolumnie(const int& kolumna, const  int& liczba);
bool szukanie_w_wierszu(const  int& wiersz, const int& liczba);
bool szukanie_w_kwadracie(const int& kwadrat_kolumna, const int& kwadrat_wiersz, const int& liczba);
bool puste_miejsce(const int& kolumna, const int& wiersz);
bool miejsce( const int& wiersz, const int& kolumna, const int& liczba);

#endif 
0
_13th_Dragon napisał(a):

https://pl.wikipedia.org/wiki/Debugowanie

Dodam, że wielką niewykorzystaną szansą jest programowanie obiektowe - jakieś niesamowite listy argumentów itd by to się ładnie uprościło, czy publiczna tablica globalna.
na razie to jest C z const referencjami int (nie wiadomo po co)

0

Korzystając z okazji pochwalę się, chociaż nie wiem czy jest czym.

#include <iostream>

    int sudoku[9][9] =
    {
        {3, 0, 6, 5, 0, 8, 4, 0, 0},
        {5, 2, 0, 0, 0, 0, 0, 0, 0},
        {0, 8, 7, 0, 0, 0, 0, 3, 1},
        {0, 0, 3, 0, 1, 0, 0, 8, 0},
        {9, 0, 0, 8, 6, 3, 0, 0, 5},
        {0, 5, 0, 0, 9, 0, 6, 0, 0},
        {1, 3, 0, 0, 0, 0, 2, 5, 0},
        {0, 0, 0, 0, 0, 0, 0, 7, 4},
        {0, 0, 5, 2, 0, 6, 3, 0, 0}
    };

void print_array();
bool posible(int x, int y, int n);
void solver();

int main()
{
    solver();
    return 0;
}

void print_array()
{
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
            std::cout << sudoku[i][j] << ' ';
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

bool posible(int x, int y, int n)
{
    for (int i = 0; i < 9; i++) //sprawdzenie wiersza
        if (sudoku[y][i] == n)
            return false;
    for (int i = 0; i < 9; i++) //sprawdzenie kolumny
        if (sudoku[i][x] == n)
            return false;
    int x0 = (x / 3) * 3;
    int y0 = (y / 3) * 3;
    for (int i = 0; i < 3; i++)
        for (int j = 0; j < 3; j++)
            if (sudoku[y0 + i][x0 + j] == n)
                return false;
    return true;    
}

void solver()
{
    for (int i = 0; i < 9; i++)
    {
        for (int j = 0; j < 9; j++)
        {
            if (sudoku[i][j] == 0)
            {
                for (int n = 1; n < 10; n++)
                {
                    if (posible(j, i, n))
                    {
                        sudoku[i][j] = n;
                        solver();
                        sudoku[i][j] = 0;
                    }
                }
                return;
            }     
        } 
    }
    print_array();     
}

Przy pisaniu inspirowałem się tym

1 użytkowników online, w tym zalogowanych: 0, gości: 1, botów: 0