RETOS C++

[Stakewinner00]

Código (c) [Seleccionar] Expandir

#include <iostream>
    using namespace std;

int main ()
{
    int a,b,c,d;
    cin >> a >> b >> c >> d;
    if ((a= a>b ? a:b)>(c= c>d ? c:d))
        cout << a << endl;
    else
        cout << c << endl;
}


esta forma de estructurar el if nunca lo havia visto
y a decir verdad solo entiendo la mitad.

Si me puedes explicar el ? y el a:b. que és lo que no entendi.

[overxfl0w13]

esta forma de estructurar el if nunca lo havia visto
y a decir verdad solo entiendo la mitad.

Si me puedes explicar el ? y el a:b. que és lo que no entendi.

Operadores ternarios busca documentación sobre ellos son bastante útiles.

EI: juntando mensajes.

RETO 12:

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <fstream>
using namespace std;
int numeroSudoku[100];
bool compruebaVertical();
bool compruebaCuadros();
bool compruebaHorizontal();

int main(int argc,char* argv)
{

    ifstream archivo("sudoku.txt");
    for(int x=0;x<=80 && archivo.eof() == false;x++)
    {
        archivo >> numeroSudoku[x];
    }
    if(compruebaVertical()  && compruebaHorizontal()  && compruebaHorizontal())
    {
        cout << "Sudoku Valido" << endl;
    }
    else
    {
        cout << "Sudoku Invalido" << endl;
    }
    return 0;
}

bool compruebaVertical()
{
    if(numeroSudoku[0] + numeroSudoku[9] + numeroSudoku[18] + numeroSudoku[27] + numeroSudoku[36] + numeroSudoku[45] + numeroSudoku[54] + numeroSudoku[63] + numeroSudoku[72] == 45 )
    {
        if(numeroSudoku[1] + numeroSudoku[10] + numeroSudoku[19] + numeroSudoku[28] + numeroSudoku[37] + numeroSudoku[46] + numeroSudoku[55] + numeroSudoku[64] + numeroSudoku[73] == 45 )
        {
            if(numeroSudoku[2] + numeroSudoku[11] + numeroSudoku[20] + numeroSudoku[29] + numeroSudoku[38] + numeroSudoku[47] + numeroSudoku[56] + numeroSudoku[65] + numeroSudoku[74] == 45 )
            {
                if(numeroSudoku[3] + numeroSudoku[12] + numeroSudoku[21] + numeroSudoku[30] + numeroSudoku[39] + numeroSudoku[48] + numeroSudoku[57] + numeroSudoku[66] + numeroSudoku[75] == 45 )
                {
                    if(numeroSudoku[4] + numeroSudoku[13] + numeroSudoku[22] + numeroSudoku[31] + numeroSudoku[40] + numeroSudoku[49] + numeroSudoku[58] + numeroSudoku[67] + numeroSudoku[76] == 45 )
                    {
                        if(numeroSudoku[5] + numeroSudoku[14] + numeroSudoku[23] + numeroSudoku[32] + numeroSudoku[41] + numeroSudoku[50] + numeroSudoku[59] + numeroSudoku[68] + numeroSudoku[77] == 45 )
                        {
                            if(numeroSudoku[6] + numeroSudoku[15] + numeroSudoku[24] + numeroSudoku[33] + numeroSudoku[42] + numeroSudoku[51] + numeroSudoku[60] + numeroSudoku[69] + numeroSudoku[78] == 45 )
                            {
                                if(numeroSudoku[7] + numeroSudoku[16] + numeroSudoku[25] + numeroSudoku[34] + numeroSudoku[43] + numeroSudoku[52] + numeroSudoku[61] + numeroSudoku[70] + numeroSudoku[79] == 45 )
                                {
                                    if(numeroSudoku[8] + numeroSudoku[17] + numeroSudoku[26] + numeroSudoku[35] + numeroSudoku[44] + numeroSudoku[53] + numeroSudoku[62] + numeroSudoku[71] + numeroSudoku[80] == 45 )
                                    {
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    else return false;
}

bool compruebaHorizontal()
{
    bool sudokuCorrecto = false;
    if(numeroSudoku[0] + numeroSudoku[1] + numeroSudoku[2] + numeroSudoku[3] + numeroSudoku[4] + numeroSudoku[5] + numeroSudoku[6] + numeroSudoku[7] + numeroSudoku[8] == 45 )
    {
        if(numeroSudoku[9] + numeroSudoku[10] + numeroSudoku[11] + numeroSudoku[12] + numeroSudoku[13] + numeroSudoku[14] + numeroSudoku[15] + numeroSudoku[16] + numeroSudoku[17] == 45 )
        {
            if(numeroSudoku[18] + numeroSudoku[19] + numeroSudoku[20] + numeroSudoku[21] + numeroSudoku[22] + numeroSudoku[23] + numeroSudoku[24] + numeroSudoku[25] + numeroSudoku[26] == 45 )
            {
                if(numeroSudoku[27] + numeroSudoku[28] + numeroSudoku[29] + numeroSudoku[30] + numeroSudoku[31] + numeroSudoku[32] + numeroSudoku[33] + numeroSudoku[34] + numeroSudoku[35] == 45 )
                {
                    if(numeroSudoku[36] + numeroSudoku[37] + numeroSudoku[38] + numeroSudoku[39] + numeroSudoku[40] + numeroSudoku[41] + numeroSudoku[42] + numeroSudoku[43] + numeroSudoku[44] == 45 )
                    {
                        if(numeroSudoku[45] + numeroSudoku[46] + numeroSudoku[47] + numeroSudoku[48] + numeroSudoku[49] + numeroSudoku[50] + numeroSudoku[51] + numeroSudoku[52] + numeroSudoku[53] == 45 )
                        {
                            if(numeroSudoku[54] + numeroSudoku[55] + numeroSudoku[56] + numeroSudoku[57] + numeroSudoku[58] + numeroSudoku[59] + numeroSudoku[60] + numeroSudoku[61] + numeroSudoku[62] == 45 )
                            {
                                if(numeroSudoku[63] + numeroSudoku[64] + numeroSudoku[65] + numeroSudoku[66] + numeroSudoku[67] + numeroSudoku[68] + numeroSudoku[69] + numeroSudoku[70] + numeroSudoku[71] == 45 )
                                {
                                    if(numeroSudoku[72] + numeroSudoku[73] + numeroSudoku[74] + numeroSudoku[75] + numeroSudoku[76] + numeroSudoku[77] + numeroSudoku[78] + numeroSudoku[79] + numeroSudoku[80] == 45 )
                                    {
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    else return false;
}

bool compruebaCuadros()
{
    bool sudokuCorrecto = false;
    if(numeroSudoku[0] + numeroSudoku[1] + numeroSudoku[2] + numeroSudoku[9] + numeroSudoku[10] + numeroSudoku[11] + numeroSudoku[18] + numeroSudoku[19] + numeroSudoku[20] == 45 )
    {
        if(numeroSudoku[3] + numeroSudoku[4] + numeroSudoku[5] + numeroSudoku[12] + numeroSudoku[13] + numeroSudoku[14] + numeroSudoku[21] + numeroSudoku[22] + numeroSudoku[23] == 45 )
        {
            if(numeroSudoku[6] + numeroSudoku[7] + numeroSudoku[8] + numeroSudoku[15] + numeroSudoku[16] + numeroSudoku[17] + numeroSudoku[24] + numeroSudoku[25] + numeroSudoku[26] == 45 )
            {
                if(numeroSudoku[27] + numeroSudoku[28] + numeroSudoku[29] + numeroSudoku[36] + numeroSudoku[37] + numeroSudoku[38] + numeroSudoku[45] + numeroSudoku[46] + numeroSudoku[47] == 45 )
                {
                    if(numeroSudoku[30] + numeroSudoku[31] + numeroSudoku[32] + numeroSudoku[39] + numeroSudoku[40] + numeroSudoku[41] + numeroSudoku[49] + numeroSudoku[50] + numeroSudoku[51] == 45 )
                    {
                        if(numeroSudoku[33] + numeroSudoku[34] + numeroSudoku[35] + numeroSudoku[42] + numeroSudoku[43] + numeroSudoku[44] + numeroSudoku[51] + numeroSudoku[52] + numeroSudoku[53] == 45 )
                        {
                            if(numeroSudoku[54] + numeroSudoku[55] + numeroSudoku[56] + numeroSudoku[63] + numeroSudoku[64] + numeroSudoku[65] + numeroSudoku[72] + numeroSudoku[73] + numeroSudoku[74] == 45 )
                            {
                                if(numeroSudoku[57] + numeroSudoku[58] + numeroSudoku[59] + numeroSudoku[66] + numeroSudoku[67] + numeroSudoku[68] + numeroSudoku[75] + numeroSudoku[76] + numeroSudoku[77] == 45 )
                                {
                                    if(numeroSudoku[60] + numeroSudoku[61] + numeroSudoku[62] + numeroSudoku[69] + numeroSudoku[70] + numeroSudoku[71] + numeroSudoku[78] + numeroSudoku[79] + numeroSudoku[80] == 45 )
                                    {
                                        return true;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    else return false;
}


El código no está para nada optimizado (puede ocupar menos de la mitad de lineas usando arrays multidimensionales),lo he hecho rápido antes de ir a acostarme . El usuario introduce los valores por lineas en un archivo de texto, de izquierda a derecha del sudoku es decir siguiendo esta imagen:

http://i.msdn.microsoft.com/dynimg/IC37479.gif

Una parte del archivo de texto quedaría así:

Código [Seleccionar] Expandir

6
3
2
7
8
1
9
4
5
...

Precisamente con el sudoku de ese gif he hecho la prueba del programa y funciona



Cuando tenga tiempo lo optimizaré, de momento 35 puntos más, esto engancha que te cagas 

[dato000]

No lo hago por los puntos, sino porque no tengo nada más que hacer XDD

3- Un programa que diga el numero mas grande. El usuario ha de insertar 4 numeros separados por un espacio.

Código (cpp) [Seleccionar] Expandir


#include <iostream>

using namespace std;

int main()
{
    int a[4];
    int mayor=0;
    cout << "digite los números, con cada espacio se registra un numero nuevo: ";
    for(int i=0; i<4; i++)
        cin >> a[i];

    // BARRIDO
    for(int i=0; i<4; i++){
        if(a[i] > mayor){
            mayor = a[i];
        }
    }

    cout << "El mayor es: " << mayor << endl;
    cin.get();
    return 0;
}


[leosansan]

Tienes el problema que si introduzco cuatro números negativos el mayor es, como no, el cero ... que no forma parte de los cuatro números. Tendrías que usar la libreria limits y asignarle a menorel valor de entero que es int_MIN o algo así.
Pero insisto en algo que postee anteriormente, no se está haciendo lo que dice textualmente el enunciado:
3- Un programa que diga el numero mas grande. El usuario ha de insertar 4 numeros separados por un espacio.
Este código sí hace lo que se pide:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <cstdio>
using namespace std;
main()
{
    int a,b,c,d,mayor;
    char ch,cad[100]/*= "17 32 15 27"*/;
    cout <<"Introduzca cuatro numeros separados por un espacio:"<< endl;
    gets (cad);
    sscanf(cad, "%d%c%d%c%d%c%d",&a, &ch ,&b,&ch, &c,&ch, &d  );
    if ((a= a>b ? a:b)>(c= c>d ? c:d))
        cout << a << endl;
    else
        cout << "mayor = " << c << endl;
    return 0;
}

[Stakewinner00]

ya actualice los puntos,si se les ocurre algo para los retos mejor

[leosansan]

12- Un programa que haga diversos rombos de 2 * n -1 lineas como en el siguiente ejemplo  

Entrada: 4
SAlida:  
   *
 ***
*****
*******
*****
 ***
  *

25 puntos

Código (c) [Seleccionar] Expandir

#include <iostream>
using namespace std;
int main()
{
int n,fila,col;
cout << "tamanyo de la piramide: "<<endl;
cin >> n;
   for(fila=1;fila<=n;fila++)
   {
       for(col=1;col<=n-fila;col++)
           cout<<" ";
       for(col=1;col<=2*fila-1;col++)
           cout<<"*";
   cout<<endl;
           }
/* Escritura de la parte inferior */
   for(fila=n-1;fila>=1;fila--)
   {
       for(col=1;col<=n-fila;col++)
           cout<<" ";
       for(col=1;col<=2*fila-1;col++)
           cout<<"*";
   cout<<endl;
   }
}

__

EI: juntando mensajes.

1-Un programa que cuente los caracteres que tiene un texto previamente introducido por el usuario (parece más fácil de lo que es)

ejemplo de entrada: "ho la" ejemplo salida:el texto tiene 5 caracteres

1 punto
Incluyendo espacios en blanco:

Código (cpp) [Seleccionar] Expandir

#include <iostream>
#include <stdio.h>
using namespace std;
main()
{
    int i;
    char cadena [200];
    gets (cadena);
    for (i=0;cadena [i]!='\0';i++) ;
    cout << "El texto tiene " << i << " caracteres." << endl;
    return 0;
}

[Eternal Idol]

Por favor no escriban dos (o mas) mensajes consecutivos.

[do-while]

SUDOKU (No se el numero de reto...)

Ya esta.

Código (cpp) [Seleccionar] Expandir


/*
* Linea de comandos: Nombre programa fichero
*
* El fichero debe tener el siguiente formato:
*  - 9 filas con 9 numeros separados por espacios
*  - Los numeros que vengan dados en el sudoku se escribiran en la posicion que corresponde
*  - Las casillas vacias del sudoku se indicaran con ceros
*  - Todas las filas deben acabar en un salto de linea
*  - Cuanquier linea que siga a las 9 primeras sera ignorada.
*
*
* Salida: Muestra como mucho 2 soluciones (las suficientes para que el contenido del fichero no sea un sudoku correcto)
* y sino indica que no hay solucion.
*
*/


#include <iostream>
#include <cstdio>
#include <cstring>

using namespace std;

class Sudoku
{
   public:
       Sudoku();

       bool cargar(char *nombrefichero);
       bool solucionar();
       bool solucion_unica();
       inline bool esta_solucionado(){return solucionado;};

       friend ostream& operator <<(ostream &out,Sudoku &s);

   private:

       bool correcto(int fila, int columna, int valor);
       bool resolver(int fila, int columna);
       bool multiples_soluciones(int fila, int columna);

       int tabla[9][9];
       bool solucionado;
};

Sudoku::Sudoku()
{
   for(int i = 0 ; i < 81 ; i++)
       tabla[i / 9][i % 9] = 0;

   solucionado = false;
}

bool Sudoku::cargar(char *nombrefichero)
{
   int i;
   char fila[19]; //los 9 numeros + 8 espacios + 1 salto de linea + '\0';
   FILE *f;

   if(!(f = fopen(nombrefichero,"r")))
       return false;

   for(i = 0 ; i < 9 ; i++)
   {
       fgets(fila,19,f);

       if(strlen(fila) < 18 || fila[strlen(fila) - 1] != '\n') //formato incorrecto
       {
           for(int j = 0 ; j < i ; i++) //anulamos la lectura que habia hasta el momento
               memset(tabla[j] , 0 , 9 * sizeof(int));

           fclose(f);

           return false;
       }

       for(int j = 0 ; j < 9 ; j++)
       {
           if(fila[2 * i] < '0' || fila[2 * i] > '9')//Si las posiciones pares no son un numero
           {
               for(int k = 0 ; k < i ; k++) //anulamos la lectura que habia hasta el momento
                   memset(tabla[k],0,9*sizeof(int));

               fclose(f);

               return false;
           }

           if(fila[2 * i + 1] != ' ' && fila[2 * i + 1] != '\n')//Si las posiciones impares no son ni espacio ni \n
           {
               for(int k = 0 ; k < i ; k++) //anulamos la lectura que habia hasta el momento
                   memset(tabla[k],0,9*sizeof(int));

               fclose(f);

               return false;
           }
       }

       //traducimos la fila para el algoritmo
       for(int j = 0 ; j < 9 ; j++)
           tabla[i][j] = fila[2 * j] - '0';
   }

   fclose(f);

   return true;
}

bool Sudoku::solucionar()
{
   return resolver(0,0);
}

bool Sudoku::solucion_unica()
{
   return !multiples_soluciones(0,0);
}

bool Sudoku::correcto(int fila, int columna, int valor)
{
   for(int i = 0 ; i < 9 ; i++)
   {
       if(tabla[i][columna] == valor)
           return false;

       if(tabla[fila][i] == valor)
           return false;

       if(tabla[3 * (fila / 3) + i / 3][3 * (columna / 3) + i % 3] == valor)
           return false;
   }

   return true;
}

bool Sudoku::resolver(int fila, int columna)
{
   if(fila == 9)
   {
       solucionado = true;
       return true;
   }

   if(tabla[fila][columna] != 0) //Si tenemos un numero original
   {
       if(resolver((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9)) //pasamos a resolver la siguiente posicion
           return true;
   }
   else
   {
       //probamos cada uno de los numeros
       for(int i = 1 ; i <= 9 ; i++)
       {
           if(correcto(fila,columna,i)) //Si es corrector en la posicion dada
           {
               tabla[fila][columna] = i; //Marcamos la casilla con el numero

               //Y pasamos a resolver la siguiente posicion
               if(resolver((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9))
                   return true;
           }
       }

       tabla[fila][columna] = 0; //Volvemos a dejar vacia la posicion actual
   }

   return false;
}

bool Sudoku::multiples_soluciones(int fila, int columna)
{
   if(fila == 9)
   {
       if(!solucionado)
       {
           cout << *this << endl;
           solucionado = true;
           return false;
       }
       cout << *this << endl;
       return true;
   }

   if(tabla[fila][columna] != 0) //Si tenemos un numero original
   {
       if(multiples_soluciones((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9)) //pasamos a resolver la siguiente posicion
           return true;
   }
   else
   {
       //probamos cada uno de los numeros
       for(int i = 1 ; i <= 9 ; i++)
       {
           if(correcto(fila,columna,i)) //Si es corrector en la posicion dada
           {
               tabla[fila][columna] = i; //Marcamos la casilla con el numero

               //Y pasamos a resolver la siguiente posicion
               if(multiples_soluciones((9 * fila + columna + 1) / 9, (9 * fila + columna + 1) % 9))
                   return true;
           }
       }

       tabla[fila][columna] = 0; //Volvemos a dejar vacia la posicion actual
   }

   return false;
}

ostream& operator <<(ostream &out,Sudoku &s)
{
   for(int i = 0 ; i < 9 ; i++)
   {
       if(!(i % 3))
           out << endl;

       for(int j = 0 ; j < 9 ; j++)
       {
           if(!(j % 3))
               out << ' ';

           out << s.tabla[i][j] << ' ';
       }

       out << endl;
   }

   return out;
}

int main(int argc, char *argv[])
{
   Sudoku sudoku;

   if(argc != 2)
   {
       cout << argv[0] << " fichero";
       return -1;
   }

   if(!sudoku.cargar(argv[1]))
   {
       cout << "Error en carga de fichero." << endl;
       return -1;
   }

   if(sudoku.solucion_unica() && sudoku.esta_solucionado())
   {
       cout << "El sudoku tiene una unica solucion:" << endl;
   }
   else if(sudoku.esta_solucionado())
       cout << "El fichero no contiene un sudoku correcto. Tiene mas de una solucion." << endl;
   else
       cout << "El sudoku no tiene solucion." << endl;

   return 0;
}


[Stakewinner00]

SUDOKU (No se el numero de reto...)

El codigo no era correcto.

Lo reviso y lo vuelvo a colgar.

¡Saludos!

ok ya vi k algo raro pasaba.

[dato000]

10- Un programa que escriba al revés las palabras.

Entrada: hola
Salida: aloh

15 puntos

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#define T 100

using namespace std;

int main()
{
    char palabra[T];
    for(int i=0; i<T; i++){
            palabra[i]= '\0';
    }

    cout << "Ingrese la palabra: ";
    cin >> palabra;

    cout << "Palabra al reves:";
    for(int i=99; i>=0; i--){
        if(palabra[i] != '\0')
            cout << palabra[i];
    }

    return 0;
}


Creo que este es el ultimo que hare... Los demás bueno, O ya han sido publicados, o simplemente no se hacerlos. Y por ejemplo, el 11 y el 12, ya se como hacerlos, los tengo por ahi, pero son inspirados en paueky, es decir, son copiados, y bah...

De todas maneras superpost!!!!! pase buen tiempo, el diccionario, el hash, y esos altos aún no se como hacerlos. Pero algún día!