Club Builder

Namso · Invitado

Hola q tal a todos!
gracis por la atencion prestada, estoy buscando alguna funcion o codigo para un sistema donde hay q convertir cierta cantidad en su equivalente en letra
por ejemplo
2310
DOS MIL TRECIENTOS DIEZ
si alguien me ayudaria, muchas gracias!!!1
suerte!

tronx · Invitado

Mira mi estimado (a)toma esta funcion y pegala como una libreria, esta es la que uso para mis facturas y me gustaria compartirla con alguien.

------- numapal.cpp --------------------
#include "numapal.h"
#include <math.h>

//------------------- Rutinas de Conversion de Numero a Letras --------------------------

__fastcall numapal::numapal()
{
}

__fastcall numapal::~numapal()
{
}

AnsiString __fastcall numapal::Obt(int cantidad)
{
//Dividir entre 1 000 000
//El resultado es "String" + millones
//Dividir entre 1 000
//El resultado es "String" + mil
//dividir entre 100
//El resultado es ciento + "String"
//dividir entre 10
//El resultado es noventa,ochenta, etc + "String"
//El resto de la división entre 10 es "String" + "y" + sies, siete, ocho, etc
String resultado;

int entero;
double resto;
resto = (double)cantidad / 1000000;
if(resto >= 1){
//Agregar mllones
if(resto == 1) return "UN MILLON";
resto = floor(resto);
entero = cantidad -resto*1000000;
if(resto > 1)
resultado = Obt(resto) + " MILLONES "+ Obt(entero);
else
resultado = " UN MILLON " + Obt(entero);
}
else
{
resto = (double)cantidad / 1000;
if(resto >= 1){
if(resto == 1) return "MIL";
//Agregar mil
resto = floor(resto);
entero = cantidad - resto*1000;
if(resto > 1)
resultado = Obt(resto) + " MIL " + Obt(entero);
else
resultado = " UN MIL " + Obt(entero);
}
else
{
resto = (double)cantidad / 100;
if(resto >= 1){
if(resto == 1) return "CIEN";
resto = floor(resto);
entero = cantidad - resto*100;
if(resto > 1)
resultado = cientos(resto)+" "+ Obt(entero);
else
resultado = "CIENTO " + Obt(entero);
//Agregar ciento al principio
}
else
{
resto = (double)cantidad /10;
if(resto > 1){
if(resto == 1) return "DIEZ";
resto = floor(resto);
entero = cantidad -resto*10;
if(entero == 0) resultado = decenas(resto);
else
if(cantidad > 20)
resultado = decenas2(resto)+unidades(entero);
else{
resultado = unidades(cantidad);
}
}else
resultado = unidades(cantidad);
}
}

}
return resultado;
}

AnsiString __fastcall numapal::cientos(int cantidad)
{
switch (cantidad){
case 9: return "NOVECIENTOS";
case 8: return "OCHOCIENTOS";
case 7: return "SETECIENTOS";
case 6: return "SEISCIENTOS";
case 5: return "QUINIENTOS";
case 4: return "CUATROCIENTOS ";
case 3: return "TRESCIENTOS";
case 2: return "DOSCIENTOS";
case 1: return "CIEN";
default: return "";
}
}
AnsiString __fastcall numapal::decenas2(int cantidad)
{
switch (cantidad){
case 9: return "NOVENTA Y ";
case 8: return "OCHENTA Y ";
case 7: return "SETENTA Y ";
case 6: return "SESENTA Y ";
case 5: return "CINCUENTA Y ";
case 4: return "CUARENTA Y ";
case 3: return "TREINTA Y ";
case 2: return "VEINTE Y ";
case 1: return "DIEZ";
default: return "";
}
}

AnsiString __fastcall numapal::decenas(int cantidad)
{
switch (cantidad){

case 9: return "NOVENTA";
case 8: return "OCHENTA";
case 7: return "SETENTA";
case 6: return "SESENTA";
case 5: return "CINCUENTA";
case 4: return "CUARENTA";
case 3: return "TREINTA";
case 2: return "VEINTE";
case 1: return "DIEZ";
default: return "";
}
}
AnsiString _fastcall numapal::unidades(int cantidad)
{
switch(cantidad){
case 20: return "VEINTE";
case 19: return "DIECINUEVE";
case 18: return "DIECIOCHO";
case 17: return "DIECISIETE";
case 16: return "DIECISEIS";
case 15: return "QUINCE";
case 14: return "CATORCE";
case 13: return "TRECE";
case 12: return "DOCE";
case 11: return "ONCE";
case 10: return "DIEZ";
case 9: return "NUEVE";
case 8: return "OCHO";
case 7: return "SIETE";
case 6: return "SEIS";
case 5: return "CINCO";
case 4: return "CUATRO";
case 3: return "TRES";
case 2: return "DOS";
case 1: return "UN";
default: return "";
}
}

AnsiString __fastcall sincomas(AnsiString cadena_z)
{
AnsiString cadtmp_z = "";
for (int ii_z=1; ii_z <= cadena_z.Length(); ii_z++) {
if(
(cadena_z[ii_z] >= '0' && cadena_z[ii_z] <='9') | |
cadena_z[ii_z] == '-' | |
cadena_z[ii_z] == '+' | |
cadena_z[ii_z] == '.'
)
cadtmp_z=cadtmp_z+cadena_z[ii_z];
}
return(cadtmp_z);
}

AnsiString __fastcall llenastr(AnsiString cadena_z, int tam_z, int hacia_z)
{
AnsiString cadtmp_z;
if (cadena_z.Length() > tam_z) {
cadena_z=cadena_z.SubString(1,tam_z);
}
switch (hacia_z) {
case DER:
cadtmp_z=cadena_z;
for (int ii_z=cadena_z.Length(); ii_z <= tam_z; ii_z++) cadtmp_z=cadtmp_z+" ";
break;
case IZQ:
for (int ii_z=1; ii_z <= tam_z-cadena_z.Length(); ii_z++) cadtmp_z=cadtmp_z+" ";
cadtmp_z=cadtmp_z+cadena_z;
break;
}
return(cadtmp_z);
}

int valsti(AnsiString cadena_z)
{
int valret_z;
try { valret_z=StrToInt(sincomas(cadena_z)); }
catch (...) { valret_z=0; }
return valret_z;
}

float valstf(AnsiString cadena_z)
{
float valret_z;
try { valret_z=StrToFloat(sincomas(cadena_z)); }
catch (...) { valret_z=0; }
return valret_z;
}

--------- numapal.h -----------
#ifndef numapalH
#define numapalH
#include <vcl.h>
#define DER 2
#define IZQ 1

//---------------------------------------------------------------------------
AnsiString __fastcall sincomas(AnsiString cadena_z);
AnsiString __fastcall llenastr(AnsiString cadena_z, int tam_z, int hacia_z);
int valsti(AnsiString cadena_z);
float valstf(AnsiString cadena_z);

class numapal
{
private: // User declarations
public: // User declarations
__fastcall numapal ();
__fastcall ~numapal();
AnsiString __fastcall Obt(int cantidad);
AnsiString __fastcall cientos(int cantidad);
AnsiString __fastcall decenas2(int cantidad);
AnsiString __fastcall decenas(int cantidad);
AnsiString __fastcall unidades(int cantidad);
};
//---------------------------------------------------------------------------
#endif

Ahora en tu proyecto nomas lo agregas e incluyes "numapal.h" en el programa que lo necesites y cuando lo necesites usar nomas pones esta instruccion:

numapal numapal_z;
numapal_z.Obt(cantidad_z);
y te devuelve la cadena en palabras
nomas la imprimes.

OK ?
Si tienes librerias truculentas para intercambiar no dudes en hacerlo.
superric@hotmail.com
tronx@chapur.com

------ : ) -----

Mario · Invitado

Felicidades por ese programa, yo ya lo use y
funciona perfectamente. Te la llevaste. Ahora si se quiere usar con decimales ya es muy sencillo, solo algunas operaciones con cadenas de caracteres y listo. Nuevamente
Felicidades!