battle programmers alliance

battle programminga forum for elite programmerswith extreme will powerto sharpen theire skills
 
HomeCalendarFAQSearchMemberlistUsergroupsRegisterLog in
Search
 
 

Display results as :
 
Rechercher Advanced Search
Latest topics
» vb.net convert array to xy coodinates
Fri Dec 08, 2017 2:18 pm by Admin

» JS javascript convert number to words
Wed Dec 06, 2017 1:23 pm by Moti Barski

» JS pascal triangle question
Mon Dec 04, 2017 9:54 am by Admin

» youtube emojis
Mon Dec 04, 2017 12:14 am by Admin

» vb.net pascal triangle
Sat Dec 02, 2017 10:10 am by Moti Barski

» puzzles at various levels
Sat Dec 02, 2017 8:06 am by Admin

» primitive tech
Fri Dec 01, 2017 8:02 pm by Admin

» course templets
Thu Nov 30, 2017 10:14 am by Moti Barski

» vb.net check if two rectangles overlap
Fri Nov 24, 2017 7:36 pm by Moti Barski

December 2017
SunMonTueWedThuFriSat
     12
3456789
10111213141516
17181920212223
24252627282930
31      
CalendarCalendar
Social bookmarking
Social bookmarking digg  Social bookmarking delicious  Social bookmarking reddit  Social bookmarking stumbleupon  Social bookmarking slashdot  Social bookmarking yahoo  Social bookmarking google  Social bookmarking blogmarks  Social bookmarking live      

Bookmark and share the address of battle programmers alliance on your social bookmarking website
Share | 
 

 visual studio c# fast tutorial

View previous topic View next topic Go down 
AuthorMessage
Moti Barski

avatar

Posts : 102
Join date : 2011-08-02

PostSubject: visual studio c# fast tutorial   Sat Apr 08, 2017 2:12 pm

this tutorial is
assuming you read the vb.net walkthroughs of the book battle programming :

DL visual studio latest version

c# jutsu :

1 hello world console app :
file, new project, from tree view select visual c#, windows desktop, console application
the code placed in the main methode will be run :
type cw tab tab
Console.WriteLine("hello world");
Console.ReadKey();
// comment
press f5 to debug (run the program)
right click the now visible promt window, properties to change the font and stuff
shift + f5 : stop debugging
ctrl + f5 run without debugging , causes the app to pause
before closing

2 wpf
file, new project, from tree view select visual c#, windows desktop, WPF application
(similar to a win form, but looks more expensive) notice in the solution window the .cs file
is were you code cs = c# sharp

3 obj = null; //obj will be garbage collectet

4 namespace contain classes and are defined by code.
system.math // system = namespace, math = class
using Sytem.Math;

double pi = math.PI; // a field
double rounded = math.Round(pi, 2); // a methode
// static methode : used by the class without neccesarily using a created variable of the class type

6 import statements in vb tranlates to using

7 declaring variables :
int N = 0;
int yii = new int32(); // default 0
short n3 = -32768; // min -32768 max 32767
ushort n4 = 33767; // min 0 max 32767
uint n5 = 4;
const int N = 50;
object o1 = new Object();
string s1 = "hello"; // s1[1] contains 'e'
System.String s1 = "hello";
var implicitValue = 98; // set to int32
var implicitValue = 98L; // set to int 64
bool defaultBool = new boolean(); // false value
const int SomeNum = 42;
public const int SomeNum = 42; // available to the whole application as a class member

byte bul = 255;
bul++ // adds 1 therefore set to 0

char c1 = 'a';
char c2 = '\u0061'; // sets c2 to a
char.IsLetterOrDigit(('#')); // returns false

Datetime dt = new DateTime(1955, 1, 1);
Console.WriteLine("the date is: " + dt.ToString("M/d/yyyy")); // mask
Console.ReadKey();
Console.WriteLine("the date is: " + dt.ToString("MMMM d, yyyy")); // mask2
Console.ReadKey();

Datetime now = DateTime.Now;


8 multifunction summon example:
using System.text;

StringBuilder builder = new StringBuilder(); // more efficient string user
builder.Append("hello")
.Append(" ")
.Append("world");

9 comment out code : mark select code, edit, advanced, comment selection

10 opperators :
+,-,*,/ divide,% reminder
++,-- add, decrease by 1 : intvalue++;
+=, -= add, decrease from value : value += 5;
Equality (boolean) operators :
== equals x == y, != not equals, ! negation (not) : !x x is boolean variable
conditional operators :
&& and, || or, ?? null-coalescing : int new = (x ?? var2); returns x if
it has some value else return var2
relational and type testing :
<,>,<=,>=, is : type compatible : if (x is String)
Non-Case-Sensitive comparison :
if (string1.Equals(string2,StringComparison.OrdianlIgnoreCase))
{
}

11 refactor :
right click a marked variable , refactor, applies the change all over the code

12 conditionals
if true
{
}
else if (true)
{}
else
{
}

select case :
switch (variable)
{
case "+" ;
// code for case
break;
default; // case else
break;
}

13 full screen editor :
alt + shift + enter

14 looping

type for tab twice
for (int i = 0; i < length; i++)
{

}

while boolVariable
{
Console.WriteLine("lup");
}

for each loop snipet sample :
string[] fruit = {"apples", "oranges", "grapes"};
foreach (var item in fruit) // fruit is a collection variable
{
Console.WriteLine(item);
}

15 methodes :
static int Add(int value1, int value2) // static mean you can use it without
// an instace object of the class, see static summon
{
return value1 + value2;
}
static summon example :
int total = add(10, 30);

static void addToOut param(int value1,int value2, out int result) // void
// means the methode returns nothing, out is like vb.net byref
{
result = value1 + value2;
}

access identifier :
static int localField = 10; // var is accesable by the class
static public localField = 10; // var is accesable by everybody
static private localField = 10; // var is accesable only to the class

16 break; // jump out of code block (like a for loop)
continue; // go from here to the start of this code block

17 comment out marked code block : ctrl + k, then ctrl + c
comment in : ctrl + k, ctrl + u

18 go to methode's code, be on methode call code line , f12

19A debug tricks :
above problematic value type :
Debug.WriteLine("value of var1 :" + var1);
run in debug mode shift + f5
press ctrl + alt + o
to see an output window of said variable.

B make a breakpoint conditional :
in the output window breakpoint (now targeting your selected
breakpoint, right click, condition, type : var1==3 (for example)

C wrapping the code
try {} // code hya
catch (Exception)
{
//throw;
}

or
catch (Exception ex)
{Console.WriteLine(ex.message);}
finally{} // place code to run anyways after the final catch

20 array
sring[] fruit = { "apples" ," "oranges", "bananas" };

string[] names = new string[3];
names[0] = "naruto";
names[1] = "sasuke";
names[2] = "kabuto";

int[] weights = { 12, 34, 20, 23}
int sum = weights.sum();

string[,] grid = new string[5,5]; //2d array

21 List

var fruitList = new list<string>();
fruit
list.add("orange");

fruitList.sort();
foreach (var item in fruitList)
{
console.writeline(item);
}


static void Figs(list<string> items)
{
string figReport = iteems.contains("fig", stringcomparer.OrdinalIgnoreCase) ?
"yes there are":
"none";
console.writeLine(figReport);
}

22 DICTIONARY

var inventory = new Dictionary<string,double>();
var keys = inventory.keys; //behaves as list
console.WriteLine(keys.count);
foreach (var key in keys)
{
console.writeLine(inventory[key]); //value in dictionary assosiated to the key
}

string[] keysArray = keys.ToArray();
Array.sort(keysArray);
foreach (var key in keysArray)
{
console.writeLine(inventory[key]);
}

if (inventory.TryGetValue("figs", out value))
{
console.writeLine(value);
}
else
{
console.writeLine("figs not in inventory");
}

23 classes :
right click solution, add class

shared function addy(byval y as integer, ByVal x As integer) As Decimal
return x + y
End Function ' in vb.net =

public static decimal addy(int y, int x)
{
return x + y;
} ' in c#

calling the function from the main class :
className.addy(1,3);


class fruit
{
public string name; // right click var name, refactor, encapsulate field, apply :
}
turns to :

class fruit
{
private string name;
public string name
{
get { return name; }
set { name = value; }
}
}
another way :
public int Quantity { get; set; }
in the main class :
var fruit1 = new fruit();
fruit1.name = "guyava";

object in list reference :
var produce = new List<object>();
produce.Add(new fruit());
((fruit)produce[1]).name = "melon

override methode example :
public override string Tostring()
{return name + "bla bla";}

24 namespace :
wrap your added classes with
namespace namehere
{}
in your main code add using namehere; at the very start
or call classname.methodename() mark it and click ctrl + .

25 inheritance :
class name : motherclass {
public name (string name1, double weight) :
base(name1,weight) ' uses base class constructor
}

c# Special codes

1 new line :
Environment.NewLine

2 returning code to standard appearance : control + k , control + d
3 string + char : concates them

Back to top Go down
View user profile
Moti Barski

avatar

Posts : 102
Join date : 2011-08-02

PostSubject: C# visual studio convert number to words hebrew counter (literal number)   Sun Nov 19, 2017 10:06 pm

kado hatsudo ! nubaz 39 kibou !

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;



        }
    }
}


Twisted Evil
Back to top Go down
View user profile
Moti Barski

avatar

Posts : 102
Join date : 2011-08-02

PostSubject: count with words in japanese   Sun Nov 19, 2017 10:17 pm

Nihongo made ??!
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;
           

       
        }

    }

}


Back to top Go down
View user profile
 
visual studio c# fast tutorial
View previous topic View next topic Back to top 
Page 1 of 1
 Similar topics
-
» Setting Up Webdriver in Visual Studio
» making a selenium framework in eclipse(java environment). previously used visual studio.
» c# webdriver - Data Driven : DataSource attribute error - Connecting Automation with MTM
» Visual aura seems to be repeating over and over...this is new!
» Yet another new visual aura

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