elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.

 

 


Tema destacado: Trabajando con las ramas de git (tercera parte)


  Mostrar Mensajes
Páginas: 1 2 3 [4] 5
31  Programación / Programación C/C++ / Re: PROBLEMA DE LOS DOS CUERPOS en: 28 Noviembre 2012, 23:11 pm
Les dejo en el siguiente enlace el programa:
http://cypascal.blogspot.com.es/2012/11/orbita-de-la-tierra-entorno-al-sol.html

y aqui mismo:
Código:
#include <stdio.h>
#include <math.h>


const int L=31536000;/*SEGS. EN UN AÑO*/
const double dt=1;/*DT ES UN SEG.*/
const double m1=5.97e24, m2=1.99e30, G= 6.674e-11;

int i;
double F,coseno,seno,d;

struct estado{
	double X;
	double Y;
	double Vx;
	double Vy;
	double Ax;
	double Ay;
}Solido1[L];

//Situacion inicial;	


int main()
{
	Solido1[0].X=1.5e11;
	Solido1[0].Y=0;
	Solido1[0].Vx=0;
	Solido1[0].Vy=2.98e4;
	
	d=sqrt(pow(Solido1[0].X,2)+pow(Solido1[0].X,2));
	F=(G*m1*m2)/(pow(d,2));
	
	Solido1[0].Ax=-F/m1;
	Solido1[0].Ay=0;
	
	printf("\n\n     ORBITA DE LA TIERRA EN TORNO AL SOL\n\n\n");
	
	for (i=1;i<=L;i++)
	{
		Solido1[i].X=Solido1[i-1].X+Solido1[i-1].Vx*dt;
		Solido1[i].Y=Solido1[i-1].Y+Solido1[i-1].Vy*dt;
		
		d=sqrt(pow(Solido1[i].X,2)+pow(Solido1[i].Y,2));
		coseno=Solido1[i].X/d;
		seno=Solido1[i].Y/d;
		
		Solido1[i].Vx=Solido1[i-1].Vx+Solido1[i-1].Ax*dt;
		Solido1[i].Vy=Solido1[i-1].Vy+Solido1[i-1].Ay*dt;
		
		F=(G*m1*m2)/(pow(d,2));
		Solido1[i].Ax=-F*coseno/m1;
		Solido1[i].Ay=-F*seno/m1;
		
		if ((i%86400)==1){/*PARA NO IMPRIMIR DEMASIDADOS DATOS*/ 
			printf(" DIA %4d)  X=%10.4f MKm",i/86400,Solido1[i].X/1000000000);
			printf("   Y=%10.4f MKm",Solido1[i].Y/1000000000);
			printf("   d=%10.4f MKm\n",d/1000000000);
		}	
	}
	
	printf("\n\n MKm significa MegaKilometro o Millones de kilometros.");
	return 0;
}

Un Saludo!
32  Programación / Programación C/C++ / C/C++ RESOLVER SUDOKU en: 28 Noviembre 2012, 01:30 am
Pues eso, que me he hecho un programa que resuelve sudokus en C/C++ (Está escrito en C) y me gustaría enseñaroslo a ver que opinais. ¿En que se diferencia de los demás? Pués en que resuelve los sudokus mediante lógica, como los humanos, no mediante prueba y error. Aprovechando que los resuelve de este modo, el programa indica las técnicas utilizadas para llegar a la resolución total.

En cuanto a como introducri los datos y tal, el programa es bastante cutre, cuando tenga tiempo ya mejoraré ese aspecto. De todas formas, se explica en el enlace que os dejo, basicamente es crear un fichero de texto con los numeros quel sudoku, y en caso de casillas vacias poner un 0. Las tecnicas que utiliza se explican en la segunda entrada, en la primera está el codigo.
Os lo dejo en esta dirección el programa:

http://cypascal.blogspot.com.es/2012/09/include-include-visita-www.html
http://cypascal.blogspot.com.es/2012/09/resolver-sudokus-en-cc.html

y tambien aqui. (Son demasiadas lineas pero bueno).

Código:
#include <stdio.h>
#include <stdlib.h>

/*VISITA WWW.CYPASCAL.BLOGSPOT.COM*/

struct TpCasilla
	{
		int HayNum;
		int Num;
		int Posibilidades;
		int Posibles[10];
	};



void LecturaDatos(struct TpCasilla T[][10]);
void InicializarDatos(struct TpCasilla T[][10]);
void ImprimeDatos(struct TpCasilla T[][10]);
void ImprimeDatos2(struct TpCasilla T[][10]);
void ImprimeDatos3(struct TpCasilla T[][10]);
void ImprimeDatos4(struct TpCasilla T[][10]);

void CandidatosSolos(struct TpCasilla T[][10], int *P);
void CandBloq1(struct TpCasilla T[][10], int *P,int U[]);
void CandBloq2(struct TpCasilla T[][10], int *P,int U[]);
void Desnudas(struct TpCasilla T[][10], int *P,int U[]);
void Escondidas(struct TpCasilla T[][10], int *P,int U[]);
void X_Wing(struct TpCasilla T[][10], int *P,int U[]);

int main(void)
{
	struct TpCasilla Tablero[10][10]; 
	int Usos[20],a,Puesto;
	
	printf("\n\n         Bienvenido a 'SUDOKU RESOLVER'\n\n"); 
	printf("Si quieres mas informacion visita WWW.CYPASCAL.BLOGSPOT.COM\n\n\n");
	InicializarDatos(Tablero); 
	LecturaDatos(Tablero);
	
	Puesto=1;
	ImprimeDatos4(Tablero); a=0;
	for(a=1;a<=20;a++) Usos[a]=0;
	
	while (Puesto==1){
		Puesto=0;
		CandidatosSolos(Tablero,&Puesto);
		if (Puesto==0){
			CandBloq1(Tablero,&Puesto,Usos);
		if(Puesto==0){
			CandBloq2(Tablero,&Puesto,Usos);
		if (Puesto==0){
			Desnudas(Tablero,&Puesto,Usos);
		if (Puesto==0){
			Escondidas(Tablero,&Puesto,Usos); 
		if (Puesto==0){
			X_Wing(Tablero,&Puesto,Usos);
		}}}}}
		ImprimeDatos4(Tablero);
	}
	
	if(Usos[1]==1) printf("\n Se ha utilizado Candidatos Bloqueados 1\n");
	if(Usos[2]==1) printf("\n Se ha utilizado Candidatos Bloqueados 2\n");
	if(Usos[3]==1) printf("\n Se ha utilizado Desnudas Parejas\n");
	if(Usos[4]==1) printf("\n Se ha utilizado Desnudas Trios\n");
	if(Usos[5]==1) printf("\n Se ha utilizado Desnudas Cuartetos\n");
	if(Usos[6]==1) printf("\n Se ha utilizado Escondidos Parejas\n");
	if(Usos[7]==1) printf("\n Se ha utilizado Escondidos Trios\n");
	if(Usos[8]==1) printf("\n Se ha utilizado Escondidos Cuartetos\n");
	if(Usos[9]==1) printf("\n Se ha utilizado X-Wing\n");
	if(Usos[10]==1) printf("\n Se ha utilizado Swordfish\n");
	scanf("%c");
	return(0);
}

void CandidatosSolos(struct TpCasilla T[][10], int *P){
	int a,b,c,d,e,N;
	for (b=1;b<=9;b++)
	for (a=1;a<=9;a++){
		if (T[a][b].HayNum==1){
			N=T[a][b].Num;
			for (c=1;c<=9;c++)
				if (T[a][c].HayNum==0) {
					if (T[a][c].Posibles[N]!=0){
						T[a][c].Posibles[N]=0;
						T[a][c].Posibilidades--;
						*P=1;}
					if (T[a][c].Posibilidades==1) {
						*P=1;
						e=1;
						while (T[a][c].Posibles[e]!=1) e++;
						T[a][c].Posibilidades=0;
						T[a][c].Num=e;
						T[a][c].HayNum=1;
				}}
				
				for (c=1;c<=9;c++)
					if (T[c][b].HayNum==0) {
						if (T[c][b].Posibles[N]!=0){
							T[c][b].Posibles[N]=0;
							T[c][b].Posibilidades--;
							*P=1;}
						if (T[c][b].Posibilidades==1) {
							*P=1;
							e=1;
							while (T[c][b].Posibles[e]!=1) e++;
							T[c][b].Posibilidades=0;
							T[c][b].Num=e;
							T[c][b].HayNum=1;
					}}
				
				for (c=(((a-1)/3)*3+1);c<=(((a-1)/3)*3+3);c++)
					for(d=(((b-1)/3)*3+1);d<=(((b-1)/3)*3+3);d++){
						if (T[c][d].HayNum==0) {
							if (T[c][d].Posibles[N]!=0){
								T[c][d].Posibles[N]=0;
								T[c][d].Posibilidades--;
								*P=1;}
							
							if (T[c][d].Posibilidades==1) {
								*P=1;
								e=1;
								while (T[c][d].Posibles[e]!=1) e++;
								T[c][d].Posibilidades=0;
								T[c][d].Num=e;
								T[c][d].HayNum=1;
}}}}}}	

void CandBloq1(struct TpCasilla T[][10], int *P,int U[])
{
	struct TpPos
		{
			int Fila;
			int Columna;
		};
	
	int FilR,ColR,Fil,Col,N,AlinF,AlinC;
	struct TpPos Pos[10];
	
	for (FilR=1;FilR<=3;FilR++)
		for (ColR=1;ColR<=3;ColR++)
			for (N=1;N<=9;N++){
				Pos[0].Fila=0;
				for (Fil=((3*FilR)-2);Fil<=(3*FilR);Fil++)
				for (Col=((3*ColR)-2);Col<=(3*ColR);Col++)
					if ((T[Fil][Col].Posibles[N]==1)&&(T[Fil][Col].HayNum==0))
					{	
						Pos[0].Fila++;
						Pos[Pos[0].Fila].Fila=Fil;
						Pos[Pos[0].Fila].Columna=Col;
					}
				if (Pos[0].Fila==1){
					T[Pos[1].Fila][Pos[1].Columna].HayNum=1;
					T[Pos[1].Fila][Pos[1].Columna].Num=N;
					T[Pos[1].Fila][Pos[1].Columna].Posibilidades=0;
					*P=1;
					U[1]=1;
					for (Col=1;Col<=9;Col++)
						T[Pos[1].Fila][Pos[1].Columna].Posibles[Col]=0;
				}
				else if (Pos[0].Fila>=1){ 
					AlinF=1;AlinC=1;
					for (Col=1;Col<=Pos[0].Fila;Col++){
						if (Pos[Col].Fila!=Pos[1].Fila) AlinF=0;
						if (Pos[Col].Columna!=Pos[1].Columna) AlinC=0;
					}
					if (AlinF==1)
						for (Col=1;Col<=9;Col++)
							if (((((Col-1)/3)+1)!=ColR)&&
								(T[Pos[1].Fila][Col].HayNum==0)&&
								(T[Pos[1].Fila][Col].Posibles[N]!=0)){
								*P=1;
								T[Pos[1].Fila][Col].Posibles[N]=0;
								T[Pos[1].Fila][Col].Posibilidades--;
								U[1]=1;
							}
					if (AlinC==1)
						for (Fil=1;Fil<=9;Fil++)
							if (((((Fil-1)/3)+1)!=FilR)&&
								(T[Fil][Pos[1].Columna].HayNum==0)&&
								(T[Fil][Pos[1].Columna].Posibles[N]!=0)){
								T[Fil][Pos[1].Columna].Posibles[N]=0;
								T[Fil][Pos[1].Columna].Posibilidades--;
								*P=1;
								U[1]=1;
}}}}

void CandBloq2(struct TpCasilla T[][10], int *P,int U[])
{
	int Fil,Fil2,Col,Col2,N,Pos[10],Mismo3x3,MismaCol,MismaFil;
	
	for (Fil=1;Fil<=9;Fil++)
		for(N=1;N<=9;N++){
			Pos[0]=0;Mismo3x3=1;
			for(Col=1;Col<=9;Col++)
				if ((T[Fil][Col].Posibles[N]==1)&&(T[Fil][Col].HayNum==0)){
					Pos[0]++;
					Pos[Pos[0]]=Col;
					if (((Col-1)/3)!=((Pos[1]-1)/3)) Mismo3x3=0;
				}
			if (Mismo3x3==1){ 
				if (Pos[0]==1){
					T[Fil][Pos[1]].HayNum=1;
					T[Fil][Pos[1]].Num=N;
					T[Fil][Pos[1]].Posibilidades=0;
					*P=1;
					U[2]=1;
				}
				if (Pos[0]!=0) 
					for (Col2=((((Pos[1]-1)/3)*3)+1);
						Col2<=((((Pos[1]-1)/3)+1)*3);Col2++)
						for (Fil2=((((Fil-1)/3)*3)+1);
							Fil2<=((((Fil-1)/3)+1)*3);Fil2++)	
							if ((T[Fil2][Col2].Posibles[N]==1)&&
								(T[Fil2][Col2].HayNum==0)){
								MismaCol=0;
								for (Col=1;Col<=Pos[0];Col++)
									if (Pos[Col]==Col2) MismaCol=1;
								if ((MismaCol==0)||(Fil!=Fil2)){
									T[Fil2][Col2].Posibilidades--;
									T[Fil2][Col2].Posibles[N]=0;
									*P=1;
									U[2]=1;}
}}}
	
	for (Col=1;Col<=9;Col++)
		for(N=1;N<=9;N++){
			Pos[0]=0;Mismo3x3=1;
			for(Fil=1;Fil<=9;Fil++){
				if ((T[Fil][Col].Posibles[N]==1)&&(T[Fil][Col].HayNum==0)){
					Pos[0]++;
					Pos[Pos[0]]=Fil;
					if (((Fil-1)/3)!=((Pos[1]-1)/3)) Mismo3x3=0;
				}
				
			}
			if (Mismo3x3==1){
				if (Pos[0]==1){
					T[Pos[1]][Col].HayNum=1;
					T[Pos[1]][Col].Num=N;
					T[Pos[1]][Col].Posibilidades=0;
					U[2]=1;
					*P=1;}
				if (Pos[0]!=0)
					for (Fil2=((((Pos[1]-1)/3)*3)+1);
						Fil2<=((((Pos[1]-1)/3)+1)*3);Fil2++)
						for (Col2=((((Col-1)/3)*3)+1);
							Col2<=((((Col-1)/3)+1)*3);Col2++)	
							if ((T[Fil2][Col2].Posibles[N]==1)&&
								(T[Fil2][Col2].HayNum==0)){
								MismaFil=0;
								if (Pos[0]!=0) for (Fil=1;Fil<=Pos[0];Fil++) 
									if (Pos[Fil]==Fil2) MismaFil=1;
								if ((MismaFil==0)||(Col!=Col2)){
									T[Fil2][Col2].Posibilidades--;
									T[Fil2][Col2].Posibles[N]=0;
									U[2]=1;
									*P=1;
}}}}}

void Desnudas(struct TpCasilla T[][10], int *P,int U[])
{
	int a[2],b[2],c[2],d[2],N,N2,Fila,Col,Pos[10];

	for (Fila=1;Fila<=9;Fila++)
		for (a[0]=1;a[0]<=8;a[0]++)
		for (b[0]=a[0]+1;b[0]<=9;b[0]++)
			if((T[Fila][a[0]].HayNum==0)&&(T[Fila][b[0]].HayNum==0)){
				Pos[0]=0;
				for (N=1;N<=9;N++)
					if ((T[Fila][a[0]].Posibles[N]==1)||
						(T[Fila][b[0]].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
					}
				if (Pos[0]==2){
					for (N=0;N<=9;N++)
						if (((a[0]!=N)&&(b[0]!=N))&&(T[Fila][N].HayNum==0)){
							if (T[Fila][N].Posibles[Pos[1]]==1){
								T[Fila][N].Posibles[Pos[1]]=0;
								T[Fila][N].Posibilidades--;
								U[3]=1;
								*P=1;}
							if (T[Fila][N].Posibles[Pos[2]]==1){
								T[Fila][N].Posibles[Pos[2]]=0;
								T[Fila][N].Posibilidades--;
								U[3]=1;
								*P=1;}
}}}

	for (Fila=1;Fila<=9;Fila++)
		for (a[0]=1;a[0]<=7;a[0]++)
		for (b[0]=a[0]+1;b[0]<=8;b[0]++)
		for (c[0]=b[0]+1;c[0]<=9;c[0]++)
			if((T[Fila][a[0]].HayNum==0)&&(T[Fila][b[0]].HayNum==0)
				&&(T[Fila][c[0]].HayNum==0)){
				Pos[0]=0;
				for (N=1;N<=9;N++){
					if ((T[Fila][a[0]].Posibles[N]==1)||
						(T[Fila][b[0]].Posibles[N]==1)
						||(T[Fila][c[0]].Posibles[N]==1)){
							Pos[0]++;
							Pos[Pos[0]]=N;
						}}
					if (Pos[0]==3){
						for (N=0;N<=9;N++)
							if (((a[0]!=N)&&(b[0]!=N)&&(c[0]!=N))&&
								(T[Fila][N].HayNum==0)){
								if (T[Fila][N].Posibles[Pos[1]]==1){
									T[Fila][N].Posibles[Pos[1]]=0;
									T[Fila][N].Posibilidades--;
									U[4]=1;
									*P=1;}
								if (T[Fila][N].Posibles[Pos[2]]==1){
									T[Fila][N].Posibles[Pos[2]]=0;
									T[Fila][N].Posibilidades--;
									U[4]=1;
									*P=1;}
								if (T[Fila][N].Posibles[Pos[3]]==1){
									T[Fila][N].Posibles[Pos[3]]=0;
									T[Fila][N].Posibilidades--;
									U[4]=1;
									*P=1;}
}}}

	for (Fila=1;Fila<=9;Fila++)
		for (a[0]=1;a[0]<=6;a[0]++)
		for (b[0]=a[0]+1;b[0]<=7;b[0]++)
		for (c[0]=b[0]+1;c[0]<=8;c[0]++)
		for (d[0]=c[0]+1;d[0]<=9;d[0]++)
			if((T[Fila][a[0]].HayNum==0)&&(T[Fila][b[0]].HayNum==0)
				&&(T[Fila][c[0]].HayNum==0)&&(T[Fila][d[0]].HayNum==0)){
				Pos[0]=0;
				for (N=1;N<=9;N++){
					if ((T[Fila][a[0]].Posibles[N]==1)||
						(T[Fila][b[0]].Posibles[N]==1)||
						(T[Fila][c[0]].Posibles[N]==1)||
						(T[Fila][d[0]].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
				}}
				if (Pos[0]==4){
					for (N=0;N<=9;N++)
						if (((a[0]!=N)&&(b[0]!=N)&&(c[0]!=N)
							&&(d[0]!=N))&&(T[Fila][N].HayNum==0)){
							if (T[Fila][N].Posibles[Pos[1]]==1){
								T[Fila][N].Posibles[Pos[1]]=0;
								T[Fila][N].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[Fila][N].Posibles[Pos[2]]==1){
								T[Fila][N].Posibles[Pos[2]]=0;
								T[Fila][N].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[Fila][N].Posibles[Pos[3]]==1){
								T[Fila][N].Posibles[Pos[3]]=0;
								T[Fila][N].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[Fila][N].Posibles[Pos[4]]==1){
								T[Fila][N].Posibles[Pos[4]]=0;
								T[Fila][N].Posibilidades--;
								U[5]=1;
								*P=1;}
}}}

	for (Col=1;Col<=9;Col++)
		for (a[0]=1;a[0]<=8;a[0]++)
		for (b[0]=a[0]+1;b[0]<=9;b[0]++)
			if((T[a[0]][Col].HayNum==0)&&(T[b[0]][Col].HayNum==0)){
				Pos[0]=0;
				for (N=1;N<=9;N++)
					if ((T[a[0]][Col].Posibles[N]==1)||
						(T[b[0]][Col].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
					}
				if (Pos[0]==2){
					for (N=0;N<=9;N++)
						if (((a[0]!=N)&&(b[0]!=N))&&(T[N][Col].HayNum==0)){
							if (T[N][Col].Posibles[Pos[1]]==1){
								T[N][Col].Posibles[Pos[1]]=0;
								T[N][Col].Posibilidades--;
								U[3]=1;
								*P=1;}
							if (T[N][Col].Posibles[Pos[2]]==1){
								T[N][Col].Posibles[Pos[2]]=0;
								T[N][Col].Posibilidades--;
								U[3]=1;
								*P=1;}
}}}
	
	for (Col=1;Col<=9;Col++)
		for (a[0]=1;a[0]<=7;a[0]++)
		for (b[0]=a[0]+1;b[0]<=8;b[0]++)
		for (c[0]=b[0]+1;c[0]<=9;c[0]++)
			if((T[a[0]][Col].HayNum==0)&&(T[b[0]][Col].HayNum==0)
				&&(T[c[0]][Col].HayNum==0))
			{
				Pos[0]=0;
				for (N=1;N<=9;N++){
					if ((T[a[0]][Col].Posibles[N]==1)||
						(T[b[0]][Col].Posibles[N]==1)||
						(T[c[0]][Col].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
				}}
				if (Pos[0]==3){
					for (N=0;N<=9;N++)
					if (((a[0]!=N)&&(b[0]!=N)&&(c[0]!=N))&&
						(T[N][Col].HayNum==0)){
						if (T[N][Col].Posibles[Pos[1]]==1){
							T[N][Col].Posibles[Pos[1]]=0;
							T[N][Col].Posibilidades--;
							U[4]=1;
							*P=1;}
						if (T[N][Col].Posibles[Pos[2]]==1){
							T[N][Col].Posibles[Pos[2]]=0;
							T[N][Col].Posibilidades--;
							U[4]=1;
							*P=1;}
						if (T[N][Col].Posibles[Pos[3]]==1){
							T[N][Col].Posibles[Pos[3]]=0;
							T[N][Col].Posibilidades--;
							U[4]=1;
							*P=1;}
}}}
	
	for (Col=1;Col<=9;Col++)
		for (a[0]=1;a[0]<=6;a[0]++)
		for (b[0]=a[0]+1;b[0]<=7;b[0]++)
		for (c[0]=b[0]+1;c[0]<=8;c[0]++)
		for (d[0]=c[0]+1;d[0]<=9;d[0]++)
			if((T[a[0]][Col].HayNum==0)&&(T[b[0]][Col].HayNum==0)
				&&(T[c[0]][Col].HayNum==0)&&(T[d[0]][Col].HayNum==0)){
				Pos[0]=0;
				for (N=1;N<=9;N++){
					if ((T[a[0]][Col].Posibles[N]==1)||
						(T[b[0]][Col].Posibles[N]==1)
						||(T[c[0]][Col].Posibles[N]==1)||
						(T[d[0]][Col].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
				}}
				if (Pos[0]==4){
					for (N=0;N<=9;N++)
						if (((a[0]!=N)&&(b[0]!=N)&&(c[0]!=N)&&(d[0]!=N))&&
							(T[N][Col].HayNum==0)){
							if (T[N][Col].Posibles[Pos[1]]==1){
								T[N][Col].Posibles[Pos[1]]=0;
								T[N][Col].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][Col].Posibles[Pos[2]]==1){
								T[N][Col].Posibles[Pos[2]]=0;
								T[N][Col].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][Col].Posibles[Pos[3]]==1){
								T[N][Col].Posibles[Pos[3]]=0;
								T[N][Col].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][Col].Posibles[Pos[4]]==1){
								T[N][Col].Posibles[Pos[4]]=0;
								T[N][Col].Posibilidades--;
								U[5]=1;
								*P=1;}
}}}

	for (Fila=1;Fila<=3;Fila++) for (Col=1;Col<=3;Col++)
		for (a[0]=(Fila*3)-2;a[0]<=(Fila*3);a[0]++)
		for (a[1]=(Col*3)-2;a[1]<=(Col*3);a[1]++)
		for (b[0]=(Fila*3)-2;b[0]<=(Fila*3);b[0]++)
		for (b[1]=(Col*3)-2;b[1]<=(Col*3);b[1]++)
			if((T[a[0]][a[1]].HayNum==0)&&(T[b[0]][b[1]].HayNum==0)&&
				((a[0]!=b[0])||(a[1]!=b[1]))){
				Pos[0]=0;
				for (N=1;N<=9;N++)
					if ((T[a[0]][a[1]].Posibles[N]==1)||
						(T[b[0]][b[1]].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
					}
				if (Pos[0]==2){
					for (N=(Fila*3)-2;N<=(Fila*3);N++)
					for (N2=(Col*3)-2;N2<=(Col*3);N2++)
						if ((((a[0]!=N)||(a[1]!=N2))&&((b[0]!=N)||(b[1]!=N2)))
							&&(T[N][N2].HayNum==0)){
							if (T[N][N2].Posibles[Pos[1]]==1){
								T[N][N2].Posibles[Pos[1]]=0;
								T[N][N2].Posibilidades--;
								U[3]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[2]]==1){
								T[N][N2].Posibles[Pos[2]]=0;
								T[N][N2].Posibilidades--;
								U[3]=1;
								*P=1;}
}}}
	
	for (Fila=1;Fila<=3;Fila++) for (Col=1;Col<=3;Col++)
		for (a[0]=(Fila*3)-2;a[0]<=(Fila*3);a[0]++)
		for (a[1]=(Col*3)-2;a[1]<=(Col*3);a[1]++)
		for (b[0]=(Fila*3)-2;b[0]<=(Fila*3);b[0]++)
		for (b[1]=(Col*3)-2;b[1]<=(Col*3);b[1]++)
		for (c[0]=(Fila*3)-2;c[0]<=(Fila*3);c[0]++)
		for (c[1]=(Col*3)-2;c[1]<=(Col*3);c[1]++)
			if((T[a[0]][a[1]].HayNum==0)&&(T[b[0]][b[1]].HayNum==0)&&
				(T[c[0]][c[1]].HayNum==0)&&((a[0]!=b[0])||(a[1]!=b[1]))
				&&((a[0]!=c[0])||(a[1]!=c[1]))&&((c[0]!=b[0])||(c[1]!=b[1]))){
				Pos[0]=0;
				for (N=1;N<=9;N++)
					if ((T[a[0]][a[1]].Posibles[N]==1)||
						(T[b[0]][b[1]].Posibles[N]==1)||
						(T[c[0]][c[1]].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
					}
				if (Pos[0]==3){
					for (N=(Fila*3)-2;N<=(Fila*3);N++)
					for (N2=(Col*3)-2;N2<=(Col*3);N2++)
						if ((((a[0]!=N)||(a[1]!=N2))&&((b[0]!=N)||(b[1]!=N2))
							&&((c[0]!=N)||(c[1]!=N2)))&&(T[N][N2].HayNum==0)){
							if (T[N][N2].Posibles[Pos[1]]==1){
								T[N][N2].Posibles[Pos[1]]=0;
								T[N][N2].Posibilidades--;
								U[4]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[2]]==1){
								T[N][N2].Posibles[Pos[2]]=0;
								T[N][N2].Posibilidades--;
								U[4]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[3]]==1){
								T[N][N2].Posibles[Pos[3]]=0;
								T[N][N2].Posibilidades--;
								U[4]=1;
								*P=1;}
							}}}

	for (Fila=1;Fila<=3;Fila++) for (Col=1;Col<=3;Col++)
		for (a[0]=(Fila*3)-2;a[0]<=(Fila*3);a[0]++)
		for (a[1]=(Col*3)-2;a[1]<=(Col*3);a[1]++)
		for (b[0]=(Fila*3)-2;b[0]<=(Fila*3);b[0]++)
		for (b[1]=(Col*3)-2;b[1]<=(Col*3);b[1]++)
		for (c[0]=(Fila*3)-2;c[0]<=(Fila*3);c[0]++)
		for (c[1]=(Col*3)-2;c[1]<=(Col*3);c[1]++)
		for (d[0]=(Fila*3)-2;d[0]<=(Fila*3);d[0]++)
		for (d[1]=(Col*3)-2;d[1]<=(Col*3);d[1]++)
			if((T[a[0]][a[1]].HayNum==0)&&(T[b[0]][b[1]].HayNum==0)&&
				(T[c[0]][c[1]].HayNum==0)&&(T[d[0]][d[1]].HayNum==0)&&
				((a[0]!=b[0])||(a[1]!=b[1]))&&((a[0]!=c[0])||(a[1]!=c[1]))&&
				((c[0]!=b[0])||(c[1]!=b[1]))&&((d[0]!=a[0])||(d[1]!=a[1]))&&
				((d[0]!=b[0])||(d[1]!=b[1]))&&((c[0]!=d[0])||(c[1]!=d[1]))){
				Pos[0]=0;
				for (N=1;N<=9;N++)
					if ((T[a[0]][a[1]].Posibles[N]==1)||
						(T[b[0]][b[1]].Posibles[N]==1)||
						(T[c[0]][c[1]].Posibles[N]==1)||
						(T[d[0]][d[1]].Posibles[N]==1)){
						Pos[0]++;
						Pos[Pos[0]]=N;
					}
				if (Pos[0]==4){
					for (N=(Fila*3)-2;N<=(Fila*3);N++)
					for (N2=(Col*3)-2;N2<=(Col*3);N2++)
						if ((((a[0]!=N)||(a[1]!=N2))&&((b[0]!=N)||(b[1]!=N2))
							&&((c[0]!=N)||(c[1]!=N2))&&((d[0]!=N)||(d[1]!=N2)))
							&&(T[N][N2].HayNum==0)){
							if (T[N][N2].Posibles[Pos[1]]==1){
								T[N][N2].Posibles[Pos[1]]=0;
								T[N][N2].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[2]]==1){
								T[N][N2].Posibles[Pos[2]]=0;
								T[N][N2].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[3]]==1){
								T[N][N2].Posibles[Pos[3]]=0;
								T[N][N2].Posibilidades--;
								U[5]=1;
								*P=1;}
							if (T[N][N2].Posibles[Pos[4]]==1){
								T[N][N2].Posibles[Pos[4]]=0;
								T[N][N2].Posibilidades--;
								U[5]=1;
								*P=1;}
}}}}

void Escondidas(struct TpCasilla T[][10], int *P,int U[])
{
	struct TpPos
		{
			int C;
			int F;};
	
	int a,b,c,d,N,Estan[10],Fila,Col,FilaR,ColR;
	struct TpPos Pos[10];
	
	for (Fila=1;Fila<=9;Fila++)
		for(a=1;a<=8;a++)
		for(b=a+1;b<=9;b++)
		{
			for(Col=1;Col<=9;Col++) Estan[Col]=0;
			Pos[0].C=0;
			for(Col=1;Col<=9;Col++)
			   if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1))
					&&(T[Fila][Col].HayNum!=1))
					{
						if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
						if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
						Pos[0].C++;
						Pos[Pos[0].C].C=Col;}
			if ((Pos[0].C==2)&&(Estan[a]==1)&&(Estan[b]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)){
						if (T[Fila][Pos[1].C].Posibles[N]==1){
							T[Fila][Pos[1].C].Posibles[N]=0;
							T[Fila][Pos[1].C].Posibilidades--;
							U[6]=1;
							*P=1;}
						if (T[Fila][Pos[2].C].Posibles[N]==1){
							T[Fila][Pos[2].C].Posibles[N]=0;
							T[Fila][Pos[2].C].Posibilidades--;
							U[6]=1;
							*P=1;}
	}}

	for (Fila=1;Fila<=9;Fila++)
		for(a=1;a<=7;a++)
		for(b=a+1;b<=8;b++)
		for(c=b+1;c<=9;c++){
			for(Col=1;Col<=9;Col++) Estan[Col]=0;
			Pos[0].C=0;
			for(Col=1;Col<=9;Col++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					Pos[0].C++;
					Pos[Pos[0].C].C=Col;}
			if ((Pos[0].C==3)&&(Estan[a]==1)&&(Estan[b]==1)&&(Estan[c]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)){
						if (T[Fila][Pos[1].C].Posibles[N]==1){
							T[Fila][Pos[1].C].Posibles[N]=0;
							T[Fila][Pos[1].C].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Fila][Pos[2].C].Posibles[N]==1){
							T[Fila][Pos[2].C].Posibles[N]=0;
							T[Fila][Pos[2].C].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Fila][Pos[3].C].Posibles[N]==1){
							T[Fila][Pos[3].C].Posibles[N]=0;
							T[Fila][Pos[3].C].Posibilidades--;
							U[7]=1;
							*P=1;}
	}}

	for (Fila=1;Fila<=9;Fila++)
		for(a=1;a<=6;a++)
		for(b=a+1;b<=7;b++)
		for(c=b+1;c<=8;c++)
		for(d=c+1;d<=9;d++){
			for(Col=1;Col<=9;Col++) Estan[Col]=0;
			Pos[0].C=0;
			for(Col=1;Col<=9;Col++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1)||
					(T[Fila][Col].Posibles[d]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					if(T[Fila][Col].Posibles[d]==1) Estan[d]=1;
					Pos[0].C++;
					Pos[Pos[0].C].C=Col;}
			if ((Pos[0].C==4)&&(Estan[a]==1)&&(Estan[b]==1)&&
				(Estan[c]==1)&&(Estan[d]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)&&(N!=d)){
						if (T[Fila][Pos[1].C].Posibles[N]==1){
							T[Fila][Pos[1].C].Posibles[N]=0;
							T[Fila][Pos[1].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Fila][Pos[2].C].Posibles[N]==1){
							T[Fila][Pos[2].C].Posibles[N]=0;
							T[Fila][Pos[2].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Fila][Pos[3].C].Posibles[N]==1){
							T[Fila][Pos[3].C].Posibles[N]=0;
							T[Fila][Pos[3].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Fila][Pos[4].C].Posibles[N]==1){
							T[Fila][Pos[4].C].Posibles[N]=0;
							T[Fila][Pos[4].C].Posibilidades--;
							U[8]=1;
							*P=1;}
	}}

	for (Col=1;Col<=9;Col++)
		for(a=1;a<=8;a++)
		for(b=a+1;b<=9;b++){
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=1;Fila<=9;Fila++)
			   if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1))
					&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;}
			if ((Pos[0].F==2)&&(Estan[a]==1)&&(Estan[b]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)){
						if (T[Pos[1].F][Col].Posibles[N]==1){
							T[Pos[1].F][Col].Posibles[N]=0;
							T[Pos[1].F][Col].Posibilidades--;
							U[6]=1;
							*P=1;}
						if (T[Pos[2].F][Col].Posibles[N]==1){
							T[Pos[2].F][Col].Posibles[N]=0;
							T[Pos[2].F][Col].Posibilidades--;
							U[6]=1;
							*P=1;}
	}}

	for (Col=1;Col<=9;Col++)
		for(a=1;a<=7;a++)
		for(b=a+1;b<=8;b++)
		for(c=b+1;c<=9;c++){
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=1;Fila<=9;Fila++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;}
			if ((Pos[0].F==3)&&(Estan[a]==1)&&(Estan[b]==1)&&(Estan[c]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)){
						if (T[Pos[1].F][Col].Posibles[N]==1){
							T[Pos[1].F][Col].Posibles[N]=0;
							T[Pos[1].F][Col].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Pos[2].F][Col].Posibles[N]==1){
							T[Pos[2].F][Col].Posibles[N]=0;
							T[Pos[2].F][Col].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Pos[3].F][Col].Posibles[N]==1){
							T[Pos[3].F][Col].Posibles[N]=0;
							T[Pos[3].F][Col].Posibilidades--;
							U[7]=1;
							*P=1;}
	}}

	for (Col=1;Col<=9;Col++)
		for(a=1;a<=6;a++)
		for(b=a+1;b<=7;b++)
		for(c=b+1;c<=8;c++)
		for(d=c+1;d<=9;d++)	{
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=1;Fila<=9;Fila++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1)||
					(T[Fila][Col].Posibles[d]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					if(T[Fila][Col].Posibles[d]==1) Estan[d]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;
				}
			if ((Pos[0].F==3)&&(Estan[a]==1)&&(Estan[b]==1)&&
				(Estan[c]==1)&&(Estan[d]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)){
						if (T[Pos[1].F][Col].Posibles[N]==1){
							T[Pos[1].F][Col].Posibles[N]=0;
							T[Pos[1].F][Col].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[2].F][Col].Posibles[N]==1){
							T[Pos[2].F][Col].Posibles[N]=0;
							T[Pos[2].F][Col].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[3].F][Col].Posibles[N]==1){
							T[Pos[3].F][Col].Posibles[N]=0;
							T[Pos[3].F][Col].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[4].F][Col].Posibles[N]==1){
							T[Pos[4].F][Col].Posibles[N]=0;
							T[Pos[4].F][Col].Posibilidades--;
							U[8]=1;
							*P=1;}
	}}

	for (FilaR=1;FilaR<=3;FilaR++)
	for (ColR=1;ColR<=3;ColR++)
		for(a=1;a<=8;a++)
		for(b=a+1;b<=9;b++){
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=((3*FilaR)-2);Fila<=(3*FilaR);Fila++)
			for(Col=((3*ColR)-2);Col<=(3*ColR);Col++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1))
					&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;
					Pos[Pos[0].F].C=Col;}
			if ((Pos[0].F==2)&&(Estan[a]==1)&&(Estan[b]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)){
						if (T[Pos[1].F][Pos[1].C].Posibles[N]==1){
							T[Pos[1].F][Pos[1].C].Posibles[N]=0;
							T[Pos[1].F][Pos[1].C].Posibilidades--;
							U[6]=1;
							*P=1;}
						if (T[Pos[2].F][Pos[2].C].Posibles[N]==1){
							T[Pos[2].F][Pos[2].C].Posibles[N]=0;
							T[Pos[2].F][Pos[2].C].Posibilidades--;
							U[6]=1;
							*P=1;}
	}}

	for (FilaR=1;FilaR<=3;FilaR++)
	for (ColR=1;ColR<=3;ColR++)
		for(a=1;a<=7;a++)
		for(b=a+1;b<=8;b++)
		for(c=b+1;c<=9;c++){
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=((3*FilaR)-2);Fila<=(3*FilaR);Fila++)
			for(Col=((3*ColR)-2);Col<=(3*ColR);Col++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;
					Pos[Pos[0].F].C=Col;}
			if ((Pos[0].F==3)&&(Estan[a]==1)&&(Estan[b]==1)&&(Estan[c]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)){
						if (T[Pos[1].F][Pos[1].C].Posibles[N]==1){
							T[Pos[1].F][Pos[1].C].Posibles[N]=0;
							T[Pos[1].F][Pos[1].C].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Pos[2].F][Pos[2].C].Posibles[N]==1){
							T[Pos[2].F][Pos[2].C].Posibles[N]=0;
							T[Pos[2].F][Pos[2].C].Posibilidades--;
							U[7]=1;
							*P=1;}
						if (T[Pos[3].F][Pos[3].C].Posibles[N]==1){
							T[Pos[3].F][Pos[3].C].Posibles[N]=0;
							T[Pos[3].F][Pos[3].C].Posibilidades--;
							U[7]=1;
							*P=1;}
	}}

	for (FilaR=1;FilaR<=3;FilaR++)
	for (ColR=1;ColR<=3;ColR++)
		for(a=1;a<=6;a++)
		for(b=a+1;b<=7;b++)
		for(c=b+1;c<=8;c++)
		for(d=c+1;d<=9;d++){
			for(Fila=1;Fila<=9;Fila++) Estan[Fila]=0;
			Pos[0].F=0;
			for(Fila=((3*FilaR)-2);Fila<=(3*FilaR);Fila++)
			for(Col=((3*ColR)-2);Col<=(3*ColR);Col++)
				if(((T[Fila][Col].Posibles[a]==1)||(T[Fila][Col].Posibles[b]==1)
					||(T[Fila][Col].Posibles[c]==1)||
					(T[Fila][Col].Posibles[d]==1))&&(T[Fila][Col].HayNum!=1)){
					if(T[Fila][Col].Posibles[a]==1) Estan[a]=1;
					if(T[Fila][Col].Posibles[b]==1) Estan[b]=1;
					if(T[Fila][Col].Posibles[c]==1) Estan[c]=1;
					if(T[Fila][Col].Posibles[d]==1) Estan[d]=1;
					Pos[0].F++;
					Pos[Pos[0].F].F=Fila;
					Pos[Pos[0].F].C=Col;}
			if ((Pos[0].F==4)&&(Estan[a]==1)&&(Estan[b]==1)
				&&(Estan[c]==1)&&(Estan[d]==1))
				for(N=1;N<=9;N++)
					if ((N!=a)&&(N!=b)&&(N!=c)&&(N!=d)){
						if (T[Pos[1].F][Pos[1].C].Posibles[N]==1){
							T[Pos[1].F][Pos[1].C].Posibles[N]=0;
							T[Pos[1].F][Pos[1].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[2].F][Pos[2].C].Posibles[N]==1){
							T[Pos[2].F][Pos[2].C].Posibles[N]=0;
							T[Pos[2].F][Pos[2].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[3].F][Pos[3].C].Posibles[N]==1){
							T[Pos[3].F][Pos[3].C].Posibles[N]=0;
							T[Pos[3].F][Pos[3].C].Posibilidades--;
							U[8]=1;
							*P=1;}
						if (T[Pos[4].F][Pos[4].C].Posibles[N]==1){
							T[Pos[4].F][Pos[4].C].Posibles[N]=0;
							T[Pos[4].F][Pos[4].C].Posibilidades--;
							U[8]=1;
							*P=1;}
	}}}

void X_Wing(struct TpCasilla T[][10], int *P,int U[])
{
	int Fil,Fil1,Fil2,Fil3,Col,Pos[10],Esta1,Esta2,Esta3,N;
	
	for(Fil1=1;Fil1<=8;Fil1++)
	for(Fil2=Fil1+1;Fil2<=9;Fil2++)
		for(N=1;N<=9;N++){
			Pos[0]=0; Esta1=Esta2=0;
			for(Col=1;Col<=9;Col++){
				if ((T[Fil1][Col].Posibles[N]==1)&&(T[Fil1][Col].HayNum==0))
					Esta1=1;
				if ((T[Fil2][Col].Posibles[N]==1)&&(T[Fil2][Col].HayNum==0))
					Esta2=1;
				if (((T[Fil1][Col].Posibles[N]==1)&&(T[Fil1][Col].HayNum==0))||
					((T[Fil2][Col].Posibles[N]==1)&&(T[Fil2][Col].HayNum==0))){
					Pos[0]++;
					Pos[Pos[0]]=Col;}}
			if((Pos[0]==2)&&(Esta1)&&(Esta2)){
				for(Fil=1;Fil<=9;Fil++)
					if((Fil!=Fil1)&&(Fil!=Fil2)){
						if((T[Fil][Pos[1]].Posibles[N]==1)
							&&(T[Fil][Pos[1]].HayNum==0)){
							T[Fil][Pos[1]].Posibles[N]=0;
							T[Fil][Pos[1]].Posibilidades--;
							U[9]=1;
							*P=1;}
						if((T[Fil][Pos[2]].Posibles[N]==1)
							&&(T[Fil][Pos[2]].HayNum==0)){
							T[Fil][Pos[2]].Posibles[N]=0;
							T[Fil][Pos[2]].Posibilidades--;
							U[9]=1;
							*P=1;}
	}}}
	
	for(Fil1=1;Fil1<=7;Fil1++)
	for(Fil2=Fil1+1;Fil2<=8;Fil2++)
	for(Fil3=Fil2+1;Fil3<=9;Fil3++)
		for(N=1;N<=9;N++){
			Pos[0]=0; Esta1=Esta2=Esta3=0;
			for(Col=1;Col<=9;Col++){
				if ((T[Fil1][Col].Posibles[N]==1)&&(T[Fil1][Col].HayNum==0))
					Esta1=1;
				if ((T[Fil2][Col].Posibles[N]==1)&&(T[Fil2][Col].HayNum==0))
					Esta2=1;
				if ((T[Fil3][Col].Posibles[N]==1)&&(T[Fil3][Col].HayNum==0))
					Esta3=1;
				if (((T[Fil1][Col].Posibles[N]==1)&&(T[Fil1][Col].HayNum==0))||
					((T[Fil2][Col].Posibles[N]==1)&&(T[Fil2][Col].HayNum==0))||
					((T[Fil3][Col].Posibles[N]==1)&&(T[Fil3][Col].HayNum==0))){
					Pos[0]++;
					Pos[Pos[0]]=Col;}}
			if((Pos[0]==3)&&(Esta1)&&(Esta2)&&(Esta3)){
				for(Fil=1;Fil<=9;Fil++)
					if((Fil!=Fil1)&&(Fil!=Fil2)&&(Fil!=Fil3)){
						if((T[Fil][Pos[1]].Posibles[N]==1)
							&&(T[Fil][Pos[1]].HayNum==0)){
							T[Fil][Pos[1]].Posibles[N]=0;
							T[Fil][Pos[1]].Posibilidades--;
							U[10]=1;
							*P=1;}
						if((T[Fil][Pos[2]].Posibles[N]==1)
							&&(T[Fil][Pos[2]].HayNum==0)){
							T[Fil][Pos[2]].Posibles[N]=0;
							T[Fil][Pos[2]].Posibilidades--;
							U[10]=1;
							*P=1;}
						if((T[Fil][Pos[3]].Posibles[N]==1)
							&&(T[Fil][Pos[3]].HayNum==0)){
							T[Fil][Pos[3]].Posibles[N]=0;
							T[Fil][Pos[3]].Posibilidades--;
							U[10]=1;
							*P=1;}
	}}}}

void InicializarDatos(struct TpCasilla T[][10])
{
	int a,b,c;
	for(a=1;a<=9;a++)
		for(b=1;b<=9;b++){
			T[a][b].HayNum=0;
			T[a][b].Num=0;
			T[a][b].Posibilidades=9;
			for(c=1;c<=9;c++)
				T[a][b].Posibles[c]=1;
}}

void LecturaDatos(struct TpCasilla T[][10])
{
	FILE *FSud;
	char NombreF[30],car;
	int N,a,b,c;
	
	printf("Escriba el nombre del fichero donde esta almacenado el Sudoku: ");
	gets(NombreF);
	
	if ((FSud=fopen(NombreF,"r"))==0){
		printf("No se pudo abrir el fichero.");scanf("%c",&car);
		exit(1);}
	
	car=getc(FSud);
	a=1;b=1;
	printf("\n\nEl Sudoku del fichero es el siguiente: \n\n\n");
	while (!feof(FSud)){
		printf("%c",car);
		N=car; N=N-48;
		if((N>=0)&&(N<=9)){
			T[b][a].Num=N;
			if (T[b][a].Num!=0){
				T[b][a].HayNum=1;
				T[b][a].Posibilidades=0;
				for (c=1;c<=9;c++)
					T[b][a].Posibles[c]=0;
			}
			if(a==9) {a=0; b++;} 
			a++;}
		car=getc(FSud);}
	fclose(FSud);
	scanf("%c",&car);}

void ImprimeDatos(struct TpCasilla T[][10])
{
	int b,a,N;
	printf("\n\n\n\n\nNumeros que pueden ir en cada casilla\n\n\n");
	for(b=1;b<=9;b++){
		for(a=1;a<=9;a++){
			for(N=1;N<=9;N++)
				printf(" %d:%d ",N,T[b][a].Posibles[N]);
			printf("   ");}
		printf("\n");}}

void ImprimeDatos2(struct TpCasilla T[][10])
{
	int b,a;
	
	printf("\nCANTIDAD DE POSIBILIDADES\n\n");
	for(b=1;b<=9;b++){
		for(a=1;a<=9;a++){
			printf("%d",T[b][a].Posibilidades);
			printf("   ");}
		printf("\n");}
	printf("\n\n");}

void ImprimeDatos3(struct TpCasilla T[][10])
{
	int b,a;
	
	for(b=1;b<=9;b++){
		for(a=1;a<=9;a++){
			printf("%d",T[b][a].HayNum);
			printf("   ");}
		printf("\n");}}

void ImprimeDatos4(struct TpCasilla T[][10])
{
	int b,a;
	
	printf("\nSUDOKU\n\n");
	for(b=1;b<=9;b++){
		for(a=1;a<=9;a++){
			printf("%d",T[b][a].Num);
			if ((a%3)==0) printf(" ");}
		printf("\n");
		if ((b%3)==0) printf("\n");}
	printf("\n\n");}


Si no los funciona, les da algun problema, resuelve algun sudoku mal, o directamente no lo resuelve, diganmelo. De momento no he encontrado ningun sudoku que se le resista (¡¡Siempre y cuando se pueda resolver por logica!!)

Un saludo y espero que les guste!!
33  Programación / Programación C/C++ / Re: PROBLEMA DE LOS DOS CUERPOS en: 28 Noviembre 2012, 00:18 am
Te comento:
1º) No estas aplicando las ecuaciones de Kepler (conservación del momento angular), sino las de gravitación universal (Newton)
2º) No vas a obtener una trayectoria elíptica de ninguna de las maneras, ya que supones la masa de la Tierra despreciable frente a la del Sol, diciendo que este último permanece quieto. Obtendras si acaso una trayectoria circular.
3º) Considerar dt=1dia es mucho considerar. Con esta consideración no se te cerrará la trayectoria ni por asomo.

Dicho todo esto, viendo el codigo, diría que falta cambiar el ángulo en cada iteración. Tampoco se muy bien que es lo que haces con las variables iniciales, que se te inicializan en cada iteración.

Igual me pongo a hacerlo de nuevo y si eso te cuento.

Un Saludo
34  Programación / Programación C/C++ / Re: ejercicio matrices c en: 9 Noviembre 2012, 15:54 pm
Te dejo tambien aqui el codigo, espero que te sirva:

Código:
#include <stdio.h>

int main(void)
{
	int matriz[11][11],fil1,fil2,c1,c2,aux;
	
	for(c1=1;c1<=10;c1++) for(c2=1;c2<=10;c2++){
		printf("Termino (%d,%d): ",c1,c2); scanf("%d",&matriz[c1][c2]);
	}
	
	printf("\n\nMatriz introducida:\n\n");
	for(c1=1;c1<=10;c1++){ for(c2=1;c2<=10;c2++){
		printf("%6d",matriz[c1][c2]);
	}printf("\n");}
	
	printf("Introduce primera fila:"); scanf("%d",&fil1);
	printf("Introduce segunda fila:"); scanf("%d",&fil2);
	
	for(c1=1;c1<=10;c1++)
	{
		aux=matriz[fil1][c1];
		matriz[fil1][c1]=matriz[fil2][c1];
		matriz[fil2][c1]=aux;
	}
	
	printf("\n\nMatriz cambiada:\n\n");
	for(c1=1;c1<=10;c1++){ for(c2=1;c2<=10;c2++){
		printf("6%d",matriz[c1][c2]);
	}printf("\n");}
	
	return(0);
}

Salu10
35  Programación / Programación C/C++ / Re: como hacer una lectura de una palabra caracter a caracter??? en: 5 Noviembre 2012, 20:21 pm
Yo lo haria asi:

Código:
#include <stdio.h>

int main(void)
{
	char c;
	
	scanf("%c", &c);
	while (c!=('\n'))
	{
		printf("%c",c);
		scanf("%c", &c);
	}
}

Te lo dejo tambien aqui: http://cypascal.blogspot.com.es/2012/11/problema-9-lectura-de-caracteres.html

Un saludo
36  Programación / Programación C/C++ / Re: Como almacenar un numero de 10 cifras en: 30 Octubre 2012, 12:03 pm
Si, yo lo haría usando un vector, de modo que no tengas que llamar a ninguna biblioteca. Por contra, tendrás que implementar las operaciones básica para el tipo de dato que uses.

Un Saludo!
37  Programación / Programación C/C++ / Re: Recursividad en C++, programas que no comprendo muy bien en: 26 Octubre 2012, 00:56 am
Usando unicamente la libreria de entrada salida, el siguiente programa permite la construcción de la piramide que tu quieres hasta el numero 99. Te lo dejo aqui:http://cypascal.blogspot.com.es/2012/10/problema-8-piramide-de-numeros.html

y aqui:
Código:
#include <stdio.h>

int main()
{
	int a,cont,espacios;
	
	printf("Introduce un numero IMPAR: "); scanf("%d",&a);
	printf("\n\n");

	espacios=0;
	while (a>=0)
	{
		if ((a)<8) espacios=espacios+1;
		if ((a)>8) espacios=espacios+2;
		
		for (cont=1;cont<=espacios;cont++) printf(" ");
		for (cont=1;cont<=a;cont++)
		{
			printf("%d",cont);	
		}
		printf("\n");
		a=a-2;
	}
	return 0;
}

Espero que te sirva
38  Programación / Programación C/C++ / Re: Ejercicios para practicar en C en: 25 Octubre 2012, 00:31 am
Lo de los retos en C es una buena idea, yo si sale y tuviera tiempo necesario me apuntaria.
39  Programación / Programación C/C++ / Re: Ejercicios para practicar en C en: 24 Octubre 2012, 14:19 pm
Buen sitio web del de project Euler
40  Programación / Programación C/C++ / Re: Ejercicios para practicar en C en: 23 Octubre 2012, 22:13 pm
1)Multiplique matrices.
2)Cifre texto mediante algun sistema de codificación, por ejemplo Cesar.
3)Imprima en pantalla un cuadrado, un rombo y un triangulo formado por caracter "X".
4)Sea capaz de sumar numeros de indefinidos dígitos.
5)Ordene arrays de numeros por diversos métodos y obtenga cual de todos es el más eficiente y menos costoso (Consultar cuales son esos metodos Burbuja,Shell)

Hay muchos más, te dejo un blog que tengo con ejemplos de programas resueltos, si te sirven como base para hacer los tuyos propios: cypascal.blogspot.com.es

Un Saludo!
Páginas: 1 2 3 [4] 5
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines