practica 9 ejercicio 1, Pascal

Language: Layout:

program HelloWorld;
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
CONST - Define las constantes para usar en tiempo de compilacion}
const
    FIN = 999;
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
TYPE - Define los tipos creados por el usuario para usar en tiempo 
de compilacion}
type
    lista = ^nodo;
    nodo = record
        datos : integer;
        sig : lista;
    end;
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
VARIABLES GLOBALES - Define variables que se podran usar por todos los modulos
de ser necesarias}
//var
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
AGREGAR ELEMENTO ...}
procedure agregarElemento(var l : lista; n : integer);
var
    nue : lista;
begin
        new (nue);
        nue^.datos := n;
        nue^.sig := l;
        l := nue;
end;

{-----------------------------------------------------------------
CARGAR LISTA ...}
procedure cargarLista(var l: lista);
var
    n : integer;
begin
    l := nil;
    n := random(20)+990;
    while (n <> FIN) do begin
        agregarElemento(l,n);
        n := random(20)+990;
    end;
end;

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
IMPRIMIR LISTA ...}
procedure imprimirLista(l : lista);
begin
    while l^.sig <> nil do begin
        write(l^.datos,' - ');
        l:= l^.sig;
    end;
    write(l^.datos, '.');
end;

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
EJERCICIO A ...}
function ejercicioA(l : lista): integer;
var 
    digitos : integer; // contador de digitos
    num : integer;    // guarda el numero a operar
    cant : integer;   // almacena la cantidad de numeros con 3 digitos
begin     // inicializamos la cantidad: 
    cant := 0;
    // empezamos el recorrido
    while (l <> nil) do begin
        // guardamos el numero e inicializamos digitos
        num := l^.datos;
        digitos := 0;
        // analisis del numero
        while num <>  0 do begin
            digitos := digitos + 1;
            num := num div 10;
        end;
        // verif
        if digitos = 3 then
            cant := cant + 1;
        // pasamos al siguiente numero
        l := l^.sig;    
    end;
    // guardamos el resultado
    ejercicioA := cant;
end;

{-----------------------------------------------------------------
BUSCAR NUMERRO ...}
function buscarNumero (l : lista; num : integer): boolean;
begin
    while (l <> nil)and(l^.datos <> num) do   l := l^.sig;
    if l <> nil then begin buscarNumero := true;
                  end else buscarNumero := false;
end;
{-----------------------------------------------------------------
RECORRER LISTA ...}
procedure recorrerLista(l:lista);
var
    num : integer;
begin
    writeln;
    writeln('-----------------------------------------------------------------');
    writeln('ejercicios : ');
    writeln('la cantidad de numeros con 3 digitos son: ',ejercicioA(l));
    num := random(20)+990;
    writeln('el numero a buscar es ',num);
    writeln('el numero se encuentra en la lista ',buscarNumero(l,num));
end;
{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
LIBERAR LISTA ... }
procedure liberar(var l : lista);
var
    aux : lista;
begin
    while (l <> nil) do begin
        aux := l^.sig;
        dispose(l);
        l:= aux;
    end;
end;
{-----------------------------------------------------------------------------------------------------------------------}

{-----------------------------------------------------------------------------------------------------------------------}
{-----------------------------------------------------------------
PROGRAMA PRINCIPAL}
var
    l : lista;
begin
    randomize;
    
    cargarLista(l);
    
    imprimirLista(l);
    
    recorrerLista(l);
    
    liberar(l);
end.
{-----------------------------------------------------------------------------------------------------------------------}

{
1. *
     Escribir un programa que lea una secuencia de números enteros terminada en 999 y los almacene en una lista simple.
    Utilizando la lista creada implementar:
    a) un módulo que reciba la lista y devuelva como resultado la cantidad de números con 3 dígitos.
    b) un módulo que reciba la lista y un número y determine si dicho número está o no en la lista.
    c) Un módulo que reciba la lista y libere la memoria reservada.
    Consideraciones: la búsqueda debe terminar al encontrar la primera ocurrencia del número buscado. Tenga en cuenta que la lista puede estar vacía.
}

Show compiler warnings [ - ] Show input
Compilation time: 0.22 sec, absolute running time: 0.17 sec, cpu time: 0 sec, memory peak: 5 Mb, absolute service time: 0,61 sec