Pascal/Turbo Pascal - actualizar un stock con listas.

   
Vista:

actualizar un stock con listas.

Publicado por Diego (98 intervenciones) el 19/10/2013 23:32:30
Buenas tardes, Lo vi a simple vista y no veo bien en que me estoy equivocando en el modulo inciso_A

este es el problema:
Una empresa de Materiales para la Construcción dispone de una lista con los productos que
comercializa. Dicha lista posee: código y nombre de producto, stock actual, stock mínimo y precio
unitario. Además la empresa posee una sucursal que diariamente envía la información de sus ventas.
De cada venta se conoce número de venta, el código de producto y cantidad vendida. Toda la
información se encuentra ordenada por código de producto.
a) Se solicita realizar el proceso que recibe la información de ventas de un día y actualiza el stock
actual de la lista de productos.

Ya generé las estructuras que disponen de la información, parece que funcionan bien, almenos para los casos en que las probé. Mi problema es en el modulo inciso_A, almenos eso creo.

program ejercicio5;
type
info_productos = record
cod_pro : integer;
nom_pro : string;
stock_actual : integer;
stock_minimo : integer;
precio_unitario : real;
end;
lista_productos = ^nodo_pro;
nodo_pro = record
elemen_pro : info_productos;
dirSig_pro : lista_productos;
end;
info_ventas = record
num_venta : integer;
cod_pro: integer;
cant_vendida : integer;
end;
lista_ventas = ^nodo_vent;
nodo_vent = record
elemen_vent : info_ventas;
dirSig_vent : lista_ventas;
end;
info_arbol = record
cod_pro : integer;
stock_a_reponer : integer;
end;
T_arbol = ^nodo_arbol;
nodo_arbol = record
hijo_der : T_arbol;
elemen_arbol : info_arbol;
hijo_izq : T_arbol;
end;
procedure crear_lista_pro (var L : lista_productos);
begin
L:= nil;
end;
procedure crear_lista_vent(var L : lista_ventas);
begin
L := nil;
end;
procedure crear_arbol(var a: T_arbol);
begin
a:= nil;
end;
procedure leer_info_pro(var reg_pro : info_productos);
begin
with (reg_pro) do
begin
write('Ingrese el código del producto: ');
readln(cod_pro);
if (cod_pro <> -1) then
begin
write('Ingrese el nombre del producto: ');
readln(nom_pro);
write('Ingrese el stock actual del producto: ');
readln(stock_actual);
write('Ingrese el stock minimo producto: ');
readln(stock_minimo);
write('Ingrese el precio unitario del producto: ');
readln(precio_unitario);
end;
end;
end;
procedure insertar_ord_pro(var pri_nodo: lista_productos; reg: info_productos);
var
nue, aux, ant : lista_productos;
begin
new(nue);
nue^.elemen_pro := reg;
nue^.dirSig_pro := nil;
if (reg.cod_pro < pri_nodo^.elemen_pro.cod_pro) then
begin
nue^.dirSig_pro := pri_nodo;
pri_nodo := nue;
end
else
begin
aux:= pri_nodo;
ant := aux;
while ((aux <> nil) and (reg.cod_pro >= aux^.elemen_pro.cod_pro)) do
begin
ant := aux;
aux := aux^.dirSig_pro;
end;
ant^.dirSig_pro := nue;
if not(aux = nil) then
nue^.dirSig_pro := aux;
end;
end;
procedure cargar_lista_productos(var list_pro : lista_productos);
var
reg_pro : info_productos;
begin
leer_info_pro(reg_pro);
if (reg_pro.cod_pro <> -1) then
begin
new(list_pro);
list_pro^.elemen_pro := reg_pro;
list_pro^.dirSig_pro := nil;
leer_info_pro(reg_pro);
while (reg_pro.cod_pro <> -1) do
begin
insertar_ord_pro(list_pro, reg_pro);
leer_info_pro(reg_pro);
end;
end;
end;
procedure leer_info_vent(var reg_vent: info_ventas);
begin
with (reg_vent) do
begin
write('Ingrese el código del producto: ');
readln(cod_pro);
if (cod_pro <> -1) then
begin
write('Ingrese el número de venta: ');
readln(num_venta);
write('Ingrese la cantidad vendida: ');
readln(cant_vendida);
end;
end;
end;
procedure insertar_ord_vent(var pri_nodo: lista_ventas; reg: info_ventas);
var
nue, aux, ant : lista_ventas;
begin
new(nue);
nue^.elemen_vent := reg;
nue^.dirSig_vent := nil;
if (reg.cod_pro < pri_nodo^.elemen_vent.cod_pro) then
begin
nue^.dirSig_vent := pri_nodo;
pri_nodo := nue;
end
else
begin
aux:= pri_nodo;
ant := aux;
while ((aux <> nil) and (reg.cod_pro >= aux^.elemen_vent.cod_pro)) do
begin
ant := aux;
aux := aux^.dirSig_vent;
end;
ant^.dirSig_vent := nue;
if not(aux = nil) then
nue^.dirSig_vent := aux;
end;
end;
procedure cargar_lista_ventas(var list_vent: lista_ventas);
var
reg_vent : info_ventas;
begin
leer_info_vent(reg_vent);
if (reg_vent.cod_pro <> -1) then
begin
new(list_vent);
list_vent^.elemen_vent := reg_vent;
list_vent^.dirSig_vent := nil;
leer_info_vent(reg_vent);
while (reg_vent.cod_pro <> -1) do
begin
insertar_ord_vent(list_vent, reg_vent);
leer_info_vent(reg_vent);
end;
end;
end;
procedure imprimir_lista_productos(L : lista_productos);
begin
while (L <> nil) do
begin
writeln('Código del producto: ', L^.elemen_pro.cod_pro);
writeln('Nombre del producto: ', L^.elemen_pro.nom_pro);
writeln('Stock actual del producto: ', L^.elemen_pro.stock_actual);
writeln('Stock minimo del producto: ', L^.elemen_pro.stock_minimo);
writeln('Precio unitario del producto: ', L^.elemen_pro.precio_unitario);
writeln();
L := L^.dirSig_pro;
end;
end;
procedure imprimir_lista_ventas(L : lista_ventas);
begin
while (L <> nil) do
begin
writeln('Código del producto: ', L^.elemen_vent.cod_pro);
writeln('Número de venta del producto: ', L^.elemen_vent.num_venta);
writeln('Cantidad vendida del producto: ', L^.elemen_vent.cant_vendida);
writeln();
L := L^.dirSig_vent;
end;
end;
procedure encontrar_cod(var list_pro: lista_productos; cod : integer);
var
ok : boolean;
begin
ok := false;
if (list_pro <> nil) then
while (ok <> true) do
begin
if (list_pro^.elemen_pro.cod_pro = cod) then
ok := true;
list_pro:= list_pro^.dirSig_pro;
end;
end;
procedure actualizar_stock(var stock_actual : integer; ventas: integer);
begin
stock_actual := stock_actual - ventas;
end;
procedure inciso_A(list_pro : lista_productos; list_vent: lista_ventas);
var
cod_actual : integer;
begin
if (list_vent <> nil) then
begin
cod_actual := list_vent^.elemen_vent.cod_pro;
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
while (list_vent <> nil) do
begin
while (list_vent^.elemen_vent.cod_pro = cod_actual) do
begin
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
end;
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
cod_actual := list_vent^.elemen_vent.cod_pro;
end;
end;
end;

var
list_pro : lista_productos;
list_vent : lista_ventas;
begin
crear_lista_pro(list_pro);
crear_lista_vent(list_vent);
writeln('---------------Lista de Productos--------------');
cargar_lista_productos(list_pro);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Ventas--------------');
cargar_lista_ventas(list_vent);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Productos--------------');
imprimir_lista_productos(list_pro);
writeln('------------------------X----------------------');
writeln();
writeln('---------------Lista de Ventas--------------');
imprimir_lista_ventas(list_vent);
writeln('------------------------X----------------------');
writeln();
writeln('----------------Inciso A------------------');
inciso_A(list_pro, list_vent);
imprimir_lista_productos(list_pro);
readln();
readln();
end.
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder

actualizar un stock con listas.

Publicado por ramon (2072 intervenciones) el 20/10/2013 13:53:44
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
{Mira Empecemos por la inserción ordenada a ver si te ayuda.
Ejecuta esto y veras como funciona}
 
 uses
      crt;
 
   type
   info_productos = record
           cod_pro : integer;
           nom_pro : string;
      stock_actual : integer;
      stock_minimo : integer;
   precio_unitario : real;
      end;
 
  lista_productos = ^nodo_pro;
         nodo_pro = record
         elemen_pro : info_productos;
         dirSig_pro : lista_productos;
      end;
 
  var
    prime, anter, ultimo, actual : lista_productos;
    producto : info_productos;
 
 
 
    procedure leer_info_pro(var reg_pro : info_productos);
    begin
      clrscr;
      writeln('*** Entrada Datos Producto Termina Entradas [-1] ***');
      writeln;
      with (reg_pro) do
      begin
          write('   Ingrese el codigo del producto          : ');
        readln(cod_pro);
        if (cod_pro <> -1) then
        begin
          write('   Ingrese el nombre del producto          : ');
          readln(nom_pro);
          write('   Ingrese el stock actual del producto    : ');
          readln(stock_actual);
          write('   Ingrese el stock minimo producto        : ');
          readln(stock_minimo);
          write('   Ingrese el precio unitario del producto : ');
          readln(precio_unitario);
       end;
     end;
  end;
 
   procedure insertaprimero(reg_pro : info_productos);
   var
      pt : lista_productos;
    begin
        new(pt);
        pt^.elemen_pro := reg_pro;
        pt^.dirSig_pro := prime;
        prime := pt;
    end;
 
    procedure insertafinal(reg_pro : info_productos);
    var
      pt : lista_productos;
    begin
        new(pt);
        pt^.elemen_pro := reg_pro;
        actual^.dirSig_pro := pt;
        pt^.dirSig_pro := nil;
        actual := pt;
    end;
 
    procedure insertamosporordendebalor(reg_pro : info_productos);
    var
      rr, pp, pt : lista_productos;
      nofin, salir : boolean;
    begin
       if reg_pro.cod_pro <> -1 then
       begin
       if prime = nil then
       begin
         new(actual);
         actual^.elemen_pro := reg_pro;
         prime := actual;
         actual^.dirSig_pro := nil;
       end
     else
       begin
       new(pt);
       pt^.elemen_pro := reg_pro;
       pp := prime;
       rr := prime;
       if pp^.elemen_pro.cod_pro > reg_pro.cod_pro then
       begin
          insertaprimero(reg_pro);
       end
     else
         begin
         salir := false;
         nofin := false;
     repeat
         rr := pp;
         pp := pp^.dirSig_pro;
         if pp^.elemen_pro.cod_pro > reg_pro.cod_pro then
         begin
            salir := true;
            nofin := true;
         end;
     until (pp^.dirSig_pro = nil) or (salir = true);
      if (salir = false) and (nofin = false) then
      begin
         insertafinal(reg_pro);
      end
    else
       begin
          pt^.dirSig_pro := pp;
          rr^.dirSig_pro := pt;
        end;
      end;
    end;
   end;
 end;
 
  procedure listardatos;
    var
      ver : lista_productos;
    begin
       clrscr;
       writeln('  Cidigo   Nombre          Actual   Minimo   Precio');
       ver := prime;
       while ver <> nil do
       begin
          with ver^.elemen_pro do
 writeln('   ',cod_pro,'       ',nom_pro,'             ',stock_actual,'       ',
        stock_minimo,'       ',precio_unitario:0:2);
          ver := ver^.dirSig_pro;
        end;
        writeln;
        writeln('   Pulse Una Tecla');
     end;
 
   procedure insertar_ord_pro(var list_pro : lista_productos;
                                 reg_pro : info_productos);
  var
     nue : lista_productos;
     ant, act : lista_productos;
    begin
      new(nue);
      nue^.elemen_pro := reg_pro;
      nue^.dirSig_pro := nil;
    if (reg_pro.cod_pro < list_pro^.elemen_pro.cod_pro) then
    begin
        nue^.dirSig_pro := list_pro;
        list_pro := nue;
     end
  else
     begin
        act := list_pro;
        ant := act;
     while ((act <> nil) and (reg_pro.cod_pro > act^.elemen_pro.cod_pro)) do
     begin
       ant := act;
       act := act^.dirSig_pro;
     end;
    if (reg_pro.cod_pro < act^.elemen_pro.cod_pro) then
     nue^.dirSig_pro := ant^.dirSig_pro;
     ant^.dirSig_pro := nue;
    end;
  end;
 
 
  begin
      prime := nil;
     while producto.cod_pro <> -1 do
     begin
      leer_info_pro(producto);
      insertamosporordendebalor(producto);
     end;
      listardatos;
      readkey;
  end.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

actualizar un stock con listas.

Publicado por Diego (98 intervenciones) el 20/10/2013 14:38:10
Gracias, pero todavía tengo dudas en el modulo inciso_A, suponiendo que las estructuras estén bien generadas, nose si el modulo inciso_A funcoina bien, porque cuando lo ejecuto me da error, pero no veo claramente porque, De todos modos gracia por decirme el insertar ordenado, voy probar mi insertar ordenado para ver si funciona bien con más casos a ver si funciona bien con todos.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

actualizar un stock con listas.

Publicado por ramon (2072 intervenciones) el 20/10/2013 17:17:59
A ver en el procedimiento encontrar_cod que quieres realizar puesto que aunque lo encuentre no
podrás verlo fuera de el puesto que el ok no puedes tomarlo en el exterior.
Tendrías que ponerlo como función no como procedimiento o sea.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
function encontrar_cod(var list_pro: lista_productos; cod : integer) : boolean;
var
   ok : boolean;
   begin
     ok := false;
   if (list_pro <> nil) then
   while (ok <> true) do
   begin
      if (list_pro^.elemen_pro.cod_pro = cod) then
       ok := true;
       list_pro:= list_pro^.dirSig_pro;
    end;
        encontrar_cod := ok;
  end;

Ahora si puedes saber si existe o no para ejecutar el resto.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
procedure inciso_A(list_pro : lista_productos; list_vent: lista_ventas);
var
cod_actual : integer;
begin
if (list_vent <> nil) then
begin
cod_actual := list_vent^.elemen_vent.cod_pro;
{Sino Esto a qui no hace nada}
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
{de la otra forma seria}
if encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro) = true rhen
begin
{Ejecutamos el resto sino salimos}
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
while (list_vent <> nil) do
begin
while (list_vent^.elemen_vent.cod_pro = cod_actual) do
begin
actualizar_stock(list_pro^.elemen_pro.cod_pro, list_vent^.elemen_vent.cant_vendida);
list_vent := list_vent^.dirSig_vent;
end;
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
cod_actual := list_vent^.elemen_vent.cod_pro;
end;
end
else
    writeln(' No Existe');
end;
end;
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

actualizar un stock con listas.

Publicado por Diego (98 intervenciones) el 20/10/2013 19:54:21
Gracias, voy a revisar bien esa parte, de todos modos, el encontrar_codigo es solamente para avanzar en la lista de productos, se asume que los datos que ingresan los usuarios siempre los ingresan bien,{eso no dijeron de parte de la catedra}, asi que no haria falta indicar si existe o no ese codigo, ya que no se puede vender algo que no existe.
Justo ahora lo estoy empezando a revisar, voy a ver bien en que me estoy equivocando. Quizás me equivoque en la carga de los datos, jajja, ojala sea eso.
Nuevamente gracias. En una horas escribo si lo resolví o sigo con el problema.
Gracias.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar

actualizar un stock con listas.

Publicado por Diego (98 intervenciones) el 20/10/2013 21:49:50
Gracias, ya lo acabo de resolver, modularizé un poco más para darme cuenta de los errores, parece que cuando tenia que actualizar porque era el mismo codigo, no verificaba si al avanzar en la lista de ventas llegué a nil, tambien como pascal es de respuesta rapida,en la conjunción pirmero tenia que poner en la lista de ventas sea diferente de nil y luego que los codigos sean iguales.
Lo arreglé haciendo estos modulos:


procedure encontrar_cod(var list_pro: lista_productos; cod : integer);
begin
if (list_pro <> nil) then
while (list_pro^.elemen_pro.cod_pro <> cod) do
list_pro:= list_pro^.dirSig_pro;
end;
procedure actualizar_stock(var stock_actual : integer; ventas: integer);
begin
stock_actual := stock_actual - ventas;
end;
procedure avanzar_lista_ventas(var list : lista_ventas);
begin
list := list^.dirSig_vent;
end;
procedure inciso_A(list_pro : lista_productos; list_vent: lista_ventas);
var
cod_actual : integer;
begin
if (list_pro <> nil) then
while (list_vent <> nil) do
begin
encontrar_cod(list_pro, list_vent^.elemen_vent.cod_pro);
cod_actual := list_pro^.elemen_pro.cod_pro;
while ((list_vent <> nil) and (list_vent^.elemen_vent.cod_pro = cod_actual)) do
begin
actualizar_stock(list_pro^.elemen_pro.stock_actual, list_vent^.elemen_vent.cant_vendida);
avanzar_lista_ventas(list_vent);
end;
end;
end;
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar