battle programmers alliance
Would you like to react to this message? Create an account in a few clicks or log in to continue.

battle programmers allianceLog in

the LivinGrimoire Artificial General Intelligence software design pattern forum

JS javascript convert number to words

power_settings_newLogin to reply
2 posters

descriptionJS javascript convert number to words EmptyJS javascript convert number to wordsWed Dec 06, 2017 1:23 pm

more_horiz

Code:

function getDigits(n){
 var result = "enter a number"
 var characters = n + "" // converts n to a string
 switch (characters.length){
        case 1:
 switch(n){
                case 1: result = 'one';break;
 case 2: result = 'two';break;
 case 3: result = 'three';break;
 case 4: result = 'four';break;
 case 5: result = 'five';break;
 case 6: result = 'six';break;
 case 7: result = 'seven';break;
 case 8: result = 'eight';break;
                case 9: result = 'nine';break;
 default: result = '';break;
 }break;
 case 2:
                    switch (Math.floor(n / 10))
                    {
                        case 1:
                            result = "ten" + " " +  getDigits(n % 10);
                            break;
                        case 2:
                            result = "twenty" + " " +  getDigits(n % 10); break;
                        case 3:
                            result = "thirty" + " " +  getDigits(n % 10); break;
                        case 4:
                            result = "forty" + " " +  getDigits(n % 10); break;
                        case 5:
                            result = "fifty" + " " +  getDigits(n % 10); break;
                        case 6:
                            result = "Sixty" + " " +  getDigits(n % 10); break;
                        case 7:
                            result = "seventy" + " " +  getDigits(n % 10); break;
                        case 8:
                            result = "eighty" + " " +  getDigits(n % 10); break;
                        case 9:
                            result = "ninety" + " " +  getDigits(n % 10); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 3:
                    switch (Math.floor(n / 100))
                    {
                        case 1:
                            result = "one hundred" + " " + getDigits(n % 100);
                            break;
                        case 2:
                            result = "two hundred" + " " + getDigits(n % 100); break;
                        case 3:
                            result = "three hundred" + " " + getDigits(n % 100); break;
                        case 4:
                            result = "four hundred" + " " + getDigits(n % 100); break;
                        case 5:
                            result = "five hundred" + " " + getDigits(n % 100); break;
                        case 6:
                            result = "six hundred" + " " + getDigits(n % 100); break;
                        case 7:
                            result = "seven hundred" + " " + getDigits(n % 100); break;
                        case 8:
                            result = "eight hundred" + " " + getDigits(n % 100); break;
                        case 9:
                            result = "nine hundred" + " " + getDigits(n % 100); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 4:
                    switch (Math.floor(n / 1000))
                    {
                        case 1:
                            result = "one Thousand" + " " + getDigits(n % 1000);
                            break;
                        case 2:
                            result = "two Thousand" + " " + getDigits(n % 1000); break;
                        case 3:
                            result = "three Thousand" + " " + getDigits(n % 1000); break;
                        case 4:
                            result = "four Thousand" + " " + getDigits(n % 1000); break;
                        case 5:
                            result = "five Thousand" + " " + getDigits(n % 1000); break;
                        case 6:
                            result = "six Thousand" + " " + getDigits(n % 1000); break;
                        case 7:
                            result = "seven Thousand" + " " + getDigits(n % 1000); break;
                        case 8:
                            result = "eight Thousand" + " " + getDigits(n % 1000); break;
                        case 9:
                            result = "nine Thousand" + " " + getDigits(n % 1000); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 5:  
     var temp1 = getDigits(Math.floor(n/1000)) + " thousand"; temp1 = temp1 + " " + getDigits(n% 1000);
 result = temp1;

 break;
 case 6:  
     var temp1 = getDigits(Math.floor(n/1000))+ " thousand";
         temp1 = temp1 + " " + getDigits(n% 1000);
 result = temp1;

 break;
 case 7:
                    switch (Math.floor(n / 1000000))
                    {
                        case 1:
                            result = "one million" + " " + getDigits(n % 1000000);
                            break;
                        case 2:
                            result = "two million" + " " + getDigits(n % 1000000); break;
                        case 3:
                            result = "three million" + " " + getDigits(n % 1000000); break;
                        case 4:
                            result = "four million" + " " + getDigits(n % 1000000); break;
                        case 5:
                            result = "five million" + " " + getDigits(n % 1000000); break;
                        case 6:
                            result = "six million" + " " + getDigits(n % 1000000); break;
                        case 7:
                            result = "seven million" + " " + getDigits(n % 1000000); break;
                        case 8:
                            result = "eight million" + " " + getDigits(n % 1000000); break;
                        case 9:
                            result = "nine million" + " " + getDigits(n % 1000000); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 8:  
     var temp1 = getDigits(Math.floor(n/1000000))+ " million";
         temp1 = temp1 + " " + getDigits(n% 1000000);
 result = temp1;

 break;
 case 9:  
     var temp1 = getDigits(Math.floor(n/1000000))+ " million";
         temp1 = temp1 + " " + getDigits(n% 1000000);
 result = temp1;

 break;
 case 10:
                    switch (Math.floor(n / 1000000000))
                    {
                        case 1:
                            result = "one Billion" + " " + getDigits(n % 1000000000);
                            break;
                        case 2:
                            result = "two Billion" + " " + getDigits(n % 1000000000); break;
                        case 3:
                            result = "three Billion" + " " + getDigits(n % 1000000000); break;
                        case 4:
                            result = "four Billion" + " " + getDigits(n % 1000000000); break;
                        case 5:
                            result = "five Billion" + " " + getDigits(n % 1000000000); break;
                        case 6:
                            result = "six Billion" + " " + getDigits(n % 1000000000); break;
                        case 7:
                            result = "seven Billion" + " " + getDigits(n % 1000000000); break;
                        case 8:
                            result = "eight Billion" + " " + getDigits(n % 1000000000); break;
                        case 9:
                            result = "nine Billion" + " " + getDigits(n % 1000000000); break;
                        default:
                            result = ""; break;
                    }


                    break;
        case 11:case 12 :
 var temp1 = getDigits(Math.floor(n/1000000000))+ " Billion";
         temp1 = temp1 + " " + getDigits(n% 1000000000);
 result = temp1;
 break;
 case 13:
                    switch (Math.floor(n / 1000000000000))
                    {
                        case 1:
                            result = "one Trillion" + " " + getDigits(n % 1000000000000);
                            break;
                        case 2:
                            result = "two Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 3:
                            result = "three Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 4:
                            result = "four Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 5:
                            result = "five Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 6:
                            result = "six Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 7:
                            result = "seven Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 8:
                            result = "eight Trillion" + " " + getDigits(n % 1000000000000); break;
                        case 9:
                            result = "nine Trillion" + " " + getDigits(n % 1000000000000); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 14:case 15 :
 var temp1 = getDigits(Math.floor(n/1000000000000))+ " Trillion";
         temp1 = temp1 + " " + getDigits(n% 1000000000000);
 result = temp1;
 break;
 case 16:
                    switch (Math.floor(n / 1000000000000000))
                    {
                        case 1:
                            result = "one Quadrillion" + " " + getDigits(n % 1000000000000000);
                            break;
                        case 2:
                            result = "two Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 3:
                            result = "three Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 4:
                            result = "four Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 5:
                            result = "five Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 6:
                            result = "six Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 7:
                            result = "seven Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 8:
                            result = "eight Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        case 9:
                            result = "nine Quadrillion" + " " + getDigits(n % 1000000000000000); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 17:case 18 :
 var temp1 = getDigits(Math.floor(n/1000000000000000))+ " Quadrillion";
         temp1 = temp1 + " " + getDigits(n% 1000000000000000);
 result = temp1;
 break;
 case 19:
                    switch (Math.floor(n / 1000000000000000000))
                    {
                        case 1:
                            result = "one Quintillion" + " " + getDigits(n % 1000000000000000000);
                            break;
                        case 2:
                            result = "two Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 3:
                            result = "three Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 4:
                            result = "four Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 5:
                            result = "five Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 6:
                            result = "six Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 7:
                            result = "seven Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 8:
                            result = "eight Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        case 9:
                            result = "nine Quintillion" + " " + getDigits(n % 1000000000000000000); break;
                        default:
                            result = ""; break;
                    }


                    break;
 case 20:case 21 :
 var temp1 = getDigits(Math.floor(n/1000000000000000000))+ " Quintillion";
         temp1 = temp1 + " " + getDigits(n% 1000000000000000000);
 result = temp1;
 break;
 
 }
 return result
}
console.info(getDigits(666666666666666666666))

function repairText(n){



var res = n;

res = res.replace("ten one", "eleven");
 
res = res.replace("ten two", "twelve");
 
res = res.replace("ten one", "thirteen");
 
res = res.replace("ten one", "fourteen");
 
res = res.replace("ten one", "fifteen");
 
res = res.replace("ten one", "sixteen");
 
res = res.replace("ten one", "seventeen");
 
res = res.replace("ten one", "eighteen");
 
res = res.replace("ten one", "nineteen");

return res;
}


function getDigit(n){
return repairText(getDigits(n))}

console.info(getDigit(12))


JS javascript convert number to words 20l5nz

descriptionJS javascript convert number to words Emptyconvert number to words vb.netMon Oct 08, 2018 6:42 am

more_horiz
created by moti barski
the following code was written on vb.net express 2010
the program reads the number in the textbox in japanese
controls :
textbox : maxlength : 16
label

to show the picture of the kanji in the select case make the respectivs kanji display in a picturebox

Code:

Imports System.Math
Public Class Form1
    Function toKanji(ByVal N As ULong) As String
        Dim kanji As String
        kanji = "enter a number"
        Select Case N.ToString.Length()
            Case 1
                Select Case N
                    Case 1
                        kanji = "ichi"
                    Case 2
                        kanji = "ni"
                    Case 3
                        kanji = "san"
                    Case 4
                        kanji = "yon"
                    Case 5
                        kanji = "go"
                    Case 6
                        kanji = "roku"
                    Case 7
                        kanji = "nana"
                    Case 8
                        kanji = "hachi"
                    Case 9
                        kanji = "kyu"
                    Case Else
                        kanji = ""
                End Select
            Case 2
                Select Case N \ 10
                    Case 1
                        kanji = "ju" & " " & toKanji(N Mod 10)
                    Case 2
                        kanji = "ni-ju" & " " & toKanji(N Mod 10)
                    Case 3
                        kanji = "san-ju" & " " & toKanji(N Mod 10)
                    Case 4
                        kanji = "yon-ju" & " " & toKanji(N Mod 10)
                    Case 5
                        kanji = "go-ju" & " " & toKanji(N Mod 10)
                    Case 6
                        kanji = "roku-ju" & " " & toKanji(N Mod 10)
                    Case 7
                        kanji = "nana-ju" & " " & toKanji(N Mod 10)
                    Case 8
                        kanji = "hachi-ju" & " " & toKanji(N Mod 10)
                    Case 9
                        kanji = "kyu-ju" & " " & toKanji(N Mod 10)
                    Case Else
                        kanji = ""
                End Select
            Case 3
                Select Case N \ 100
                    Case 1
                        kanji = "hyaku" & " " & toKanji(N Mod 100)
                    Case 2
                        kanji = "ni-hyaku" & " " & toKanji(N Mod 100)
                    Case 3
                        kanji = "sanbyaku" & " " & toKanji(N Mod 100)
                    Case 4
                        kanji = "yon-hyaku" & " " & toKanji(N Mod 100)
                    Case 5
                        kanji = "go-hyaku" & " " & toKanji(N Mod 100)
                    Case 6
                        kanji = "roppyaku" & " " & toKanji(N Mod 100)
                    Case 7
                        kanji = "nana-hyaku" & " " & toKanji(N Mod 100)
                    Case 8
                        kanji = "happyaku" & " " & toKanji(N Mod 100)
                    Case 9
                        kanji = "kyu-hyaku" & toKanji(N Mod 100)
                    Case Else
                        kanji = ""
                End Select
            Case 4
                Select Case N \ 1000
                    Case 1
                        kanji = "sen" & " " & toKanji(N Mod 1000)
                    Case 2
                        kanji = "ni-sen" & " " & toKanji(N Mod 1000)
                    Case 3
                        kanji = "san-zen" & " " & toKanji(N Mod 1000)
                    Case 4
                        kanji = "yon-sen" & " " & toKanji(N Mod 1000)
                    Case 5
                        kanji = "go-sen" & " " & toKanji(N Mod 1000)
                    Case 6
                        kanji = "roku-sen" & " " & toKanji(N Mod 1000)
                    Case 7
                        kanji = "nana-sen" & " " & toKanji(N Mod 1000)
                    Case 8
                        kanji = "hassen" & " " & toKanji(N Mod 1000)
                    Case 9
                        kanji = "kyu-sen" & toKanji(N Mod 1000)
                    Case Else
                        kanji = ""
                End Select
            Case 5
                Select Case N \ 10000
                    Case 1
                        kanji = "ichi-man" & " " & toKanji(N Mod 10000)
                    Case 2
                        kanji = "ni-man" & " " & toKanji(N Mod 10000)
                    Case 3
                        kanji = "san-man" & " " & toKanji(N Mod 10000)
                    Case 4
                        kanji = "yon-man" & " " & toKanji(N Mod 10000)
                    Case 5
                        kanji = "go-man" & " " & toKanji(N Mod 10000)
                    Case 6
                        kanji = "roku-man" & " " & toKanji(N Mod 10000)
                    Case 7
                        kanji = "nana-man" & " " & toKanji(N Mod 10000)
                    Case 8
                        kanji = "hachi-man" & " " & toKanji(N Mod 10000)
                    Case 9
                        kanji = "kyu-man" & toKanji(N Mod 10000)
                    Case Else
                        kanji = ""
                End Select
            Case 6
                Select Case N \ 100000
                    Case 1
                        kanji = "ju" & " " & toKanji(N Mod 100000)
                    Case 2
                        kanji = "ni-ju" & " " & toKanji(N Mod 100000)
                    Case 3
                        kanji = "san-ju" & " " & toKanji(N Mod 100000)
                    Case 4
                        kanji = "yon-ju" & " " & toKanji(N Mod 100000)
                    Case 5
                        kanji = "go-ju" & " " & toKanji(N Mod 100000)
                    Case 6
                        kanji = "roku-ju" & " " & toKanji(N Mod 100000)
                    Case 7
                        kanji = "nana-ju" & " " & toKanji(N Mod 100000)
                    Case 8
                        kanji = "hachi-ju" & " " & toKanji(N Mod 100000)
                    Case 9
                        kanji = "kyu-ju" & toKanji(N Mod 100000)
                    Case Else
                        kanji = ""
                End Select
            Case 7
                Select Case N \ 1000000
                    Case 1
                        kanji = "hyaku" & " " & toKanji(N Mod 1000000)
                    Case 2
                        kanji = "ni-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 3
                        kanji = "san-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 4
                        kanji = "yon-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 5
                        kanji = "go-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 6
                        kanji = "roku-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 7
                        kanji = "nana-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 8
                        kanji = "hachi-hyaku" & " " & toKanji(N Mod 1000000)
                    Case 9
                        kanji = "kyu-hyaku" & toKanji(N Mod 1000000)
                    Case Else
                        kanji = ""
                End Select
            Case 8
                Select Case N \ 10000000
                    Case 1
                        kanji = "sen" & " " & toKanji(N Mod 10000000)
                    Case 2
                        kanji = "ni-sen" & " " & toKanji(N Mod 10000000)
                    Case 3
                        kanji = "sanzen" & " " & toKanji(N Mod 10000000)
                    Case 4
                        kanji = "yon-sen" & " " & toKanji(N Mod 10000000)
                    Case 5
                        kanji = "go-sen" & " " & toKanji(N Mod 10000000)
                    Case 6
                        kanji = "roku-sen" & " " & toKanji(N Mod 10000000)
                    Case 7
                        kanji = "nana-sen" & " " & toKanji(N Mod 10000000)
                    Case 8
                        kanji = "hachi-sen" & " " & toKanji(N Mod 10000000)
                    Case 9
                        kanji = "kyu-sen" & toKanji(N Mod 10000000)
                    Case Else
                        kanji = ""
                End Select
            Case 9
                Select Case N \ 100000000
                    Case 1
                        kanji = "ichi-oku" & " " & toKanji(N Mod 100000000)
                    Case 2
                        kanji = "ni-oku" & " " & toKanji(N Mod 100000000)
                    Case 3
                        kanji = "san-oku" & " " & toKanji(N Mod 100000000)
                    Case 4
                        kanji = "yon-oku" & " " & toKanji(N Mod 100000000)
                    Case 5
                        kanji = "go-oku" & " " & toKanji(N Mod 100000000)
                    Case 6
                        kanji = "roku-oku" & " " & toKanji(N Mod 100000000)
                    Case 7
                        kanji = "nana-oku" & " " & toKanji(N Mod 100000000)
                    Case 8
                        kanji = "hachi-oku" & " " & toKanji(N Mod 100000000)
                    Case 9
                        kanji = "kyu-oku" & toKanji(N Mod 100000000)
                    Case Else
                        kanji = ""
                End Select
Case 10
                Select Case N \ 1000000000
                    Case 1
                        kanji = "ju" & " " & toKanji(N Mod 1000000000)
                    Case 2
                        kanji = "ni-ju" & " " & toKanji(N Mod 1000000000)
                    Case 3
                        kanji = "san-ju" & " " & toKanji(N Mod 1000000000)
                    Case 4
                        kanji = "yon-ju" & " " & toKanji(N Mod 1000000000)
                    Case 5
                        kanji = "go-ju" & " " & toKanji(N Mod 1000000000)
                    Case 6
                        kanji = "roku-ju" & " " & toKanji(N Mod 1000000000)
                    Case 7
                        kanji = "nana-ju" & " " & toKanji(N Mod 1000000000)
                    Case 8
                        kanji = "hachi-ju" & " " & toKanji(N Mod 1000000000)
                    Case 9
                        kanji = "kyu-ju" & toKanji(N Mod 1000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 11
                Select Case N \ 10000000000
                    Case 1
                        kanji = "hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 2
                        kanji = "ni-hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 3
                        kanji = "sanbyaku" & " " & toKanji(N Mod 10000000000)
                    Case 4
                        kanji = "yon-hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 5
                        kanji = "go-hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 6
                        kanji = "roku-hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 7
                        kanji = "nana-hyaku" & " " & toKanji(N Mod 10000000000)
                    Case 8
                        kanji = "hapyaku" & " " & toKanji(N Mod 10000000000)
                    Case 9
                        kanji = "kyu-hyaku" & toKanji(N Mod 10000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 12
                Select Case N \ 100000000000
                    Case 1
                        kanji = "sen" & " " & toKanji(N Mod 100000000000)
                    Case 2
                        kanji = "ni-sen" & " " & toKanji(N Mod 100000000000)
                    Case 3
                        kanji = "sanzen" & " " & toKanji(N Mod 100000000000)
                    Case 4
                        kanji = "yon-sen" & " " & toKanji(N Mod 100000000000)
                    Case 5
                        kanji = "go-sen" & " " & toKanji(N Mod 100000000000)
                    Case 6
                        kanji = "roku-sen" & " " & toKanji(N Mod 100000000000)
                    Case 7
                        kanji = "nana-sen" & " " & toKanji(N Mod 100000000000)
                    Case 8
                        kanji = "hassen" & " " & toKanji(N Mod 100000000000)
                    Case 9
                        kanji = "kyu-sen" & toKanji(N Mod 100000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 13
                Select Case N \ 1000000000000
                    Case 1
                        kanji = "itcho" & " " & toKanji(N Mod 1000000000000)
                    Case 2
                        kanji = "ni-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 3
                        kanji = "san-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 4
                        kanji = "yon-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 5
                        kanji = "go-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 6
                        kanji = "roku-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 7
                        kanji = "nana-cho" & " " & toKanji(N Mod 1000000000000)
                    Case 8
                        kanji = "hatcho" & " " & toKanji(N Mod 1000000000000)
                    Case 9
                        kanji = "kyu-cho" & toKanji(N Mod 1000000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 14
                Select Case N \ 10000000000000
                    Case 1
                        kanji = "ju" & " " & toKanji(N Mod 10000000000000)
                    Case 2
                        kanji = "ni-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 3
                        kanji = "san-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 4
                        kanji = "yon-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 5
                        kanji = "go-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 6
                        kanji = "roku-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 7
                        kanji = "nana-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 8
                        kanji = "hachi-ju" & " " & toKanji(N Mod 10000000000000)
                    Case 9
                        kanji = "kyu-ju" & toKanji(N Mod 10000000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 15
                Select Case N \ 100000000000000
                    Case 1
                        kanji = "hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 2
                        kanji = "ni-hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 3
                        kanji = "sanbyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 4
                        kanji = "yon-hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 5
                        kanji = "go-hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 6
                        kanji = "roku-hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 7
                        kanji = "nana-hyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 8
                        kanji = "hapyaku" & " " & toKanji(N Mod 100000000000000)
                    Case 9
                        kanji = "kyu-hyaku" & toKanji(N Mod 100000000000000)
                    Case Else
                        kanji = ""
                End Select
            Case 16
                Select Case N \ 1000000000000000
                    Case 1
                        kanji = "sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 2
                        kanji = "ni-sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 3
                        kanji = "sanzen" & " " & toKanji(N Mod 1000000000000000)
                    Case 4
                        kanji = "yon-sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 5
                        kanji = "go-sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 6
                        kanji = "roku-sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 7
                        kanji = "nana-sen" & " " & toKanji(N Mod 1000000000000000)
                    Case 8
                        kanji = "hassen" & " " & toKanji(N Mod 1000000000000000)
                    Case 9
                        kanji = "kyu-sen" & toKanji(N Mod 1000000000000000)
                    Case Else
                        kanji = ""
                End Select
            Case Else

        End Select


        Return kanji
    End Function
    Private Sub TextBox1_KeyUp(ByVal sender As System.Object, ByVal e As System.Windows.Forms.KeyEventArgs) Handles TextBox1.KeyUp
        Try
            Dim dnum As ULong
            dnum = TextBox1.Text
            If dnum = 0 Then
                Label1.Text = "rei"
            Else
                Label1.Text = toKanji(dnum)
            End If
        Catch ex As Exception
            MsgBox("enter an integer up to 16 digits , text length : " & TextBox1.Text.Length())
        End Try
    End Sub
End Class

http://japan-cc.com/countjp.htm :greatscott:

descriptionJS javascript convert number to words Emptyjava convert number to hebrew wordsSun Oct 21, 2018 8:44 pm

more_horiz
code

Code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;



namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show(toHebCount(9566999666999000666));
        }
        private string phoneReplace(string st1)
        {
            string temp1 = st1;
            temp1 = temp1.Replace("עשר ואחת", "ואחת עשרה");
            temp1 = temp1.Replace("עשר ושתיים", "ושתיים עשרה");
            temp1 = temp1.Replace("עשר ושלוש", "ושלוש עשרה");
            temp1 = temp1.Replace("עשר וארבע", "וארבע עשרה");
            temp1 = temp1.Replace("עשר וחמש", "וחמש עשרה");
            temp1 = temp1.Replace("עשר ושש", "ושש עשרה");
            temp1 = temp1.Replace("עשר ושבע", "ושבע עשרה");
            temp1 = temp1.Replace("עשר ושמונה", "ושמונה עשרה");
            temp1 = temp1.Replace("עשר ותשע", "ותשע עשרה");
          
            return temp1;
        }
        private string phoneReplace2(string st1)
        {
            string temp1 = st1 ;
          
            temp1 = temp1.Replace("ושבע עשרה", "שבע עשרה");
            temp1 = temp1.Replace("ושמונה עשרה", "שמונה עשרה");
            temp1 = temp1.Replace("ושש עשרה", "שש עשרה");
            temp1 = temp1.Replace("וחמש עשרה", "חמש עשרה");
            temp1 = temp1.Replace("וארבע עשרה", "ארבע עשרה");
            temp1 = temp1.Replace("ושלוש עשרה", "שלוש עשרה");
            temp1 = temp1.Replace("ושתיים עשרה", "שתיים עשרה");
            temp1 = temp1.Replace("ואחת עשרה", "אחת עשרה");
            temp1 = temp1.Replace("ותשע עשרה", "תשע עשרה");
            return temp1;
        }
            private string toHebCount(ulong N)
        {
            string tochaa;
            tochaa = "enter a number";
            if (N < 20)
            {
                switch (N)
                {
                    case 1:
                        tochaa = "ראשונה"; break;
                    case 2:
                        tochaa = "שנייה"; break;
                    case 3:
                        tochaa = "שלישית"; break;
                    case 4:
                        tochaa = "רביעית"; break;
                    case 5:
                        tochaa = "חמישית"; break;
                    case 6:
                        tochaa = "שישית"; break;
                    case 7:
                        tochaa = "שביעית"; break;
                    case 8:
                        tochaa = "שמינית"; break;
                    case 9:
                        tochaa = "תשיעית"; break;
                    case 10:
                        tochaa = "עשירית"; break;
                    case 11:
                        tochaa = "אחת עשרה"; break;
                    case 12:
                        tochaa = "שתיים עשרה"; break;
                    case 13:
                        tochaa = "שלוש עשרה"; break;
                    case 14:
                        tochaa = "ארבע עשרה"; break;
                    case 15:
                        tochaa = "חמש עשרה"; break;
                    case 16:
                        tochaa = "שש עשרה"; break;
                    case 17:
                        tochaa = "שבע עשרה"; break;
                    case 18: tochaa = "שמונה עשרה"; break;
                    case 19: tochaa = "תשע עשרה"; break;

                    default:
                        tochaa = ""; break;

                }





            }

            else { tochaa = toKanji(N); }
            tochaa = tochaa.Replace("עשר ואחת", "ואחת עשרה");
            tochaa = tochaa.Replace("עשר ושתיים", "ושתיים עשרה");
            tochaa = tochaa.Replace("עשר ושלוש", "ושלוש עשרה");
            tochaa = tochaa.Replace("עשר וארבע", "וארבע עשרה");
            tochaa = tochaa.Replace("עשר וחמש", "וחמש עשרה");
            tochaa = tochaa.Replace("עשר ושש", "ושש עשרה");
            tochaa = tochaa.Replace("עשר ושבע", "ושבע עשרה");
            tochaa = tochaa.Replace("עשר ושמונה", "ושמונה עשרה");
            tochaa = tochaa.Replace("עשר ותשע", "ותשע עשרה");
            return tochaa;
        }
        private string toKanji(ulong N)
        {
            string kanji;
            kanji = "enter a number";
            string characters = N.ToString();
            switch (characters.Length)
            {
                case 1:
                    switch (N)
                    {
                        case 1:
                            kanji = "ואחת";
                            break;
                        case 2:
                            kanji = "ושתיים"; break;
                        case 3:
                            kanji = "ושלוש"; break;
                        case 4:
                            kanji = "וארבע"; break;
                        case 5:
                            kanji = "וחמש"; break;
                        case 6:
                            kanji = "ושש"; break;
                        case 7:
                            kanji = "ושבע"; break;
                        case 8:
                            kanji = "ושמונה"; break;
                        case 9:
                            kanji = "ותשע"; break;
                        default:
                            kanji = ""; break;

                    }



                    break;
                case 2:
                    switch (N / 10)
                    {
                        case 1:
                            kanji = "עשר" + " " + toKanji(N % 10);
                            break;
                        case 2:
                            kanji = "עשרים" + " " + toKanji(N % 10); break;
                        case 3:
                            kanji = "שלושים" + " " + toKanji(N % 10); break;
                        case 4:
                            kanji = "ארבעים" + " " + toKanji(N % 10); break;
                        case 5:
                            kanji = "חמישים" + " " + toKanji(N % 10); break;
                        case 6:
                            kanji = "שישים" + " " + toKanji(N % 10); break;
                        case 7:
                            kanji = "שבעים" + " " + toKanji(N % 10); break;
                        case 8:
                            kanji = "שמונים" + " " + toKanji(N % 10); break;
                        case 9:
                            kanji = "תשעים" + " " + toKanji(N % 10); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 3:
                    switch (N / 100)
                    {
                        case 1:
                            kanji = "מאה" + " " + toKanji(N % 100);
                            break;
                        case 2:
                            kanji = "מאתיים" + " " + toKanji(N % 100); break;
                        case 3:
                            kanji = "שלוש מאות" + " " + toKanji(N % 100); break;
                        case 4:
                            kanji = "ארבע מאות" + " " + toKanji(N % 100); break;
                        case 5:
                            kanji = "חמש מאות" + " " + toKanji(N % 100); break;
                        case 6:
                            kanji = "שש מאות" + " " + toKanji(N % 100); break;
                        case 7:
                            kanji = "שבע מאות" + " " + toKanji(N % 100); break;
                        case 8:
                            kanji = "שמונה מאות" + " " + toKanji(N % 100); break;
                        case 9:
                            kanji = "תשע מאות" + " " + toKanji(N % 100); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 4:
                    switch (N / 1000)
                    {
                        case 1:
                            kanji = "אלף" + " " + toKanji(N % 1000);
                            break;
                        case 2:
                            kanji = "אלפיים" + " " + toKanji(N % 1000); break;
                        case 3:
                            kanji = "שלושת אלפים" + " " + toKanji(N % 1000); break;
                        case 4:
                            kanji = "ארבעת אלפים" + " " + toKanji(N % 1000); break;
                        case 5:
                            kanji = "חמשת אלפים" + " " + toKanji(N % 1000); break;
                        case 6:
                            kanji = "ששת אלפים" + " " + toKanji(N % 1000); break;
                        case 7:
                            kanji = "שבעת אלפים" + " " + toKanji(N % 1000); break;
                        case 8:
                            kanji = "שמונת אלפים" + " " + toKanji(N % 1000); break;
                        case 9:
                            kanji = "תשעת אלפים" + " " + toKanji(N % 1000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 5:
                    switch (N / 10000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000) + " אלף";
                            
                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000));

                            kanji = temp1;
                            break;
                        
                        default:
                            string temp2 = toKanji(N / 1000) + " אלף";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 6:
                    switch (N / 10000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000) + " אלף";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000) + " אלף";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 7:
                    switch (N / 1000000)
                    {
                        case 1:
                            kanji = " מיליון" + " " + toKanji(N % 1000000);
                            break;
                        case 2:
                            kanji = " שתי מיליון" + " " + toKanji(N % 1000000); break;
                        case 3:
                            kanji = " שלוש מיליון" + " " + toKanji(N % 1000000); break;
                        case 4:
                            kanji = "  ארבע מיליון" + " " + toKanji(N % 1000000); break;
                        case 5:
                            kanji = " חמש מיליון" + " " + toKanji(N % 1000000); break;
                        case 6:
                            kanji = " שש מיליון" + " " + toKanji(N % 1000000); break;
                        case 7:
                            kanji = " שבע מיליון" + " " + toKanji(N % 1000000); break;
                        case 8:
                            kanji = " שמונה מיליון" + " " + toKanji(N % 1000000); break;
                        case 9:
                            kanji = " תשע מיליון" + " " + toKanji(N % 1000000); break;
                        default:
                            kanji = ""; break;
                    }
                    break;
                case 8:
                    switch (N / 10000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000) + " מליון";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000) + " מיליון";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 9:
                    switch (N / 100000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000) + " מליון";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000) + " מיליון";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 10:
                    switch (N / 1000000000)
                    {
                        case 1:
                            kanji = " מיליארד" + " " + toKanji(N % 1000000000);
                            break;
                        case 2:
                            kanji = " שתי מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 3:
                            kanji = " שלוש מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 4:
                            kanji = "  ארבע מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 5:
                            kanji = " חמש מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 6:
                            kanji = " שש מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 7:
                            kanji = " שבע מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 8:
                            kanji = " שמונה מיליארד" + " " + toKanji(N % 1000000000); break;
                        case 9:
                            kanji = " תשע מיליארד" + " " + toKanji(N % 1000000000); break;
                        default:
                            kanji = ""; break;
                    }
                    break;
                case 11:
                    switch (N / 10000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000) + " מיליארד";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000) + " מיליארד";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 12:
                    switch (N / 100000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000) + " מיליארד";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000) + " מיליארד";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 13:
                    switch (N / 1000000000000)
                    {
                        case 1:
                            kanji = " טריליון" + " " + toKanji(N % 1000000000000);
                            break;
                        case 2:
                            kanji = " שתי טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 3:
                            kanji = " שלוש טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 4:
                            kanji = "  ארבע טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 5:
                            kanji = " חמש טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 6:
                            kanji = " שש טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 7:
                            kanji = " שבע טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 8:
                            kanji = " שמונה טריליון" + " " + toKanji(N % 1000000000000); break;
                        case 9:
                            kanji = " תשע טריליון" + " " + toKanji(N % 1000000000000); break;
                        default:
                            kanji = ""; break;
                    }
                    break;
                case 14:
                    switch (N / 10000000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000000) + " טריליון";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000000) + " טריליון";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 15:
                    switch (N / 100000000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000000) + " טריליון";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000000) + " טריליון";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 16:
                    switch (N / 1000000000000000)
                    {
                        case 1:
                            kanji = " טריליארד" + " " + toKanji(N % 1000000000000000);
                            break;
                        case 2:
                            kanji = " שתי טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 3:
                            kanji = " שלוש טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 4:
                            kanji = "  ארבע טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 5:
                            kanji = " חמש טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 6:
                            kanji = " שש טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 7:
                            kanji = " שבע טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 8:
                            kanji = " שמונה טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        case 9:
                            kanji = " תשע טריליארד" + " " + toKanji(N % 1000000000000000); break;
                        default:
                            kanji = ""; break;
                    }
                    break;
                case 17:
                    switch (N / 10000000000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000000000) + " טריליארד";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000000000) + " טריליארד";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 18:
                    switch (N / 100000000000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000000000) + " טריליארד";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000000000) + " טריליארד";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                case 19:
                    switch (N / 1000000000000000000)
                    {
                        case 1:
                            kanji = " קוודריליון" + " " + toKanji(N % 1000000000000000000);
                            break;
                        case 2:
                            kanji = " שתי קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 3:
                            kanji = " שלוש קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 4:
                            kanji = "  ארבע קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 5:
                            kanji = " חמש קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 6:
                            kanji = " שש קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 7:
                            kanji = " שבע קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 8:
                            kanji = " שמונה קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        case 9:
                            kanji = " תשע קוודריליון" + " " + toKanji(N % 1000000000000000000); break;
                        default:
                            kanji = ""; break;
                    }
                    break;
                case 20:
                    switch (N / 10000000000000000000)
                    {
                        case 1:
                            string temp1 = toKanji(N / 1000000000000000000) + " קוודריליון";

                            temp1 = phoneReplace2(temp1);
                            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000000000));

                            kanji = temp1;
                            break;

                        default:
                            string temp2 = toKanji(N / 1000000000000000000) + " קוודריליון";

                            //temp2 = phoneReplace2(temp2);
                            temp2 += " " + phoneReplace(toKanji(N % 1000000000000000000));

                            kanji = temp2;
                            break;
                    }


                    break;
                //case 21: //ulong var too lacks power from here
                //    switch (N / 100000000000000000000)
                //    {
                //        case 1:
                //            string temp1 = toKanji(N / 1000000000000000000) + " קוודריליון";

                //            temp1 = phoneReplace2(temp1);
                //            temp1 += " " + phoneReplace2(toKanji(N % 1000000000000000000));

                //            kanji = temp1;
                //            break;

                //        default:
                //            string temp2 = toKanji(N / 1000000000000000000) + " קוודריליון";

                //            //temp2 = phoneReplace2(temp2);
                //            temp2 += " " + phoneReplace(toKanji(N % 1000000000000000000));

                //            kanji = temp2;
                //            break;
                //    }


                //    break;

            }
          
            
            return kanji;



        }
        private string toKanji2(ulong N)
        {
            string kanji;
            kanji = "enter a number";
            string characters = N.ToString();
            switch (characters.Length)
            {
                case 1:
                    switch (N)
                    {
                        case 1:
                            kanji = "ואחת";
                            break;
                        case 2:
                            kanji = "ושתיים"; break;
                        case 3:
                            kanji = "ושלוש"; break;
                        case 4:
                            kanji = "וארבע"; break;
                        case 5:
                            kanji = "וחמש"; break;
                        case 6:
                            kanji = "ושש"; break;
                        case 7:
                            kanji = "ושבע"; break;
                        case 8:
                            kanji = "ושמונה"; break;
                        case 9:
                            kanji = "ותשע"; break;
                        default:
                            kanji = ""; break;

                    }



                    break;
                case 2:
                    switch (N / 10)
                    {
                        case 1:
                            kanji = "עשר" + " " + toKanji2(N % 10);
                            break;
                        case 2:
                            kanji = "עשרים" + " " + toKanji2(N % 10); break;
                        case 3:
                            kanji = "שלושים" + " " + toKanji2(N % 10); break;
                        case 4:
                            kanji = "ארבעים" + " " + toKanji2(N % 10); break;
                        case 5:
                            kanji = "חמישים" + " " + toKanji2(N % 10); break;
                        case 6:
                            kanji = "שישים" + " " + toKanji2(N % 10); break;
                        case 7:
                            kanji = "שבעים" + " " + toKanji2(N % 10); break;
                        case 8:
                            kanji = "שמונים" + " " + toKanji2(N % 10); break;
                        case 9:
                            kanji = "תשעים" + " " + toKanji2(N % 10); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 3:
                    switch (N / 100)
                    {
                        case 1:
                            kanji = "מאה" + " " + toKanji2(N % 100);
                            break;
                        case 2:
                            kanji = "מאתיים" + " " + toKanji2(N % 100); break;
                        case 3:
                            kanji = "שלוש מאות" + " " + toKanji2(N % 100); break;
                        case 4:
                            kanji = "ארבע מאות" + " " + toKanji2(N % 100); break;
                        case 5:
                            kanji = "חמש מאות" + " " + toKanji2(N % 100); break;
                        case 6:
                            kanji = "שש מאות" + " " + toKanji2(N % 100); break;
                        case 7:
                            kanji = "שבע מאות" + " " + toKanji2(N % 100); break;
                        case 8:
                            kanji = "שמונה מאות" + " " + toKanji2(N % 100); break;
                        case 9:
                            kanji = "תשע מאות" + " " + toKanji2(N % 100); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 4:
                    switch (N / 1000)
                    {
                        case 1:
                            kanji = "אלף" + " " + toKanji2(N % 1000);
                            break;
                        case 2:
                            kanji = "אלפיים" + " " + toKanji2(N % 1000); break;
                        case 3:
                            kanji = "שלושת אלפים" + " " + toKanji2(N % 1000); break;
                        case 4:
                            kanji = "ארבעת אלפים" + " " + toKanji2(N % 1000); break;
                        case 5:
                            kanji = "חמשת אלפים" + " " + toKanji2(N % 1000); break;
                        case 6:
                            kanji = "ששת אלפים" + " " + toKanji2(N % 1000); break;
                        case 7:
                            kanji = "שבעת אלפים" + " " + toKanji2(N % 1000); break;
                        case 8:
                            kanji = "שמונת אלפים" + " " + toKanji2(N % 1000); break;
                        case 9:
                            kanji = "תשעת אלפים" + " " + toKanji2(N % 1000); break;
                        default:
                            kanji = toKanji2(N / 1000) + " אלף" + toKanji2(N % 1000); break;
                    }


                    break;
                    //case 5:
                    //    switch (N / 10000)
                    //    {
                    //        case 1:
                    //            kanji = "עשרת אלפים" + " " + toKanji(N % 10000);
                    //            break;
                    //        case 2:
                    //            kanji = "אחת עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 3:
                    //            kanji = "שתיים עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 4:
                    //            kanji = "שלוש עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 5:
                    //            kanji = "חמש עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 6:
                    //            kanji = "שש עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 7:
                    //            kanji = "שבע עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 8:
                    //            kanji = "שמונה עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        case 9:
                    //            kanji = "תשע עשרה אלף" + " " + toKanji(N % 10000); break;
                    //        default:
                    //            kanji = ""; break;
                    //    }


                    //    break;

            }
            
            return kanji;



        }
    }
}


hadouken

descriptionJS javascript convert number to words Emptyc# convert number to kanji countSun Oct 21, 2018 8:45 pm

more_horiz
code

Code:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;



namespace WindowsFormsApp1
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            MessageBox.Show(toKanji(1234567891234567));
        }
        private string toKanji(ulong N)
        {
            string kanji;
            kanji = "enter a number";
            string characters = N.ToString();
            switch (characters.Length)
            {
                case 1:
                    switch (N)
                    {
                        case 1:
                            kanji = "ichi";
                            break;
                        case 2:
                            kanji = "ni"; break;
                            case 3 :
                            kanji = "san"; break;
                            case 4 :
                              kanji = "yon"; break;
                        case 5:
                            kanji = "go";break;
                        case 6:
                            kanji = "roku"; break;
                        case 7:
                            kanji = "shichi";break;
                        case 8:
                            kanji = "hachi";break;
                        case 9:
                            kanji = "kyuu";break;
                        default:
                            kanji = "";break;

                    }

               

                    break;
                case 2:
                    switch (N / 10) {
                        case 1:
                            kanji = "ju" + " " + toKanji(N % 10);
                            break;
                        case 2:
                            kanji = "ni-ju" + " " + toKanji(N % 10); break;
                        case 3:
                            kanji = "san-ju" + " " + toKanji(N % 10); break;
                        case 4:
                            kanji = "yon-ju" + " " + toKanji(N % 10); break;
                        case 5:
                            kanji = "go-ju" + " " + toKanji(N % 10); break;
                        case 6:
                            kanji = "roku-ju" + " " + toKanji(N % 10); break;
                        case 7:
                            kanji = "nana-ju" + " " + toKanji(N % 10); break;
                        case 8:
                            kanji = "hachi-ju" + " " + toKanji(N % 10); break;
                        case 9:
                            kanji = "kyu-ju" + " " + toKanji(N % 10); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 3:
                    switch (N / 100)
                    {
                        case 1:
                            kanji = "hyaku" + " " + toKanji(N % 100);
                            break;
                        case 2:
                            kanji = "ni-hyaku" + " " + toKanji(N % 100); break;
                        case 3:
                            kanji = "sanbyaku" + " " + toKanji(N % 100); break;
                        case 4:
                            kanji = "yon-hyaku" + " " + toKanji(N % 100); break;
                        case 5:
                            kanji = "go-hyaku" + " " + toKanji(N % 100); break;
                        case 6:
                            kanji = "roppyaku" + " " + toKanji(N % 100); break;
                        case 7:
                            kanji = "nana-hyaku" + " " + toKanji(N % 100); break;
                        case 8:
                            kanji = "happyaku" + " " + toKanji(N % 100); break;
                        case 9:
                            kanji = "kyu-hyaku" + " " + toKanji(N % 100); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 4:
                    switch (N / 1000)
                    {
                        case 1:
                            kanji = "sen" + " " + toKanji(N % 1000);
                            break;
                        case 2:
                            kanji = "ni-sen" + " " + toKanji(N % 1000); break;
                        case 3:
                            kanji = "san-zen" + " " + toKanji(N % 1000); break;
                        case 4:
                            kanji = "yon-sen" + " " + toKanji(N % 1000); break;
                        case 5:
                            kanji = "go-sen" + " " + toKanji(N % 1000); break;
                        case 6:
                            kanji = "roku-sen" + " " + toKanji(N % 1000); break;
                        case 7:
                            kanji = "nana-sen" + " " + toKanji(N % 1000); break;
                        case 8:
                            kanji = "hassen" + " " + toKanji(N % 1000); break;
                        case 9:
                            kanji = "kyu-sen" + " " + toKanji(N % 1000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 5:
                    switch (N / 10000)
                    {
                        case 1:
                            kanji = "ichi-man" + " " + toKanji(N % 10000);
                            break;
                        case 2:
                            kanji = "ni-man" + " " + toKanji(N % 10000); break;
                        case 3:
                            kanji = "san-man" + " " + toKanji(N % 10000); break;
                        case 4:
                            kanji = "yon-man" + " " + toKanji(N % 10000); break;
                        case 5:
                            kanji = "go-man" + " " + toKanji(N % 10000); break;
                        case 6:
                            kanji = "roku-man" + " " + toKanji(N % 10000); break;
                        case 7:
                            kanji = "nana-man" + " " + toKanji(N % 10000); break;
                        case 8:
                            kanji = "hachi-man" + " " + toKanji(N % 10000); break;
                        case 9:
                            kanji = "kyu-man" + " " + toKanji(N % 10000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 6:
                    switch (N / 100000)
                    {
                        case 1:
                            kanji = "ju" + " " + toKanji(N % 100000);
                            break;
                        case 2:
                            kanji = "ni-ju" + " " + toKanji(N % 100000); break;
                        case 3:
                            kanji = "san-ju" + " " + toKanji(N % 100000); break;
                        case 4:
                            kanji = "yon-ju" + " " + toKanji(N % 100000); break;
                        case 5:
                            kanji = "go-ju" + " " + toKanji(N % 100000); break;
                        case 6:
                            kanji = "roku-ju" + " " + toKanji(N % 100000); break;
                        case 7:
                            kanji = "nana-ju" + " " + toKanji(N % 100000); break;
                        case 8:
                            kanji = "hachi-ju" + " " + toKanji(N % 100000); break;
                        case 9:
                            kanji = "kyu-ju" + " " + toKanji(N % 100000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 7:
                    switch (N / 1000000)
                    {
                        case 1:
                            kanji = "hyaku" + " " + toKanji(N % 1000000);
                            break;
                        case 2:
                            kanji = "ni-hyaku" + " " + toKanji(N % 1000000); break;
                        case 3:
                            kanji = "sanbyaku" + " " + toKanji(N % 1000000); break;
                        case 4:
                            kanji = "yon-hyaku" + " " + toKanji(N % 1000000); break;
                        case 5:
                            kanji = "go-hyaku" + " " + toKanji(N % 1000000); break;
                        case 6:
                            kanji = "roku-hyaku" + " " + toKanji(N % 1000000); break;
                        case 7:
                            kanji = "nana-hyaku" + " " + toKanji(N % 1000000); break;
                        case 8:
                            kanji = "happyaku" + " " + toKanji(N % 1000000); break;
                        case 9:
                            kanji = "kyu-hyaku" + " " + toKanji(N % 1000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 8:
                    switch (N / 10000000)
                    {
                        case 1:
                            kanji = "sen" + " " + toKanji(N % 10000000); break;
                        case 2:
                            kanji = "ni-sen" + " " + toKanji(N % 10000000); break;
                        case 3:
                            kanji = "sanzen" + " " + toKanji(N % 10000000); break;
                        case 4:
                            kanji = "yon-sen" + " " + toKanji(N % 10000000); break;
                        case 5:
                            kanji = "go-sen" + " " + toKanji(N % 10000000); break;
                        case 6:
                            kanji = "roku-sen" + " " + toKanji(N % 10000000); break;
                        case 7:
                            kanji = "nana-sen" + " " + toKanji(N % 10000000); break;
                        case 8:
                            kanji = "hachi-sen" + " " + toKanji(N % 10000000); break;
                        case 9:
                            kanji = "kyu-sen" + " " + toKanji(N % 10000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 9:
                    switch (N / 100000000)
                    {
                        case 1:
                            kanji = "ichi-oku" + " " + toKanji(N % 100000000); break;
                        case 2:
                            kanji = "ni-oku" + " " + toKanji(N % 100000000); break;
                        case 3:
                            kanji = "sanzen" + " " + toKanji(N % 100000000); break;
                        case 4:
                            kanji = "yon-oku" + " " + toKanji(N % 100000000); break;
                        case 5:
                            kanji = "go-oku" + " " + toKanji(N % 100000000); break;
                        case 6:
                            kanji = "roku-oku" + " " + toKanji(N % 100000000); break;
                        case 7:
                            kanji = "nana-oku" + " " + toKanji(N % 100000000); break;
                        case 8:
                            kanji = "hachi-oku" + " " + toKanji(N % 100000000); break;
                        case 9:
                            kanji = "kyu-oku" + " " + toKanji(N % 100000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 10:
                    switch (N / 1000000000)
                    {
                        case 1:
                            kanji = "ju" + " " + toKanji(N % 1000000000); break;
                        case 2:
                            kanji = "ni-ju" + " " + toKanji(N % 1000000000); break;
                        case 3:
                            kanji = "san-ju" + " " + toKanji(N % 1000000000); break;
                        case 4:
                            kanji = "yon-ju" + " " + toKanji(N % 1000000000); break;
                        case 5:
                            kanji = "go-ju" + " " + toKanji(N % 1000000000); break;
                        case 6:
                            kanji = "roku-ju" + " " + toKanji(N % 1000000000); break;
                        case 7:
                            kanji = "nana-ju" + " " + toKanji(N % 1000000000); break;
                        case 8:
                            kanji = "hachi-ju" + " " + toKanji(N % 1000000000); break;
                        case 9:
                            kanji = "kyu-ju" + " " + toKanji(N % 1000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 11:
                    switch (N / 10000000000)
                    {
                        case 1:
                            kanji = "hyaku" + " " + toKanji(N % 10000000000); break;
                        case 2:
                            kanji = "ni-hyaku" + " " + toKanji(N % 10000000000); break;
                        case 3:
                            kanji = "sanbyaku" + " " + toKanji(N % 10000000000); break;
                        case 4:
                            kanji = "yon-hyaku" + " " + toKanji(N % 10000000000); break;
                        case 5:
                            kanji = "go-hyaku" + " " + toKanji(N % 10000000000); break;
                        case 6:
                            kanji = "roku-hyaku" + " " + toKanji(N % 10000000000); break;
                        case 7:
                            kanji = "nana-hyaku" + " " + toKanji(N % 10000000000); break;
                        case 8:
                            kanji = "happyaku" + " " + toKanji(N % 10000000000); break;
                        case 9:
                            kanji = "kyu-hyaku" + " " + toKanji(N % 10000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 12:
                    switch (N / 100000000000)
                    {
                        case 1:
                            kanji = "sen" + " " + toKanji(N % 100000000000); break;
                        case 2:
                            kanji = "ni-sen" + " " + toKanji(N % 100000000000); break;
                        case 3:
                            kanji = "sanzen" + " " + toKanji(N % 100000000000); break;
                        case 4:
                            kanji = "yon-sen" + " " + toKanji(N % 100000000000); break;
                        case 5:
                            kanji = "go-sen" + " " + toKanji(N % 100000000000); break;
                        case 6:
                            kanji = "roku-sen" + " " + toKanji(N % 100000000000); break;
                        case 7:
                            kanji = "nana-sen" + " " + toKanji(N % 100000000000); break;
                        case 8:
                            kanji = "hassen" + " " + toKanji(N % 100000000000); break;
                        case 9:
                            kanji = "kyu-sen" + " " + toKanji(N % 100000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 13:
                    switch (N / 1000000000000)
                    {
                        case 1:
                            kanji = "itcho" + " " + toKanji(N % 1000000000000); break;
                        case 2:
                            kanji = "ni-cho" + " " + toKanji(N % 1000000000000); break;
                        case 3:
                            kanji = "san-cho" + " " + toKanji(N % 1000000000000); break;
                        case 4:
                            kanji = "yon-cho" + " " + toKanji(N % 1000000000000); break;
                        case 5:
                            kanji = "go-cho" + " " + toKanji(N % 1000000000000); break;
                        case 6:
                            kanji = "roku-cho" + " " + toKanji(N % 1000000000000); break;
                        case 7:
                            kanji = "nana-cho" + " " + toKanji(N % 1000000000000); break;
                        case 8:
                            kanji = "hatcho" + " " + toKanji(N % 1000000000000); break;
                        case 9:
                            kanji = "kyu-cho" + " " + toKanji(N % 1000000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 14:
                    switch (N / 10000000000000)
                    {
                        case 1:
                            kanji = "ju" + " " + toKanji(N % 10000000000000); break;
                        case 2:
                            kanji = "ni-ju" + " " + toKanji(N % 10000000000000); break;
                        case 3:
                            kanji = "san-ju" + " " + toKanji(N % 10000000000000); break;
                        case 4:
                            kanji = "yon-ju" + " " + toKanji(N % 10000000000000); break;
                        case 5:
                            kanji = "go-ju" + " " + toKanji(N % 10000000000000); break;
                        case 6:
                            kanji = "roku-ju" + " " + toKanji(N % 10000000000000); break;
                        case 7:
                            kanji = "nana-ju" + " " + toKanji(N % 10000000000000); break;
                        case 8:
                            kanji = "hachi-ju" + " " + toKanji(N % 10000000000000); break;
                        case 9:
                            kanji = "kyu-ju" + " " + toKanji(N % 10000000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 15:
                    switch (N / 100000000000000)
                    {
                        case 1:
                            kanji = "hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 2:
                            kanji = "ni-hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 3:
                            kanji = "sanbyaku" + " " + toKanji(N % 100000000000000); break;
                        case 4:
                            kanji = "yon-hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 5:
                            kanji = "go-hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 6:
                            kanji = "roku-hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 7:
                            kanji = "nana-hyaku" + " " + toKanji(N % 100000000000000); break;
                        case 8:
                            kanji = "happyaku" + " " + toKanji(N % 100000000000000); break;
                        case 9:
                            kanji = "kyu-hyaku" + " " + toKanji(N % 100000000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
                case 16:
                    switch (N / 1000000000000000)
                    {
                        case 1:
                            kanji = "sen" + " " + toKanji(N % 1000000000000000); break;
                        case 2:
                            kanji = "ni-sen" + " " + toKanji(N % 1000000000000000); break;
                        case 3:
                            kanji = "sanzen" + " " + toKanji(N % 1000000000000000); break;
                        case 4:
                            kanji = "yon-sen" + " " + toKanji(N % 1000000000000000); break;
                        case 5:
                            kanji = "go-sen" + " " + toKanji(N % 1000000000000000); break;
                        case 6:
                            kanji = "roku-sen" + " " + toKanji(N % 1000000000000000); break;
                        case 7:
                            kanji = "nana-sen" + " " + toKanji(N % 1000000000000000); break;
                        case 8:
                            kanji = "hassen" + " " + toKanji(N % 1000000000000000); break;
                        case 9:
                            kanji = "kyu-sen" + " " + toKanji(N % 1000000000000000); break;
                        default:
                            kanji = ""; break;
                    }


                    break;
            }
            return kanji;
           

       
        }

    }

}




hadouken

descriptionJS javascript convert number to words EmptyRe: JS javascript convert number to wordsWed Jun 21, 2023 7:40 pm

more_horiz

Code:

package AXJava;

import java.math.BigInteger;

public class NumToWord {
    private String convert(int n){
        String result = "enter a number";
        String nStr = n +"";
        switch(nStr.length()){
            case 1:
                switch(n){
                    case 1: result = "one";break;
                    case 2:result="two";break;
                    case 3:result="three";break;
                    case 4:result="four";break;
                    case 5:result="five";break;
                    case 6:result="six";break;
                    case 7:result="seven";break;
                    case 8:result="eight";break;
                    case 9:result="nine";break;
                    default: result = "";break;
                }break;
            case 2:
                switch (n/10){
                    case 1:
                        result = "ten" + " " +  convert(n % 10);
                        break;
                    case 2:
                        result = "twenty" + " " +  convert(n % 10); break;
                    case 3:
                        result = "thirty" + " " +  convert(n % 10); break;
                    case 4:
                        result = "forty" + " " +  convert(n % 10); break;
                    case 5:
                        result = "fifty" + " " +  convert(n % 10); break;
                    case 6:
                        result = "Sixty" + " " +  convert(n % 10); break;
                    case 7:
                        result = "seventy" + " " +  convert(n % 10); break;
                    case 8:
                        result = "eighty" + " " +  convert(n % 10); break;
                    case 9:
                        result = "ninety" + " " +  convert(n % 10); break;
                    default:
                        result = ""; break;
                }break;
            case 3:
                switch (n / 100)
                {
                    case 1:
                        result = "one hundred" + " " + convert(n % 100);
                        break;
                    case 2:
                        result = "two hundred" + " " + convert(n % 100); break;
                    case 3:
                        result = "three hundred" + " " + convert(n % 100); break;
                    case 4:
                        result = "four hundred" + " " + convert(n % 100); break;
                    case 5:
                        result = "five hundred" + " " + convert(n % 100); break;
                    case 6:
                        result = "six hundred" + " " + convert(n % 100); break;
                    case 7:
                        result = "seven hundred" + " " + convert(n % 100); break;
                    case 8:
                        result = "eight hundred" + " " + convert(n % 100); break;
                    case 9:
                        result = "nine hundred" + " " + convert(n % 100); break;
                    default:
                        result = ""; break;
                }
                break;
            case 4:
                switch (n / 1000){
                    case 1:
                        result = "one Thousand" + " " + convert(n % 1000);
                        break;
                    case 2:
                        result = "two Thousand" + " " + convert(n % 1000); break;
                    case 3:
                        result = "three Thousand" + " " + convert(n % 1000); break;
                    case 4:
                        result = "four Thousand" + " " + convert(n % 1000); break;
                    case 5:
                        result = "five Thousand" + " " + convert(n % 1000); break;
                    case 6:
                        result = "six Thousand" + " " + convert(n % 1000); break;
                    case 7:
                        result = "seven Thousand" + " " + convert(n % 1000); break;
                    case 8:
                        result = "eight Thousand" + " " + convert(n % 1000); break;
                    case 9:
                        result = "nine Thousand" + " " + convert(n % 1000); break;
                    default:
                        result = ""; break;
                }
                break;
            case 5:
                String temp1 = convert(n/1000) + " thousand"; temp1 = temp1 + " " + convert(n% 1000);
                result = temp1;
                break;
            case 6:
                String temp2 = convert(n/1000)+ " thousand";
                temp2 = temp2 + " " + convert(n% 1000);
                result = temp2;
                break;
            case 7:
                switch (n / 1000000)
                {
                    case 1:
                        result = "one million" + " " + convert(n % 1000000);
                        break;
                    case 2:
                        result = "two million" + " " + convert(n % 1000000); break;
                    case 3:
                        result = "three million" + " " + convert(n % 1000000); break;
                    case 4:
                        result = "four million" + " " + convert(n % 1000000); break;
                    case 5:
                        result = "five million" + " " + convert(n % 1000000); break;
                    case 6:
                        result = "six million" + " " + convert(n % 1000000); break;
                    case 7:
                        result = "seven million" + " " + convert(n % 1000000); break;
                    case 8:
                        result = "eight million" + " " + convert(n % 1000000); break;
                    case 9:
                        result = "nine million" + " " + convert(n % 1000000); break;
                    default:
                        result = ""; break;
                }
                break;
            }
        return result;
    }
    private String repairText(String n){
        String res = n;

        res = res.replace("ten one", "eleven");

        res = res.replace("ten two", "twelve");

        res = res.replace("ten one", "thirteen");

        res = res.replace("ten one", "fourteen");

        res = res.replace("ten one", "fifteen");

        res = res.replace("ten one", "sixteen");

        res = res.replace("ten one", "seventeen");

        res = res.replace("ten one", "eighteen");

        res = res.replace("ten one", "nineteen");

        return res;
    }
    public String wordification(int n){
        String result = convert(n);
        result = repairText(result);
        return result;
    }
}
privacy_tip Permissions in this forum:
You cannot reply to topics in this forum
power_settings_newLogin to reply