Przekształć liczby w słowa w systemie lakh / crore (2023)

Piszę kod, który konwertuje daną liczbę na słowa, oto, co otrzymałem po googlowaniu. Ale myślę, że to trochę za długo jak na tak proste zadanie.
Dwa wyrażenia regularne i dwaDopętli, chcę czegoś prostszego.

Staram się to osiągnąć w jak najmniejszej liczbie linii kodu. oto co do tej pory wymyśliłem:

Jakieś sugestie?

byłth = ['','tysiąc','milion','miliard','bilion'];byłdg = ['zero','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć'];byłtn = ['dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];byłtw = ['20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];funkcjonować do słów(S) { s = s.do Ciągu(); s = s.zastępować(/[, ]/G,'');Jeśli(s!=naciśnijPływak(S))powrót „nie liczba”;byłx = s.indeks('.');Jeśli(x == -1) x = s.długość;Jeśli(x >15)powrót 'za duży';byłn = s.podział('');byłstr ='';byłsk =0;Do(byłja=0; ja Jeśli((x-i)%3==2) {Jeśli(n[i] ==„1”) { str += tn[Numer(n[i+1])] +''; i++; sk=1; }w przeciwnym razie Jeśli(n[i]!=0) { str += tw[n[i]-2] +''; sk=1; } }w przeciwnym razie Jeśli(n[i]!=0) {// 0235str += dg[n[i]] +'';Jeśli((x-i)%3==0) str +=„sto”; sk=1; }Jeśli((x-i)%3==1) {Jeśli(sk) str += th[(x-i-1)/3] +''; sk=0; } }Jeśli(x!= s.długość) {byłi = tak.długość; str +='punkt ';Do(byłi=x+1; i''; }powrótul.zastępować(/s+/g,'');}

Ponadto powyższy kod konwertuje na angielski system numeracji, taki jak Million/Billion, potrzebuję południowoazjatyckiego systemu numeracji, takiego jak Lakhs i Crores.

“Zwodniczoproste zadanie”. –Taca ziemniaczana

Rzeczywiście. W szczegółach tego problemu tkwi wiele małych diabłów. Rozwiązanie było bardzo zabawne.

EDYTOWAĆ:Ta aktualizacja ma znacznie bardziej kompozycyjne podejście. Wcześniej istniała jedna duża funkcja, która obejmowała kilka innych zastrzeżonych funkcji. Zamiast tego tym razem definiujemy ogólne funkcje wielokrotnego użytku, które można wykorzystać do wielu różnych zadań. Więcej o nich po przyjrzeniu sięliczba słówsamo …

// numToWords :: (Liczba a, Ciąg a) => a -> Ciągpozwalać liczba słów= n => {pozwalaćza = ['','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć','dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];pozwalaćb = ['','','20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];pozwalaćg = ['','tysiąc','milion','miliard','bilion','kwadrylion',„kwintylion”,„sekstylion”,„septylion”,„oktylion”,„nonillion”];// ta część nadal jest naprawdę paskudna // może później edytować to ponownie, aby pokazać, jak Monoids może to naprawić pozwalać makeGroup= ([jednostki, dziesiątki, huny]) => {powrót[liczba(uwaga) ===0?'': a [hun] +„sto”,liczba(jednostki) ===0? b[dziesiątki] : b[dziesiątki] && b[dziesiątki] +'-'||'', a[dziesiątki+jednostki] || a [je] ].dołączyć(''); };// konstruktor "tysięcy"; chyba nie ma na to dobrych nazw pozwalać tysiąc= (grupa, ja) => grupa ===''? Grupa :`${grupa} ${g[i]}`;// wykonać ! Jeśli(typn ==='numer')powrót liczba słów(Strunowy(N));Jeśli(n ===„0”)powrót 'zero';powrótkomp (kawałek(3)) (odwracać) (arr(N)) .mapa(makeGroup) .mapa(tysiące) .filtr(komp(nie)(jestpusty)) .odwracać() .dołączyć('');};

Oto zależności:

Zauważysz, że nie wymagają one prawie żadnej dokumentacji, ponieważ ich intencje są natychmiast jasne.kawałekmoże być jedynym, którego przetrawienie zajmuje chwilę, ale naprawdę nie jest tak źle. Ponadto nazwa funkcji dość dobrze wskazuje, co robi, i prawdopodobnie jest to funkcja, z którą się już spotkaliśmy.

konst arr= x =>Szyk.z(X);konst liczba= x =>Numer(x) ||0;konst ul= x =>Strunowy(X);konst jest pusty= xs => xs.długość===0;konst Brać= n =>xs=>xs.plasterek(0,N);konst upuszczać= n =>xs=>xs.plasterek(N);konst odwracać= xs => xs.plasterek(0).odwracać();konst komp= fa =>G=> X=>fa (g (x));konst nie= x => !x;konst kawałek= n =>xs=> jest pusty(xs) ? [] : [Brać(n)(xs), ...kawałek (n) (kropla (n) (xs))];

„Więc dzięki temu jest lepiej?”

Zobacz, jak znacznie uporządkowano kod

// NOWY KOD (obcięty)powrótkomp (kawałek(3)) (odwracać) (arr(N)) .mapa(makeGroup) .mapa(tysiące) .filtr(komp(nie)(jestpusty)) .odwracać() .dołączyć('');// STARY KOD (obcięty)pozwalać grp= n => („000”+ n).podstr(-3);pozwalać Rem= n => n.podstr(0, N.długość-3);pozwalać Cons= xs =>X=> G=>X ? [x, g &&''+ g ||'','', xs].dołączyć('') : xs;pozwalać iter= str =>I=> X=> R=>{Jeśli(x ===„000”&& R.długość===0)powrótstr;powrót iter(Cons(str)(fmt(x))(g[i])) (i+1) (grp(R)) (Rem(R));};powrót iter('')(0)(grp(Strunowy(N)))(Rem(Strunowy(N)));

Co najważniejsze, funkcje użytkowe, które dodaliśmy w nowym kodzie, mogą być używane w innych miejscach w Twojej aplikacji. Oznacza to, że jako efekt uboczny wdrożenialiczba słóww ten sposób pozostałe funkcje otrzymujemy gratis. Soda bonusowa!

Niektóre testy

konsola.dziennik(liczba słów(11009));//=> jedenaście tysięcy dziewięćkonsola.dziennik(liczba słów(10000001));//=> dziesięć milionów jedenkonsola.dziennik(liczba słów(987));//=> dziewięćset osiemdziesiąt siedemkonsola.dziennik(liczba słów(1015));//=> tysiąc piętnaściekonsola.dziennik(liczba słów(55111222333));//=> pięćdziesiąt pięć miliardów sto jedenaście milionów dwieście// dwadzieścia dwa tysiące trzysta trzydzieści trzykonsola.dziennik(liczba słów("999999999999999999999991"));//=> dziewięćset dziewięćdziesiąt dziewięć sekstylionów dziewięćset dziewięćdziesiąt dziewięć// kwintylion dziewięćset dziewięćdziesiąt dziewięć biliardów dziewięćset// dziewięćdziesiąt dziewięć bilionów dziewięćset dziewięćdziesiąt dziewięć miliardów dziewięć// sto dziewięćdziesiąt dziewięć milionów dziewięćset dziewięćdziesiąt dziewięć tysięcy// dziewięćset dziewięćdziesiąt jedenkonsola.dziennik(liczba słów(6000753512));//=> sześć miliardów siedemset pięćdziesiąt trzy tysiące pięćset// dwanaście

Działające demo

Możesz transpilować kod za pomocąbabel.jsjeśli chcesz zobaczyć wariant ES5

Możesz spróbować rekurencyjnie. Działa dla liczb od 0 do 999999. Pamiętaj o tym(~~)robi to samo co Math.floor

byłliczba =„zero jeden dwa trzy cztery pięć sześć siedem osiem dziewięć dziesięć jedenaście dwanaście trzynaście czternaście piętnaście szesnaście siedemnaście osiemnaście dziewiętnaście”.podział(" ");byłdziesiątki =„dwadzieścia trzydzieści czterdzieści pięćdziesiąt sześćdziesiąt siedemdziesiąt osiemdziesiąt dziewięćdziesiąt”.podział(" ");funkcjonować liczba2słowa(N){Jeśli(n <20)powrótczy [n]byłcyfra = n%10;Jeśli(n <100)powrótdziesiątki[~~(n/10)-2] + (cyfra?"-"+ czy [cyfry]:"");Jeśli(n <1000)powrótczy [~~(n/100)] +"sto"+ (n%100==0?"":" "+liczba2słowa(N%100));powrót liczba2słowa(~~(n/1000)) +„tysiąc”+ (n%1000!=0?" "+liczba2słowa(N%1000):"");}

Podoba mi się wynik, który tutaj uzyskałem, który moim zdaniem jest łatwy do odczytania i wystarczająco krótki, aby pasował jako rozwiązanie.

funkcjonować NumInWords(liczba) {konstpierwszy = ['','jeden ',„dwa”,'trzy ',„cztery”,'pięć ',„sześć”,„siedem”,'osiem ','dziewięć ','dziesięć ',„jedenaście”,„dwanaście”,„trzynaście”,„czternaście”,'piętnaście ',„szesnaście”,„siedemnaście”,'osiemnaście ','dziewiętnaście '];konstdziesiątki = ['','','20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];konstszalony = ['','tysiąc','milion','miliard','bilion'];pozwalaćsłowo ='';Do(pozwalaćja =0; ja < szalony.długość; i++) {pozwalaćtymczasowa liczba = liczba% (100*Matematyka.pow(1000,I));Jeśli(Matematyka.podłoga(tempNumer/Matematyka.pow(1000,i)) !==0) {Jeśli(Matematyka.podłoga(tempNumer/Matematyka.pow(1000,i)) <20) { słowo = pierwszy[Matematyka.podłoga(tempNumer/Matematyka.pow(1000,i))] + mad[i] +''+ słowo; }w przeciwnym razie{ słowo = dziesiątki[Matematyka.podłoga(tempNumer/(10*Matematyka.pow(1000,i)))] +'-'+ pierwszy[Matematyka.podłoga(tempNumer/Matematyka.pow(1000,I))%10] + wściekły[i] +''+ słowo; } } tempNumber = liczba%(Matematyka.pow(1000, ja+1));Jeśli(Matematyka.podłoga(tempNumer/(100*Matematyka.pow(1000,i))) !==0) słowo = pierwszy[Matematyka.podłoga(tempNumer/(100*Matematyka.pow(1000,i)))] +„sto”+ słowo; }powrótsłowo;}konsola.dziennik(NumInWords(89754697976431))

A wynikiem jest:

osiemdziesiąt dziewięć bilionów siedemset pięćdziesiąt cztery miliardy sześćset dziewięćdziesiąt siedem milionów dziewięćset siedemdziesiąt sześć tysięcy czterysta trzydzieści jeden

Zmodyfikowałem kod MC Shamana, aby naprawić błąd związany z pojedynczym numerem i pojawianiem się przed nim

funkcjonować numberToangielski(N) {byłciąg = n.do Ciągu(), jednostki, dziesiątki, skale, start, koniec, chunks, chunksLen, chunk, ints, i, word, Words i ='I';/* Usuń spacje i przecinki */ciąg = ciąg.zastępować(/[, ]/G,"");/* Czy liczba jest zerowa? */ Jeśli(parseInt(ciąg znaków) ===0) {powrót 'zero'; }/* Tablica jednostek jako słowa */jednostki = ['','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć','dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];/* Tablica dziesiątek jako słowa */dziesiątki = ['','','20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];/* Tablica skal jako słowa */łuski = ['','tysiąc','milion','miliard','bilion','kwadrylion',„kwintylion”,„sekstylion”,„septylion”,„oktylion”,„nonillion”,„decyzja”,„undecylion”,„duodecylion”,„tredecylion”,cztery decyliony,„quindecylion”,„seksdecylion”,„sześć decylionów”,„oktodecylion”,„decylion listopada”,dwadzieścia milionów,„centylion”];/* Podziel argument użytkownika na 3-cyfrowe części od prawej do lewej */początek = ciąg.długość; kawałki = [];chwila(początek >0) { koniec = początek; kawałki.naciskać( strunowy.plasterek( ( początek =Matematyka.maks(0, początek -3) ), koniec ) ); }/* Sprawdź, czy funkcja ma wystarczającą liczbę słów skali, aby móc zawęzić argument użytkownika */kawałkiLen = kawałki.długość;Jeśli( chunksLen > skale .długość) {powrót ''; }/* Dodaj łańcuch do każdej liczby całkowitej w każdym fragmencie */słowa = [];Do( ja =0; i < kawałkiLen; i++ ) { porcja =parseInt( kawałki[i] );Jeśli( kawałek ) {/* Podziel fragment na tablicę pojedynczych liczb całkowitych */int = kawałki [i].podział('').odwracać().mapa(naciśnijPływak);/* Jeśli liczba całkowita dziesiątek wynosi 1, tj. 10, dodaj 10 do liczby całkowitej jednostek */ Jeśli( int[1] ===1) { int[0] +=10; }/* Dodaj słowo skalowania, jeśli porcja nie jest równa zeru i element tablicy istnieje */ Jeśli( ( słowo = skala[i] ) ) { słowa.naciskać( słowo ); }/* Dodaj słowo jednostki, jeśli element tablicy istnieje */ Jeśli( ( słowo = jednostki [ liczby całkowite [0] ] ) ) { słowa.naciskać( słowo ); }/* Dodaj słowo dziesiątek, jeśli element tablicy istnieje */ Jeśli( ( słowo = dziesiątki [ liczba całkowita [1] ] ) ) { słowa.naciskać( słowo ); }/* Dodaj ciąg znaków „i” po jednostkach lub dziesiątkach, jeśli: */ Jeśli( int[0] || int[1] ) {/* Fragment ma liczbę całkowitą setek lub fragment jest pierwszym z wielu fragmentów */ Jeśli( int[2] || (ja +1) > kawałkiLen ) { słowa.naciskać( I ); } }/* Dodaj setki słów, jeśli element tablicy istnieje */ Jeśli( ( słowo = jednostki [ liczby całkowite [2] ] ) ) { słowa.naciskać(słowo +„sto”); } } }powrótsłowa.odwracać().dołączyć(''); }// - - - - - Testy - - - - - -funkcjonować postać(wartość) { finalRys =numberToangielski(val);dokument.getElementById("słowa").wewnętrzny HTML= końcowaRysunek;}

<Zakres ID="słowa">Zakres><wejście ID="numer" typ="tekst" wł.klawisz=liczba (ta.wartość)/>

Aktualizacja luty 2021 r

Chociaż to pytanie zostało zadane ponad 8 lat temu z różnymi rozwiązaniami i odpowiedziami, najłatwiejsze rozwiązanie, które można łatwo zaktualizować w celu zwiększenia skali, po prostu wstawiając nazwę do tablicy bez modyfikacji kodu; a także użycie bardzo krótkiego kodu to poniższa funkcja.

To rozwiązanie jest przeznaczone do czytania liczb w języku angielskim (nie w systemie południowoazjatyckim) i wykorzystuje standardowy amerykański angielski (amerykański sposób) zapisywania dużych liczb. tj. nie korzysta z systemu brytyjskiego (system brytyjski używa słowa „i”, jak: „trzysta dwadzieścia dwa tysiące”).

Dostępne są przypadki testowe, a także pole wejściowe.

Pamiętaj, że konwertujemy na słowa „liczby całkowite bez znaku”.

Możesz zwiększyćskala[] tablicapoza Sextillionem.

Ponieważ funkcja jest krótka, możesz jej użyć jako funkcji wewnętrznej, powiedzmy, do przeliczania walut, gdzie używane są liczby dziesiętne i wywołać ją dwukrotnie dla części całkowitej i części ułamkowej.

Mam nadzieję, że jest to przydatne.

/************************************************ ********@funkcjonować: liczba całkowitaToWords()*@zamiar: Konwertuje liczby całkowite bez znaku na słowa* przy użyciu tablicy trójek łańcuchowych.*@wersja: 1,05*@autor: Mohsen Alyafei*@data: 15 stycznia 2021 r.*@param: {liczba} [liczba całkowita lub ciąg znaków]*@zwroty: {string} Słowny ciąg liczb******************************************** **************/konst Jedynki= ["","Jeden","Dwa","Trzy",„Cztery”,"Pięć","Sześć",„Siedem”,"Osiem","Dziewięć","Dziesięć","Jedenaście","Dwanaście","Trzynaście","Czternaście","Piętnaście","Szesnaście","Siedemnaście","Osiemnaście","Dziewiętnaście"],Kilkadziesiąt= ["","","20","Trzydzieści","Czterdzieści","Pięćdziesiąt","Sześćdziesiąt","Siedemdziesiąt","Osiemdziesiąt","Dziewięćdziesiąt","Sto"],Skala= ["","Tysiąc","Milion","Miliard","Bilion","Kwadrylion",„Kwintylion”,„Sekstylion”];//==================================konst liczba całkowita na słowa= (n =0) => {Jeśli(n ==0)powrót "Zero";// sprawdź zeron = („0”.powtarzać(2*(n+="").długość%3) + n).mecz(/.{3}/g);// utwórz tablicę trójekJeśli(N.długość>Skala.długość)powrót "Za duży";// sprawdź, czy jest większy niż tablica scalepozwalaćna zewnątrz ="";powrótN.dla każdego((Trójka, poz) =>{// pętla do tablicy dla każdej trójkiJeśli(+Tryplet) { out+=''+(+Tryplet[0]?Jedynki[+Tryplet[0]]+''+Kilkadziesiąt[10] :"") +''+ (+Tryplet.podstr(1)<20?Jedynki[+Tryplet.podstr(1)] :Kilkadziesiąt[+Tryplet[1]] + (+Tryplet[2]?"-":"") +Jedynki[+Tryplet[2]]) +''+Skala[N.długość-pos-1]; }}),na zewnątrz.zastępować(/s+/g,'').przycinać();};// leniwa praca używająca trim()//==================================//=========================================// Przypadki testowe//=========================================byłr=0;// śledzenie testówr |=test(0,"Zero"); r |=test(5,"Pięć"); r |=test(10,"Dziesięć"); r |=test(19,"Dziewiętnaście"); r |=test(33,"Trzydzieści trzy"); r |=test(100,„Sto”); r |=test(111,"Sto jedenaście"); r |=test(890,„Osiemset dziewięćdziesiąt”); r |=test(1234,„Tysiąc dwieście trzydzieści cztery”); r |=test(12345,„Dwanaście tysięcy trzysta czterdzieści pięć”); r |=test(123456,„Sto dwadzieścia trzy tysiące czterysta pięćdziesiąt sześć”); r |=test(1234567,„Jeden milion dwieście trzydzieści cztery tysiące pięćset sześćdziesiąt siedem”); r |=test(12345678,„Dwanaście milionów trzysta czterdzieści pięć tysięcy sześćset siedemdziesiąt osiem”); r |=test(123456789,„Sto dwadzieścia trzy miliony czterysta pięćdziesiąt sześć tysięcy siedemset osiemdziesiąt dziewięć”); r |=test(1234567890,„Jeden miliard dwieście trzydzieści cztery miliony pięćset sześćdziesiąt siedem tysięcy osiemset dziewięćdziesiąt”); r |=test(1001,„Tysiąc jeden”); r |=test(10001,„Dziesięć tysięcy jeden”); r |=test(100001,„Sto tysięcy jeden”); r |=test(1000001,„Jeden milion jeden”); r |=test(10000001,„Dziesięć milionów jeden”); r |=test(100000001,„Sto milionów jeden”); r |=test(12012,„Dwanaście tysięcy dwanaście”); r |=test(120012,„Sto dwadzieścia tysięcy dwanaście”); r |=test(1200012,„Jeden milion dwieście tysięcy dwanaście”); r |=test(12000012,„Dwanaście milionów dwanaście”); r |=test(120000012,„Sto dwadzieścia milionów dwanaście”); r |=test(75075,„Siedemdziesiąt pięć tysięcy siedemdziesiąt pięć”); r |=test(750075,„Siedemset pięćdziesiąt tysięcy siedemdziesiąt pięć”); r |=test(7500075,„Siedem milionów pięćset tysięcy siedemdziesiąt pięć”); r |=test(75000075,„Siedemdziesiąt pięć milionów siedemdziesiąt pięć”); r |=test(750000075,„Siedemset pięćdziesiąt milionów siedemdziesiąt pięć”); r |=test(1000,"Tysiąc"); r |=test(1000000,"Jeden milion"); r |=test(1000000000,"Jeden bilion"); r |=test(1000000000000,"Jeden trylion"); r |=test("1000000000000000",„Jeden kwadrylion”); r |=test("10000000000000000000",„Jeden kwintylion”); r |=test("1000000100100100100",„Jeden kwintylion sto miliardów sto milionów sto tysięcy sto”);Jeśli(r==0)konsola.dziennik(„Wszystkie testy zdane”.);//=====================================// Funkcja testera//=====================================funkcjonować test(n, powinien) {pozwalaćwynik =liczba całkowita na słowa(N);Jeśli(wynik !== powinien) {konsola.dziennik(`${n}Wyjście :${wynik}N${n}Powinien być:${powinien}`);powrót 1;}}

<wejście typ="tekst" nazwa="numer" symbol zastępczy=„Proszę wprowadzić liczbę całkowitą” wł.klawisz="word.innerHTML=integerToWords(this.value)"/><dz ID="słowo">dz>

Konwersja ciągu wejściowego na liczbę zamiast przechowywania go jako ciągu ogranicza rozwiązanie do maksymalnej dozwolonej wartości zmiennoprzecinkowej/liczby całkowitej na tej maszynie/przeglądarce. Mój skrypt poniżej obsługuje waluty do 1 biliona dolarów – 1 cent :-). I może zostać rozszerzony, aby obsłużyć do 999 bilionów, dodając 3 lub 4 linie kodu.

byłjedynki = ["","Jeden","Dwa","Trzy",„Cztery”,"Pięć","Sześć",„Siedem”,"Osiem","Dziewięć","Dziesięć","Jedenaście","Dwanaście","Trzynaście","Czternaście","Piętnaście","Szesnaście","Siedemnaście","Osiemnaście","Dziewiętnaście"];byłdziesiątki = ["","","20","Trzydzieści","Czterdzieści","Pięćdziesiąt","Sześćdziesiąt","Siedemdziesiąt","Osiemdziesiąt","Dziewięćdziesiąt"];funkcjonować słowa999(n999) {// n999 jest liczbą całkowitą mniejszą lub równą 999.//// Zaakceptuj dowolne 3 cyfry int włącznie z 000 i 999 i zwróć słowa.// byłsłowa ='';był Hn=0;byłn99 =0;Hn=Matematyka.podłoga(n999 /100);// # setek w nim Jeśli(Hn>0) {// jeśli co najmniej jeden 100słowa =słowa99(Hn) +„sto”;// jedno wywołanie dla setek} n99 = n999 - (Hn*100);// odejmij setki.słowa += ((słowa =='')?'':'') +słowa99(n99);// połącz setki z dziesiątkami i jednościami. powrótsłowa;}// słowa funkcyjne999( n999 )funkcjonować słowa99(n99) {// n99 jest liczbą całkowitą mniejszą lub równą 99.//// Zaakceptuj dowolne 2 cyfry int włącznie z 00 i 99 i zwróć słowa.// byłsłowa ='';był Dn=0;był I=0;Dn=Matematyka.podłoga(n99 /10);// # dziesiątek I= n99%10;// jednostki Jeśli(Dn>0||I>0) {Jeśli(Dn<2) { słowa += jedności[Dn*10+I];// słowa dla # < 20}w przeciwnym razie{ słowa += dziesiątki[Dn];Jeśli(I>0) słowa +="-"+ jedynki[I]; } }// jeśli (Dn > 0 || Un > 0 ) powrótsłowa;}// słowa funkcyjne99( n99 )funkcjonować getAmtInWords(identyfikator1, identyfikator2) {// użyj wartości liczbowej id1, aby wypełnić tekst w id2//// Odczytaj pole kwoty liczbowej i przekonwertuj na kwotę słowną// byłt1 =dokument.getElementById(id1).wartość;byłt2 = t1.przycinać(); amStr = t2.zastępować(/,/G,'');// 123 456 789,12 $ = 123456789,12dotPos = amtStr.indeks('.');// pozycja kropki przed centami, -ve jeśli nie istnieje. Jeśli(punkt kropki >0) { dolarów = amtStr.plasterek(0kropkaPoz);// 1234,56 = 1234centy = biuroStr.plasterek(kropkaPoz+1);// 1234,56 = 0,56}w przeciwnym razie Jeśli(punkt kropki ==0) { dolarów =„0”; centy = biuroStr.plasterek(kropkaPoz+1);// 1234,56 = 0,56}w przeciwnym razie{ dolarów = amtStr.plasterek(0);// 1234 = 1234centy =„0”; } t1 ='000000000000'+ dolary;// aby rozszerzyć do bilionów, użyj 15 zerdolary = t1.plasterek(-12);// i -15 tutaj.miliardy =Numer(dolary.podstr(0,3)); miliony =Numer(dolary.podstr(3,3)); tysiące =Numer(dolary.podstr(6,3)); setki =Numer(dolary.podstr(9,3)); t1 =słowa999(miliardy); bW = t1.przycinać();// Miliardy w słowacht1 =słowa999(miliony); mW = t1.przycinać();// Miliony w słowacht1 =słowa999(tysiące); tW = t1.przycinać();// Tysiące słówt1 =słowa999(setki); hW = t1.przycinać();// Setki słowniet1 =słowa99(centy); cW = t1.przycinać();// Centy słownie byłmartwe biuro ='';Jeśli(bW !='') totAmt += ((totAmt !='')?'':'') + bW +' Miliard';Jeśli(mW !='') totAmt += ((totAmt !='')?'':'') + mW +„Milion”;Jeśli(tW !='') totAmt += ((totAmt !='')?'':'') + tW +„Tysiąc”;Jeśli(hW !='') totAmt += ((totAmt !='')?'':'') + hW +„Dolary”;Jeśli(cW !='') totAmt += ((totAmt !='')?' I ':'') + cW +„ Centy ”;// alert('totAmt = ' + totAmt); // wyświetl słowa w alerciet1 =dokument.getElementById(id2).wartość; t2 = t1.przycinać();Jeśli(t2 =='')dokument.getElementById(id2).wartość= martwy urząd;powrót FAŁSZ;}// funkcja getAmtInWords( id1, id2 )// ======================== [ Kod końcowy ] ==================== ================

Przetestuj na TypeScript Playground

Wersja hindi

klasa N2WHindi{ prywatnystatycznytylko czytaćzeroDo99: ciąg[] ='|jeden|dwa|trzy|cztery|pięć|sześć|siedem|osiem|dziewięć|dziesięć|jedenaście|dwanaście|trzynaście|czternaście|piętnaście|szesnaście|siedemnaście|osiemnaście|dziewiętnaście|dwadzieścia|dwadzieścia jeden|dwadzieścia trzy| dwadzieścia cztery| dwadzieścia pięć | dwadzieścia sześć | dwadzieścia siedem | dwadzieścia osiem | trzydzieści dziewięć | pięćdziesiąt|pięćdziesiąt jeden|pięćdziesiąt dwa|pięćdziesiąt cztery|pięćdziesiąt pięćdziesiąt|sześćdziesiąt szósty|sześćdziesiąt osiem|sześćdziesiąt dziewięć|sześćdziesiąt -jeden|sześćdziesiąt dwa|sześćdziesiąt trzy|sześćdziesiąt-czwarta|sześćdziesiąt-pięć|sześćdziesiąt-szósta|sześćdziesiąt-siódma|sześćdziesiąt-osiem|siedemdziesiąt dziewięć|siedemdziesiąt|siedemdziesiąt jeden|siedemdziesiąt-dwa|siedemdziesiąt-trzy|siedemdziesiąt -cztery | siedemdziesiąt pięć | siedemdziesiąt sześć |.podział('|'); prywatnystatycznytylko czytaćmiejsce: ciąg[] =„tysiąc|milionów|krore|miliard|bilionów|zero".podział('|'); publicznystatyczny konwertować(X: string): string {pozwalać N: liczba = x.długość; x = n ===0?„00”: n ===1|| N %2===0?„0”+ x : x; n = x.długość;pozwalać R: string = N2WHindi.zeroDo99[X.kod znaku o godz((n-=2)) *10+ x.kod znaku o godz(n +1) -528];Jeśli(n >0) {konst w: string = N2WHindi.zeroDo99[X.kod znaku o godz((n-=1)) -48];Jeśli(v) r = v +„sto”+ (r?''+ R:''); }Do(pozwalaćja =0; n >0; i++) {konst w: string = N2WHindi.zeroDo99[X.kod znaku o godz((n-=2)) *10+ x.kod znaku o godz(n +1) -528];Jeśli(v) r = v +''+ N2WHindi.miejsce[i] + (r ?''+ R:''); }powrótr ||'Zero'; }}

Indyjska wersja angielska

klasa N2WIndyjski{ prywatnystatycznytylko czytaćzeroDo99: ciąg[] = []; prywatnystatycznytylko czytaćmiejsce: ciąg[] ='Tysiąc|Lakh|Krore|Arab|Kharab|Nil'.podział('|');statyczny{konst te: ciąg[] ='|Jeden|Dwa|Trzy|Cztery|Pięć|Sześć|Siedem|Osiem|Dziewięć|Dziesięć|Jedenaście|Dwanaście|Trzynaście|Czternaście|Piętnaście|Szesnaście|Siedemnaście|Osiemnaście|Dziewiętnaście'.podział('|');konst kilkadziesiąt: ciąg[] ='||Dwadzieścia|Trzydzieści|Czterdzieści|Pięćdziesiąt|Sześćdziesiąt|Siedemdziesiąt|Osiemdziesiąt|Dziewięćdziesiąt'.podział('|');Do(pozwalaćja =0; ja <100; i++) {konst T: liczba =Matematyka.podłoga(I /10);konst o: liczba = i%10; N2WIndyjski.zeroDo99.naciskać(t <2? jedności[i] : dziesiątki[t] + (o ?''+ jedności[o] :'')); } } publicznestatyczny konwertować(X: string): string {pozwalać N: liczba = x.długość; x = n ===0?„00”: n ===1|| N %2===0?„0”+ x : x; n = x.długość;pozwalaćr = N2WIndyjski.zeroDo99[X.kod znaku o godz((n-=2)) *10+ x.kod znaku o godz(n +1) -528];Jeśli(n >=1) {konst w: string = N2WIndyjski.zeroDo99[X.kod znaku o godz((n-=1)) -48];Jeśli(v) r = v +„sto”+ (r?''+ R:''); }Do(pozwalaćja =0; n >0; i++) {konst w: string = N2WIndyjski.zeroDo99[X.kod znaku o godz((n-=2)) *10+ x.kod znaku o godz(n +1) -528];Jeśli(v) r = v +''+ N2WIndyjski.miejsce[i] + (r ?''+ R:''); }powrótr ||'Zero'; }}

Wersja międzynarodowa

klasa N2WIntl{ prywatnystatycznytylko czytaćzeroDo999: ciąg[] = []; prywatnystatycznymiejsce tylko do odczytu ='|Tysiąc|Milion|Miliard|bililion|kwadrylion|kwintylion|sextillion|septillion|oktillion|nonillion|decillion|Undecillion|duodecylion|tredecylion|Quattuordecillion|quindecylion|sedecillion|septendecillion|oktodecylion|Novendecylion|Vigintillion|Unviginlion intillion|Duovigintillion|Tresvigintillion| Quattuorvigintillion|Quinvigintillion|Sesvigintillion|Septemvigintillion|Octovigintillion|Novemvigintillion|Trigintillion|Untrigintillion|Duotrigintillion|Trestrigintillion|Quattuortrigintillion|Quintrigintillion|Sestrigintillion|Septentrigintillion|Octotrigintillion|Noventrigintillion|Qu adragintillion'.podział('|');statyczny{konstjedynki ='|Jeden|Dwa|Trzy|Cztery|Pięć|Sześć|Siedem|Osiem|Dziewięć|Dziesięć|Jedenaście|Dwanaście|Trzynaście|Czternaście|Piętnaście|Szesnaście|Siedemnaście|Osiemnaście|Dziewiętnaście'.podział('|');konstdziesiątki ='||Dwadzieścia|Trzydzieści|Czterdzieści|Pięćdziesiąt|Sześćdziesiąt|Siedemdziesiąt|Osiemdziesiąt|Dziewięćdziesiąt'.podział('|');Do(pozwalaćja =0; ja <100; i++) {konstt =Matematyka.podłoga(I /10);konsto = ja%10; N2WIntl.zeroDo999[ja] = t <2? jedności[i] : dziesiątki[t] + (o ===0?'':''+ jedności[o]); }Do(pozwalaćja =100; ja <1000; i++) {konsth =Matematyka.podłoga(I /100);konstt =Matematyka.podłoga(I /10) %10;konsto = ja%10;konstr = N2WIntl.zeroDo999[h] +„sto”; N2WIntl.zeroDo999[i] = t ===0&& o ===0? r : r +''+ N2WIntl.zeroDo999[T *10+ o]; } } publicznestatyczny konwertować(X: string): string {pozwalaćn = x.długość; x = n ===0?„000”: (N %3===1?„00”: N %3===2?„0”:'') + x; n = x.długość;pozwalaćr ='';Do(pozwalaćja =0; n >0; i++) {konst w: string = N2WIntl.zeroDo999[ X.kod znaku o godz((n-=3)) *100+ x.kod znaku o godz(n +1) *10+ x.kod znaku o godz(n +2) -5328];Jeśli(v) r = v + (ja ?''+ N2WIntl.miejsce[I] :'') + (r?''+ R:''); }powrótr ||'Zero'; }}

konst test= () => { {pozwalaćn =5000000;konst test: ciąg znaków =„1234567890”;konstt0 = wydajność.Teraz();chwila(n-- >0) { N2WHindi.konwertować(test); }konstt1 = wydajność.Teraz();konsola.dziennik('1234567890 do 5 milionów razy:'+ (t1 - t0) +'SM');konsola.dziennik('10^15 -1:n'+„9”.powtarzać(15) +'N'+ N2WHindi.konwertować(„9”.powtarzać(15))); } {pozwalaćn =5000000;konst test: ciąg znaków =„1234567890”;konstt0 = wydajność.Teraz();chwila(n-- >0) { N2Windyjski.konwertować(test); }konstt1 = wydajność.Teraz();konsola.dziennik('1234567890 do 5 milionów razy:'+ (t1 - t0) +'SM');konsola.dziennik('10^15 -1:n'+„9”.powtarzać(15) +'N'+ N2WIndyjski.konwertować(„9”.powtarzać(15))); } {pozwalaćn =5000000;konst test: ciąg znaków =„1234567890”;konstt0 = wydajność.Teraz();chwila(n-- >0) { N2WIntl.konwertować(test); }konstt1 = wydajność.Teraz();konsola.dziennik('1234567890 do 5 milionów razy:'+ (t1 - t0) +'SM');konsola.dziennik('10^126 -1:n'+„9”.powtarzać(126) +'N'+ N2WIntl.konwertować(„9”.powtarzać(126))); }};test();

Przykład

N2WHindi.konwertować(„122356”)„jeden lakh dwadzieścia dwa tysiące trzysta pięćdziesiąt sześć”N2WIndyjski.konwertować(„122356”)„Jeden lakh dwadzieścia dwa tysiące trzysta pięćdziesiąt sześć”N2WIntl.konwertować(„122356”)„Sto dwadzieścia dwa tysiące trzysta pięćdziesiąt sześć”

Przykład przeliczania waluty

konst[r, p] =„23,54”.podział('.');`${N2WHindi.convert(r)}rupii i${N2WHindi.convert(p)}Pieniądze`„dwadzieścia trzy rupie i pięćdziesiąt cztery paise”`${N2WIndian.convert(r)}rupii i${N2WIndian.convert(p)}Paisa`„Dwadzieścia trzy rupie i pięćdziesiąt cztery pajsy”`${N2WIntl.convert(r)}dolarów i${N2WIntl.convert(p)}Centy`„Dwadzieścia trzy dolary i pięćdziesiąt cztery centy”

To jest odpowiedź na komentarz @LordZardeck doDoskonała odpowiedź @ naomika powyżej. Przepraszam, skomentowałbym bezpośrednio, ale nigdy wcześniej nie publikowałem, więc nie mam takiego przywileju, więc zamiast tego publikuję tutaj.

W każdym razie tak się złożyło, że w zeszły weekend przetłumaczyłem wersję ES5 na bardziej czytelną formę, więc udostępniam ją tutaj. Powinno to być wierne oryginałowi (w tym ostatniej edycji) i mam nadzieję, że nazewnictwo jest jasne i dokładne.

funkcjonować int_to_words(int) {Jeśli(int ===0)powrót 'zero';był JEDEN= ['','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć','dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];był KILKADZIESIĄT= ['','','20','trzydzieści',„czterdzieści”,'pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];był SKALA= ['','tysiąc','milion','miliard','bilion','kwadrylion',„kwintylion”,„sekstylion”,„septylion”,„oktylion”,„nonillion”];// Zwróć ciąg trzech pierwszych cyfr, w razie potrzeby uzupełniony zerami funkcjonować get_first(ul) {powrót(„000”+ str.).podstr(-3); }// Zwraca ciąg cyfr z odciętymi pierwszymi trzema cyframi funkcjonować odpocznij(ul) {powrótul.podstr(0, ul.długość-3); }// Zwraca ciąg trójek przekonwertowanych na słowa funkcjonować trójka_do_słów(_3, _2, _1) {powrót(_3rd ==„0”?'':JEDEN[_3rd] +„sto”) + (_1. ==„0”?KILKADZIESIĄT[_2nd] :KILKADZIESIĄT[_2nd] &&KILKADZIESIĄT[_2nd] +'-'||'') + (JEDEN[_2. + _1.] ||JEDEN[_1st]); ,// Dodaj do słów, trójki słów ze słowem skali funkcjonować dodaj_do_słów(słowa, trójka_słów, skala_słowo) {powrótsłowa_trójki? triplet_words + (scale_word &&''+ skala_słowo ||'') +''+ słowa: słowa; }funkcjonować iter(słowa, ja, po pierwsze, odpocznij) {Jeśli(pierwszy ==„000”&& odpoczynek.długość===0)powrótsłowa;powrót iter(dodaj_do_słów(słowa,trójka_do_słów(Pierwszy[0], Pierwszy[1], Pierwszy[2]),SKALA[i]), ++i,get_first(odpoczynek),odpocznij(odpoczynek)); }powrót iter('',0,get_first(Strunowy(int)),odpocznij(Strunowy(int)));}

byłw słowach =funkcjonować(całkowity czynsz){//console.log(całkowity czynsz);byłza = ['','jeden ',„dwa”,'trzy ',„cztery”,'pięć ',„sześć”,„siedem”,'osiem ','dziewięć ','dziesięć ',„jedenaście”,„dwanaście”,„trzynaście”,„czternaście”,'piętnaście ',„szesnaście”,„siedemnaście”,'osiemnaście ','dziewiętnaście '];byłb = ['','','20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];byłliczba =naciśnijPływak(całkowity czynsz).doNaprawiono(2).podział(".");byłliczba =parseInt(numer[0]);byłcyfra =parseInt(numer[1]);//console.log(liczba);Jeśli((liczbado Ciągu()).długość>9)powrót 'przelewowy';byłn = ('000000000'+ liczba).podstr(-9).mecz(/^(d{2})(d{2})(d{2})(d{1})(d{2})$/);byłd = („00”+ cyfra).podstr(-2).mecz(/^(d{2})$/);;Jeśli(!N)powrót;byłstr ='';str += (n[1] !=0)? (A[Numer(N[1])] || b[n[1][0]] +''+ a[n[1][1]]) +„krore”:'';str += (n[2] !=0)? (A[Numer(N[2])] || b[n[2][0]] +''+ a[n[2][1]]) +„lak”:'';str += (n[3] !=0)? (A[Numer(N[3])] || b[n[3][0]] +''+ a[n[3][1]]) +„tysiące”:'';str += (n[4] !=0)? (A[Numer(N[4])] || b[n[4][0]] +''+ a[n[4][1]]) +„sto”:'';str += (n[5] !=0)? (A[Numer(N[5])] || b[n[5][0]] +''+ a[n[5][1]]) +„Rupia”:'';str += (d[1] !=0)? ((str!='')?"I ":'') + (a[Numer(D[1])] || b[d[1][0]] +''+ a[d[1][1]]) +„Paise”:'Tylko!';konsola.dziennik(str);powrótstr;}

Jest to zmodyfikowany kod obsługujący rupię indyjską z dwoma miejscami po przecinku.

Poniżej tłumaczenia z j

• liczba całkowita do słowa
• płynąć do słowa
• pieniądze na słowo

Przypadki testowe znajdują się na dole

był TYSIĄC=Matematyka.pow(10,3);był JEDEN MILION=Matematyka.pow(10,6);był JEDEN BILION=Matematyka.pow(10,9);był JEDEN TRYLION=Matematyka.pow(10,12);był ONE_QUADRILLION=Matematyka.pow(10,15);był ONE_QUINTILLION=Matematyka.pow(10,18);funkcjonować liczba całkowita na słowo(liczba całkowita) {byłprzedrostek ='';byłsufiks ='';Jeśli(!liczba całkowita){powrót "zero"; }Jeśli(liczba całkowita <0){ przedrostek ="negatywny"; sufiks =liczba całkowita na słowo(-1* liczba całkowita);powrótprzedrostek +" "+ sufiks; }Jeśli(liczba całkowita <=90){przełącznik(liczba całkowita) {sprawaliczba całkowita <0: przedrostek ="negatywny"; sufiks =liczba całkowita na słowo(-1* liczba całkowita);powrótprzedrostek +" "+ sufiks;sprawa 1:powrót "jeden";sprawa 2:powrót "dwa";sprawa 3:powrót "trzy";sprawa 4:powrót „cztery”;sprawa 5:powrót "pięć";sprawa 6:powrót "sześć";sprawa 7:powrót „siedem”;sprawa 8:powrót "osiem";sprawa 9:powrót "dziewięć";sprawa 10:powrót "dziesięć";sprawa 11:powrót "jedenaście";sprawa 12:powrót "dwanaście";sprawa 13:powrót "trzynaście";sprawa 14:powrót "czternaście";sprawa 15:powrót "piętnaście";sprawa 16:powrót "szesnaście";sprawa 17:powrót "siedemnaście";sprawa 18:powrót "osiemnaście";sprawa 19:powrót "dziewiętnaście";sprawa 20:powrót "20";sprawa 30:powrót "trzydzieści";sprawa 40:powrót "czterdzieści";sprawa 50:powrót "pięćdziesiąt";sprawa 60:powrót "sześćdziesiąt";sprawa 70:powrót "siedemdziesiąt";sprawa 80:powrót "osiemdziesiąt";sprawa 90:powrót "dziewięćdziesiąt";domyślny:przerwa; } }Jeśli(liczba całkowita <100){ przedrostek =liczba całkowita na słowo(liczba całkowita - liczba całkowita %10); sufiks =liczba całkowita na słowo(liczba całkowita %10);powrótprzedrostek +"-"+ sufiks; }Jeśli(liczba całkowita <TYSIĄC){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /100),10) ) +"sto";Jeśli(liczba całkowita %100){ sufiks =" I "+liczba całkowita na słowo(liczba całkowita %100); }powrótprzedrostek + przyrostek; } }Jeśli(liczba całkowita <JEDEN MILION){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /TYSIĄC),10)) +„tysiąc”;Jeśli(liczba całkowita %TYSIĄC){ sufiks =liczba całkowita na słowo(liczba całkowita %TYSIĄC); } }w przeciwnym razie Jeśli(liczba całkowita <JEDEN BILION){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /JEDEN MILION),10)) +„ milion ”;Jeśli(liczba całkowita %JEDEN MILION){ sufiks =liczba całkowita na słowo(liczba całkowita %JEDEN MILION); } }w przeciwnym razie Jeśli(liczba całkowita <JEDEN TRYLION){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /JEDEN BILION),10)) +" miliard";Jeśli(liczba całkowita %JEDEN BILION){ sufiks =liczba całkowita na słowo(liczba całkowita %JEDEN BILION); } }w przeciwnym razie Jeśli(liczba całkowita <ONE_QUADRILLION){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /JEDEN TRYLION),10)) +" bilion";Jeśli(liczba całkowita %JEDEN TRYLION){ sufiks =liczba całkowita na słowo(liczba całkowita %JEDEN TRYLION); } }w przeciwnym razie Jeśli(liczba całkowita <ONE_QUINTILLION){ przedrostek =liczba całkowita na słowo(parseInt(Matematyka.podłoga(liczba całkowita /ONE_QUADRILLION),10)) +„kwadrylion”;Jeśli(liczba całkowita %ONE_QUADRILLION){ sufiks =liczba całkowita na słowo(liczba całkowita %ONE_QUADRILLION); } }w przeciwnym razie{powrót ''; }powrótprzedrostek +" "+ sufiks;}funkcjonować pieniądze na słowo(wartość){byłwartość dziesiętna = (wartość %1);byłliczba całkowita = wartość - wartość dziesiętna; wartość dziesiętna =Matematyka.okrągły(wartość dziesiętna *100);byłdecimalText = !decimalValue?'':liczba całkowita na słowo(wartość dziesiętna) +„cent”+ (wartość dziesiętna ===1?'':'S');byłintegerText= !całkowita?'':liczba całkowita na słowo(liczba całkowita) +„dolar”+ (liczba całkowita ===1?'':'S');powrót( liczba całkowita &&!wartośćdziesiętna?tekst całkowity: liczba całkowita && wartość dziesiętna? liczba całkowitaTekst +' I '+tekst dziesiętny: !liczba całkowita && wartość dziesiętna?tekst dziesiętny:„zero centów”);}funkcjonować przenieś do słowa(wartość){byłwartość dziesiętna = (wartość %1);byłliczba całkowita = wartość - wartość dziesiętna; wartość dziesiętna =Matematyka.okrągły(wartość dziesiętna *100);byłdecimalText = !decimalValue?'': wartość dziesiętna <10?„punkt o”+liczba całkowita na słowo(wartość dziesiętna): wartość dziesiętna %10===0?'punkt '+liczba całkowita na słowo(wartość dziesiętna /10):'punkt '+liczba całkowita na słowo(wartość dziesiętna);powrót( liczba całkowita &&!wartośćdziesiętna?liczba całkowita na słowo(liczba całkowita): liczba całkowita && wartość dziesiętna? [liczba całkowita na słowo(liczba całkowita), tekst dziesiętny].dołączyć(''): !liczba całkowita && wartość dziesiętna?tekst dziesiętny:liczba całkowita na słowo(0) );}// test(funkcjonować(){konsola.dziennik('liczba całkowita na słowo ==================================');Do(byłja =0; ja <101; ++i){konsola.dziennik('%s=%s', I,liczba całkowita na słowo(I)); }konsola.dziennik('floatToWord ===================================='); ja =131;chwila(I--){konsola.dziennik('%s=%s', I /100,przenieś do słowa(I /100)); }konsola.dziennik('pieniądze na słowo ====================================');Do(ja =0; ja <131; ++i){konsola.dziennik('%s=%s', I /100,pieniądze na słowo(I /100)); }}());

Kolejna konwersja wykorzystująca reszty i obsługująca różne języki:

funkcjonować liczba na słowa(numer) {byłwynik = [];byłułamek = liczba.doNaprawiono(2).podział('.');byłczęść_całkowita =parseInt(frakcja[0]);// var część_ułamkowa = parseInt(frakcja [1]); -- tutaj nie załatwione byłpoprzedniLiczba =zero;Do(byłja =0; i < ułamek [0].długość; i++) {byłprzypomnienie =Matematyka.podłoga(część_całkowita %10); część_całkowita /=10;byłimię =pobierzNazwęNumeru(przypomnienie, i, ułamek[0].długość, poprzedniNumer); poprzedniNumer = przypomnienie;Jeśli(nazwa) wynik.naciskać(nazwa); } wynik.odwracać();powrótwynik.dołączyć('');}

ThepobierzNazwęNumerufunkcja jest zależna od języka i obsługuje liczby do9999(ale łatwo go rozszerzyć, aby obsługiwał większe liczby):

funkcjonować pobierzNazwęNumeru(liczba, moc, miejsca, poprzedni numer) {byłwynik ="";Jeśli(moc ==1) { wynik =uchwytTeensAndTys(liczba, poprzednia liczba); }w przeciwnym razie Jeśli(moc ==0&& miejsca !=1|| liczba ==0) {// pomiń liczbę, która była obsługiwana w nastolatkach i zero}w przeciwnym razie{ wynik = ustawienia regionalne.liczbaNazwy[numer.do Ciągu()] + ustawienia regionalne.nazwy mocy[moc.do Ciągu()]; }powrótwynik;}

uchwytTeensAndTysobsługuje wielokrotności dziesięciu:

funkcjonować uchwytTeensAndTys(numer, poprzedni numer) {byłwynik ="";Jeśli(liczba ==1) {// nastolatki Jeśli(poprzedni numerWwidownia.specjalne Nazwy Nastolatków) { wynik = ustawienia regionalne.specjalne Nazwy Nastolatków[poprzedni numer]; }w przeciwnym razie Jeśli(poprzedni numerWwidownia.specjalneTyNames) { wynik = ustawienia regionalne.specjalneTyNames[poprzedni numer] + ustawienia regionalne.nastolatekPrzyrostek; }w przeciwnym razie{ wynik = ustawienia regionalne.liczbaNazwy[poprzedni numer] + ustawienia regionalne.nastolatekPrzyrostek; } }w przeciwnym razie Jeśli(liczba ==0) {// poprzednia liczba nie była obsługiwana w przypadku nastolatkówwynik = ustawienia regionalne.liczbaNazwy[poprzedni numer.do Ciągu()]; }w przeciwnym razie{// inne tys Jeśli(numerWwidownia.specjalneTyNames) { wynik = ustawienia regionalne.specjalneTyNames[numer]; }w przeciwnym razie{ wynik = ustawienia regionalne.liczbaNazwy[numer]; } wynik += ustawienia narodowe.nazwy mocy[1];Jeśli(poprzedni numer !=0) { wynik +=" "+ język.liczbaNazwy[poprzedni numer.do Ciągu()]; } }powrótwynik;}

Na koniec przykłady ustawień regionalnych:

byłjęzyk = {// Język angielski liczbaNazwy: {1:"jeden",2:"dwa",3:"trzy",4:„cztery”,5:"pięć",6:"sześć",7:„siedem”,8:"osiem",9:"dziewięć"},nazwy mocy: {0:"",1:"ty",2:"sto",3:„tysiąc”},specjalne Nazwy Nastolatków: {0:"dziesięć",1:"jedenaście",2:"dwanaście"},specjalneTyNames: {2:„dwadzieścia”,3:„trzy”,5:„fif”},nastolatekPrzyrostek:„nastolatek”};byłjęzyk = {// estoński liczbaNazwy: {1:"jeden",2:"dwa",3:"trzy",4:„cztery”,5:"pięć",6:"sześć",7:„siedem”,8:"osiem",9:"dziewięć"},nazwy mocy: {0:"",1:"dziesięć",2:"Teraz",3:"tysiąc"},specjalne Nazwy Nastolatków: {0:"dziesięć"},specjalneTyNames: {},nastolatekPrzyrostek:"inny"};

Oto JSFiddle z testami:https://jsfiddle.net/rcrxna7v/15/

Zmodyfikowałem kod @McShamana, przekonwertowałem go na CoffeeScript i dodałem dokumenty przezJSŁadnie. Oto wynik, dla zainteresowanych (angielski):

###Konwertowaćliczba całkowita do anjęzyk angielskiekwiwalent ciągu znaków @param {Liczba całkowita} numer liczba całkowita do przeliczenia @powrót{Strunowy}język angielskiekwiwalent liczbowy###inWords = (liczba) -> ### @property {Szyk} ### angielskiLiczby całkowite = ["" "jeden " „dwa” "trzy " „cztery” "pięć " „sześć” „siedem” "osiem " "dziewięć " "dziesięć " „jedenaście” „dwanaście” „trzynaście” „czternaście” "piętnaście " „szesnaście” „siedemnaście” "osiemnaście " "dziewiętnaście "] ### @nieruchomość {Szyk} ### angielskiIntegerTens = ["" "" "20" "trzydzieści" "czterdzieści" "pięćdziesiąt" "sześćdziesiąt" "siedemdziesiąt" "osiemdziesiąt" "dziewięćdziesiąt"] ### @nieruchomość {Szyk} ### englishIntegerTysiące = ["tysiąc" "milion" ""] liczba = liczba.do Ciągu()powrót "" Jeślinumer.długość>9### @właściwość {string} ### liczba = ("000000000"+ liczba).podstr(-9) ### @nieruchomość {(Szyk.<łańcuch>|zero)} ### liczba = liczba.mecz(/.{3}/g) ### @property {ciąg znaków} ### przekonwertowane słowa =""### @właściwość {liczba} ### i =0 chwilai < polskiLiczba całkowitaTysiące.długość### @property {string} ### currentNumber = number[i] ### @property {string} ### tempResult =""tempWynik += (Jeśliprzekonwertowane słowa nie są""Następnie" "+ polskiCałkowiteTysiące[i] +" " w przeciwnym razie "") tempWynik += (Jeśliaktualny numer[0] nie jest0następnie angielskiLiczby całkowite[Numer(aktualny numer[0])] +„sto” w przeciwnym razie "") ### @property {string} ### bieżąca liczba = bieżąca liczba.podstr(1) tempWynik += (JeśliObecny numer nie jest0Następnie ((JeślitempWynik nie jest""Następnie"I " w przeciwnym razie "")) + (angielskiLiczby całkowite[Numer(bieżąca liczba)] lub angielska liczba całkowitaDziesięć[bieżąca liczba[0]] +" "+ angielskiLiczby całkowite[bieżąca liczba[1]])w przeciwnym razie "") przekonwertowane słowa += tempResult i++ przekonwertowane słowa

Chociaż odpowiedź na to pytanie została udzielona – nadal chcę podzielić się czymś, co niedawno opracowałem w skrypcie java (opartym na logice starej implementacji C#.Net, którą znalazłem w Internecie) do konwersji wartości indyjskich walut na słowa. Może obsłużyć do 40 cyfr. Możesz rzucić okiem.

Stosowanie:
InrToWordConverter.Initialize();.
var inWords = InrToWordConverter.ConvertToWord(kwota);

Realizacja:

htPunctuation = {};listStaticSuffix = {};listStaticPrefix = {};listHelpNotation = {};był InrToWordConverter=funkcjonować() {};InrToWordConverter.Zainicjuj=funkcjonować() {InrToWordConverter.LoadStaticPrefix();InrToWordConverter.LoadStaticSuffix();InrToWordConverter.Załaduj pomocnotacji();};InrToWordConverter.Konwertuj na słowo=funkcjonować(wartość) { wartość = wartość.do Ciągu();Jeśli(wartość) {byłżetony = wartość.podział(".");byłrsCzęść ="";byłpsCzęść ="";Jeśli(żetony.długość===2) { rsCzęść =Strunowy.przycinać(żetony[0]) ||„0”; psCzęść =Strunowy.przycinać(żetony[1]) ||„0”; }w przeciwnym razie Jeśli(żetony.długość===1) { rsCzęść =Strunowy.przycinać(żetony[0]) ||„0”; psCzęść =„0”; }w przeciwnym razie{ rsCzęść =„0”; psCzęść =„0”; } htPunctuation = {};byłrsInWords =InrToWordConverter.ConvertToWordInternal(rsCzęść) ||"Zero";byłpsInWords =InrToWordConverter.ConvertToWordInternal(psCzęść) ||"Zero";byłwynik =„rupii”+ rsInWords +"I "+ psInWords +„Paise”.;powrótwynik; }};InrToWordConverter.ConvertToWordInternal=funkcjonować(wartość) {byłprzekonwertowany ciąg ="";Jeśli(!(wartość.do Ciągu().długość>40)) {Jeśli(InrToWordConverter.CzyNumeryczne(wartość.do Ciągu())) {próbować{byłstrWartość =InrToWordConverter.Odwracać(wartość);przełącznik(StrValue.długość) {sprawa 1:Jeśli(parseInt(StrValue.do Ciągu()) >0) { przekonwertowany ciąg =InrToWordConverter.PobierzWordConversion(wartość); }w przeciwnym razie{ przekonwertowany ciąg =„Zero”; }przerwa;sprawa 2: przekonwertowany ciąg =InrToWordConverter.PobierzWordConversion(wartość);przerwa;domyślny:InrToWordConverter.Wstaw do tabeli interpunkcyjnej(StrValue);InrToWordConverter.ReverseHashTable(); przekonwertowany ciąg =InrToWordConverter.ReturnHashtableValue();przerwa; } }złapać(wyjątek) { przekonwertowany ciąg =„Wystąpił nieoczekiwany błąd 
”; } }w przeciwnym razie{ przekonwertowany ciąg =„Wprowadź tylko liczby, wartości dziesiętne nie są obsługiwane”; } }w przeciwnym razie{ przekonwertowany ciąg =„Wprowadź wartość mniejszą lub równą 40 cyfrom”; }powrótprzekonwertowany ciąg;};InrToWordConverter.CzyNumeryczne=funkcjonować(wartośćInNumerycznie) {byłjest dobrze =PRAWDA; wartośćInLiczbowo = wartośćInLiczbowo ||"";byłlen = wartość w liczbach.długość;Do(byłja =0; ja < długość; i++) {byłch = wartośćInLiczbowo[i];Jeśli(!(ch >=„0”&& ch <=„9”)) { jest dobrze =FAŁSZ;przerwa; } }powrótjest w porządku;};InrToWordConverter.ReturnHashtableValue=funkcjonować() {byłstrKońcowyCiąg ="";byłtablica kluczy = [];Do(byłkluczWhtPunctuation) { kluczeArr.naciskać(klucz); }Do(byłi = klucze Arr.długość-1; ja >=0; I--) {byłhKey = klawiszeTablica[i];Jeśli(InrToWordConverter.PobierzWordConversion((htPunctuation[hKey]).do Ciągu()) !=="") { strFinalString = strFinalString +InrToWordConverter.PobierzWordConversion((htPunctuation[hKey]).do Ciągu()) +InrToWordConverter.Znajdź przedrostek statyczny((klawisz h).do Ciągu()); } }powrótstrFinalString;};InrToWordConverter.ReverseHashTable=funkcjonować() {byłhtTemp = {};Do(byłkluczWhtInterpunkcja) {byłitem = htPunctuation[key]; htTemp[klucz] =InrToWordConverter.Odwracać(przedmiot.do Ciągu()); } htPunctuation = {}; htPunctuation = htTemp;};InrToWordConverter.Wstaw do tabeli interpunkcyjnej=funkcjonować(strWartość) { htInterpunkcja[1] = strWartość.podstr(0,3).do Ciągu();byłj =2;Do(byłja =3; i < strWartość.długość; ja = ja +2) {Jeśli(StrValue.podstr(I).długość>0) {Jeśli(StrValue.podstr(I).długość>=2) { htPunctuation[j] = strValue.podstr(I,2).do Ciągu(); }w przeciwnym razie{ htPunctuation[j] = strValue.podstr(I,1).do Ciągu(); } }w przeciwnym razie{przerwa; } j++; }};InrToWordConverter.Odwracać=funkcjonować(strWartość) {byłodwrócony ="";Do(byłIWstrValue) {byłch = strWartość[i]; odwrócony = ch + odwrócony; }powrótwywrócony;};InrToWordConverter.PobierzWordConversion=funkcjonować(liczba wejściowa) {byłdoReturnWord ="";Jeśli(numer wejścia.długość<=3&& wprowadź liczbę.długość>0) {Jeśli(numer wejścia.długość===3) {Jeśli(parseInt(numer wejścia.podstr(0,1)) >0) { do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(0,1)) +„sto”; }byłTempString =InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(1,2));Jeśli(tempString ==="") { do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(1,1) +„0”); do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(2,1)); } toReturnWord = toReturnWord + tempString; }Jeśli(numer wejścia.długość===2) {byłTempString =InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(0,2));Jeśli(tempString ==="") { do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(0,1) +„0”); do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(1,1)); } toReturnWord = toReturnWord + tempString; }Jeśli(numer wejścia.długość===1) { do słowa powrotu = do słowa powrotu +InrToWordConverter.StaticSuffixFind(numer wejścia.podstr(0,1)); } }powrótdoReturnWord;};InrToWordConverter.StaticSuffixFind=funkcjonować(numerKlucz) {byłwartośćZLiczby ="";Do(byłkluczWlistStaticSuffix) {Jeśli(Strunowy.przycinać(klucz.do Ciągu()) ===Strunowy.przycinać(numerKey)) {wartośćOdNumber = listStaticSuffix[klucz].do Ciągu();przerwa; } }powrótwartośćOdLiczby;};InrToWordConverter.Znajdź przedrostek statyczny=funkcjonować(numerKlucz) {byłwartośćZLiczby ="";Do(byłkluczWlistStaticPrefix) {Jeśli(Strunowy.przycinać(klawisz) ===Strunowy.przycinać(liczbaKlucz)) { wartośćOdNumer = listaStaticPrefix [klucz].do Ciągu();przerwa; } }powrótwartośćOdLiczby;};InrToWordConverter.StaticHelpNotationFind=funkcjonować(numerKlucz) {byłtekst pomocy ="";Do(byłkluczWlistPomocNotacja) {Jeśli(Strunowy.przycinać(klucz.do Ciągu()) ===Strunowy.przycinać(numerKey)) { helpText = listHelpNotation [klucz].do Ciągu();przerwa; } }powrótTekst pomocy; };InrToWordConverter.LoadStaticPrefix=funkcjonować() { listStaticPrefix[2] =„Tysiąc”; listStaticPrefix[3] ="szlak"; listStaticPrefix[4] =„Krore”; listStaticPrefix[5] =„Arab”; listStaticPrefix[6] =„Kharab”; listStaticPrefix[7] ="Neel"; listStaticPrefix[8] =„Padma”; listStaticPrefix[9] =„Shankh”; listStaticPrefix[10] =„Maha-szank”; listStaticPrefix[11] ="Anka"; listStaticPrefix[12] =„Jald”; listStaticPrefix[13] ="duży"; listStaticPrefix[14] ="przodek"; listStaticPrefix[15] ="Mrówka "; listStaticPrefix[16] =„Maha-mrówka”; listStaticPrefix[17] ="Gówno"; listStaticPrefix[18] =„Singhar”; listStaticPrefix[19] =„Maha Singhar”; listStaticPrefix[20] =„Adant Singhar”;};InrToWordConverter.LoadStaticSuffix=funkcjonować() { listStaticSuffix[1] ="Jeden "; listStaticSuffix[2] =„Dwa”; listStaticSuffix[3] ="Trzy "; listStaticSuffix[4] =„Cztery”; listStaticSuffix[5] ="Pięć "; listStaticSuffix[6] =„Sześć”; listStaticSuffix[7] =„siedem”; listStaticSuffix[8] ="Osiem "; listStaticSuffix[9] ="Dziewięć "; listStaticSuffix[10] ="Dziesięć "; listStaticSuffix[11] =„Jedenaście”; listStaticSuffix[12] =„Dwanaście”; listStaticSuffix[13] =„Trzynaście”; listStaticSuffix[14] =„czternaście”; listStaticSuffix[15] ="Piętnaście "; listStaticSuffix[16] =„szesnaście”; listStaticSuffix[17] =„siedemnaście”; listStaticSuffix[18] ="Osiemnaście "; listStaticSuffix[19] ="Dziewiętnaście "; listStaticSuffix[20] ="20 "; listStaticSuffix[30] ="Trzydzieści "; listStaticSuffix[40] =„czterdzieści”; listStaticSuffix[50] =„Pięćdziesiąt”; listStaticSuffix[60] =„Sześćdziesiąt”; listStaticSuffix[70] =„siedemdziesiąt”; listStaticSuffix[80] ="Osiemdziesiąt "; listStaticSuffix[90] =„Dziewięćdziesiąt”;};InrToWordConverter.Załaduj pomocnotacji=funkcjonować() { listHelpNotation[2] =„=1000 (3 końcowe zera)”; listaPomocNotacja[3] =„=1 00 000 (5 końcowych zer)”; listaPomocNotacja[4] =„=1,00,00,000 (7 końcowych zer)”; listaPomocNotacja[5] =„=1,00,00,00,000 (9 końcowych zer)”; listaPomocNotacja[6] =„=1,00,00,00,00,000 (11 końcowych zer)”; listaPomocNotacja[7] =„=1,00,00,00,00,00,000 (13 końcowych zer)”; listaPomocNotacja[8] =„=1,00,00,00,00,00,00,000 (15 końcowych zer)”; listaPomocNotacja[9] =„=1,00,00,00,00,00,00,00,000 (17 końcowych zer)”; listaPomocNotacja[10] =„=1,00,00,00,00,00,00,00,00,000 (19 końcowych zer)”; listaPomocNotacja[11] =„=1,00,00,00,00,00,00,00,00,00,000 (21 końcowych zer)”; listaPomocNotacja[12] =„=1,00,00,00,00,00,00,00,00,00,00,000 (23 końcowe zera)”; listaPomocNotacja[13] =„=1,00,00,00,00,00,00,00,00,00,00,00,000 (25 końcowych zer)”; listaPomocNotacja[14] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,000 (27 końcowych zer)”; listaPomocNotacja[15] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (29 końcowych zer)”; listaPomocNotacja[16] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (31 końcowych zer)”; listaPomocNotacja[17] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (33 końcowe zera)”; listaPomocNotacja[18] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (35 końcowych zer)”; listaPomocNotacja[19] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (37 końcowych zer)”; listaPomocNotacja[20] =„=1,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,000 (39 końcowych zer)”;};Jeśli(!Strunowy.przycinać) {Strunowy.przycinać=funkcjonować(ul) {byłwynik ="";byłZnaleziona pierwsza niebiała przestrzeń =FAŁSZ;byłstartIndeks = -1;byłindeks końcowy = -1;Jeśli(str) {Do(byłja =0; ja < ul.długość; i++) {Jeśli(firstNonWhiteSpaceZnalezione ===FAŁSZ) {Jeśli(str[i] ===''|| str[i] ==='T') {Kontynuować; }w przeciwnym razie{ firstNonWhiteSpaceZnalezione =PRAWDA; startIndeks = i; indeks końcowy = i; } }w przeciwnym razie{Jeśli(str[i] ===''|| str[i] ==='T') {Kontynuować; }w przeciwnym razie{ indeks końcowy = i; } } }Jeśli(indeks startowy !== -1&& indeks końcowy !== -1) { wynik = str.plasterek(początkowyIndeks, końcowyIndeks +1); } }powrótwynik; };}

Wypróbuj ten kod z kodem JavaScript zgodnym z turecką walutą

funkcjonować wydma() {byłinpt =dokument.getElementById("tar1").wartość;byłspt = wejście.podział(''); spt.odwracać();byłpojedynczy = ["","Jeden",dopóki,"Latać",„Cztery”,"Pięć","Sześć",„Siedem”,"Osiem","Dziewięć"];byłdziesiętny = ["","NA","20","Trzydzieści","Czterdzieści",„Elli”,"Sześćdziesiąt","Siedemdziesiąt","Osiemdziesiąt","Dziewięćdziesiąt"];był Sto= ["","Twarz","Dwie twarze","Trzysta","Czterysta","Pięćset","Sześćset","Siedemset","Osiemset","Dziewięćset"];byłpowinien = ["","","","","Kosz","Milion","Miliard","Bilion","Kwadrylion",„Kentilyon”];byłja, j;byłbas3 ="";byłbas6 ="";byłbas9 ="";byłbas12 ="";byłcałkowity;Do(ja =0; ja <1; i++) { bas3 +=Sto[szt[i+2]] + dziesiętny[spt[i+1]] + tek[spt[i]]; bas6 +=Sto[szt[i+5]] + dziesiętny[spt[i+4]] + tek[spt[i+3]] + powinien[4]; bas9 +=Sto[szt[i+8]] + dziesiętny[spt[i+7]] + tek[spt[i+6]] + powinien[5]; bas12 +=Sto[szt[i+11]] + dziesiętny[spt[i+10]] + tek[spt[i+9]] + powinien[6];Jeśli(wł.długość<4) { bas6 =''; bas9 =''; }Jeśli(wł.długość>6&& wł.plasterek(5,6) ==0) { bas6 = bas6.zastępować(/Kosz/g,''); }Jeśli(wł.długość<7) { bas9 =''; }Jeśli(wł.długość>9&& wł.plasterek(1,3) ==000) { bas9 = bas9.zastępować(/ milion / gram,''); }Jeśli(wł.długość<10) { bas12 =''; } } razem = bas12 + bas9 + bas6 + bas3; suma = suma.zastępować(NaN,''); suma = suma.zastępować(nieokreślony,'');dokument.getElementById('próbny').wewnętrzny HTML= ogółem; }

Wiele dobrych odpowiedzi. Potrzebowałem mojego do indyjskiego (południowoazjatyckiego) systemu numeracji. Zmodyfikowałem jeden z powyższych kodów – załączam go tutaj, na wypadek gdyby ktoś inny tego potrzebował. W indyjskim systemie numeracji grupy po tysiącach są dwucyfrowe, a nie trzycyfrowe, jak w systemie zachodnim.

był IS_POŁUDNIOWA_AZJA=PRAWDA;funkcjonować int_to_words(int) {Jeśli(int ===0)powrót 'zero';był JEDEN_WORD= ['','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć','dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];był TENS_WORD= ['','','20','trzydzieści',„czterdzieści”,'pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];był SCALE_WORD_WESTERN= ['','tysiąc','milion','miliard','bilion','kwadrylion',„kwintylion”,„sekstylion”,„septylion”,„oktylion”,„nonillion”];był SCALE_WORD_POŁUDNIOWA_AZJA= ['','tysiąc',„lak”,„krore”,'Arab',„kharab”,„neel”,„padma”,'cholewka','***','***'];był WIELKOŚĆ GRUPY= (typ IS_POŁUDNIOWA_AZJA!="nieokreślony"&&IS_POŁUDNIOWA_AZJA)?2:3;był SCALE_WORD= (typ IS_POŁUDNIOWA_AZJA!="nieokreślony"&&IS_POŁUDNIOWA_AZJA)?SCALE_WORD_POŁUDNIOWA_AZJA:SCALE_WORD_WESTERN;// Zwróć ciąg trzech pierwszych cyfr, w razie potrzeby uzupełniony zerami funkcjonować get_first_3(ul) {powrót(„000”+ str.).podstr(-(3)); }funkcjonować get_first(ul) {//-- Zwróć ciąg znaków składający się z pierwszych cyfr GROUP_SIZE, w razie potrzeby dopełnionych zerami, jeśli rozmiar grupy wynosi 2, ustaw rozmiar 3, poprzedzając go znakiem „0” powrót(WIELKOŚĆ GRUPY==2?„0”:'') + („000”+ str.).podstr(-(WIELKOŚĆ GRUPY)); }// Zwraca ciąg cyfr z odciętymi pierwszymi trzema cyframi funkcjonować get_rest_3(ul) {powrótul.podstr(0, ul.długość-3); }funkcjonować odpocznij(ul) {// Zwraca ciąg cyfr z odciętymi pierwszymi cyframi GROUP_SIZE powrótul.podstr(0, ul.długość-WIELKOŚĆ GRUPY); }// Zwraca ciąg trójek przekonwertowanych na słowa funkcjonować trójka_do_słów(_3, _2, _1) {powrót(_3rd ==„0”?'':JEDEN_WORD[_3rd] +„sto”) + (_1. ==„0”?TENS_WORD[_2nd] :TENS_WORD[_2nd] &&TENS_WORD[_2nd] +'-'||'') + (JEDEN_WORD[_2. + _1.] ||JEDEN_WORD[_1st]);//-- Pierwsza zwraca jeden-dziewiętnaście - druga zwraca jeden-dziewięć}// Dodaj do wyniku trójki słów ze słowem skali funkcjonować dodaj_do_wyniku(wynik, trójka_słów, skala_słowo) {powrótsłowa_trójki? triplet_words + (scale_word &&''+ skala_słowo ||'') +''+ wynik : wynik; }funkcjonować uciekanie się(wynik, scaleIdx, pierwszy, reszta) {Jeśli(pierwszy ==„000”&& odpoczynek.długość===0)powrótwynik;byłnowyWynik = add_to_result (wynik, triplet_to_words (pierwszy[0], Pierwszy[1], Pierwszy[2]),SCALE_WORD[identyfikator skali]);powrótrecurse (newResult, ++scaleIdx,get_first(odpoczynek),odpocznij(odpoczynek)); }powrótrekurencja ('',0,get_first_3(Strunowy(int)),get_rest_3(Strunowy(int)));}

podczas gdy ten system używa pętli for, używa angielskiego amerykańskiego i jest szybki, dokładny i rozszerzalny (możesz dodać nieskończone wartości do „th” var i zostaną one uwzględnione).

Ta funkcja pobiera 3 grupy liczb wstecz, aby uzyskać grupy liczb, gdzie a,normalnie rozdzieliłby je w postaci liczbowej. Następnie każda grupa trzech liczb jest dodawana do tablicy zawierającej tylko 3 liczby (np. sto dwadzieścia trzy). Następnie bierze tę nową listę tablic i odwraca ją ponownie, dodając jednocześnieczvar tego samego indeksu na koniec łańcucha.

byłjedynki = ['','jeden ',„dwa”,'trzy ',„cztery”,'pięć ',„sześć”,„siedem”,'osiem ','dziewięć ','dziesięć ',„jedenaście”,„dwanaście”,„trzynaście”,„czternaście”,'piętnaście ',„szesnaście”,„siedemnaście”,'osiemnaście ','dziewiętnaście '];byłdziesiątki = ['','','20 ','trzydzieści ',„czterdzieści”,„pięćdziesiąt”,„sześćdziesiąt”,„siedemdziesiąt”,'osiemdziesiąt ',„dziewięćdziesiąt”,„sto”];byłth = ['',„tysiące”,„milion”,'miliard ','bilion '];funkcjonować numerDoSłowa(numer){byłtekst ="";byłrozmiar = liczba.długość;byłlista tekstowa = [];byłtextListCount =0;//pobierz każdą 3-cyfrową liczbę Do(byłja = liczba.długość-1; ja >=0; ja -=3){// pobierz 3-cyfrową grupę byłliczba =0;Jeśli(liczba[(i-2)]){liczba += liczba[(i-2)];}Jeśli(liczba[(i-1)]){liczba += liczba[(i-1)];}Jeśli(liczba[i]){liczba += liczba[i];}//usuń wszelkie dodatkowe 0 z początku liczbyliczba =Matematyka.podłoga(liczba).do Ciągu();Jeśli(numerdługość==1|| liczba <20){//jeśli jedna cyfra lub mniej niż 20textList[textListCount] = jedności[liczba]; }w przeciwnym razie Jeśli(numerdługość==2){//jeśli 2 cyfry i więcej niż 20textList[textListCount] = dziesiątki[liczba[0]]+jednostki1]]; }w przeciwnym razie Jeśli(numerdługość==3){//jeśli 3 cyfrytextList[textListCount] = jedności[num[0]]+dziesiątki[10]+czas [liczba [1]]+jednostki2]]; } textListCount++; }//dodaj listę 3 grup cyfr do łańcucha Do(byłi = lista tekstowa.długość-1; ja >=0; I--){Jeśli(tekstLista[i] !==''){tekst += tekstLista[i]+th[i];}// pomiń jeśli liczba była równa 0}powróttekst;}

Funkcja, która będzie działać również z wartościami dziesiętnymi

funkcjonować ilośćToWords(kwota w cyfrach){// Amerykański system numeracji byłth = ['','tysiąc','milion','miliard','bilion'];byłdg = ['zero','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć'];byłtn = ['dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];byłtw = ['20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];funkcjonować do słów(S){ s = s.do Ciągu(); s = s.zastępować(/[, ]/G,'');Jeśli(s!=naciśnijPływak(S))powrót „nie liczba”;byłx = s.indeks('.');Jeśli(x == -1) x = s.długość;Jeśli(x >15)powrót 'za duży';byłn = s.podział('');byłstr ='';byłsk =0;Do(byłja=0; ja Jeśli((x-i)%3==2){Jeśli(n[i] ==„1”) { str += tn[Numer(n[i+1])] +''; i++; sk=1; }w przeciwnym razie Jeśli(n[i]!=0) { str += tw[n[i]-2] +'';sk=1; } }w przeciwnym razie Jeśli(n[i]!=0) { str += dg[n[i]] +'';Jeśli((x-i)%3==0) str +=„sto”; sk=1; }Jeśli((x-i)%3==1) {Jeśli(sk) str += th[(x-i-1)/3] +'';sk=0; } }Jeśli(x!= s.długość) {byłi = tak.długość; str +='punkt ';Do(byłi=x+1; i''; }powrótul.zastępować(/s+/g,''); }powrót do słów(kwota w cyfrach); }

<wejście typ="tekst" nazwa="numer" symbol zastępczy=„Liczba LUB kwota” wł.klawisz="word.innerHTML=ilośćToWords(ta.wartość)"/><dz ID="słowo">dz>

To także odpowiedź naświetny post naomika! Niestety nie mam przedstawiciela, który mógłby opublikować we właściwym miejscu, ale zostawiam to tutaj, na wypadek gdyby komuś mogło to pomóc.

Jeśli potrzebujesz formy pisemnej w języku angielskim brytyjskim, musisz wprowadzić pewne zmiany w kodzie. Brytyjski angielski różni się od amerykańskiego na kilka sposobów. Zasadniczo musisz wstawić słowo „i” w dwóch określonych miejscach.

1. Po stuzakładając, że są dziesiątki i jedności. Np. Sto dziesięć. Tysiąc siedemnaście.NIETysiąc sto i.
2. Na niektórych krawędziachpo tysiącu, milionach, miliardach itd. gdy nie ma mniejszych jednostek. Np. Tysiąc dziesięć. Milion czterdzieści cztery.NIEMilion i tysiąc.

Pierwszą sytuację można rozwiązać, sprawdzając 10 i 1 w metodzie makeGroup i dodając „i”, jeśli istnieją.

utwórzGrupę =([jednostki, dziesiątki, huny]) =>{byłprzymiotnik =Ten.liczba(je)?„sto i”:Ten.liczba(dziesiątki) ?„sto i”:„sto”;powrót[Ten.liczba(uwaga) ===0?'':Ten.A[huns] + przymiotnik,Ten.liczba(jednostki) ===0?Ten.B[dziesiątki] :Ten.B[dziesiątki] &&Ten.B[dziesiątki] +'-'||'',Ten.A[dziesiątki+jednostki] ||Ten.A[te]].dołączyć('');

};

Drugi przypadek jest bardziej skomplikowany. Jest to równoważne

• dodaj „i” do „milionu, tysiąca” lub „miliarda”, jeśli przedostatnia liczba wynosi zero. np.

1100,057 milion stotysiące ipięćdziesiąt siedem.
5000,006 pięćmilion isześć

Myślę, że można to zaimplementować w kodzie @naomik za pomocą funkcji filtrującej, ale nie byłem w stanie wymyślić, jak to zrobić. W końcu zdecydowałem się na hackickie zapętlenie przez zwróconą tablicę słów i użycie indexOf do wyszukania przypadków, w których brakowało słowa „setka” w ostatnim elemencie.

Właśnie napisałempaisa.jsaby to zrobić, a także poprawnie obsługuje lakhs i crores, może to sprawdzić. Rdzeń wygląda mniej więcej tak:

konststali bywalcy = [ {1:'jeden',2:'dwa',3:'trzy',4:„cztery”,5:'pięć',6:'sześć',7:„siedem”,8:'osiem',9:'dziewięć'}, {2:'20',3:'trzydzieści',4:'czterdzieści',5:'pięćdziesiąt',6:'sześćdziesiąt',7:'siedemdziesiąt',8:'osiemdziesiąt',9:'dziewięćdziesiąt'}]konstwyjątki = {10:'dziesięć',11:'jedenaście',12:'dwanaście',13:'trzynaście',14:'czternaście',15:'piętnaście',16:'szesnaście',17:'siedemnaście',18:'osiemnaście',19:'dziewiętnaście'}konst częśćW słowach= (część) => {Jeśli(parseInt(część) ===0)powrót konstcyfry = część.podział('')konstsłowa = []Jeśli(cyfry.długość===3) { słowa.naciskać([bywalcy[0][cyfry.zmiana()],'sto'].dołączyć('')) }Jeśli(wyjątki [cyfry.dołączyć('')]) { słowa.naciskać(wyjątki [cyfry.dołączyć('')]) }w przeciwnym razie{ słowa.naciskać(cyfry.odwracać().zmniejszyć((notatka, i) =>{ notatka.zmienić bieg(zwykły[i][el])powrótnotatka }, []).filtr(w=>w).dołączyć('')) }powrótsłowa.filtr(w=>w.przycinać().długość).dołączyć(' I ')}

Moje rozwiązanie jest oparte na rozwiązaniu Juana Gaitána dla waluty indyjskiej, działa na crores.

funkcjonować wartośćInWords(wartość) {pozwalaćjedynki = ['','jeden','dwa','trzy',„cztery”,'pięć','sześć',„siedem”,'osiem','dziewięć','dziesięć','jedenaście','dwanaście','trzynaście','czternaście','piętnaście','szesnaście','siedemnaście','osiemnaście','dziewiętnaście'];pozwalaćdziesiątki = ['20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];pozwalaćcyfra =0;Jeśli(wartość <20)powrótjedynki [wartość];Jeśli(wartość <100) { cyfra = wartość %10;//reszta powrótkilkadziesiąt[Matematyka.podłoga(wartość/10)-2] +" "+ (cyfra >0? jedności[cyfra] :""); }Jeśli(wartość <1000) {powrótte[Matematyka.podłoga(wartość/100)] +"sto"+ (wartość %100>0?wartośćInWords(wartość %100) :""); }Jeśli(wartość <100000) {powrót wartośćInWords(Matematyka.podłoga(wartość/1000)) +"tysiące"+ (wartość %1000>0?wartośćInWords(wartość %1000) :""); }Jeśli(wartość <10000000) {powrót wartośćInWords(Matematyka.podłoga(wartość/100000)) +" lakh "+ (wartość %100000>0?wartośćInWords(wartość %100000) :""); }powrót wartośćInWords(Matematyka.podłoga(wartość/10000000)) +"krora"+ (wartość %10000000>0?wartośćInWords(wartość %10000000) :""); }

Dla tych, którzy szukają imperialnych/angielskich konwencji nazewnictwa.

Na podstawie @Salmanaodpowiedź

byłza = ['','jeden ',„dwa”,'trzy ',„cztery”,'pięć ',„sześć”,„siedem”,'osiem ','dziewięć ','dziesięć ',„jedenaście”,„dwanaście”,„trzynaście”,„czternaście”,'piętnaście ',„szesnaście”,„siedemnaście”,'osiemnaście ','dziewiętnaście '];byłb = ['','','20','trzydzieści','czterdzieści','pięćdziesiąt','sześćdziesiąt','siedemdziesiąt','osiemdziesiąt','dziewięćdziesiąt'];funkcjonować w słowach(liczba) {Jeśli((liczba = liczba.do Ciągu()).długość>12)powrót 'przelewowy'; n = ('00000000000'+ liczba).podstr(-12).mecz(/^(d{3})(d{3})(d{3})(d{1})(d{2})$/);Jeśli(!N)powrót;byłstr =''; str += (n[1] !=0)? (Numer(N[1]) >99?Ten.A[Numer(N[1][0])] +„sto”:'') + (a[Numer(N[1])] || b[n[1][1]] +''+ a[n[1][2]]) +'miliard ':''; str += (n[2] !=0)? (Numer(N[2]) >99?Ten.A[Numer(N[2][0])] +„sto”:'') + (a[Numer(N[2])] || b[n[2][1]] +''+ a[n[2][2]]) +„milion”:''; str += (n[3] !=0)? (Numer(N[3]) >99?Ten.A[Numer(N[3][0])] +„sto”:'') + (a[Numer(N[3])] || b[n[3][1]] +''+ a[n[3][2]]) +„tysiące”:''; str += (n[4] !=0)? (A[Numer(N[4])] || b[n[4][0]] +''+ a[n[4][1]]) +„sto”:''; str += (Numer(N[5]) !==0)? ((str!=='')?'I ':'') + (Ten.A[Numer(N[5])] ||Ten.B[N[5][0]] +''+Ten.A[N[5][1]]) +'':'';powrótstr;}dokument.getElementById('numer').wł.klawisz=funkcjonować() {dokument.getElementById('słowa').wewnętrzny HTML=w słowach(dokument.getElementById('numer').wartość);};

<Zakres ID="słowa">Zakres><wejście ID="numer" typ="tekst"/>

Najczystsze i najłatwiejsze podejście, które przyszło mi do głowy:

konstliczbaTekst = {1:'jeden',2:'dwa',3:'trzy',4:„cztery”,5:'pięć',6:'sześć',7:„siedem”,8:'osiem',9:'dziewięć',10:'dziesięć',11:'jedenaście',12:'dwanaście',13:'trzynaście',14:'czternaście',15:'piętnaście',16:'szesnaście',17:'siedemnaście',18:'osiemnaście',19:'dziewiętnaście',20:'20',30:'trzydzieści',40:'czterdzieści',50:'pięćdziesiąt',60:'sześćdziesiąt',70:'siedemdziesiąt',80:'osiemdziesiąt',90:'dziewięćdziesiąt',100:'sto',1000:'tysiąc',}konstliczbaWartości =Obiekt.Klucze(numerTekst) .mapa((wartość) => Numer(val)) .sortować((a, b) =>b - a)konst konwertuj liczbę na tekst w języku angielskim= (N) => {Jeśli(n ===0)powrót 'zero' Jeśli(n <0)powrót 'negatywny '+konwertuj liczbę na tekst w języku angielskim(-N)pozwalaćczy = npozwalaćtekst ='' Do(konstliczbaWartośćzliczbaWartości) {konstliczyć =Matematyka.pień(liczba / liczbaWartość)Jeśli(liczba <1)Kontynuować Jeśli(liczbaWartość>=100) tekst +=konwertuj liczbę na tekst w języku angielskim(liczba) +''tekst += liczbaTekst[wartośćliczby] +''liczba -= liczba * liczbaWartość}Jeśli(liczba !==0)rzucić Błąd('Coś poszło nie tak!')powróttekst.przycinać()}

Prawdopodobnie najprostszy, jaki dostałem i użyłem, pochodził od Bena E. Wprowadziłem modyfikacje do jego kodu, ponieważ zwracał on na przykład tylko „Pięćset” przy próbie przekonwertowania 500 000,00. Właśnie dodałem wiersz kodu warunkowego, aby to naprawić. Dodano również przepis dotyczący podawania dwóch ostatnich miejsc po przecinku. Używam go teraz do konwersji kwoty na słowa podczas drukowania czeków. Oto moja poprawka dodana do tego:

Jeśli(Matematyka.podłoga((numer%(100*Matematyka.pow(1000,I))/Matematyka.pow(1000,i))) ==0) { słowo = pierwszy[Matematyka.podłoga(tempNumer/(100*Matematyka.pow(1000,i)))] +„sto”+ wściekły[i] +''+ słowo;}w przeciwnym razie{

Mam trudności z wklejeniem kodu tutaj, ale daj mi znać, jeśli potrzebujesz wyjaśnień

odpowiedział @pramod kharade

uproszczony

funkcjonować Liczba do słowa(liczba wejściowa) {byłstr =nowy Strunowy(liczba wejściowa)byłsplt = ul.podział("");byłobr = splt.odwracać();byłraz = ['Zero',' Jeden',„Dwa”,' Trzy',„Cztery”,' Pięć',„Sześć”,„Siedem”,' Osiem',' Dziewięć'];byłdwójki = ['Dziesięć',„Jedenaście”,„Dwanaście”,„trzynaście”,„Czternaście”,' Piętnaście',„szesnaście”,„siedemnaście”,' Osiemnaście',' Dziewiętnaście'];byłdziesiątki = ['','Dziesięć',' 20',' Trzydzieści',„Czterdzieści”,„Pięćdziesiąt”,„Sześćdziesiąt”,„siedemdziesiąt”,' Osiemdziesiąt',„Dziewięćdziesiąt”]; liczbaDługość = obr.długość;byłsłowo =nowy Szyk();byłj =0;Do(ja =0; i < liczbaDługość; i++) {przełącznik(I) {sprawa 0:Jeśli((obr[i] ==0) || (rew[i +1] ==1)) { słowo [j] =''; }w przeciwnym razie{ słowo [j] =''+ raz[obr[i]]; } słowo[j] = słowo[j];przerwa;sprawa 1:powyżej Dziesiątki();przerwa;sprawa 2:Jeśli(obr[i] ==0) { słowo [j] =''; }w przeciwnym razie Jeśli((obr[i -1] ==0) || (rew[i -2] ==0)) { słowo[j] = raz[obr[i]] +„sto”; }w przeciwnym razie{słowo[j] = raz[rev[i]] +„sto i”; }przerwa;sprawa 3:Jeśli(obr[i] ==0|| obr[i +1] ==1) { słowo [j] =''; }w przeciwnym razie{słowo[j] = raz[rev[i]]; }Jeśli((rew[i +1] !=0) || (rew[i] >0)) { słowo [j] = słowo [j] +„Tysiąc”; }przerwa;sprawa 4:powyżej Dziesiątki();przerwa;sprawa 5:Jeśli((obr[i] ==0) || (rew[i +1] ==1)) { słowo [j] =''; }w przeciwnym razie{słowo[j] = raz[rev[i]]; }Jeśli(rew[i +1] !==„0”|| obr[i] >„0”) { słowo [j] = słowo [j] +„Lakh”; }przerwa;sprawa 6:powyżej Dziesiątki();przerwa;sprawa 7:Jeśli((obr[i] ==0) || (rew[i +1] ==1)) { słowo [j] =''; }w przeciwnym razie{słowo[j] = raz[rev[i]]; }Jeśli(rew[i +1] !==„0”|| obr[i] >„0”) { słowo [j] = słowo [j] +„Krore”; }przerwa;sprawa 8:powyżej Dziesiątki();przerwa;domyślny:przerwa; } j++; }funkcjonować powyżej Dziesiątki() {Jeśli(obr[i] ==0) { słowo [j] =''; }w przeciwnym razie Jeśli(obr[i] ==1) { słowo[j] = dwójki[obr[i -1]]; }w przeciwnym razie{słowo[j] = dziesiątki[obr[i]]; } } słowo.odwracać();byłkońcowy wynik ='';Do(ja =0; i < liczbaDługość; i++) { finalOutput = finalOutput + word[i]; }powrótkońcowy wynik;}konsola.dziennik(Liczba do słowa(123))konsola.dziennik(Liczba do słowa(12345678))konsola.dziennik(Liczba do słowa(12334543))konsola.dziennik(Liczba do słowa(6789876123))