Hola, muy buenas fiestas a todos.

Aclaro que a continuación hablaré respecto al código C no C++.

Les comento, para el curso de este año nos han mandado la implementación (con unos requisitos) del juego de Hundir la flota (Battleship). Con su menú compacto/reducido, modalidades de juego (0 jugadores, 1 jugador o 2 jugadores) calcular la puntuación y la certeza de disparos, guardar datos en ficheros, mostrar top 10 de un fichero, etc.

El problema surje cuando tengo que programar la inteligencia del siguiente disparo de la máquina.

La maquina dispara en un tablero inicializado con todo agua ('?'). El primer disparo lo hace al azar en un tablero de 8x8, 9x9 o 10x10 decidido por el usuario.
En la modalidad 0, la máquina (el programa) juega toda sola, automaticamente: el programa genera disparos para descubrir la posición de todos los barcos i hundir la flota. El objetivo es hundirla con el menor numero de disparos posibles.

El programa decidirá el siguiente disparo llamando al procedimiento decide_disparo, para determinar fila y columna del siguiente disparo. El procedimiento debe decidir segun el contenido del tablero de disparos y de la estrategia a seguir, las coordenadas del siguiente disparo, que a continuación llamará a otro procedimiento ya implementado dispara() que nos efectua el tiro y devuelve el resultado de éste, si ha sido tocado, agua, hundido, etc.

Debemos seguir una estrategia de juego. Por ejemplo He programado que cuando se hunde un barco se envuelva el barco con el caracter agua tocada ('.').

Se me ocurren diferentes estrategias:
0. Disparos totalmente aleatorios, sin repetir casillas anteriores.
1. En caso que el ultimo disparo sea parte de un barco, disparar a casillas adyacentes. Si no se vuelve a tocar que dispare aleatoriamente.
2.En caso que sea barco, seguir una dirección de disparo (N,S,E,O) para decidir el siguiente disparo. Si no se encuentra ninguna disponible usamos la estrategia 0.
3. En caso de llegar al extremo de un barco, buscar en la dirección contraria. Si no se encuentra disponible, usar la estrategia 0.

A mejor estrategia mejor nota. He realizado la 1 con un correcto funcionamiento. Pero llevo dos semanas atascado en cómo poder implementar las otras dos estrategias (2-3). He pensado en usar variables auxiliares como memoria, para acordarse de los 2 disparos anteriores, guardando también sus coordenadas (en caso que fuese barco '@'). Y con esa información ir recorriendo usando el método BFS pero por lo que he encontrado por internet, éste metodo solo se utiliza en C++.
También pensé en una variable boleana que me permitiese saber cuando he tocado un barco por primera vez. Si miro a su alrededor y es todo (?) significa que lo he tocado por primera vez. Si alrededor de la casilla actual @ encuentro otro @ ya sabría la dirección que tomar.

El caso se encuentra cuando he tocado un barco y en alguna de las direcciones tengo 1, 2 o 3 aguas tocadas '.' (si tuviese 4 aguas tocadas significaría que el barco es de tamaño 1 casilla, y ya está hundido). Aquí es donde entraría en juego las variables aux de memoria.

Creo que se puede llegar a hacer más sencillo de cómo lo tengo planteado hacer.

Me gustaría leer ideas, aportes, consejos, y si alguien, con el espiritu Navideño, se ve con ganas de ayudar le podría pasar el proyecto entero.

Para decidir el disparo, nos exigen diseñar un procedimiento con la siguiente cabecera:

void P_decide_disparo (int *f, int *c, char tablero_disparos[][COL_MAX], unsigned int dim)

Dónde, *f= numero de la fila en la que hemos disparado (referencia)
*c= numero de la columna que hemos disparado (referencia)
tablero_disparos[][COL_MAX] --> mi tablero donde he disparado, y veo agua sin visitar (?), agua tocada (.), tocado (@). Cuando se hunde el barco se envuelve con agua tocada para saber que está hundido.
dim = valor de la dimensión del tablero 8, 9 o 10.

Podría colgar el código que tengo hecho del procedimiento por si a alguien le es mas sencillo seguir un planteamiento a raíz de éste.

Muchas gracias a toda la comunidad, soys de gran ayuda.

PD: antes de postear me he leido todo el foro y buscado ayuda sobre el tema, y al no encontrar nada sobre el tema no me ha quedado otra que abrir un post.

Hola a todos, disculpen ser tan directo, pero llevo semanas comiendome la cabeza.

Estoy trabajando con un proyecto en el que debo, en lenguaje .C NO en C++:

Disponemos de un archivo, "NOTAS.txt", con las notas de los alumnos (25 alumnos) de
todas las clases de un colegio (12 clases). En el archivo, en primer lugar se encuentra el
número de clases, a continuación, para cada clase, el identificativo de la clase (un
valor entero de 1 a 12), y las notas correspondientes a cada alumno (reales). Los datos de
las clases no están ordenados. Cada línea contiene los datos de una clase, con las
notas de cada alumno:

Me pide hacerlo sin usar procedimientos (funciones, acciones) más adelante si.
Esto es lo que necesito para empezar a hacer el programa, más adelante me pide calcular medias, desviación tipica, etc.

Este es el formato del .txt: y aquí el enlace al .txt --> http://ge.tt/6XjDLOh2

12
(clase) (notas) (notas)......(notas)
1 nota1 nota2 nota3 ... nota25\n
4 nota1 nota2 nota3 ... nota25\n
2 nota1 nota2 nota3 ... nota25\n
... (hasta 12)

Leer el archivo y que me lo imprima bien por pantalla lo tengo hecho. Ahora solamente me faltaría ordenar (por filas) las clases, con sus notas respectivas,  las notas no hace falta ordenarlas, es decir, que me quede algo así:

12
(clase) (notas) (notas)......(notas)
1 nota1 nota2 nota3 ... nota25\n
2 nota1 nota2 nota3 ... nota25\n
3 nota1 nota2 nota3 ... nota25\n
... (hasta 12)

He probado utilizar el metodo de la burbuja pero no me lo ordena del todo. A continuación les muestro mi código hasta ahora:

Explico lo que he pensado. En primer lugar fijarme solamente en la primera columna de todas las filas, y comprobar si la posición 0,0 > a la posición [1][0] y así sucesivamente. En segundo lugar si la posición 0,0 es mayor a la [1][0] hacer que se intercambien usando una variable auxiliar de reales.

Les muestro el código hecho hasta ahora:

CÓDIGO:

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define NOM_FITXER "notes.txt"
#define CLASES 12
#define ALUMNES 26
 
int main()
{
    FILE *f;
    /* int classes[CLASES];*/
    int i, j,k, total_classes=0;
    float taula[CLASES][ALUMNES], aux=0;
 
    f=fopen(NOM_FITXER, "r");
 
    if (f!=NULL)
    {
        printf("El fitxer s'ha obert correctament.\n");
        fscanf(f,"%d",&total_classes);
        printf("%d\n",total_classes);
        if (total_classes==EOF)
        {
            printf("Seq buida");
        }
        else
        {
            while (!feof(f))
            {
                for (i=0; i<12; i++)
                {
                    for (j=0; j<26; j++)
                        fscanf(f,"%f ", &taula[i][j]);
                }
            }
        }
    }
    for (i=0; i<CLASES; i++)
    {
        for (j=i+1; j<CLASES; j++)
        {
            for (k=0; k<ALUMNES; k++)
            {
                if (taula[i][0]>taula[j][0])
                {
                    aux = taula[i][k];
                    taula[i][k]=taula[j][k];
                    taula[j][k]=aux;
                }
            }
 
        }
    }
 
 
 
    for (i=0; i<12; i++)
    {
        printf("%d ",(int)taula[i][0]);
        for (j=1; j<26; j++)
            printf("%.2f ",taula[i][j]);
        printf("\n");
    }
    return 0;
}
 

Aclarar que debo intercambiar filas enteras mirando solamente la primera columna.

Ahora me ordena bien la primera columna, pero me sigue dejando  el resto de filas tal y como estan en el .txt, es decir, me intercambia solamente la primera columna, y quiero que intercambie la fila entera.

Pongo un ejemplo de mi .txt:

12
1 6.63 0.71 4.70 4.51 1.55 .....
3 2.34 7.60 1.17 3.03 3.83 .....
10 6.88 0.21 7.80 3.30 8.65 .....
2 9.27 2.01 4.76 0.18 0.69 .....
4 9.31 3.16 1.96 6.35 0.27 .....
12 1.09 3.51 2.03 2.85 1.33 .....
5 3.42 4.63 1.80 8.73 5.84 .....
8 5.15 1.50 9.06 2.29 5.15.....
9 4.73 0.77 2.06 4.73 4.78 .....
6 9.57 7.61 3.20 5.61 6.03 .....
7 3.62 5.56 8.85 6.03 3.50.....

Me devuelve esto:

12
1 6.63 0.71 4.70 4.51 1.55 .....
2 2.34 7.60 1.17 3.03 3.83 .....
3 6.88 0.21 7.80 3.30 8.65 .....
4 9.27 2.01 4.76 0.18 0.69 .....
5 9.31 3.16 1.96 6.35 0.27 .....
6 1.09 3.51 2.03 2.85 1.33 .....
7 3.42 4.63 1.80 8.73 5.84 .....
8 5.15 1.50 9.06 2.29 5.15.....
9 4.73 0.77 2.06 4.73 4.78 .....
10 9.57 7.61 3.20 5.61 6.03 .....
11 3.62 5.56 8.85 6.03 3.50.....
12 3.73 2.96 2.79 4.39 3.03....


Gracias por todos a los que intenten colaborar con esto.

He conseguido, tras multiples peleas con mi ordenador, solucionar mi ejercicio por completo. Una vez ordenado el fichero me calcula la mediana, la desviación tipica y lo escribo en un fichero resultados.txt donde en la segunda columna incluyo las desviaciones.

Si alguien está interesado en que cuelgue o le envie el código que tan solo responda en este post.

Tema concluido.