Efectuarea unor reprezentări citibile de către om a unui întreg

Iată o problemă de codare pentru cei care se bucură de acest gen de lucruri. Să vedem implementările (în limba dvs. de alegere, desigur) a unei funcții care returnează o reprezentare String lizibilă de om a unui Integer specificat. De exemplu:

  • humanReadable(1) returns "one".
  • humanReadable(53) returns "fifty-three".
  • humanReadable(723603) returns "seven hundred and twenty-three thousand, six hundred and three".
  • humanReadable(1456376562) returns "one billion, four hundred and fifty-six million, three hundred and seventy-six thousand, five hundred and sixty-two".

Puncte bonus pentru soluții deosebit de inteligente/elegante!

S-ar putea să pară un exercițiu fără rost, dar există un număr de aplicații în lumea reală pentru acest tip de algoritm (deși numărul de susținere la un miliard poate fi depășit :-)

0
fr hi bn
Pentru oricine se străduiește cum să procedeze, de ex. 12,254 de la 12254 face 12254.to_s.reverse.split ('') each_slice (3) .to_a.map {| x | x = x.j & zwnj;. oin() revers} .rever & zwnj; se.join ( '')
adăugat autor xxjjnn, sursa
Sună ca o temă sau o întrebare de interviu, ar trebui să faci asta cu adevărat.
adăugat autor leppie, sursa

5 răspunsuri

Sprijină până la 999 milioane, dar nu există numere negative:

String humanReadable(int inputNumber) {
  if (inputNumber == -1) {
    return "";
  }
  int remainder;
  int quotient;
  quotient = inputNumber/1000000;
  remainder = inputNumber % 1000000;
  if (quotient > 0) {
    return humanReadable(quotient) + " million, " + humanReadable(remainder);
  }
  quotient = inputNumber/1000;
  remainder = inputNumber % 1000;
  if (quotient > 0) {
    return humanReadable(quotient) + " thousand, " + humanReadable(remainder);
  }
  quotient = inputNumber/100;
  remainder = inputNumber % 100;
  if (quotient > 0) {
    return humanReadable(quotient) + " hundred, " + humanReadable(remainder);
  }
  quotient = inputNumber/10;
  remainder = inputNumber % 10;
  if (remainder == 0) {
    //hackish way to flag the algorithm to not output something like "twenty zero"
    remainder = -1;
  }
  if (quotient == 1) {
    switch(inputNumber) {
    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";
    }
  }
  switch(quotient) {
  case 2:
    return "twenty " + humanReadable(remainder);
  case 3:
    return "thirty " + humanReadable(remainder);
  case 4:
    return "forty " + humanReadable(remainder);
  case 5:
    return "fifty " + humanReadable(remainder);
  case 6:
    return "sixty " + humanReadable(remainder);
  case 7:
    return "seventy " + humanReadable(remainder);
  case 8:
    return "eighty " + humanReadable(remainder);
  case 9:
    return "ninety " + humanReadable(remainder);
  }
  switch(inputNumber) {
  case 0:
    return "zero";
  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";
  }
}
0
adăugat
Ați uitat să precizați limba.
adăugat autor Lightness Races in Orbit, sursa

Există o mare problemă cu privire la implementarea acestei funcții. Este localizarea viitoare. Această funcție, scrisă de vorbitor nativ de limba engleză, probabil că nu ar funcționa corect pentru nici o altă limbă decât engleza. Este aproape imposibil să scrieți o funcție generală ușor localizabilă pentru orice dialect de limbă umană într-o lume, dacă nu aveți nevoie să o păstrați general. De fapt, în lumea reală nu trebuie să funcționați cu numere întregi uriașe, astfel încât să puteți păstra toate numerele într-o matrice mare (sau chiar nu atât de mare).

0
adăugat
Există informații în CLDR cu privire la modul în care numerele scrise funcționează în fiecare limbă, dar nu am putut găsi nici un exemplu de cod pentru a lucra cu acest lucru pentru a genera de fapt numerele.
adăugat autor Random832, sursa

There was already a question about this: Convert integers to written numbers

Răspunsul este pentru C#, dar cred că vă puteți da seama.

0
adăugat

au convenit că există o serie de aplicații din lumea reală. ca atare, există deja o serie de implementări în lumea reală.

a făcut parte din bsdgames, deoarece a fost destul de mult pentru totdeauna ...

> man number
0
adăugat
using System;

namespace HumanReadable
{
    public static class HumanReadableExt
    {
        private static readonly string[] _digits = {
                                                       "", "one", "two", "three", "four", "five",
                                                       "six", "seven", "eight", "nine", "eleven", "twelve",
                                                       "thirteen", "fourteen", "fifteen", "sixteen", "seventeen",
                                                       "eighteen", "nineteen"
                                                   };

        private static readonly string[] _teens = {
                                                      "", "", "twenty", "thirty", "forty", "fifty",
                                                      "sixty", "seventy", "eighty", "ninety"
                                                  };

        private static readonly string[] _illions = {
                                                        "", "thousand", "million", "billion", "trillion"
                                                    };

        private static string Seg(int number)
        {
            var work = string.Empty;

            if (number >= 100) 
                work += _digits[number/100] + " hundred ";

            if ((number % 100) < 20)
                work += _digits[number % 100];
            else
                work += _teens[(number % 100)/10] + "-" + _digits[number % 10];

            return work;
        }

        public static string HumanReadable(this int number)
        {
            if (number == 0)
                return "zero";
            var work = string.Empty;

            var parts = new string[_illions.Length];

            for (var ind = 0; ind < parts.Length; ind++)
                parts[ind] = Seg((int) (number % Math.Pow(1000, ind + 1)/Math.Pow(1000, ind)));

            for (var ind = 0; ind < parts.Length; ind++)
                if (!string.IsNullOrEmpty(parts[ind]))
                    work = parts[ind] + " " + _illions[ind] + ", " + work;

            work = work.TrimEnd(',', ' ');

            var lastSpace = work.LastIndexOf(' ');
            if (lastSpace >= 0)
                work = work.Substring(0, lastSpace) + " and" + work.Substring(lastSpace);

            return work;
        }
    }

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine(1.HumanReadable());
            Console.WriteLine(53.HumanReadable());
            Console.WriteLine(723603.HumanReadable());
            Console.WriteLine(1456376562.HumanReadable());
            Console.ReadLine();
        }
    }
}
0
adăugat