[SOLUCIONADO] Mastermind c++ (juego)

[b3salvat]

El Mastermind es un juego de tablero del tipo juego abstracto, donde se usa la capacidad de deducción por
averiguar un código formado por letras (colores en el original).

Cada tirada consiste en provar un código que damos, la máquina nos contestará cuantas letras hemos colocado bien, pero no cualas, y también
el número de aproximaciones que hemos puesto pero que no estan en el sitio correcto.

Os quería pedir ayuda porque ya tengo las dos primeras funciones que son:

string to_string (int valor)
Nos devolverá el entero del parámetro en forma de string.

bool válido (string, int n)
Nos devuelve cierto si todas las letras son minúsculas y que
Su longitud es igual a n.

y me falta una tercera:

string evaluar (string, string)
Debe evaluar una jugada, devolviendo un string de la forma "2A, 4ª" en el
caso de obtener 2 acertados y 4 aproximaciones.

Si alguien me pudiera ayudar estaría muy agradecido, y si alguien ha hecho este juego y quiere ayudar que envie mp jeje ^^

[b3salvat]

Si teneis alguna duda o no me he explicado suficientemente bien decidmelo porfavor

[eferion]

Y dónde está lo que llevas hecho de esas funciones?

[b3salvat]

Aqui las dejo:

Código C++:

string to_string (int n){
 
    stringstream iss;
    iss<<n;
    return iss.str();
}
 

Código C++:

bool valida(string s, int n)
{
    if (s.size()!=n) return false; // SORTIDA IMMEDIATA DE LA FUNCIO
    for (int i=0; i<s.size(); i++)
    {
        cout<<"Original: "<<s[i]<<" - Copia: "<<(char)tolower(s[i])<<endl;
        if (s[i]!=(char)tolower(s[i]))
        {
            return false;
        }
    }
    return true;
}
 

[dehm]

Esta no es la mejor de las soluciones, porque hace recorridos dobles , breaks y engendros así, pero a estas horas.....

Código C++:

string evaluar (string cadena, string referencia);
 
int main()
{
 
    cout<<evaluar("12345","54321")<<endl;
    cout<<evaluar("abbcd","accbd")<<endl;
    return 0;
}
 
string evaluar (string cadena, string referencia)
{
    int acertados=0;
    int aproximaciones=0;
    //asumimos que las cadenas tienen el mismo tamaño
    for (int i=0;i<cadena.size();i++)
    {
        if (cadena[i]==referencia[i])
        {
            acertados++;
        }
        else
        {
            for (int j=0;j<cadena.size();j++)
            {
                if (cadena[i]==referencia[j])
                {
                            aproximaciones++;
                            break;
                }
            }
        }
    }
    stringstream iss;
    iss<<acertados<<"A, "<<aproximaciones<<"a";
    return iss.str();
}
 

(creo que funciona)
Saludos!

[eferion]

Para comprobar si los caracteres están en minúsculas hay una forma mejor que ir recorriendo el string:

*Haces una copia del string
*Conviertes la copia a minúsculas
*Si ambos strings son iguales... pues eso

Vale que string no dispone de ningún método para hacer la conversión a minúsculas de forma directa, pero puedes valerte de la stl:

Código C++:

#include <algorithm>
 
std::string copia = cadena;
std::transform(copia.begin(), copia.end(), copia.begin(), ::tolower);
 
if ( copia == cadena )
...
 

Por otro lado, el procedimiento para detectar las coincidencias podría ser algo más o menos así:

Código C++:

// Creamos un array para los resultados, así podemos ir marcando los aciertos
std::vector< bool> resultado( cadena.length( ), false );
int aciertos = 0;
int aproximaciones = 0;
 
// Primero buscamos los aciertos
for ( size_t i = 0; i < cadena.length( ); ++i )
{
  if ( cadena[ i ] == referencia[ i ] )
  {
    // Marcamos el acierto, esto nos permite evitar estos valores al contar las aproximaciones
    resultado[ i ] = true;
    aciertos++;
  }
}
 
// Después buscamos las aproximaciones
for ( size_t i = 0; i < cadena.length( ); ++i )
{
  if ( !resultado[ i ] )
  {
    size_t aprox = 0;
    
    while( true )
    {
      // Buscamos la siguiente referencia
      aprox = std::find( referencia, aprox );
 
      // Comprobamos si no se encuentran más referencias
      if ( aprox ==  string::npos )
        break;
 
      // Si la referencia no ha sido utilizada, la marcamos
      if ( resultado[ aprox ] == 0 )
      {
        aproximaciones++;
 
        // eliminamos la aproximación de la referencia
        referencia[ aprox ] = '_'; // Cualquier caracter que no pertenezca a la secuencia vale.
        break;
      }
    }
  }
}
 
// Componemos el string
return to_string( aciertos ) + "A, " + to_string( aproximaciones );
 

No lo he compilado, pero creo que debería funcionar.

[b3salvat]

Muchas gracias eferion por tu aportación. La verdad es que ahora me iba a la cama y no tengo tiempo de mirarmelo pero mañana lo haré a primera hora.

Gracias!

[dehm]

Pues si que estaba mal lo mío, ya que mi código dejaba que una posición fuera a la vez Acierto y Aproximación.

Ahora le he hecho un añadido para que no contemple esa doble condición:

Código C++:

#include <iostream>
#include <cstring>
#include <sstream>
 
using namespace std;
string evaluar (string cadena, string referencia);
 
int main()
{
 
    cout<<evaluar("12345","54321")<<endl;
    cout<<evaluar("yybr","ygbr")<<endl;
    return 0;
}
 
string evaluar (string cadena, string referencia)
{
    int acertados=0;
    int aproximaciones=0;
    //asumimos que las cadenas tienen el mismo tamaño
    for (int i=0; i<cadena.size(); i++)
    {
        if (cadena[i]==referencia[i])
        {
            acertados++;
        }
        else
        {
            for (int j=0; j<cadena.size(); j++)
            {
                if (cadena[i]==referencia[j] && cadena[j]!=referencia[j])//aqui está el añadido
                {
                    aproximaciones++;
                    break;
                }
            }
        }
    }
    stringstream iss;
    iss<<acertados<<"A, "<<aproximaciones<<"a";
    return iss.str();
}
 

A ver si ahora cumple mejor

Sobre lo de comprobar las minúsculas...eres la 2ª persona que propone esa forma (y ambos personas muy solventes), pero pienso que este método es menos eficaz, ya que obliga a crear una copia, pasarla a minúsculas, y entiendo que la sobrecarga del operador == igualmente hace un recorrido por la cadena.
¿Puede ser o estoy diciendo una tontería?
@b3salvat: En caso de duda, haz caso a eferion

[eferion]

Iniciado por dehm

PSobre lo de comprobar las minúsculas...eres la 2ª persona que propone esa forma (y ambos personas muy solventes), pero pienso que este método es menos eficaz, ya que obliga a crear una copia, pasarla a minúsculas, y entiendo que la sobrecarga del operador == igualmente hace un recorrido por la cadena.
¿Puede ser o estoy diciendo una tontería?

Es un hecho que la inmensa mayoría de los programadores ve una gran preocupación en el rendimiento... antes incluso de ver la aplicación en funcionamiento.

Si necesitas que tu código se ejecute en millonésimas de segundo, o el algoritmo se ejecuta millones de veces de forma iterativa, entonces puede que tengas que preocuparte por optimizar el rendimiento (atención al "puede")... pero un algoritmo que interactua con el usuario, que se ejecuta una decena de veces, y que en cada iteración hace una copia de un string de 10 caracteres... por mucho que lo intentes optimizar no vas a notar ninguna diferencia. En cambio, sí vas a notar diferencias de tiempo entre depurar un código super optimizado y un código legible.

Y no, la optimización no suele llevarse bien con la legibilidad. Ya puestos, se podría optimizar aún más bajando a C... o a ensamblador directamente... creo que se entiende la idea.

Es menos óptimo? Sí, por supuesto
Merece la pena optimizar? Lo dudo mucho.
Decisión final? Depende de ti. Tu eres el diseñador de esa aplicación.

[b3salvat]

Dehm no me deja compilar tu último programa, me da error en la última llave (fila 36) y no sé porque..

[eferion]

Iniciado por dehm

Sobre lo de comprobar las minúsculas...eres la 2ª persona que propone esa forma (y ambos personas muy solventes), pero pienso que este método es menos eficaz, ya que obliga a crear una copia, pasarla a minúsculas, y entiendo que la sobrecarga del operador == igualmente hace un recorrido por la cadena.
¿Puede ser o estoy diciendo una tontería?
@b3salvat: En caso de duda, haz caso a eferion

Por cierto, respecto a este comentario. No se si te has dado cuenta, pero tu código hace sendas copias de los strings cada vez que llamas a la función. No estás pasando los strings por referencia sino por valor, luego estás obligando a que se creen copias de las cadenas con cada llamada ;)

[b3salvat]

Además dehm, yo creo que tu primer programa hace exactamente lo que quería, pone los aciertos correctamente y las aproximaciones también..
Muchas gracias a los dos por ayudarme, marco el tema como solucionado y repito: gracias.

[dehm]

Iniciado por eferion

No se si te has dado cuenta, pero tu código hace sendas copias de los strings cada vez que llamas a la función

ehhhh....quería respetar el prototipo de la función
(mentira, casi nunca me acuerdo de tener en cuenta esto)

@b3salvat: El caso es que nunca he jugado al mastermind, pero por lo que estoy viendo en el ejemplo de wikipedia, lo mio no funciona, ya que en caso de repetición de colores, siendo estos aproximaciones, sólo se consideran tantas aproximaciones como colores iguales haya en el patrón.

En el ejemplo de la wikipedia la secuencia a acertar es verde-rojo-azul-verde
Digamos que es en ingles grbg
Y se hacen dos intentos:
rojo-amarillo-rojo-verde ryrg
y
verde-verde-naranaja-rojo ggor
El primer intento arroja 1 acierto y 1 aproximación
El segundo 1 acierto y 2 aproximaciones

Pero mi código arroja 1 intento y 2 aproximaciones en ambos casos:

Código C++:

cout<<evaluar("ryrg","grbg")<<endl;
cout<<evaluar("ggor","grbg")<<endl;
 

Eso es porque parece (viendo el ejemplo) que si tengo dos fichas rojas que no están en su sitio y un sóla ficha roja en el patrón, he de considerar sólo una aproximación.
Mira a ver el código de eferion, que seguramente lo hará mejor