program conversor;

uses Math;

function potencia4(a,b:integer):integer;
var aux:integer;
begin
if b = 0 then
potencia4 := 1
else if b = 1 then
potencia4 := a
else begin
aux := potencia4(a, b div 2);
if (b mod 2) = 0 then
potencia4 := sqr(aux)
else
potencia4 := sqr(aux)*a;
end;
end;

function DigitoToChar(digito:byte):char;
begin
DigitoToChar := char(ord('A') + digito - 10);
end;

function CharToDigito(caracter:char):byte;
begin
CharToDigito := ord(upcase(caracter)) - ord('A') + 10;
end;

function BaseToDec(numero:string; base:byte):string;

var i,longitud,digito:byte; acumulador:longint = 0;
begin
longitud := length(numero);
for i := longitud downto 1 do begin
if numero[i] in ['0'..'9']
then val(numero[i], digito)
else digito := CharToDigito(numero[i]);
acumulador += digito*potencia4(base,longitud-i);
end;
str(acumulador, BaseToDec);
end;

function DecToBase(numero:string; base:byte): string;

var dividendo:longint; resto:string; i,HighLimit:word; restobyte:byte;
begin
val(numero, dividendo);
DecToBase := '';
HighLimit := trunc(logn(base, dividendo));
for i := 1 to HighLimit do begin
restobyte := (dividendo div trunc(power(base, i-1))) mod base;
if restobyte > 9
then resto := DigitoToChar(restobyte)
else str(restobyte, resto);
DecToBase := resto + DecToBase;
end;
// restobyte = ultimo cociente
restobyte := (dividendo div trunc(power(base, HighLimit)));
if restobyte > 9
 then resto := DigitoToChar(restobyte)
else str(restobyte, resto);
DecToBase := resto + DecToBase;
end;

function PBaseToQBase(numeroP:string; P,Q:byte):string;

begin
PBaseToQBase := DecToBase(BaseToDec(numeroP, P), Q);
end;

begin
end.

unit TADABB;

interface

const
NULOABB = nil; // Para representar posiciones nulas en el ABB

type
// tDato: tipo de dato que contiene el ABB homogeneamente (a editar por el
programador que use el ABB)
tDato = integer;

tABB = ^tNodo; // Posicion de un elemento del ABB

tNodo = record // Estructura de un nodo del ABB
info:tDato;
hijoizq, hijoder:tABB;
end;

procedure CrearABB(var ABB:tABB);

function EsABBVacio(ABB:tABB):boolean;
function Raiz(ABB:tABB):tDato;
function HijoIzq(ABB:tABB):tABB;
function HijoDer(ABB:tABB):tABB;
function InsertarDato(dato:tDato; var ABB:tABB):boolean;
function BuscarDato(dato:tDato; ABB:tABB):tABB;
Procedure EliminarDato(dato: tDato; var ABB: tABB);

implementation

{ Funcion privada }
function CrearNodo(dato:tDato; var ABB:tABB):boolean;
begin
new(ABB); // reservamos memoria en el monticulo para el ABB
CrearNodo := false; // suponemos que no se ha podido reservar memoria
if ABB <> NULOABB then begin // si se ha podido reservar memoria...
ABB^.info := dato; // guardamos el dato en el nodo
ABB^.hijoizq := NULOABB; // hijoizq es nil
ABB^.hijoder := NULOABB; // hijoder es nil
CrearNodo := true; // devolvemos true para crear nodo
end;
end;

procedure CrearABB(var ABB:tABB);

{
* Objetivo: crear un ABB
* Parametros de E: ABB
* PreCD: -
* PostCD: -
* Salida: el ABB creado
}
begin
ABB := NULOABB; // creamos el ABB haciendo que apunte a nil
end;

function EsABBVacio(ABB:tABB):boolean;
{
* Objetivo: test para verificar si el ABB esta vacio
* Parametros de E: ABB
* PreCD: el ABB creado previamente
* PostCD: -
* Salida: verdadero si el ABB esta vacio, false en caso contrario
}
begin
EsABBVacio := (ABB = NULOABB); // testeamos si el ABB apunta a nil
end;

function Raiz(ABB:tABB):tDato;
{
* Objetivo: obtener el hijo izquierdo de un ABB
* Parametros de E: ABB
* PreCD: el ABB no esta vacio
* PostCD: -
* Salida: el hijo izquierdo del ABB de entrada
}
begin
Raiz := ABB^.info; // devolvemos la raiz del ABB
end;

function HijoIzq(ABB:tABB):tABB;
{
* Objetivo: obtener el hijo derecho de un ABB
* Parametros de E: ABB
* PreCD: el ABB no esta vacio
* PostCD: -
* Salida: el hijo derecho del ABB de entrada
}
begin
HijoIzq := ABB^.hijoizq; // devolvemos el hijoizq
end;

function HijoDer(ABB:tABB):tABB;
{
* Objetivo: obtener el hijo izquierdo de un ABB
* Parametros de E: ABB
* PreCD: el ABB no esta vacio
* PostCD: -
* Salida: el hijo izquierdo del ABB de entrada
}
begin
 HijoDer := ABB^.hijoder; // devolvemos el hijoder
end;

Function InsertarDato(dato:tDato; var ABB:tABB):boolean;

{
* Objetivo: insertar un nodo con informacion en el ABB, en su lugar
* correspondiente, de acuerdo al valor de un dato
* Parametros de E: dato a insertar y ABB a modificar
* PreCD: ABB creado previamente
* PostCD: -
* Salida: el ABB con el nodo insertado si ha sido posible y el test
}
begin
if EsABBVacio(ABB) then // si el ABB esta vacio o viene de un ABB hoja
InsertarDato := CrearNodo(dato, ABB)
else if dato = Raiz(ABB) then // si el dato ya esta en la estructura no lo
insertamos
InsertarDato := true
else if dato < Raiz(ABB) then // si el dato es menor que la raiz, insertamos
por el hijoizq
InsertarDato := InsertarDato(dato, ABB^.hijoizq)
else // si el dato es mayor que la raiz, insertamos por el hijoder
InsertarDato := InsertarDato(dato, ABB^.hijoder);
end;

function BuscarDato(dato:tDato; ABB:tABB):tABB;

{
* Objetivo: buscar el nodo en el que se encuentra el dato en el ABB
* Parametros de E: ABB
* PreCD: el ABB creado previamente
* PostCD: -
* Salida: el nodo donde se encuentra el dato en el ABB
}
begin
if EsABBVacio(ABB) then // si el ABB esta vacio
BuscarDato := NULOABB
else if dato = Raiz(ABB) then // si encontramos el dato
BuscarDato := ABB
else if dato < Raiz(ABB) then // si el dato es menor que la raiz, buscamos
por el hijoizq
BuscarDato := BuscarDato(dato, ABB^.hijoizq)
else // si el dato es mayor que la raiz, buscamos por el hijoder
BuscarDato := BuscarDato(dato, ABB^.hijoder);
end;

{ Procedimiento privado }
procedure reemplazar(var ABBAux:tABB; aux:tABB); // reemplaza el nodo por su
anterior
begin
if not EsABBVacio(ABBAux^.hijoder) then
reemplazar(ABBAux^.hijoder, aux) // bajamos por la rama derecha
else begin
aux^.info := ABBAux^.info; // reemplazamos los campos de informacion
aux := ABBAux; // marcamos el nodo sobre el que hacer dispose
ABBAux := ABBAux^.hijoizq; // y reenlazamos la estructura - saltando -
end; // al nodo que se va a eliminar
end;

Procedure EliminarDato(dato:tDato; var ABB:tABB);

{
* Objetivo: Eliminar el dato del ABB
* Parametros de E: dato y ABB
* PreCD: el dato esta en el ABB
* PostCD: -
* Salida: el ABB sin el dato
}
var
aux: tABB;
begin
if dato < Raiz(ABB) then // si la dato es menor borrar en subABB hijoizq
EliminarDato(dato, ABB^.hijoizq)
else if dato > Raiz(ABB) then // si la dato es mayor borrar en subABB hijoder
EliminarDato(dato, ABB^.hijoder)
else begin // si la dato es igual borramos el nodo
aux := ABB;
if EsABBVacio(ABB^.hijoder) then // si no tiene hijo hijoder sustituir
por el hijoizq
ABB := ABB^.hijoizq // (incluye el caso de los dos hijos vacios)
else if EsABBVacio(ABB^.hijoizq) then // si no tiene hijo hijoizq
sustituir por el hijoder
ABB := ABB^.hijoder // si tiene dos hijos llamamos a reemplazar
else
reemplazar(ABB^.hijoizq, aux); // pasando como parametro su
subarbol hijoizq
dispose(aux);
end;
end;

begin
{ Seccion de inicializacion }
end.

nit TADCola;

interface

const
NULOCOLA = nil;

type
tDato = integer;
tPosC = ^tNodo;
tNodo = record
dato:tDato;
sig:tPosC;
 end;
tCola = record
primera,ultima:tPosC;
end;

procedure CrearCola (var C:tCola);

function EsColaVacia (C:tCola):boolean;
function CimaCola (C:tCola):tDato;
function Encolar (var C:tCola; var D:tDato):boolean;
function Desencolar (var C:tCola):tDato;
procedure VaciarCola (var C:tCola);

implementation

procedure CrearCola (var C:tCola);

begin
C.primera := NULOCOLA;
C.ultima := NULOCOLA;
end;

function EsColaVacia (C:tCola):boolean;

begin
EsColaVacia := (C.primera = NULOCOLA) and (C.ultima = NULOCOLA);
end;

function CimaCola (C:tCola):tDato;

begin
CimaCola := C.primera^.dato;
end;

function CrearNodo (var P:tPosC; D:tDato):tPosC;

begin
new(P);
if P <> NULOCOLA then begin
P^.dato := D;
P^.sig := NULOCOLA;
end;
CrearNodo := P;
end;

function Encolar (var C:tCola; var D:tDato):boolean;

var P:tPosC;
begin
if CrearNodo(P,D) <> NULOCOLA then begin
Encolar := true;
if EsColaVacia(C)
then C.primera := P
else C.ultima^.sig := P;
C.ultima := P;
end else
Encolar := false;
end;

function Desencolar (var C:tCola):tDato;

var D:tDato; P:tPosC;
begin
D := CimaCola(C);
P := C.primera;
C.primera := C.primera^.sig;
 dispose(P);
if C.primera = NULOCOLA then
C.ultima := NULOCOLA;
Desencolar := D;
end;

procedure VaciarCola (var C:tCola);

begin
while not EsColaVacia(C) do Desencolar(C);
end;

begin
{ Seccin de inicializacin }
end.

unit TADPilaDinamica;

interface

const
NULOP = nil; // Para representar posiciones nulas en la pila

type

// tDato: tipo de dato que contiene la pila homogneamente (a editar por el

programador que use la pila)
tDato = ...;

tPosP = ^tNodo; // Posicion de un elemento de la pila

tNodo = record // Estructura de un nodo de la pila
info:tDato;
sig:tPosP;
end;

tPila = tPosP; // Representacion de la pila

procedure CrearPila(var pila:tPila);

function EsPilaVacia(pila:tPila):boolean;
function Apilar(var pila:tPila; dato:tDato):boolean;
function CimaPila(pila:tPila):tDato;
procedure Desapilar(var pila:tPila);

implementation
procedure CrearPila(var pila:tPila);
{
Objetivo: Crea una pila vacia.
Entradas: La pila a crear.
Salidas: La pila inicializada.
PreCD: -
PostCD: La pila sin datos.
}
begin
pila := NULOP;
end;

function EsPilaVacia(pila:tPila):boolean;
{
Objetivo: Determina si la pila esta vacia.
Entradas: La pila a comprobar.
Salidas: True si la pila esta vacia, False en caso contrario.
PreCD: La pila inicializada.
PostCD: -
}
begin
EsPilaVacia := (Pila = NULOP);
end;

function Apilar(var pila:tPila; dato:tDato):boolean;

{
Objetivo: Insertar un elemento en la cima de la pila
Entradas: La pila a comprobar.
Salidas: Devuelve True si se inserta el dato correctamente; False en caso
contrario.
PreCD: La pila inicializada.
PostCD: -
}
var nodo:tPosP;
begin
new(nodo);
if nodo = NULOP then
Apilar:=false
else
begin
Apilar:=true;
nodo^.info:=dato;
if EsPilaVacia(pila) then // si la pila esta vacia
begin
pila:=nodo;
pila^.sig:=NULOP;
end
else // si la pila tiene 1 o mas elementos
begin
nodo^.sig := pila;
pila:=nodo;
end;
end;
end;

function CimaPila(pila:tPila):tDato;
{
Objetivo: Obtener el elemento de la cima de la pila.
Entradas: La pila.
Salidas: El elemento de la cima de la pila.
PreCD: La pila no esta vacia.
PostCD: -
}
begin
CimaPila := pila^.info;
end;

procedure Desapilar(var pila:tPila);

var aux:tPosP;
{
Objetivo: Eliminar el primer elemento de la pila
Entradas: La pila.
Salidas: La pila sin el primer elemento.
PreCD: La pila no esta vacia.
PostCD: -
}
begin
if pila^.sig=NULOP then // si solo hay un elemento
begin
dispose(pila);
pila:=NULOP;
end
else // si hay dos o mas elementos
begin
aux:=pila;
pila:=pila^.sig;
dispose(aux);
end;
end;

begin
{ Seccion de inicializacion }
end.

unit TADRacional;

interface

type
Racional = ^tRacional; // Tipo Racional - puntero a registro
tRacional = record // Tipo registro de Racional
numerador,denominador:integer;
end;

function CrearRacional(a,b:integer):Racional; { Crea un numero racional }

function MostrarRacional(r:Racional):string; { Muestra un numero racional }
function Numerador(r:Racional):integer; { Obtiene el numerador de un numero
racional }
function Denominador(r:Racional):integer; { Obtiene el denominador de un numero
racional }
function SumarRacional(r,s:Racional):Racional; { Suma dos numeros racionales }
function RestarRacional(r,s:Racional):Racional; { Resta el segundo numero racional
al primero }
function MultiplicarRacional(r,s:Racional):Racional; { Multiplica dos numeros
racionales }
function DividirRacional(r,s:Racional):Racional; { Divide el primer numero racional
pasado por el segundo }
function SimplificarRacional(var r:Racional):Racional; { Simplifica un numero
racional }

implementation

function min(a,b:integer):integer; { Devuelve el minimo entre dos numeros }

begin
min:=a;
if b<a then
min:=b;
end;

function mcd(a,b:integer):integer; { Devuelve el maximo comun divisor positivo de 2

enteros }
var t:integer;
begin
a:=abs(a);
b:=abs(b);
t:=min(a,b);
while (t>1) and (((b mod t) <> 0) or ((a mod t) <> 0)) do begin
t:=t-1;
end;
mcd := t;
end;

function CrearRacional(a,b:integer):Racional;
{
* Objetivo: crea un numero racional.
* Parametros de E: dos numeros enteros (numerador y denominador).
* PreCD: el denominador distinto de 0.
* PostCD: -
* Salida: el numero racional.
}
begin
new(CrearRacional);
CrearRacional^.numerador := a;
CrearRacional^.denominador := b;
end;

function MostrarRacional(r:Racional):string;
{
* Objetivo: muestra un numero racional.
* Parametros de E: un numero racional.
* PreCD: un numero racional inicializado.
* PostCD: -
* Salida: muestra por pantalla el numero racional con el signo colocado
correctamente.
}
var num,den:string;
begin
if ((numerador(r)>0) and (denominador(r)>0)) or ((numerador(r)<0) and
(denominador(r)<0)) then begin { Mostrar Racional positivo }
str(abs(numerador(r)),num);
str(abs(denominador(r)),den);
MostrarRacional := num + '/' + den;
end
else if numerador(r) = 0 then { Mostrar "Racional" 0 }
MostrarRacional := '0'
else begin { Mostrar Racional negativo }
str(abs(numerador(r)),num);
str(abs(denominador(r)),den);
MostrarRacional := '-' + num + '/' + den;
end;

end;

function Numerador(r:Racional):integer;
{
* Objetivo: obtiene el numerador de un numero racional.
* Parametros de E: un numero racional.
* PreCD: un numero racional inicializado.
* PostCD: -
* Salida: el numerador del numero racional.
}
begin
Numerador := r^.numerador;
end;

function Denominador(r:Racional):integer;
{
* Objetivo: obtiene el denominador de un numero racional.
* Parametros de E: un numero racional.
* PreCD: un numero racional inicializado.
* PostCD: -
* Salida: el denominador del numero racional.
}
begin
Denominador := r^.denominador;
end;

function SimplificarRacional(var r:Racional):Racional;

{
* Objetivo: simplifica un numero racional.
* Parametros de E: un numero racional.
* PreCD: un numero racional inicializado.
* PostCD: -
* Salida: el numero racional simplificado.
}
var a,b:integer;
begin
a:=abs(numerador(r));
b:=abs(denominador(r));
if (mcd(a,b) <> 0) then begin
r^.numerador := numerador(r) div mcd(a,b);
r^.denominador := denominador(r) div mcd(a,b);
end;
 SimplificarRacional := r;
end;

function SumarRacional(r,s:Racional):Racional;
{
* Objetivo: suma dos numeros racionales.
* Parametros de E: dos numeros racionales.
* PreCD: los dos numeros racionales inicializados.
* PostCD: -
* Salida: la suma de los dos numeros racionales.
}
begin
new(SumarRacional);
SumarRacional^.denominador := denominador(r) * denominador(s);
SumarRacional^.numerador := denominador(SumarRacional) div denominador(r) *
numerador(r) + denominador(SumarRacional) div denominador(s) * numerador(s);
SumarRacional := SimplificarRacional(SumarRacional);
end;

function RestarRacional(r,s:Racional):Racional;
{
* Objetivo: resta dos numeros racionales.
* Parametros de E: dos numeros racionales.
* PreCD: los dos numeros racionales inicializados.
* PostCD: -
* Salida: la resta del primer numero racional menos el segundo numero
racional.
}
begin
new(RestarRacional);
RestarRacional^.denominador := denominador(r) * denominador(s);
RestarRacional^.numerador := denominador(RestarRacional) div denominador(r) *
numerador(r) - denominador(RestarRacional) div denominador(s) * numerador(s);
RestarRacional := SimplificarRacional(RestarRacional);
end;

function MultiplicarRacional(r,s:Racional):Racional;
{
* Objetivo: multiplica dos numeros racionales.
* Parametros de E: dos numeros racionales.
* PreCD: los dos numeros racionales inicializados.
* PostCD: -
* Salida: la multiplicacion de los dos numeros racionales.
}
begin
new(MultiplicarRacional);
MultiplicarRacional^.numerador := numerador(r) * numerador(s);
MultiplicarRacional^.denominador := denominador(r) * denominador(s);
MultiplicarRacional := SimplificarRacional(MultiplicarRacional);
end;

function DividirRacional(r,s:Racional):Racional;
{
* Objetivo: divide dos numeros racionales.
* Parametros de E: dos numeros racionales.
* PreCD: los dos numeros racionales inicializados.
* PostCD: -
* Salida: la division del primer numero racional entre el segundo numero
racional.
}
begin
new(DividirRacional);
DividirRacional^.numerador := numerador(r) * denominador(s);
DividirRacional^.denominador := denominador(r) * numerador(s);
DividirRacional := SimplificarRacional(DividirRacional);
end;

begin
{ Inicializacion }
end.

unit TADTABLAHASH;

interface

{ constantes publicas }
const
TablaHash_TAM = 101; // Tamanho Tabla Primo ** modificar **
TablaHash_POSICION_PRIMERA = 0; // no modificar
TablaHash_POSICION_ULTIMA = TablaHash_TAM-1; // no modificar
TablaHash_REHASHP = 97; // Doble ReHash Primo ** modificar **

{ tipos de datos publicos }

type
tClaveTablaHash = longint;
tIndiceTablaHash = TablaHash_POSICION_PRIMERA..TablaHash_POSICION_ULTIMA;
tEstado = (OCUPADA,VACIA,ELIMINADA);
tDato = integer;

tEntrada = record
dato:tDato;
estado:tEstado;
end;

tTablaHash = array[tIndiceTablaHash] of tEntrada;

{ funciones publicas }
procedure TablaHash_Inicializar(var TablaHash:tTablaHash);
function TablaHash_Buscar(C:longint; TablaHash:tTablaHash):tIndiceTablaHash;
function TablaHash_ExisteElemento(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
function TablaHash_EsEntradaOcupada(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
function TablaHash_EsEntradaVacia(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
function TablaHash_EsEntradaEliminada(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
function TablaHash_ObtenerDato(hash:tIndiceTablaHash;
TablaHash:tTablaHash):tClaveTablaHash;
procedure TablaHash_Insertar(C:tClaveTablaHash; var TablaHash:tTablaHash);
procedure TablaHash_Eliminar(C:tClaveTablaHash; var TablaHash:tTablaHash);

implementation

/////////////////////////////////////////////////////////////////////

{ funcion privada - HashClave, que determina la posicion de una clave en la tabla }

{
- Hashea claves de enteros positivos (+ 0)
- Valida para entradas aleatorias
}
function TablaHash_HashClave(C:tClaveTablaHash):tIndiceTablaHash;
begin
TablaHash_HashClave := (C mod TablaHash_TAM);
end;

{ funcion privada - ReHashClave, que resuelve colisiones mediante exploracion doble

}
{
- Doble Rehashing
}
function TablaHash_ReHashClave(hash:tIndiceTablaHash; i:longint):tIndiceTablaHash;
begin
TablaHash_ReHashClave := i * (TablaHash_REHASHP - (hash mod
TablaHash_REHASHP));
end;

/////////////////////////////////////////////////////////////////////

procedure TablaHash_Inicializar(var TablaHash:tTablaHash);

var it:tIndiceTablaHash;
begin
for it:=TablaHash_POSICION_PRIMERA to TablaHash_POSICION_ULTIMA do
TablaHash[it].estado := VACIA;
end;

function TablaHash_Buscar(C:tClaveTablaHash;
TablaHash:tTablaHash):tIndiceTablaHash;
var hash,hash_actual:tIndiceTablaHash; i:integer;
begin
i := 0;
hash := TablaHash_HashClave(C);
hash_actual := hash;
while (TablaHash[hash_actual].estado <> VACIA) and
(TablaHash[hash_actual].dato <> C) do begin
i := i + 1;
hash_actual := (((hash + TablaHash_ReHashClave(hash,i)) mod
TablaHash_TAM));
end;
TablaHash_Buscar := hash_actual;
end;

function TablaHash_ExisteElemento(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
begin
TablaHash_ExisteElemento := (TablaHash[hash].estado = OCUPADA);
end;

function TablaHash_EsEntradaOcupada(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
begin
TablaHash_EsEntradaOcupada := (TablaHash[hash].estado = OCUPADA);
end;

function TablaHash_EsEntradaVacia(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
begin
TablaHash_EsEntradaVacia := (TablaHash[hash].estado = VACIA);
end;

function TablaHash_EsEntradaEliminada(hash:tIndiceTablaHash;
TablaHash:tTablaHash):boolean;
begin
TablaHash_EsEntradaEliminada := (TablaHash[hash].estado = ELIMINADA);
end;

function TablaHash_ObtenerDato(hash:tIndiceTablaHash;
TablaHash:tTablaHash):tClaveTablaHash;
begin
TablaHash_ObtenerDato := TablaHash[hash].dato;
end;

procedure TablaHash_Insertar(C:tClaveTablaHash; var TablaHash:tTablaHash);

var hash:tIndiceTablaHash;
begin
hash := TablaHash_Buscar(C,TablaHash);
if TablaHash[hash].estado <> OCUPADA then begin
TablaHash[hash].dato := C;
TablaHash[hash].estado := OCUPADA;
end;
end;

procedure TablaHash_Eliminar(C:tClaveTablaHash; var TablaHash:tTablaHash);

var hash:tIndiceTablaHash;
begin
hash := TablaHash_Buscar(C,TablaHash);
if TablaHash[hash].estado = OCUPADA then begin
TablaHash[hash].estado := ELIMINADA;
end;
end;

begin
{ Seccion de inicializacion }
end.

function InvertirString(str:tString):tString;
var i,j:byte; t:char;
begin
i:=1; // apuntamos con i al primer caracter
 j:=length(str); // apuntamos con j al ultimo caracter
while i<j do begin // si i y j son iguales, apuntan al mismo caracter, por lo
tanto no es necesario intercambiarlos
// intercambiamos los caracteres str[i], str[j]
t := str[i];
str[i] := str[j];
str[j] := t;
i +=1; // movemos i un caracter hacia adelante { cambiar por i := i + 1
si no funciona }
j -=1; // movemos j un caracter hacia atras { cambiar por j := j - 1 si
no funciona }
end;
InvertirString := str;
end;

unit Graficos;

interface
uses graph, crt;
function IniciarGrafico():boolean;

implementation
function IniciarGrafico():boolean;
var ControladorGrafico,
ModoGrafico,
CodigoError:integer;
begin
writeln('Inicializando graficos, espera por favor...');
ControladorGrafico := Detect; // establecemos la macro Detect para
ControladoGrafico
InitGraph(ControladorGrafico, ModoGrafico, ''); // inicializamos el grafico
CodigoError := GraphResult; // recogemos el resultado de la inicializacion
del grafico
If GraphResult <> grOK then begin // si hubo un error
IniciarGrafico := false;
clrscr;
writeln('Ocurrio un error de graficos: ', GraphErrorMsg(CodigoError));
writeln('Si no se encuentra el archivo, el error se muestra arriba.');
writeln('Por ello debes cambiar el directorio actual,');
writeln('Localizacion desde C:\ -> TP -> BGI, ' + 'del menu de
archivo');
readln; // hacemos una pausa para leer el error
halt(1); // salimos con error 1
end
else IniciarGrafico := true;
end;
begin
end.