PRACTICO U1 Programacion

Practico U1 – POO
Nombre: Bonny Leonardo

Apellido: Arandia Cuellar
Materia: Programación 1 INF- 120
Año: 1-2023
PRACTICO U1 – POO
1. Haga un programa que, dada una constante natural k, imprima los números k naturales
1.1. Análisis:
1.1.1. Abstraer:
* Números Naturales
1.1.2. Identificar:
* Imprimir los primeros k números naturales.

1.2. Diseño:
1.2.1. Diseño Formal:
imprimirNaturales
1.2.2. Diseño Procedimental:
imprimirNaturales : (imprimirNaturales) n=>[ P ]=>?

P/
var
i,k:integer;
begin
write('Ingrese el valor de k: ');
readln(k);
for i:=1 to k do
write(i,' ');
end;
PP/
imprimirNaturales();
1.3. Implementación:
1.3.1. Implementación del programa en Pascal:
Pascal:
program imprimirNaturales;
{$mode objfpc}{$H+}
uses
{$IFDEF UNIX}{$IFDEF UseCThreads}
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils;
var
i,k:integer;
begin
write('Ingrese el valor de k: ');
readln(k);
for i:=1 to k do
write(i,' ');
end.
2. Haga un programa que acepte como entrada un numero natural (n), e imprima los primeros n
naturales.
2.1. Análisis:
2.1.1. Abstraer:
 Número natural
Atributos:
n
Comportamientos:
Imprimir los primeros n naturales
2.2. Diseño: Se tiene el número natural (n) y se debe imprimir los primeros n naturales.

ImprimirNaturales //Imprime los primeros n naturales

ImprimirNaturales : (ImprimirNaturales) n=>[ N ]=>?
P/
i:=1;
while i<=n do
begin
write(i,' ');
i:=i+1;
end;
2.3. Implementación:
2.3.1. Creando el programa
Pascal:
program ImprimirNaturales;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils;
procedure ImprimirNaturales(n:integer);
var
i:integer;
begin
i:=1;
while i<=n do
begin
write(i,' ');
i:=i+1;
end;
end;
var
n:integer;
begin
write('Ingrese un numero natural: ');
readln(n);
ImprimirNaturales(n);
end.
3. Haga un programa que acepte como entrada un numero natural (n), y calcule la suma de los
primeros n naturales.
Análisis:
1.1. Abstraer:
 Suma de los primeros n números naturales
Atributos:
n
Comportamientos:
Calcular suma
1.2. Diseño:

Constructor //Inicializar el atributo con valor por defecto
setN // Fijar un valor en N
getN // Recuperar el valor de N
calcularSuma // Calcular la suma de los primeros N números naturales

Constructor : (crear) ?=>[ C ]=>?
P/
n:=0;
Fijar N : (setN) a=>[ P ]=>?

P/
n:=a;
Obtener N : (getN) ?=>[ F ]=>(int)

P/
retornar n;
Calcular Suma : (calcularSuma) ?=>[ P ]=>(int)

P/
suma:=0;
for i:=1 to n do
begin
suma:=suma+i;
end;
retornar suma;
PP/
//Inicializando la Instancia
sumaN:=SumaNatural.Create();
sumaN.setN(10);
writeln('La suma de los primeros ',sumaN.getN(),' números naturales es: ', sumaN.calcularSuma());
sumaN.setN(5);
Implementación:
2.1. Creando la unidad que contiene la Clase SumaNatural
Pascal:
unit uSumaNatural;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ SumaNatural }
SumaNatural=Class
private
n:integer;
public
constructor Create();
procedure setN(n1:integer);
function getN():integer;
function calcularSuma():integer;
end;
implementation
{ SumaNatural }
constructor SumaNatural.Create();
begin
n:=0;
end;
procedure SumaNatural.setN(n1: integer);
begin
n:=n1;
end;
function SumaNatural.getN(): integer;
begin
result:=n;
end;
function SumaNatural.calcularSuma(): integer;
var
suma,i:integer;
begin
suma:=0;
for i:=1 to n do
begin
suma:=suma+i;
end;
result:=suma;
end;
end.
//Programa Principal
program t1e3;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, uSumaNatural
{ you can add units after this };
var
sumaN:SumaNatural;
begin
sumaN:=SumaNatural.Create();
sumaN.setN(10);
sumaN.setN(5);
end.
4. Haga un programa que acepte como entrada un numero natural (n), e imprima las n primeras letras
del alfabeto (1 <= n <= 26).
Análisis:
1.1. Abstraer:
Imprimir las primeras n letras del alfabeto
Atributos:
n (número natural)
Comportamientos:
imprimir letras del alfabeto
1.2. Diseño:

imprimirLetras // Imprimir las primeras n letras del alfabeto

P/
n:=0;

P/
n:=a;

P/
retornar n;
Imprimir Letras : (imprimirLetras) ?=>[ P ]=>(string)

P/
letras:='';
for i:=1 to n do
begin
letras:=letras+Chr(i+64)+' ';
end;
writeln(letras);
PP/
alfabeto:=Alfabeto.Create();
alfabeto.setN(10);
writeln('Las primeras ',alfabeto.getN(),' letras del alfabeto son: ');
alfabeto.imprimirLetras();
alfabeto.setN(5);
Implementación:
2.1. Creando la unidad que contiene la Clase Alfabeto
Pascal:
unit uAlfabeto;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Alfabeto }
Alfabeto=Class
private
n:integer;
public
function imprimirLetras():string;
end;
implementation
{ Alfabeto }
constructor Alfabeto.Create();
begin
n:=0;
end;
procedure Alfabeto.setN(n1: integer);
begin
n:=n1;
end;
function Alfabeto.getN(): integer;
begin
result:=n;
end;
function Alfabeto.imprimirLetras(): string;
var
letras:string;
i:integer;
begin
letras:='';
for i:=1 to n do
begin
letras:=letras+Chr(i+64)+' ';
end;
result:=letras;
end;
end.
program t1e4;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, uAlfabeto
var
alfabeto:Alfabeto;
begin
alfabeto:=Alfabeto.Create();
alfabeto.setN(10);
alfabeto.setN(5);
end.
5. Haga un programa que acepte como entrada un numero natural (n), si n es par imprima los n primeros
pares sino los n primeros impares.
Análisis:
1.1. Abstraer:
Si n es par, imprimir los primeros n números pares.

Si n es impar, imprimir los primeros n números impares.
Atributos:
n (número natural)
Comportamientos:
imprimir n primeros pares o impares
1.2. Diseño:

imprimirNumeros // Imprimir los primeros n números pares o impares

P/
n:=0;
P/
n:=a;
P/
retornar n;
Imprimir Numeros : (imprimirNumeros) ?=>[ P ]=>(string)

P/
numeros:='';
if (n mod 2 = 0) then
begin
for i:=1 to n do
begin
numeros:=numeros+IntToStr(i2)+' ';
end;
numeros:='Los primeros '+IntToStr(n)+' números pares son: '+numeros;
end
else
begin
for i:=1 to n do
begin
numeros:=numeros+IntToStr((i2)-1)+' ';
end;
numeros:='Los primeros '+IntToStr(n)+' números impares son: '+numeros;
end;
retornar numeros;
PP/
numerosN:=Numeros.Create();
numerosN.setN(10);
writeln(numerosN.imprimirNumeros());
numerosN.setN(5);
writeln(numerosN.imprimirNumeros());
Implementación:
2.1. Creando la unidad que contiene la Clase Numeros:

Pascal:
unit uNumeros;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Numeros }
Numeros=Class
private
n:integer;
public
procedure imprimirNumeros();
end;
implementation
{ Numeros }
constructor Numeros.Create();
begin
n:=0;
end;
procedure Numeros.setN(n1: integer);
begin
n:=n1;
end;
function Numeros.getN(): integer;
begin
result:=n;
end;
procedure Numeros.imprimirNumeros();
var
i:integer;
begin
if (n mod 2 = 0) then // Si n es par, imprimir los n primeros números pares
begin
for i:=1 to n do
begin
writeln(2i);
end;
end
else // Si n es impar, imprimir los n primeros números impares
begin
for i:=1 to n do
begin
writeln(2i-1);
end;
end;
end;
end.
program t1e5;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, uNumeros
var
numeros:Numeros;
begin
numeros:=Numeros.Create();
numeros.setN(10);
numeros.imprimirNumeros();
numeros.setN(5);
numeros.imprimirNumeros();
end.
6. Haga un programa que acepte como entrada dos números NATURALES (n y m) y devuelva como
resultado el producto de n x m, pero simule la operación empleando la suma y no el producto.
Análisis:
1.1. Abstraer:
Operación de multiplicación de dos números naturales empleando la suma.
Atributos:
n (número natural)
m (número natural)
Comportamientos:
Sumar n "m" veces.

1.2. Diseño:
Constructor //Inicializar los atributos con valor por defecto
setN // Fijar un valor en n
setM // Fijar un valor en m
getN // Recuperar el valor de n
getM // Recuperar el valor de m
calcularProducto // Calcular el producto de n y m empleando la suma.

P/
n:=0;
m:=0;

P/
n:=a;
Fijar M : (setM) a=>[ P ]=>?

P/
m:=a;

P/
retornar n;
Obtener M : (getM) ?=>[ F ]=>(int)
P/
retornar m;
Calcular Producto : (calcularProducto) ?=>[ P ]=>(int)
P/
suma:=0;
for i:=1 to m do
begin
suma:=suma+n;
end;
retornar suma;
PP/
producto:=ProductoSuma.Create();
producto.setN(5);
producto.setM(4);
writeln(producto.getN(),'x',producto.getM(),'=',producto.calcularProducto());
producto.setN(3);
producto.setM(2);
writeln(producto.getN(),'x',producto.getM(),'=',producto.calcularProducto());
Implementación:
2.1. Creando la unidad que contiene la Clase ProductoSuma
Pascal:
unit uProductoSuma;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ ProductoSuma }
ProductoSuma=Class
private
n,m:integer;
public
procedure setM(m1:integer);
function getM():integer;
function calcularProducto():integer;
end;
implementation
{ ProductoSuma }
constructor ProductoSuma.Create();
begin
n:=0;
m:=0;
end;
procedure ProductoSuma.setN(n1: integer);
begin
n:=n1;
end;
procedure ProductoSuma.setM(m1: integer);
begin
m:=m1;
end;
function ProductoSuma.getN(): integer;
begin
result:=n;
end;
function ProductoSuma.getM(): integer;
begin
result:=m;
end;
function ProductoSuma.calcularProducto(): integer;
var
suma,i:integer;
begin
suma:=0;
for i:=1 to m do
begin
suma:=suma+n;
end;
result:=suma;
end;
end.
resultado el cociente de n/m, pero simule la operación empleando la resta y no la división.
Análisis:
1.1. Abstraer:
División de dos números naturales utilizando restas
Atributos:
n (número natural)
m (número natural)
Comportamientos:
calcular cociente
1.2. Diseño:
setM // Fijar un valor en M
getM // Recuperar el valor de M
calcularCociente // Calcular el cociente de N/M

P/
n:=0;
m:=0;

P/
n:=a;

P/
retornar n;

P/
m:=a;
Obtener M : (getM) ?=>[ F ]=>(int)

P/
retornar m;
Calcular Cociente : (calcularCociente) ?=>[ P ]=>(real)

P/
cociente:=0;
while n>=m do
begin
n:=n-m;
cociente:=cociente+1;
end;
retornar cociente;
PP/
divR:=DivisionResta.Create();
divR.setN(7);
divR.setM(3);
writeln('El cociente de ',divR.getN(),'/',divR.getM(),' es: ', divR.calcularCociente():0:2);
divR.setN(16);
divR.setM(4);
writeln('El cociente de ',divR.getN(),'/',divR.getM(),' es: ', divR.calcularCociente():0:2);
Implementación:
2.1. Creando la unidad que contiene la Clase DivisionResta
Pascal:
unit uDivisionResta;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ DivisionResta }
DivisionResta = class
private
n, m: integer;
public
procedure setN(n1: integer);
function getN(): integer;
procedure setM(m1: integer);
function getM(): integer;
function calcularCociente(): real;
end;
implementation
{ DivisionResta }
constructor DivisionResta.Create();
begin
n := 0;
m := 0;
end;
procedure DivisionResta.setN(n1: integer);

begin
n := n1;
end;
function DivisionResta.getN(): integer;

begin
Result := n;
end;
procedure DivisionResta.setM(m1: integer);

begin
m := m1;
end;
function DivisionResta.getM(): integer;
begin
Result := m;
end;
function DivisionResta.calcularCociente(): real;

var
cociente: real;
begin
cociente := 0;
while n >= m do
begin
n := n - m;
cociente := cociente + 1;
end;
Result := cociente;
end;
end.
rogram t1e7;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils;
function cociente(n, m: integer): integer;

var
resto, i: integer;
begin
i := 0;
resto := n;
while resto >= m do
begin
resto := resto - m;
i := i + 1;
end;
Result := i;
end;
var
n, m: integer;
begin
Write('Ingrese n: ');
ReadLn(n);
Write('Ingrese m: ');
ReadLn(m);
if m = 0 then
WriteLn('Error: no se puede dividir por cero')
else
WriteLn('El cociente de ', n, ' / ', m, ' es: ', cociente(n, m));
end.
8. Haga un programa que acepte como entrada dos numero ENTEROS (n y m) y devuelva como
resultado el producto de n x m, pero simule la operación empleando la suma y no el producto.
¡CON SIGNO!
Análisis:
1.1. Abstraer:
Producto de dos números enteros (con signo) utilizando solamente sumas
Atributos:
n (número entero con signo)
m (número entero con signo)
Comportamientos:
calcular producto
1.2. Diseño:

calcularProducto // Calcular el producto de N y M utilizando solo sumas

P/
n:=0;
m:=0;

P/
n:=a;
Obtener N : (getN) ?=>[ F ]=>(integer)

P/
retornar n;

P/
m:=a;
Obtener M : (getM) ?=>[ F ]=>(integer)

P/
retornar m;
Calcular Producto : (calcularProducto) ?=>[ P ]=>(integer)

P/
producto:=0;
for i:=1 to abs(n) do
begin
producto:=producto+abs(m);
end;
if ((n<0) and (m>0)) or ((n>0) and (m<0)) then
begin
producto:=-producto;
end;
retornar producto;
PP/
productoEnteros:=ProductoEnteros.Create();
productoEnteros.setN(-3);
productoEnteros.setM(4);
writeln('El producto de ', productoEnteros.getN(), ' y ', productoEnteros.getM(), ' es: ',
productoEnteros.calcularProducto());
productoEnteros.setN(5);
productoEnteros.setM(-2);
writeln('El producto de ', productoEnteros.getN(), ' y ', productoEnteros.getM(), ' es: ',
productoEnteros.calcularProducto());
Implementación:
2.1. Creando la unidad que contiene la Clase ProductoEnteros
Pascal:
unit uProductoEnteros;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ ProductoEnteros }
ProductoEnteros=Class
private
n,m:integer;
producto:integer;
public
function calcularProducto():integer;
end;
implementation
{ ProductoEnteros }
constructor ProductoEnteros.Create();
begin
n := 0;
m := 0;
end;
procedure ProductoEnteros.setN(n1: integer);

begin
n := n1;
end;
procedure ProductoEnteros.setM(m1: integer);

begin
m := m1;
end;
function ProductoEnteros.getN(): integer;

begin
result := n;
end;
function ProductoEnteros.getM(): integer;

begin
result := m;
end;
function ProductoEnteros.calcularProducto(): integer;

var
producto, i: integer;
begin
producto := 0;
for i := 1 to abs(m) do
begin
producto := producto + abs(n);
end;
if ((n < 0) and (m > 0)) or ((n > 0) and (m < 0)) then
begin
producto := -producto;
end;
result := producto;
end;
end.
program t1e8;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils, uProductoEnteros
var
producto: ProductoEnteros;
begin
producto := ProductoEnteros.Create();
producto.setN(5);
producto.setM(4);
writeln('El producto de ', producto.getN(), ' x ', producto.getM(), ' es: ', producto.calcularProducto());
producto.setN(-3);
producto.setM(2);
producto.setN(-6);
producto.setM(-8);
producto.setN(0);
producto.setM(10);
end.
9. Haga un programa que acepte como entrada dos números ENTEROS (n y m) y devuelva como
resultado el cociente de n / m, pero simule la operación empleando la resta y no la división.
¡CON SIGNO!
Análisis:
1.1. Abstraer:
Cociente de dos números enteros (con signo) utilizando solamente restas
Atributos:
n (número entero con signo)
m (número entero con signo)
Comportamientos:
calcular cociente
1.2. Diseño:

calcularCociente // Calcular el cociente de N y M utilizando solo restas

P/
n:=0;
m:=0;

P/
n:=a;

P/
retornar n;

P/
m:=a;

P/
retornar m;
Calcular Cociente : (calcularCociente) ?=>[ P ]=>(integer)

P/
cociente:=0;
if m = 0 then
begin
writeln('Error: División por cero');
end
else
begin
if n = 0 then
begin
cociente:=0;
end
else
begin
begin
cociente:=-1;
end
else
begin
cociente:=1;
end;
n:=abs(n);
m:=abs(m);
while n>=m do
begin
n:=n-m;
cociente:=cociente+1;
end;
begin
cociente:=-cociente;
end;
end;
end;
retornar cociente;
PP/
cocienteEnteros:=CocienteEnteros.Create();
cocienteEnteros.setN(10);
cocienteEnteros.setM(3);
writeln('El cociente de ', cocienteEnteros.getN(), ' y ', cocienteEnteros.getM(), ' es: ',
cocienteEnteros.calcularCociente());
cocienteEnteros.setN(-15);
cocienteEnteros.setM(4);
Implementación:
2.1. Creando la unidad que contiene la Clase CocienteEnteros
Pascal:
unit uCocienteEnteros;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ CocienteEnteros }
CocienteEnteros=Class
private
n,m:integer;
cociente:integer;
public
function calcularCociente():integer;
end;
implementación:
program CocienteEnteros;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils;
type
{ CocienteEnteros }
CocienteEnteros = class
private
n, m: integer;
public
function calcularCociente(): integer;
end;
{ CocienteEnteros }
constructor CocienteEnteros.Create();
begin
n := 0;
m := 0;
end;
procedure CocienteEnteros.setN(n1: integer);

begin
n := n1;
end;
procedure CocienteEnteros.setM(m1: integer);

begin
m := m1;
end;
function CocienteEnteros.getN(): integer;

begin
Result := n;
end;
function CocienteEnteros.getM(): integer;

begin
Result := m;
end;
function CocienteEnteros.calcularCociente(): integer;
var
cociente: integer;
begin
cociente := 0;
if m = 0 then
begin
writeln('Error: División por cero');
end
else
begin
begin
cociente := -1;
end
else
begin
cociente := 1;
end;
n := abs(n);
m := abs(m);
while ((n > 0) and (n >= m)) or ((n < 0) and (n <= m)) do
begin
n := n - m;
cociente := cociente + 1;
end;
begin
cociente := -cociente;
end;
end;
Result := cociente;
end;
var
cocienteEnteros: CocienteEnteros;
n, m: integer;
begin
cocienteEnteros := CocienteEnteros.Create();
writeln('Ingrese dos numeros enteros: ');

readln(n, m);
cocienteEnteros.setN(n);
cocienteEnteros.setM(m);
readln;
end.
resultado n m empleando la multiplicación.
Análisis:
1.1. Abstraer:
Potencia de un número natural utilizando solamente multiplicaciones
Atributos:
n (número natural)
m (número natural)
Comportamientos:
calcular potencia
1.2. Diseño:

calcularPotencia // Calcular la potencia de N elevado a M utilizando solo multiplicaciones

P/
n:=0;
m:=0;

P/
n:=a;

P/
retornar n;

P/
m:=a;

P/
retornar m;
Calcular Potencia : (calcularPotencia) ?=>[ P ]=>(integer)

P/
if m = 0 then
begin
calcularPotencia := 1;
end
else
begin
calcularPotencia := n;
for i := 2 to m do
begin
calcularPotencia := calcularPotencia * n;
end;
end;
retornar calcularPotencia;
PP/
potenciaEnteros:=PotenciaEnteros.Create();
potenciaEnteros.setN(2);
potenciaEnteros.setM(3);
writeln(potenciaEnteros.getN(), ' elevado a la ', potenciaEnteros.getM(), ' es: ',
potenciaEnteros.calcularPotencia());
potenciaEnteros.setN(5);
potenciaEnteros.setM(0);
writeln(potenciaEnteros.getN(), ' elevado a la ', potenciaEnteros.getM(), ' es: ',
potenciaEnteros.calcularPotencia());
Implementación:
2.1. Creando la unidad que contiene la Clase PotenciaEnteros
Pascal:
unit uPotenciaEnteros;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ PotenciaEnteros }
PotenciaEnteros=Class
private
n,m:integer;
public
function calcularPotencia():integer;
end;
implementación:
program PotenciaEnteros;
{$mode objfpc}{$H+}
uses
cthreads,
{$ENDIF}{$ENDIF}
Classes, SysUtils;
type
{ PotenciaEnteros }
PotenciaEnteros = class
private
n, m: integer;
public
function calcularPotencia(): integer;
end;
{ PotenciaEnteros }
constructor PotenciaEnteros.Create();
begin
n := 0;
m := 0;
end;
procedure PotenciaEnteros.setN(n1: integer);

begin
n := n1;
end;
function PotenciaEnteros.getN(): integer;

begin
Result := n;
end;
procedure PotenciaEnteros.setM(m1: integer);

begin
m := m1;
end;
function PotenciaEnteros.getM(): integer;

begin
Result := m;
end;
function PotenciaEnteros.calcularPotencia(): integer;

var
i: integer;
pot: integer;
begin
pot := 1;
for i := 1 to m do
pot := pot * n;
Result := pot;
end;
var
pe: PotenciaEnteros;
potencia: integer;
begin
pe := PotenciaEnteros.Create();
pe.setN(2);
pe.setM(4);
potencia := pe.calcularPotencia();
writeln(potencia);
readln;
end.
11. Haga un programa que acepte como entrada un numero naturales y devuelva como resultado n
m empleando la suma. ¿Puede emplear algo de lo ya hecho?
Análisis:
1.1. Abstraer:
Suma de potencias de un número natural
Atributos:
n (número natural)
m (número natural)
Comportamientos:
calcular suma de potencias
1.2. Diseño:

calcularSumaPotencias // Calcular la suma de potencias de N hasta M utilizando solo sumas

P/
n:=0;
m:=0;

P/
n:=a;

P/
retornar n;

P/
m:=a;

P/
retornar m;
Calcular Suma de Potencias : (calcularSumaPotencias) ?=>[ P ]=>(integer)

P/
sum := 0;
for i := 0 to m do
begin
sum := sum + potencia(n, i);
end;
retornar sum;
Función Potencia : (potencia) (n:integer, m:integer) ?=>[ F ]=>(integer)

P/
if m = 0 then
begin
potencia := 1;
end
else
begin
potencia := n;
for i := 2 to m do
begin
potencia := potencia * n;
end;
end;
PP/
potenciaSuma:=PotenciaSuma.Create();
potenciaSuma.setN(2);
potenciaSuma.setM(3);
writeln('La suma de potencias de ', potenciaSuma.getN(), ' hasta ', potenciaSuma.getM(), ' es: ',
potenciaSuma.calcularSumaPotencias());
potenciaSuma.setN(3);
potenciaSuma.setM(2);
writeln('La suma de potencias de ', potenciaSuma.getN(), ' hasta ', potenciaSuma.getM(), ' es: ',
potenciaSuma.calcularSumaPotencias());
Implementación:
2.1. Creando la unidad que contiene la Clase PotenciaSuma
Pascal:
unit uPotenciaSuma;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ PotenciaSuma }
PotenciaSuma = class
private
n, m: integer;
public
function calcularPotencia(): integer;
end;
implementation
{ PotenciaSuma }
constructor PotenciaSuma.Create();
begin
n := 0;
m := 0;
end;
procedure PotenciaSuma.setN(n1: integer);

begin
n := n1;
end;
function PotenciaSuma.getN(): integer;

begin
Result := n;
end;
procedure PotenciaSuma.setM(m1: integer);

begin
m := m1;
end;
function PotenciaSuma.getM(): integer;

begin
Result := m;
end;
function PotenciaSuma.calcularPotencia(): integer;

var
i, pot: integer;
begin
pot := n;
for i := 2 to m do
pot := pot + n;
Result := pot;
end;
end.
12. Haga un programa que acepte como entrada don números NATURALES (n y b, con 2 < b < 9) y
convierta el numero n al correspondiente numero en base b. recuerde que un numero puede
representarse con el siguiente polinomio:
n
S di ‘ b
i-1 donde di es el i-esimo digito del numero y b es la base.
i=1
Análisis:
1.1. Abstraer:
Convertir un número natural en una base dada a otra base utilizando polinomios
Atributos:
n (número natural): número a convertir
baseOrigen (número natural): base del número a convertir
baseDestino (número natural): base a la que se desea convertir el número
Comportamientos:
convertirBase: convierte el número a la nueva base
1.2. Diseño:

setBaseOrigen // Fijar un valor en BaseOrigen
getBaseOrigen // Recuperar el valor de BaseOrigen
setBaseDestino // Fijar un valor en BaseDestino
getBaseDestino // Recuperar el valor de BaseDestino
convertirBase // Convertir el número a la nueva base

P/
n:=0;
baseOrigen:=0;
baseDestino:=0;

P/
n:=a;

P/
retornar n;
Fijar Base Origen : (setBaseOrigen) a=>[ P ]=>?

P/
baseOrigen:=a;
Obtener Base Origen : (getBaseOrigen) ?=>[ F ]=>(integer)

P/
retornar baseOrigen;
Fijar Base Destino : (setBaseDestino) a=>[ P ]=>?

P/
baseDestino:=a;
Obtener Base Destino : (getBaseDestino) ?=>[ F ]=>(integer)

P/
retornar baseDestino;
Convertir Base : (convertirBase) ?=>[ P ]=>(string)

P/
digito:='';
i:=0;
while n > 0 do
begin
i:=i+1;
digito:=IntToStr(n mod baseDestino) + digito;
n:=n div baseDestino;
end;
convertirBase:=digito;
PP/
conversor:=Conversor.Create();
conversor.setN(156);
conversor.setBaseOrigen(10);
conversor.setBaseDestino(2);
writeln(conversor.getN(), ' en base ', conversor.getBaseOrigen(), ' es: ', conversor.convertirBase(), ' en base
', conversor.getBaseDestino());
Implementación:
2.1. Creando la unidad que contiene la Clase Conversor
Pascal:
unit uConversor;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Conversor }
Conversor=Class
private
n,baseOrigen,baseDestino:integer;
public
procedure setBaseOrigen(base1:integer);
function getBaseOrigen():integer;
procedure setBaseDestino(base2:integer);
function getBaseDestino():integer;
function convertirBase():string;
end;
implementation
{ Conversor }
constructor Conversor.Create();
begin
n := 0;
b := 0;
end;
procedure Conversor.setN(n1: integer);

begin
n := n1;
end;
function Conversor.getN(): integer;

begin
Result := n;
end;
procedure Conversor.setB(b1: integer);

begin
b := b1;
end;
function Conversor.getB(): integer;

begin
Result := b;
end;
function Conversor.ConvertirABaseB(): string;

var
cociente, resto, i: integer;
resultado: string;
begin
cociente := n;
while cociente > 0 do
begin
resto := cociente mod b;
cociente := cociente div b;
resultado := IntToStr(resto) + resultado;
end;
Result := resultado;
end;
var
conv: Conversor;
num, base: integer;
begin
conv := Conversor.Create();
writeln('Ingrese un número natural:');

readln(num);
conv.setN(num);
writeln('Ingrese una base (entre 2 y 9):');

readln(base);
while (base <= 2) or (base >= 9) do
begin
writeln('La base debe estar entre 2 y 9, ingrese nuevamente:');
readln(base);
end;
conv.setB(base);
writeln('El número ', num, ' convertido a base ', base, ' es: ', conv.ConvertirABaseB());
readln;
end.
13. Haga un programa que acepte como entrada tres caracteres que deben ser algunos de los dígitos del
cero al nueve, y los convierta en el correspondiente número de tres dígitos y lo imprima. (Ejemplo:
sean los caracteres 3, 7, 5; deben ser convertidos en el número 375).
Análisis:
1.1. Abstraer:
Convertir tres caracteres que representan dígitos del 0 al 9 en su correspondiente número de tres dígitos
Atributos:
char1 (carácter): primer dígito a convertir
char2 (carácter): segundo dígito a convertir
char3 (carácter): tercer dígito a convertir
Comportamientos:
convertirNumeros: convierte los tres caracteres en su correspondiente número de tres dígitos
1.2. Diseño:

setChar1 // Fijar un valor en char1
getChar1 // Recuperar el valor de char1
convertirNumeros // Convertir los caracteres en su correspondiente número de tres dígitos

P/
char1 := '0';
char2 := '0';
char3 := '0';
Fijar Char1 : (setChar1) c1=>[ P ]=>?

P/
char1 := c1;
Obtener Char1 : (getChar1) ?=>[ F ]=>(char)

P/
retornar char1;

P/
char2 := c2;

P/
retornar char2;

P/
char3 := c3;

P/
retornar char3;
Convertir Numeros : (convertirNumeros) ?=>[ P ]=>(integer)

P/
convertirNumeros := StrToInt(char1 + char2 + char3);
PP/
conversor.setChar1('3');
writeln('Los caracteres ', conversor.getChar1(), conversor.getChar2(), conversor.getChar3(), ' representan el
número ', conversor.convertirNumeros());
Implementación:
Pascal:
unit uConversor;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Conversor }
Conversor=Class
private
char1,char2,char3:char;
public
procedure setChar1(c1:char);
function getChar1():char;
function convertirNumeros():integer;
end;
implementation
{ Conversor }
begin
char1 := '0';
char2 := '0';
char3 := '0';
end;
procedure Conversor.setChar1(c1: char);

begin
char1 := c1;
end;
function Conversor.getChar1(): char;

begin
begin
n := 0;
baseOrigen := 0;
baseDestino := 0;
end;

begin
n := n1;
end;

begin
Result := n;
end;
procedure Conversor.setBaseOrigen(base1: integer);

begin
baseOrigen := base1;
end;
function Conversor.getBaseOrigen(): integer;

begin
Result := baseOrigen;
end;
procedure Conversor.setBaseDestino(base2: integer);
begin
baseDestino := base2;
end;
function Conversor.getBaseDestino(): integer;

begin
Result := baseDestino;
end;
function Conversor.convertirBase(): string;

var
digito: string;
i: integer;
begin
digito := '';
i := 0;
while n > 0 do
begin
i := i + 1;
digito := IntToStr(n mod baseDestino) + digito;
n := n div baseDestino;
end;
convertirBase := digito;
end;
var
conv: Conversor;
a, b, c: char;
begin
writeln('Ingrese tres caracteres que sean dígitos del cero al nueve:');
readln(a, b, c);
while not(a in ['0'..'9']) or not(b in ['0'..'9']) or not(c in ['0'..'9']) do

begin
writeln('Debe ingresar tres caracteres que sean dígitos del cero al nueve:');
readln(a, b, c);
end;
conv.setN(StrToInt(a + b + c));
conv.setBaseOrigen(10);
conv.setBaseDestino(10);
writeln('El número ingresado es: ', conv.getN());

writeln('El número convertido a la misma base es: ', conv.convertirBase());
readln;
end.
14. Haga un programa que acepte como entrada tres caracteres, que deben ser algunos de los dígitos
del cero al nueve, y opcionalmente un carácter que represente un signo (+ o -) y los convierta en el
correspondiente número de tres dígitos y lo imprima. (Ejemplo: sean los caracteres + 3, 7, 5; deben
ser convertidos en el número +375).
program ConvertirDigitos;
var
dig1, dig2, dig3, signo: char;
num: integer;
begin
writeln('Ingrese tres dígitos del cero al nueve: ');
readln(dig1, dig2, dig3);
num := (ord(dig1) - ord('0')) * 100 + (ord(dig2) - ord('0')) * 10 + (ord(dig3) - ord('0'));
writeln('El número correspondiente es: ', num);
writeln('Ingrese un signo (+ o -) opcionalmente: ');
readln(signo);
if signo = '+' then
writeln('El número completo es: ', num)
else if signo = '-' then
writeln('El número completo es: -', num)
else
writeln('El signo ingresado no es válido.');
end.
15. Haga un programa que acepte como entrada uno más, pero no más de cinco caracteres, que deben
ser algunos de los dígitos del cero al nueve, y opcionalmente un carácter que represente un signo (+
o -) y los convierta en el correspondiente numero y lo imprima. (Ejemplo: sean los caracteres – 1, 3,
0, 7, 5; deben ser convertidos en el numero -13075). Tenga en cuenta que el máximo entero es
32767 y el menor – 32768.
program ConvertirNumero;
uses crt;
var
input: string;
numero, i, signo: integer;
begin
writeln('Ingrese los caracteres del numero:');
readln(input);
// verificar si hay signo y obtener el número correspondiente

if (input[1] = '+') or (input[1] = '-') then
begin
signo := 1;
if input[1] = '-' then
signo := -1;
input := copy(input, 2, length(input)-1);

end
else
signo := 1;
// convertir caracteres a número

numero := 0;
for i := 1 to length(input) do
begin
if (input[i] >= '0') and (input[i] <= '9') then
numero := numero * 10 + ord(input[i]) - ord('0')
else
writeln('Caracter no válido: ', input[i]);
end;
// aplicar signo
numero := numero * signo;
// imprimir resultado
writeln('El número convertido es: ', numero);
readkey;
end.
16. Realice el programa de la calculadora para que puedan entrarse dos ENTEROS y un OPERADOR, y
devuelva el resultado de la operación.
Análisis:
1.1. Abstraer:
Realizar operaciones aritméticas básicas (suma, resta, multiplicación, división) entre dos números
enteros
Atributos:
n1 (número entero): primer número de la operación
n2 (número entero): segundo número de la operación
operador (carácter): operador aritmético a utilizar (+,-,*,/)
Comportamientos:
realizarOperacion: realiza la operación aritmética entre los dos números
1.2. Diseño:

setN1 // Fijar un valor en N1
getN1 // Recuperar el valor de N1
setN2 // Fijar un valor en N2
getN2 // Recuperar el valor de N2
setOperador // Fijar un valor en Operador
getOperador // Recuperar el valor de Operador
realizarOperacion // Realizar la operación aritmética entre N1 y N2

P/
n1 := 0;
n2 := 0;
operador := '+';
Fijar N1 : (setN1) a=>[ P ]=>?

P/
n1 := a;
Obtener N1 : (getN1) ?=>[ F ]=>(integer)

P/
retornar n1;
Fijar N2 : (setN2) a=>[ P ]=>?

P/
n2 := a;
Obtener N2 : (getN2) ?=>[ F ]=>(integer)

P/
retornar n2;
Fijar Operador : (setOperador) c=>[ P ]=>?

P/
operador := c;
Obtener Operador : (getOperador) ?=>[ F ]=>(char)

P/
retornar operador;
Realizar Operación : (realizarOperacion) ?=>[ P ]=>(integer)
P/
case operador of
'+': realizarOperacion := n1 + n2;
'-': realizarOperacion := n1 - n2;
'*': realizarOperacion := n1 * n2;
'/': realizarOperacion := n1 div n2;
end;
PP/
calculadora := Calculadora.Create();
calculadora.setN1(10);
calculadora.setN2(5);
calculadora.setOperador('-');
writeln(calculadora.getN1(), ' ', calculadora.getOperador(), ' ', calculadora.getN2(), ' = ',
calculadora.realizarOperacion());
Implementación:
2.1. Creando la unidad que contiene la Clase Calculadora
Pascal:
unit uCalculadora;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Calculadora }
Calculadora = class
private
n1,n2:integer;
operador:char;
public
procedure setN1(a:integer);
function getN1():integer;
procedure setN2(b:integer);
function getN2():integer;
procedure setOperador(c:char);
function getOperador():char;
function realizarOperacion():integer;
end;
implementation
{ Calculadora }
constructor Calculadora.Create();
begin
a := 0;
b := 0;
end;
procedure Calculadora.setA(a1: integer);
begin
a := a1;
end;
function Calculadora.getA(): integer;

begin
Result := a;
end;
procedure Calculadora.setB(b1: integer);

begin
b := b1;
end;
function Calculadora.getB(): integer;

begin
Result := b;
end;
function Calculadora.sumar(): integer;

begin
Result := a + b;
end;
function Calculadora.restar(): integer;

begin
Result := a - b;
end;
function Calculadora.multiplicar(): integer;

begin
Result := a * b;
end;
function Calculadora.dividir(): real;

begin
if b = 0 then
Result := 0
else
Result := a / b;
end;
var
calc: Calculadora;
a, b: integer;
operador: char;
begin
calc := Calculadora.Create();
writeln('Ingrese un número entero:');

readln(a);
calc.setA(a);
writeln('Ingrese otro número entero:');

readln(b);
calc.setB(b);
writeln('Ingrese un operador (+, -, *, /):');
readln(operador);
case operador of
'+': writeln('El resultado es: ', calc.sumar());
'-': writeln('El resultado es: ', calc.restar());
'*': writeln('El resultado es: ', calc.multiplicar());
'/': writeln('El resultado es: ', calc.dividir():0:2);
else
writeln('Operador inválido');
end;
readln;
end.
17. Modifique el programa de la calculadora para que puedan entrarse los números carácter a
carácter, no como tales. Decida cuántos dígitos soportará la calculadora, y de cuantos dígitos
será el resultado.
Análisis:
1.1. Abstraer:
Modificar una calculadora para que los números sean ingresados carácter a carácter, limitando el número
de dígitos a ingresar y el número de dígitos del resultado.
Atributos:
num1 (cadena de caracteres): primer número ingresado
num2 (cadena de caracteres): segundo número ingresado
operacion (carácter): operación a realizar
maxDigitos (número natural): máximo número de dígitos permitidos para ingresar
maxDigitosResultado (número natural): máximo número de dígitos permitidos en el resultado de la
operación
Comportamientos:
setNum1: fija el primer número ingresado
getNum1: retorna el primer número ingresado
setNum2: fija el segundo número ingresado
getNum2: retorna el segundo número ingresado
setOperacion: fija la operación a realizar
getOperacion: retorna la operación a realizar
setMaxDigitos: fija el máximo número de dígitos permitidos para ingresar
getMaxDigitos: retorna el máximo número de dígitos permitidos para ingresar
setMaxDigitosResultado: fija el máximo número de dígitos permitidos en el resultado de la operación
getMaxDigitosResultado: retorna el máximo número de dígitos permitidos en el resultado de la operación
calcular: realiza la operación especificada y retorna el resultado
1.2. Diseño:

setNum1 // Fijar un valor en num1
getNum1 // Recuperar el valor de num1
setOperacion // Fijar un valor en operacion
getOperacion // Recuperar el valor de operacion
setMaxDigitos // Fijar un valor en maxDigitos
getMaxDigitos // Recuperar el valor de maxDigitos
setMaxDigitosResultado // Fijar un valor en maxDigitosResultado
getMaxDigitosResultado // Recuperar el valor de maxDigitosResultado
calcular // Realizar la operación especificada y retornar el resultado

P/
suma:='';
carry:=0;
end;
Ingresar Dígito: (ingresarDigito) dig=>[ P ]=>?

P/
// Si la calculadora ya tiene el número máximo de dígitos, no hace nada.
if Length(suma) >= maxDigitos then Exit;
suma:=dig+suma;
// Si la calculadora tiene el número máximo de dígitos, activa el flag "maximoDígitos"

if Length(suma) = maxDigitos then
begin
maximoDigitos:=true;
end;
Fijar Operación: (fijarOperacion) op=>[ P ]=>?

P/
if (op = '+') or (op = '-') or (op = '*') or (op = '/') then
begin
operacion:=op;
end
else
begin
writeln('Operación inválida.');
end;
Obtener Operación: (obtenerOperacion) ?=>[ F ]=>(string)

P/
retornar operacion;
Calcular: (calcular) ?=>[ P ]=>(string)

P/
if operacion = '+' then
begin
// Si la suma tiene más dígitos que el máximo, acorta la suma para que tenga el mismo número de dígitos
que el resultado
if Length(suma) > digitosResultado then
begin
suma:=Copy(suma,1,digitosResultado);
end;
resultado:=IntToStr(StrToInt(suma)+carry);
end
else if operacion = '-' then
begin
// Si la resta da negativo, setea el resultado a 0 y muestra un mensaje de error
if (StrToInt(suma)+carry) < 0 then
begin
resultado:='0';
writeln('Error: el resultado es negativo.');
end
else
begin
// Si la resta tiene más dígitos que el máximo, acorta la resta para que tenga el mismo número de dígitos
que el resultado
if Length(suma) > digitosResultado then
begin
suma:=Copy(suma,1,digitosResultado);
end;
resultado:=IntToStr(StrToInt(suma)+carry);
end;
end
else if operacion = '*' then
begin
resultado:=IntToStr(StrToInt(suma)*carry);
// Si el resultado tiene más dígitos que el máximo, acorta el resultado para que tenga el mismo número de
dígitos que el resultado
if Length(resultado) > digitosResultado then
begin
resultado:=Copy(resultado,1,digitosResultado);
end;
end
else if operacion = '/' then
begin
// Si el divisor es 0, setea el resultado a 0 y muestra un mensaje de error
if carry = 0 then
begin
resultado:='0';
writeln('Error: división por cero.');
end
else
begin
resultado:=IntToStr(StrToInt(suma) div carry);
end;
end;
// Si el resultado tiene menos dígitos que el máximo, agrega 0s al inicio hasta que tenga el mismo número
de dígitos que el resultado
while Length(resultado) < digitosResultado do
begin
resultado:='0'+resultado;
end;
// Si el resultado tiene más dígitos que el máximo, acorta el resultado para que tenga el mismo número
18. Haga un programa que acepte como entrada un número natural ( n , donde 1<n < 2000 ) y lo
convierta en el correspondiente número romano.
Análisis:
1.1. Abstraer:
Convertir un número natural en notación decimal a notación romana.
Atributos:
n (número natural): número a convertir en notación romana.
Comportamientos:
convertirARomano: convierte el número a notación romana.
1.2. Diseño:

convertirARomano // Convertir el número a notación romana

P/
n:=0;

P/
n:=a;

P/
retornar n;
Convertir a Romano : (convertirARomano) ?=>[ P ]=>(string)

P/
romanos: array[1..13] of string = ('M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I');
decimales: array[1..13] of integer = (1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1);
var i: integer;
resultado: string;
begin
i:=1;
while n > 0 do
begin
if decimales[i] <= n then
begin
n := n - decimales[i];
resultado := resultado + romanos[i];
end
else
i := i + 1;
end;
convertirARomano:=resultado;
end;
PP/
conversor.setN(1998);
writeln(conversor.getN(), ' en notación romana es: ', conversor.convertirARomano());
Implementación:
Pascal:
unit uConversor;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Conversor }
Conversor=Class
private
n:integer;
public
function convertirARomano():string;
end;
implementation
{ Conversor }
begin
n := 0;
end;

begin
n := n1;
end;

begin
Result := n;
end;
function Conversor.convertirARomano(): string;

var
romano: string;
i: integer;
begin
romano := '';
while n > 0 do
begin
if n >= 1000 then
begin
romano := romano + 'M';
n := n - 1000;
end
else if n >= 900 then
begin
romano := romano + 'CM';
n := n - 900;
end
begin
romano := romano + 'D';
n := n - 500;
end
begin
romano := romano + 'CD';
n := n - 400;
end
begin
romano := romano + 'C';
n := n - 100;
end
begin
romano := romano + 'XC';
n := n - 90;
end
begin
romano := romano + 'L';
n := n - 50;
end
begin
romano := romano + 'XL';
n := n - 40;
end
begin
romano := romano + 'X';
n := n - 10;
end
else if n >= 9 then
begin
romano := romano + 'IX';
n := n - 9;
end
else if n >= 5 then
begin
romano := romano + 'V';
n := n - 5;
end
else if n >= 4 then
begin
romano := romano + 'IV';
n := n - 4;
end
else if n >= 1 then
begin
romano := romano + 'I';
n := n - 1;
end;
end;
Result := romano;
end;
var
conv: Conversor;
num: integer;
begin
writeln('Ingrese un número natural:');

readln(num);
while (num <= 1) or (num >= 2000) do
begin
writeln('El número debe estar entre 1 y 2000, ingrese nuevamente:');
readln(num);
end;
conv.setN(num);
writeln('El número ', num, ' en romano es: ', conv.convertirARomano());
readln;
end.
19. Realizar un proceso que me convierta una fracción decimal ( 0.551 ) decimal a Binario.
Análisis:
1.1. Abstraer:
Convertir una fracción decimal a binario
Atributos:
fraccion (número decimal): fracción decimal a convertir
Comportamientos:
convertirABinario: convierte la fracción decimal a binario
1.2. Diseño:

setFraccion // Fijar un valor en Fraccion
getFraccion // Recuperar el valor de Fraccion
convertirABinario // Convertir la fracción a binario

P/
fraccion:=0;
Fijar Fraccion : (setFraccion) a=>[ P ]=>?

P/
fraccion:=a;
Obtener Fraccion : (getFraccion) ?=>[ F ]=>(double)

P/
retornar fraccion;
Convertir a Binario : (convertirABinario) ?=>[ P ]=>(string)

P/
i:=0;
resultado:='.';
while (fraccion <> 1) and (i < 10) do
begin
fraccion:=fraccion * 2;
if fraccion >= 1 then
begin
resultado:=resultado + '1';
fraccion:=fraccion - 1;
end
else
resultado:=resultado + '0';
i:=i+1;
end;
convertirABinario:=resultado;
PP/
conversor.setFraccion(0.551);
writeln(conversor.getFraccion(), ' en binario es: ', conversor.convertirABinario());
Implementación:
Pascal:
unit uConversor;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Conversor }
Conversor=Class
private
fraccion:double;
public
procedure setFraccion(f:double);
function getFraccion():double;
function convertirABinario():string;
end;
implementation
{ Conversor }
begin
fraccion := 0;
end;
procedure Conversor.setFraccion(f: double);

begin
fraccion := f;
end;
function Conversor.getFraccion(): double;

begin
Result := fraccion;
end;
function Conversor.convertirABinario(): string;

var
i: integer;
resultado: string;
begin
i := 0;
resultado := '.';
while (fraccion <> 1) and (i < 10) do
begin
fraccion := fraccion * 2;
if fraccion >= 1 then
begin
resultado := resultado + '1';
fraccion := fraccion - 1;
end
else
resultado := resultado + '0';
i := i + 1;
end;
Result := resultado;
end;
var
conv: Conversor;
fraccion: double;
begin
writeln('Ingrese una fracción decimal:');

readln(fraccion);
conv.setFraccion(fraccion);
writeln('La fracción ', fraccion, ' en binario es: ', conv.convertirABinario());
readln;
end.
20. Realizar un proceso que me convierta un número decimal ( 12.125 ) a Octal.

unit uConversor;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Conversor }
Conversor = class
private
n: double;
baseOrigen, baseDestino: integer;
public
procedure setN(n1: double);
function getN(): double;
procedure setBaseOrigen(base1: integer);
function getBaseOrigen(): integer;
procedure setBaseDestino(base2: integer);
function getBaseDestino(): integer;
function convertirBase(): string;
end;
implementation
{ Conversor }
begin
n := 0;
baseOrigen := 0;
baseDestino := 0;
end;
procedure Conversor.setN(n1: double);

begin
n := n1;
end;
function Conversor.getN(): double;

begin
Result := n;
end;
procedure Conversor.setBaseOrigen(base1: integer);

begin
baseOrigen := base1;
end;
function Conversor.getBaseOrigen(): integer;

begin
Result := baseOrigen;
end;
procedure Conversor.setBaseDestino(base2: integer);

begin
baseDestino := base2;
end;
function Conversor.getBaseDestino(): integer;

begin
Result := baseDestino;
end;
function Conversor.convertirBase(): string;

var
cociente: integer;
residuo: double;
octal: string;
begin
cociente := Trunc(n); //obtener la parte entera del número
residuo := n - cociente; //obtener la parte decimal del número
octal := ''; //cadena que almacenará el número octal
//convertir la parte entera a octal

while cociente > 0 do
begin
octal := IntToStr(cociente mod baseDestino) + octal;
cociente := cociente div baseDestino;
end;
octal := octal + '.'; //separador decimal
//convertir la parte decimal a octal

for i := 1 to 5 do //se convierte hasta la quinta cifra decimal
begin
residuo := residuo * baseDestino;
octal := octal + IntToStr(Trunc(residuo));
residuo := residuo - Trunc(residuo);
end;
Result := octal;
end;
var
conversor: Conversor;
begin
conversor := Conversor.Create();
conversor.setN(12.125);
conversor.setBaseOrigen(10);
conversor.setBaseDestino(8);
writeln(conversor.getN(), ' en base ', conversor.getBaseOrigen(), ' es: ', conversor.convertirBase(), ' en base
', conversor.getBaseDestino());
end.
21. Hallar los dos Mayores Dígitos de un número. C=3924112435 Primer Digito: 9 Segundo Digito:5
Análisis:
1.1. Abstraer:
Dado un número, encontrar los dos mayores dígitos en él.
Atributos:
num (entero positivo): número del cual se quieren encontrar los dos mayores dígitos
Comportamientos:
encontrarMayoresDigitos: busca y devuelve los dos mayores dígitos en el número dado
1.2. Diseño:

setNum // Fijar un valor en num
getNum // Recuperar el valor de num
encontrarMayoresDigitos // Buscar y devolver los dos mayores dígitos en el número dado

P/
num:=0;
Fijar num : (setNum) a=>[ P ]=>?

P/
num:=a;
Obtener num : (getNum) ?=>[ F ]=>(integer)

P/
retornar num;
encontrarMayoresDigitos : (encontrarMayoresDigitos) ?=>[ P ]=>(string)

P/
primero := 0;
segundo := 0;
temp := num;
while temp > 0 do
begin
digito := temp mod 10;
if digito > primero then
begin
segundo := primero;
primero := digito;
end
else if (digito > segundo) and (digito < primero) then
segundo := digito;
temp := temp div 10;
end;
encontrarMayoresDigitos := 'Primer dígito: ' + IntToStr(primero) + ' Segundo dígito: ' + IntToStr(segundo);
PP/
numero:=Numero.Create();
numero.setNum(3924112435);
writeln(numero.encontrarMayoresDigitos());
Implementación:
2.1. Creando la unidad que contiene la Clase Numero
Pascal:
unit uNumero;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Numero }
Numero=Class
private
num:integer;
public
procedure setNum(num1:integer);
function getNum():integer;
function encontrarMayoresDigitos():string;
end;
implementation
{ Numero }
constructor Numero.Create();
begin
num := 0;
end;
procedure Numero.setNum(num1: integer);

begin
num := num1;
end;
function Numero.getNum(): integer;

begin
Result := num;
end;
function Numero.encontrarMayoresDigitos(): string;

var
temp, digito, primero, segundo: integer;
begin
primero := 0;
segundo := 0;
temp := num;
while temp > 0 do

begin
digito := temp mod 10;
if digito > primero then
begin
segundo := primero;
primero := digito;
end
else if (digito > segundo) and (digito < primero) then
segundo := digito;
temp := temp div 10;
end;
Result := 'Primer dígito: ' + IntToStr(primero) + ' Segundo dígito: ' + IntToStr(segundo);
end;
var
num: Numero;
begin
num := Numero.Create();
num.setNum(3924112435);
writeln(num.encontrarMayoresDigitos());
var
numero: integer;
resultado: string;
begin
numero := 3924112435;
resultado := dosMayoresDigitos(numero);
WriteLn(resultado);
end.
22. Hallar los dos Menores Dígitos de un número. C=3924112435_Primer Digito: 1 Segundo Digito:2
Análisis:
1.1. Abstraer:
Encontrar los dos menores dígitos de un número dado.
Atributos:
n (número entero): número al que se le buscarán los dígitos
Comportamientos:
encontrarMenores: encuentra los dos menores dígitos del número
1.2. Diseño:

encontrarMenores // Encontrar los dos menores dígitos del número

P/
n:=0;

P/
n:=a;

P/
retornar n;
Encontrar Menores : (encontrarMenores) ?=>[ P ]=>(string)

P/
menor1:=10;
menor2:=10;
for i:=1 to Length(IntToStr(n)) do
begin
digito:=StrToInt(IntToStr(n)[i]);
if digito < menor1 then
begin
menor2:=menor1;
menor1:=digito;
end
else if digito < menor2 then
menor2:=digito;
end;
encontrarMenores:= 'Primer Digito: ' + IntToStr(menor1) + ' Segundo Digito: ' + IntToStr(menor2);
PP/
numero:= Numero.Create();
numero.setN(3924112435);
writeln(numero.encontrarMenores());
Implementación:
2.1. Creando la unidad que contiene la Clase Numero
Pascal:
unit uNumero;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Numero }
Numero=Class
private
n:integer;
public
function encontrarMenores():string;
end;
implementation
{ Numero }
constructor Numero.Create();
begin
n := 0;
end;
procedure Numero.setN(n1: integer);

begin
n := n1;
end;
function Numero.getN(): integer;

begin
Result := n;
end;
function Numero.encontrarMenores(): string;

var
i, digito, menor1, menor2: integer;
begin
menor1 := 10;
menor2 := 10;
for i := 1 to Length(IntToStr(n)) do
begin
digito := StrToInt(IntToStr(n)[i]);
if digito < menor1 then
begin
menor2 := menor1;
menor1 := digito;
end
else if digito < menor2 then
menor2 := digito;
end;
Result := 'Primer Digito: ' + IntToStr(menor1) + ' Segundo Digito: ' + IntToStr(menor2);
end;
var
num: Numero;
begin
num := Numero.Create();
num.setN(3924112435);
writeln(num.encontrarMenores());
readln;
end.
23. Realizar la unión de dos números enteros en un tercer de la siguiente manera: A=3924 B=112435
C=3924112435
Análisis:
1.1. Abstraer:
Unir dos números enteros en un tercer número
Atributos:
num1 (número entero): primer número a unir
num2 (número entero): segundo número a unir
Comportamientos:
unirNumeros: une los dos números en un tercer número
1.2. Diseño:

unirNumeros // Unir los dos números en un tercer número

P/
num1:=0;
num2:=0;
Fijar Num1 : (setNum1) a=>[ P ]=>?

P/
num1:=a;
Obtener Num1 : (getNum1) ?=>[ F ]=>(integer)

P/
retornar num1;
Fijar Num2 : (setNum2) a=>[ P ]=>?

P/
num2:=a;
Obtener Num2 : (getNum2) ?=>[ F ]=>(integer)

P/
retornar num2;
Unir Numeros : (unirNumeros) ?=>[ P ]=>(integer)

P/
num3:=StrToInt(IntToStr(num1) + IntToStr(num2));
unirNumeros:=num3;
PP/
union:=Union.Create();
union.setNum1(3924);
union.setNum2(112435);
writeln('Uniendo ', union.getNum1(), ' y ', union.getNum2(), ': ', union.unirNumeros());
Implementación:
2.1. Creando la unidad que contiene la Clase Union
Pascal:
unit uUnion;
{$mode objfpc}{$H+}
interface
uses
Classes, SysUtils;
type
{ Union }
Union=Class
private
num1,num2:integer;
public
procedure setNum1(a1:integer);
function getNum1():integer;
procedure setNum2(a2:integer);
function getNum2():integer;
function unirNumeros():integer;
end;
implementation
{ Union }
constructor Union.Create();
begin
num1 := 0;
num2 := 0;
end;
procedure Union.setNum1(a1: integer);

begin
num1 := a1;
end;
function Union.getNum1(): integer;

begin
Result := num1;
end;
procedure Union.setNum2(a2: integer);

begin
num2 := a2;
end;
function Union.getNum2(): integer;

begin
Result := num2;
end;
function Union.unirNumeros(): integer;

begin
Result := StrToInt(IntToStr(num1) + IntToStr(num2));
end;
var
union: Union;
num1, num2: integer;
begin
union := Union.Create();
writeln('Ingrese el primer número:');

readln(num1);
union.setNum1(num1);
writeln('Ingrese el segundo número:');

readln(num2);
union.setNum2(num2);
writeln('Uniendo ', num1, ' y ', num2, ': ', union.unirNumeros());
readln;
end.
24. Realizar la mezcla de dos números enteros en un tercero de la siguiente manera:

A=3924 B=112435
C=3191224435
program Ejercicio24;
var
A, B, C: string;
i, j: integer;
begin
A := '3924';
B := '112435';
C := '';
for i := 1 to length(A) do
begin
C := C + A[i];
for j := 1 to length(B) do
begin
C := C + B[j];
end;
end;
writeln('El número resultante es: ', C);
readln;
end.

PRACTICO U1 Programacion

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

PRACTICO U1 Programacion

Cargado por

Copyright:

Formatos disponibles

Practico U1 – POO

Nombre: Bonny Leonardo

* Imprimir los primeros k números naturales.

1.2.1. Diseño Formal:

imprimirNaturales : (imprimirNaturales) n=>[ P ]=>?

1.3.1. Implementación del programa en Pascal:

2.2.1. Diseño Formal:

2.2.2. Diseño Procedimental:

1.2.1. Diseño Formal:

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(int)

Calcular Suma : (calcularSuma) ?=>[ P ]=>(int)

Constructor //Inicializar el atributo con valor por defecto

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(int)

Imprimir Letras : (imprimirLetras) ?=>[ P ]=>(string)

Si n es par, imprimir los primeros n números pares.

Constructor //Inicializar el atributo con valor por defecto

1.2.2. Diseño Procedimental:

Imprimir Numeros : (imprimirNumeros) ?=>[ P ]=>(string)

2.1. Creando la unidad que contiene la Clase Numeros:

Sumar n "m" veces.

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Fijar M : (setM) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(int)

División de dos números naturales utilizando restas

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(int)

Fijar M : (setM) a=>[ P ]=>?

Obtener M : (getM) ?=>[ F ]=>(int)

Calcular Cociente : (calcularCociente) ?=>[ P ]=>(real)

procedure DivisionResta.setN(n1: integer);

function DivisionResta.getN(): integer;

procedure DivisionResta.setM(m1: integer);

function DivisionResta.calcularCociente(): real;

function cociente(n, m: integer): integer;

1.2.1. Diseño Formal:

Constructor //Inicializar los atributos con valor por defecto

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(integer)

Fijar M : (setM) a=>[ P ]=>?

Obtener M : (getM) ?=>[ F ]=>(integer)

Calcular Producto : (calcularProducto) ?=>[ P ]=>(integer)

procedure ProductoEnteros.setN(n1: integer);

procedure ProductoEnteros.setM(m1: integer);

function ProductoEnteros.getN(): integer;

function ProductoEnteros.getM(): integer;

function ProductoEnteros.calcularProducto(): integer;

1.2.1. Diseño Formal:

Constructor //Inicializar los atributos con valor por defecto

1.2.2. Diseño Procedimental:

Fijar N : (setN) a=>[ P ]=>?

Obtener N : (getN) ?=>[ F ]=>(integer)

Fijar M : (setM) a=>[ P ]=>?

Obtener M : (getM) ?=>[ F ]=>(integer)

Calcular Cociente : (calcularCociente) ?=>[ P ]=>(integer)

procedure CocienteEnteros.setN(n1: integer);

procedure CocienteEnteros.setM(m1: integer);

function CocienteEnteros.getN(): integer;