Escritura de un programa para SUDOKU
wada
-
le7amdon -
le7amdon -
Hola
tengo algunos conocimientos de programación y me gustaría escribir un pequeño programa para resolver SUDOKUS!
1) ¿Qué lenguaje sencillo para PC puedo usar?
2) ¿Es posible obtener gratuitamente el compilador adecuado? (¿cobol u otro??)
3) ¿Hay alguien que ya haya hecho este tipo de programa?
¡GRACIAS a todos por leerme!
si alguien pudiera brindarme un poco de ayuda, se lo agradecería mucho!!
¡Hasta pronto!
tengo algunos conocimientos de programación y me gustaría escribir un pequeño programa para resolver SUDOKUS!
1) ¿Qué lenguaje sencillo para PC puedo usar?
2) ¿Es posible obtener gratuitamente el compilador adecuado? (¿cobol u otro??)
3) ¿Hay alguien que ya haya hecho este tipo de programa?
¡GRACIAS a todos por leerme!
si alguien pudiera brindarme un poco de ayuda, se lo agradecería mucho!!
¡Hasta pronto!
17 respuestas
Hola, soy un estudiante de la FST de Túnez, ya he programado en C la solución de los problemas SUDOKU.
Les digo, como futuro ingeniero, que el diseño es más importante en este tipo de problemas.
Aquí está a qué puede parecerse el diseño de este programa:
1- Barrer cada submatriz (o tabla) de 3*3 en busca de un elemento nulo.
2- Asociar a cada casilla vacía encontrada una estructura que contenga un array 'V' de tamaño 9 de probabilidades inicializadas en 0.
3- Barrer las dos filas y columnas (del SUDOKU 9*9) correspondientes al elemento nulo encontrado: si no contienen un cierto número 'a', la casilla de igual rango de 'V' recibe 1.
4- Iterar este proceso hasta encontrar un vector (o array 'V') que solo contenga un único elemento igual a 1, de este modo la casilla correspondiente a este array 'V' recibe el valor del índice que contiene ese 1.
5- Iterar estos 4 pasos tantas veces como sea necesario según la complejidad del SUDOKU (mi programa realiza de 3 a 7 iteraciones).
Por último, me disculpo por no entrar en los detalles estructurales, tengo el honor de responderles, contáctenme y gracias.
Les digo, como futuro ingeniero, que el diseño es más importante en este tipo de problemas.
Aquí está a qué puede parecerse el diseño de este programa:
1- Barrer cada submatriz (o tabla) de 3*3 en busca de un elemento nulo.
2- Asociar a cada casilla vacía encontrada una estructura que contenga un array 'V' de tamaño 9 de probabilidades inicializadas en 0.
3- Barrer las dos filas y columnas (del SUDOKU 9*9) correspondientes al elemento nulo encontrado: si no contienen un cierto número 'a', la casilla de igual rango de 'V' recibe 1.
4- Iterar este proceso hasta encontrar un vector (o array 'V') que solo contenga un único elemento igual a 1, de este modo la casilla correspondiente a este array 'V' recibe el valor del índice que contiene ese 1.
5- Iterar estos 4 pasos tantas veces como sea necesario según la complejidad del SUDOKU (mi programa realiza de 3 a 7 iteraciones).
Por último, me disculpo por no entrar en los detalles estructurales, tengo el honor de responderles, contáctenme y gracias.
En esta dirección hay una implementación en C y otra en Python.
Fue hecha por Rusty Russel (el principal diseñador del Firewall de Linux)
http://ozlabs.org/~rusty/index.cgi/tech/2005-06-20.html
Buena suerte, parece complejo...
Fue hecha por Rusty Russel (el principal diseñador del Firewall de Linux)
http://ozlabs.org/~rusty/index.cgi/tech/2005-06-20.html
Buena suerte, parece complejo...
Buenas noches a todos.
Entonces, yo he hecho un pequeño sitio, y para atraer visitantes me gustaría incluir el juego del Sudoku. ¿Cómo hacerlo?
Gracias de antemano por sus respuestas.
Entonces, yo he hecho un pequeño sitio, y para atraer visitantes me gustaría incluir el juego del Sudoku. ¿Cómo hacerlo?
Gracias de antemano por sus respuestas.
Hola
entonces el lenguaje te diría que puedes hacerlo en cualquiera, pero como soy un adepto de C y Java, solo podría recomendarte esos. Para C tienes el compilador Devc++ que es gratuito ( http://www.bloodshed.net ), y para Java tienes el compilador Eclipse, también gratuito ( http://www.ecipse.org ).
También te aconsejo el sitio http://www.cppfrance.com, en el cual tienes fuentes en C++ sobre la resolución del sudoku. Creo que puedes inspirarte en ello para realizar tu programa y hasta mejorar el algoritmo
Buenas noches
entonces el lenguaje te diría que puedes hacerlo en cualquiera, pero como soy un adepto de C y Java, solo podría recomendarte esos. Para C tienes el compilador Devc++ que es gratuito ( http://www.bloodshed.net ), y para Java tienes el compilador Eclipse, también gratuito ( http://www.ecipse.org ).
También te aconsejo el sitio http://www.cppfrance.com, en el cual tienes fuentes en C++ sobre la resolución del sudoku. Creo que puedes inspirarte en ello para realizar tu programa y hasta mejorar el algoritmo
Buenas noches
Hola,
He programado una página html / javascript para ayudarme a resolver sudokus:
http://www.larmoire.info/jeux/sudoku/ (muy exigente en CPU al inicio)
la versión en C++: http://www.larmoire.info/jeux/sudoku/sudoku.cpp
compilada con djgpp (un gcc para windows) o gcc en linux
la interfaz es por línea de comandos
y una capa adicional al excelente sitio https://www.hugedomains.com/domain_profile.cfm?d=koalog&e=com
que tiene el defecto de mostrar los números mal colocados en relación a la solución y no los que infringen las reglas,
http://www.larmoire.info/jeux/sudoku/koalog.tcl
He programado una página html / javascript para ayudarme a resolver sudokus:
http://www.larmoire.info/jeux/sudoku/ (muy exigente en CPU al inicio)
la versión en C++: http://www.larmoire.info/jeux/sudoku/sudoku.cpp
compilada con djgpp (un gcc para windows) o gcc en linux
la interfaz es por línea de comandos
y una capa adicional al excelente sitio https://www.hugedomains.com/domain_profile.cfm?d=koalog&e=com
que tiene el defecto de mostrar los números mal colocados en relación a la solución y no los que infringen las reglas,
http://www.larmoire.info/jeux/sudoku/koalog.tcl
He codificado una página html / javascript para ayudarme a resolver sudokus:
http://www.larmoire.info/jeux/sudoku/ (muy exigente en cpu al inicio)
Bonito...
http://www.larmoire.info/jeux/sudoku/ (muy exigente en cpu al inicio)
Bonito...
Bueno, en realidad me gustaría saber dónde aprender a programar, pero cuando digo aprender, no me refiero a un tutorial, sino a algo después de lo cual podría arreglármelas solo.
```html
/*====================================================================================== SUDOKU ==
Global:
kuMain grille principale
Opérations de base:
gridClear
gridCopy
cellDisplay partie de gridDisplay
gridDisplay afficher une grille
gridGet lire et vérifier la grille affichée
Calcul de grille:
gridCheck vérifie si une grille est valide
gridPossible calcul préliminaire pour résoudre
gridExtract solution partielle
gridFill solution partielle
gridSolve résoudre récursivement la grille d'entrée
Autres fonctions:
msg
Fonctions non incluses dans cette liste:
fileI/O
interface utilisateur
================================================================================================*/
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#define STD 2
#define ERR 1
#define FATAL 0
#define SINGLE 1
#define SHOW 2
#define SEARCH 4
#define N 3 /* DIMENSION DU SUDOKU */
#define N2 (N * N)
#define N4 (N2*N2)
#define SOLMAX 10 /* nombre maximum de solutions */
/* définition de la grille sudoku */
typedef char KU[N2][N2][N2+1] ; /* si KU[row][col][0] > 0 c'est la valeur définie */
/* sinon KU[row][col][val]= 1 si val est une valeur possible */
KU kuMain ;
int gridCheck(KU ku) ;
/*----------------------------------------------------------------------------------------------*/
void msg(int mask, char *fmt,...) /* afficher un message standard, d'erreur ou fatal */
/*----------------------------------------------------------------------------------------------*/
{
char s[1024] = "" ; /* tampon pour construire le message d'erreur */
int s1 = 0 ; /* compteur de caractères ou de messages */
va_list ap ;
if (mask == ERR)
{
Beep() ;
s1 = sprintf(s, "%s", "** ERREUR ** ") ;
}
va_start(ap, fmt) ; /* construire le message d'erreur */
vsprintf(s + s1, fmt, ap) ;
va_end(ap) ;
/* afficher le message */
switch (mask)
{
case STD :
case ERR :
break ;
case FATAL :
/* afficher le message fatal */
exit(1) ;
}
}
/*===================================================================== OPÉRATION DE BASE & I/O ==*/
/*----------------------------------------------------------------------------------------------*/
void gridClear(KU ku) /* effacer uniquement la partie visible */
/*----------------------------------------------------------------------------------------------*/
{
int r, c ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
ku[r][c][0] = 0 ;
}
/*----------------------------------------------------------------------------------------------*/
void gridCopy(KU kuSrc, KU kuDest) /* copier la grille kuSrc à kuDest */
/*----------------------------------------------------------------------------------------------*/
{
int r, c ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
kuDest[r][c][0] = kuSrc[r][c][0] ;
}
/*----------------------------------------------------------------------------------------------*/
void cellDisplay(int r, int c, int v, int bold)
/*----------------------------------------------------------------------------------------------*/
{
char s[2] = " " ;
int color ;
s[0] = v + '0' ;
if (s[0] == '0') s[0] = '\0' ;
/* afficher le texte s dans la cellule à la colonne c et à la ligne r */
/* attribut du texte : gras */
}
/*----------------------------------------------------------------------------------------------*/
void gridDisplay(KU ku) /* afficher la grille sur UIR */
/*------------------------------------------------------------------------------------------------
Cette fonction affiche la grille source (kuMain) avec des caractères gras.
Si la solution (ku) est définie (non nulle), elle est affichée avec des caractères normaux.
------------------------------------------------------------------------------------------------*/
{
int r, c, v ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
char k = kuMain[r][c][0] ; /* grille source */
int bold = 1 ;
cellDisplay(r, c, k, 1) ;
if (ku && k == 0) /* données remplies */
{
k = ku[r][c][0] ;
bold = 0 ;
}
cellDisplay(r, c, k, bold) ;
}
}
/*----------------------------------------------------------------------------------------------*/
int gridGet(KU ku) /* obtenir la grille de UIR - résultat = même que gridCheck() */
/*----------------------------------------------------------------------------------------------*/
{
int e, r, c ;
gridClear(ku) ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
char s[16] ;
int ic ;
/* obtenir le texte de la cellule à la colonne c et à la ligne r */
switch (strlen(s))
{
case 0 :
ic = 0 ;
break ;
case 1 :
ic = s[0] - '0' ;
if (ic >= 1 && ic <= N2) break ;
default :
msg(ERR, "Cellule non valide") ;
return -1 ;
}
ku[r][c][0] = ic ;
}
e = gridCheck(ku) ;
if (e < 0)
msg(ERR, "Grille non valide") ;
return e ;
}
/*============================================================================ CALCUL DE GRILLE ==*/
/*----------------------------------------------------------------------------------------------*/
int gridCheck(KU ku) /* vérifier si une grille est valide */
/*------------------------------------------------------------------------------------------------
Cette fonction retourne le nombre de cellules définies, et -1 si la grille n'est pas valide.
------------------------------------------------------------------------------------------------*/
{
int b, r, c, rf, cf, v ;
int count[N2 + 1] ; /* index = 1..N2 */
int defined = 0 ;
for (r = 0 ; r < N2 ; r++) /* vérifier les valeurs */
for (c = 0 ; c < N2 ; c++)
{
v = ku[r][c][0] ;
if (v < 0 || v > N2)
return -1 ;
if (v > 0)
defined++ ;
}
for (r = 0 ; r < N2 ; r++) /* traiter les lignes */
{
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (c = 0 ; c < N2 ; c++) /* compter les définis */
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
for (c = 0 ; c < N2 ; c++) /* traiter les colonnes */
{
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (r = 0 ; r < N2 ; r++) /* compter les définis */
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
for (b = 0 ; b < N2 ; b++) /* traiter les blocs */
{
int r1 = N * (b / N) ;
int c1 = (N * b) % N2 ;
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (c = c1 ; c < c1 + N ; c++) /* compter définis */
for (r = r1 ; r < r1 + N ; r++)
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
return defined ; /* la grille est valide */
}
/*----------------------------------------------------------------------------------------------*/
int gridPossible(KU ku) /* définir et compter les valeurs possibles */
/*----------------------------------------------------------------------------------------------*/
{
int r, c, v ;
int possible = 0 ; /* compteur */
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
int r1, c1, r2, c2 ;
if (ku[r][c][0]) /* cas cellule définie */
{
for (v = 1 ; v <= N2 ; v++) /* aucun n'est possible */
ku[r][c][v] = 0 ;
continue ;
}
for (v = 1 ; v <= N2 ; v++) /* au début : tous sont possibles */
ku[r][c][v] = 1 ;
for (c1 = 0 ; c1 < N2 ; c1++) /* traiter la ligne */
{
if (v = ku[r][c1][0])
ku[r][c][v] = 0 ;
}
for (r1 = 0 ; r1 < N2 ; r1++) /* traiter la colonne */
{
if (v = ku[r1][c][0])
ku[r][c][v] = 0 ;
}
c1 = N * (c / N) ; /* traiter le bloc */
c2 = c1 + N ;
for ( ; c1 < c2 ; c1++)
{
r1 = N * (r / N) ;
r2 = r1 + N ;
for ( ; r1 < r2 ; r1++)
{
if (v = ku[r1][c1][0])
ku[r][c][v] = 0 ;
}
}
for (v = 1 ; v <= N2 ; v++) /* compter le nombre de possibles */
if (ku[r][c][v]) possible++ ;
}
return possible ;
}
/*----------------------------------------------------------------------------------------------*/
int gridExtract(KU ku) /* extraire les valeurs uniques possibles */
/*------------------------------------------------------------------------------------------------
Le résultat est le nombre de valeurs trouvées, ou -1 en cas d'erreur
------------------------------------------------------------------------------------------------*/
{
int r, c, v ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
int found = 0 ;
if (ku[r][c][0]) continue ; /* sauter les cellules définies */
for (v = 1 ; v <= N2 ```
/*====================================================================================== SUDOKU ==
Global:
kuMain grille principale
Opérations de base:
gridClear
gridCopy
cellDisplay partie de gridDisplay
gridDisplay afficher une grille
gridGet lire et vérifier la grille affichée
Calcul de grille:
gridCheck vérifie si une grille est valide
gridPossible calcul préliminaire pour résoudre
gridExtract solution partielle
gridFill solution partielle
gridSolve résoudre récursivement la grille d'entrée
Autres fonctions:
msg
Fonctions non incluses dans cette liste:
fileI/O
interface utilisateur
================================================================================================*/
#include <windows.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <stdarg.h>
#define STD 2
#define ERR 1
#define FATAL 0
#define SINGLE 1
#define SHOW 2
#define SEARCH 4
#define N 3 /* DIMENSION DU SUDOKU */
#define N2 (N * N)
#define N4 (N2*N2)
#define SOLMAX 10 /* nombre maximum de solutions */
/* définition de la grille sudoku */
typedef char KU[N2][N2][N2+1] ; /* si KU[row][col][0] > 0 c'est la valeur définie */
/* sinon KU[row][col][val]= 1 si val est une valeur possible */
KU kuMain ;
int gridCheck(KU ku) ;
/*----------------------------------------------------------------------------------------------*/
void msg(int mask, char *fmt,...) /* afficher un message standard, d'erreur ou fatal */
/*----------------------------------------------------------------------------------------------*/
{
char s[1024] = "" ; /* tampon pour construire le message d'erreur */
int s1 = 0 ; /* compteur de caractères ou de messages */
va_list ap ;
if (mask == ERR)
{
Beep() ;
s1 = sprintf(s, "%s", "** ERREUR ** ") ;
}
va_start(ap, fmt) ; /* construire le message d'erreur */
vsprintf(s + s1, fmt, ap) ;
va_end(ap) ;
/* afficher le message */
switch (mask)
{
case STD :
case ERR :
break ;
case FATAL :
/* afficher le message fatal */
exit(1) ;
}
}
/*===================================================================== OPÉRATION DE BASE & I/O ==*/
/*----------------------------------------------------------------------------------------------*/
void gridClear(KU ku) /* effacer uniquement la partie visible */
/*----------------------------------------------------------------------------------------------*/
{
int r, c ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
ku[r][c][0] = 0 ;
}
/*----------------------------------------------------------------------------------------------*/
void gridCopy(KU kuSrc, KU kuDest) /* copier la grille kuSrc à kuDest */
/*----------------------------------------------------------------------------------------------*/
{
int r, c ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
kuDest[r][c][0] = kuSrc[r][c][0] ;
}
/*----------------------------------------------------------------------------------------------*/
void cellDisplay(int r, int c, int v, int bold)
/*----------------------------------------------------------------------------------------------*/
{
char s[2] = " " ;
int color ;
s[0] = v + '0' ;
if (s[0] == '0') s[0] = '\0' ;
/* afficher le texte s dans la cellule à la colonne c et à la ligne r */
/* attribut du texte : gras */
}
/*----------------------------------------------------------------------------------------------*/
void gridDisplay(KU ku) /* afficher la grille sur UIR */
/*------------------------------------------------------------------------------------------------
Cette fonction affiche la grille source (kuMain) avec des caractères gras.
Si la solution (ku) est définie (non nulle), elle est affichée avec des caractères normaux.
------------------------------------------------------------------------------------------------*/
{
int r, c, v ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
char k = kuMain[r][c][0] ; /* grille source */
int bold = 1 ;
cellDisplay(r, c, k, 1) ;
if (ku && k == 0) /* données remplies */
{
k = ku[r][c][0] ;
bold = 0 ;
}
cellDisplay(r, c, k, bold) ;
}
}
/*----------------------------------------------------------------------------------------------*/
int gridGet(KU ku) /* obtenir la grille de UIR - résultat = même que gridCheck() */
/*----------------------------------------------------------------------------------------------*/
{
int e, r, c ;
gridClear(ku) ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
char s[16] ;
int ic ;
/* obtenir le texte de la cellule à la colonne c et à la ligne r */
switch (strlen(s))
{
case 0 :
ic = 0 ;
break ;
case 1 :
ic = s[0] - '0' ;
if (ic >= 1 && ic <= N2) break ;
default :
msg(ERR, "Cellule non valide") ;
return -1 ;
}
ku[r][c][0] = ic ;
}
e = gridCheck(ku) ;
if (e < 0)
msg(ERR, "Grille non valide") ;
return e ;
}
/*============================================================================ CALCUL DE GRILLE ==*/
/*----------------------------------------------------------------------------------------------*/
int gridCheck(KU ku) /* vérifier si une grille est valide */
/*------------------------------------------------------------------------------------------------
Cette fonction retourne le nombre de cellules définies, et -1 si la grille n'est pas valide.
------------------------------------------------------------------------------------------------*/
{
int b, r, c, rf, cf, v ;
int count[N2 + 1] ; /* index = 1..N2 */
int defined = 0 ;
for (r = 0 ; r < N2 ; r++) /* vérifier les valeurs */
for (c = 0 ; c < N2 ; c++)
{
v = ku[r][c][0] ;
if (v < 0 || v > N2)
return -1 ;
if (v > 0)
defined++ ;
}
for (r = 0 ; r < N2 ; r++) /* traiter les lignes */
{
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (c = 0 ; c < N2 ; c++) /* compter les définis */
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
for (c = 0 ; c < N2 ; c++) /* traiter les colonnes */
{
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (r = 0 ; r < N2 ; r++) /* compter les définis */
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
for (b = 0 ; b < N2 ; b++) /* traiter les blocs */
{
int r1 = N * (b / N) ;
int c1 = (N * b) % N2 ;
for (v = 1 ; v <= N2 ; v++) count[v] = 0 ; /* réinitialiser les comptes */
for (c = c1 ; c < c1 + N ; c++) /* compter définis */
for (r = r1 ; r < r1 + N ; r++)
if (v = ku[r][c][0]) count[v]++ ;
for (v = 1 ; v <= N2 ; v++) /* vérifier les comptes */
if (count[v] > 1)
return -1 ;
}
return defined ; /* la grille est valide */
}
/*----------------------------------------------------------------------------------------------*/
int gridPossible(KU ku) /* définir et compter les valeurs possibles */
/*----------------------------------------------------------------------------------------------*/
{
int r, c, v ;
int possible = 0 ; /* compteur */
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
int r1, c1, r2, c2 ;
if (ku[r][c][0]) /* cas cellule définie */
{
for (v = 1 ; v <= N2 ; v++) /* aucun n'est possible */
ku[r][c][v] = 0 ;
continue ;
}
for (v = 1 ; v <= N2 ; v++) /* au début : tous sont possibles */
ku[r][c][v] = 1 ;
for (c1 = 0 ; c1 < N2 ; c1++) /* traiter la ligne */
{
if (v = ku[r][c1][0])
ku[r][c][v] = 0 ;
}
for (r1 = 0 ; r1 < N2 ; r1++) /* traiter la colonne */
{
if (v = ku[r1][c][0])
ku[r][c][v] = 0 ;
}
c1 = N * (c / N) ; /* traiter le bloc */
c2 = c1 + N ;
for ( ; c1 < c2 ; c1++)
{
r1 = N * (r / N) ;
r2 = r1 + N ;
for ( ; r1 < r2 ; r1++)
{
if (v = ku[r1][c1][0])
ku[r][c][v] = 0 ;
}
}
for (v = 1 ; v <= N2 ; v++) /* compter le nombre de possibles */
if (ku[r][c][v]) possible++ ;
}
return possible ;
}
/*----------------------------------------------------------------------------------------------*/
int gridExtract(KU ku) /* extraire les valeurs uniques possibles */
/*------------------------------------------------------------------------------------------------
Le résultat est le nombre de valeurs trouvées, ou -1 en cas d'erreur
------------------------------------------------------------------------------------------------*/
{
int r, c, v ;
for (r = 0 ; r < N2 ; r++)
for (c = 0 ; c < N2 ; c++)
{
int found = 0 ;
if (ku[r][c][0]) continue ; /* sauter les cellules définies */
for (v = 1 ; v <= N2 ```
He captado un juego gratuito de sudoku en 3D realmente bueno: http://sudoku-3d.com. Creo que te debería ayudar :-)
Hola
gracias por su respuesta....pero he formulado mal mi problema y le pido disculpas!
Voy a reformular mi problema intentando ser más claro
1) ¿Puede decirme cuál es, en su opinión, el lenguaje más adecuado para estas diferentes condiciones:
- compilador gratuito para descargar
- para PC Windows XP
- posibilidad de hacer aparecer una cuadrícula (para mi SUDOKU)
de ingresar números y recuperarlos en mi programa
- posibilidad de hacer reaparecer la cuadrícula completada con otros números
- aprendizaje fácil del lenguaje y documentación gratuita
si es posible en FRANCÉS!!
¡Quizás estoy pidiendo demasiado y me disculpo!
Gracias a todos por leerme!
¡Hasta pronto!
gracias por su respuesta....pero he formulado mal mi problema y le pido disculpas!
Voy a reformular mi problema intentando ser más claro
1) ¿Puede decirme cuál es, en su opinión, el lenguaje más adecuado para estas diferentes condiciones:
- compilador gratuito para descargar
- para PC Windows XP
- posibilidad de hacer aparecer una cuadrícula (para mi SUDOKU)
de ingresar números y recuperarlos en mi programa
- posibilidad de hacer reaparecer la cuadrícula completada con otros números
- aprendizaje fácil del lenguaje y documentación gratuita
si es posible en FRANCÉS!!
¡Quizás estoy pidiendo demasiado y me disculpo!
Gracias a todos por leerme!
¡Hasta pronto!
Euh, entonces ya te han dado un poco la respuesta, las restricciones son un poco extrañas, porque puedes hacer visualización gráfica en C, Java, Python u otro. Los compiladores gratuitos existen tanto para Java, C, Python, Delphi, Pascal. Creo que después es tu elección. Pero para mí, hacer una interfaz es más sencillo en Java que en C, en cualquier caso. Para los otros lenguajes no lo sé. Para los tutoriales sobre todos estos lenguajes en francés, te aconsejo el sitio http://www.developpez.com
Ahí tienes.
Ahí tienes.
Bonjour, je dois crear un solucionador de sudoku en lenguaje C, pero el problema es que no sé por dónde empezar. ¿No tienes un algoritmo que puedas pasarme?
¡Gracias!
¡Gracias!
he escrito un solucionador de sudoku
me he servido de vba con interfaz excel
para los algoritmos ver wikipedia
el más sencillo de programar es bastante fácil se construye un array de 9x9 en el que se coloca "123456789"
se añaden las restricciones así si un 1 está dado en (1,1) se reemplaza el "123456789" por "1"
se propagan las restricciones en filas, en columnas y en cuadrados para todas las celdas(?,1) diferentes de (1,1) se quita de "123456789" "1" y para todas las celdas (1,?) se hace lo mismo, se continúa con las celdas de (1,1) a (3;3)
se retoma la cuadrícula desde el principio mientras evoluciona
luego se tienen en cuenta las restricciones implícitas un número
por columna, por fila, por cuadrado y sus combinaciones
este modelo debe iterar mientras hagamos evolucionar la cuadrícula
en ese momento o la cuadrícula está completa (todas las cuadrículas fáciles
se resuelven con menos números introducidos que el problema proporciona)
sino lo más efectivo es proceder por ensayo y error a partir de
los dobles restantes
--
¿no es hermosa la vida?
me he servido de vba con interfaz excel
para los algoritmos ver wikipedia
el más sencillo de programar es bastante fácil se construye un array de 9x9 en el que se coloca "123456789"
se añaden las restricciones así si un 1 está dado en (1,1) se reemplaza el "123456789" por "1"
se propagan las restricciones en filas, en columnas y en cuadrados para todas las celdas(?,1) diferentes de (1,1) se quita de "123456789" "1" y para todas las celdas (1,?) se hace lo mismo, se continúa con las celdas de (1,1) a (3;3)
se retoma la cuadrícula desde el principio mientras evoluciona
luego se tienen en cuenta las restricciones implícitas un número
por columna, por fila, por cuadrado y sus combinaciones
este modelo debe iterar mientras hagamos evolucionar la cuadrícula
en ese momento o la cuadrícula está completa (todas las cuadrículas fáciles
se resuelven con menos números introducidos que el problema proporciona)
sino lo más efectivo es proceder por ensayo y error a partir de
los dobles restantes
--
¿no es hermosa la vida?
Hola,
http://phpsudo.free.fr
Sudoku de código abierto en php y javascript. ¡Cuadrículas de 4*4, 6*6, 8*8, 9*9, 10*10, 12*12, 14*14 y 16*16 números y letras! Solución única, cuadrículas ilimitadas y 3 niveles de dificultad... A seguir...
Me parece bastante bien
http://phpsudo.free.fr
Sudoku de código abierto en php y javascript. ¡Cuadrículas de 4*4, 6*6, 8*8, 9*9, 10*10, 12*12, 14*14 y 16*16 números y letras! Solución única, cuadrículas ilimitadas y 3 niveles de dificultad... A seguir...
Me parece bastante bien
Escribí uno en C hace 2 o 3 años. El problema es la IHM.
En VB, seguramente es más fácil.
Lo retomé en Python hace un año con mucho más placer
y rendimiento:
- búsqueda de soluciones simples primero,
- interactividad con posibilidad de deshacer
- posibilidad de ver todas las soluciones
La ventaja de Python, además de ser gratuito,
es que es muy fácil de instalar y de poner en marcha.
Una IDE formidable y gratuita es Wing101.
Para la documentación, la de ActivePython (1 archivo .chm) es muy práctica.
Para la IHM, Tkinter funciona bien. Se puede hacer todo.
Finalmente, para el diseño, es importante dominar:
- los arrays, los índices,
- las indirections con índices,
- la recursividad
Buena suerte
En VB, seguramente es más fácil.
Lo retomé en Python hace un año con mucho más placer
y rendimiento:
- búsqueda de soluciones simples primero,
- interactividad con posibilidad de deshacer
- posibilidad de ver todas las soluciones
La ventaja de Python, además de ser gratuito,
es que es muy fácil de instalar y de poner en marcha.
Una IDE formidable y gratuita es Wing101.
Para la documentación, la de ActivePython (1 archivo .chm) es muy práctica.
Para la IHM, Tkinter funciona bien. Se puede hacer todo.
Finalmente, para el diseño, es importante dominar:
- los arrays, los índices,
- las indirections con índices,
- la recursividad
Buena suerte
tengo que hacer un proyecto informático sobre la programación de un sudoku en lenguaje EXCEL/VBA o JavaScript.
¿Has hecho alguna vez algo así y podrías ayudarme?
Muchas gracias de antemano.
se espera que haga un programa en C que permita resolver un sudoku
es decir, que debo crear una cuadrícula y resolverla
si es posible, me gustaría que me ayudaras y me dijeras cómo proceder porque, francamente, no sé por dónde empezar :s
gracias de antemano Tamza
Basta con crear funciones o procedimientos que realicen las funciones especificadas, cada acción necesaria en cada paso anunciado por Hamza se presenta en forma de función o procedimiento que logra el objetivo. Pero aquí hay que tener en cuenta el número y los tipos de parámetros que pueden existir en las funciones cada vez.
Buen trabajo :)
Así que, ¿podrías enviarme el programa en C para resolver una cuadrícula de Sudoku? Haré un esfuerzo por entender (con comentarios, si es posible). Mándamelo a mi correo, por favor.
Gracias de nuevo.