Здравствуйте, Руслан Радионович.
Исходный код решения головоломки "Судоку" Вы можете посмотреть здесь. Пользовательский ввод игровой доски осуществляется записью ссответствующих цифр в текстовый файл filenumbers.txt, который впоследствии загружается программой.

Здравствуйте, Руслан Радионович!
Я написал такую программу с использованием файлов:
1) ввод из файла in.txt;
2) вывод результата в otvet.txt;
3) если у головоломки несколько решений или решений нет - вывод в 1.txt

Приложение:
#include <iostream>
#include <cstdlib>
#include <fstream>
using namespace std;

struct kletka // структура, в которой хранится значение или массив возможных значений
{
int znach;
int vozm[9];
};

void input(kletka **x) // ввод из файла 1.txt
{
ifstream fin("in.txt");
int a;
for(int i=0;i<9;i++)
for(int j=0;j<9;j++)
{
fin >> a;
if(a!=0) x[i][j].znach=a;
else
{
x[i][j].znach=0;
for(int t=0;t<9;t++)
x[i][j].vozm[t]=t+1;
}
}
}

void output(kletka **x,char name[]) // вывод текущего состояния поля
{
ofstream fout(name);
fout << "\n\n";
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
if(x[i][j].znach!=0) fout << " |" << x[i][j].znach << "| \t";
else
{
for(int t=0;t<9;t++)
{
if(x[i][j].vozm[t]!=0) fout << x[i][j].vozm[t];
else fout << ' ';
}
fout << "\t";
}
}
fout << "\n";
}
}

void checklines(kletka **x) // проверка линий
{
for(int i=0;i<9;i++)
for(int j=0;j<9;j++)
if(x[i][j].znach!=0)
{
int m = x[i][j].znach - 1;
for(int t=0;t<9;t++)
if(x[i][t].znach==0) x[i][t].vozm[m]=0;
}
}

void checkrows(kletka **x) // проверка столбцов
{
for(int j=0;j<9;j++)
for(int i=0;i<9;i++)
if(x[i][j].znach!=0)
{
int m = x[i][j].znach - 1;
for(int t=0;t<9;t++)
if(x[t][j].znach==0) x[t][j].vozm[m]=0;
}
}

void checkkvadrs(kletka **x) // проверка квадратов 3х3
{
for(int j=0;j<9;j++)
for(int i=0;i<9;i++)
if(x[i][j].znach!=0)
{
int m = x[i][j].znach - 1;
for(int i1=i-i%3;i1<i-i%3+3;i1++)
for(int j1=j-j%3;j1<j-j%3+3;j1++)
if(x[i1][j1].znach==0) x[i1][j1].vozm[m]=0;
}
}

int checkvozm(kletka **x) // если в клетке одно возможное значение
{
bool ch=0;
for(int j=0;j<9;j++)
for(int i=0;i<9;i++)
{
int s=0,c;
for(int t=0;t<9;t++)
if(x[i][j].vozm[t]!=0)
{
s++;
c=t;
}
if(s==1)
{
x[i][j].znach=x[i][j].vozm[c];
x[i][j].vozm[c]=0;
ch++;
}
}
return ch;
}

void otvet(kletka **x) // проверка: является данное состояние решением?
{
bool cond=true;
for(int j=0;j<9;j++)
for(int i=0;i<9;i++)
if(x[i][j].znach==0) cond=false;
if(cond) // да - вывод в файл otvet.txt
{
ofstream fout("otvet.txt");
for(int j=0;j<9;j++)
{
for(int i=0;i<9;i++) fout << x[i][j].znach << " ";
fout << "\n";
}
}
else // нет - вывод возможных значений в файл 1.txt
{
cout << "Otvetov neskolko ili otveta net";
output(x,"1.txt");
}
}

int main()
{
kletka **a;
a=(kletka**)calloc(9,sizeof(kletka*));
for(int i=0;i<9;i++) a[i]=(kletka*)calloc(9,sizeof(kletka));
input(a);
do
{
checklines(a);
checkrows(a);
checkkvadrs(a);
}
while(checkvozm(a)!=0);
otvet(a);
system("pause");
return 0;
}

Здравствуйте, Руслан Радионович.
Я тоже увлекаюсь Судоку. И тоже были мысли написать программу...:)
Правда, все руки не доходят довести до ума. Дарю свои наработки...Может у Вас получится...

Приложение:
#include <windows.h>

#define OF(i,j) ((i)*9+(j))
#define OFF(i,j,k) (((i)*9+(j))*10+(k))


BYTE bExample[9*9] =
{0, 0, 0, 0, 0, 1, 2, 3, 0,
0, 0, 0, 0, 6, 0, 0, 8, 1,
0, 0, 0, 7, 3, 0, 0, 0, 4,
0, 0, 4, 0, 0, 9, 0, 0, 2,
0, 5, 6, 0, 0, 0, 4, 9, 0,
9, 0, 0, 4, 0, 0, 5, 0, 0,
6, 0, 0, 0, 1, 5, 0, 0, 0,
1, 9, 0, 0, 8, 0, 0, 0, 0,
0, 2, 5, 3, 0, 0, 0, 0, 0} ;
/*
{0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0} ;
*/
// структуры для поиска по 3-му способу
typedef struct tagARRAY
{
DWORD dwIndex ; // здесь сохраним индекс в оригинальной структуре
DWORD dwCount ; // количество вариантов в клетке
DWORD dwElement[9] ; // сами значения вариантов в клетке
} ARRAY, *NPARRAY ;

typedef struct tagSUDOKU
{
DWORD dwLenArray ; // количество клеток, с вариантами > 1
ARRAY array[9] ; // массив данных
DWORD dwIndexes[7] ; // здесь индексы
DWORD dwNumbers[9] ; // здесь сами числа
} SUDOKU, *NPSUDOKU ;

DWORD Init_bArray(BYTE * pbInArray, BYTE * pbArray) ;
void View_bArray(BYTE * pbInArray, BYTE * pbArray) ;
BOOL NextIndex(DWORD dwGroup, DWORD i, DWORD dwType, DWORD * pdwRow, DWORD * pdwCol) ;
DWORD AnalizeGroup(BYTE * pbArray, DWORD dwGroup, DWORD dwType, BOOL * pfRepeat,
DWORD * pdwCount, DWORD * pdwRow, DWORD * pdwCol) ;
BOOL NextGroup(DWORD dwGroupMax, DWORD dwAllMax, DWORD pdwData[], BOOL fFirst) ;
DWORD AnalizeGroup3(BYTE * pbArray, DWORD dwGroup, DWORD dwType) ;
DWORD TestArray(BYTE * pbArray, DWORD * pdwCount, DWORD * pdwRow, DWORD * pdwCol) ;
DWORD TestArray3(BYTE * pbArray) ;
DWORD SearchSolution(BYTE * pbArray, DWORD * pdwCount, BYTE * pbRezult) ;
DWORD AnalyzeSudoku(BYTE * pbInArray, BYTE * pbRezult) ;
int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow) ;

DWORD Init_bArray(BYTE * pbInArray, BYTE * pbArray)
{
DWORD dwCount = 81 ;
int i, j, k ;
BYTE bCh ;

for (i=0; i<9; i++)
{
for (j=0; j<9; j++)
{
bCh = pbInArray[OF(i,j)] ;
if (bCh)
{
pbArray[OFF(i,j,0)] = 1 ;
pbArray[OFF(i,j,1)] = bCh ;
dwCount-- ;
}
else
for (k=1,pbArray[OFF(i,j,0)]=9; k<10; pbArray[OFF(i,j,k)]=(BYTE)k, k++) ;
}
}
return dwCount ;
} // end of Init_bArray

void View_bArray(BYTE * pbInArray, BYTE * pbArray)
{
int i, j ;
BYTE *pData ;

for (i=0; i<9; i++)
{
for (j=0; j<9; j++)
{
pData = (BYTE*)&pbArray[OFF(i,j,0)] ;
if (pData[0]==1)
pbInArray[OF(i,j)] = pData[1] ;
}
}
} // end of View_bArray

//типы выборок
#define TYPE_ROW 0 //по строкам
#define TYPE_COL 1 //по столбцам
#define TYPE_SQU 2 //в квадратах

//коды возврата AnalizeGroup и TestArray
#define RET_ERROR -1 //некорректность
#define RET_FOUND 1 //найдено очередное число
#define RET_NOTFOUND 0 //не найдено ничего

BOOL NextIndex(DWORD dwGroup, DWORD i, DWORD dwType, DWORD * pdwRow, DWORD * pdwCol)
{
if ((dwGroup>8) | (i>8))
return FALSE ;

switch (dwType)
{
case TYPE_ROW:
*pdwRow = dwGroup ;
*pdwCol = i ;
break ;
case TYPE_COL:
*pdwRow = i ;
*pdwCol = dwGroup ;
break ;
case TYPE_SQU:
*pdwRow = (dwGroup/3)*3 + ((i/3) % 3);
*pdwCol = (dwGroup % 3)*3 + (i % 3);
break ;
default:
return FALSE ;
}
return TRUE ;
}

DWORD AnalizeGroup(BYTE * pbArray, DWORD dwGroup, DWORD dwType, BOOL * pfRepeat,
DWORD * pdwCount, DWORD * pdwRow, DWORD * pdwCol)
{
DWORD i, j, k, l ;
DWORD dwRow, dwCol ;
DWORD dwRow1, dwCol1 ;
BYTE *pData, *pData1 ;
BOOL fContinue ;

// Правило 1 - для найденных убрать для всех клеток группы
for (i=0; i<9; i++)
{
NextIndex(dwGroup, i, dwType, &dwRow, &dwCol) ;
pData = (BYTE*)&pbArray[OFF(dwRow,dwCol,0)] ;

if (pData[0] == 1)
{
for (j=0; j<9; j++)
{
if (j != i)
{
NextIndex(dwGroup, j, dwType, &dwRow1, &dwCol1) ;
pData1 = (BYTE*)&pbArray[OFF(dwRow1,dwCol1,0)] ;
if (pData1[0]>1)
{
for (k=1; k<=pData1[0]; k++)
{
if (pData1[k] == pData[1])
{
*pfRepeat = TRUE ;
for (l=k; l<pData1[0]; l++)
pData1[l] = pData1[l+1] ;
if (--pData1[0] == 1)
{
*pdwRow = dwRow1 ;
*pdwCol = dwCol1 ;
(*pdwCount)-- ;
return RET_FOUND ;
}
break ;
}
}
}
else if (pData[1] == pData1[1])
{
*pdwRow = MAKELONG(LOWORD(dwRow),LOWORD(dwRow1)) ;
*pdwCol = MAKELONG(LOWORD(dwCol),LOWORD(dwCol1)) ;
return RET_ERROR ;
}
}
}
}
}

// Правило 2 - если какое-то число только в одной клетке, то там оно и есть
for (i=0; i<9; i++)
{
NextIndex(dwGroup, i, dwType, &dwRow, &dwCol) ;
pData = (BYTE*)&pbArray[OFF(dwRow,dwCol,0)] ;
if (pData[0] > 1)
{
for (k=0; k<pData[0]; k++) //по каждому числу
{
for (j=0,fContinue=TRUE; (j<9) && fContinue; j++) //по остальным клеткам
{
if (j != i)
{
NextIndex(dwGroup, j, dwType, &dwRow1, &dwCol1) ;
pData1 = (BYTE*)&pbArray[OFF(dwRow1,dwCol1,0)] ;
if (pData1[0]>1)
{
for (l=0; l<pData1[0]; l++)
{
if (pData1[l+1] == pData[k+1])
{
fContinue = FALSE ;
break ;
}
}
}
}
}
if (fContinue)
{
pData[0] = 1 ;
pData[1] = pData[k+1] ;
*pdwRow = dwRow ;
*pdwCol = dwCol ;
(*pdwCount)-- ;
return RET_FOUND ;
}
}
}
}
return RET_NOTFOUND ;
} // end of AnalizeGroup

BOOL NextGroup(DWORD dwGroupMax, DWORD dwAllMax, DWORD * pdwData, BOOL fFirst)
{
DWORD i ;

if (fFirst)
{
for (i=0; i<dwGroupMax; i++)
*(pdwData+i) = i ;
return TRUE ;
}
switch (dwGroupMax)
{
case 2:
if (++(*(pdwData+1)) < dwAllMax)
return TRUE ;
if (++(*pdwData) == (dwAllMax-1))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
return TRUE ;
case 3:
if (++(*(pdwData+2)) < dwAllMax)
return TRUE ;
if (++(*(pdwData+1)) < (dwAllMax-1))
{
*(pdwData+2) = (*(pdwData+1))+1 ;
return TRUE ;
}
if (++(*pdwData) == (dwAllMax-2))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
*(pdwData+2) = (*pdwData)+2 ;
return TRUE ;
case 4:
if (++(*(pdwData+3)) < dwAllMax)
return TRUE ;
if (++(*(pdwData+2)) < (dwAllMax-1))
{
*(pdwData+3) = (*(pdwData+2))+1 ;
return TRUE ;
}
if (++(*(pdwData+1)) < (dwAllMax-2))
{
*(pdwData+2) = (*(pdwData+1))+1 ;
*(pdwData+3) = (*(pdwData+2))+1 ;
return TRUE ;
}
if (++(*pdwData) == (dwAllMax-3))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
*(pdwData+2) = (*pdwData)+2 ;
*(pdwData+3) = (*pdwData)+3 ;
return TRUE ;
case 5:
if (++(*(pdwData+4)) < dwAllMax)
return TRUE ;
if (++(*(pdwData+3)) < (dwAllMax-1))
{
*(pdwData+4) = (*(pdwData+3))+1 ;
return TRUE ;
}
if (++(*(pdwData+2)) < (dwAllMax-2))
{
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
return TRUE ;
}
if (++(*(pdwData+1)) < (dwAllMax-3))
{
*(pdwData+2) = (*(pdwData+1))+1 ;
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
return TRUE ;
}
if (++(*pdwData) == (dwAllMax-4))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
*(pdwData+2) = (*pdwData)+2 ;
*(pdwData+3) = (*pdwData)+3 ;
*(pdwData+4) = (*pdwData)+4 ;
return TRUE ;
case 6:
if (++(*(pdwData+5)) < dwAllMax)
return TRUE ;
if (++(*(pdwData+4)) < (dwAllMax-1))
{
*(pdwData+5) = (*(pdwData+4))+1 ;
return TRUE ;
}
if (++(*(pdwData+3)) < (dwAllMax-2))
{
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
return TRUE ;
}
if (++(*(pdwData+2)) < (dwAllMax-3))
{
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
return TRUE ;
}
if (++(*(pdwData+1)) < (dwAllMax-4))
{
*(pdwData+2) = (*(pdwData+1))+1 ;
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
return TRUE ;
}
if (++(*pdwData) == (dwAllMax-5))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
*(pdwData+2) = (*pdwData)+2 ;
*(pdwData+3) = (*pdwData)+3 ;
*(pdwData+4) = (*pdwData)+4 ;
*(pdwData+5) = (*pdwData)+5 ;
return TRUE ;
case 7:
if (++(*(pdwData+6)) < dwAllMax)
return TRUE ;
if (++(*(pdwData+5)) < (dwAllMax-1))
{
*(pdwData+6) = (*(pdwData+5))+1 ;
return TRUE ;
}
if (++(*(pdwData+4)) < (dwAllMax-2))
{
*(pdwData+5) = (*(pdwData+4))+1 ;
*(pdwData+6) = (*(pdwData+5))+1 ;
return TRUE ;
}
if (++(*(pdwData+3)) < (dwAllMax-3))
{
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
*(pdwData+6) = (*(pdwData+5))+1 ;
return TRUE ;
}
if (++(*(pdwData+2)) < (dwAllMax-4))
{
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
*(pdwData+6) = (*(pdwData+5))+1 ;
return TRUE ;
}
if (++(*(pdwData+1)) < (dwAllMax-5))
{
*(pdwData+2) = (*(pdwData+1))+1 ;
*(pdwData+3) = (*(pdwData+2))+1 ;
*(pdwData+4) = (*(pdwData+3))+1 ;
*(pdwData+5) = (*(pdwData+4))+1 ;
*(pdwData+6) = (*(pdwData+5))+1 ;
return TRUE ;
}
if (++(*pdwData) == (dwAllMax-6))
return FALSE ;
*(pdwData+1) = (*pdwData)+1 ;
*(pdwData+2) = (*pdwData)+2 ;
*(pdwData+3) = (*pdwData)+3 ;
*(pdwData+4) = (*pdwData)+4 ;
*(pdwData+5) = (*pdwData)+5 ;
*(pdwData+6) = (*pdwData)+6 ;
return TRUE ;
default:
return FALSE ;
}
} // end of NextGroup

DWORD AnalizeGroup3(BYTE * pbArray, DWORD dwGroup, DWORD dwType)
{
DWORD i, j, k, l, m ;
DWORD dwRow, dwCol ;
BYTE *pData ;
BOOL fFound, fNotFound ;
SUDOKU sudoku ;

// Правило 3 (для сложных судоку) - если в ряду N чисел в N клетках, то в остальных их не может быть
// Сначала скопируем в дополнительную структуру sudoku
sudoku.dwLenArray = 0 ;
for (i=0; i<9; i++)
{
NextIndex(dwGroup, i, dwType, &dwRow, &dwCol) ;
pData = (BYTE*)&pbArray[OFF(dwRow,dwCol,0)] ;
if (pData[0] > 1)
{
l = sudoku.dwLenArray ;
sudoku.array[l].dwIndex = i ;
j = sudoku.array[l].dwCount = pData[0] ;
for (k=0; k<j; k++)
sudoku.array[l].dwElement[k] = pData[k+1] ;
sudoku.dwLenArray++ ;
}
}
if (sudoku.dwLenArray < 4) // только, если >= 4 клеток
return RET_NOTFOUND ;

// начнем анализ
for (l=2; l<(sudoku.dwLenArray-1); l++) // ищем группы 2,3,...,dwLenArray-2
{
NextGroup(l, sudoku.dwLenArray, sudoku.dwIndexes, TRUE);
do
{
fFound = FALSE ;
j = sudoku.array[sudoku.dwIndexes[0]].dwCount ; // вначале количество равно количеству первого элемента
memcpy(sudoku.dwNumbers, sudoku.array[sudoku.dwIndexes[0]].dwElement, j<<2) ; // первый элемент берем полностью

for (i=1; i<l; i++) // со второго и дальше
{
for (k=0; k<sudoku.array[sudoku.dwIndexes[i]].dwCount; k++) // по числам проверяемого элемента
{
for (fNotFound=TRUE,m=0; m<j; m++) // по результируещему массиву чисел
{
if (sudoku.dwNumbers[m] == sudoku.array[sudoku.dwIndexes[i]].dwElement[k])
{
fNotFound = FALSE;
break ;
}
}
if (fNotFound)
sudoku.dwNumbers[j++] = sudoku.array[sudoku.dwIndexes[i]].dwElement[k] ;
}
}
if (j == l)
{
fFound = TRUE ;
break ;
}
} while (NextGroup(l, sudoku.dwLenArray, sudoku.dwIndexes, FALSE)) ;

if (fFound) // Нашли последовательность !
{
fFound = FALSE ;
for (i=0; i<sudoku.dwLenArray; i++)
{
for (fNotFound=TRUE,k=0; k<l; k++)
{
if (i == sudoku.dwIndexes[k])
{
fNotFound = FALSE ;
break ;
}
}
if (fNotFound)
{
NextIndex(dwGroup, sudoku.array[i].dwIndex, dwType, &dwRow, &dwCol) ;
pData = (BYTE*)&pbArray[OFF(dwRow,dwCol,0)] ;

for (j=0; j<pData[0]; j++)
{
for (k=0; k<l; k++)
{
if (pData[j+1] == (BYTE)sudoku.dwNumbers[k])
{
fFound = TRUE ;
for (m=j; m<(DWORD)(pData[0]-1); m++)
pData[m+1] = pData[m+2] ;
pData[0]-- ;
j-- ; // в цикле опять будет +1 (проверим с того же места)
break ;
}
}
}
}
}
return ((DWORD)fFound) ;
}
}

return RET_NOTFOUND ;
} // end of AnalizeGroup3

DWORD TestArray(BYTE * pbArray, DWORD * pdwCount, DWORD * pdwRow, DWORD * pdwCol)
{
DWORD i, dwRet ;
BOOL fRepeat = TRUE ;

while (fRepeat)
{
fRepeat = FALSE ;
for (i=0; i<9; i++)
{
// по строкам
if (dwRet = AnalizeGroup(pbArray, i, TYPE_ROW, &fRepeat, pdwCount, pdwRow, pdwCol))
return dwRet;
// по столбцам
if (dwRet = AnalizeGroup(pbArray, i, TYPE_COL, &fRepeat, pdwCount, pdwRow, pdwCol))
return dwRet;
// по квадратам
if (dwRet = AnalizeGroup(pbArray, i, TYPE_SQU, &fRepeat, pdwCount, pdwRow, pdwCol))
return dwRet;
}
}
return RET_NOTFOUND ;
} // end of TestArray

DWORD TestArray3(BYTE * pbArray)
{
DWORD i, dwRet ;

for (i=0; i<9; i++)
{
// по строкам
if (dwRet = AnalizeGroup3(pbArray, i, TYPE_ROW))
return dwRet;
// по столбцам
if (dwRet = AnalizeGroup3(pbArray, i, TYPE_COL))
return dwRet;
// по квадратам
if (dwRet = AnalizeGroup3(pbArray, i, TYPE_SQU))
return dwRet;
}
return dwRet ; // dwRet=RET_NOTFOUND
} // end of TestArray

DWORD SearchSolution(BYTE * pbArray, DWORD * pdwCount, BYTE * pbRezult)
{
DWORD dwRet ;
DWORD dwRow, dwCol ;
do
{
do
{
dwRet = TestArray(pbArray, pdwCount, &dwRow, &dwCol) ; //анализ методами 1 и 2
} while(*pdwCount && (dwRet == RET_FOUND)) ;

if (*pdwCount && (dwRet == RET_NOTFOUND))
dwRet = TestArray3(pbArray) ; // более сложный анализ методом 3

if (*pdwCount && (dwRet == RET_NOTFOUND))
{
}
} while(*pdwCount && (dwRet == RET_FOUND)) ;

View_bArray(pbRezult, pbArray) ;
return dwRet ;
} // end of SearchSolution

DWORD AnalyzeSudoku(BYTE * pbInArray, BYTE * pbRezult)
{
DWORD dwRet, dwCount ;
BYTE * pbArray = (BYTE *)malloc(9*9*10);

dwCount = Init_bArray(pbInArray, pbArray) ;
dwRet = SearchSolution(pbArray, &dwCount, pbRezult) ;

free(pbArray) ;
return dwRet ;
} // end of AnalyzeSudoku

int PASCAL WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpszCmdLine, int nCmdShow)
{
BYTE * pbRezult = (BYTE *)malloc(9*9);

AnalyzeSudoku((BYTE*)&bExample, pbRezult) ;

free(pbRezult) ;
return 0 ;
} // end of WinMain