예제 #1
0
        private void hundredsToOrdinal(int hundreds)
        {
            switch (hundreds)
            {
            case 0:
                break;

            case 1:
                result = "сто ";
                break;

            case 2:
                result = Ordinal.getOnes(hundreds) + "істі ";
                break;

            case 3:
                result = Ordinal.getOnes(hundreds) + "ста ";
                break;

            case 4:
                result = Ordinal.getOnes(hundreds) + "ста ";
                break;

            default:
                result = Ordinal.getOnes(hundreds) + "сот ";
                break;
            }
        }
예제 #2
0
        private void tensToOrdinal(int tens)
        {
            result += Ordinal.getTens(tens);
            switch (tens)
            {
            case 1:
                break;

            case 2:
                result += "ь ";
                break;

            case 3:
                result += "ь ";
                break;

            case 9:
                result += "о ";
                break;

            default:
                result += " ";
                break;
            }
        }
예제 #3
0
        private void onesToOrdinal(int tens)
        {
            switch (tens != 8 && tens != 7)
            {
            case true:
                result += Ordinal.getOnes(tens) + "ь ";
                break;

            case false:
                result += Ordinal.getOnes(tens);
                break;
            }
        }
예제 #4
0
        private string checkOnes(int tens)
        {
            switch (tens)
            {
            case 0:
                return("");

            case 8:
                return(Ordinal.getOnes(tens) + "t ");    // eigh - t - th

            case 9:
                return(result = Ordinal.getOnes(tens) + "e");    // nin - e - th

            default:
                return(result = Ordinal.getOnes(tens));
            }
        }
예제 #5
0
        private string checkOnes(int tens)
        {
            switch (tens)
            {
            case 0:
                return("");

            case 7:
                return(Ordinal.getOnes(tens) + "en");    // Sieb - en -  te

            case 8:
                return(result = Ordinal.getOnes(tens) + "t");    // Ach - t - te

            default:
                return(result = Ordinal.getOnes(tens));
            }
        }
예제 #6
0
        private void onesInLastThousandsToOrdinal(int tens) // для числівників, що закінчуються на "тисячний, мільйонний, мільярдний, трильйонний"
        {
            switch (tens)
            {
            case 0:
                break;

            case 1:
                result += Ordinal.getOnes(tens) + "но";
                break;

            case 2:
                result += Ordinal.getOnes(tens) + "ох";
                break;

            case 3:
                result += "трьох";
                break;

            case 4:
                result += "чотирьох";
                break;

            case 6:
                result += "шести";
                break;

            case 7:
                result += "семи";
                break;

            case 8:
                result += "восьми";
                break;

            default:
                result += Ordinal.getOnes(tens) + "и";
                break;
            }
        }
예제 #7
0
        private void onesInLastHundredToOrdinal(int tens) // для сотні
        {
            switch (tens)
            {
            case 1:
                result += Ordinal.getLastOnes(tens);
                break;

            case 2:
                result += Ordinal.getLastOnes(tens);
                break;

            case 3:
                result += Ordinal.getLastOnes(tens);
                break;

            case 4:
                result += Ordinal.getLastOnes(tens);
                break;

            case 6:
                result += "шостий";
                break;

            case 7:
                result += "сьомий";
                break;

            case 8:
                result += "восьмий";
                break;

            default:
                result += Ordinal.getOnes(tens) + "ий";
                break;
            }
        }
예제 #8
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))
            {
            case true:
                switch (classOfNumber == 0)
                {
                case true:
                    lastHundred(hundreds, tens);
                    break;

                case false:
                    switch (classOfNumber == Number.getLastClass())
                    {
                    case true:             // якщо клас числа є останнім (Складні порядові числівники, що закінчуються на "тисячний, мільйонний, мільярдний, трильйонний" пишуться разом та всі частини відмінюються)
                        switch (hundreds)
                        {
                        case 0:
                            break;

                        case 1:
                            result += "ста";
                            break;

                        default:
                            onesInLastThousandsToOrdinal(hundreds);
                            result += "сот";
                            break;
                        }
                        switch (tens > 19)
                        {
                        case true:
                            switch (tens / 10)
                            {
                            case 4:
                                result += Ordinal.getTens(tens / 10) + "а";
                                break;

                            case 9:
                                result += Ordinal.getTens(tens / 10) + "о";
                                break;

                            default:
                                result += Ordinal.getTens(tens / 10) + "и";
                                break;
                            }
                            onesInLastThousandsToOrdinal(tens % 10);                 // винесено у метод для уникнення повторення
                            break;

                        case false:
                            switch (tens)
                            {
                            case 1:
                                break;

                            default:
                                onesInLastThousandsToOrdinal(tens);                     // винесено у метод для уникнення повторення
                                break;
                            }
                            break;
                        }
                        result += Ordinal.getClassName(classOfNumber) + "ний";
                        break;

                    case false:             // Не останній класс числа
                        hundredsToOrdinal(hundreds);
                        tensToOrdinal(tens / 10);
                        switch (classOfNumber)             // для корректного роду числівників
                        {
                        case 1:
                            switch (tens > 19 || tens < 4)
                            {
                            case true:                     // одна тисяча, дві-три-чотири тисячі... тисяч
                                switch (tens % 10)
                                {
                                case 1:
                                    result += Ordinal.getOnes(tens % 10) + "нa " + Ordinal.getClassName(classOfNumber) + "а ";
                                    break;

                                case 2:
                                    result += Ordinal.getOnes(tens % 10) + "і " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                case 3:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                case 4:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "і ";
                                    break;

                                default:
                                    onesToOrdinal(tens % 10);
                                    result += " " + Ordinal.getClassName(classOfNumber) + " ";
                                    break;
                                }
                                break;

                            case false:
                                onesToOrdinal(tens);
                                result += Ordinal.getClassName(classOfNumber) + " ";
                                break;
                            }
                            break;

                        default:
                            switch (tens > 19 || tens < 4)
                            {
                            case true:                     // один мільйон-мільярд... і тд. два мільйони-мільярди...
                                switch (tens % 10)
                                {
                                case 1:
                                    result += Ordinal.getOnes(tens % 10) + "ин " + Ordinal.getClassName(classOfNumber) + " ";
                                    break;

                                case 2:
                                    result += Ordinal.getOnes(tens % 10) + "а " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                case 3:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                case 4:
                                    result += Ordinal.getOnes(tens % 10) + " " + Ordinal.getClassName(classOfNumber) + "и ";
                                    break;

                                default:
                                    onesToOrdinal(tens % 10);
                                    result += Ordinal.getClassName(classOfNumber) + "ів ";
                                    break;
                                }
                                break;

                            case false:
                                onesToOrdinal(tens);
                                result += Ordinal.getClassName(classOfNumber) + "iв ";
                                break;
                            }
                            break;
                        }
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }
예제 #9
0
        private string lastHundred(int hundreds, int tens) // сотня
        {
            switch (tens == 0)
            {
            case true:
                switch (hundreds)
                {
                case 1:
                    result = "сотий";
                    break;

                default:
                    onesInLastThousandsToOrdinal(hundreds);
                    result += "сотий";
                    break;
                }
                break;

            case false:
                hundredsToOrdinal(hundreds);
                switch (tens > 19)
                {
                case true:
                    switch (tens % 10 == 0)
                    {
                    case true:
                        result += Ordinal.getTens(tens / 10);
                        switch (tens / 10)
                        {
                        case 2:
                            result += "ий";
                            break;

                        case 3:
                            result += "тий";
                            break;

                        case 4:
                            result += "овий";
                            break;

                        default:
                            result += "ий";
                            break;
                        }
                        break;

                    case false:
                        tensToOrdinal(tens / 10);
                        onesInLastHundredToOrdinal(tens % 10);
                        break;
                    }
                    break;

                case false:
                    onesInLastHundredToOrdinal(tens % 10);
                    break;
                }
                break;
            }
            return(result);
        }
예제 #10
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))
            {
            case true:
                switch (hundreds != 0)    //hundreds
                {
                case true:
                    result += checkOnes(hundreds) + Ordinal.getClassName(0);
                    switch (classOfNumber == 0 && tens == 0)
                    {
                    case true:
                        result += "th";
                        break;
                    }
                    break;
                }
                switch (tens > 19)    //Tens
                {
                case true:
                    result += Ordinal.getTens(tens / 10);
                    switch (classOfNumber == 0)         // if last hundred
                    {
                    case true:
                        switch (tens % 10 != 0)
                        {
                        case true:
                            result += "y";
                            switch (tens % 10 < 5)
                            {
                            case true:
                                result += Ordinal.getLastOnes(tens % 10);
                                break;

                            case false:
                                result += Ordinal.getOnes(tens % 10) + "th";
                                break;
                            }
                            break;

                        case false:
                            result += "ieth";
                            break;
                        }
                        break;

                    case false:
                        result += "y";
                        result += checkOnes(tens % 10);
                        break;
                    }
                    break;

                case false:
                    switch (classOfNumber == 0)         // if last hundred
                    {
                    case true:
                        switch (tens < 5)
                        {
                        case true:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        case false:
                            result += Ordinal.getOnes(tens) + "th";
                            break;
                        }
                        break;

                    case false:
                        result += checkOnes(tens);
                        break;
                    }
                    break;
                }
                switch (classOfNumber > 0)     // Names of number classes
                {
                case true:
                    result += Ordinal.getClassName(classOfNumber);
                    switch (Number.getLastClass() == classOfNumber)
                    {
                    case true:
                        result += "th";
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }
예제 #11
0
        protected override string convertHundreds(int hundreds, int tens, int classOfNumber)
        {
            result = "";
            switch (!Number.isNull(classOfNumber))//hundreds
            {
            case true:
                switch (hundreds != 0)
                {
                case true:
                    result += checkOnes(hundreds) + Ordinal.getClassName(0);
                    switch (classOfNumber == 0 && tens == 0)
                    {
                    case true:
                        result += "ste";
                        break;
                    }
                    result += " ";
                    break;
                }
                switch (tens > 19)     //tens
                {
                case true:
                    switch (tens % 10 != 0)
                    {
                    case true:
                        result += Ordinal.getOnes(tens % 10) + "und";
                        break;
                    }
                    result += Ordinal.getTens(tens / 10);
                    switch (tens % 10 == 0 || classOfNumber == 0)
                    {
                    case true:
                        result += "ste ";
                        break;
                    }
                    break;

                case false:
                    switch (classOfNumber == 0)
                    {
                    case true:
                        switch (tens)
                        {
                        case 1:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        case 3:
                            result += Ordinal.getLastOnes(tens);
                            break;

                        default:
                            result += Ordinal.getOnes(tens) + "te";
                            break;
                        }
                        break;

                    case false:
                        result += Ordinal.getOnes(tens);
                        break;
                    }
                    break;
                }
                switch (classOfNumber > 0)    // classes
                {
                case true:
                    result += Ordinal.getClassName(classOfNumber);
                    switch (Number.getLastClass() == classOfNumber)
                    {
                    case true:
                        result += "ste ";
                        break;

                    case false:
                        switch (classOfNumber)
                        {
                        case 3:
                            result += "en";                 // milliard - en
                            break;
                        }
                        result += " ";
                        break;
                    }
                    break;
                }
                break;
            }
            return(result);
        }