Mensajes

Hubo un mal entendido entonces.

La cosa es que en este foro nos cuidamos mucho de hacer tareas. Sí, resolvemos dudas y orientamos haciendo snippets o modificando el código de la gente que plantea sus dudas. Pero también hay quien viene pidiendo que se haga una tarea sin mostrar avance alguno o con un código que no muestra que ha intentado atacar el problema. Alguna vez se han lanzado estos retos para divertimento, aunque normalmente desde cuentas que ya llevan un buen tiempo aquí y se sabe que no piden solución a una tarea y se puede confiar que es eso, un juego.

Habría sido mejor acogido el mensaje inicial habiendo explicado lo de que es un ejercicio para tus alumnos, con un enunciado lo más claro posible, tal vez como el que expusiste a tus alumnos y tal vez dando tu solución (si no quieres directamente aquí) mediante un enlace externo como pastebin matando dos pájaros de un tiro (tal vez sería una buena opción si quieres realmente ver códigos de gente de por aquí):

1. Que los moderadores sepan que realmente se trata de un juego.
2. El que quiera participar no verá la solución hasta haber completado la suya.

Espero que no te hayas desanimado y verte más por aquí.

Entiendo que

extrayendo los números que son iguales e insertándolos en una pila

quiere decir que a la pila van los números repetidos.

Usa etiquetas GeSHi para insertar el código. Están en la barra de herramientas, en un desplegable, cuando estás escribiendo un post o una respuesta. (Para moderadores y webmaster: Sería mejor cambiar el texto Código GeSHi por algo más intuitivo como 'Elige lenguaje...' o 'Color syntax...'.

AXA, ¿qué estás usando para aprender C?

Veo main sin tipo o main con tipo void... Normalmente un libro o tutorial (de C moderno, no el pre-ansi) te dice que main es de tipo int y hay que marcarlo explícitamente.

También debes tener en cuenta la precedencia de operadores:

Código [Seleccionar] Expandir

*i2.i1=i3;
estás dereferenciando i1, no i2.
Una pequeña prueba de ello:

Código (c) [Seleccionar] Expandir

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

struct st {
int *miembro;
};

int main() {
struct st mi_estructura;
mi_estructura.miembro = malloc(sizeof(int));
*mi_estructura.miembro = 20;

printf("%d\n", *mi_estructura.miembro);

free(mi_estructura.miembro);
}
Por tanto debería ser así:

Código [Seleccionar] Expandir

(*i2).i1=i3;
Aunque en C tienes el operador flecha que te limpia el código:

Código [Seleccionar] Expandir

i2->i1=i3;

Por tanto el código último que has puesto, solucionados estos pequeños fallos y poniendo nombres representativos en los identificadores, quedaría algo así:

Código (c) [Seleccionar] Expandir

#include <stdio.h>

struct st {
int miembro;
};

void inicializa_a_20(struct st *una_estructura) {
una_estructura->miembro = 20;
// alternativa:
// (*una_estructura).miembro = 20;
}

int main() {
struct st mi_estructura;
inicializa_a_20(&mi_estructura);
printf("%d\n", mi_estructura.miembro);
}

El problema con esa función es que si el buffer ya está vacío getchar tomará el control de la consola obligando a que el buffer se llene otra vez. Es decir: esa función sólo hace el trabajo esperado si en el buffer quedó algo.

Bueno, ahí va un hack que me ha funcionado siempre:

Código [Seleccionar] Expandir

fseek(stdin, 0, SEEK_END);

Realmente podrías haber resuelto esta función cómo si estuvieras en Java, no hay mucha diferencia. Pero debo decir que sí, tu algoritmo para es_primo es erróneo.

Una solución sería esta:

Código (c) [Seleccionar] Expandir

int es_primo ( int p ) {
   int divisor;

   /* Casos base */
   /* Falta por decidir qué se hace con los números menores de 1 */
   if( p == 1 )    return 0;     /* El 1 no se considera primo. */
   if( p == 2 )    return 1;     /* El 2 se considera primo.    */
   if( p & 1 == 0) return 0;  /* Ningún par, a excepción del 2 (controlado anteriormente) es primo. */

   for(divisor = 3; divisor * divisor <= p; divisor += 2) { /* Se usará el divisor a partir del tres, con incremento de 2 (así se evita operar con pares) */
      if ( p % divisor == 0)                                /* hasta que el producto del divisor supere al número p (así nos evitamos la raíz cuadrada).  */
         return 0;                                          /* Si la división da un residuo 0 quiere decir que ese número no es primo. Se regresa con 0.  */
   }
   return 1;                                                /* Si el algoritmo llega hasta aquí significa que el número es primo.                         */
}

Como ya viste C supongo que estás familiarizada con C entiendo que el operador de bit & te suena.

Aún así. No sabes cómo guardó el ordenador la estructura. Es un archivo binario así que no sabes dónde empiezan y terminan los campos. La solución es grabarlos uno mismo en el orden y leerlos el en mismo orden.

Código [Seleccionar] Expandir

return 0;short resp;
Después de ese return no se ejecuta nada. ¿Lo sabías?

Te encontraste con un problema se serialización, o cómo se guardan internamente los datos y cómo se deben guardar cuando salen fuera.

La cosa es que por motivos de eficiencia un ordenador decide de qué forma guarda los datos de una estructura, que puede ser diferente a cómo se creó en código. Cuando le das a guardar esa estructura en un archivo directamente, lo que hace es copiar esa representación interna. Así que cuando lo vas a leer tiempo después o en otro ordenador la estructura interna de al estructura puede cambiar y el ordenador tratará de leerla como tiene en su modelo interno. Obviamente los datos no van a coincidir.

¿Qué debes hacer? Se debe guardar uno a uno los campos de la estructura y si uno de esos campos también es una estructura se tiene que desgranar igual. Para recuperar los campos se deben leer uno a uno en el mismo orden en que fueron grabado y colocados en la estructura; no leer la estructura directamente del archivo.

Realmente un arreglo te facilitará mucho las cosas. Después de hacer la media deberás mirar otra vez todos los datos introducidos para ver cuál es menor. Con un arreglo sólo deberás usar un bucle, de la otra forma tendrás que repetir código por cada variable.