Mensajes

[the program is ill-formed]

Al colocar los paréntesis lo que haces es llamar al constructor por defecto. Es decir que si hay constructor predeterminado o definido por el usuario, vamos a poder inicializar la variable a la hora de declararla.

If T is a const-qualified type, or a (possibly cv-qualified) POD class type (or array thereof) containing (directly or indirectly) a member of const-qualified type, the program is ill-formed.

Tu firma me la recordaba cada clase mi profesor de prácticas de Sistemas Operativos xDD

En general el código está bien. Las funciones no sobrepasan un Xterm (23 líneas).

¿Qué cosas modificaría? Pues generalizar ese problema para mostrar los factoriales de 0 a N con una constante:

Código (c) [Seleccionar] Expandir

/* Se despliegan los factoriales de los numeros del 0 al N, se utiliza la recursividad para calcularlos */
#include <stdio.h>

#define N 15

/* Prototipo de funcion */
long calculaFactorial( long numero );
void muestraLlamadasRecursivas( long numero );

/* Inicia la ejecucion del programa */
int main()
{

int i; /* Contador */

printf( "\n\n***Este programa imprime los factoriales de los numeros del 0 al %d\n", N );
printf( "y sus llamadas recursivas a la funcion que calcula los mismos.\n" );
printf( "Este programa se crea con la finalidad de hacer que sea mas facil\n" );
printf( "entender el tema de recursividad***\n\n" );

/* Repite N+1 veces; durante cada iteracion calcula el factorial de i y lo despliega en pantalla */
for ( i = 0; i <= N; i++ )
{
printf( "%d! = %ld\n", i, calculaFactorial( i ) ); /* Imprimimos el valor del factorial */
muestraLlamadasRecursivas( i ); /* Llamamos a la funcion que imprime las llamadas a funcion */
}

return 0; /* Terminacion exitosa */

} /* Fin de main */

/* Definicion recursiva de la funcion factorial */
long calculaFactorial( long numero )
{
/* Caso base */
if ( numero <= 1 ) {
return 1;
} /* Fin de if */
else { /* Paso recursivo o llamada recursiva */
return ( numero * calculaFactorial( numero - 1 ) );
} /* Fin de else */
} /* Fin de la funcion factorial */

void muestraLlamadasRecursivas( long numero )
{
static int contadorEspacios = 1; /* es static para que el valor no se destruya entre las llamadas recursivas a funcion */
int contador = contadorEspacios; /* Variable que determinara el numero de espacios a imprimir */

for ( contador; contador >= 1; contador-- ) { /* Imprimimos los espacios correspondientes */
printf( " " );
} /* Fin de for */

if ( numero <= 1 ) {
printf( "1\n" );
printf( "-------------------\n" );
}
else {
printf( "%ld * factorial( %ld - 1 )\n", numero, numero ); /* Imprimimos la llamada recursiva */
contadorEspacios++; /* Agregamos 1 a la variable de espacios */
muestraLlamadasRecursivas( numero - 1 ); /* Llamamos recursivamente a la funcion */
}

contadorEspacios = 1; /* Reestablecemos la variable a 1 para que no se vallan a imprimir los espacios ya calculados en el factorial anterior*/
} /* Fin de funcion muestraLlamadasRecursivas */



En este caso no es recomendable usar recursividad porque derrochamos demasiada memoria con cada cambio de contexto, aunque está bien de forma didáctica (para comprender la recursividad y porque generalmente el código es mucho más inteligible).

Y si preguntas por reestructurar... dividiría el main en dos funciones: 1 para el título y otra para el proceso principal, aunque no es imprescindible.

Por último, tus comentarios están bien pero son excesivos. Para alguien al que le vas a explicar algo nuevo están bien pero pero hay que mantenerlos escuetos y tratar de no poner comentarios innecesarios.

En conclusión, es un código interesante para comprender como funciona la recursividad pero inviable en un código optimizado.

¡Enhorabuena!

[pero la longitud no indica el orden de s1 respecto de s2]

Depende en qué manera desees comparar dos strings. En C existe la función strcmp(const char [], const char []) (de la librería string.h) que hace una comparación ASCII.

Según el criterio de comparación ASCII strcmp(s1,s2) devuelve:

salida = 0, si y sólo si, todos los caracteres de s1 son idénticos a los caracteres de s2. (Implícitamente se ve que la longitud de s1 es igual a la longitud de s2, pero la longitud no indica el orden de s1 respecto de s2).
salida > 0, si y sólo si, recorriendo los caracteres de s1 y s2 simultáneamente (de 0 a n-1) nos encontramos que s1_i > s2_i (comparando el nº ASCII) siempre y cuando no se cumpla que para cualquier s1_j < s2_j (j<i).
salida < 0, en otro caso. (si s1 es menor que s2)

Resumiendo: strcmp devuelve ->
0 si s1 = s2
1 si s1 > s2
-1 si s1 < s2

Piensa en cómo quieres comparar esos dos char arrays y luego diseña una función que lo haga.

Me respondo a mí mismo por si a alguien más le ayuda.

Al construir el DatagramSocket del servidor debí haber especificado el puerto (que se pasa como primer y único argumento al servidor) en el constructor.

No he leído el código en absoluto, simplemente he corregido un error de sintaxis que tú mismo sabías y deberías haber corregido

Procura identar el código y seguir un estilo al programar. La tarea de programar no trata sólo de escribir líneas de código.

¡Saludos! y si no te funciona trata de averiguar por qué y, lo más importante, trata de solventarlo por ti mismo

Código (java) [Seleccionar] Expandir

package juegomoneda;

import java.util.Random;
import java.util.Scanner;

public class LanzarMoneda {

    private int cara;
    private int cruz;
    Scanner t = new Scanner(System.in);

    public void jugar()
    {
        // creamos la variable que represente la primera decision(opc)
        String opc;

        bienvenida(); // llamamos al metodo bienvenida para que de la bienvenida al usuario

        // pedimos que se elija una opcion
        System.out.println("Eliga una opcion");
        System.out.println("Escriba 'L' para lanzar la moneda o");
        System.out.println("Escriba 'S' para salir");
        opc = t.nextLine();

        // si la opcion elegida es 'Salir' imprimimos un mensaje de salida
        if("S".equals(opc))
        {
            System.out.println("Ha decido salir");
            System.out.println("No se inicio el juego");

            // si la opcion elegida es 'Lanzar' tiramos la moneda
            if("L".equals(opc))
            {
                // llamamos al metodo tirar que devuelve true si cae cara o false si cae cruz
                // almacenamos el resultado en la variable boolean resultado, si el valor devuelto
                // es true, aumentamos cara en 1, y si es false aumentamos cruz en 1

                boolean resultado = tirar();
                if(resultado == true)
                cara++;
                else
                cruz++;

            }
            segundoTiro();
        }
    }

    // metodo que da la bienvenida al juego

    public void bienvenida()
    {
        System.out.println("Bienvenido al juego 'Lanza la moneda'");
    }

    // metodo tirar, tira una moneda, si cae cara devuelve true, si cae cruz devuelve false

    public boolean tirar()
    {
        Random generadorAleatorio = new Random();
        int moneda = 1 + generadorAleatorio.nextInt(2);

        if(moneda == 1)
        return true;
        else
        return false;
    }

    public void segundoTiro()
    {
        String opc2;
        boolean resultado;

        do {
        // y preguntamos al usuario si quiere lanzarla nuevamente

        System.out.println("Desea Lanzar la moneda otra vez");
        System.out.println("'Y' para si y 'N' para no");
        opc2 = t.nextLine();

        if("Y".equals(opc2))
        {
            // Hacemos lo mismo, llamar al metodo tirar y aumentar si es cara o cruz
            resultado = tirar();
            if(resultado == true)
            cara++;
        }
        else
        {
            cruz++;
        }
        } while("Y".equals(opc2)); // Se repite el lanzamiento mientras la opcion elegida sea //'Si, Lanzar'

        // Si despues del 1er tiro el usuario no quiere seguir jugando, imprimimos un //mensaje de salida
        // e imprimimos los resultados del juego

        if("N".equals(opc2))
        {
            System.out.println("Ha decido salir");
            System.out.println("Usted saco "+cara+ "caras y "+cruz+" cruces");
        }
    } // Esta llave debería indicar el fin del método segundoTiro
} // Y esta el fin de la clase

Bueno, he codificado un cliente-servidor UDP pero mi servidor no logra recibir el paquete datagrama enviado por el cliente ._.

¿Alguna ayudita?

ClienteUDP,java

Código (java) [Seleccionar] Expandir

package proyecto.socketudp;
import java.net.*;
/** Ejemplo que implementa un cliente de eco usando UDP. */
public class ClienteUDP {
public static void main(String argv[]) {
if (argv.length != 3) {
System.err.println("Formato: ClienteUDP <maquina> <puerto> <mensaje>");
System.exit(-1);
}
DatagramSocket sDatagram = null;
try {
// Creamos el socket no orientado a conexión
// (en cualquier puerto libre)
sDatagram = new DatagramSocket();
// Establecemos un timeout de 30 segs
sDatagram.setSoTimeout(30000);
// Obtenemos la dirección IP del servidor
// (recibida en el primer argumento por linea de comandos)
InetAddress dirServidor = InetAddress.getByName(argv[0]);
// Obtenemos el puerto del servidor
// (recibido en el segundo argumento por linea de comandos)
int puertoServidor = Integer.parseInt(argv[1]);
// Obtenemos el mensaje
// (tercer argumento de la linea de comandos)
String mensaje = argv[2];

byte[] envInfo = new byte[1024];
      envInfo = mensaje.getBytes();
// Preparamos el datagrama que vamos a enviar y lo enviamos
DatagramPacket envPaquete = new DatagramPacket(
envInfo, envInfo.length,
dirServidor, puertoServidor
);
// Enviamos el datagrama
sDatagram.send(envPaquete);
System.out.println(
"CLIENTE: Enviando "
+ new String(envPaquete.getData()) + " a "
+ envPaquete.getAddress().toString() + ":"
+ envPaquete.getPort()
);

// Preparamos el datagrama de recepción
byte[] recInfo = new byte[1024];
DatagramPacket recPaquete = new DatagramPacket(recInfo, recInfo.length);
// Recibimos el mensaje
sDatagram.receive(recPaquete);
System.out.println(
"CLIENTE: Recibido "
+ new String(recPaquete.getData(), 0, recPaquete.getLength())
+ " de " + recPaquete.getAddress().toString() + ":"
+ recPaquete.getPort()
);
} catch (SocketTimeoutException e) {
System.err.println("30 segs sin recibir nada");
} catch (Exception e) {
System.err.println("Error: " + e.getMessage());
} finally {
// Cerramos el socket para liberar la conexión
sDatagram.close();
}
}
}

ServidorUDP.java

Código (java) [Seleccionar] Expandir

package proyecto.socketudp;

import java.net.*;
/** Ejemplo que implementa un servidor de eco usando UDP. */
public class ServidorUDP {
   public static void main(String argv[]) throws SocketException {
       if (argv.length != 1) {
           System.err.println("Formato: ServidorUDP <puerto>");
           System.exit(-1);
       }
       try {
           // Creamos el socket datagrama
           DatagramSocket sDatagram = new DatagramSocket(Integer.parseInt(arv[0]));
           // Establecemos un timeout de 30 segs
           sDatagram.setSoTimeout(30000);
           byte array[] = new byte[1024];
           DatagramPacket dgramRec, dgramEnv = null;
           while (true) {
               // Preparamos un datagrama para recepción
               dgramRec = new DatagramPacket(array, array.length);

               // Recibimos el mensaje
               sDatagram.receive(dgramRec);

               // Recabamos informacion
               String mensaje = new String(dgramRec.getData());
               InetAddress dirCliente = dgramRec.getAddress();
               int puertoCliente = dgramRec.getPort();

               System.out.println(
                   "SERVIDOR: Recibido "
                   + new String(dgramRec.getData(), 0, dgramRec.getLength())
                   + " de " + dirCliente.toString() + ":"
                   + puertoCliente
               );

               // Preparamos el datagrama que vamos a enviar
               dgramEnv = new DatagramPacket(
                   mensaje.getBytes(), mensaje.getBytes().length,
                   dirCliente, puertoCliente
               );

               // Enviamos el mensaje
               sDatagram.send(dgramEnv);
               System.out.println(
                   "SERVIDOR: Enviando"
                   + new String(dgramEnv.getData(), 0, dgramEnv.getLength())
                   + " de " + dgramEnv.getAddress().toString() + ":"
                   + dgramEnv.getPort()
               );
           }
       } catch (SocketTimeoutException e) {
           System.err.println("30 segs sin recibir nada");
       } catch (Exception e) {
           System.err.println("Error: " + e.getMessage());
       }
   }
}

char ** linea: equivalente a un array de strings pero de forma dinámica

Lo único que tienes que hacer es alocar memoria mientres necesites hacerlo o, por el contrario, eliminarla cuando no la necesites.

El coste espacial es mayor / elemento almacenado que de manera estática pero te evitas estimar un tamaño, aunque sabiendo que es de un GB y sabiendo el tamaño de línea...

Haz pruebas con algún archivo pequeñito y según los resultados que obtengas aplícalo al de 1GB.

jack09, perdón por no leer el código pero estoy vago xD. Por otra parte la función buscar es una locura.

Ten en cuenta la siguiente frase: "Si algo es difícil es que está mal". Aunque parezca una tontería a mí me ayuda bastante xD.

Lo necesario para este ejercicio es conocer las coordenadas de 2 y 3. Luego podemos tener:

Código (c) [Seleccionar] Expandir


typedef struct {
x,y:unsigned int; // matriz
} Punto;


Y tener p2 y p3 de tipo Punto. Buscar significa recorrer la matriz y si encontramos a 2, guardar las coordenadas en p2 y, por el contrario, si encontramos a 3, guardamos las coordenadas en p3:

// No es necesario pasar el tamaño de la segunda dimensión porque se infiere por el tipo int y la longitud de la dimensión 1.

Código (c) [Seleccionar] Expandir


void buscar (int m[3][], Punto *p2, *p3) {

int i,j;

for (i = 0; i < 3; i++)
for (j = 0; j < 3; j++)
if (m[i][j] == 2) {
p2->x = i;
p2->y = j;
} else if (m[i][j] == 3) {
p3->x = i;
p3->y = j;
}
}


Luego, para llegar de 3 a 2 simplemente hay que desplazar p3 hasta p2 teniendo en cuenta las filas y las columnas y que nos acercamos a p2 hasta encontrarnos con él. La primera componente de la matriz identifica a las filas de las mismas y la segunda a las columnas.

No he leído el código de leosansan pero creo que está bien.

¡Suerte!

Código (c) [Seleccionar] Expandir

int m[3][3] = {0, 2, 0, 0, 0, 0, 0, 0, 3};

Eso es una matriz unidimensional (aunque los arrays n-dimensionales se almacenen por filas) y no entiendo bien tu pregunta...

Simplemente sigue la aritmética de punteros como haces con los arrays unidimensionales.

Y en tu ejemplo recorres la matriz y cuando encuentras esos valores, asignas sus direcciones a los punteros.

Para recorrer una matriz bidimensional con un puntero...

Código (c) [Seleccionar] Expandir

int main () {
int m[3][3] = { {0, 2, 0},
                        {0, 0, 0},
                        {0, 0, 3}};
int *p;
int i, j;

for(i=0; i<3; i++) {
    p = m[i];
for(j=0; j<3; j++){
printf("%d", p[j]);
}
printf("\n");
}

return 0;

}