Requerimientos para realizar el siguiente ejercicio C?

[IEEE]

Estimados,

Ante todo gracias por tomarse la molestia de leer mi post.

La duda es la siguiente.
Estoy tratando de hacer el siguiente ejercicio. Y la verdad creo que no lo puedo realizar con los contenidos que vimos hasta ahora en mi curso (sentencias de seleccion, corte de cntrol, funioes y hasta ahi. No vimos ni arrays ni punteros)

*************************************************

Una empresa de venta de accesorios para automotor que comercializa como maximo 500 articulos, desea confeccionar un programa en C para el control de sus existencias y dando respuestas a las siguientes consideraciones:
*un primer registro con el - numero de articulo (entre 1001 y 4004)
- existencia inicial (entre 1 y 400)
- precio unitario (entre 1 y 123)
*un segundo registro por cada venta realizada conteniendo :
- numero de articulo y las unidades vendidas (entre 1 y 12)

Se garantiza que existen entre 1 y 5 ventas de c/ articulo.
Esta informacion se halla clasificada por nro de articulo.
Debe solicitarse y exibirse en pantalla los datos ingresados con leyendas aclaratorias, controlando su validez y rechazando posibles errores.
La informacion finaliza con un registro negativo de articulo.
La cantidad de articulos a ingresar debe ser entre 20 y 30 registros.
Deben contemplarce todos lso casos posibles.

Se debe determinar e informar:
2 - Un alista dodne figure cada articulo con su saldo final, con titulos aclaratorios
3 - El nro de articulo del cual se vendieron en total mas unidades.
4 - El nro de articulo que en el total de sus ventas genero el mayor importe.
5 - la cantidad de articulos que al fin del proceso quedaron con saldo nulo.

FUNCIONES A CONFECCIONAR Y UTILIZAR:

1) para controlar la validez de los datos a ingresar.
2) para calcular el importe de cada venta.
3) para informar lo solicitado en el punto 4.
4) para determinar si un articulo quedo con saldo nulo.

*************************************************

Lo que necesito saber maso menos como encarar el planteo del ejercicio en lineas generales. Ya que lo unico que pude hacer es la primer funcion que detecta errores en la entrada de datos (lo se... es triste).

[j8k6f4v9j]

El ejercicio se puede hacer sin arrays ni punteros, ya que te da un número limitado de registros (entre 20 y 30). Claro que la ordenación no va a ser de lo más flexible

Supongo que la intención del docente es demostrar lo mal que se puede hacer un programa sin las herramientas adecuadas

Hace falta declarar ambos registros. Y declarar las variables (20 a 30) en las que se van a guardar los datos.

Una vez introducidos los datos, hacen falta las funciones:
- la encargada de ver el número de existencias (buscando el artículo entre los registros)
- la encargada de mostrar todos los registros ordenados
- etc, etc

Básicamente, para lo que tú preguntas, que es cómo organizar los datos sin arrays ni punteros, yo lo haría de ese modo.

Salu2

Keep on Rollin'

[IEEE]

Mil gracias por la respuesta!
Me diste la tranquilidad que necesitaba de que lo puedo hacer con lo que se. Ahora solo resta ponerse .

[j8k6f4v9j]

De todas formas, de esa forma es todo muy enrrevesado, así que no te agobies si no sale, simplemente haz lo que puedas, que supongo que es lo que se pretende.

Salu2

Keep on Rollin'

[IEEE]

Bueno... el sabado pasado encare al profesor en la clase y le comente lo que me explicabas, j8 ( de mas esta agradecer tu colaboracion ), y termino por sacarle el punto 2 al ejercicio ( el que pide hacer una lista ).
Por ende ahora el ej lo puedo hacer tranquilamente con lo que ya sabia.

Muchisimas gracias nuevamente!!!

IEEE

[j8k6f4v9j]

No las merece

Dale caña Luego de ver lo mal que se hace así, toca indagar sobre cómo se ha de hacer para que resulte pontente de verdad.

A mí me gusta mantener un array desordenado ( de estructuras), para luego crear otro array pero de punteros a estructuras por cada ordenación que desee. Así sólo se ordenan los punteros. Estudia a fonde la función qsort() y aprende a hacer las funciones de comparación (usadas por qsort) y tendrás en tu mano todo lo necesario para trabajar rápida y cómodamente con arrays de estructuras

Si necesitas algún ejemplo estaré encantado de comentártelo.

Salu2

Keep on Rollin'

[IEEE]

Pues bien, sigo yo con mis dudas.

Estoy haciendo la funcion que valida los datos y vuelve a pedirlos en caso de que sean incorrectos:

int validar_datos(int *pn_articulo, int *pex_ini, float *pprecio_uni)

{
int b1=0;
while(b1!=1)
{
if(n_articulo>=1001 && n_articulo<=4004)
if(ex_ini>=1 && ex_ini<=400)
if(precio_uni>=1 && precio_uni<=123)
{
printf("\nNumero de articulo: %d", n_articulo);
printf("\nExistencias Iniciales: %d", ex_ini);
printf("\nPrecio unitario: %.2f", precio_uni);
b1=1;
}
else
{
printf("\n¡!*¡* ERROR *!*!*\n\n\aReingrese el precio unitario: ");
fflush(stdin);
scanf("%f", &*pprecio_uni);
}
else
{
printf("\n¡!*¡* ERROR *!*!*\n\n\aReingrese las existencias iniciales: ");
fflush(stdin);
scanf("%d", &*pex_ini);
}
else
{
printf("\n¡!*¡* ERROR *!*!*\n\n\aReingrese numero de articulo: ");
fflush(stdin);
scanf("%d", &*pn_articulo);
}
}
}

El tema es que, nuevamente, me vi forzado a utilizar punteros para que los datos que toman los scanf de la funcion se asignen efectivamente a las variables globales. Peeeero, en la clase aun no vimos punteros :s. Existe alguna forma de que la funcion realice esa tarea sin punteros?. O directamente cuando uno de los datos es erroneo se deben volver a pedir pero desde fuera de la funcion?. De ser asi tendria que volver a estructurar todo el programa calculo.

Muchas gracias!

[.Yok3R.]

Sinceramente me resulta díficil solucionar el problema , y lo digo porque tan claro resulta cuando conoces las herramientas necesarias que te ayudan a solventar la necesidad, con esto me refiero a Arreglos y Nodos como bien dice j8, métodos de ordenación, etc. en general Estructura de datos, jajaja me resulta "gracioso" porque se me hizo complicado emigrar de programación estructurada a POO, ahora todo lo veo como objetos, o de forma tal para simplificar las cosas, aunque eso sí dijera Böhm-Jacopini todo programa se puede realizar con 3 reglas básicas: una secuencia, una condición y un control de iteraciones... Que para mi caso en ésta situación no veo la solución sin usar punteros o arreglos, espero mantengas al tanto de cómo lo haces, para recordar un poco mis viejas andanzas por C jajaja, y sino puedes, a utilizar las herramientas antes mencionadas, total para eso estan, ¿O no?

En fin, saludos.

¡Abur!

[j8k6f4v9j]

Existe alguna forma de que la funcion realice esa tarea sin punteros?

Puedes hacerlo copiando una estructura por ejemplo. Es decir, la función va tomando los datos y creando una estructura, que será lo que devuelva.
Es decir, en vez de esto:

int validar_datos(int *pn_articulo, int *pex_ini, float *pprecio_uni)

pues algo así:

tipo_de_ls_estructura validar_datos()

Salu2

Keep on Rollin'

[IEEE]

Hola a todos!

Ante todo, como siempre, muchas gracias por su tiempo.

Ahora pasemos a los bifes...

Finalmente opte por hacer que las funciones NO tomen los datos correctos, sino que solamente validen los datos ingresados. Esto fue debido a que indagando a otros compañeros averigue que si utilizaba punteros (tema todavia pendiente en el curso) el ej iba a estar incorrecto. Por ende, y para (espero) finalizar el tema, por lo menos hasta el proximo TP (jejejeje), les dejo el codigo del ej para algun que otro curioso que tal vez le sirva de algo.
Nuevamente muchas gracias a todos!

#include <stdio.h>
#include <conio.h>


int n_articulo,n_articulo_v, ex_ini, ex_temp, unid_vendidas, n_articulo_max=0;
float precio_uni, suma_ventas, suma_ventas_max=0;
int b0=1/*Contador de ventas*/;
int total_ventas_xart=0, max_art=0, n_max_art=0;
int limin, limsu;

/*Prototipos de funciones*/
int validar_datos(float dato, int limin, int limsu);
float calc_imp_ventas (int unid_vendidas, float precio_uni);
int art_saldo_nulo(int n_articulo, int ex_temp);
int max_venta (float suma_ventas, float suma_ventas_max, int n_articulo,
int n_articulo_max);


/*Inicio de Programa*/

int main()
{
printf("\n\n\t *****************************************\n");
printf("\t * Ejercicio A9 *\n");
printf("\t *****************************************\n\n");

printf("\nIngrese el numero de articulo (1001-4004)");
printf("\no un numero negativo para finalizar: ");
fflush(stdin);
scanf("%d", &n_articulo);

while(n_articulo >= 0)
{
do
{
if(validar_datos (n_articulo, 1001, 4004) == 0)
{
printf("\n\t** ERROR **\n\n\aReingrese numero de articulo: ");
fflush(stdin);
scanf("%d", &n_articulo);
}}
while(validar_datos (n_articulo, 1001, 4004) == 0);

printf("\nIngrese las existencias iniciales (1-400): ");
fflush(stdin);
scanf("%d", &ex_ini);

do
{
if(validar_datos (ex_ini, 1, 400) == 0)
{
printf("\n\t** ERROR **\n\n\aReingrese las existencias iniciales: ");
fflush(stdin);
scanf("%d", &ex_ini);
}}
while(validar_datos (ex_ini, 1, 400) == 0);

printf("\nIngrese el precio unitario(1-123): ");
fflush(stdin);
scanf("%f", &precio_uni);

ex_temp = ex_ini;

do
{
if(validar_datos (precio_uni, 1, 123) == 0)
{
printf("\n\t** ERROR **\n\n\aReingrese el precio unitario: ");
fflush(stdin);
scanf("%f", &precio_uni);
}}
while (validar_datos (precio_uni, 1, 123) == 0);


printf("\nNumero de articulo: %d", n_articulo);
printf("\nExistencias Iniciales: %d", ex_ini);
printf("\nPrecio unitario: %.2f\n", precio_uni);

printf("\n\n\t *****************************************\n");
printf("\t * Carga de ventas: Art. %d *\n", n_articulo);
printf("\t *****************************************\n\n");

printf("\nIngrese numero de articulo de la venta (0 para finalizar): ");
fflush(stdin);
scanf("%d", &n_articulo_v);


if(n_articulo_v != 0)
{
printf("\nIngrese unidades vendidas: ");
fflush(stdin);
scanf("%d", &unid_vendidas);
}
while(n_articulo_v != 0)
{

do
{
if(n_articulo_v != n_articulo)
{
printf("\n\t** ERROR ** \n\nReingrese el numero de articulo (entre 1001 y 4004)");
fflush(stdin);
scanf("%d", &n_articulo_v);
}}
while(n_articulo_v != n_articulo);/*Inicia el ciclo de carga de ventas*/

do
{
if(unid_vendidas > ex_ini || unid_vendidas < 1 || unid_vendidas > 12)
{
printf("\n\t** ERROR ** \n\nReingrese la cantidad vendida (1-12): ");
fflush(stdin);
scanf("%d", &unid_vendidas);
}
else
{
printf("\nVENTA NUM. %d : \n\n", b0);
printf("Numero de Articulo: %d\n", n_articulo);
printf("Cantidad vendida: %d\n", unid_vendidas);
b0++;
}
}
while (unid_vendidas > ex_ini || unid_vendidas < 1 || unid_vendidas > 12);

ex_temp -= unid_vendidas;

total_ventas_xart += unid_vendidas;

suma_ventas += calc_imp_ventas(unid_vendidas, precio_uni);

printf("Importe de Venta: %.2f\n", calc_imp_ventas(unid_vendidas, precio_uni));
printf("Unidades en stock restantes: %d\n", ex_temp);
printf("Importe total sobre el art. %d: %.2f\n", n_articulo_v, suma_ventas);

printf("\nIngrese numero de articulo (0 para finalizar): ");
fflush(stdin);
scanf("%d", &n_articulo_v);

if(n_articulo_v != 0)
{
printf("\nIngrese unidades vendidas (1-12): ");
fflush(stdin);
scanf("%d", &unid_vendidas);
}

}/*Finaliza el ciclo de carga de ventas*/

if(total_ventas_xart > max_art)
{
max_art = total_ventas_xart;
n_max_art = n_articulo;
}

max_venta (suma_ventas, suma_ventas_max, n_articulo, n_articulo_max);

suma_ventas = 0;

art_saldo_nulo(n_articulo, ex_temp);

printf("\n\t *******************************************");
printf("\n\t * FIN carga de ventas del articulo %d *", n_articulo);
printf("\n\t *******************************************\n");

printf("\nIngrese el numero de articulo (1001-4004)");
printf("\no un numero negativo para finalizar: ");
fflush(stdin);
scanf("%d", &n_articulo);

}
printf("\nArticulo con mas unidades vendidas: %d\n\n", n_max_art);
getch();
}/*Finaliza Programa*/


/*****FUNCIONES*****/


/*Funcion: valida los datos cargados al inicio*/
int validar_datos(float dato, int limin, int limsu)
{
int f;
if (dato >= limin && dato <= limsu)
{
f=1;
return f;
}
else
{
f=0;
return f;
}
}

/*Funcion de calculo de importe de la venta*/
float calc_imp_ventas (int unid_vendidas, float precio_uni)
{
float imp_venta;

imp_venta = unid_vendidas * precio_uni;
return imp_venta;
}

/*Funcion: determina el articulo que genero mas ventas*/
int max_venta (float suma_ventas, float suma_ventas_max, int n_articulo,
int n_articulo_max)
{
if(suma_ventas > suma_ventas_max)
{
n_articulo_max = n_articulo;
suma_ventas_max = suma_ventas;
printf("\nEl art. %d genero el maximo de ventas\n", n_articulo_max);
}
else
{
printf("\nEl art. %d genero el maximo de ventas\n", n_articulo_max);
}
}

/*Funcion: determina los articulos con saldo nulo*/
int art_saldo_nulo(int n_articulo, int ex_temp)
{
if(ex_temp == 0)
printf("El articulo %d quedo con saldo nulo", n_articulo);
}

[hystd]

ok! enhorabuena.

Cierro el hilo.

Un saludo