My Pastes
Public Pastes
Layout Width
Share Pastebin
Guest
Public paste!

EnDleSs_DaRk

By: a guest | Sep 4th, 2009 | Syntax: C++ | Size: 9.52 KB | Hits: 52 | Expires: Never
Download | Raw | Embed | Report abuse
Copy text to clipboard
  1. #include <iostream>
  2. #include <string>
  3.  
  4. using namespace std;
  5.  
  6. //Colores de las celdas
  7. enum TipoCelda
  8. {Azul,Negro,Amarillo,Naranja,Rojo,Verde,Nada};
  9.  
  10. //Clase celda
  11. class celda {
  12.         private:
  13.            TipoCelda tipocelda;
  14.            int valor;
  15.         public:
  16.  
  17. //Set tipo de celda
  18.  void setTipo(int tipo) {
  19.    switch(tipo)
  20.         {case 1:
  21.          tipocelda = Azul;
  22.          break;
  23.          case 2:
  24.          tipocelda = Negro;
  25.          break;
  26.          case 3:
  27.          tipocelda = Amarillo;
  28.          break;
  29.          case 4:
  30.          tipocelda = Naranja;
  31.          break;
  32.          case 5:
  33.          tipocelda = Rojo;
  34.          break;
  35.          case 6:
  36.          tipocelda = Verde;
  37.          break;
  38.  
  39.          default:
  40.          tipocelda = Nada;
  41.          break;}
  42.  }
  43.  
  44. //Get tipo de celda
  45.  int getTipo() {
  46.    switch(tipocelda)
  47.         {case Azul:
  48.          return(1);
  49.          break;
  50.          case Negro:
  51.          return(2);
  52.          break;
  53.          case Amarillo:
  54.          return(3);
  55.          break;
  56.          case Naranja:
  57.          return(4);
  58.          break;
  59.          case Rojo:
  60.          return(5);
  61.          break;
  62.          case Verde:
  63.          return(6);
  64.          break;
  65.  
  66.          default:
  67.          return(0);
  68.          break;}
  69.  }
  70.  
  71. //Constructor de la clase celda
  72.  celda(int mivalor=0) : valor(mivalor) {
  73.  
  74.    setTipo(valor);
  75.  
  76.  }
  77.  
  78. };
  79.  
  80. //Clase Columna
  81. class columna {
  82.         private:
  83.            celda celdas[5];
  84.            int num1;
  85.            int num2;
  86.            int num3;
  87.            int num4;
  88.            int num5;
  89.            int num6;
  90.         public:
  91.  
  92. //Comprueba si está resuelta
  93.  bool esta_resuelta(){
  94.  
  95.    if ((celdas[0].getTipo()==0) && (celdas[5].getTipo()==0)) {
  96.    if (celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()) return (true);
  97.    else return(false);}
  98.  
  99.    else if (celdas[0].getTipo()==0) {
  100.    if (celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()==celdas[5].getTipo()) return (true);
  101.    else return(false);}
  102.  
  103.    else if (celdas[5].getTipo()==0) {
  104.    if (celdas[0].getTipo()==celdas[1].getTipo()==celdas[2].getTipo()==celdas[3].getTipo()==celdas[4].getTipo()) return (true);
  105.    else return(false);}
  106.  }
  107.  
  108.  int get_superior1() {
  109.  
  110.    return(celdas[1].getTipo());
  111.  
  112.  }
  113.  
  114.  int get_superior2() {
  115.  
  116.    return(celdas[2].getTipo());
  117.  
  118.  }
  119.  
  120.  int get_inferior1() {
  121.  
  122.    return(celdas[3].getTipo());
  123.  
  124.  }
  125.  
  126.  int get_inferior2() {
  127.  
  128.    return(celdas[4].getTipo());
  129.  
  130.  }
  131.  
  132.  void set_par_superior(int valores[1]) {
  133.  
  134.    celdas[1].setTipo(valores[0]);
  135.    celdas[2].setTipo(valores[1]);
  136.  
  137.  }
  138.  
  139.  void set_par_inferior(int valores[1]) {
  140.  
  141.   celdas[3].setTipo(valores[0]);
  142.   celdas[4].setTipo(valores[1]);
  143.  
  144.  }
  145.  
  146. //Constructor de la clase Columna
  147.  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) {
  148.  
  149.    celdas[0]=num1;
  150.    celdas[1]=num2;
  151.    celdas[2]=num3;
  152.    celdas[3]=num4;
  153.    celdas[4]=num5;
  154.    celdas[5]=num6;
  155.  }
  156.  
  157. //Desplazar la columna
  158.  void desplazar(bool direccion) {
  159.    int aux1,aux2;
  160.  
  161.    if (not direccion) {
  162.                      aux1 = celdas[0].getTipo();
  163.                      celdas[0].setTipo(0);
  164.                      aux2 = celdas[1].getTipo();
  165.                      celdas[1].setTipo(aux1);
  166.                      aux1 = celdas[2].getTipo();
  167.                      celdas[2].setTipo(aux2);
  168.                      aux2=celdas[3].getTipo();
  169.                      celdas[3].setTipo(aux1);
  170.                      aux1=celdas[4].getTipo();
  171.                      celdas[4].setTipo(aux2);
  172.                      celdas[5].setTipo(aux1);
  173.                    }
  174.  
  175.               else {
  176.                      aux1 = celdas[5].getTipo();
  177.                      celdas[5].setTipo(0);
  178.                      aux2 = celdas[4].getTipo();
  179.                      celdas[4].setTipo(aux1);
  180.                      aux1 = celdas[3].getTipo();
  181.                      celdas[3].setTipo(aux2);
  182.                      aux2=celdas[2].getTipo();
  183.                      celdas[2].setTipo(aux1);
  184.                      aux1=celdas[1].getTipo();
  185.                      celdas[1].setTipo(aux2);
  186.                      celdas[0].setTipo(aux1);
  187.                    }
  188.  
  189.  }
  190. };
  191.  
  192. //Clase YoLocoLoco
  193. class yolocoloco{
  194.         private:
  195.            columna columnas[5];
  196.            bool soporte_vertical;
  197.            string solucion;
  198.            string anteriores;
  199.            char codificacion[23];
  200.         public:
  201.  
  202. //Comprueba si está resuelto
  203.  bool esta_resuelto(){
  204.    if (columnas[0].esta_resuelta() && columnas[1].esta_resuelta() && columnas[2].esta_resuelta() && columnas[3].esta_resuelta() && columnas[4].esta_resuelta()) return (true);
  205.    else return (false);
  206.  }
  207.  
  208. //Constructor de la clase YoLocoLoco
  209.  yolocoloco (int inicial[22]) {
  210.  
  211.    int columna_actual[5];
  212.    int i;
  213.  
  214.    codificacion[0]='*';
  215.    for (i=0;i<23;i++) {sprintf(&codificacion[i+1],"%d",inicial[i]);}
  216.  
  217.    soporte_vertical = false;
  218.    columna_actual[5]=0;
  219.    for (i=0;i<5;i++){
  220.       columna_actual[i]=inicial[i];
  221.    }
  222.    columnas[0] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
  223.  
  224.    columna_actual[0]=0;
  225.    columna_actual[5]=0;
  226.    for (i=1;i<4;i++){
  227.        columna_actual[i]=inicial[i+5];
  228.    }
  229.    columnas[1] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
  230.  
  231.    columna_actual[5]=0;
  232.    for (i=0;i<5;i++){
  233.        columna_actual[i]=inicial[i+9];
  234.    }
  235.    columnas[2] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
  236.  
  237.    columna_actual[5]=0;
  238.    for (i=0;i<5;i++){
  239.        columna_actual[i]=inicial[i+14];
  240.    }
  241.    columnas[3] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
  242.  
  243.    columna_actual[0]=0;
  244.    columna_actual[5]=0;
  245.    for (i=1;i<4;i++){
  246.        columna_actual[i]=inicial[i+19];
  247.    }
  248.    columnas[4] = columna(columna_actual[0],columna_actual[1],columna_actual[2],columna_actual[3],columna_actual[4],columna_actual[5]);
  249.    printf("inicializado!\n");
  250.  }
  251.  
  252. //Comprueba si es un ciclo
  253.  bool es_ciclo(){
  254.   string::size_type encontrado = anteriores.find(codificacion,0);
  255.      if( encontrado != string::npos) {
  256.        cout<<"Anteriores:"<<anteriores<<"\n";
  257.        return (true);
  258.      }
  259.      else {
  260.        anteriores.append(codificacion,23);
  261.        return (false);
  262.      }
  263.  }
  264.  
  265. //Movimiento del soporte vertical
  266.  void mover_soporte_vertical() {
  267.    columnas[0].desplazar(soporte_vertical);
  268.    columnas[2].desplazar(soporte_vertical);
  269.    columnas[3].desplazar(soporte_vertical);
  270.    soporte_vertical = not soporte_vertical;
  271.    solucion.append("1",1);
  272.    printf("movido soporte vertical!\n");
  273.  }
  274.  
  275. //Movimiento del cilindro superior
  276.  void mover_cilindro_superior(){
  277.  
  278.    int aux1[2],aux2[2];
  279.  
  280.    aux1[0] = columnas[0].get_superior1();
  281.    aux1[1] = columnas[0].get_superior2();
  282.  
  283.    aux2[0] = columnas[1].get_superior1();
  284.    aux2[1] = columnas[1].get_superior2();
  285.  
  286.    columnas[1].set_par_superior(aux1);
  287.  
  288.    aux1[0] = columnas[2].get_superior1();
  289.    aux1[1] = columnas[2].get_superior2();
  290.  
  291.    columnas[2].set_par_superior(aux2);
  292.  
  293.    aux2[0] = columnas[3].get_superior1();
  294.    aux2[1] = columnas[3].get_superior2();
  295.  
  296.    columnas[3].set_par_superior(aux1);
  297.  
  298.    aux1[0] = columnas[4].get_superior1();
  299.    aux1[1] = columnas[4].get_superior2();
  300.  
  301.    columnas[4].set_par_superior(aux2);
  302.    columnas[0].set_par_superior(aux1);
  303.    solucion.append("2",4);
  304.    //printf("movido cilindro superior!\n");
  305.  }
  306.  
  307. //Imprimir solución
  308. void imprimir_solucion(){
  309. cout<<"Solucion:"<<solucion<<"\n";
  310. }
  311.  
  312. //Movimiento del cilindro inferior
  313.  void mover_cilindro_inferior(){
  314.  
  315.    int aux1[1],aux2[1];
  316.  
  317.    aux1[0] = columnas[0].get_inferior1();
  318.    aux1[1] = columnas[0].get_inferior2();
  319.  
  320.    aux2[0] = columnas[1].get_inferior1();
  321.    aux2[1] = columnas[1].get_inferior2();
  322.  
  323.    columnas[1].set_par_inferior(aux1);
  324.  
  325.    aux1[0] = columnas[2].get_inferior1();
  326.    aux1[1] = columnas[2].get_inferior2();
  327.  
  328.    columnas[2].set_par_inferior(aux2);
  329.  
  330.    aux2[0] = columnas[3].get_inferior1();
  331.    aux2[1] = columnas[3].get_inferior2();
  332.  
  333.    columnas[3].set_par_inferior(aux1);
  334.  
  335.    aux1[0] = columnas[4].get_inferior1();
  336.    aux1[1] = columnas[4].get_inferior2();
  337.  
  338.    columnas[4].set_par_inferior(aux2);
  339.    columnas[0].set_par_inferior(aux1);
  340.    solucion.append("3",4);
  341.  }
  342. };
  343.  
  344. //Funcion chunga y recursiva!
  345. void resolver(yolocoloco actual){
  346.  
  347. if (actual.esta_resuelto()) printf("resuelto!!\n");
  348. else {
  349.  
  350.  if (not actual.es_ciclo()) {
  351.  
  352.  
  353.         printf("creo el aux1!\n");
  354.         yolocoloco aux1(actual);
  355.         aux1.mover_cilindro_superior();
  356.         resolver(aux1);
  357.  
  358.         printf("creo el aux2!\n");        
  359.         yolocoloco aux2(actual);
  360.         aux2.mover_cilindro_inferior();
  361.         resolver(aux2);
  362.        
  363.         printf("creo el aux3!\n");
  364.         yolocoloco aux3(actual);
  365.         aux3.mover_soporte_vertical();
  366.         resolver(aux3);
  367.      }
  368.   }
  369. }
  370.  
  371. //Clase Main
  372. int main() {
  373. printf("YoLocoLoco resolver 1.0\n");
  374. printf("=======================\n\n");
  375. printf("Sitúe el YoLocoLoco en posición vertical sobre la base\n");
  376. printf("antes de comenzar a introducir los datos, tome como\n");
  377. printf("referencia la columna de bolas que tiene cinco elementos\n");
  378. printf("con columnas de cuatro elementos a ambos lados.\n\n");
  379. printf("Las casillas van ordenadas de arriba hacia abajo y\n");
  380. printf("las columnas de izquierda a derecha.\n\n");
  381.  
  382. int inicial[22];
  383. int indice = 0;
  384. int columna = 1;
  385. int casilla = 1;
  386.  
  387. while (indice<23) {
  388.  
  389. int valor = 0;
  390.  
  391.     while (valor<1 || valor>6) {
  392.  
  393.       printf("\n(1)Azul(2)Negro(3)Amarillo(4)Naranja(5)Rojo(6)Verde\n");
  394.       printf("Introduce el color de la casilla %d, columna %d:",casilla,columna);
  395.  
  396.       scanf("%d",&valor);
  397.       if (valor<1 || valor>6) printf ("Error: Código de color introducido inválido\n");
  398.       }
  399.  
  400.    inicial[indice] = valor;
  401.    indice++;
  402.    casilla++;
  403.  
  404.    if ((indice==5) || (indice==9) || (indice==14) || (indice == 19)) {
  405.                                                                         casilla = 1;
  406.                                                                         columna++;
  407.                                                                      }
  408. }
  409.  
  410. printf("=======================\n\n");
  411. printf("Inicialización completada, calculando la solución...\n");
  412.  
  413. yolocoloco juego(inicial);
  414. resolver(juego);
  415. return 0;}
create new paste | create new version of this paste RAW Paste Data