Mensajes

Mi aportacion:

limite = 5 * 20; // 5 = múltiplo, 20 = número de repeticiones
for (i=0; i < limite; i+=5)
.... printf("%d\n", i); // en C++: std:cout << i << std:endl;


NOTA: Cuantas menos operaciones hagas (multiplicaciones en tu caso) mas rápido y eficiente será el programa.

NOTA 2: Ya verás tu si el bucle empieza en 0 o en 1, y si la condición de parada es "i < limite" o "i <= limite"

Pues igual que anades enfermos
Imagina algo tal que:

Código (c) [Seleccionar] Expandir


struct T_enfermedad
{
 char nombre[32]
 struct T_enfermedad *sig;
}

struct T_enfermo
{
  char nombre[32];
  int edad;
  //-- resto de campos
  struct T_enfermedad *enfermedades;
  struct T_enfermo *sig;
}

int Nuevo_Enfermo( T_enfermo *Lista)
{
    struct T_enfermo *p;
    p = (struct T_enfermo *) malloc (sizeof(struct T_enfermo));
    if (!p) return -1; // no se pudo reservar memoria
    p->enfermedades = NULL; //no tiene enfermedades
    p->sig = NULL;
   // lees la informacion del paciente y la guardas en p

   //-- ¿quieres añadir alguna enfermedad ? Si la respuesta es sí
   Nueva_Enfermedad(p->enfermedades);
   //---

   // añadir por el principio de la lista
   if (Lista != NULL)
     p->sig = Lista;
   Lista = p;        
}

int Nueva_enfermedad(T_enfermedad *lista)
{
 struct  T_enfermedad *p;
  p = (struct T_enfermedad *) malloc (sizeof(struct T_enfermedad));
  p->sig =NULL;
  //-- pedir informacion y ponerla en p

   if (lista != NULL)
     p->sig = lista;
   lista = p;  
}


int main()
{
 struct  T_enfermo *Lista = NULL;

  // -- tu codigo
 // -- opciones
  switch {
     case 1:
        Nuevo_Enfermo(Lista);
        break;


  };

}


obviamente es un codigo de referencia, va a contener algun error.
Si quieres añadile mas enfermedades lo unico que tienes que hacer es localizar al enfermo recorriendo la lista y luego le pasas el puntero 'enfermedades'.

Un saludo!

PD:Cambia el nombre de las funciones porque esta noche no estoy muy original

Si quieres hacer algo aceptable tienes que saber programar medianamente bien. En internet hay cientos de ejemplos de como crear botones en c++ y hasta frameworks como Qt que lo puedes disenar tu interfaz a golpe de raton. para reproducir el sonido tambien tienes mucha informacion y librerias como sdl que te lo hacen. ¿qué es lo "complicado"? entender lo que estás haciendo para que puedas terminar tu proyecto, pero para eso tienes que saber programar algo

El tema de repruducir aleatoriamente hay muchas maneras de hacerlo. una de ellas que me parece de las mas faciles es que abras el directorio de los sonidos listes todo el contenido menos el directorio actual ( . ) y el anterior ( .. ) los carges en un vector y al final generes un numero aleatorio entre 0 y el total de sonidos ( numero = rand() % total_sonidos; ) luego solo pasarias a la funcion de reproduccion el archivo 'directorio/sonido[numero'. Para facilitar la tarea los archivos pueden llamarse igual que tus palabras asi que si quieres anadir una palabra solo tienes que añadir el archivo sonoro.

Ejemplo de lo que habria en el directorio:
.
..
Hola.wav
Hombre.wav
Telefono.wav

Las palabras que estarian añadidas serian hola, hombre, telefono

Para trabajar con directorios mirate el winapi, y funciones como opendir y demás


Otra opción es que lo hagas en html / javascript y un minimo de php. El diseño en html, la repruccion del sonido con html y ayudandote con javascript.

Código (javascript) [Seleccionar] Expandir


    function reproducior_sonido(){
    document.getElementById('sonido').innerHTML='<embed src="archivo.mp3" autostart="true" />'
    }


Código (html4strict) [Seleccionar] Expandir


    <div id="sonido"></div>
    <button onclick="reproducir_sonido()"/>

obviamente donde pone archivo.mp3 seria uno aleatorio que obtendrias con php de "la misma forma" que harías con C.

Suerte!!

PD: Si no tienes interes aprender a programar dificilmente podras hacer algo

[salir = true;]

Por aquello de simplificar el trabajo yo guardaria todo en una sola linea

Código (cpp) [Seleccionar] Expandir


archivo << people[reg].Naame << ":"  people[reg].age <<  endl;


Si vas a leer el el archivo desde tu aplicacion creo que puedes prescindir de poner 'name', 'age' y otra información. Simplemente conoces el formato en el que se guarda la informacion y en tu aplicacion ya le pones la etiqueta/ nota que consideres.

Para lo que pides simplemente abres el archivo en modo lectura, lo recorres y ayudandote de getline lees la linea entera te quedas con la primera parte (lo que queda antes del ' :' <dos puntos> ) y lo comparas con lo que busques, si es inguar lo muestras y en otro caso sigues recorriendo hasta final de fichero.

Otra opción es que guardes la la estructura (modo binario)  y no los campos de la misma en modo texto. Para eso usas el método write. Obviamente luego recorres el fichero en modo lectura y leyendo con el médodo read. La comparacion es trivial.

Otras observaciones. Yo que tú evitaría tanta llamada recursiva a main siemplemente modifica el switch en el caso 3 y pones algo como: salir = true; y en codigo del main (debajo del Data people[LEN];  //struct ) pones unbool salir = false; do { // todo tu codigo hasta antes del return } while(salir == false);.
En la funcion Addd tambien quitaria las llamadas a main solo tienes que modificar el do-while te quedaria algo como:

Código (cpp) [Seleccionar] Expandir


}while ((sn!="N")||(sn!="n"));


Un saludo

No creo que nadie te haga el ejercicio, de todas maneras vas bien.
Una lista para enfermos y dentro de ese 'nodo/ficha' (o como lo quieras llamar) tienes otro puntero con las enfermedades. El movimiento de punteros es el mismo, lo unico que cambia es la informacion que contiene.

debe de ser cosa del cansancio pero no entiendo exactamente lo que tiene que hacer el programa.
¡podrias poner dos ejemplos?

Hola,
No creo que nadie te vaya a hacer esos ejercicios. Si te han puesto esa tarea se entiende que te han explicado los conceptos basicos para hacerlos. Eres tu quien debe de ponerse a pensar durante horas como resolverlo, así es la programación y más en los inicios.

Aun asi creo que te puedo dar una serie de pasos orientativos.

A)
- Declaras un array bidimensional para hacerlo dinamicamente puedes mirar en internet pero el concepto básico es:

Código (cpp) [Seleccionar] Expandir


arreglo =(char **) malloc (numero_de_palabras*sizeof(char *));
contador_palabras = 0;
while (contador_palabra < numero_de_palabras){
   arreglo[contador_palabras] = (char *) malloc (13 * sizeof(char));
}
/** NOTA: Si las palabras son de 12 caracteres hay que sumarle uno por el fin de cadena (\x0) **/
/** NOTA 2: Como para leer el nombre tienes que declarar una variable, podrias calcular el tamaño dependiendo del largo de cada palabra. Es decir leer la palabra y en el malloc que esta dentro del bucle sustituyes el 13 por un strlen(variable) + 1

- La insercion de las palabras la puedes hacer directamente al reservar la memoria y solo es usar la funcion strcpy
a) No entiendo bien lo que te piden con eso del primero de acuerdo a un orden alfabetico, pero en todo caso seria recorrer el vector e ir comparando y cuando lo encuentre lo muestras y fin. Te recomiendo que uses un bucle tipo while con alguna bandera para detectar si hay que continuar. El esquema es algo asi:

Código (cpp) [Seleccionar] Expandir


i = 0;
encontrado = 0;
while ( i < numero_de_palabras && !encontrado)
{
    if (/** comparacion que sea **/)
    {
         /** codigo que sea **/
        encontrado = 1;
    }
}


b) Un recorrido con saltos pares:

Código (cpp) [Seleccionar] Expandir


for (i = 0; i < numero_de_palabras; i+=2)
{
    /** mostrar el elemento i **/
}

c) Es una variente del caso a, piensa un poco. strncmp te ayudará


B) En este caso puedes optar por hacer un array de estructuras (me parece lo mas sencillo) o bien por un array bidimensional. Como supongo que es lo que te piden lo plantearé como un array bidimensional.
- La reserva de memoria es identido al caso A, la diferencia es que la variable con la que leias palabras tiene que ser más larga. (No te olvides del strlen)
- Lees nombre y apellido con la funcion gets o con scanf, tal que scanf("%[^\n]", variable); para que puedas leer los espacios en blanco
- una vez cargados los nombres y apellidos:
-- la posicion 0 es la primeria inicial del nombre
-- la siguiente posicion al espacio en blanco es la primera letra del apellido. Puedes calcular esa posicion recorriendo el vector y cuendo lo encuentres vas mostrando los caracteres encontrados (es una manera simple de hacerlo, aunque no la más alegante)
-- finalmente muestras @gmail.com

Estructura ""pseudocodigo"":

Código (cpp) [Seleccionar] Expandir


para todas las palabras hacer
   mostrar arreglo[i][0];
   j =  buscar_espacio_en_blanco(arreglo[i])
   mientras no final de cadena
      mostrar(arreglo[i][j+1])
      incremeto j
   fin_mientras
   mostrar "@gmail.com"
   mostrar_salto_de_linea
  incremento i
fin_para


Los trozos de codigo estan pensados en C, si quieres hacerlo en C++ tienes que investigar el new, en vez del malloc, utilizar los metodos de la clase string en vez de los str[...], en fin ... solo es una orientacion, de ti depende hacerlo.

Suerte!

Tal como entiendo el problema tendrías un vector con palabras y otro vector del mismo tamaño que tendría un valor numerico y tendrías que ordenar el vector de palabras en funcion del vector numerico
¿Me equivoco?

La idea sería hacer un método de ordenación, por ejemplo la burbuja aunque no es el más eficiente. y cuando hagas el intercambio de valores numericos tmb realices el intercambio de las cadenas.

El código de intercambio sería algo tal que:

Código (c) [Seleccionar] Expandir



      if (ocurrencia[d] > ocurrencia[d+1])
      {
       /** Ordenamos el vector de ocurrencias **/
        swap       = ocurrencia[d];
        array[d]   = ocurrencia[d+1];
        ocurrencia[d+1] = swap;
       /** Ordenamos el vector de cadenas **/
       strcpy(aux, cadenas[d]);
       strcpy(cadenas[d], cadenas[d + 1];
       strcpy(cadena[d + 1], aux);
      /** **/
      }
 
Darse cuenta que 'swap' es una variable auxiliar dell tipo numérico (int swap;). Y 'aux' es la variable auxiliar para guardar la palabra (char aux[SZ].

Espero haber podido ayudar.

Suerte!

A grosso modo:
1- Abres el fichero con fopen
2- recorres el fichero con un fgets la cual leerá hasta final de linea
3- el fgets lo pones en un bucle hasta que sea final de fichero. algo tal que: while(fgets(cadena, 81, fichero))
4- dentro de ese buche te quedas con cadena que sera un vector de 81 caracteres, por ejemplo.
4.1 coges los primeros 20 caracteres que serla el nombre y lo guardas en un vector, por simplificar el problema
4.2- sigues recorriendo el vector y los otros caracteres los guardas en otro vector y lo transformas a numero con la funcion atof
5- Compruebas q el valor de atof sea menor de 0, eso significa que debe dinero. En ese caso abres otro archivo en modo escritura y guardas esa informacion. Por simplificar utiliza la funcion fprintf
6 cierras el fichero

Nota: si abres el fichero deudores al principio tienes que cerrarlo al final, si lo abres dentro del buble tienes que cerrarlo al final del bloque si está abierto

Suerte

Antes de decir nada quisiera comentar tres cosas:
a) Que no he dedicado más que 45segundos para ver el codigo, por tanto puedo estar metiendo la pata
b) Que la duda ya estará resuelta
c) Quizás ayude a otra persona que se encuentre en una situacion similar.


Para tener 'm' buzones dado tu código no seria más que poner

Código (c) [Seleccionar] Expandir


struct pila *buzon[m];


Donde m puede ser una constante (C++), una variable (se trata de C++, en C no es válido), una macro (C++/C) o simplemente un número.

Por ejemplo:

Código (cpp) [Seleccionar] Expandir


push(&p,destino);
cout<<"Carta para esta casa"<<endl;
/*se supone que cada buzon es una pila tambien, falta implementar eso*/


Cambiaría a algo parecido a:

Código (cpp) [Seleccionar] Expandir


push(&buzon[i],1);
cout<<"Carta para esta casa"<<endl;


Notar que buzon es el buzon de la casa i. El valor 1 es por poner algo en la pila. En este caso representa una carta y como no hay datos del remitente ....

El codigo se simplificaria bastante si se plantea el problema como que el cartero tiene las cartas agrupadas por viviendas antes de salir de la oficina, de esta manera solo se tendría un array de pilas de tal modo que el cartero cogeria el monton de cartas de la vivienda i sin necesidad de revisar el resto. esto basicamente permitiría que el bucle de llenado de datos quedara tal que

Código (cpp) [Seleccionar] Expandir


for(int a=0;a<cant_cartas;a++){ /*llena la pila con los destinos correspondientes*/
cin>>destino;
push(&p[destino], 1 );
}

Y el bucle de entrega de cartas en:

Código (cpp) [Seleccionar] Expandir


for (int i=0;i<cant_casas;i++){ /*itera la cantidad de casas*/
   cont=0;
   cout<<"El cartero ha llegado a la casa "<<i<<endl;
   cout<<"Revisando cartas"<<endl;
   int total = 0;
   while(pop(&p[i]))
   {
      cout << "carta entregada a la vivienda " << i << endl;
      total++;
   }
   cout << total << " cartas entregadas en esta casa" << endl;
}


Suerte!