Hola gente como va?

Bueno estoy aca luchando con un programa de listas en el que no puedo resolver una parte del enunciado. Lo que no puedo resolver es la parte b) de tal. El enunciado es el siguiente:

Se desea implementar una aplicacion que permita almacenar las mediciones de valores de
resistencias para compararlos con los valores nominales (1, 10, 100, 1000, etc Ohm) que se esperaba
de cada una de ellas. El programa debera ser capaz de almacenar un numero desconocido de mediciones con
los siguientes datos de las resistencias:

* Codigo del Componente (un digito alfanumerico de 5 caracteres).
* Valor nominal de la resistencia.
* Valor medido.

Se pide:

a) Cargar todos los datos medidos en una LSE tipo COLA hasta que el valor del codigo de componente sea
"fin".
b) Una vez finalizada la carga se debera listar en pantalla todas las resistencias cuyo valor medido
difiera de su valor nominal por mas de un porcentaje que ingresaremos al comienzo del programa por
linea de comando (arg del main).
c) Se dara al ususario un menu con las siguiente opciones:
1. Modificar medicion: Para ello se ingresa codigo de la resistencia y nueva medicion.
2. Eliminar Medicion: Para ello se ingresa codigo de la resistencia y se elimina medicion.
3. Salir: Momento en el cual se libera memoria pedida para la COLA.

No se bien como pensar la parte de recorrer toda la lista y ir verificando cada valor. Por otro lado, supongo que para la parte matematica del punto, simplemente tengo que multiplicar el valor medido por 100 y al resultado dividirlo por el valor nominal de la resistencia. Si el valor que me da es distinto del valor que ingrese por linea de comando (que vendria a ser la tolerancia o porcentaje de la resistencia) entonces listo en pantalla dicha resistencia con su codigo y demas. Esto lo tengo que hacer para todas las resistencias. Nuevamente mi problema es hacer el codigo para poder recorrer todos los nodos y ir "tomando" los valores de las resistencias de cada nodo. Aqui les dejo lo que hice del programa:

http://www.copiatelo.com/index.php?show=m2aaf5adb

Como ven, a la funcion la llame "verificar (H , float tole)" la cual recibe NODO **H que es el primer nodo de todos (el header) y lo tomo como un puntero a puntero pues h ya es un puntero y yo le toy dando la direccion de lo que ya es un puntero y un "float tole" que seria el porcentaje que yo ingrese por telcado por linea de comando al comienzo. A la funcion cuando la invoque en el main, le pase la direccion de H y lo que yo ingrese por linea de comando (utilice el atof pues lo que yo ingreso por teclado la PC lo toma como chars y yo quiero que lo tome como floats). La idea es recorrer la lista con un puntero auxiliar y que a traves de este yo pueda ingresar a los datos "v_medido" y "v_nominal" de cada nodo (resistencia) y poder compararlos como propuse anteriormente con el valor de "tole". Pero no se cual seria el codigo.

Quien me da una mano?

Eso es todo muchas gracias!

---

Ahi lo pense y hice esto:

http://www.copiatelo.com/index.php?show=m6bac6951

No se si esta bien o no. Esta vez no le pase la direccion a la funcion cuando la invoque en el main sino que le pase directamente la variable h y por ende en la funcion la use como puntero. Esta bien hecho?

¡Aloha!

En general parece estar bien, ahora me detengo mejor sobre verificar(). Como consejo, pensá que poner nombres más lindos a las variables no cuesta nada. En lugar de "tole" o "H", poner "tolerancia" o "elemento" ayudan un poco más a que quien lee por primera vez el código entienda mejor qué es lo que hace.

Por otro lado, es muy de electrónicos el tema (incluso los de sistemas sufrimos la herencia de que los primeros informáticos eran electrónicos, ja) de "ahorrarse" comparaciones o cosas así. En lugar de "while (H->next)", dejá BIEN EN CLARO cuál es la condición: "while (H->next != NULL)". Esto sí puede impactar un poco en la performance, pero seguramente sea mínimo el impacto (onda, sólo lo "optimizaría" si hiciera falta, porque lo corrí en un tamagochi que no tiene mucha sopa y va lento, y buen, pruebo a ver si cambiandolo mejora el tema).

Ya centrándome en verificar(), fijate que hacés primero un while(H->next) y adentro de eso un while(H). El while de adentro va a ser falso sólo cuando H sea NULL. En ese caso, va a salir del ciclo, y volver al while(H->next). Y como H es NULL, cuando quiera evaluar el H->next va a suicidarse.

Podrías usar un do {} while(), para evaluar si avanza o no al final, o sacar el while (H->next) al principio (si tuvieras un único nodo, igual deberías validar que la resistencia de bien) y dejar algo así:

 

// defino valorAbsoluto porque fabs() requiere la libm y no se si ustedes la podran usar o no

float valorAbsoluto(float numero) {

    if(numero < 0) {

        return -numero;

    }

    return numero;

}



verificar (NODO *elemento , float tolerancia) {

    while (elemento != NULL) {

        DATOS *resistencia = &(elemento->info); //apunto a la info (no copio para no duplicar los datos al pedo)



        // la tolerancia es +/-, asi que calculo el valor absoluto de la diferencia de valores y comparo con la tolerancia

        if(valorAbsoluto(resistencia->v_medido - resistencia->v_nominal) < tolerancia) { // va -> porque ahora tengo el puntero

            printf("Codigo de la Resistencia: %s\n",resistencia->codigo);

            printf("Valor nominal de la Resistencia: %d\n",resistencia->v_nominal);

            printf("Valor Medido de la Resistencia: %g\n",resistencia->v_medido);

        }

 

        elemento = elemento->next;

    }

}

Tal vez te lo resolví demasiado.

Gracias desert. Varias dudas:

1. No entiendo que esta mal con el "doble while". Yo lo pense asi: Tenes el while (H->next) el cual te dice que mientras el puntero a next sea 1 (distinto de NULL) vas a ingresar. Suponiendo que la condicion se de y ingreses al while te encontras con un nuevo while que dice: while (H). Si la direccion de H no es null entra y hace lo que tiene que hacer. Si es null directamente H apunta al siguiente nodo (con el next) y se repite el while original hasta llegar al NULL y salir. Que esta mal de eso?

2. Por que en la condicion pusiste
valorAbsoluto(resistencia->v_medido - resistencia->v_nominal) < tolerancia
y no el != ? El enunciado dice que tiene que ser distinto no menor o mayor que la tolerancia.

3. No entendi lo que hiciste aca:

while (elemento != NULL) {
11 DATOS *resistencia = &(elemento->info);

Eso es todo, muchisimas gracias por la paciencia de escribirme el codigo :=).

Warning: Son las 3 de la mañana [y todo el mundo bailando].


1) Tu código decía:

 

verificar (NODO *H , float tole) {

  while (H->next) {

    while (H) {

      if(((((H->info).v_medido)*100)/((H->info).v_nominal))!= tole) {

        printf("Codigo de la Resistencia: %s\n",(H->info).codigo);

        printf("Valor nominal de la Resistencia: %d\n",(H->info).v_nominal);

        printf("Valor Medido de la Resistencia: %g\n",(H->info).v_medido);

      }

      H = H -> next;

    }

  }

}

El H = H -> next; está **DENTRO** del while(H). Osea que, si H == null, no avanza el cursor (cosa que está *muy* bien, porque si H es NULL querer hacer H -> next; va a fallar estrepitósamente). El problema es que, como el while(H) no se cumple, va a intentar ejecutar la instrucción siguente al while(), pero *fuera de él*. Como no hay ninguna instrucción fuera, ejecuta el "vuelta al principio del while" del while de afuera (el while H->next). Y ahí lo mismo que decía recién: H va a ser NULL (sino, seguiría en el while de adentro), y H->next va a dar segmentation fault.

Eso siendo "técnico". Si lo encarás "conceptual", ¿por qué hay dos condiciones distintas que cumplir para recorrer una lista? ¿Acaso "recorrer una lista" no es hacer algo "mientras siga teniendo algún elemento en la lista"? Buen, eso es lo que hice: while(elemento != NULL). Si eso se cumple, hago lo que carajo quiera hacer con ese elemento actual que tengo, y por último avanzo el cursor (para no quedarme eternamente dandole masa al mismo elemento).

Y ahí es donde te digo que "while(elemento != NULL)" es más expresivo que "while(H)". Se podría mejorar el nombre "elemento" que es re genérico, pero... ¿qué carajo es "H"?


2) El enunciado que vos pusiste dice:

Cita:Una vez finalizada la carga se debera listar en pantalla todas las resistencias cuyo valor medido difiera de su valor nominal por mas de un porcentaje que ingresaremos al comienzo del programa por linea de comando (arg del main)

Me quedo con esas dos cosas resaltadas: difiera implica restar y quedarse el valor absoluto, porque es onda "una distancia" (ok, podría interesarnos con signo la diferencia, para saber si está por arriba o abajo, pero vamos con el punto que sigue). "por más de" habla de eso: que la diferencia esa sea mayor a la tolerancia. ¿Cuál es la idea? Si tengo una resistencia que debería ser de, no se, 100, y la pruebo y es de 150, y la tolerancia es el 10%, buen, claramente la resistencia está como el culo, y por eso quiero que "salte la ficha". ¿Y cómo sabemos eso? Bueno, porque 150 - 100 = 50 omhs es la diferencia de resistencias. Y en una resistencia de 100 nominales y tolerancia del 10% significa que me puedo desviar 10 omhs. Osea, las resistencias entre 90 (100 - 10) y 110 (100 + 10) ohms van a estar OK, el resto tengo que marcarlas como malas.

Y ahora que leo, hay dos errores: la tolerancia debería multiplicarse por el valor nominal (no quiero comparar contra un 10% sino contra una cantidad de ohms, que es lo que me da la resta de valores), y el signo es >, no < (quiero aquellas cuya diferencia sea MAYOR a la permitida, no menor).

Entonces esa línea sería:

 if(valorAbsoluto(resistencia->v_medido - resistencia->v_nominal) > tolerancia * resistencia->v_nominal) { // va -> porque ahora tengo el puntero

3) DATOS *resistencia = &(elemento->info);
Antes del signo =, declaro una variable llamada resistencia, de tipo DATOS *. Cualquier_tipo * es una declaración de "puntero a Cualquier_tipo". Así como tu campo next del struct nodo es un puntero a struct nodo (pusiste "struct nodo *next"), esta variable resistencia es un puntero a una cosa de tipo DATOS (tu struct que tiene codigo, v_nominal y v_medido).

El = es el operador de asignación. en lo que está a la izquierda del = guardo el resultado de evaluar lo que está a la otra izquierda del mismo.

En este caso, lo que está a la derecha es el operador & aplicado al campo info del elemento. & es el operador que devuelve un puntero a lo que sea que le pasemos por parámetro (o, más técnicamente, devuelve la dirección de memoria de lo que tiene como parámetro).

Entonces, a un poquito más alto nivel, declaramos una variable resistencia que apunte al campo info del elemento. Entonces, en vez de volverme boludo escribiendo elemento->info muchas veces, puedo usar directamente "resistencia".

Podría haber hecho también esto:

 DATOS resistencia = elemento->info;

Pero ahí estaría diciendo que resistencia *es* un struct con los 3 campos, y al asignarle el info de elemento estaría copiando **todo el struct** a un nuevo struct creado en memoria. Entonces, por un lado desperdicio memoria y hago más lento el asunto (tiene que copiar varios campos). La diferencia es mínima, sí, pero es choto. Pero, por otro, estoy generando UNA COPIA, por lo que si llegara a modificar algo de resistencia, el elemento original no se vería afectado.
¿Esto último es necesariamente malo? No. Podría interesarme hacer eso en algún contexto, y en algún otro podría interesarme que eso no pase. En casos como este, en que no modificamos esos datos, no nos calienta en absoluto si se copia o no. Cualquiera de los dos casos funcionaría igual, salvando ese temita de performance que no vamos a notar. Pero sí está bueno tener en cuenta que en otros casos puede hacer diferencia.



Si no fui claro en algo o quedó algo en el tintero, chifle nomái.

Abrazo!

(29-08-2013 13:29)Gonsha escribió:  [quote='Desert69' pid='343238' dateline='1377757559']
Warning: Son las 3 de la mañana [y todo el mundo bailando].


1) Tu código decía:

 

verificar (NODO *H , float tole) {

  while (H->next) {

    while (H) {

      if(((((H->info).v_medido)*100)/((H->info).v_nominal))!= tole) {

        printf("Codigo de la Resistencia: %s

",(H->info).codigo);

        printf("Valor nominal de la Resistencia: %d

",(H->info).v_nominal);

        printf("Valor Medido de la Resistencia: %g

",(H->info).v_medido);

      }

      H = H -> next;

    }

  }

}

Compilar y ejecutar código

El H = H -> next; está **DENTRO** del while(H). Osea que, si H == null, no avanza el cursor (cosa que está *muy* bien, porque si H es NULL querer hacer H -> next; va a fallar estrepitósamente). El problema es que, como el while(H) no se cumple, va a intentar ejecutar la instrucción siguente al while(), pero *fuera de él*. Como no hay ninguna instrucción fuera, ejecuta el "vuelta al principio del while" del while de afuera (el while H->next). Y ahí lo mismo que decía recién: H va a ser NULL (sino, seguiría en el while de adentro), y H->next va a dar segmentation fault.

Eso siendo "técnico". Si lo encarás "conceptual", ¿por qué hay dos condiciones distintas que cumplir para recorrer una lista? ¿Acaso "recorrer una lista" no es hacer algo "mientras siga teniendo algún elemento en la lista"? Buen, eso es lo que hice: while(elemento != NULL). Si eso se cumple, hago lo que carajo quiera hacer con ese elemento actual que tengo, y por último avanzo el cursor (para no quedarme eternamente dandole masa al mismo elemento).

Y ahí es donde te digo que "while(elemento != NULL)" es más expresivo que "while(H)". Se podría mejorar el nombre "elemento" que es re genérico, pero... ¿qué carajo es "H"?

JAJAJAJAAJA posta, H es header pero tenes razon . Ahora si entendi, claro tengo ese while "externo" que me traba todo. Gracias!!!!!

(29-08-2013 03:25)Desert69 escribió:  2) El enunciado que vos pusiste dice:

Cita:Una vez finalizada la carga se debera listar en pantalla todas las resistencias cuyo valor medido difiera de su valor nominal por mas de un porcentaje que ingresaremos al comienzo del programa por linea de comando (arg del main)

Me quedo con esas dos cosas resaltadas: difiera implica restar y quedarse el valor absoluto, porque es onda "una distancia" (ok, podría interesarnos con signo la diferencia, para saber si está por arriba o abajo, pero vamos con el punto que sigue). "por más de" habla de eso: que la diferencia esa sea mayor a la tolerancia. ¿Cuál es la idea? Si tengo una resistencia que debería ser de, no se, 100, y la pruebo y es de 150, y la tolerancia es el 10%, buen, claramente la resistencia está como el culo, y por eso quiero que "salte la ficha". ¿Y cómo sabemos eso? Bueno, porque 150 - 100 = 50 omhs es la diferencia de resistencias. Y en una resistencia de 100 nominales y tolerancia del 10% significa que me puedo desviar 10 omhs. Osea, las resistencias entre 90 (100 - 10) y 110 (100 + 10) ohms van a estar OK, el resto tengo que marcarlas como malas.

Y ahora que leo, hay dos errores: la tolerancia debería multiplicarse por el valor nominal (no quiero comparar contra un 10% sino contra una cantidad de ohms, que es lo que me da la resta de valores), y el signo es >, no < (quiero aquellas cuya diferencia sea MAYOR a la permitida, no menor).

Entonces esa línea sería:

 if(valorAbsoluto(resistencia->v_medido - resistencia->v_nominal) > tolerancia * resistencia->v_nominal) { // va -> porque ahora tengo el puntero

Compilar y ejecutar código

3) DATOS *resistencia = &(elemento->info);
Antes del signo =, declaro una variable llamada resistencia, de tipo DATOS *. Cualquier_tipo * es una declaración de "puntero a Cualquier_tipo". Así como tu campo next del struct nodo es un puntero a struct nodo (pusiste "struct nodo *next"), esta variable resistencia es un puntero a una cosa de tipo DATOS (tu struct que tiene codigo, v_nominal y v_medido).

El = es el operador de asignación. en lo que está a la izquierda del = guardo el resultado de evaluar lo que está a la otra izquierda del mismo.

En este caso, lo que está a la derecha es el operador & aplicado al campo info del elemento. & es el operador que devuelve un puntero a lo que sea que le pasemos por parámetro (o, más técnicamente, devuelve la dirección de memoria de lo que tiene como parámetro).

Entonces, a un poquito más alto nivel, declaramos una variable resistencia que apunte al campo info del elemento. Entonces, en vez de volverme boludo escribiendo elemento->info muchas veces, puedo usar directamente "resistencia".

Podría haber hecho también esto:

 DATOS resistencia = elemento->info;

Compilar y ejecutar código

Pero ahí estaría diciendo que resistencia *es* un struct con los 3 campos, y al asignarle el info de elemento estaría copiando **todo el struct** a un nuevo struct creado en memoria. Entonces, por un lado desperdicio memoria y hago más lento el asunto (tiene que copiar varios campos). La diferencia es mínima, sí, pero es choto. Pero, por otro, estoy generando UNA COPIA, por lo que si llegara a modificar algo de resistencia, el elemento original no se vería afectado.
¿Esto último es necesariamente malo? No. Podría interesarme hacer eso en algún contexto, y en algún otro podría interesarme que eso no pase. En casos como este, en que no modificamos esos datos, no nos calienta en absoluto si se copia o no. Cualquiera de los dos casos funcionaría igual, salvando ese temita de performance que no vamos a notar. Pero sí está bueno tener en cuenta que en otros casos puede hacer diferencia.



Si no fui claro en algo o quedó algo en el tintero, chifle nomái.

Abrazo!

Para verificar, si no decido optimizar el programa y lo dejo como lo tenia yo, estaria bien asi:

verificar (NODO *H , float tole)
{
while (H!=NULL)
{
if(valorAbsoluto(((H->info).v_medido)-((H->info).v_nominal))> (tole *((H->info).v_nominal)))
{
printf("Codigo de la Resistencia: %s
",(H->info).codigo);
printf("Valor nominal de la Resistencia: %d
",(H->info).v_nominal);
printf("Valor Medido de la Resistencia: %g
",(H->info).v_medido);
}

H = H -> next;
}


}
Cual seria el prototipo de la funcion "valor absoluto"? Y necesito agregar algun header especifico? Nunca la utilice esa funcion.
Eso es todo . Saludos y mil gracias!

Fijate que valorAbsoluto() la definí en mi primer respuesta:

(28-08-2013 16:45)Desert69 escribió:  

 

// defino valorAbsoluto porque fabs() requiere la libm y no se si ustedes la podran usar o no

float valorAbsoluto(float numero) {

    if(numero < 0) {

        return -numero;

    }

    return numero;

}

Compilar y ejecutar código

Es decir, "no existía", la hice yo. Si tenés libertad de usar funciones predefinidas, usá fabs() que está en la libm. vas a tener que incluir math.h y linkear con -lm. Si no podés usarla, usá valorAbsoluto como la definí ahí.

Uhh que nabo jajjaja. Gracias Desert . Un gran abrazo!

Bueno gente, termine de hacer el punto b por completo, pero cuando lo compilo y lo hago funcionar, hace cualquier cosa! El codigo:

http://www.copiatelo.com/index.php?show=mb872e10

Alguien me podria ayudar a "depurar" el programa?

Muchas gracias! Saludos!

Gonsha, cunado decís que "hace cualquier cosa", ¿a qué te referís?


Pensando en el otro post que hice hoy, fijate qué casos plantearías para tu programa, con sus resultados esperados, y comparalos con tu programa, a ver qué puede estar pasando. Tratá de ser lo más específico que puedas en tu descripción del problema, que incluso eso mismo te va a obligar a probar cosas y pensar muy bien qué cosas probaste y cuáles no, como para ir acotando el problema. Y tal vez incluso lo detectes mientras te tomás ese laburo, y no haga falta preguntar (pero sí contar cuál era el problema, je ).

Si te sobran unos minutos, leete ¿Qué intentaste?, también.

(02-09-2013 02:41)Desert69 escribió:  Gonsha, cunado decís que "hace cualquier cosa", ¿a qué te referís?


Pensando en el otro post que hice hoy, fijate qué casos plantearías para tu programa, con sus resultados esperados, y comparalos con tu programa, a ver qué puede estar pasando. Tratá de ser lo más específico que puedas en tu descripción del problema, que incluso eso mismo te va a obligar a probar cosas y pensar muy bien qué cosas probaste y cuáles no, como para ir acotando el problema. Y tal vez incluso lo detectes mientras te tomás ese laburo, y no haga falta preguntar (pero sí contar cuál era el problema, je ).

Si te sobran unos minutos, leete ¿Qué intentaste?, también.

Me falla cuando pongo "fin" para terminar el ingreso de datos para la struct y me imprime cualquier cosa.