Convertir Número a texto

[Frafive]

Hola Amigos

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

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


Un saludo

[Willi Quintana]

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

Salu2

[ARCC]

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

[Frafive]

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.

[caducca]

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

[Frafive]

Hola amigos

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


Un saludo

[JmGarcia]

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.

[Manuel Valdenebro]

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

[Frafive]

Gracias a todos , me funciona perfectamente


un saludo

[ARCC]

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)

[Manuel Valdenebro]

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.

[ARCC]

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.