pastebin - collaborative debugging

#include <iostream>
#include <string>

using namespace std;

//Colores de las celdas
enum TipoCelda
{Azul,Negro,Amarillo,Naranja,Rojo,Verde,Nada};

//Clase celda
class celda {
        private:
           TipoCelda tipocelda;
           int valor;
        public:

//Set tipo de celda
 void setTipo(int tipo) {
   switch(tipo)
        {case 1:
         tipocelda = Azul;
         break;
         case 2:
         tipocelda = Negro;
         break;
         case 3:
         tipocelda = Amarillo;
         break;
         case 4:
         tipocelda = Naranja;
         break;
         case 5:
         tipocelda = Rojo;
         break;
         case 6:
         tipocelda = Verde;
         break;

         default:
         tipocelda = Nada;
         break;}
 }

//Get tipo de celda
 int getTipo() {
   switch(tipocelda)
        {case Azul:
         return(1);
         break;
         case Negro:
         return(2);
         break;
         case Amarillo:
         return(3);
         break;
         case Naranja:
         return(4);
         break;
         case Rojo:
         return(5);
         break;
         case Verde:
         return(6);
         break;

         default:
         return(0);
         break;}
 }

//Constructor de la clase celda
 celda(int mivalor=0) : valor(mivalor) {

   setTipo(valor);

 }

};

//Clase Columna
class columna {
        private:
           celda celdas[5];
           int num1;
           int num2;
           int num3;
           int num4;
           int num5;
           int num6;
        public:

//Comprueba si está resuelta
 bool esta_resuelta(){

   if ((celdas[0].getTipo()==0) && (celdas[5].getTipo()==0)) {
   if (celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()) return (true);
   else return(false);}

   else if (celdas[0].getTipo()==0) {
   if (celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()==celdas[5].getTipo()) return (true);
   else return(false);}

   else if (celdas[5].getTipo()==0) {
   if (celdas[0].getTipo()==celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()) return (true);
   else return(false);}
 }

 int get_superior1() {

   return(celdas[1].getTipo());

 }

 int get_superior2() {

   return(celdas[2].getTipo());

 }

 int get_inferior1() {

   return(celdas[3].getTipo());

 }

 int get_inferior2() {

   return(celdas[4].getTipo());

 }

 void set_par_superior(int valores[1]) {

   celdas[1].setTipo(valores[0]);
   celdas[2].setTipo(valores[1]);

 }

 void set_par_inferior(int valores[1]) {

  celdas[3].setTipo(valores[0]);
  celdas[4].setTipo(valores[1]);

 }

//Constructor de la clase Columna
 columna(int valor1=0,int valor2=0,int valor3=0,int valor4=0,int valor5=0,int valor6=0) : num1(valor1),num2(valor2),num3(valor3),num4(valor4),num5(valor5),num6(valor6) {

   celdas[0]=num1;
   celdas[1]=num2;
   celdas[2]=num3;
   celdas[3]=num4;
   celdas[4]=num5;
   celdas[5]=num6;
 }

//Desplazar la columna
 void desplazar(bool direccion) {
   int aux1,aux2;

   if (not direccion) {
                     aux1 = celdas[0].getTipo();
                     celdas[0].setTipo(0);
                     aux2 = celdas[1].getTipo();
                     celdas[1].setTipo(aux1);
                     aux1 = celdas[2].getTipo();
                     celdas[2].setTipo(aux2);
                     aux2=celdas[3].getTipo();
                     celdas[3].setTipo(aux1);
                     aux1=celdas[4].getTipo();
                     celdas[4].setTipo(aux2);
                     celdas[5].setTipo(aux1);
                   }

              else {
                     aux1 = celdas[5].getTipo();
                     celdas[5].setTipo(0);
                     aux2 = celdas[4].getTipo();
                     celdas[4].setTipo(aux1);
                     aux1 = celdas[3].getTipo();
                     celdas[3].setTipo(aux2);
                     aux2=celdas[2].getTipo();
                     celdas[2].setTipo(aux1);
                     aux1=celdas[1].getTipo();
                     celdas[1].setTipo(aux2);
                     celdas[0].setTipo(aux1);
                   }

 }
};

//Clase YoLocoLoco
class yolocoloco{
        private:
           columna columnas[5];
           bool soporte_vertical;
           string solucion;
           string anteriores;
           char codificacion[23];
        public:

//Comprueba si está resuelto
 bool esta_resuelto(){
   if (columnas[0].esta_resuelta() && columnas[1].esta_resuelta() && columnas[2].esta_resuelta() && columnas[3].esta_resuelta() && columnas[4].esta_resuelta()) return (true);
   else return (false);
 }

//Constructor de la clase YoLocoLoco
 yolocoloco (int inicial[22]) {

   int columna_actual[5];
   int i;

   codificacion[0]='*';
   for (i=0;i<23;i++) {sprintf(&codificacion[i+1],"%d",inicial[i]);}

   soporte_vertical = false;
   columna_actual[5]=0;
   for (i=0;i<5;i++){
      columna_actual[i]=inicial[i];
   }
   columnas[0] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);

   columna_actual[0]=0;
   columna_actual[5]=0;
   for (i=1;i<4;i++){
       columna_actual[i]=inicial[i+5];
   }
   columnas[1] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);

   columna_actual[5]=0;
   for (i=0;i<5;i++){
       columna_actual[i]=inicial[i+9];
   }
   columnas[2] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);

   columna_actual[5]=0;
   for (i=0;i<5;i++){
       columna_actual[i]=inicial[i+14];
   }
   columnas[3] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);

   columna_actual[0]=0;
   columna_actual[5]=0;
   for (i=1;i<4;i++){
       columna_actual[i]=inicial[i+19];
   }
   columnas[4] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
   printf("inicializado!\n");
 }

//Comprueba si es un ciclo
 bool es_ciclo(){
  string::size_type encontrado = anteriores.find(codificacion,0);
     if( encontrado != string::npos) {
       cout<<"Anteriores:"<<anteriores<<"\n";
       return (true);
     }
     else {
       anteriores.append(codificacion,23);
       return (false);
     }
 }

//Movimiento del soporte vertical
 void mover_soporte_vertical() {
   columnas[0].desplazar(soporte_vertical);
   columnas[2].desplazar(soporte_vertical);
   columnas[3].desplazar(soporte_vertical);
   soporte_vertical = not soporte_vertical;
   solucion.append("1",1);
   printf("movido soporte vertical!\n");
 }

//Movimiento del cilindro superior
 void mover_cilindro_superior(){

   int aux1[2],aux2[2];

   aux1[0] = columnas[0].get_superior1();
   aux1[1] = columnas[0].get_superior2();

   aux2[0] = columnas[1].get_superior1();
   aux2[1] = columnas[1].get_superior2();

   columnas[1].set_par_superior(aux1);

   aux1[0] = columnas[2].get_superior1();
   aux1[1] = columnas[2].get_superior2();

   columnas[2].set_par_superior(aux2);

   aux2[0] = columnas[3].get_superior1();
   aux2[1] = columnas[3].get_superior2();

   columnas[3].set_par_superior(aux1);

   aux1[0] = columnas[4].get_superior1();
   aux1[1] = columnas[4].get_superior2();

   columnas[4].set_par_superior(aux2);
   columnas[0].set_par_superior(aux1);
   solucion.append("2",4);
   //printf("movido cilindro superior!\n");
 }

//Imprimir solución
void imprimir_solucion(){
cout<<"Solucion:"<<solucion<<"\n";
}

//Movimiento del cilindro inferior
 void mover_cilindro_inferior(){

   int aux1[1],aux2[1];

   aux1[0] = columnas[0].get_inferior1();
   aux1[1] = columnas[0].get_inferior2();

   aux2[0] = columnas[1].get_inferior1();
   aux2[1] = columnas[1].get_inferior2();

   columnas[1].set_par_inferior(aux1);

   aux1[0] = columnas[2].get_inferior1();
   aux1[1] = columnas[2].get_inferior2();

   columnas[2].set_par_inferior(aux2);

   aux2[0] = columnas[3].get_inferior1();
   aux2[1] = columnas[3].get_inferior2();

   columnas[3].set_par_inferior(aux1);

   aux1[0] = columnas[4].get_inferior1();
   aux1[1] = columnas[4].get_inferior2();

   columnas[4].set_par_inferior(aux2);
   columnas[0].set_par_inferior(aux1);
   solucion.append("3",4);
 }
};

//Funcion chunga y recursiva!
void resolver(yolocoloco actual){

if (actual.esta_resuelto()) printf("resuelto!!\n");
else {

 if (not actual.es_ciclo()) {


        printf("creo el aux1!\n");
        yolocoloco aux1(actual);
        aux1.mover_cilindro_superior();
        resolver(aux1);

        printf("creo el aux2!\n");
        yolocoloco aux2(actual);
        aux2.mover_cilindro_inferior();
        resolver(aux2);

        printf("creo el aux3!\n");
        yolocoloco aux3(actual);
        aux3.mover_soporte_vertical();
        resolver(aux3);
     }
  }
}

//Clase Main
int main() {
printf("YoLocoLoco resolver 1.0\n");
printf("=======================\n\n");
printf("Sitúe el YoLocoLoco en posición vertical sobre la base\n");
printf("antes de comenzar a introducir los datos, tome como\n");
printf("referencia la columna de bolas que tiene cinco elementos\n");
printf("con columnas de cuatro elementos a ambos lados.\n\n");
printf("Las casillas van ordenadas de arriba hacia abajo y\n");
printf("las columnas de izquierda a derecha.\n\n");

int inicial[22];
int indice = 0;
int columna = 1;
int casilla = 1;

while (indice<23) {

int valor = 0;

    while (valor<1 || valor>6) {

      printf("\n(1)Azul(2)Negro(3)Amarillo(4)Naranja(5)Rojo(6)Verde\n");
      printf("Introduce el color de la casilla %d, columna %d:",casilla,columna);

      scanf("%d",&valor);
      if (valor<1 || valor>6) printf ("Error: Código de color introducido inválido\n");
      }

   inicial[indice] = valor;
   indice++;
   casilla++;

   if ((indice==5) || (indice==9) || (indice==14) || (indice == 19)) {
                                                                        casilla = 1;
                                                                        columna++;
                                                                     }
}

printf("=======================\n\n");
printf("Inicialización completada, calculando la solución...\n");

yolocoloco juego(inicial);
resolver(juego);
return 0;}