• Lunes 23 de Diciembre de 2024, 07:58
« anterior próximo »
Páginas: [1]

Autor Tema:  soy tan tonto q no me sale este ej con archivos  (Leído 1495 veces)

tomas_sauron

  • Miembro activo
  • **
  • Mensajes: 56
    • Ver Perfil
soy tan tonto q no me sale este ej con archivos
« en: Domingo 13 de Febrero de 2011, 01:41 »
0
gente necesito ayuda con este programa de pascal...se trata de una aplicacion para solicitudes de autos este es el enunciado estoy practicando para mi final de programacion 1 si alguien me pued ayudar muchas gracias de antemano.....hice casi todo el programa pero no logro q ejecute despues de los ingresos de los datos y ya noc q mas hacer
.- Desarrollar un algoritmo que permita la actualización de un archivo de solicitudes de planes de ahorro para compra de automóviles.

Se cuenta con un archivo secuencial ordenado en forma ascendente por el campo NRO-SOLICITUD donde están registradas todas las solicitudes vigentes. Los registros de este archivo tienen la siguiente estructura:

           REGISTRO-SOLICITUD
NRO-SOLICITUD       entero
TITULAR                     cadena de 40 caracteres
MARCA                       entero (1 a 4)
MODELO                     entero (1 a 3)
COLOR              entero (1 a 8)

 
Y un archivo también secuencial que informa las altas a procesar. Este archivo tiene la misma estructura de registros que el archivo de solicitudes  y también está ordenado en forma ascendente por el campo NRO-SOLICITUD

Se quiere generar un nuevo archivo de solicitudes resultado de efectuar las altas correspondientes. (Este archivo tendrá la misma estructura que el archivo de solicitudes.)
Se podrán rechazar altas  por nro. de solicitud ya existente o por valor inválido en marca, modelo o color. Se listará cada alta rechazada indicando la razón del rechazo.

Al final del proceso se emitirá un informe indicando para cada marca, la cantidad de solicitudes existentes por modelo y color.
También al final del proceso se indicará la cantidad de registros leídos en cada uno de los archivos de entrada, la cantidad de registros grabados en el archivo actualizado, la cantidad de altas  rechazadas.
Código: Pascal
  1. program autos;
  2. uses crt;
  3. type
  4.     tnum=integer;
  5.     tregAlta=record
  6.                  nro:tnum;
  7.                  titular:string[40];
  8.                  marca:tnum;
  9.                  modelo:tnum;
  10.                  color:tnum
  11.             end;
  12.      tregRech=record
  13.                  nro:tnum;
  14.                  titular:string[40];
  15.                  motivo:string[20]
  16.             end;
  17.      tregMarca=record
  18.                     mod1M1,mod2M1,mod3M1:tnum;
  19.                     mod1M2,mod2M2,mod3M2:tnum;
  20.                     mod1M3,mod2M3,mod3M3:tnum;
  21.                     mod1M4,mod2M4,mod3M4:tnum;
  22.                     color1M1,color2M1,color3M1,color4M1,color5M1,color6M1,color7M1,color8M1:tnum;
  23.                     color1M2,color2M2,color3M2,color4M2,color5M2,color6M2,color7M2,color8M2:tnum;
  24.                     color1M3,color2M3,color3M3,color4M3,color5M3,color6M3,color7M3,color8M3:tnum;
  25.                     color1M4,color2M4,color3M4,color4M4,color5M4,color6M4,color7M4,color8M4:tnum;
  26.                 end;
  27.       arAlta=file of tregAlta;
  28.       arRech=file  of tregRech;
  29.       arMarca=file of tregMarca;
  30.  
  31. var
  32.    alta,solic,solic_n:arAlta;
  33.    marca:arMarca;regSol,regAlta:tregAlta;motivo:arRech;
  34.    regMarca:tregMarca;finSol,finAlta,finMarca,finmotivo:boolean;
  35.  
  36.  
  37. procedure ingAlta(var alta:arAlta;var regAlta:tregAlta);
  38. var
  39.    tecla:char;
  40. begin
  41.       assign(alta,'c:userstomasarch_pascalalta.dat');
  42.       rewrite(alta);
  43.       writeln('ingresa datos de altas');
  44.       readln(tecla);
  45.       while(tecla='s')do
  46.          begin
  47.                writeln('ingrese nro de solicitud');readln(regAlta.nro);
  48.               writeln('ingrese titular');readln(regAlta.titular);
  49.               writeln('ingrese marca');readln(regAlta.marca);
  50.               writeln('ingrese modelo');readln(regAlta.modelo);
  51.               writeln('ingrese color');readln(regAlta.color);
  52.               write(alta,regAlta);
  53.               writeln('ingresa mas datos(s/n)');readln(tecla)
  54.          end;
  55.  
  56.        close(alta)
  57. end;
  58. procedure ingSol(var solic:arAlta;var regSol:tregAlta);
  59. var
  60.    tecla:char;
  61. begin
  62.      assign(solic,'c:userstomasarch_pascalsolic.dat');
  63.      rewrite(solic);
  64.      writeln('ingresa datos de solicitud');readln(tecla);
  65.      while(tecla='s')do
  66.        begin
  67.               writeln('ingrese nro de solicitud');readln(regsol.nro);
  68.               writeln('ingrese titular');readln(regSol.titular);
  69.               writeln('ingrese marca');readln(regSol.marca);
  70.               writeln('ingrese modelo');readln(regSol.modelo);
  71.               writeln('ingrese color');readln(regSol.color);
  72.               write(solic,regSol);
  73.               writeln('ingresa mas datos(s/n)');readln(tecla)
  74.          end;
  75.  
  76.        close(solic)
  77. end;
  78. procedure leer_alta(var F:arAlta;var reg:tregAlta;var fin_alta:boolean);
  79.  
  80. begin
  81.      fin_alta:=eof(F);
  82.      if not(fin_alta)then
  83.        read(F,reg)
  84.      else fin_alta:=true
  85. end;
  86. procedure leer_sol(var F:arAlta;var reg:tregAlta;var fin_sol:boolean);
  87.  
  88. begin
  89.      fin_sol:=eof(F);
  90.      if not(fin_sol)then
  91.        read(F,reg)
  92.      else fin_sol:=true
  93. end;
  94. procedure actualizar(var alta,solic,solic_n:arAlta);
  95. var
  96.    regAlta,regSol:tregAlta;
  97. begin
  98.         assign(alta,'c:userstomasarch_pascalalta.dat');
  99.         assign(solic,'c:userstomasarch_pascalsolic.dat');
  100.         assign(solic,'c:userstomasarch_pascalsolic_n.dat');
  101.         reset(alta);reset(solic);rewrite(solic_n);
  102.         leer_sol(solic,regSol,finsol);leer_alta(alta,regAlta,finAlta);
  103.         while(not(finSol))and(not(finAlta))do
  104.            begin
  105.                 if(regSol.nro=regAlta.nro)or(regAlta.marca>4)or(regalta.modelo>3)or(regAlta.color>8)then
  106.                   begin
  107.                        leer_sol(solic,regSol,finsol);
  108.                        leer_alta(alta,regAlta,finalta)
  109.                   end
  110.                 else
  111.                     if(regSol.nro<regAlta.nro)then
  112.                        begin
  113.                             write(solic_n,regSol);
  114.                             leer_sol(solic,regSol,finsol)
  115.                        end
  116.                     else
  117.                        if(regAlta.nro<regSol.nro)and(regAlta.marca<=4)and(regAlta.modelo<=3)and(regAlta.color<=8)then
  118.                           begin
  119.                                write(solic_n,regAlta);
  120.                                leer_alta(alta,regAlta,finalta)
  121.                           end
  122.  
  123.             end;
  124.           close(solic);close(alta);close(solic_n)
  125.  
  126. end;
  127.  
  128. procedure motivo_x_rech(var solic,alta:arAlta;var motivo:arrech);
  129. var
  130.    regAlta,regSol:tregalta;
  131.    regrech:tregrech;
  132. begin
  133.         assign(alta,'c:userstomasarch_pascalalta.dat');
  134.         assign(solic,'c:userstomasarch_pascalsolic.dat');
  135.         assign(motivo,'c:userstomasarch_pascalmotivo.dat');
  136.         reset(alta);reset(solic);rewrite(motivo);
  137.         leer_sol(solic,regSol,finsol);leer_alta(alta,regAlta,finalta);
  138.         while(not(finsol))and(not(finalta))do
  139.           begin
  140.                if(regSol.nro=regAlta.nro)then
  141.                   begin
  142.                        regrech.nro:=regAlta.nro;
  143.                        regrech.titular:=regAlta.titular;
  144.                        regrech.motivo:='solicitud existente';
  145.                        write(motivo,regrech);
  146.                        leer_sol(solic,regsol,finsol);leer_alta(alta,regAlta,finalta)
  147.                   end
  148.                else
  149.                    if(regAlta.marca>4)then
  150.                       begin
  151.                            regrech.nro:=regAlta.nro;
  152.                            regrech.titular:=regAlta.titular;
  153.                            regrech.motivo:='marca invalida';
  154.                            write(motivo,regrech);
  155.                            leer_alta(alta,regAlta,finalta)
  156.                       end
  157.                    else
  158.                        if(regAlta.modelo>3)then
  159.                           begin
  160.                                regrech.nro:=regAlta.nro;
  161.                                regrech.titular:=regAlta.titular;
  162.                                regrech.motivo:='modelo invalida';
  163.                                write(motivo,regrech);
  164.                                leer_alta(alta,regAlta,finalta)
  165.                            end
  166.                        else
  167.                            if(regAlta.color>8)then
  168.                               begin
  169.                                    regrech.nro:=regAlta.nro;
  170.                                    regrech.titular:=regAlta.titular;
  171.                                    regrech.motivo:='color invalido';
  172.                                    write(motivo,regrech);
  173.                                    leer_alta(alta,regAlta,finalta)
  174.                                end
  175.  
  176.                end;
  177.  
  178.              close(solic);close(alta);close(motivo)
  179.  
  180. end;
  181.  
  182. procedure armar_solic(var marca:arMarca;var solic_n:arAlta);
  183. var
  184.     regSol:tregAlta;
  185.     regMarca:tregMarca;
  186. begin
  187.      assign(solic_n,'c:userstomasarchivos_pascalsolic_n.dat');
  188.      assign(marca,'c:userstomasarchivos_pascalmarca.dat');
  189.      reset(solic_n);rewrite(marca);
  190.      with(regMarca)do
  191.         begin
  192.              mod1M1:=0;mod2M2:=0;mod3M3:=0;color1M1:=0;color2M1:=0;
  193.              color3M1:=0;color4M1:=0;color5M1:=0;color6M1:=0;color7M1:=0;
  194.              color8M1:=0;mod1M2:=0;mod2M2:=0;mod3M2:=0;color1M2:=0;color2M2:=0;color3M2:=0;color4M2:=0;
  195.              color5M2:=0;color6M2:=0;color7M2:=0;color8M2:=0;mod1M3:=0;mod2M3:=0;mod3M3:=0;color1M3:=0;
  196.              color2M3:=0;color3M3:=0;color4M3:=0;color5M3:=0;color6M3:=0;color7M3:=0;color8M3:=0;
  197.              mod1M4:=0;mod2M4:=0;mod3M4:=0;color1M4:=0;color2M4:=0;color3M4:=0;color4M4:=0;color5M4:=0;
  198.              color6M4:=0;color7M4:=0;color8M4:=0
  199.         end;
  200.      leer_sol(solic_n,regSol,finSol);
  201.      while(not finSol)do
  202.        begin
  203.         with(regMarca)do
  204.           begin
  205.              if(regSol.marca=1)then
  206.                 begin
  207.                      case(regSol.modelo)of
  208.                         1:inc(mod1M1);
  209.                         2:inc(mod2M1);
  210.                         3:inc(mod3M1)
  211.                      end;
  212.                      case(regSol.color)of
  213.                         1:inc(color1M1);
  214.                         2:inc(color2M1);
  215.                         3:inc(color3M1);
  216.                         4:inc(color4M1);
  217.                         5:inc(color5M1);
  218.                         6:inc(color6M1);
  219.                         7:inc(color7M1);
  220.                         8:inc(color8M1)
  221.                      end;
  222.                      write(marca,regMarca);
  223.                      leer_sol(solic,regSol,finsol)
  224.                   end
  225.              else
  226.                  if(regSol.marca=2)then
  227.                     begin
  228.                          case(regSol.modelo)of
  229.                             1:inc(mod1M2);
  230.                             2:inc(mod2M2);
  231.                             3:inc(mod3M2)
  232.                          end;
  233.                          case(regSol.color)of
  234.                             1:inc(color1M2);
  235.                             2:inc(color2M2);
  236.                             3:inc(color3M2);
  237.                             4:inc(color4M2);
  238.                             5:inc(color5M2);
  239.                             6:inc(color6M2);
  240.                             7:inc(color7M2);
  241.                             8:inc(color8M2)
  242.                          end;
  243.                          write(marca,regMarca);
  244.                          leer_sol(solic_n,regSol,finsol)
  245.                      end
  246.                   else
  247.                       if(regSol.marca=3)then
  248.                          begin
  249.                              case(regSol.modelo)of
  250.                                 1:inc(mod1M3);
  251.                                 2:inc(mod2M3);
  252.                                 3:inc(mod3M3)
  253.                              end;
  254.                              case(regSol.color)of
  255.                                 1:inc(color1M3);
  256.                                 2:inc(color2M3);
  257.                                 3:inc(color3M3);
  258.                                 4:inc(color4M3);
  259.                                 5:inc(color5M3);
  260.                                 6:inc(color6M3);
  261.                                 7:inc(color7M3);
  262.                                 8:inc(color8M3)
  263.                              end;
  264.                              write(marca,regMarca);
  265.                              leer_sol(solic_n,regSol,finsol)
  266.                           end
  267.                         else
  268.                             if(regSol.marca=4)then
  269.                                begin
  270.                                    case(regSol.modelo)of
  271.                                       1:inc(mod1M4);
  272.                                       2:inc(mod2M4);
  273.                                       3:inc(mod3M4)
  274.                                    end;
  275.                                    case(regSol.color)of
  276.                                       1:inc(color1M4);
  277.                                       2:inc(color2M4);
  278.                                       3:inc(color3M4);
  279.                                       4:inc(color4M4);
  280.                                       5:inc(color5M4);
  281.                                       6:inc(color6M4);
  282.                                       7:inc(color7M4);
  283.                                       8:inc(color8M4)
  284.                                    end;
  285.                                    write(marca,regMarca);
  286.                                    leer_sol(solic_n,regSol,finsol)
  287.                                 end
  288.  
  289.  
  290.  
  291.  
  292.           end
  293.  
  294.  
  295.        end;
  296.  
  297.  
  298.      close(solic_n);
  299.      close(marca)
  300.  
  301. end;
  302.  
  303. procedure leer_marca(var marca:arMarca;regMarca:tregMarca;fin:boolean);
  304.  
  305. begin
  306.      fin:=eof(marca);
  307.      if(not(fin))then
  308.        read(marca,regMarca)
  309.      else
  310.         fin:=true
  311. end;
  312. procedure leer_motivo(var motivo:arrech;regrech:tregrech;fin:boolean);
  313.  
  314. begin
  315.      fin:=eof(motivo);
  316.      if(not(fin))then
  317.         read(motivo,regrech)
  318.      else
  319.         fin:=true
  320. end;
  321.  
  322. procedure mostrar_motivo(var motivo:arrech);
  323. var
  324.    regrech:tregrech;
  325. begin
  326.      assign(motivo,'c:userstomasarchivos_pascalmotivo.dat');
  327.      reset(motivo);
  328.      leer_motivo(motivo,regrech,finmotivo);
  329.      while(not(finmotivo))do
  330.         begin
  331.              writeln(regrech.nro:10,regrech.titular:10,regrech.motivo:10);
  332.              leer_motivo(motivo,regrech,finmotivo)
  333.         end;
  334.      close(motivo)
  335. end;
  336.  
  337. procedure mostrar_sol(var marca:arMarca);
  338. var
  339.    regMarca:tregMarca;
  340. begin
  341.      assign(marca,'c:userstomasarchivos_pascalmarca.dat');
  342.      reset(marca);
  343.      leer_marca(marca,regMarca,finMarca);
  344.      while(not(finMarca))do
  345.          begin
  346.               with(regMarca)do
  347.                  begin
  348.                       writeln('marca 1',mod1M1:10,mod2M1:10,mod3M1:10,'':19,color1M1:10,color2M1:10,color3M1:10,color4M1:10,color5M1:10,color6M1:10,color7M1:10,color8M1:10);
  349.                       writeln('marca 2',mod1M2:10,mod2M2:10,mod3M2:10,'':19,color1M2:10,color2M2:10,color3M2:10,color4M2:10,color5M2:10,color6M2:10,color7M2:10,color8M2:10);
  350.                       writeln('marca 3',mod1M3:10,mod2M3:10,mod3M3:10,'':19,color1M3:10,color2M3:10,color3M3:10,color4M3:10,color5M3:10,color6M3:10,color7M3:10,color8M3:10);
  351.                       writeln('marca 4',mod1M4:10,mod2M4:10,mod3M4:10,'':19,color1M4:10,color2M4:10,color3M4:10,color4M4:10,color5M4:10,color6M4:10,color7M4:10,color8M4:10);
  352.                  end;
  353.               leer_marca(marca,regMarca,finMarca)
  354.          end;
  355.  
  356. end;
  357.  
  358. begin
  359.      ingAlta(alta,regAlta);
  360.      ingSol(solic,regSol);
  361.      actualizar(alta,solic,solic_n);
  362.      motivo_x_rech(solic,alta,motivo);
  363.      armar_solic(marca,solic_n);
  364.      mostrar_motivo(motivo);
  365.      mostrar_sol(marca);
  366.      readkey
  367. end.
  368.  
  369.  
  370.  
Páginas: [1]
« anterior próximo »