battle programming a forum for elite programmers with extreme will power to sharpen theire skills
 
HomeSearchRegisterLog in
Share
 

 JS javascript convert number to words

Go down 
AuthorMessage
Moti Barski
super
super
Moti Barski

Posts : 395
Join date : 2011-08-02

JS javascript convert number to words Empty
PostSubject: JS javascript convert number to words   JS javascript convert number to words EmptyWed Dec 06, 2017 1:23 pm

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

_________________
MB over and out emp it up
Back to top Go down
Moti Barski
super
super
Moti Barski

Posts : 395
Join date : 2011-08-02

JS javascript convert number to words Empty
PostSubject: convert number to words vb.net   JS javascript convert number to words EmptyMon Oct 08, 2018 6:42 am

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:

_________________
MB over and out emp it up
Back to top Go down
Moti Barski
super
super
Moti Barski

Posts : 395
Join date : 2011-08-02

JS javascript convert number to words Empty
PostSubject: java convert number to hebrew words   JS javascript convert number to words EmptySun Oct 21, 2018 8:44 pm

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

_________________
MB over and out emp it up
Back to top Go down
Moti Barski
super
super
Moti Barski

Posts : 395
Join date : 2011-08-02

JS javascript convert number to words Empty
PostSubject: c# convert number to kanji count   JS javascript convert number to words EmptySun Oct 21, 2018 8:45 pm

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

_________________
MB over and out emp it up
Back to top Go down
 
JS javascript convert number to words
Back to top 
Page 1 of 1

Permissions in this forum:You cannot reply to topics in this forum
battle programmers alliance :: battle programming alliance :: battle programming-
Jump to: