C#练习题答案: 九十九九九九九【难度：3级】--景越C#经典编程题库,1000道C#基础练习题等你来挑战

九十九九九九九【难度:3级】:

答案1:

using System.Collections.Generic;


class Kata
{
    public static string NumberToEnglish(int number)
    {
      Dictionary <int, string> numberReader = new Dictionary <int, string> ()
        {
          {0, "zero"},
          {1, "one"},
          {2, "two"},
          {3, "three"},
          {4, "four"},
          {5, "five"},
          {6, "six"},
          {7, "seven"},
          {8, "eight"},
          {9, "nine"},
          {10,"ten"},
          {11,"eleven"},
          {12,"twelve"},
          {13,"thirteen"},
          {14,"fourteen"},
          {15,"fifteen"},
          {16,"sixteen"},
          {17,"seventeen"},
          {18,"eighteen"},
          {19,"nineteen"},
          {20,"twenty"},
          {30,"thirty"},
          {40,"forty"},
          {50,"fifty"},
          {60,"sixty"},
          {70,"seventy"},
          {80,"eighty"},
          {90,"ninety"},
          {100,"hundred"},
          {1000,"thousand"}
        } ;
       if (number < 0) return "" ;
       if (number <= 20) return numberReader[number];
       if (number/10000 != 0) return NumberToEnglish(number/1000) + " " + numberReader[1000] + " " + NumberToEnglish(number%1000) ;
       if (number/1000 != 0) return (numberReader[number/1000] + " " + numberReader[1000] + " " + NumberToEnglish (number%1000)).Trim(' ')  ;
       if ((number/100) != 0) return (numberReader[number/100] + " " + numberReader[100] + (((number%100) == 0) ? "" :( " " + NumberToEnglish (number%100)))).Trim(' ') ;
       if ((number/10) != 0) return numberReader[(number/10)*10] + (((number%10) == 0) ? "" : (" " +  numberReader[number%10])) ;

       return "";
    }
}​

           

答案2:

class Kata
{
static string[] ones = new string[] { "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
    static string[] teens = new string[] { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
    static string[] tens = new string[] { "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };
    static string[] thousandsGroups = { "", " thousand", " million", " billion" };

    private static string FriendlyInteger(int n, string leftDigits, int thousands)
    {
        if (n == 0)
        {
            return leftDigits;
        }

        string friendlyInt = leftDigits;

        if (friendlyInt.Length > 0)
        {
            friendlyInt += " ";
        }

        if (n < 10)
        {
            friendlyInt += ones[n];
        }
        else if (n < 20)
        {
            friendlyInt += teens[n - 10];
        }
        else if (n < 100)
        {
            friendlyInt += FriendlyInteger(n % 10, tens[n / 10 - 2], 0);
        }
        else if (n < 1000)
        {
            friendlyInt += FriendlyInteger(n % 100, (ones[n / 100] + " hundred"), 0);
        }
        else
        {
            friendlyInt += FriendlyInteger(n % 1000, FriendlyInteger(n / 1000, "", thousands+1), 0);
            if (n % 1000 == 0)
            {
                return friendlyInt;
            }
        }

        return friendlyInt + thousandsGroups[thousands];
    }

    public static string NumberToEnglish(int n)
    {
        if (n == 0)
        {
            return "zero";
        }
        else if (n < 0 || n > 99999)
        {
            return string.Empty;
        }

        return FriendlyInteger(n, "", 0);
    }
}​

           

答案3:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
class Kata
{
    public static string NumberToEnglish(int n)
    {
            string words = "";
            double intPart;
            double decPart = 0;
            if (n == 0)
                return "zero";
            if (n < 0)
                return "";
            try
            {
                string[] splitter = n.ToString().Split('.');
                intPart = double.Parse(splitter[0]);
                decPart = double.Parse(splitter[1]);
            }
            catch
            {
                intPart = n;
            }

            words = NumWords(intPart);

            if (decPart > 0)
            {
                if (words != "")
                    words += " and ";
                int counter = decPart.ToString().Length;
                switch (counter)
                {
                    case 1: words += NumWords(decPart) + " tenths"; break;
                    case 2: words += NumWords(decPart) + " hundredths"; break;
                    case 3: words += NumWords(decPart) + " thousandths"; break;
                    case 4: words += NumWords(decPart) + " ten-thousandths"; break;
                    case 5: words += NumWords(decPart) + " hundred-thousandths"; break;
                    case 6: words += NumWords(decPart) + " millionths"; break;
                    case 7: words += NumWords(decPart) + " ten-millionths"; break;
                }
            }
            return words.TrimStart(' ');
        }

            static String NumWords(double n) 
            {
                string[] numbersArr = new string[] { " one", " two", " three", " four", " five", " six", " seven", " eight", " nine", " ten", " eleven", " twelve", " thirteen", " fourteen", " fifteen", " sixteen", " seventeen", " eighteen", " nineteen" };
                string[] tensArr = new string[] { " twenty", " thirty", " forty", " fifty", " sixty", " seventy", " eighty", " ninety" };
                string[] suffixesArr = new string[] { " thousand", " million", " billion", " trillion", " quadrillion", " quintillion", " sextillion", " septillion", " octillion", " nonillion", " decillion", " undecillion", " duodecillion", " tredecillion", " Quattuordecillion", " Quindecillion", " Sexdecillion", " Septdecillion", " Octodecillion", " Novemdecillion", " Vigintillion" };
                string words = "";

                bool tens = false;

                if (n < 0)
                {
                    words += "negative ";
                    n *= -1;
                }

                int power = (suffixesArr.Length + 1) * 3;

                while (power > 3)
                {
                    double pow = Math.Pow(10, power);
                    if (n >= pow)
                    {
                        if (n % pow > 0)
                        {
                            words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1] + " ";
                        }
                        else if (n % pow == 0)
                        {
                            words += NumWords(Math.Floor(n / pow)) + " " + suffixesArr[(power / 3) - 1];
                        }
                        n %= pow;
                    }
                    power -= 3;
                }
                if (n >= 1000)
                {
                    if (n % 1000 > 0) words += NumWords(Math.Floor(n / 1000)) + " thousand";
                    else words += NumWords(Math.Floor(n / 1000)) + " thousand";
                    n %= 1000;
                }
                if (0 <= n &amp;&amp; n <= 999)
                {
                    if ((int)n / 100 > 0)
                    {
                        words += NumWords(Math.Floor(n / 100)) + " hundred";
                        n %= 100;
                    }
                    if ((int)n / 10 > 1)
                    {
                        if (words != "")
                            words += "";
                        words += tensArr[(int)n / 10 - 2];
                        tens = true;
                        n %= 10;
                    }

                    if (n < 20 &amp;&amp; n > 0)
                    {
                        if (words != "" &amp;&amp; tens == false)
                            words += "";
                        words += (tens ? "" + numbersArr[(int)n - 1] : numbersArr[(int)n - 1]);
                        n -= Math.Floor(n);
                    }
                }

                return words;

            }
}​

           

答案4:

using System;
using System.Collections.Generic;
using System.Linq;

class Kata
{
    public static string NumberToEnglish(int n)
    {
        var ones = new[] { "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" };
        var teen = new[] { "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"};
        var tens = new[] { "", "", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety", };
        
        var answer = new List<string>();
        
        if (n > 999999 || n < 0) return "";
        if (n == 0) return "zero";
        if (n / 1000 > 0)
        {
          answer.Add($"{NumberToEnglish(n/1000)} thousand");
          n%=1000;
        }
        if (n / 100 > 0)
        {
          answer.Add($"{ones[n/100]} hundred");
          n%=100;
        }
        if (n >= 20)
        {
          answer.Add($"{tens[n/10]} {ones[n%10]}");
        }
        else if (n > 9)
        {
          answer.Add(teen[n%10]);
        }
        else if (n > 0)
        {
          answer.Add(ones[n%10]);
        }
        
        
        return string.Join(" ", answer).Trim();
    }
}​

           

答案5:

class Kata
{
    const string z = "zero";
    private static string[] unitsMap = new[] { z, "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
    private static string[] tensMap = new[] { z, "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };

    private static void CheckNumber(ref string words, ref int n, int d, string w)
    {
        int r = n / d;
        if (r > 0)
        {
            words += NumberToEnglish(r) + " " + w + " ";
            n %= d;
        }
    }

    public static string NumberToEnglish(int n)
    {
        if (n == 0)
        return z;

        if (n < 0)
            return "";
    
        string words = "";
    
        CheckNumber(ref words, ref n, 1000000, "million");
        CheckNumber(ref words, ref n, 1000, "thousand");
        CheckNumber(ref words, ref n, 100, "hundred");
    
        if (n > 0)
        {
            if (n < 20)
            {
                words += unitsMap[n];
            }
            else
            {
                int div = 10;
                int mod = n % div;
                words += tensMap[n / div];
              
                if (mod > 0)
                {
                    words += " " + unitsMap[mod];
                }
            }
        }
    
        return words.Trim();
    }
}​

           

答案6:

using System;
using System.Collections.Generic;

class Kata
{
private static Dictionary<int, string> _words = new Dictionary<int, string>
        {
            {1,"one"},
            {2,"two"},
            {3,"three"},
            {4,"four"},
            {5,"five"},
            {6,"six"},
            {7,"seven"},
            {8,"eight"},
            {9,"nine"},
            {10,"ten"},
            {11,"eleven"},
            {12,"twelve"},
            {13,"thirteen"},
            {14,"fourteen"},
            {15,"fifteen"},
            {16,"sixteen"},
            {17,"seventeen"},
            {18,"eighteen"},
            {19,"nineteen"},
            {20,"twenty"},
            {30,"thirty"},
            {40,"forty"},
            {50,"fifty"},
            {60,"sixty"},
            {70,"seventy"},
            {80,"eighty"},
            {90,"ninety"}
        };
        
        public static string NumberToEnglish(int value)
        {
            string returnValue = string.Empty;
            
            if(value == 0)
            {
               return "zero";
            }
            
            if (value >= 1000)
            {
                if ((value % 10000 == 0 || (value % 10000 < 1000)) || value / 1000 < 20)
                {
                    returnValue = $"{_words[value / 1000]} thousand ";
                }
                else
                {
                    returnValue = $"{_words[(value / 10000) * 10]} {_words[value % 10]} thousand ";
                }

                value = value % 1000;
            }

            returnValue += GenerateHundreds(value);
            return returnValue.Trim();
        }
        
        public static string GenerateTensAndOnes(int value)
        {
            if (value > 0)
            {
                if ((value % 10 == 0) || value < 20)
                {
                    return _words[value];
                }
                else
                {
                    return $"{_words[(value / 10) * 10]} {_words[value % 10]}";
                }
            }

            return string.Empty;
        }
        
        public static string GenerateHundreds(int value)
        {
            string returnValue = string.Empty;

            if (value >= 100)
            {
                returnValue = $"{_words[value / 100]} hundred ";
                value = value % 100;
            }

            return returnValue += GenerateTensAndOnes(value);
        }

}​

           

答案7:

using System;
using System.Collections.Generic;
using System.Linq;

public static class Kata
{
    private static readonly List<string> LargeTerms = new List<string> { "", "thousand", "million", "billion", "trillion", "quadrillion", "quintillion" };
    private static readonly List<string> MediumTerms = new List<string> { "", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety", "hundred" };
    private static readonly List<string> SmallTerms = new List<string> { "", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten",
        "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };

    public static string NumberToEnglish(int n)
    {
        // Handle edge-case inputs
        if (n < 0 || n > 99999) return string.Empty;
        if (n == 0) return "zero";

        var words = new List<string>();

        // Break down the number into groupings of 3 digits
        var parts = n.ToString("N0").Split(',');
        for (var i = 0; i < parts.Length; i++)
        {
            var part = Convert.ToInt32(parts[i]);
            if (part > 0)
            {
                // Handle the hundreds portion first
                var hundreds = part / 100;
                if (hundreds > 0)
                {
                    words.Add(SmallTerms[hundreds]);
                    words.Add(MediumTerms[10]);
                }
                part %= 100;

                // Now the final two digits
                if (part >= 20)
                {
                    // Numbers 20 and greater follow the same pattern
                    var tens = part / 10;
                    var ones = part % 10;
                    words.Add(MediumTerms[tens]);
                    if (ones > 0) words.Add(SmallTerms[ones]);
                }
                else if (part > 0)
                {
                    // Numbers 1-19 handled directly from the small terms array
                    words.Add(SmallTerms[part]);
                }

                // Add the large term
                words.Add(LargeTerms[parts.Length - i - 1]);
            }
        }

        return string.Join(" ", words.Where(s => !string.IsNullOrEmpty(s)));
    }
}​

           

答案8:

using System;

class Kata
{
    public static string NumberToEnglish(int number)
    {
    if (number == 0)
        return "zero";

    if (number < 0)
        return string.Empty;

    string words = "";

    if ((number / 1000000) > 0)
    {
        words += NumberToEnglish(number / 1000000) + " million ";
        number %= 1000000;
    }

    if ((number / 1000) > 0)
    {
        words += NumberToEnglish(number / 1000) + " thousand ";
        number %= 1000;
    }

    if ((number / 100) > 0)
    {
        words += NumberToEnglish(number / 100) + " hundred ";
        number %= 100;
    }

    if (number > 0)
    {
        var unitsMap = new[] { "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen" };
        var tensMap = new[] { "zero", "ten", "twenty", "thirty", "forty", "fifty", "sixty", "seventy", "eighty", "ninety" };

        if (number < 20)
            words += unitsMap[number];
        else
        {
            words += tensMap[number / 10];
            if ((number % 10) > 0)
                words += " " + unitsMap[number % 10];
        }
    }

    return words.Trim();
    }
}​

           

答案9:

class Kata
    {
        public static string NumberToEnglish(int n)
        {
            string mil = "";
            string cien = "";
            string uni = "";

            if(n>99999 || n < 0)
            {
                return "";
            }
            else if(n==0)
            {
                return "zero";
            }
            else
            {
                if (n > 999) { mil = Decena((n / 1000)) + " thousand "; }
                
                if((n/100).ToString()[(n / 100).ToString().Length - 1] != '0')
                {
                    cien = Decena(int.Parse((n / 100).ToString()[(n / 100).ToString().Length - 1].ToString())) + " hundred ";
                }

                if (n % 100 != 0) { uni = Decena(n%100); }

                string resultado = mil + cien + uni;
                string resultado2="";
                if (resultado[(resultado.Length - 1)] == ' ')
                {
                    for(int i = 0; i < (resultado.Length - 1); i++)
                    {
                        resultado2 += resultado[i];
                        
                    }
                    resultado = resultado2;
                    
                }

                return resultado;
            }
        }



        public static string Decena(int d)
        {
            
            string Unidad(int u)
            {
                switch (u)
                {
                    case 0: return "";
                    case 1: return "one";
                    case 2: return "two";
                    case 3: return "three";
                    case 4: return "four";
                    case 5: return "five";
                    case 6: return "six";
                    case 7: return "seven";
                    case 8: return "eight";
                    case 9: return "nine";
                    default: return null;
                }
            }

            if (d < 100 &amp;&amp; d > -1)
            {
                if (d < 10) { return Unidad(d); }
                
                else if (d >= 10 &amp;&amp; d < 20)
                {
                    switch (d)
                    {
                        case 10: return "ten";
                        case 11: return "eleven";
                        case 12: return "twelve";
                        case 13: return "thirteen";
                        case 14: return "fourteen";
                        case 15: return "fifteen";
                        case 16: return "sixteen";
                        case 17: return "seventeen";
                        case 18: return "eighteen";
                        case 19: return "nineteen";
                        default: return "";


                    }
                }
                else
                {
                    string raya;

                    if (d.ToString()[1] == '0')
                    {
                        raya = "";
                    }
                    else { raya = " "; }

                    string decena= "";

                    switch (d.ToString()[0])
                    {
                        case '2': decena = "twenty"; break;
                        case '3': decena = "thirty"; break;
                        case '4': decena = "forty"; break;
                        case '5': decena = "fifty"; break;
                        case '6': decena = "sixty"; break;
                        case '7': decena = "seventy"; break;
                        case '8': decena = "eighty"; break;
                        case '9': decena = "ninety"; break;
                    }

                    return decena + raya + Unidad(int.Parse(d.ToString()[1].ToString()));
                }



            }
            else { return ""; }

            
        }
    }​

           

答案10:

using System;

class Kata
{
    public static string NumberToEnglish(int n)
    {
        string num = "" + n;
        if(n > 99999 || n < 0)
          return "";
        if(n < 10)
          return convertOnes(n);
        else if(n >= 10 &amp;&amp; n <= 19)
          return convertTensSpecial(n);
        
        string str = "";

        int z = num.Length;
        
        if(z == 5)
        {
            string firstTwo = num.Substring(0,2);
            int numTwo = int.Parse(firstTwo);
            if(numTwo >= 10 &amp;&amp; numTwo <= 19)
              str+= convertTensSpecial(numTwo) + " thousand ";
            else if(numTwo == 20)
              str+= " twenty thousand ";
            else if(int.Parse(firstTwo) % 10 == 0){
              str+= convertTens(n/10) + "ty ";
            }
            else if(int.Parse(firstTwo) % 10 != 0){
              int twoDigits = int.Parse(num.Substring(0,2));
              string twoString = "" + twoDigits;
              Console.WriteLine(twoString);
              if(twoString.Substring(0,1) != "0")
                str+= convertTens(int.Parse(twoString.Substring(0,1))) + "ty ";
              if(twoString.Substring(1,1) != "0")
                str+= convertOnes(int.Parse(twoString.Substring(1,1))) + " thousand ";
            }
            
            if(num.Substring(2,1) != "0")
              str+= convertOnes(int.Parse(num.Substring(0,1))) + " hundred ";
            int twoNum = int.Parse(num.Substring(3,2));
            str += convertTwoDigits(twoNum);  
        }
        
        if(z == 4)
        {
            str+= convertOnes(int.Parse(num.Substring(0,1))) + " thousand ";
            if(num.Substring(1,1) != "0")
              str+= convertOnes(int.Parse(num.Substring(1,1))) + " hundred ";
            int twoNum = int.Parse(num.Substring(2,2));
            str += convertTwoDigits(twoNum);  
        }
        
        if(z == 3)
        {
            if(num.Substring(0,1) != "0")
              str+= convertOnes(int.Parse(num.Substring(0,1))) + " hundred ";
            int twoNum = int.Parse(num.Substring(1,2));
            str += convertTwoDigits(twoNum);  
        }
        
        else if(z == 2 &amp;&amp; n % 10 == 0){
          return convertTens(n/10) + "ty";
        }
        else if(z==2 &amp;&amp; n % 10 != 0){
          int twoNum = int.Parse(num.Substring(0,2));
          string twoString = "" + twoNum;
          Console.WriteLine(twoString);
          if(twoString.Substring(0,1) != "0")
            str+= convertTens(int.Parse(twoString.Substring(0,1))) + "ty ";
          if(twoString.Substring(1,1) != "0")
            str+= convertOnes(int.Parse(twoString.Substring(1,1)));
        }

        Console.WriteLine(str);
        return str.Trim();
    }
    
    public static string convertOnes(int n){
      if(n == 1)
        return "one";
      else if(n == 2)
        return "two";
      else if(n == 3)
        return "three";
      else if(n == 4)
        return "four";
      else if(n == 5)
        return "five";
      else if(n == 6)
        return "six";
      else if(n == 7)
        return "seven";
      else if(n == 8)
        return "eight";
      else if(n == 9)
        return "nine";
      else if (n == 0)
        return "zero";
      return "";
    }    
    
    public static string convertTensSpecial(int n){
      if(n == 10)
        return "ten";
      else if(n == 11)
        return "eleven";
      else if(n == 12)
        return "twelve";
      else if(n == 13)
        return "thirteen";
      else if(n == 14)
        return "fourteen";
      else if(n == 15)
        return "fifteen";
      else if(n == 16)
        return "sixteen";
      else if(n == 17)
        return "seventeen";
      else if(n == 18)
        return "eighteen";
      else if(n == 19)
        return "nineteen";
      return "";
    }
    
    public static string convertTens(int n){
      if(n == 2)
        return "twen";
      else if(n == 3)
        return "thir";
      else if(n == 4)
        return "for";
      else if(n == 5)
        return "fif";
      else if(n == 6)
        return "six";
      else if(n == 7)
        return "seven";
      else if(n == 8)
        return "eigh";
      else if(n == 9)
        return "nine";
      return "";
    }
    
    public static string convertTwoDigits(int twoNum){
          string str = "";
          if(twoNum < 10 &amp;&amp; twoNum > 0){
            str+= convertOnes(twoNum);
          }
          else if(twoNum == 0){
          
          }
          else if(twoNum >= 10 &amp;&amp; twoNum <= 19)
          {
            str+= convertTensSpecial(twoNum);
          }
          else if(twoNum % 10 == 0)
          {
            string twoString = "" + twoNum;
            Console.WriteLine(twoString);
            if(twoString.Substring(0,1) != "0")
              str+= convertTens(int.Parse(twoString.Substring(0,1))) + "ty ";
            if(twoString.Substring(1,1) != "0")
              str+= convertOnes(int.Parse(twoString.Substring(1,1)));
          }
          else if(twoNum % 10 != 0)
          {
            string twoString = "" + twoNum;
            if(twoString.Substring(0,1) != "0")
              str+= convertTens(int.Parse(twoString.Substring(0,1))) + "ty ";
            if(twoString.Substring(1,1) != "0")
              str+= convertOnes(int.Parse(twoString.Substring(1,1)));
          }
          return str;
    }
}​