Demo entry 6770119

Codice per risolvere un cubo di Rubik

   

Submitted by anonymous on Nov 11, 2018 at 20:01
Language: C++. Code size: 68.6 kB.

#include<stdio.h>
#include <stdlib.h>
#include<time.h>

 ///// definizione dei vettori e delle copie per le mosse /////
 
// mischiacubo R u F2 D R2 f U
 
 // bianco=1, blu=2, arancio=3, verde=4, rosso=5, giallo=6
int cuboA[]={1, 1, 1, 1};
int cuboB[]={2, 2, 2, 2};
int cuboC[]={3, 3, 3, 3};
int cuboD[]={4, 4, 4, 4};
int cuboE[]={5, 5, 5, 5};
int cuboF[]={6, 6, 6, 6};
 
//int cuboA[]={5, 5, 5, 5 };
//int cuboB[]={2, 4, 6, 1};
//int cuboC[]={4, 4, 2, 4};
//int cuboD[]={2, 6, 6, 2};
//int cuboE[]={6, 1, 1, 1};
//int cuboF[]={3, 3, 3, 3};


//int cuboA[]={1, 3, 2, 1};
//int cuboB[]={6, 5, 5, 4};
//int cuboC[]={6, 5, 2, 5};
//int cuboD[]={4, 3, 6, 1};
//int cuboE[]={3, 3, 2, 4};
//int cuboF[]={4, 1, 2, 6};

int copia1;
int copia2;
int copia3;


void StampaCubo(){     // mi fa vedere a schermo tutto il cubo quando voglio, anche a forma della proiezione ;)
  	//printf("%d%d\n",10,10);
  	printf("    %d-%d       \n",cuboB[3],cuboB[0]);
	printf("    %d-%d       \n",cuboB[2],cuboB[1]);
    printf("%d-%d-%d-%d-%d-%d-%d-%d\n",cuboC[1],cuboC[2],cuboA[3],cuboA[0],cuboE[3],cuboE[0],cuboF[2],cuboF[3]);
    printf("%d-%d-%d-%d-%d-%d-%d-%d\n",cuboC[0],cuboC[3],cuboA[2],cuboA[1],cuboE[2],cuboE[1],cuboF[1],cuboF[0]);
    printf("    %d-%d       \n",cuboD[2],cuboD[3]);
  	printf("    %d-%d       \n",cuboD[1],cuboD[0]);
  	printf("\n");
  }

 bool checkColors(){ //se i valori associati ai colori non danno la somma 84, allora c'è un errore nel codice
 int a=0,b=0,c=0,d=0,e=0,f=0;
 for (int i=0;i<4;i++){
    a=a+cuboA[i];
    b=b+cuboB[i];
    c=c+cuboC[i];
    d=d+cuboD[i];
    e=e+cuboE[i];
    f=f+cuboF[i];
 }
 //printf("%d",a+b+c+d+e+f);
 return(a+b+c+d+e+f==84);
 }
 

 bool checkFaccia1(){ //controlla che la faccia sia risolta
 return (checkColors()&&cuboA[0]==cuboA[1] && cuboA[0]==cuboA[2]&& cuboA[0]==cuboA[3]);
 }

 bool checkFacciaF(){ //controlla che la faccia opposta sia risolta tenendo conto dell'altra
 return (checkFaccia1 && cuboF[0]==cuboF[1] && cuboF[0]==cuboF[2]&& cuboF[0]==cuboF[3]);
 }

 bool checkCubo(){ //controlla tutto il cubo
 return (checkFacciaF && cuboB[0]==cuboB[1] && cuboB[0]==cuboB[2]&& cuboB[0]==cuboB[3]
&& cuboC[0]==cuboC[1] && cuboC[0]==cuboC[2]&& cuboC[0]==cuboC[3]
&& cuboD[0]==cuboD[1] && cuboD[0]==cuboD[2]&& cuboD[0]==cuboD[3]
);
 }
 
 
 
 
 
 ///// definizione delle mosse che possono svolgere i motori del robot /////

void bracciogiu ()
 {
//OnRev(OUT_C, 50);
//Wait(255);
//Off(OUT_C);
//Wait(500);
 }


void bracciosu ()
{
//OnFwd(OUT_C, 50);
//Wait(260);
//Off(OUT_C);
//Wait(500);
  }

void giracubo ()
{
//OnRev(OUT_C, 85);
//Wait(180); //200
//Off(OUT_C);
//Wait(200);
//OnFwd(OUT_C, 85);
//Wait(173);  //210
//Off(OUT_C);
//Wait(500);
 }

void sensoreavanti ()
{
//OnFwd(OUT_A,90);
//Wait(240);
//Off(OUT_A);
//Wait(500);
}

void sensoreindietro ()
{
//OnRev(OUT_A,90);
//Wait(230);
//Off(OUT_A);
//Wait(500);
 }



void mossaavanti ()
 {
/*RotateMotor(OUT_B, 60, 206.96);
Wait(500);*/

//RotateMotor(OUT_B, 60, 124); //204.5
/*OnFwd(OUT_B, 100);
Wait(269);
Off(OUT_B);
OnRev(OUT_B, 100);
Wait(50);
Off(OUT_B);
//Wait(230); con cubo senza braccio*/ 
}

void  mossaindietro ()
{ 
//RotateMotor(OUT_B, 60, -124.5);   //205
// Wait(500);
 }
 
void scan(int gradi)
{
//int scal=gradi*124;
//RotateMotor(OUT_B, 30, scal);
//Wait(500);
}

//RotateMotor(OUT_B, 60, 103.48);



///// scannerizzazione colori e creazione dei 6 vettori /////


 int leggiColore()
{

//int val= Sensor(IN_3);
// prindf zio
return 1;
}


void scannerizzazione()

{
// ArrayInit(cuboA, 0, 4);
// ArrayInit(cuboB, 0, 4);
// ArrayInit(cuboC, 0, 4);
// ArrayInit(cuboD, 0, 4);
// ArrayInit(cuboE, 0, 4);
// ArrayInit(cuboF, 0, 4);
//   
// SetSensorLight(IN_3);
// SetSensorMode(IN_3,SENSOR_MODE_RAW);
// sensoreavanti();
//
//  // faccia 1
// scan(45);
// cuboA[0]= leggiColore();
// scan(90);
// cuboA[1]= leggiColore();
// scan(90);
// cuboA[2]= leggiColore();
// scan(90);
// cuboA[3]= leggiColore();
// scan(45);
//
//   sensoreindietro();
//   bracciogiu();
//   giracubo();
//   bracciosu();
//   sensoreavanti();
//
//  // faccia 2
// scan(45);
// cuboB[0]= leggiColore();
// scan(90);
// cuboB[1]= leggiColore();
// scan(90);
// cuboB[2]= leggiColore();
// scan(90);
// cuboB[3]= leggiColore();
// scan(45);
//
//   sensoreindietro();
//   mossaindietro();
//   bracciogiu();
//   giracubo();
//   bracciosu();
//   sensoreavanti();
//
//     // faccia 3
// scan(45);
// cuboC[0]= leggiColore();
// scan(90);
// cuboC[1]= leggiColore();
// scan(90);
// cuboC[2]= leggiColore();
// scan(90);
// cuboC[3]= leggiColore();
// scan(45);
//
//   sensoreindietro();
//   bracciogiu();
//   giracubo();
//   bracciosu();
//   sensoreavanti();
//
//      // faccia 4
// scan(45);
// cuboD[0]= leggiColore();
// scan(90);
// cuboD[1]= leggiColore();
// scan(90);
// cuboD[2]= leggiColore();
// scan(90);
// cuboD[3]= leggiColore();
// scan(45);
// 
//   sensoreindietro();
//   bracciogiu();
//   giracubo();
//   bracciosu();
//   sensoreavanti();
//
//        // faccia 5
// scan(45);
// cuboE[0]= leggiColore();
// scan(90);
// cuboE[1]= leggiColore();
// scan(90);
// cuboE[2]= leggiColore();
// scan(90);
// cuboE[3]= leggiColore();
// scan(45);
//
//   sensoreindietro();
//   mossaavanti();
//   bracciogiu();
//   giracubo();
//   bracciosu();
//   sensoreavanti();
//
//           // faccia 5
// scan(45);
// cuboF[0]= leggiColore();
// scan(90);
// cuboF[1]= leggiColore();
// scan(90);
// cuboF[2]= leggiColore();
// scan(90);
// cuboF[3]= leggiColore();
// scan(45);
//
//   sensoreindietro();
//   bracciogiu();
//   giracubo();
//   giracubo();
//   bracciosu();
//   mossaindietro();
//
}


///// definiamo gli spostamenti vettoriali per ogni singola mossa da inserire nel gruppo di mosse /////

// spostamenti per la faccia bianca //

void fronte()
{
 copia1=cuboC[0];  //movimento esterno
 copia2=cuboC[3];
 cuboC[0]=cuboF[1];
 cuboC[3]=cuboF[0];
 cuboF[0]=cuboE[1];
 cuboF[1]=cuboE[2];
 cuboE[1]=cuboA[1];
 cuboE[2]=cuboA[2];
 cuboA[1]=copia2;
 cuboA[2]=copia1;
 copia3=cuboD[1]; //movimento interno
 cuboD[1]=cuboD[0];
 cuboD[0]=cuboD[3];
 cuboD[3]=cuboD[2];
 cuboD[2]=copia3;
}

void fronteprimo()
{
 fronte();
 fronte();
 fronte();
}

void sinistra()

{
 copia1=cuboB[2]; //movimento esterno
 copia2=cuboB[3];
 cuboB[2]=cuboF[3];
 cuboB[3]=cuboF[0];
 cuboF[0]=cuboD[2];
 cuboF[3]=cuboD[1];
 cuboD[1]=cuboA[2];
 cuboD[2]=cuboA[3];
 cuboA[2]=copia1;
 cuboA[3]=copia2;
 copia3=cuboC[1];  //movimento interno
 cuboC[1]=cuboC[0];
 cuboC[0]=cuboC[3];
 cuboC[3]=cuboC[2];
 cuboC[2]=copia3;
}

void sinistraprimo()

{
 sinistra();
 sinistra();
 sinistra();
}

void sotto()

{
 copia1=cuboC[0];  //movimento esterno
 copia2=cuboC[1];
 cuboC[0]=cuboB[3];
 cuboC[1]=cuboB[0];
 cuboB[0]=cuboE[1];
 cuboB[3]=cuboE[0];
 cuboE[0]=cuboD[0];
 cuboE[1]=cuboD[1];
 cuboD[0]=copia1;
 cuboD[1]=copia2;
 copia3=cuboF[3]; //movimento interno
 cuboF[3]=cuboF[2];
 cuboF[2]=cuboF[1];
 cuboF[1]=cuboF[0];
 cuboF[0]=copia3;
}

void sottoprimo()
{
 sotto();
 sotto();
 sotto();

}

/// spostamenti supplementari per la faccia opposta ///

void destra()
{
 copia1=cuboD[0]; //movimento esterno
 copia2=cuboD[3];
 cuboD[3]=cuboF[1];
 cuboD[0]=cuboF[2];
 cuboF[1]=cuboB[0];
 cuboF[2]=cuboB[1];
 cuboB[0]=cuboA[0];
 cuboB[1]=cuboA[1];
 cuboA[0]=copia2;
 cuboA[1]=copia1;
 copia3=cuboE[1]; //movimento interno
 cuboE[1]=cuboE[0];
 cuboE[0]=cuboE[3];
 cuboE[3]=cuboE[2];
 cuboE[2]=copia3;
 
 //copia3=cuboE[0];
 //cuboE[0]=cuboE[3];
 //cuboE[3]=cuboE[2];
 //cuboE[2]=cuboE[1];
 //cuboE[1]=copia3;

}

void destraprimo()

{
 destra();
 destra();
 destra();
}

void sopra()
{
 copia1=cuboE[2];
 copia2=cuboE[3];
 cuboE[2]=cuboB[1];
 cuboE[3]=cuboB[2];
 cuboB[1]=cuboC[2];
 cuboB[2]=cuboC[3];
 cuboC[2]=cuboD[2];
 cuboC[3]=cuboD[3];
 cuboD[2]=copia1;
 cuboD[3]=copia2;
 
 copia3=cuboA[0];
 cuboA[0]=cuboA[3];
 cuboA[3]=cuboA[2];
 cuboA[2]=cuboA[1];
 cuboA[1]=copia3;
}

void sopraprimo()
{
 sopra();
 sopra();
 sopra();
}

/// spostamenti vettoriali per il passaggio finale ///

void dietro()
{
 copia1=cuboE[0];
 copia2=cuboE[3];
 cuboE[0]=cuboF[3];
 cuboE[3]=cuboF[2];
 cuboF[3]=cuboC[2];
 cuboF[2]=cuboC[1];
 cuboC[2]=cuboA[0];
 cuboC[1]=cuboA[3];
 cuboA[0]=copia1;
 cuboA[3]=copia2;
 
 int copia=cuboB[0];
 cuboB[0]=cuboB[3];
 cuboB[3]=cuboB[2];
 cuboB[2]=cuboB[1];
 cuboB[1]=copia;
 
}


///// ora si definiscono tutte le mosse messe insieme (tempo e margine errore minori) possibili /////
 
/// per la posizione 1 ///

void df()    //IMPORTANTE: inserire all'interno anche gli spostamenti vettoriali
{
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sottoprimo();    //spostamenti vettoriali
 fronteprimo();
}

void L2Df()
{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sinistra();       //spostamenti vettoriali
 sinistra();
 sotto();
 fronteprimo();
}

void lF2()
{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sinistraprimo();       //spostamenti vettoriali
 fronte();
 fronte();
}

void lF()
{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sinistraprimo();      //spostamenti vettoriali
 fronte();
}

void D2f()
{
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sotto();        //spostamenti vettoriali
 sotto();
 fronteprimo();
}

void LF()
{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sinistra();     //spostamenti vettoriali
 fronte();
}

void F()
{
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte();         //spostamenti vettoriali
}

void FDf()
{
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte();        //spostamenti vettoriali
 sotto();
 fronteprimo();
}

void Df()
{
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sotto();              //spostamenti vettoriali
 fronteprimo();
}

void LF2()
{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sinistra();      //spostamenti vettoriali
 fronte();
 fronte();
}

void F2Df()

{
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte();         //spostamenti vettoriali
 fronte();
 sotto();
 fronteprimo();
}

void dFDf()

{
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sottoprimo();        //spostamenti vettoriali
 fronte();
 sotto();
 fronteprimo();
}

void f()

{
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronteprimo();      //spostamenti vettoriali
}

void FdF2()

{
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte();         //spostamenti vettoriali
 sottoprimo();
 fronte();
 fronte();
}

void F2()
{
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte();        //spostamenti vettoriali
 fronte();
}

void dF2()

{
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sottoprimo();      //spostamenti vettoriali
 fronte();
 fronte();
}

void D2F2()

{
 bracciogiu();
 mossaindietro();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sotto();         //spostamenti vettoriali
 sotto();
 fronte();
 fronte();
}

void DF2()

{
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 sotto();            //spostamenti vettoriali
 fronte();
 fronte();
}


/// per la posizione 2 ///


void D2l()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();              //spostamenti vettoriali
 sotto();
 sinistraprimo();
}

void L()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistra();         //spostamenti vettoriali
}

void ldL2()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();     //spostamenti vettoriali
 sottoprimo();
 sinistra();
 sinistra();
}

void LDl()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistra();          //spostamenti vettoriali
 sotto();
 sinistraprimo();
}

void Dl()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();              //spostamenti vettoriali
 sinistraprimo();
}

void lDl()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();     //spostamenti vettoriali
 sotto();
 sinistraprimo();
}

void L2Dl()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistra();        //spostamenti vettoriali
 sinistra();
 sotto();
 sinistraprimo();
}

void dLDl()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 sottoprimo();    //spostamenti vettoriali
 sinistra();
 sotto();
 sinistraprimo();
}

void l()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();   //spostamenti vettoriali
}

void LdL2()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistra();        //spostamenti vettoriali
 sottoprimo();
 sinistra();
 sinistra();
}

void D2LDl()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();          //spostamenti vettoriali
 sotto();
 sinistra();
 sotto();
 sinistraprimo();
}

void dl()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sottoprimo();      //spostamenti vettoriali
 sinistraprimo();
}

void dL2()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sottoprimo();     //spostamenti vettoriali
 sinistra();
 sinistra();
}

void L2()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistra();      //spostamenti vettoriali
 sinistra();
}

void DL2()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaindietro();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 sotto();        //spostamenti vettoriali
 sinistra();
 sinistra();
}

void D2L2()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaindietro();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 sotto();       //spostamenti vettoriali
 sotto();
 sinistra();
 sinistra();
}


/// per la posizione 3 ///


void DldL()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();         //spostamenti vettoriali
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void lDLdlDL()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();   //spostamenti vettoriali
 sotto();
 sinistra();
 sottoprimo();
 sinistraprimo();
 sotto();
 sinistra();
}

void dlDL()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sottoprimo();      //spostamenti vettoriali
 sinistraprimo();
 sotto();
 sinistra();
}

void D2lDL()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();             //spostamenti vettoriali
 sotto();
 sinistraprimo();
 sotto();
 sinistra();
}

void ldL()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();   //spostamenti vettoriali
 sottoprimo();
 sinistra();
}

void ldLDldL()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();   //spostamenti vettoriali
 sottoprimo();
 sinistra();
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void lD2L()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();   //spostamenti vettoriali
 sotto();
 sotto();
 sinistra();
}

void dldL()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sottoprimo();     //spostamenti vettoriali
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void lDL()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();  //spostamenti vettoriali
 sotto();
 sinistra();
}

void D2ldL()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();          //spostamenti vettoriali
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void dlD2LDldL()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sottoprimo();     //spostamenti vettoriali
 sinistraprimo();
 sotto();
 sotto();
 sinistra();
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void D2lD2LDldL()

{
 mossaavanti();
 bracciogiu();
 mossaindietro();
 mossaindietro();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();            //spostamenti vettoriali
 sotto();
 sinistraprimo();
 sotto();
 sotto();
 sinistra();
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void DlD2LDldL()

{
 mossaavanti();
 bracciogiu();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sotto();            //spostamenti vettoriali
 sinistraprimo();
 sotto();
 sotto();
 sinistra();
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

void lD2LDldL()

{
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 giracubo();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 giracubo();
 mossaavanti();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 sinistraprimo();     //spostamenti vettoriali
 sotto();
 sotto();
 sinistra();
 sotto();
 sinistraprimo();
 sottoprimo();
 sinistra();
}

/// algoritmi faccia opposta ///

void FRuruRUrf() //algoritmo 1

{
 bracciogiu();
 giracubo();
 mossaavanti();  //F
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();  //R
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();  //u
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaavanti();  //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro(); //f
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 fronte(); //spostamenti vettoriali
 destra();
 sopraprimo();
 destraprimo();
 sopraprimo();
 destra();
 sopra();
 destraprimo();
 fronteprimo();
}

void RUrurFRf()   //algoritmo 2

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti(); //F
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaindietro(); //f
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 destra();  //spostamenti vettoriali
 sopra();
 destraprimo();
 sopraprimo();
 destraprimo();
 fronte();
 destra();
 fronteprimo();
}

void R2U2rU2R2()   //algortimo 3

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti(); //R2
 giracubo();
 mossaindietro();
 mossaindietro(); //U2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaavanti();
 mossaavanti(); //U2
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti(); //R2
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 destra(); //spostamenti vettoriali
 destra();
 sopra();
 sopra();
 destraprimo();
 sopra();
 sopra();
 destra();
 destra();
}

void U2FRUruf()   //algortimo 4

{
 bracciogiu();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();  //U2
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //F
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();  //R
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro(); //f
 giracubo();
 bracciosu();
 mossaavanti();
 mossaavanti();
 sopra(); //spostamenti vettoriali
 sopra();
 fronte();
 destra();
 sopra();
 destraprimo();
 sopraprimo();
 fronteprimo();
}

void RUrURU2r()  //algortimo 5

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaindietro();
 mossaindietro(); //U2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 destra();   //spostamenti vettoriali
 sopra();
 destraprimo();
 sopra();
 destra();
 sopra();
 sopra();
 destraprimo();
}

void URU2R2uR2uR2U2R()     //algoritmo 6

{
 bracciogiu();
 giracubo();
 giracubo();
 mossaavanti(); //U
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 mossaindietro(); //U2
 giracubo();
 mossaavanti();
 mossaavanti(); //R2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //u
 giracubo();
 mossaindietro();
 mossaindietro(); //R2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //u
 giracubo();
 mossaavanti();
 mossaavanti(); //R2
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti(); //U2
 giracubo();
 mossaavanti(); //R
 giracubo();
 bracciosu();
 mossaindietro();
 sopra(); //spostamenti vettoriali
 destra();
 sopra();
 sopra();
 destra();
 destra();
 sopraprimo();
 destra();
 destra();
 sopraprimo();
 destra();
 destra();
 sopra();
 sopra();
 destra();
}

void RU2ruRur()  //algoritmo 7

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaavanti();
 mossaavanti(); //U2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 destra();  //spostamenti vettoriali
 sopra();
 sopra();
 destraprimo();
 sopraprimo();
 destra();
 sopraprimo();
 destraprimo();
}

/// orientamenti per cubo (4) ///

void spostamentoAvanti(){
int copia;
copia=cuboC[0];	
cuboC[0]=cuboC[2];
cuboC[2]=copia;
copia=cuboC[1];	
cuboC[1]=cuboC[3];
cuboC[3]=copia;

copia=cuboE[0];	
cuboE[0]=cuboE[2];
cuboE[2]=copia;
copia=cuboE[1];	
cuboE[1]=cuboE[3];
cuboE[3]=copia;


copia=cuboA[0];	
cuboA[0]=cuboF[1];
cuboF[1]=copia;
copia=cuboA[1];	
cuboA[1]=cuboF[2];
cuboF[2]=copia;
copia=cuboA[2];	
cuboA[2]=cuboF[3];
cuboF[3]=copia;
copia=cuboA[3];	
cuboA[3]=cuboF[0];
cuboF[0]=copia;

copia=cuboB[0];	
cuboB[0]=cuboD[3];
cuboD[3]=copia;
copia=cuboB[1];	
cuboB[1]=cuboD[0];
cuboD[0]=copia;

copia=cuboB[2];	
cuboB[2]=cuboD[1];
cuboD[1]=copia;
copia=cuboB[3];	
cuboB[3]=cuboD[2];
cuboD[2]=copia;

}

void orientamentonullo()
{	
 bracciogiu();
 giracubo();
 giracubo();
 bracciosu();
 spostamentoAvanti();
}

void orientamentoavanti()

{
 bracciogiu();
 mossaindietro();
 sottoprimo();
 giracubo();
 giracubo();
 bracciosu();
 spostamentoAvanti();
}

void orientamentoindietro()

{
 bracciogiu();
 mossaavanti();
 sotto();
 giracubo();
 giracubo();
 bracciosu();
 spostamentoAvanti();
}

void orientamentodoppio()
{
 bracciogiu();
 mossaavanti();
 mossaavanti();
 sotto();
 sotto();
 giracubo();
 giracubo();
 bracciosu();
 spostamentoAvanti();
}

/// algoritmi per finire il cubo ///

void FRuruRUrfRUrurFRf()

{
 bracciogiu();
 giracubo();
 mossaavanti(); //F
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro(); //f
 bracciosu();
 mossaindietro();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti(); //F
 bracciosu();
 mossaindietro();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //f
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 fronte(); //spostamenti vettoriali
 destra();
 sopraprimo();
 destraprimo();
 sopraprimo();
 destra();
 sopra();
 destraprimo();
 fronteprimo();
 destra();
 sopra();
 destraprimo();
 sopraprimo();
 destraprimo();
 fronte();
 destra();
 fronteprimo();
}

void rFrB2RfrB2R2()

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti(); //F
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti(); //B2
 bracciosu();
 mossaindietro();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro(); //f
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti(); //B2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro();
 mossaindietro(); //R2
 giracubo();
 bracciosu();
 mossaindietro();
 destraprimo(); //spostamenti vettoriali
 fronte();
 destraprimo();
 dietro();
 dietro();
 destra();
 fronteprimo();
 destraprimo();
 dietro();
 dietro();
 destra();
 destra();
}

void R2F2R2()

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti();
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaindietro();
 mossaindietro();
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 bracciosu();
 mossaindietro();
 destra(); //spostamenti vettoriali
 destra();
 fronte();
 fronte();
 destra();
 destra();
 
}

void RuRF2rUr()

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //R
 giracubo();
 mossaindietro();  //u
 giracubo();
 giracubo();
 giracubo();
 mossaavanti(); //R
 bracciosu();
 mossaavanti();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti(); //F2
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 bracciosu();
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti(); //U
 giracubo();
 giracubo();
 giracubo();
 mossaindietro(); //r
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 destra(); //spostaenti vettoriali
 sopraprimo();
 destra();
 fronte();
 fronte();
 destraprimo();
 sopra();
 destraprimo();
}

void R2uB2U2R2uR2()

{
 mossaindietro();
 bracciogiu();
 giracubo();
 mossaavanti();
 mossaavanti(); //R2
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti(); //B2
 giracubo();
 giracubo();
 mossaindietro();
 mossaindietro(); //U2
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();  //R2
 giracubo();
 mossaindietro(); //u
 giracubo();
 giracubo();
 giracubo();
 mossaavanti();
 mossaavanti();  //R2
 giracubo();
 giracubo();
 giracubo();
 bracciosu();
 mossaavanti();
 destra(); //spostamenti vettoriali R2uB2U2R2uR2
 destra();
 sopraprimo();
 dietro();
 dietro();
 sopra();
 sopra();
 destra();
 destra();
 sopraprimo();
 destra();
 destra();
}




  ///// creati i sei vettori, ora si puo risolvere il cubo analizzandoli /////
void completaCubo(){

    while ((cuboB[1]!=cuboB[2]) || (cuboC[2]!=cuboC[3]) || (cuboB[0]!=cuboB[3]) || (cuboC[0]!=cuboC[1]))   // se il cubo non e risolto...
      
      {
        if ((cuboB[1]==cuboB[2]) && (cuboC[2]==cuboC[3])) //se la faccia sopra e completa...

           {
             if ((cuboB[0]==cuboD[0]) && (cuboB[3]==cuboD[1])) //e sotto bisogna scambiare in croce
           
                {
                  if (cuboE[1]==cuboE[2])
                  
                     {
                      orientamentonullo();
                      FRuruRUrfRUrurFRf();
                      break;
                     }
                     
                  if (cuboB[0]==cuboE[2])
                  
                     {
                      bracciogiu();
                      mossaindietro();
                      sottoprimo();
                      bracciosu();
                      orientamentonullo();
                      FRuruRUrfRUrurFRf();
                      break;
                     }
                     
                  if (cuboC[1]==cuboE[2])
                  
                     {
                      bracciogiu();
                      mossaavanti();
                      mossaavanti();
                      sotto();
                      sotto();
                      bracciosu();
                      orientamentonullo();
                      FRuruRUrfRUrurFRf();
                      break;
                     }
                     
                  if (cuboD[1]==cuboE[2])
                  
                     {
                      bracciogiu();
                      mossaavanti();
                      sotto();
                      bracciosu();
                      orientamentonullo();
                      FRuruRUrfRUrurFRf();
                      break;
                     }
                     
                }
                
            if (cuboD[0]==cuboD[1]) //o bisogna scambiare parti vicine
             
               {
                orientamentonullo();
                rFrB2RfrB2R2();
                break;
               }
                
            if (cuboE[0]==cuboE[1])
            
               {
                bracciogiu();
                mossaindietro();
                sottoprimo();
                bracciosu();
                orientamentonullo();
                rFrB2RfrB2R2();
                break;
               }
               
           if (cuboB[0]==cuboB[3])
           
               {
                bracciogiu();
                mossaavanti();
                mossaavanti();
                sotto();
                sotto();
                bracciosu();
                orientamentonullo();
                rFrB2RfrB2R2();
                break;
               }
              
           if (cuboC[0]==cuboC[1])
           
               {
                bracciogiu();
                mossaavanti();
                sotto();
                bracciosu();
                orientamentonullo();
                rFrB2RfrB2R2();
                break;
               }

           }
           
        if ((cuboB[0]==cuboB[3]) && (cuboC[0]==cuboC[1])) //se sotto e risolto
        
           {

             if ((cuboB[1]==cuboD[3]) && (cuboB[2]==cuboD[2])) // e sopra bisogna scambiare in croce
             
                {
                
                   if (cuboD[2]==cuboD[1])
                   
                      {
                       FRuruRUrfRUrurFRf();
                       break;
                      }
             
                   if (cuboE[2]==cuboD[1])
                   
                      {
                       bracciogiu();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       mossaavanti();
                       sotto();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       bracciosu();
                       FRuruRUrfRUrurFRf();
                       break;
                      }
                      
                   if (cuboB[1]==cuboD[1])
                   
                      {
                       bracciogiu();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       mossaavanti();
                       mossaavanti();
                       sotto();
					   sotto();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       bracciosu();
                       FRuruRUrfRUrurFRf();
                       break;
                      }
                      
                   if (cuboC[2]==cuboD[1])
                   
                      {
                       bracciogiu();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       mossaindietro();
                       sottoprimo();
                       giracubo();
                       giracubo();
                       spostamentoAvanti();
                       bracciosu();
                       FRuruRUrfRUrurFRf();
                       break;
                      }
                      
                }
             
             if (cuboB[1]==cuboB[2]) //o bisogna scambiare parti vicine
             
                {
                 rFrB2RfrB2R2();
                 break;
                }
                
             if (cuboC[2]==cuboC[3])
             
                {
                 bracciogiu();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 mossaavanti();
                 sotto();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 bracciosu();
                 rFrB2RfrB2R2();
                 break;
                }
                
             if (cuboD[2]==cuboD[3])
             
                {
                 bracciogiu();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 mossaavanti();
                 mossaavanti();
                 sotto();
                 sotto();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 bracciosu();
                 rFrB2RfrB2R2();
                 break;
                }
                
             if (cuboE[2]==cuboE[3])
             
                {
                 bracciogiu();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 mossaindietro();
                 sottoprimo();
                 giracubo();
                 giracubo();
                 spostamentoAvanti();
                 bracciosu();
                 rFrB2RfrB2R2();
                 break;
                }
             
           }
           
        if ((cuboB[0]==cuboD[0]) && (cuboB[3]==cuboD[1])) //se sotto scambio in croce
       
           {
           
              if ((cuboB[1]==cuboD[3]) && (cuboB[2]==cuboD[2])) // e sopra scambio in croce
              
                 {
                 
                    if (cuboD[0]==cuboD[3])
                    
                       {
                        R2F2R2();
                        break;
                       }
                       
                    if (cuboD[3]==cuboE[0])
                    
                       {
                        bracciogiu();
                        mossaindietro();
                        sottoprimo();
                        bracciosu();
                        R2F2R2();
                        break;
                       }
                       
                    if (cuboD[3]==cuboB[3])
                    
                       {
                        bracciogiu();
                        mossaavanti();
                        mossaavanti();
                        sotto();
                        sotto();
                        bracciosu();
                        R2F2R2();
                        break;
                       }
                       
                    if (cuboD[3]==cuboC[0])
                    
                       {
                        bracciogiu();
                        mossaavanti();
                        sotto();
                        bracciosu();
                        R2F2R2();
                        break;
                       }
                       
                 }
             
              if (cuboD[2]==cuboD[3]) //e sopra si scambia parti vicine
              
                 {
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboE[2]==cuboE[3])
                 {
                  bracciogiu();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  mossaavanti();
                  sotto();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  bracciosu();
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboB[1]==cuboB[2])
              
                 {
                  bracciogiu();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  mossaavanti();
                  mossaavanti();
                  sotto();
                  sotto();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  bracciosu();
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboC[2]==cuboC[3])
              
                 {
                  bracciogiu();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  mossaindietro();
                  sottoprimo();
                  giracubo();
                  giracubo();
                  spostamentoAvanti();
                  bracciosu();
                  RuRF2rUr();
                  break;
                 }
             
           }
           
        if ((cuboB[1]==cuboD[3]) && (cuboB[2]==cuboD[2])) // se sopra bisogna scambiare in croce
        
           {
           
              if (cuboB[0]==cuboB[3]) // e sotto scambiare parti vicine
              
                 {
                  orientamentonullo();
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboC[0]==cuboC[1])
              
                 {
                  bracciogiu();
                  mossaindietro();
                  sottoprimo();
                  bracciosu();
                  orientamentonullo();
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboD[0]==cuboD[1])
              
                 {
                  bracciogiu();
                  mossaavanti();
                  mossaavanti();
                  sotto();
                  sotto();
                  bracciosu();
                  orientamentonullo();
                  RuRF2rUr();
                  break;
                 }
                 
              if (cuboE[0]==cuboE[1])
              
                 {
                  bracciogiu();
                  mossaavanti();
                  sotto();
                  bracciosu();
                  orientamentonullo();
                  RuRF2rUr();
                  break;
                 }
           
           }
           
      break;
           
      }
      
      while ((cuboB[1]!=cuboB[2]) || (cuboC[2]!=cuboC[3]) || (cuboB[0]!=cuboB[3]) || (cuboC[0]!=cuboC[1]))
      
      {
           
        if (cuboE[0]==cuboE[1])
        
           {
            bracciogiu();
            mossaindietro();
            sottoprimo();
            bracciosu();
           }
           
        if (cuboB[0]==cuboB[3])
        
           {
            bracciogiu();
            mossaavanti();
            mossaavanti();
            bracciosu();
            sotto();
            sotto();
           }
           
        if (cuboC[0]==cuboC[1])
        
           {
           	printf("......Eccolo....\n");
            bracciogiu();
            mossaavanti();
            bracciosu();
            sotto();
            
            StampaCubo();
           }
           
        if (cuboE[2]==cuboE[3])
        
           {
           	printf("......ariEccolo....\n");
            bracciogiu();
            giracubo();
            giracubo();
            spostamentoAvanti();
            mossaavanti();
            sotto();
            giracubo();
            giracubo();
            spostamentoAvanti();
            bracciosu();
            StampaCubo();
            
            R2uB2U2R2uR2();
            StampaCubo();
            break;
           }
           
        if (cuboB[1]==cuboB[2])
        
           {
            bracciogiu();
            giracubo();
            giracubo();
            spostamentoAvanti();
            mossaavanti();
            mossaavanti();
            sotto();
            sotto();
            giracubo();
            giracubo();
            spostamentoAvanti();
            bracciosu();
            R2uB2U2R2uR2();
            break;
           }
           
        if (cuboC[2]==cuboC[3])
        
           {
            bracciogiu();
            giracubo();
            giracubo();
            spostamentoAvanti();
            mossaindietro();
            sottoprimo();
            giracubo();
            giracubo();
            spostamentoAvanti();
            bracciosu();
            R2uB2U2R2uR2();
            break;
           }
           
        else { R2uB2U2R2uR2(); break; }
        break;
      }
      
      while (cuboD[3]!=cuboD[0])
      	 {
             bracciogiu();
             mossaavanti();
             bracciosu();
             sotto();
      }
      
//    while ((cuboB[1]!=cuboB[2]) || (cuboC[2]!=cuboC[3]) || (cuboB[0]!=cuboB[3]) || (cuboC[0]!=cuboC[1]))
//    
//      {
//      	printf("sono dentro................");
//      
//         if (cuboD[3]==cuboE[0])
//         
//            {
//             bracciogiu();
//             mossaindietro();
//             bracciosu();
//             break;
//            }
//            
//         if (cuboD[3]==cuboB[3])
//         
//            {
//             bracciogiu();
//             mossaavanti();
//             mossaavanti();
//             bracciosu();
//             break;
//            }
//
//         if (cuboD[3]==cuboC[0])
//         
//            {
//             bracciogiu();
//             mossaavanti();
//             bracciosu();
//             break;
//            }
//            
//        }

  }
    
void FacciaOpposta(){
	  while ((cuboF[0]!=cuboF[1]) || (cuboF[0]!=cuboF[2]) || (cuboF[0]!=cuboF[3])) //se la faccia opposta non ha i colori a posto, li si mette
      {
        if (cuboF[0]==cuboD[0] && cuboF[0] ==cuboF[2] && cuboD[0]==cuboC[1])   //4 possibilita per ogni algoritmo in base a come si trova sotto
           {
            orientamentodoppio();  //per girarlo nella posizione giusta
            FRuruRUrf();
            orientamentonullo();
           // printf("Entrato  1");
			break;                                     //algortimo 1
           }
            
        if (cuboD[1]==cuboF[1] && cuboD[1]==cuboE[0] && cuboD[1]==cuboF[3])

           {
            orientamentoindietro();
            FRuruRUrf();
            orientamentonullo();
            
			//printf("Entrato 2")
			;break;
           }

        if (cuboF[0]==cuboE[1] && cuboF[0]==cuboF[2] && cuboF[0]==cuboB[3])

           {
            orientamentonullo();
            FRuruRUrf();
           orientamentonullo();
            
            //printf("Entrato 3");
			break;
           }
           
        if (cuboF[1]==cuboB[0] && cuboF[1]==cuboF[3]&& cuboF[1]==cuboC[0])
        
           {
            orientamentoavanti();
            FRuruRUrf();
            orientamentonullo();
            
            //printf("Entrato 4");
			break;
           }
        
        if (cuboF[0]==cuboD[0] && cuboF[0]==cuboB[0] && cuboF[0]==cuboF[3])   //algoritmo 2
        
           {
            orientamentodoppio();
            RUrurFRf();
            orientamentonullo();
            
			//printf("Entrato 5");
			break;
           }
        
        if (cuboF[0]==cuboF[1] && cuboF[0]==cuboE[0]&& cuboF[0]==cuboC[1])
        
           {
            orientamentoindietro();
            RUrurFRf();
            orientamentonullo();
            
			//printf("Entrato 6");
			break;
           }
           
        if (cuboD[1]==cuboF[1] && cuboD[1]==cuboF[2] && cuboD[1]==cuboB[3])
        
           {
            orientamentonullo();
            RUrurFRf();
            orientamentonullo();
            
			//printf("Entrato 7");
			break;
           }
           
        if (cuboC[0]==cuboE[1] && cuboC[0]==cuboF[2]&& cuboC[0]==cuboF[3])
        
           {
            orientamentoavanti();
            RUrurFRf();
            orientamentonullo();
            
			//printf("Entrato 8");
			break;
           }

        if (cuboD[0]==cuboD[1] && cuboD[0]==cuboB[0] && cuboD[0]==cuboB[3]) //algortitmo 3

           {
            orientamentonullo();
            R2U2rU2R2();
            orientamentonullo();
		   // R2D2rD2R2();
           
			//bracciogiu();
            //giracubo();
            //giracubo();
            //bracciosu();
            //printf("Entrato 9");
            break;
           }
           
        if (cuboE[0]==cuboE[1] && cuboE[0]==cuboC[0] && cuboE[0]==cuboC[1])
        
           {
            orientamentoavanti();
            R2U2rU2R2();
            orientamentonullo();
            
			
			//printf("Entrato 10");
			break;
           }
           
        if (cuboF[0]==cuboF[3] && cuboF[0]==cuboE[0] && cuboF[0]==cuboE[1]) //algoritmo 4
        
           {
            orientamentonullo();
            U2FRUruf();
            orientamentonullo();
            
			//printf("Entrato 11");
			break;
           }
           
        if (cuboF[0]==cuboF[1]&& cuboF[0]==cuboB[0] && cuboF[0]==cuboB[3])
        
           {
            orientamentoavanti();
            U2FRUruf();
           //orientamentonullo();
            
            printf("Entrato 12");
			break;
           }
           
        if (cuboF[1]==cuboF[2] && cuboF[1]==cuboC[0] && cuboF[1]==cuboC[1])
        
           {
            orientamentodoppio();
            U2FRUruf();
            orientamentonullo();
            
			//printf("Entrato 13");
			break;
           }
           
        if (cuboD[0]==cuboD[1] && cuboD[0]==cuboF[2]&& cuboD[0]==cuboF[3])
        
           {
            orientamentoindietro();
            U2FRUruf();
            orientamentonullo();
            
			//printf("Entrato 14");
			break;
           }
           
        if (cuboF[0]==cuboE[1] && cuboF[0]==cuboB[0] && cuboF[0]==cuboC[1]) //algoritmo 5
        
           {
            orientamentoavanti();
            RUrURU2r();
            orientamentonullo();
            
            //printf("Entrato 15");
			break;
           }
           
        if (cuboD[1]==cuboF[1] && cuboD[1]==cuboB[0]&& cuboD[1]==cuboC[1])
        
           {
            orientamentodoppio();
            RUrURU2r();
            orientamentonullo();
            
			//printf("Entrato 16");
			break;
           }
           
        if (cuboF[2]==cuboC[1] && cuboF[2]==cuboD[1] &&cuboF[2]==cuboE[1])
        
           {
            orientamentoindietro();
            RUrURU2r();
            orientamentonullo();
            
            //printf("Entrato 17");
			break;
           }
           
        if (cuboF[3]==cuboD[1] && cuboF[3]==cuboE[1]&& cuboF[3]==cuboB[0])
        
           {
            orientamentonullo();
            RUrURU2r();
            orientamentonullo();
            
			//printf("Entrato 18");
			break;
           }
           
        if (cuboE[1]==cuboB[0] && cuboE[1]==cuboB[3]&& cuboE[1]==cuboC[0])  //algoritmo 6
        
           {
            orientamentonullo();
            URU2R2uR2uR2U2R();
            orientamentonullo();
            
            //printf("Entrato 19");
            break;
           }
           
        if (cuboD[0]==cuboB[0]&& cuboD[0]==cuboC[0]&& cuboD[0]==cuboC[1])
        
           {
            orientamentoavanti();
            URU2R2uR2uR2U2R();
            orientamentonullo();
            
           // printf("Entrato 20");
            break;
           }
           
        if (cuboD[0]==cuboD[1] && cuboD[0]==cuboE[0] && cuboD[0]==cuboC[1])
        
           {
            orientamentodoppio();
            URU2R2uR2uR2U2R();
            orientamentonullo();
            
			//printf("Entrato 21");
			break;
           }
           
        if (cuboE[0]==cuboE[1]&& cuboE[0]==cuboB[3]&& cuboE[0]==cuboD[1])
        
           {
            orientamentoindietro();
            URU2R2uR2uR2U2R();
           orientamentonullo();
            
			//printf("Entrato 22");
            
			break;
           }
           
        if (cuboF[1]==cuboE[0]&& cuboF[1]==cuboB[3] && cuboF[1]==cuboC[0])  // algoritmo 7
        
           {
            orientamentonullo();
            RU2ruRur();
            orientamentonullo();
            //printf("Entrato 23");
			break;
           }
           
        if (cuboD[0]==cuboF[2]&&cuboD[0]==cuboB[3]&&cuboD[0]==cuboC[0])
        
           {
            orientamentoavanti();
            RU2ruRur();
            orientamentonullo();
            
			//printf("Entrato 24");
			break;
           }
           
        if (cuboF[3]==cuboD[0]&& cuboF[3]==cuboE[0]&&cuboF[3]==cuboC[0])
        
           {
            orientamentodoppio();
            RU2ruRur();
            orientamentonullo();
            
		//	printf("Entrato 25");
			break;
           }
           
        if (cuboF[0]==cuboD[0]&& cuboF[0]==cuboE[0]&& cuboF[0]==cuboB[3])
        
           {
            orientamentoindietro();
            RU2ruRur();
            orientamentonullo();
           // printf("Entrato 26");
			break;
           }
        printf("Problema!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"); //se non entra in nessun if allora qualcosa non va
        break;
      }
}

void Faccia1(){
 while (cuboA[0]!=cuboA[1])    //spostiamo in posizione 1 il colore simile
      {
        if (cuboB[0]==cuboA[0])

           {
             df();
             break;
           }             // le mosse non spostano il colore principale
        
        if (cuboB[2]==cuboA[0])           //cuboB1 no...

           {
             L2Df();
             break;
           }

        if (cuboB[3]==cuboA[0])
        
           {
             lF2();
             break;
           }
           
        if (cuboC[0]==cuboA[0])
        
           {
             lF();
             break;
           }
           
        if (cuboC[1]==cuboA[0])
        
           {
             D2f();
             break;
           }
           
        if (cuboC[2]==cuboA[0])

           {
             LF();
             break;
           }
           
        if (cuboC[3]==cuboA[0])

           {
             F();
             break;
           }
           
        if (cuboD[0]==cuboA[0])

           {
             FDf();
             break;
           }
           
        if (cuboD[1]==cuboA[0])

           {
             Df();
             break;
           }
           
        if (cuboD[2]==cuboA[0])

           {
             LF2();
             break;
           }
           
        if (cuboD[3]==cuboA[0])

           {
             F2Df();
             break;
           }
           
        if (cuboE[0]==cuboA[0])

           {
             dFDf();
             break;
           }
  
        if (cuboE[1]==cuboA[0])

           {
             f();
             break;
           }
           
        if (cuboE[2]==cuboA[0])

           {
             FdF2();
             break;
           }

        if (cuboF[0]==cuboA[0])  //cuboE 3 no....

           {
             F2();
             break;
           }
           
        if (cuboF[1]==cuboA[0])

           {
             dF2();
             break;
           }
           
        if (cuboF[2]==cuboA[0])

           {
             D2F2();
             break;
           }

        if (cuboF[3]==cuboA[0])

           {
             DF2();
             break;
           }

      }
//     printf("Primi Due\n");
//	 StampaCubo();
    while (cuboA[0]!=cuboA[2])    //spostiamo in posizione 2 il colore simile

      {
        if (cuboB[0]==cuboA[0])

           {
             D2l();
             break;
           }             // le mosse non spostano i due colori principali

        if (cuboB[2]==cuboA[0])           //cuboB1 no...

           {
             L();
             break;
           }

        if (cuboB[3]==cuboA[0])

           {
             ldL2();
             break;
           }

        if (cuboC[0]==cuboA[0])

           {
             LDl();
             break;
           }

        if (cuboC[1]==cuboA[0])

           {
             Dl();
             break;
           }

        if (cuboC[2]==cuboA[0])

           {
             lDl();
             break;
           }

        if (cuboC[3]==cuboA[0])

           {
             L2Dl();
             break;
           }

        if (cuboD[0]==cuboA[0])

           {
             dLDl();
             break;
           }

        if (cuboD[1]==cuboA[0])

           {
             l();
             break;
           }

        if (cuboD[2]==cuboA[0])

           {
             LdL2();
             break;
           }

        if (cuboE[0]==cuboA[0])  //cuboD3 no...

           {
             D2LDl();
             break;
           }

        if (cuboE[1]==cuboA[0])

           {
             dl();
             break;
           }

        if (cuboF[0]==cuboA[0])  //cuboE2 e cuboE3 no....

           {
           	
             dL2();
             break;
           }

        if (cuboF[1]==cuboA[0])

           {
             D2L2();
             break;
           }

        if (cuboF[2]==cuboA[0])

           {
             DL2();
             break;
           }

        if (cuboF[3]==cuboA[0])

           {
             L2();
             break;
           }

      }
//printf("Primi Tre\n");
//	 StampaCubo();
    while (cuboA[3]!=cuboA[0])    //spostiamo in posizione 3 il colore simile

      {
        if (cuboB[0]==cuboA[0])

           {
             DldL();
             break;
           }             // le mosse non spostano i tre colori principali

        if (cuboB[2]==cuboA[0])           //cuboB1 no...

           {
             lDLdlDL();
             break;
           }

        if (cuboB[3]==cuboA[0])

           {
             dlDL();
             break;
           }

        if (cuboC[0]==cuboA[0])

           {
             D2lDL();
             break;
           }

        if (cuboC[1]==cuboA[0])

           {
             ldL();
             break;
           }

        if (cuboC[2]==cuboA[0])

           {
             ldLDldL();
             break;
           }

        if (cuboD[0]==cuboA[0])    //cuboC3 no...

           {
             lD2L();
             break;
           }

        if (cuboD[1]==cuboA[0])

           {
             dldL();
             break;
           }

        if (cuboE[0]==cuboA[0])  //cuboD2 e cuboD3 no...

           {
             lDL();
             break;
           }

        if (cuboE[1]==cuboA[0])

           {
             D2ldL();
             break;
           }

        if (cuboF[0]==cuboA[0])  //cuboE2 e cuboE3 no....

           {
             dlD2LDldL();
             break;
           }

        if (cuboF[1]==cuboA[0])

           {
             D2lD2LDldL();
             break;
           }

        if (cuboF[2]==cuboA[0])

           {
            DlD2LDldL();
             break;
           }

        if (cuboF[3]==cuboA[0])

           {
            lD2LDldL();
             break;
           }

      }
}

void soluzione()  {
Faccia1();   

FacciaOpposta();

completaCubo();

if (checkCubo())
	printf("Cubo ok\n"); //dimmmi se è risolto correttamente

}


 
void mischiaCubo(){
srand(time(NULL));

cuboA[0]=1;
cuboA[1]=1;
cuboA[2]=1;
cuboA[3]=1;
cuboB[0]=2;
cuboB[1]=2;
cuboB[2]=2;
cuboB[3]=2;
cuboC[0]=3;
cuboC[1]=3;
cuboC[2]=3;
cuboC[3]=3;
cuboD[0]=4;
cuboD[1]=4;
cuboD[2]=4;
cuboD[3]=4;
cuboE[0]=5;
cuboE[1]=5;
cuboE[2]=5;
cuboE[3]=5;
cuboF[0]=6;
cuboF[1]=6;
cuboF[2]=6;
cuboF[3]=6;

 StampaCubo();	//per vedere il cubo all'inizio
 for(int i=0;i<10;i++){
	int j=(rand()%3)+1;
	int k=(rand()%3)+1;
	if (j==1){
		for(int l=0;l<k;l++){
		sinistra(); //le volte che corrispondono al valore di k
		printf("sinistra\n"); //per verificare se ha fatto realmente sinistra
		}
	}else if(j==2){
		for(int l=0;l<k;l++){
			sotto();
			printf("sotto\n");
		}
	}
	else{
		for(int l=0;l<k;l++){
			sopra();
			printf("sopra\n");
		}
	}
	StampaCubo();  //per controllare se ha mischiato correttamente
}

}//in sintesi, sceglie un movimento a caso da fare, lo fa per un numero casuale di volte, il tutto per 10 volte

  
  
 int main()
  {
  	
  
  	
  	
  	int j=0;
      for(int i=0;i<10000;i++){ //risolvi 10000 cubi ;)
  	
	  mischiaCubo();
		
	  if(!checkColors()){
	  	printf("Errore!!!"); //se dopo aver mischiato i colori non sono verificati, dimmelo
	  }
	  printf("-----PRIMA-----\n");
	  StampaCubo();
	  printf("---------------\n");
	 
	  Faccia1();
	 
	  printf("-----Faccia1-----\n");
	  StampaCubo();
	  printf("---------------\n");
//	  if (checkFaccia1()){
//	      k++;
//		  printf("Faccia1 ok %d\n",i);
//	  }
//	  else return 0;
	 
	  FacciaOpposta();
	  printf("-----FacciaF-----\n");
	  StampaCubo();
	  printf("---------------\n");
	  
	  completaCubo();
      printf("-----Fine-----\n");
	  StampaCubo();
	  printf("---------------\n");
      if (checkCubo()){
	    printf("Cubo ok\n"); //controlla che il cubo è risolto e dimmelo
	    j++; //aggiungi un cubo ai cubi risolti
	  }else
	  return 0;
	  
	  
	  
	  
	  
  }
  printf("Corretti = %d\n", j); //dimmi quanti cubi hai risolto correttamente
  return 0;
  }



  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

This snippet took 0.14 seconds to highlight.

Back to the Entry List or Home.

Delete this entry (admin only).