UNIVERSIDAD PEDAGOGICA NACIONAL
“FRANCISCO MORAZAN”
UPNFM/ sistema cued
ASIGNATURA:
PROGRAMACION II
TEMA:
TAREA PASCAL
CATEDRATICO:
LIC. MARIA LUISA CERRATO
ESTUDIANTE:
EMY REBECA GUERRERO MARTINEZ
REGISTRO:
1501 2006 01391
SEDE:
JUTICALPA
JULIO 2023
1.Cree un programa que muestre una cadena “La paciencia es la madre de todas las
ciencias”, luego debe
mostrar “la madre de todas las ciencias” y por último “la matemática es la madre de
todas las ciencias”.
PROGRAM Ejer_CadenaUno;
var Cad1: string[80];
BEGIN
Cad1:='La paciencia es la madre de todas las ciencias';
writeln('==============Frase original==================');
writeln(Cad1);
delete(Cad1,1,16);
writeln();
writeln('=============Nueva frase recortada============');
writeln(Cad1);
insert('La matematica es ',Cad1,1);
writeln();
writeln('=============Nueva frase aumentada============');
writeln(Cad1);
readln;
END.
2. Cree un programa que contenga tres cadenas, que las una y que al final diga la
siguiente frase: Las
matemáticas no mienten, lo que hay son muchos matemáticos mentirosos.
a. lo que hay son muchos matemáticos
b. mentirosos.
c. Las matemáticas no mienten,
PROGRAM UnirTresCadenas;
var cad1, cad2, cad3, cad4: string[80];
BEGIN
cad1:='lo que hay son muchos matematicos';
cad2:='mentirosos';
cad3:='Las matematicas no mienten,';
cad4:= concat(cad3,' ',cad1,' ',cad2);
writeln('Cadena numero uno');
writeln(cad1);
writeln;
writeln('Cadena numero dos');
writeln(cad2);
writeln;
writeln('Cadena numero tres');
writeln(cad3);
writeln;
writeln('Union de las cadenas');
writeln(cad4);
readln;
END.
3. Escriba un programa que tiene la siguiente cadena: “me gusta la clase de
Programación” y que muestre “ME
gusta LA clase de PROGRAmación”
PROGRAM Ejer_upcase;
var cad1: string[40];
BEGIN
cad1:='me gusta la clase de Programacion';
writeln(cad1);
delete(cad1,1,1);
insert('M',cad1,1);
delete(cad1,23,5);
insert('ROGRA',cad1,23);
writeln(cad1);
readln;
END.
4. Escribir un programa en Pascal que llene un arreglo unidimensional con los números
enteros comprendidos
entre 1 y 20.
PROGRAM Arreglo_Uno_Veinte;
var nums: array[1..20] of integer;
i:integer;
BEGIN
for i:=1 to 20 do
nums[i]:=i;
writeln('El arreglo unidimensional de los numeros entre 1 y 20 ');
for i:=1 to 20 do
writeln(nums[i]);
readln;
END.
5. Escribir un programa en Pascal que llene un arreglo con los números impares
comprendidos entre 60 y 100.
PROGRAM Ejer_Impares;
var nums: array[60..100] of integer;
i: integer;
BEGIN
for i:= 60 to 100 do
nums[i]:= i;
writeln('Numeros impares entre 60 y 100');
for i:= 60 to 100 do
BEGIN
if (i mod 2 <>0) then
writeln(nums[i]);
END;
readln;
END.
6. Escribir un programa en Pascal que llene un arreglo con los números comprendidos
entre 25 y 35 divididos por 3.
PROGRAM Ejer_divisoresdetres;
var nums: array[25..35] of integer;
i:integer;
BEGIN
for i:=25 to 35 do
nums[i] := i;
writeln('Los numeros que se pueden dividir entre tres comprendidos entre 25 y 35 son:');
for i:=25 to 35 do
if (i mod 3 = 0) then
writeln(nums[i]);
readln;
END.
7.Escribir un programa en Pascal que llene un arreglo con los números múltiplos de 5.
El límite de los números debe ser dado por el usuario.
PROGRAM Ejer_multiplosDeCinco;
var Multi:array [1..100] of integer;
i, n: integer;
BEGIN
Write('Ingrese el limite de los multiplos de cinco: ');
readln(n);
for i:=1 to n do
Multi[i]:=i;
Writeln('Los multiplos son los siguientes');
for i:=1 to n do
begin
if (i mod 5 = 0) then
writeln(Multi[i]);
end;
readln;
END.
8. Escribir un programa en Pascal que multiplique por cuatro los elementos de la
siguiente matriz:
11 6 6
10 15 5
PROGRAM Ejer_ocho;
CONST Mat: array [1..2,1..3] of integer =((11,6,6),
(10,15,5));
var i,j,mult,multi:integer;
BEGIN
for i:=1 to 2 do
for j:=1 to 3 do
Mat[i,j]:=Mat[i,j];
//Imprimir la matri
writeln('La matriz original');
for i:=1 to 2 do
BEGIN
for j:=1 to 3 do
write('[',Mat[i,j],']');
writeln;
END;
writeln('La matriz multipliada por 4');
for j:=1 to 3 do
BEGIN
for i:=1 to 2 do
if i=1 then mult:=4*Mat[1,j];
write('[',mult,']');
END;
writeln;
for j:=1 to 3 do
BEGIN
for i:=1 to 2 do
if i=2 then multi:=4*Mat[2,j];
write('[',multi,']');
END;
readln;
END.
9. Escribir un programa en Pascal que sume los datos de cada una de las filas de la
siguiente matriz.
12 3 4 1
17 2 5 6
20 30 40 1
PROGRAM suma_filas;
CONST S: array [1..3,1..4] of integer=((12,3,4,1),(17,2,5,6),(20,30,40,1));
var filas,columnas, suma1, suma2, suma3:integer;
BEGIN
for filas:=1 to 3 do
for columnas:=1 to 4 do
S[filas,columnas]:= S[filas,columnas];
for filas:=1 to 3 do
BEGIN
for columnas:=1 to 4 do
BEGIN
if filas=1 then suma1:=suma1+S[1,columnas];
if filas=2 then suma2:=suma2+S[2,columnas];
if filas=3 then suma3:=suma3+S[3,columnas];
END;
END;
writeln('La suma de la fila 1 es: ',suma1);
writeln('La suma de la fila 2 es: ',suma2);
writeln('La suma de la fila 3 es: ',suma3);
readln;
END.
10.Identifique el número que se encuentra en la posición 3,3 de la matriz anterior y
multiplíquelo por cada uno de
los números que se encuentran en la matriz.
PROGRAM multiplicacion_Escalar;
CONST S: array [1..3,1..4] of integer=((12,3,4,1),(17,2,5,6),(20,30,40,1));
var filas,columnas, mul, mult, multi:integer;
BEGIN
for filas:=1 to 3 do
for columnas:=1 to 4 do
S[filas,columnas]:= S[filas,columnas];
writeln('Matriz de 3x4');
for filas:=1 to 3 do
BEGIN
for columnas:=1 to 4 do
write('[',S[filas,columnas],']');
writeln;
END;
Writeln;
writeln('El numero en la posicion 3,3 es ',S[3,3]);
writeln;
writeln('la multiplicacion por 40');
for columnas:=1 to 4 do
BEGIN
for filas:=1 to 3 do
if filas=1 then mul:=S[3,3]*S[1,columnas];
write(mul,' ');
END;
writeln;
for columnas:=1 to 4 do
BEGIN
for filas:=1 to 3 do
if filas=2 then mult:=S[3,3]*S[2,columnas];
write(mult,' ');
END;
writeln;
for columnas:=1 to 4 do
BEGIN
for filas:=1 to 3 do
if filas=3 then multi:=S[3,3]*S[3,columnas];
write(multi,' ');
END;
readln;
END.
11.Investigar el método de ordenación por burbuja y ordenación por inserción y hacer lo
siguiente:
a. Escribir el programa para cada uno de estos métodos.
Método de ordenación por burbuja:
Program Ordenar;
var
datos: array[1..6] of integer;
i,j: integer;
temporal: integer;
begin
datos[1] := 56;
datos[2] := 9;
datos[3] := 34;
datos[4] := 12;
datos[5] := 41;
datos[6] := 8;
{ Primero mostramos los datos }
writeLn('Los datos iniciales son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
{ Ahora ordenamos mediante burbuja }
for i := 6 downto 2 do
for j := 0 to i - 1 do
if datos[j] > datos[j + 1] then
begin
temporal := datos[j];
datos[j] := datos[j + 1];
datos[j + 1] := temporal;
end;
{ Y mostramos el resultado }
writeLn('Los datos tras ordenar son: ');
for i := 1 to 6 do
write(datos[i], ' ');
writeLn;
end.
Método de ordenación por inserción:
PROCEDURE Inserciondirecta( var v:tvector);
{Efecto. Se ordena ‘v’ ascendentemente}
VAR
i, j:tIntervalo;
aux:telem;
BEGIN
for i:=2 to N do begin
aux:=v[i]
j:=i-1
while (j≥1) and (v[j]>aux) do begin
v[j+1]:=v[j];
j:=j-1
end; {while}
v[j+1]:=aux
end {for}
END;
b. Escribir un breve análisis de cada método.
El método de ordenamiento por burbuja también llamado de intercambio, funciona
revisando cada elemento de la lista que va a ser ordenada con el siguiente elemento del
mismo, realizando intercambios si es requerido. Este método se utiliza para recorrer un
array, comparar elementos y corregir el orden si por algún motivo es incorrecto, y
funciona desplazando el número menor al inicio del array. En el caso del ejemplo
anterior de este método los datos iniciales son: 56, 9, 34, 12, 41, 8 y después de ejecutar
nuestro código tendremos los números ordenados de menor a mayor:. 8, 9, 12, 34, 41,
56.
El método de ordenamiento por inserción permite el ordenamiento de una lista.
Consiste en el recorrido por la lista seleccionando en cada iteración un valor como clave
y compararlo con el resto insertándolo en el lugar correspondiente. En el ejemplo
podemos observar cómo recorre el vector “v” insertando el elemento v[i] en su lugar
correcto entre los ya ordenados.
c. Explicar diferencias entre cada uno de estos métodos.
El método de ordenamiento por burbujas mueve sucesivamente hacia abajo el
valor más grande encontrado, intercambiándolo a través de valores sin clasificar
al lugar correcto junto con valores más grandes y ya ordenados al final de la
matriz.
El orden de inserción mueve sucesivamente cada valor hacia arriba, llevándolo a
través de valores ordenados hasta que alcanza el lugar correcto entre los valores
ya ordenados en la cabecera de la matriz.
El método por burbujas mueve un valor por una serie de intercambios por pares.
La ordenación por inserción elimina otros valores, pero solo escribe un valor
recién ordenado en la sección ordenada una vez que sabe dónde se encuentra
frente a otros valores ordenados hasta ahora.
