FiveTech Support Forums

Hola Amigos

Alguien tiene alguna rutina para convertir un número a texto.

1200,25 -> MIL DOSCIENTOS EUROS CON VEINTICINCO CENTIMOS.

Un saludo

Aqui va:

http://hyperupload.com/download/021257e ... a.prg.html

Salu2

Buen día para todos...

Esta es una función muy sencilla pero efectiva para convertir números en letra, espero te sirva:

//*******######
Function Num2Txt(nCantidad)
//*******######
Local aUni:= {"un", "dos", "tres", "cuatro", "cinco", ;
"seis", "siete", "ocho", "nueve"}

Local aDec:= {"diez", "veinte", "treinta", "cuarenta", "cincuenta",;
"sesenta", "setenta", "ochenta", "noventa"}

Local aCen:= {"cien", "doscientos", "trescientos", ;
"cuatrocientos", "quinientos", "seiscientos",;
"setecientos", "ochocientos", "novecientos"}

Local aAux1:= {"once", "doce", "trece", "catorce", "quince", ;
"dieciseis", "diecisiete", "dieciocho", "diecinueve"}

Local aAux2:= {"veintiun", "veintidos", "veintitres", "veinticuatro",;
"veinticinco", "veintiseis", "veintisiete", ;
"veintiocho", "veintinueve"}

Local nI, nJ, nNumero, nEntero, nCents, nPunto
Local cCadena, cDigitos, cTerminador, cCents
Local aTexto[5], acMoneda:= {" bolivar ", " bolivares "}

AFill(aTexto, "")

nCantidad:= Round(nCantidad, 2)
nEntero := Int(nCantidad)
nCents := nCantidad - nEntero
cCents := Str(nCents)
nPunto := At(".", cCents)

If (nEntero == 0.0)
Return "Cero" + acMoneda[2] + "con 00/100 Ctms."

ElseIf (nEntero == 1.0) .AND. nCents == 0
Return "Un" + acMoneda[1] + "con 00/100 Ctms."
EndIf

cCadena:= StrTran(Str(nEntero, 15), " ", "0")

nJ:= 0
For nI:= 1 To 15 step 3

nJ:= nJ + 1
cDigitos:= SubStr(cCadena, nI, 3)
nNumero := Val(SubStr(cDigitos, 1, 1))

If (nNumero != 0)
aTexto[nJ]:= aTexto[nJ] + aCen[nNumero]
EndIf

If (nNumero = 1 .AND. Val(SUbStr(cDigitos, 2, 2)) != 0)
aTexto[nJ]:= aTexto[nJ] + "to "
Else
aTexto[nJ]:= aTexto[nJ] + " "
EndIf
nNumero:= Val(SubStr(cDigitos, 2, 2))

If (nNumero != 0)

If (nNumero % 10) == 1
cTerminador:= "un "

ElseIf (nNumero % 10) != 0
cTerminador:= aUni[(nNumero % 10)]

EndIf

Do Case
Case nNumero % 10 = 0
aTexto[nJ]:= aTexto[nJ] + aDec[Int(nNumero / 10)] + " "

Case nNumero > 0 .AND. nNumero < 10
aTexto[nJ]:= aTexto[nJ] + cTerminador + " "

Case nNumero > 10 .AND. nNumero < 20
aTexto[nJ]:= aTexto[nJ] + aAux1[(nNumero % 10)] + " "

Case nNumero > 20 .AND. nNumero < 30
aTexto[nJ]:= aTexto[nJ] + aAux2[(nNumero % 10)] + " "

Case nNumero > 30 .AND. nNumero < 100
aTexto[nJ]:= aTexto[nJ] + aDec[Int(nNumero / 10)] + " y " + cTerminador + " "
EndCase
EndIf

aTexto[nJ]:= AllTrim(aTexto[nJ])
Next

For nI:= 1 To 5
If (Len(aTexto[nI]) != 0)
Do Case
Case nI = 1
aTexto[nI]:= aTexto[nI] + IIf(Left(aTexto[nI], 2) = "un", " billon", " billones")

Case nI = 2
aTexto[nI]:= aTexto[nI] + IIf(Len(aTexto[3]) = 0, " mil millones", " mil")

Case nI = 3
aTexto[nI]:= aTexto[nI] + IIf(Left(aTexto[nI], 2) = "un", " millon", " millones")

Case nI = 4
aTexto[nI]:= aTexto[nI] + " mil"
EndCase
EndIf
Next

cCadena := AllTrim(aTexto[1] + " " + aTexto[2] + " " + aTexto[3] + " " + ;
aTexto[4] + " " + aTexto[5])

cCadena := Stuff(cCadena, 1, 1, Upper(Left(cCadena, 1)))
cCadena := cCadena + IIf(nEntero == 1, acMoneda[1], acMoneda[2])
cCadena := cCadena + "con " + Right(cCents, 2) + "/100 Ctms."

Return cCadena

Gracias a los dos, la rutina no me devuelve los decimales, me muestra 50/ 100

Me hace falta una rutina que por ejemplo si tengo un importe de 1250.50 me devuelva MIL DOSCIENTOS CINCUENTA EUROS Y CINCUENTA CENTIMOS.

Frafive wrote:Gracias a los dos, la rutina no me devuelve los decimales, me muestra 50/ 100



Me hace falta una rutina que por ejemplo si tengo un importe de 1250.50 me devuelva MIL DOSCIENTOS CINCUENTA EUROS Y CINCUENTA CENTIMOS.

Frafive, yo uso lo siguiente

numer=space(133)
numer1=space(64)
numer2=space(64)
nro2=int(mando)
nro3=(mando-nro2)*100
nro9=val(right(alltrim(str(nro3,8)),2))
numer1=let_num(nro2)
numer2=let_num(nro9)
mandope=alltrim(numer1)+' CON '+alltrim(numer2)+' CENTAVOS'

//--------------------------------------------------------------------------//
//********************************
//*** PASO DE NUMEROS A LETRAS ***
//********************************
FUNCTION let_num(nro1)
local largo
local letra
local nro2
declare unidad[9],decena[9],centena[9],deci[9],vige[9]

unidad[1]='UNO'
unidad[2]='DOS'
unidad[3]='TRES'
unidad[4]='CUATRO'
unidad[5]='CINCO'
unidad[6]='SEIS'
unidad[7]='SIETE'
unidad[8]='OCHO'
unidad[9]='NUEVE'

decena[1] = "DIEZ"
decena[2] = "VEINTE"
decena[3] = "TREINTA"
decena[4] = "CUARENTA"
decena[5] = "CINCUENTA"
decena[6] = "SESENTA"
decena[7] = "SETENTA"
decena[8] = "OCHENTA"
decena[9] = "NOVENTA"

centena[1] = "CIEN"
centena[2] = "DOSCIENTOS"
centena[3] = "TRESCIENTOS"
centena[4] = "CUATROCIENTOS"
centena[5] = "QUINIENTOS"
centena[6] = "SEISCIENTOS"
centena[7] = "SETECIENTOS"
centena[8] = "OCHOCIENTOS"
centena[9] = "NOVECIENTOS"

deci[1] = "ONCE"
deci[2] = "DOCE"
deci[3] = "TRECE"
deci[4] = "CATORCE"
deci[5] = "QUNICE"
deci[6] = "DIECISEIS"
deci[7] = "DIECISIETE"
deci[8] = "DIECIOCHO"
deci[9] = "DIECINUEVE"

vige[1] = "VEINTIUN"
vige[2] = "VEINTIDOS"
vige[3] = "VEINTITRES"
vige[4] = "VEINTICUATRO"
vige[5] = "VEINTICINCO"
vige[6] = "VEINTISESIS"
vige[7] = "VEINTISIETE"
vige[8] = "VEINTIOCHO"
vige[9] = "VEINTINUEVE"

largo=len(alltrim(str(nro1,8)))
letra=space(0)
do while .t.
do case
case nro1=0
letra=letra+'CERO'
exit
case largo=1 .and. nro1 > 0
letra=letra+unidad[nro1]
exit
case largo=2
if nro1 > 9
do case
case nro1 > 10 .and. nro1 < 20
letra=letra+deci[nro1-10]
case nro1 > 20 .and. nro1 < 30
letra=letra+vige[nro1-20]
case nro1 >= 30 .or. nro1=10 .or. nro1=20
if right(str(nro1,2),1)='0'
letra=letra+decena[nro1/10]
else
letra=letra+decena[nro1/10]+' y '+unidad[val(right(str(nro1,2),1))]
endif
endcase
exit
endif
largo-=1
nro1=val(right(str(nro1,2),1))
case largo=3
if right(str(nro1,3),2)='00'
letra=letra+centena[nro1/100]
exit
else
if nro1 > 99 .and. nro1 < 200
letra=letra+'CIENTO '
else
if nro1 >= 200
letra=letra+centena[nro1/100]+' '
endif
endif
largo-=1
nro1=val(right(str(nro1,3),2))
endif
case largo=4
if right(str(nro1,4),3)='000'
if nro1=1000
letra=letra+'UN MIL'
else
letra=letra+unidad[nro1/1000]+' MIL'
endif
exit
else
if nro1/1000 >= 1 .and. nro1/1000 < 2
letra=letra+'UN MIL '
else
letra=letra+unidad[nro1/1000]+' MIL '
endif
largo-=1
nro1=val(right(str(nro1,4),3))
endif
case largo=5
if right(str(nro1,5),4)='0000'
letra=letra+decena[nro1/10000]+' MIL'
exit
else
if nro1/10000 > 1
nro2=int(nro1/1000)
do case
case nro2 > 10 .and. nro2 < 20
letra=letra+deci[nro2-10]
case nro2 > 20 .and. nro2 < 30
letra=letra+vige[nro2-20]
case nro2 >= 30 .or. nro2=10 .or. nro2=20
if right(str(nro2,2),1)='0'
letra=letra+decena[nro2/10]
else
letra=letra+decena[nro2/10]+' y '+unidad[val(right(str(nro2,2),1))]
endif
endcase
letra=letra+' MIL '
endif
endif
largo-=2
nro1=val(right(str(nro1,5),3))
case largo=6
if right(str(nro1,6),5)='00000'
letra=letra+centena[nro1/100000]+' MIL'
exit
else
if nro1/100000 >= 1 .and. nro1/100000 < 2
letra=letra+' CIENTO '
else
letra=letra+centena[nro1/100000]+' '
if substr(str(nro1,6),2,2)='00'
letra=letra+' MIL '
endif
endif
endif
largo-=1
nro1=val(right(str(nro1,6),5))
endcase
enddo
Return(letra)

Espero te sirva.
Saludos

Hola amigos

Gracias a todos, pero necesito una rutina que me devuelva a Euros y con centimos.

Un saludo

Frafive wrote: Gracias a todos, pero necesito una rutina que me devuelva a Euros y con centimos.

Pues separa (previamente) euros de centimos... y ya esta.

e:=1234.50
a:=funcion(int(e)) // Euros
b:=funcion((int(e-int(e)*100)) // Centimos
Texto:=a+" EUROS CON "+b+" CENTIMOS"
? Texto
MIL DOSCIENTOS TREINTA Y CUATRO EUROS CON CINCUENTA CENTIMOS.

Aqui tienes la función que yo utilizo. Vale para euros (por defecto) pero tambien para monedas "femeninas" como la peseta. El importe en letras,
sale en minúsculas o mayúsculas, con/sin céntimos.

Por ejemplo: nTotal := 1250.50

cTotal:=NumLetra (nTotal)
mil doscientos cincuenta euros con cincuenta céntimos

cTotal:=NumLetra (nTotal, '')
mil doscientos cincuenta con cincuenta céntimos

cTotal:=NumLetra (nTotal, 'BOLIVARES', .T.)
MIL DOSCIENTOS CINCUENTA BOLIVARES CON CINCUENTA CENTIMOS

// ------------------------------------------------------------------------
// Funcion ... : NumLetra
// Descripción : Convierte número a letras (español)
// Autor ......: Valdenebro 2005
// Parámetros .:
// nImporte Importe a convertir a letras
// cMoneda Moneda: Por defecto Euros.- Sin moneda ''
// lMayuscula letras y monedas en mayúsculas: defecto .f.
// lFemenino importes en femenino (uno/una): por defecto .f.
// lCentimos indicar los céntimos con letras o números: .t.
// Ejemplo ....: NumLetra (nImporte)
// ------------------------------------------------------------------------

FUNC NumLetra ( nImporte, cMoneda, lMayuscula, lFemenino, lCentimos )

local nEntero // enteros
local nCentimos, cCenLet := '' // céntimos
local nCien, cCien:='' // unidades, decenas y centenas
local nMil, cMil:='' // millares
local nMillon, cMillon:='' // millones
local cEntLet := '' // resultado final
local lNegativo := .f. // si el importe es negativo

DEFAULT cMoneda := "euros",; // moneda
lFemenino := .f. ,; // femenino
lMayuscula:= .f. ,; // mayusculas
lCentimos := .t. // céntimos en letras

IF nImporte = 0
RETURN ( "cero " + cMoneda )
ENDI

IF nImporte > 999999999.99
MsgStop( "Número demasiado largo" )
RETURN cEntLet
ENDIF

IF nImporte <= 0 // si es numero negativo lo invierte
nImporte:= (nImporte * (-1) )
lNegativo := .t.
ENDI

nEntero := INT (nImporte) // importe entero
nCentimos := ( (nImporte * 100) - (nEntero * 100 ) ) // cantidad de c‚ntimos

/// MILLONES

nMillon := INT ( nEntero / 1000000 )

IF nMillon > 0
IF nMillon = 1
cMillon = "un millón"
ELSE
cMillon := FCENTENA (nMillon) // + " millones "
cMillon += " millones "
ENDI
nEntero := ( nEntero - INT (nMillon * 1000000) )
ENDI

/// MILLARES
nMil := INT ( nEntero / 1000)
IF nMil > 0
DO CASE
CASE nMil = 1
IF nEntero < 2000
cMil = "mil "
ELSE
cMil = "un mil "
ENDI
CASE nMil = 100
cMil = "cien mil "
OTHER
cMil := FCENTENA (nMil) + " mil "
ENDC
nEntero := ( nEntero - INT (nMil * 1000) )
ENDI

/// CENTENAS
nCien := INT ( nEntero / 100)
IF nEntero > 0
IF nEntero = 100
cCien := "cien"
ELSE
cCien := FCENTENA (nEntero)
ENDI
ENDI
IF !EMPTY(cMillon) .and. EMPTY(cMil) .and. EMPTY(cCien) .and. !EMPTY(cMoneda)
cEntLet := RTRIM ( cMillon + " de " ) // enteros en letras
ELSE
cEntLet := RTRIM ( cMillon + cMil + cCien ) // enteros en letras
ENDI

*** centimos
IF nCentimos > 0 // si hay céntimos
IF lCentimos
IF lMayuscula
cCenLet := FCENTENA (nCentimos) + " CENTIMOS" // c‚ntimos en letras
ELSE
cCenLet := FCENTENA (nCentimos) + " céntimos" // c‚ntimos en letras
ENDI
ELSE
cCenLet := ALLTRIM(STR(nCentimos,2,0)) + "/100"
ENDI

ENDI

IF lFemenino // si los importes son en femeninos, p.e. pesetas o libras
cEntLet := STRTRAN(cEntLet, "un", "una", 1)
cEntLet := STRTRAN(cEntLet, "ciento","cienta")
cCenLet := STRTRAN(cCenLet,"un","una", 1)
ENDI

IF nCentimos = 0 // no lleva centimos
cEntLet := cEntLet + " " + cMoneda
ELSE
IF EMPTY(cEntLet) // solo hay céntimos
cEntLet := cCenLet
ELSE // si ponemo centimos con acento sale mal en mayusculas
cEntLet := cEntLet + " " + cMoneda + " con " + cCenLet
ENDI
ENDI

IF lNegativo
cEntLet := "menos " + cEntLet
ENDI

IF lMayuscula
cEntlet := UPPER (cEntlet)
ENDI

RETURN cEntLet

////////////////////////////////////
/// funcion auxiliar de NumLetra
////////////////////////////////////
STATIC FUNCTION FCENTENA (nImporte)
Local nUnidad, nDecena, cRet:= '', cCentena:=''
local nCentena := INT(nImporte/100) // para ver si hay unidades de centenas
local aNumero := ARRAY(900)

aNumero[1] := "un"; aNumero[2] := "dos"; aNumero[3] := "tres"
aNumero[4] := "cuatro"; aNumero[5] := "cinco"; aNumero[6] := "seis"
aNumero[7] := "siete"; aNumero[8] := "ocho" ; aNumero[9] := "nueve"
aNumero[10] := "diez" ; aNumero[11] := "once"; aNumero[12] := "doce"
aNumero[13] := "trece" ; aNumero[14] := "catorce"; aNumero[15] := "quince"
aNumero[16] := "dieciseis" ; aNumero[17] := "diecisiete"
aNumero[18] := "dieciocho" ; aNumero[19] := "diecinueve"
aNumero[20] := "veinte"; aNumero[30] := "treinta"; ;
aNumero[40] := "cuarenta"; aNumero[50] := "cincuenta"
aNumero[60] := "sesenta"
aNumero[70] := "setenta"; aNumero[80] := "ochenta"; aNumero[90] := "noventa"
aNumero[100] := "ciento"; aNumero[200] := "doscientos"
aNumero[300] := "trescientos"; aNumero[400] := "cuatrocientos"
aNumero[500] := "quinientos"; aNumero[600] := "seiscientos"
aNumero[700] := "setecientos"; aNumero[800] := "ochocientos"
aNumero[900] := "novecientos"

IF nCentena > 0
nDecena := ( nImporte - (nCentena*100) )
cCentena := aNumero [ nCentena * 100 ]
cRet := SPACE(1)
ELSE
nDecena := nImporte
ENDI

IF nDecena > 0
IF nDecena > 20
nUnidad := INT( nDecena - ( INT ( nDecena / 10 ) * 10 ) )
nDecena := nDecena - nUnidad
IF nUnidad > 0
IF nDecena < 30
DO CASE
CASE nUnidad = 1
cCentena += cRet + "veintiún"
CASE nUnidad = 3
cCentena += cRet + "veintrés"
OTHER

               cCentena += cRet + "veinti" + aNumero[nUnidad]
         ENDC
      ELSE
         cCentena += cRet + aNumero [nDecena] +  " y " + aNumero [nUnidad]
      ENDI
   ELSE
      cCentena += cRet + aNumero [nDecena]
   ENDI
ELSE
   cCentena += cRet + aNumero[nDecena]
ENDI

ENDI

RETURN cCentena

Gracias a todos , me funciona perfectamente

un saludo

Buen día para todos...

Bueno ya vi que te funciono la funcion del amigo Manuel Valdenebro, pero de todas forma le hice unas mejoras a mi funcion, y ahora puedes trabajar los centimos en letras y/o en números, tambien puedes cambiar a tu gusto el tipo de modeda (mira las 3 primeras líneas de la función).

//*******######
Function Num2Txt(nCantidad)
//*******######

//Utilices o cambie estos valores según su moneda
Local acMoneda := {" euro " , " euros "} //Moneda en singular y plurar
Local acCentimos := {" centimo", " centimos"} //Centimos en singular y plurar
Local lCentsEnletra := .t. //Si es falso muestra los centimos en formato 00/100

Local aTexto[5]
Local cCadena, cDigitos, cTerminador, cCents
Local nI, nJ, nNumero, nEntero, nCents, nPunto

Local aUni:= {"un", "dos", "tres", "cuatro", "cinco", ;
"seis", "siete", "ocho", "nueve"}

Local aDec:= {"diez", "veinte", "treinta", "cuarenta", "cincuenta",;
"sesenta", "setenta", "ochenta", "noventa"}

Local aCen:= {"cien", "doscientos", "trescientos", ;
"cuatrocientos", "quinientos", "seiscientos",;
"setecientos", "ochocientos", "novecientos"}

Local aAux1:= {"once", "doce", "trece", "catorce", "quince", ;
"dieciseis", "diecisiete", "dieciocho", "diecinueve"}

Local aAux2:= {"veintiun", "veintidos", "veintitres", "veinticuatro",;
"veinticinco", "veintiseis", "veintisiete", ;
"veintiocho", "veintinueve"}

//Verifica el tamaño del número
IF nCantidad > 9999999999999.99
MsgStop("Número muy grande para convertir en letras",;
"Mensaje de la Función Num2Txt")
Return nCantidad
EndIf

AFill(aTexto, "")
nCantidad:= Round(nCantidad, 2) //Redondea a 2 los decimales
nEntero := Int(nCantidad)
cCents := StrTran(Str(nCantidad - nEntero), "0.", "")
nCents := Val(cCents)

If (nEntero == 0) .AND. nCents == 0
If lCentsEnletra
Return "cero" + acMoneda[2] + "con cero" + acCentimos[2]
else
Return "cero" + acMoneda[2] + "con 00/100" + acCentimos[2]
EndIF

ElseIf (nCents == 1) .AND. nCents == 0
If lCentsEnletra
Return "un" + acMoneda[1] + "con cero" + acCentimos[2]
else
Return "un" + acMoneda[1] + "con 00/100" + acCentimos[2]
EndIf
EndIf

cCadena:= StrTran(Str(nEntero, 15), " ", "0")

nJ:= 0
For nI:= 1 To 15 step 3

nJ:= nJ + 1
cDigitos:= SubStr(cCadena, nI, 3)
nNumero := Val(SubStr(cDigitos, 1, 1))

If (nNumero != 0)
aTexto[nJ]:= aTexto[nJ] + aCen[nNumero]
EndIf

If (nNumero = 1 .AND. Val(SUbStr(cDigitos, 2, 2)) != 0)
aTexto[nJ]:= aTexto[nJ] + "to "
Else
aTexto[nJ]:= aTexto[nJ] + " "
EndIf
nNumero:= Val(SubStr(cDigitos, 2, 2))

If (nNumero != 0)

If (nNumero % 10) == 1
cTerminador:= "un "

ElseIf (nNumero % 10) != 0
cTerminador:= aUni[(nNumero % 10)]

EndIf

Do Case
Case nNumero % 10 = 0
aTexto[nJ]:= aTexto[nJ] + aDec[Int(nNumero / 10)] + " "

Case nNumero > 0 .AND. nNumero < 10
aTexto[nJ]:= aTexto[nJ] + cTerminador + " "

Case nNumero > 10 .AND. nNumero < 20
aTexto[nJ]:= aTexto[nJ] + aAux1[(nNumero % 10)] + " "

Case nNumero > 20 .AND. nNumero < 30
aTexto[nJ]:= aTexto[nJ] + aAux2[(nNumero % 10)] + " "

Case nNumero > 30 .AND. nNumero < 100
aTexto[nJ]:= aTexto[nJ] + aDec[Int(nNumero / 10)] + " y " + cTerminador + " "
EndCase
EndIf

aTexto[nJ]:= AllTrim(aTexto[nJ])
Next

For nI:= 1 To 5
If (Len(aTexto[nI]) != 0)
Do Case
Case nI = 1
aTexto[nI]:= aTexto[nI] + IIf(Left(aTexto[nI], 2) = "un", " billon", " billones")

Case nI = 2
aTexto[nI]:= aTexto[nI] + IIf(Len(aTexto[3]) = 0, " mil millones", " mil")

Case nI = 3
aTexto[nI]:= aTexto[nI] + IIf(Left(aTexto[nI], 2) = "un", " millon", " millones")

Case nI = 4
aTexto[nI]:= aTexto[nI] + " mil"
EndCase
EndIf
Next

//Genera el número entero
cCadena := LTrim(aTexto[1] + " " + aTexto[2] + " " + aTexto[3] + " " + ;
aTexto[4] + " " + aTexto[5]) + IIf(nEntero == 1, acMoneda[1], acMoneda[2]) + "con "

//Genera el número entero más decimales
If lCentsEnletra //Si lo centimos son en letras
If (nCents % 10) == 1
cTerminador:= "un "

ElseIf (nCents % 10) != 0
cTerminador:= aUni[(nCents % 10)]

EndIf

Do Case

Case nCents = 0
cCadena := cCadena + "cero"

Case nCents % 10 = 0
cCadena := cCadena + aDec[Int(nCents / 10)]

Case nCents > 0 .AND. nCents < 10
cCadena := cCadena + aUni[nCents]

Case nCents > 10 .AND. nCents < 20
cCadena := cCadena + aAux1[(nCents % 10)]

Case nCents > 20 .AND. nCents < 30
cCadena := cCadena + aAux2[(nCents % 10)]

Case nCents > 30 .AND. nCents < 100
cCadena := cCadena + aDec[Int(nCents / 10)] + " y " + cTerminador
EndCase

If nEntero = 0
cCadena := "cero" + cCadena + acCentimos[2]
ElseIf nCents = 1
cCadena := cCadena + acCentimos[1]
Else
cCadena := cCadena + acCentimos[2]
EndIf

Else //Si lo centimos son en números

If nEntero = 0
cCadena := "cero" + cCadena + Right(cCents, 2) + "/100" + acCentimos[2]
Else
cCadena := cCadena + Right(cCents, 2) + "/100" + acCentimos[2]
EndIf
EndIf

Return Upper(cCadena)

Antonio,

Me ha gustado tu idea de poner en singular la moneda y "céntimos" cuando el importe sea UNO. No habia caido en ello, aunque a decir verdad, pocas cosas se pueden comprar por aquí con un euro.

Ya he incorporado esa idea tuya a mi función.

Buen día para todos...

Que tal Manuel Valdenebro, bueno después de 2 años sin programar he vuelto a mis andanzas , me alegra tomes y ideas para mejorar tu función la cual es muy versátil para convertir a letras los números, fítaje que también se pueden convertir números de hasta 15 dígitos (9,999,999,999,999.99) o billones, pero bueno ya en mi país se acaba de realizar una reconversión monetaria y para llegar a billones hay que tener mucho pero mucho dinero.