unit UNumeros;

interface
uses
System.SysUtils,math;

type
numero = class
private
valor : cardinal;
Function ALiteral2D( N : Byte):String;
Function ALiteral3D ( N :Word) : String;
Function ALiteral4D ( N :Word) : String;
public
function ObtValor:cardinal;
procedure CambValor(n:cardinal);
procedure Imvertir;
function EsPrimo:Boolean;
function ElimDig(dg: byte):Cardinal;
procedure ElimDigPr;
procedure IntDig(p1,p2:byte);
function ObtDig(p:byte):byte;
procedure ModfDig(p:byte; d:byte);
procedure InsDig(p:byte;d:byte);
function NuMYor(d:byte):cardinal;
function NuMNenor(d:byte):cardinal;
function ND:byte;
procedure EliminarCero;
function Dig_May_nd(nd:byte):Integer;
Procedure EliminarP ( p: Byte);
function sonIguales(n:integer):Boolean;
Function getValue:Cardinal; //get significa obtener,devolver
Procedure setValue(v: Cardinal);
Function isPar:Boolean;
Procedure delDig(p: Byte);
Function toBinary:string;
function smDigPares:boolean;
Procedure InsertarDigito ( X :Byte; P: Byte);
Procedure delDigit( p:Byte);
Function FormaPartedelNumero (x : Byte): Boolean;
Procedure DelNum ( x: Cardinal );
Function SumaDigPar:Boolean;
function ObNumDig(p,nd:byte):Cardinal;
function EncUnDig(d:byte):Boolean;
Function ObtenerValor : Cardinal;
Procedure CambiarValor( V : Cardinal);
Procedure EliminarDigito ( d: Byte);
Function ALiteral (n:Word): String;
Function ABinario : String;
function SmDig:cardinal;
function BusqDg(d:byte):Boolean;
function N_Dig:byte;
procedure ElimD_Primos;
procedure InsertarD(p,d: byte);
procedure IncD_En_Posicion(p,d:byte);
function El_numero_Mayor(d:cardinal):cardinal;
function Cantidad_de_Numeros:cardinal;
function CantDeCeros:byte;
function Condicion(z:Cardinal):Boolean;
 procedure Unir2num( num:numero);

end;
implementation

{ numero }
procedure numero.CambValor(n:cardinal);
begin
valor:= n;
end;
function numero.CantDeCeros: byte;
var
n1,n2,n3:Cardinal;
d1,e,c:byte;
begin
c:=0;
e:=10;
n1:=valor;
while ( n1 > 0) do
begin
d1:= n1 mod 10;
if ( d1 <> 0) then
begin
e:=10;
n2:=n1;
n3 := n2 mod 1000;
if (Condicion(n3)) then
begin
c:=c+1;
e:=100;
end;
end;

n1:= n1 div e;
end;
Result:= c ;
end;

function numero.Cantidad_de_Numeros: cardinal;

var n,cont:cardinal;
begin
cont := 0;
n:= valor;
while (n > 0) do
begin
cont:= cont+1;
n:= n div 10;
end;
Result:= cont;
end;
function numero.Condicion(z: Cardinal): Boolean;
begin
if ( ((z mod 100)< 9 )and ((z div 100)<>0)) then
Result:= True
else
Result:= False;
end;
procedure numero.ElimD_Primos;
var d:byte;
n,m,s: cardinal;
begin
s:=1;
m:=0;
n := valor;
while n >0 do
begin
d:= n mod 10;
if d in [1,4,6,8] then
begin
m:=d*s+m;
s := s*10;
end;
n := n div 10;
end;
valor:=m;
end;

function numero.El_numero_Mayor(d:cardinal):cardinal;
var n,r1,f,r2:cardinal;
begin
f:= Cantidad_de_Numeros;
if (d > f) then
begin
n:= valor;
r1:= n mod (Trunc(Power(10,d)));
while n>0 do
begin
r2:= n mod (Trunc(Power(10,d)));
if (r1>r2) then
else
begin
r1:= r2;
r2:=0;
end;
n:=n div 10;
end;
Result:=r1;
end
Else raise Exception.Create('numero de digito que sobre pasa:');
end;
procedure numero.IncD_En_Posicion(p, d: byte);
var n:cardinal;
begin

end;

procedure numero.InsertarD(p, d: byte);

Var
np : Cardinal;
begin
np:=trunc(power(10,p-1));
Valor:=(((Valor div np))*10+d)*np+(Valor mod np);
end;

function numero.obtValor:Cardinal;
begin
 Result:= valor;
end;
function Numero.BusqDg(d: byte): Boolean;
var
n:cardinal;
dg:byte;
b:Boolean;
begin
dg:=0;
n:=valor;
b:=false;
while (n>0)and(b=false) do
begin
dg:=n mod 10;
if (d=dg) then
b:=true;
n:=n div 10;
end;
Result:=b;
end;

function Numero.N_Dig: byte;

var
n:Cardinal;
cd:byte;

begin
n:=valor;
cd:=0;
while (n>0) do
begin
n:=n div 10;
cd:=cd+1;
end;
Result:=cd;
end;

function Numero.SmDig: cardinal;

var n,sm:Cardinal;
dg:byte;
begin
n:=Valor;
sm:=0;
while (n>0) do
Begin
sm:=sm+(n mod 10);
n:=n div 10;
End;
Result:=sm;
end;

function Numero.ABinario: String;

Const
Dig ='01';
Var
 N : Cardinal;
d : Byte;
S : String;
begin
N:=Valor;S:='';
while N>0 do
Begin
d:= N mod 2;
S:= Dig[d+1]+S;
N:= N div 2;
End;
Result:=S;
end;

function Numero.ALiteral(n : Word): String;

begin
if( n < 99 ) then

Result:= ALiteral2D(n)

else
if( n <= 999 ) then
Result:=ALiteral3D(n)
else Result:=ALiteral4D(n);

end;

function Numero.ALiteral2D(N: Byte): String;

Const
Dig : Array[1..2,0..15] of String = (('
','Uno' ,'Dos' ,'Tres' ,'Cuatro' ,'Cinco' ,'Seis' ,'Siete' ,'Ocho' ,'N
ueve' ,'Diez','Once','Doce','Trece','Catorce','Quince'),

('' ,'Diez','Veinti','Treinta','Cuarenta','Cincuenta','Sesenta','Setenta','Ochenta
','Noventa','' ,'' ,'' ,'' ,'' ,'' ) );
begin

if ( N <= 15 ) then
Result:=Dig[1,N]
else Result:=Dig[2,N div 10]+' y '+Dig[1,N mod 10];

end;

function Numero.ALiteral3D(N: Word): String;

Const
Dig : Array[1..9] of String = ('Ciento' ,
'Docientos' ,
'Trecientos' ,
'Cuatrocientos' ,
'Quinientos' ,
'Seiscientos' ,
'Setecientos' ,
'Ochocientos' ,
'Novecientos' );
begin
 if ( N = 100 ) then
Result:= 'Cien'
Else
Result:= Dig[N div 100]+ ' ' + ALiteral2D(N mod 100);
end;

function numero.ALiteral4D(N: Word): String;

Const
Dig : Array[1..9] of String = ('Mil' ,
'Dosmil' ,
'Tresmil' ,
'Cuatromil' ,
'Cincomil' ,
'Seismil' ,
'Sietemil' ,
'Ochomil' ,
'Nuevemil' );
begin

Result:= Dig[N div 1000]+ ' ' + ALiteral3D(N mod 1000);

end;

procedure Numero.CambiarValor(V: Cardinal);

begin
Valor:=V;
end;

procedure Numero.EliminarDigito(d: Byte);

Var
N,K : Cardinal;
C,dig : Byte;
begin
N:=Valor;C:=1;
while (N>0) do
Begin
dig:= N Mod 10;
if dig=d then
Begin
K:=Trunc(Power(10,C-1));
Valor:=((Valor div K) div 10)*K+(Valor Mod K);
End
Else C:=C+1;
N:=N Div 10;

End;
end;

function Numero.EsPrimo: Boolean;

Var
t: Cardinal;
Sw:Boolean;
begin
t:=2;
sw:=True;
while ( t < Valor) and (sw = True) do
Begin
if ((Valor Mod t)= 0) then
Sw:=False
else
 t:=t+1;
End;
Result:=Sw;
end;

function Numero.ObtenerValor: Cardinal;

begin
Result:=Valor;
end;
procedure Numero.delDigit(p: Byte);
var
k,n1,n2:cardinal;
begin
k:=Trunc(power(10,p-1));
n1:=(Valor div k) div 10;
n2:=Valor mod k;
Valor:=n1*k+n2;
end;

procedure Numero.DelNum(x: Cardinal);

Var
Nd,K, N, Aux, S, q : Cardinal;
begin
S:=0;
Nd:=Trunc(Log10(X)+1);
N:=Valor;
K:=Trunc(Power(10,Nd));
q:=1;
while (N>0) do
Begin
Aux:=N Mod K;
Nd:=Nd+1;
if x<>Aux then

Begin
S:=Aux*q+s;
N:=N Div k;
Q:=Trunc(Power(10,(Nd-1)));
Nd:=Nd+1;

End
Else
N:=N Div K;

End;
Valor:=S

end;

function Numero.EncUnDig(d: byte): Boolean;

var na:Cardinal;
n:byte;
sw:Boolean;
begin
na:=valor;
sw:= false;
 while ((na>0)and (sw=false)) do
begin
n:=na mod 10;
if (n=d) then
sw:=true
end;
Result:=sw;

end;

function Numero.FormaPartedelNumero(x:Byte): Boolean;

Var
Nd,N, Aux : Integer;
k : Cardinal;
Sw: Boolean;
begin
Sw:=False;
Nd:=Trunc(Log10(X)+1);
N:=Valor;
K:=Trunc(Power(10,Nd));
while (N>0) Do
Begin
Aux:=N Mod K;
if x=Aux then
Begin
Sw:=True;
N:=0;
End
Else
N:=N Div 10;

End;
Result:= Sw;

end;

function Numero.getValue: Cardinal;

begin
Result:=Valor;
end;

procedure Numero.InsertarDigito(X, P: Byte);

Begin

end;

function Numero.isPar: Boolean;

begin
if (valor mod 2) = 0 then
Result := True
Else
Result := False;
end;

function Numero.ObNumDig(p, nd: byte): Cardinal;

var na,n1:Cardinal;
begin
na:=valor;
 n1:= na mod (Trunc(Power(10,p-1)));
Result:= n1 mod (Trunc(Power(10,nd)));;
end;

procedure Numero.setValue(v: Cardinal);

begin
Valor := V;
end;

function Numero.SumaDigPar: Boolean;

Var
n : Cardinal;
s : Byte;
begin
n:=Valor;
while n>0 do
Begin
s:=s+(n mod 10);
n:=n div 10;
End;
Result:=(s mod 2)=0;
end;

function Numero.toBinary: String;

Const
Dig= '01';
Var
N, D : Cardinal;
B : String;
begin
N := Valor;
B := '';
while (N>0) do
Begin
d:=n mod 2;
b:=Dig[d+1]+b;
N:= n div 2;
End;
Result:=b;
end;
procedure numero.Unir2num(num:numero);
var m:cardinal;

begin
m:= valor * Trunc(Power(10,num.ND))+ num.valor;
valor:= m ;
end;

procedure Numero.delDig(p: Byte);

var k,n1,n2:Cardinal;
begin
k:=Trunc(power(10,p-1));
n1:=(Valor div k) div 10;
n2:=Valor mod k;
Valor:=n1*k+n2;
//Otro modo para activar el power si en caso no conociera MATH es:
//posicionarse al centro,click derecho,Refactor,Find Unit.
end;
function Numero.smDigPares: boolean;
var v:Boolean;
d,n,suma:Cardinal;

begin
n:= valor;
while n > 0 do
Begin
d:=n mod 10;
suma :=suma + d;

n:=n Div 10;

End;
if (suma mod 2 = 0) then
Result :=true
else
begin
Result:=false;
end;

Result:=v;

end;

function numero.Dig_May_nd(nd:byte): Integer;

var d,dm,k,n:Integer;

begin
n:=valor;
k:=Trunc(Power(10,nd));
dm:= n mod k;
//n:=n div 10;
while (n>0) do
begin
d:=n mod k;
if (d > dm) then
dm:=d;
n:=n div 10;
end;
Result:=dm;
end;

function numero.ElimDig(dg: byte):cardinal;

var nn,n:Integer;
e,d:byte;

begin
n:=valor;
d:=0;
nn:=0;
e:=0;
 while (n>0) do
Begin
d:= n mod 10;
if (dg <> d) then
begin
nn:= nn + (d* Trunc(power(10,e)));
e:=e+1;
end;
n:=n div 10;
End;
Result:=nn;

end;

procedure numero.ElimDigPr;
Var
n,r,k : Cardinal;
d: byte;
begin
n:=Valor;
r:=0;
k:=1;
while n>0 do
Begin
d:= n mod 10;
if d in [0,1,4,6,8,9] then
begin
r:=d*k+r;
k:=k*10;
end;
n:=n div 10;
End;
Valor:=r;

end;

procedure numero.EliminarCero;
var n:cardinal;
d,k,c:byte;
begin
n:=Valor;
c:=0;
while (n>0) do
begin
d:=n mod 10; n:=n div 10; c:=c+1;
if (d <> 0) then
begin
d:= n mod 10; n:=n div 10; c:=c+1; k:=c;
if (d=0) then
begin
d:= n mod 10; n:=n div 10; c:=c+1;
if (d<>0) then
begin
EliminarP(k);
n:=valor;
c:=0;
end;
end;
end;
 end;

end;

procedure numero.EliminarP(p: Byte);

var n,k1,k,k3,k2:Cardinal;
begin
n:=valor;
K:=Trunc(Power(10,p-1));
K1:=n div (Trunc(Power(10,p-1)));
K2:=n mod (Trunc(Power(10,p-1)));
k3:=k1 div 10;
valor:=k3* k+k2;

end;

procedure numero.Imvertir;
var nn,n:Integer;
d:byte;
begin
n:=valor;
d:=0;
nn:=0;
while ( n > 0 ) do
begin
d:= n mod 10;
nn:= nn * 10 + d;
n:= n div 10;
end;
valor:=nn;
end;

procedure numero.InsDig(p, d: byte);

Var
np : Cardinal;
begin
np:=trunc(power(10,p-1));
Valor:=(((Valor div np))*10+d)*np+(Valor mod np);

end;

procedure numero.IntDig(p1, p2: byte);

var d1,d2:byte;
n:cardinal;
begin
d1:=ObtDig(p1);
d2:=ObtDig(p2);
ModfDig(p1,d1);
ModfDig(p2,d2);
end;

procedure numero.ModfDig(p, d: byte);

var h:cardinal;
begin
h:= Trunc(Power(10,p-1));
 valor := ((((valor div h) div 10)*10+d)*h)+ (valor mod h);

end;

function numero.ND: byte;

var n: cardinal;
cont : byte;
begin
cont := 0;
n:= valor;
while n > 0 do
begin
cont := cont + 1;
n:= n div 10;
end;
Result:= cont;
end;

function numero.NuMNenor(d: byte): cardinal;

var r1,r2,n:cardinal;
begin
n:= valor;
if d>0 then
begin
if d <= ND then
begin
r1:= n mod(Trunc( Power(10,d)));
while n > 0 do
begin
r2:= n mod(Trunc( Power(10,d)));
if r1 <= r2 then
else
begin
if r2 < r1 then
begin
r1 := r2;
end;
end;
n:= n div 10;
end;

end
else raise Exception.Create('Nmero de Digito Que sobrepasa lo
numeros de digitod');
end
else raise Exception.Create('Numero de Digito No valido');;
Result:= r1;

end;

function numero.NuMYor(d: byte):cardinal;

var n,r,r2:cardinal;
begin
n:= valor;
if d > 0 then
if d <= ND then
begin
begin
 r := n mod (trunc(power(10,d)));
while n > 0 do
begin
r2 := n mod (trunc(power(10,d)));
if r > r2 then
else
begin
if r2 > r then
r:= r2;
end;
n:= n div 10;
end;
end;
end

else raise Exception.Create('numero no aceptado por excedente: '+

IntToStr(d))
else raise Exception.Create('numero no aceptado: '+ IntToStr(d));
Result:= r;
end;

function numero.ObtDig(p: byte): byte;

begin
Result:= valor div (Trunc(Power(10,p-1))) mod 10;
end;

function numero.sonIguales(n:integer): Boolean;

var b1,b2:Boolean;
n22,n1,n2:cardinal;
d1,d2:byte;

begin
n1:=n;
n2:=valor;
b1:=True;
while (n1>0)and (b1 = true) do
Begin
d1:=n1 mod 10;
n22:=n2;
b1:=False;
while (n22>0)and (b1 = False) do
begin
d2:= n22 mod 10;
if (d1 = d2) then
b1:=True;
n22:=n22 div 10;
end;
n1:=n1 div 10;
End;
n1:=valor;
n2:=n;
b2:=True;
while (n1>0)and (b2 = true) do
Begin
d1:=n1 mod 10;
n22:=n2;
b2:=False;
while (n22>0)and (b2 = False) do
 begin
d2:= n22 mod 10;
if (d1 = d2) then
b2:=True;
n22:=n22 div 10;
end;
n1:=n1 div 10;
End;
if (b2 = b1) then
Result:=True
else Result:=False;

end;

end.