Es una EMERGENCIA!
Me llamo Anllys, soy de Venezuela, estudio ingeniería de sistema y necesito ayuda acerca de un programa en Pascal, si me pueden ayudar se lo sabre agradecer, por favor y gracias de antemano.
Este es el trabajo que necesito:
"Cargue los elementos de un vector de 100 posiciones con números enteros, generados en forma aleatoria y con valores en un rango entre 1 y 1000.
Además debe manejar tres pilas A, B y C las cuales se van a llenar de la siguiente manera:
-La pila A con todos aquellos valores que divididos entre 2 den como resultado un número entero.
-La pila B con todos aquellos valores que divididos entre 5 sea su resultado un número entero y
-La pila C con todos aquellos valores que divididos entre 3 ó 7 sea, de igual manera su resultado un número entero.
Si existe un valor que aplique para llenar más de una pila se colocará dicho valor en las pilas donde aplique.
Como los valores son generados aleatoriamente se puede dar el caso que se genere el mismo número más de una vez, por lo que al final de cargadas las pilas se deberá chequear que no existan valores repetidos en las pilas, en tal caso, estos deben eliminarse.
Implante un algoritmo en Pascal que resuelva el problema planteado, e imprima las pilas resultantes y los valores eliminados si los hubo. Recuerde hacer uso de las pilas.
Y este otro caso, de verdad necesito ayuda por favor.
Especificaciones:
Dadas las expresiones
A=Z+X-Y*V
B=Z*(X+Z)/Y
C=X/Y+Z/Y-V/Z
Donde V y Z son constantes con los valores 500 y 1000 respectivamente y POR y Y son variables con los valores siguientes:
Para POR desde 2 hasta 1000 tomando únicamente los valores pares y para Y desde 1000 hasta 2 tomando de igual manera los pares, queriendo decir con esto que los valores de POR se irán incrementando y los valores de Y se irán incrementando.
En base a lo planteado, diseñe un algoritmo en pascal que obtenga los resultados de A, B, C para cada valor que tomarán las variables POR y Y haciendo uso de una función y/o procedimiento recursivo.
Los resultados deben tener como máximo tres decimales.
Ayúdenme que lo necesito, por favor.
-
Este es el trabajo que necesito:
"Cargue los elementos de un vector de 100 posiciones con números enteros, generados en forma aleatoria y con valores en un rango entre 1 y 1000.
Además debe manejar tres pilas A, B y C las cuales se van a llenar de la siguiente manera:
-La pila A con todos aquellos valores que divididos entre 2 den como resultado un número entero.
-La pila B con todos aquellos valores que divididos entre 5 sea su resultado un número entero y
-La pila C con todos aquellos valores que divididos entre 3 ó 7 sea, de igual manera su resultado un número entero.
Si existe un valor que aplique para llenar más de una pila se colocará dicho valor en las pilas donde aplique.
Como los valores son generados aleatoriamente se puede dar el caso que se genere el mismo número más de una vez, por lo que al final de cargadas las pilas se deberá chequear que no existan valores repetidos en las pilas, en tal caso, estos deben eliminarse.
Implante un algoritmo en Pascal que resuelva el problema planteado, e imprima las pilas resultantes y los valores eliminados si los hubo. Recuerde hacer uso de las pilas.
Y este otro caso, de verdad necesito ayuda por favor.
Especificaciones:
Dadas las expresiones
A=Z+X-Y*V
B=Z*(X+Z)/Y
C=X/Y+Z/Y-V/Z
Donde V y Z son constantes con los valores 500 y 1000 respectivamente y POR y Y son variables con los valores siguientes:
Para POR desde 2 hasta 1000 tomando únicamente los valores pares y para Y desde 1000 hasta 2 tomando de igual manera los pares, queriendo decir con esto que los valores de POR se irán incrementando y los valores de Y se irán incrementando.
En base a lo planteado, diseñe un algoritmo en pascal que obtenga los resultados de A, B, C para cada valor que tomarán las variables POR y Y haciendo uso de una función y/o procedimiento recursivo.
Los resultados deben tener como máximo tres decimales.
Ayúdenme que lo necesito, por favor.
-
1 respuesta
Respuesta de josephoenix
1
Para el primer problema, la solución sería esta:
Program prueba;
Uses
crt, tadpila;
Const
MAX = 100;
Type
Vector = array[1..MAX] of integer;
Var
vec: Vector;
pila1, pila2, pila3: TipoPila;
Procedure Generar_Vector(var v: vector);
{Genera aleatoriamente un vector de numeros enteros}
var
i: integer;
begin
randomize;
for i:= 1 to MAX do
v:= random(1000) + 1;{Se genera un numero aleatorio entre 1 y 1000}
end;
Procedure Generar_Pilas(var p1, p2, p3: TipoPila; v: vector);
{Clasifica los elementos del vector, y los coloca en sus respectivas pilas}
var
i: integer;
begin
Inicializar(p1);
Inicializar(p2);
Inicializar(p3);
for i:= 1 to MAX do
begin
if (v mod 2) = 0 then Adicionar(p1, v);
if (v mod 5) = 0 then Adicionar(p2, v);
if ((vmod 3)=0)or((vmod 7)=0) then Adicionar(p3, v);
end;
end;
Procedure Imprimir_Pila(p: TipoPila);
{Imprime los elementos de la pila, y aquellos que han sido eliminados, por se repetidos}
var
pila_aux: TipoPila;{En esta pila se almacenaran los valores repetidos}
top: integer;
begin
Inicializar(pila_aux);
While not Vacia(p) do
begin
top:= tope(p);
Eliminar_Tope(p);
If not Esta(pila_aux, top) then write(top,' '); {Verifico que no sea un elemento repetido}
If Esta(p, top) then Adicionar(pila_aux, top);{Si esta repetido entonces lo agrego en la pila de repetidos}
end;
writeln;
writeln('ELEMENTOS ELIMINADOS');
While not Vacia(pila_aux) do
begin
write(Tope(pila_aux),' ');
Eliminar_Tope(pila_aux);
end;
Destruir(pila_aux);
end;
Procedure Imprimir_Vector(v: vector);
{Imprimer los elementos del vector generado aleatoriamente}
var
i: integer;
begin
for i:= 1 to MAX do
write(v,' ');
writeln;
end;
Begin {PROGRAMA PRINCIPAL}
clrscr;
Generar_Vector(vec);
Generar_Pilas(pila1, pila2, pila3, vec);
writeln('VECTOR DE ',MAX,' POSICIONES CON NUMEROS GENERADOS ALEATORIAMENTE');
Imprimir_Vector(vec); writeln;
writeln('ELEMENTOS DE LA PILA A');
Imprimir_Pila(pila1); writeln;
writeln('ELEMENTOS DE LA PILA B');
Imprimir_Pila(pila2); writeln;
writeln('ELEMENTOS DE LA PILA C');
Imprimir_Pila(pila3);
readln;
Destruir(pila1); Destruir(pila2); Destruir(pila3);
end.
ESTA ES LA UNIDAD TADPILA
UNIT TADPila;
INTERFACE
{ESTRUCTURA DE DATOS}
Const MAX_ELEM = 100;
Type
arreglo = array[1..MAX_ELEM] of integer;
TipoPila = ^Nodo;
Nodo = record
info: arreglo;
tope: integer;
end;
{OPERACIONES}
{CONSTRUCTORA}
Procedure Inicializar(var p: TipoPila);
{Inicializa la pila como vacia}
{MODIFICADORAS}
Procedure Adicionar(var p: TipoPila; elem: integer);
{Coloca el elemento elem sobre el tope de la pila}
Procedure Eliminar_Tope(var p: TipoPila);
{Elimina el elemento que se encuentra en el tope de la pila}
{ANALIZADORAS}
Function Tope(p: TipoPila): integer;
{Devuelve el elemento que se encuentra en el tope de la pila}
Function Vacia(p: TipoPila): boolean;
{Informa si la pila esta vacia}
Function Esta(p: TipoPila; elem: integer): boolean;
{Informa si "elem" se encuentra en la pila}
{DESTRUCTORA}
Procedure Destruir(var p: TipoPila);
{Destruye la pila, recuperando la memoria que antes ocupaba}
IMPLEMENTATION
Procedure Inicializar(var p: TipoPila);
begin
new(p);
p^.tope:= 0;
end;
Procedure Adicionar(var p: TipoPila; elem: integer);
begin
p^.tope:= p^.tope + 1;
p^.info[p^.tope]:= elem;
end;
Procedure Eliminar_Tope(var p: TipoPila);
begin
p^.tope:= p^.tope - 1;
end;
Function Tope(p: TipoPila): integer;
begin
Tope:= p^.info[p^.tope];
end;
Function Vacia(p: Tipopila): boolean;
begin
Vacia:= p^.tope = 0;
end;
Function Esta(p: TipoPila; elem: integer): boolean;
var
i: integer;
begin
if p^.tope =
Program prueba;
Uses
crt, tadpila;
Const
MAX = 100;
Type
Vector = array[1..MAX] of integer;
Var
vec: Vector;
pila1, pila2, pila3: TipoPila;
Procedure Generar_Vector(var v: vector);
{Genera aleatoriamente un vector de numeros enteros}
var
i: integer;
begin
randomize;
for i:= 1 to MAX do
v:= random(1000) + 1;{Se genera un numero aleatorio entre 1 y 1000}
end;
Procedure Generar_Pilas(var p1, p2, p3: TipoPila; v: vector);
{Clasifica los elementos del vector, y los coloca en sus respectivas pilas}
var
i: integer;
begin
Inicializar(p1);
Inicializar(p2);
Inicializar(p3);
for i:= 1 to MAX do
begin
if (v mod 2) = 0 then Adicionar(p1, v);
if (v mod 5) = 0 then Adicionar(p2, v);
if ((vmod 3)=0)or((vmod 7)=0) then Adicionar(p3, v);
end;
end;
Procedure Imprimir_Pila(p: TipoPila);
{Imprime los elementos de la pila, y aquellos que han sido eliminados, por se repetidos}
var
pila_aux: TipoPila;{En esta pila se almacenaran los valores repetidos}
top: integer;
begin
Inicializar(pila_aux);
While not Vacia(p) do
begin
top:= tope(p);
Eliminar_Tope(p);
If not Esta(pila_aux, top) then write(top,' '); {Verifico que no sea un elemento repetido}
If Esta(p, top) then Adicionar(pila_aux, top);{Si esta repetido entonces lo agrego en la pila de repetidos}
end;
writeln;
writeln('ELEMENTOS ELIMINADOS');
While not Vacia(pila_aux) do
begin
write(Tope(pila_aux),' ');
Eliminar_Tope(pila_aux);
end;
Destruir(pila_aux);
end;
Procedure Imprimir_Vector(v: vector);
{Imprimer los elementos del vector generado aleatoriamente}
var
i: integer;
begin
for i:= 1 to MAX do
write(v,' ');
writeln;
end;
Begin {PROGRAMA PRINCIPAL}
clrscr;
Generar_Vector(vec);
Generar_Pilas(pila1, pila2, pila3, vec);
writeln('VECTOR DE ',MAX,' POSICIONES CON NUMEROS GENERADOS ALEATORIAMENTE');
Imprimir_Vector(vec); writeln;
writeln('ELEMENTOS DE LA PILA A');
Imprimir_Pila(pila1); writeln;
writeln('ELEMENTOS DE LA PILA B');
Imprimir_Pila(pila2); writeln;
writeln('ELEMENTOS DE LA PILA C');
Imprimir_Pila(pila3);
readln;
Destruir(pila1); Destruir(pila2); Destruir(pila3);
end.
ESTA ES LA UNIDAD TADPILA
UNIT TADPila;
INTERFACE
{ESTRUCTURA DE DATOS}
Const MAX_ELEM = 100;
Type
arreglo = array[1..MAX_ELEM] of integer;
TipoPila = ^Nodo;
Nodo = record
info: arreglo;
tope: integer;
end;
{OPERACIONES}
{CONSTRUCTORA}
Procedure Inicializar(var p: TipoPila);
{Inicializa la pila como vacia}
{MODIFICADORAS}
Procedure Adicionar(var p: TipoPila; elem: integer);
{Coloca el elemento elem sobre el tope de la pila}
Procedure Eliminar_Tope(var p: TipoPila);
{Elimina el elemento que se encuentra en el tope de la pila}
{ANALIZADORAS}
Function Tope(p: TipoPila): integer;
{Devuelve el elemento que se encuentra en el tope de la pila}
Function Vacia(p: TipoPila): boolean;
{Informa si la pila esta vacia}
Function Esta(p: TipoPila; elem: integer): boolean;
{Informa si "elem" se encuentra en la pila}
{DESTRUCTORA}
Procedure Destruir(var p: TipoPila);
{Destruye la pila, recuperando la memoria que antes ocupaba}
IMPLEMENTATION
Procedure Inicializar(var p: TipoPila);
begin
new(p);
p^.tope:= 0;
end;
Procedure Adicionar(var p: TipoPila; elem: integer);
begin
p^.tope:= p^.tope + 1;
p^.info[p^.tope]:= elem;
end;
Procedure Eliminar_Tope(var p: TipoPila);
begin
p^.tope:= p^.tope - 1;
end;
Function Tope(p: TipoPila): integer;
begin
Tope:= p^.info[p^.tope];
end;
Function Vacia(p: Tipopila): boolean;
begin
Vacia:= p^.tope = 0;
end;
Function Esta(p: TipoPila; elem: integer): boolean;
var
i: integer;
begin
if p^.tope =
