fork download 
  1. #include <stdio.h>
  2. #include <string.h>
  3.  
  4. #define MATRIX_ROW (3)
  5. #define MATRIX_COLUMN (3)
  6. #define NUMBER_OF_ROW (9)
  7. #define NUMBER_OF_COLUMN (9)
  8. #define NUMBER_OF_ELEMENTS (9)
  9.  
  10. typedef struct _SUDOKU_CELL
  11. {
  12. 	int current;
  13. 	int nCandidates;
  14. 	int candidates[NUMBER_OF_ELEMENTS + 1];
  15. } SUDOKU_CELL;
  16.  
  17. typedef struct _SUDOKU_PLANE
  18. {
  19. 	int unsolved;
  20. 	SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN];
  21. } SUDOKU_PLANE;
  22.  
  23. void Reset_SudokuPlane(SUDOKU_PLANE *plane)
  24. {
  25. 	int i = 0,j = 0,k = 0;
  26. 	memset(plane,0,sizeof(SUDOKU_PLANE));
  27. 	plane->unsolved = NUMBER_OF_ELEMENTS * NUMBER_OF_ELEMENTS;
  28. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  29. 	{
  30. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  31. 		{
  32. 			plane->cell[i][j].nCandidates = NUMBER_OF_ELEMENTS;
  33. 			for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  34. 			{
  35. 				plane->cell[i][j].candidates[k] = 1;
  36. 			}
  37. 		}
  38. 	}
  39. 	return;
  40. }
  41.  
  42. void Input_SudokuCell(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int rIndex,int cIndex,int n)
  43. {
  44. 	int i = 0,j = 0;
  45. 	int rBase = 0,cBase = 0;
  46. 	if (cell[rIndex][cIndex].current || n == 0)
  47. 		return;
  48. 	rBase = MATRIX_ROW * (rIndex / MATRIX_ROW);
  49. 	cBase = MATRIX_COLUMN * (cIndex / MATRIX_COLUMN);
  50. 	cell[rIndex][cIndex].current = n;
  51. 	cell[rIndex][cIndex].nCandidates = 1;
  52. 	memset(cell[rIndex][cIndex].candidates,0,sizeof(int)*(NUMBER_OF_ELEMENTS + 1));
  53. 	cell[rIndex][cIndex].candidates[n] = 1;
  54. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  55. 	{
  56. 		if (i == rIndex)
  57. 			continue;
  58. 		if (cell[i][cIndex].candidates[n])
  59. 		{
  60. 			cell[i][cIndex].candidates[n] = 0;
  61. 			cell[i][cIndex].nCandidates -= 1;
  62. 		}
  63. 	}
  64. 	for(i = 0;i < NUMBER_OF_COLUMN;++i)
  65. 	{
  66. 		if (i == cIndex)
  67. 			continue;
  68. 		if (cell[rIndex][i].candidates[n])
  69. 		{
  70. 			cell[rIndex][i].candidates[n] = 0;
  71. 			cell[rIndex][i].nCandidates -= 1;
  72. 		}
  73. 	}
  74. 	for(i = 0;i < MATRIX_ROW;++i)
  75. 	{
  76. 		for(j = 0;j < MATRIX_COLUMN;++j)
  77. 		{
  78. 			if (((rBase + i) == rIndex) && ((cBase + j) == cIndex))
  79. 				continue;
  80. 			if (cell[rBase + i][cBase + j].candidates[n])
  81. 			{
  82. 				cell[rBase + i][cBase + j].candidates[n] = 0;
  83. 				cell[rBase + i][cBase + j].nCandidates -= 1;
  84. 			}
  85. 		}
  86. 	}
  87. 	return;
  88. }
  89.  
  90. void Input_SudokuPlane(SUDOKU_PLANE *plane)
  91. {
  92. 	int i = 0,j = 0;
  93. 	int cnt = 0;
  94. 	int n[NUMBER_OF_COLUMN] = {0};
  95. 	static char * const format = "%d,%d,%d,%d,%d,%d,%d,%d,%d";
  96. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  97. 	{
  98. 		cnt +=
  99. 		fscanf(
  100. 		stdin,
  101. 		format,
  102. 		&n[0],
  103. 		&n[1],
  104. 		&n[2],
  105. 		&n[3],
  106. 		&n[4],
  107. 		&n[5],
  108. 		&n[6],
  109. 		&n[7],
  110. 		&n[8]);
  111. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  112. 		{
  113. 			if (n[j])
  114. 			{
  115. 				Input_SudokuCell(plane->cell,i,j,n[j]);
  116. 				plane->unsolved -= 1;
  117. 			}
  118. 		}
  119. 	}
  120. 	return;
  121. }
  122.  
  123. void Show_SudokuPlane(SUDOKU_PLANE *plane)
  124. {
  125. 	int i = 0,j = 0,k = 0;
  126. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  127. 	{
  128. 		fprintf(stdout,"\n");
  129. 		if (i % MATRIX_ROW == 0)
  130. 		{
  131. 			fprintf(stdout,"+");
  132. 			for(k = 0;k < (NUMBER_OF_COLUMN/MATRIX_COLUMN);++k)
  133. 			{
  134. 				for(j = 0;j < MATRIX_COLUMN;++j)
  135. 					fprintf(stdout,"---");
  136. 				fprintf(stdout,"+");
  137. 			}
  138. 			fprintf(stdout,"\n");
  139. 		}
  140. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  141. 		{
  142. 			if (j == 0)
  143. 				fprintf(stdout,"|");
  144. 			if (plane->cell[i][j].current)
  145. 				fprintf(stdout," %d ",plane->cell[i][j]);
  146. 			else
  147. 				fprintf(stdout,"   ");
  148. 			if ((j + 1) % MATRIX_COLUMN == 0)
  149. 				fprintf(stdout,"|");
  150. 		}
  151. 	}
  152. 	fprintf(stdout,"\n");
  153. 	fprintf(stdout,"+");
  154. 	for(k = 0;k < (NUMBER_OF_COLUMN/MATRIX_COLUMN);++k)
  155. 	{
  156. 		for(j = 0;j < MATRIX_COLUMN;++j)
  157. 			fprintf(stdout,"---");
  158. 		fprintf(stdout,"+");
  159. 	}
  160. 	fprintf(stdout,"\n");
  161. 	return;
  162. }
  163.  
  164. int method1(SUDOKU_PLANE *plane)
  165. {
  166. 	int i = 0,j = 0,k = 0;
  167. 	int n = 0;
  168. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  169. 	{
  170. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  171. 		{
  172. 			if (plane->cell[i][j].current == 0 && plane->cell[i][j].nCandidates == 1)
  173. 			{
  174. 				++n;
  175. 				for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  176. 				{
  177. 					if (plane->cell[i][j].candidates[k])
  178. 					{
  179. 						Input_SudokuCell(plane->cell,i,j,k);
  180. 						plane->unsolved -= 1;
  181. 						break;
  182. 					}
  183. 				}
  184. 			}
  185. 		}
  186. 	}
  187. 	return n;
  188. }
  189.  
  190. int find_cell_with_value(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int rIndex,int cIndex,int n,int left,int top,int width,int height,int *row,int *col)
  191. {
  192. 	int i = 0,j = 0;
  193. 	int find = 0;
  194. 	for(i = 0;i < height;++i)
  195. 	{
  196. 		for(j = 0;j < width;++j)
  197. 		{
  198. 			if (((top + i) == rIndex) && ((left + j) == cIndex))
  199. 				continue;
  200. 			if (cell[top + i][left + j].current == 0 && cell[top + i][left + j].candidates[n])
  201. 			{
  202. 				find = 1;
  203. 				if (row)
  204. 					*row = top + i;
  205. 				if (col)
  206. 					*col = left + j;
  207. 				goto _find;
  208. 			}
  209. 		}
  210. 	}
  211. _find:
  212. 	return find;
  213. }
  214.  
  215. int method2(SUDOKU_PLANE *plane)
  216. {
  217. 	int i = 0,j = 0,k = 0;
  218. 	int n = 0;
  219. 	int rBase = 0,cBase = 0;
  220. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  221. 	{
  222. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  223. 		{
  224. 			rBase = MATRIX_ROW * (i / MATRIX_ROW);
  225. 			cBase = MATRIX_COLUMN * (j / MATRIX_COLUMN);
  226. 			if (plane->cell[i][j].current == 0)
  227. 			{
  228. 				for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  229. 				{
  230. 					if (plane->cell[i][j].candidates[k])
  231. 					{
  232. 						if (!find_cell_with_value(plane->cell,i,j,k,0,i,NUMBER_OF_COLUMN,1,NULL,NULL))
  233. 						{
  234. 							++n;
  235. 							Input_SudokuCell(plane->cell,i,j,k);
  236. 							plane->unsolved -= 1;
  237. 							break;
  238. 						}
  239. 						else if (!find_cell_with_value(plane->cell,i,j,k,j,0,1,NUMBER_OF_ROW,NULL,NULL))
  240. 						{
  241. 							++n;
  242. 							Input_SudokuCell(plane->cell,i,j,k);
  243. 							plane->unsolved -= 1;
  244. 							break;
  245. 						}
  246. 						else if (!find_cell_with_value(plane->cell,i,j,k,cBase,rBase,MATRIX_COLUMN,MATRIX_ROW,NULL,NULL))
  247. 						{
  248. 							++n;
  249. 							Input_SudokuCell(plane->cell,i,j,k);
  250. 							plane->unsolved -= 1;
  251. 							break;
  252. 						}
  253. 					}
  254. 				}
  255. 			}
  256. 		}
  257. 	}
  258. 	return n;
  259. }
  260.  
  261. int find_nset(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int rIndex,int cIndex,int left,int top,int width,int height,char f[NUMBER_OF_ROW][NUMBER_OF_COLUMN])
  262. {
  263. 	int i = 0,j = 0;
  264. 	int n = 0;
  265. 	memset(f,0,sizeof(char)*(NUMBER_OF_ROW * NUMBER_OF_COLUMN));
  266. 	for(i = 0;i < height;i++)
  267. 	{
  268. 		for(j = 0;j < width;++j)
  269. 		{
  270. 			if (((top + i) == rIndex) && ((left + j) == cIndex))
  271. 				continue;
  272. 			if (cell[top + i][left + j].current == 0 &&
  273. 				!memcmp(cell[rIndex][cIndex].candidates,cell[top + i][left + j].candidates,sizeof(int)*(NUMBER_OF_ELEMENTS + 1)))
  274. 			{
  275. 				++n;
  276. 				f[top + i][left + j] = 1;
  277. 			}
  278. 		}
  279. 	}
  280. 	++n;
  281. 	return n;
  282. }
  283.  
  284. int method3(SUDOKU_PLANE *plane)
  285. {
  286. 	int i = 0,j = 0,k = 0,l = 0,m = 0;
  287. 	int rBase = 0,cBase = 0;
  288. 	int n = 0;
  289. 	char f[NUMBER_OF_ROW][NUMBER_OF_COLUMN] = {0};
  290. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  291. 	{
  292. 		for(j = 0;j < NUMBER_OF_COLUMN;++j)
  293. 		{
  294. 			rBase = MATRIX_ROW * (i / MATRIX_ROW);
  295. 			cBase = MATRIX_COLUMN * (j / MATRIX_COLUMN);
  296. 			if (plane->cell[i][j].current == 0)
  297. 			{
  298. 				if (plane->cell[i][j].nCandidates == find_nset(plane->cell,i,j,0,i,NUMBER_OF_COLUMN,1,f))
  299. 				{
  300. 					++n;
  301. 					for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  302. 					{
  303. 						if (plane->cell[i][j].candidates[k])
  304. 						{
  305. 							for(l = 0;l < NUMBER_OF_COLUMN;++l)
  306. 							{
  307. 								if (l == j)
  308. 									continue;
  309. 								if (!f[i][l] && plane->cell[i][l].candidates[k])
  310. 								{
  311. 									plane->cell[i][l].candidates[k] = 0;
  312. 									plane->cell[i][l].nCandidates -= 1;
  313. 								}
  314. 							}
  315. 						}
  316. 					}
  317. 				}
  318. 				if (plane->cell[i][j].nCandidates == find_nset(plane->cell,i,j,j,0,1,NUMBER_OF_ROW,f))
  319. 				{
  320. 					++n;
  321. 					for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  322. 					{
  323. 						if (plane->cell[i][j].candidates[k])
  324. 						{
  325. 							for(l = 0;l < NUMBER_OF_ROW;++l)
  326. 							{
  327. 								if (l == i)
  328. 									continue;
  329. 								if (!f[l][j] && plane->cell[l][j].candidates[k])
  330. 								{
  331. 									plane->cell[l][j].candidates[k] = 0;
  332. 									plane->cell[l][j].nCandidates -= 1;
  333. 								}
  334. 							}
  335. 						}
  336. 					}
  337. 				}
  338. 				if (plane->cell[i][j].nCandidates == find_nset(plane->cell,i,j,cBase,rBase,MATRIX_COLUMN,MATRIX_ROW,f))
  339. 				{
  340. 					++n;
  341. 					for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  342. 					{
  343. 						if (plane->cell[i][j].candidates[k])
  344. 						{
  345. 							for(l = 0;l < MATRIX_ROW;++l)
  346. 							{
  347. 								for(m = 0;m < MATRIX_COLUMN;++m)
  348. 								{
  349. 									if (((rBase + l) == i) && ((cBase + m) == j))
  350. 										continue;
  351. 									if (!f[rBase + l][cBase + m] && plane->cell[rBase + l][cBase + m].candidates[k])
  352. 									{
  353. 										plane->cell[rBase + l][cBase + m].candidates[k] = 0;
  354. 										plane->cell[rBase + l][cBase + m].nCandidates -= 1;
  355. 									}
  356. 								}
  357. 							}
  358. 						}
  359. 					}
  360. 				}
  361. 			}
  362. 		}
  363. 	}
  364. 	return n;
  365. }
  366.  
  367. int method4_sub1(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int rIndex)
  368. {
  369. 	int i = 0,j = 0,k = 0;
  370. 	int rBase = 0,cBase = 0;
  371. 	int n = 0;
  372. 	const int nBlock = (NUMBER_OF_ROW / MATRIX_ROW) * (NUMBER_OF_COLUMN / MATRIX_COLUMN);
  373. 	int nHitBlock = 0;
  374. 	int block[(NUMBER_OF_ROW / MATRIX_ROW) * (NUMBER_OF_COLUMN / MATRIX_COLUMN)] = {0};
  375. 	for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  376. 	{
  377. 		nHitBlock = 0;
  378. 		memset(block,0,sizeof(int)*nBlock);
  379. 		for(i = 0;i < NUMBER_OF_COLUMN;++i)
  380. 		{
  381. 			if (cell[rIndex][i].current == 0 && cell[rIndex][i].candidates[k])
  382. 			{
  383. 				if (block[MATRIX_ROW*(rIndex / MATRIX_ROW) + (i / MATRIX_COLUMN)] == 0)
  384. 					block[MATRIX_ROW*(rIndex / MATRIX_ROW) + (i / MATRIX_COLUMN)] += 1;
  385. 			}
  386. 		}
  387. 		for(i = 0; i< nBlock;++i)
  388. 			nHitBlock += block[i];
  389. 		if (nHitBlock == 1)
  390. 		{
  391. 			for(i = 0;i < nBlock;++i)
  392. 			{
  393. 				if (block[i])
  394. 				{
  395. 					rBase = MATRIX_ROW * (i / MATRIX_ROW);
  396. 					cBase = MATRIX_COLUMN * (i % MATRIX_ROW);
  397. 					for(i = 0;i < MATRIX_ROW;++i)
  398. 					{
  399. 						for(j = 0;j < MATRIX_COLUMN;++j)
  400. 						{
  401. 							if ((rBase + i) == rIndex)
  402. 								continue;
  403. 							if (cell[rBase + i][cBase + j].current == 0 &&
  404. 								cell[rBase + i][cBase + j].candidates[k])
  405. 							{
  406. 								++n;
  407. 								cell[rBase + i][cBase + j].candidates[k] = 0;
  408. 								cell[rBase + i][cBase + j].nCandidates -= 1;
  409. 							}
  410. 						}
  411. 					}
  412. 					break;
  413. 				}
  414. 			}
  415. 		}
  416. 	}
  417. 	return n;
  418. }
  419.  
  420. int method4_sub2(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int cIndex)
  421. {
  422. 	int i = 0,j = 0,k = 0;
  423. 	int rBase = 0,cBase = 0;
  424. 	int n = 0;
  425. 	const int nBlock = (NUMBER_OF_ROW / MATRIX_ROW) * (NUMBER_OF_COLUMN / MATRIX_COLUMN);
  426. 	int block[(NUMBER_OF_ROW / MATRIX_ROW) * (NUMBER_OF_COLUMN / MATRIX_COLUMN)] = {0};
  427. 	int nHitBlock = 0;
  428. 	for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  429. 	{
  430. 		nHitBlock = 0;
  431. 		memset(block,0,sizeof(int)*nBlock);
  432. 		for(i = 0;i < NUMBER_OF_ROW;++i)
  433. 		{
  434. 			if (cell[i][cIndex].current == 0 && cell[i][cIndex].candidates[k])
  435. 			{
  436. 				if (block[MATRIX_ROW*(i / MATRIX_ROW) + (cIndex / MATRIX_COLUMN)] == 0)
  437. 					block[MATRIX_ROW*(i / MATRIX_ROW) + (cIndex / MATRIX_COLUMN)] += 1;
  438. 			}
  439. 		}
  440. 		for(i = 0;i < nBlock;++i)
  441. 		{
  442. 			nHitBlock += block[i];
  443. 		}
  444. 		if (nHitBlock == 1)
  445. 		{
  446. 			for(i = 0;i < nBlock;++i)
  447. 			{
  448. 				if (block[i])
  449. 				{
  450. 					rBase = MATRIX_ROW * (i / MATRIX_ROW);
  451. 					cBase = MATRIX_COLUMN * (i % MATRIX_ROW);
  452. 					for(i = 0;i < MATRIX_ROW;++i)
  453. 					{
  454. 						for(j = 0;j < MATRIX_COLUMN;++j)
  455. 						{
  456. 							if ((cBase + j) == cIndex)
  457. 								continue;
  458. 							if (cell[rBase + i][cBase + j].current == 0 &&
  459. 								cell[rBase + i][cBase + j].candidates[k])
  460. 							{
  461. 								++n;
  462. 								cell[rBase + i][cBase + j].candidates[k] = 0;
  463. 								cell[rBase + i][cBase + j].nCandidates -= 1;
  464. 							}
  465. 						}
  466. 					}
  467. 					break;
  468. 				}
  469. 			}
  470. 		}
  471. 	}
  472. 	return n;
  473. }
  474.  
  475. int method4_sub3(SUDOKU_CELL cell[NUMBER_OF_ROW][NUMBER_OF_COLUMN],int rIndex,int cIndex)
  476. {
  477. 	int i = 0,j = 0,k = 0;
  478. 	int rBase = 0,cBase = 0;
  479. 	int n = 0;
  480. 	int row[NUMBER_OF_ROW] = {0};
  481. 	int column[NUMBER_OF_COLUMN] = {0};
  482. 	int nHitRow = 0;
  483. 	int nHitColumn = 0;
  484. 	for(k = 1;k <= NUMBER_OF_ELEMENTS;++k)
  485. 	{
  486. 		nHitRow = 0;
  487. 		nHitColumn = 0;
  488. 		memset(row,0,sizeof(row));
  489. 		memset(column,0,sizeof(column));
  490. 		rBase = MATRIX_ROW * (rIndex / MATRIX_ROW);
  491. 		cBase = MATRIX_COLUMN * (cIndex / MATRIX_COLUMN);
  492. 		for(i = 0;i < MATRIX_ROW;++i)
  493. 		{
  494. 			for(j = 0;j < MATRIX_COLUMN;++j)
  495. 			{
  496. 				if (cell[rBase + i][cBase + j].current == 0 &&
  497. 					cell[rBase + i][cBase + j].candidates[k])
  498. 				{
  499. 					if (row[rBase + i] == 0)
  500. 					{
  501. 						row[rBase + i] += 1;
  502. 					}
  503. 					if (column[cBase + j] == 0)
  504. 					{
  505. 						column[cBase + j] += 1;
  506. 					}
  507. 				}
  508. 			}
  509. 		}
  510. 		for(i = 0;i < NUMBER_OF_ROW;++i)
  511. 			nHitRow += row[i];
  512. 		for(i = 0;i < NUMBER_OF_COLUMN;++i)
  513. 			nHitColumn += column[i];
  514. 		if (nHitRow == 1)
  515. 		{
  516. 			for(i = 0;i < NUMBER_OF_ROW;++i)
  517. 			{
  518. 				if (row[i])
  519. 				{
  520. 					for(j = 0;j < NUMBER_OF_COLUMN;++j)
  521. 					{
  522. 						if (cBase <= j && j < (cBase + MATRIX_COLUMN))
  523. 							continue;
  524. 						if (cell[i][j].current == 0 && cell[i][j].candidates[k])
  525. 						{
  526. 							++n;
  527. 							cell[i][j].candidates[k] = 0;
  528. 							cell[i][j].nCandidates -= 1;
  529. 						}
  530. 					}
  531. 					break;
  532. 				}
  533. 			}
  534. 		}
  535. 		else if (nHitColumn == 1)
  536. 		{
  537. 			for(j = 0;j < NUMBER_OF_COLUMN;++j)
  538. 			{
  539. 				if (column[j])
  540. 				{
  541. 					for(i = 0;i < NUMBER_OF_ROW;++i)
  542. 					{
  543. 						if (rBase <= i && i < (rBase + MATRIX_ROW))
  544. 							continue;
  545. 						if (cell[i][j].current == 0 && cell[i][j].candidates[k])
  546. 						{
  547. 							++n;
  548. 							cell[i][j].candidates[k] = 0;
  549. 							cell[i][j].nCandidates -= 1;
  550. 						}
  551. 					}
  552. 					break;
  553. 				}
  554. 			}
  555. 		}
  556. 	}
  557. 	return n;
  558. }
  559.  
  560. int method4(SUDOKU_PLANE *plane)
  561. {
  562. 	int i = 0,j = 0;
  563. 	int n = 0;
  564. 	for(i = 0;i < NUMBER_OF_ROW;++i)
  565. 	{
  566. 		n += method4_sub1(plane->cell,i);
  567. 	}
  568. 	for(i = 0;i < NUMBER_OF_COLUMN;++i)
  569. 	{
  570. 		n += method4_sub2(plane->cell,i);
  571. 	}
  572. 	for(i = 0;i < MATRIX_ROW;++i)
  573. 	{
  574. 		for(j = 0;j < MATRIX_COLUMN;++j)
  575. 		{
  576. 			n += method4_sub3(plane->cell,MATRIX_ROW*i,MATRIX_COLUMN*j);
  577. 		}
  578. 	}
  579. 	return n;
  580. }
  581.  
  582. int Solve_SudokuPlane(SUDOKU_PLANE *plane)
  583. {
  584. 	int cnt = 0;
  585. 	while(plane->unsolved)
  586. 	{
  587. 		for(;;)
  588. 		{
  589. 			if (!method1(plane))
  590. 				break;
  591. 		}
  592. 		for(;;)
  593. 		{
  594. 			if (!method2(plane))
  595. 				break;
  596. 		}
  597. 		method3(plane);
  598. 		method4(plane);
  599. 		if (++cnt > 800)
  600. 			break;
  601. 	}
  602. 	return (plane->unsolved == 0);
  603. }
  604.  
  605. int isSolved(SUDOKU_PLANE *plane)
  606. {
  607. 	return (plane->unsolved == 0);
  608. }
  609.  
  610. int main(int argc,char **argv)
  611. {
  612. 	SUDOKU_PLANE plane;
  613. 	Reset_SudokuPlane(&plane);
  614. 	Input_SudokuPlane(&plane);
  615. 	Show_SudokuPlane(&plane);
  616. 	fprintf(stdout,"Thinking... Please wait...\n");
  617. 	Solve_SudokuPlane(&plane);
  618. 	Show_SudokuPlane(&plane);
  619. 	if (!isSolved(&plane))
  620. 	{
  621. 		fprintf(stdout,"Sorry but, I cannot solve this Sudoku...\n");
  622. 		fprintf(stdout,"It is difficult for me to solve this Sudoku !\n");
  623. 	}
  624. 	return 0;
  625. }
  626.  
Success #stdin #stdout 0.05s 2048KB
comments (?)
stdin 
0,0,9,5,0,3,1,0,0
0,7,1,0,0,0,9,6,0
3,4,0,0,0,0,0,2,5
0,0,0,1,0,4,0,0,0
0,0,3,8,0,9,2,0,0
0,9,0,0,0,0,0,1,0
0,1,5,9,0,2,7,3,0
0,0,0,3,0,6,0,0,0
0,0,0,0,0,0,0,0,0
stdout 
+---------+---------+---------+
|       9 | 5     3 | 1       |
|    7  1 |         | 9  6    |
| 3  4    |         |    2  5 |
+---------+---------+---------+
|         | 1     4 |         |
|         | 8     9 | 2       |
|    9    |         |    1    |
+---------+---------+---------+
|    1  5 | 9     2 | 7  3    |
|         | 3     6 |         |
|         |         |         |
+---------+---------+---------+

Thinking... Please wait...
Sorry but, I cannot solve this Sudoku...
It is difficult for me to solve this Sudoku !
Entering Brute-force mode...

1 th solution:

+---------+---------+---------+
| 8  2  9 | 5  6  3 | 1  4  7 |
| 5  7  1 | 2  4  8 | 9  6  3 |
| 3  4  6 | 7  9  1 | 8  2  5 |
+---------+---------+---------+
| 2  6  8 | 1  7  4 | 3  5  9 |
| 1  5  4 | 8  3  9 | 2  7  6 |
| 7  9  3 | 6  2  5 | 4  1  8 |
+---------+---------+---------+
| 6  1  5 | 9  8  2 | 7  3  4 |
| 4  8  7 | 3  1  6 | 5  9  2 |
| 9  3  2 | 4  5  7 | 6  8  1 |
+---------+---------+---------+
2 th solution:

+---------+---------+---------+
| 8  2  9 | 5  6  3 | 1  4  7 |
| 5  7  1 | 2  4  8 | 9  6  3 |
| 3  4  6 | 7  9  1 | 8  2  5 |
+---------+---------+---------+
| 7  6  8 | 1  2  4 | 3  5  9 |
| 1  5  4 | 8  3  9 | 2  7  6 |
| 2  9  3 | 6  5  7 | 4  1  8 |
+---------+---------+---------+
| 6  1  5 | 9  8  2 | 7  3  4 |
| 4  8  7 | 3  1  6 | 5  9  2 |
| 9  3  2 | 4  7  5 | 6  8  1 |
+---------+---------+---------+
3 th solution:

+---------+---------+---------+
| 8  2  9 | 5  6  3 | 1  4  7 |
| 5  7  1 | 2  4  8 | 9  6  3 |
| 3  4  6 | 7  9  1 | 8  2  5 |
+---------+---------+---------+
| 7  6  8 | 1  2  4 | 3  5  9 |
| 1  5  4 | 8  3  9 | 2  7  6 |
| 2  9  3 | 6  7  5 | 4  1  8 |
+---------+---------+---------+
| 6  1  5 | 9  8  2 | 7  3  4 |
| 4  8  7 | 3  1  6 | 5  9  2 |
| 9  3  2 | 4  5  7 | 6  8  1 |
+---------+---------+---------+
4 th solution:

+---------+---------+---------+
| 2  8  9 | 5  6  3 | 1  4  7 |
| 5  7  1 | 2  4  8 | 9  6  3 |
| 3  4  6 | 7  9  1 | 8  2  5 |
+---------+---------+---------+
| 8  5  2 | 1  3  4 | 6  7  9 |
| 1  6  3 | 8  7  9 | 2  5  4 |
| 7  9  4 | 6  2  5 | 3  1  8 |
+---------+---------+---------+
| 4  1  5 | 9  8  2 | 7  3  6 |
| 9  2  7 | 3  5  6 | 4  8  1 |
| 6  3  8 | 4  1  7 | 5  9  2 |
+---------+---------+---------+
5 th solution:

+---------+---------+---------+
| 8  2  9 | 5  6  3 | 1  4  7 |
| 5  7  1 | 2  4  8 | 9  6  3 |
| 3  4  6 | 7  9  1 | 8  2  5 |
+---------+---------+---------+
| 7  6  8 | 1  2  4 | 3  5  9 |
| 1  5  4 | 8  3  9 | 2  7  6 |
| 2  9  3 | 6  5  7 | 4  1  8 |
+---------+---------+---------+
| 6  1  5 | 9  8  2 | 7  3  4 |
| 4  8  2 | 3  7  6 | 5  9  1 |
| 9  3  7 | 4  1  5 | 6  8  2 |
+---------+---------+---------+
This Sudoku has 5 solution.
https://ideone.com/SRAHM0
Sudoku !
language:
C (gcc 8.3)
created:
11 years ago
visibility:
secret

Share or Embed source code

Discover > Sphere Engine API

The brand new service which powers Ideone!

Discover > IDE Widget

Widget for compiling and running the source code in a web browser!