algorithm हरण एक पूर्णांक के मानव पठनीय प्रतिनिधित्व करना




सबसे छोटा पूर्णांक (5)

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();
        }
    }
}

यहाँ उन लोगों के लिए एक कोडिंग समस्या है जो इस तरह की चीज़ों को पसंद करते हैं चलो एक समारोह के अपने कार्यान्वयन (निश्चित रूप से अपनी भाषा में), जो एक निर्दिष्ट पूर्णांक के मानव पठनीय स्ट्रिंग प्रतिनिधित्व को देता है। उदाहरण के लिए:

  • मानव रिडीबल (1) "एक" देता है
  • मानव रिडीबल (53) "पचास-तीन" देता है
  • मानव रीडेबल (723603) "सात सौ तेईस हजार छः सौ और तीन" देता है
  • मानव रीडेबल (1456376562) "एक अरब, चार सौ पचास लाख, तीन सौ और सत्तर छः हजार, पांच सौ और साठ बजे" देता है।

विशेष रूप से चतुर / सुरुचिपूर्ण समाधान के लिए बोनस अंक!

यह एक व्यर्थ अभ्यास की तरह लग सकता है, लेकिन इस तरह के एल्गोरिथम के लिए असली दुनिया के अनुप्रयोगों की संख्या (हालांकि अरबों के रूप में उच्च के रूप में समर्थन संख्या ओवरकिल हो सकती है :-)



import math

def encodeOnesDigit(num):
   return ['', 'one', 'two', 'three', 'four', 'five', 'six', 'seven', 'eight', 'nine'][num]

def encodeTensDigit(num):
   return ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety'][num-2]

def encodeTeens(num):
   if num < 10:
      return encodeOnesDigit(num)
   else:
      return ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen', 'sixteen', 'seventeen', 'eighteen', 'nineteen'][num-10]

def encodeTriplet(num):
   if num == 0: return ''
   str = ''
   if num >= 100:
      str = encodeOnesDigit(num / 100) + ' hundred'
   tens = num % 100
   if tens >= 20:
      if str != '': str += ' '
      str += encodeTensDigit(tens / 10)
      if tens % 10 > 0:
         str += '-' + encodeOnesDigit(tens % 10)
   elif tens != 0:
      if str != '': str += ' '
      str += encodeTeens(tens)
   return str

def zipNumbers(numList):
   if len(numList) == 1:
      return numList[0]
   strList = ['', ' thousand', ' million', ' billion'] # Add more as needed
   strList = strList[:len(numList)]
   strList.reverse()
   joinedList = zip(numList, strList)
   joinedList = [item for item in joinedList if item[0] != '']
   return ', '.join(''.join(item) for item in joinedList)

def humanReadable(num):
   if num == 0: return 'zero'
   negative = False
   if num < 0:
      num *= -1
      negative = True
   numString = str(num)
   tripletCount = int(math.ceil(len(numString) / 3.0))
   numString = numString.zfill(tripletCount * 3)
   tripletList = [int(numString[i*3:i*3+3]) for i in range(tripletCount)]
   readableList = [encodeTriplet(num) for num in tripletList]
   readableStr = zipNumbers(readableList)
   return 'negative ' + readableStr if negative else readableStr

इस समारोह कार्यान्वयन के बारे में एक बड़ी समस्या है यह भविष्य का स्थानीयकरण है अंग्रेजी मूल स्पीकर द्वारा लिखित उस समारोह, सबसे अधिक शायद अंग्रेजी की तुलना में किसी भी अन्य भाषा के लिए सही काम नहीं करेगा। दुनिया में किसी भी मानव भाषा की बोली के लिए सामान्य आसान स्थानीयकृत फ़ंक्शन लिखना लगभग असंभव है, जब तक कि आपको इसे सामान्य रखने की आवश्यकता न हो। दरअसल वास्तविक दुनिया में आपको बड़ी संख्या के साथ काम करने की ज़रूरत नहीं है, इसलिए आप सभी नंबरों को एक बड़ा (या इतनी बड़ी नहीं) स्ट्रिंग सरणी में रख सकते हैं।


सहमति व्यक्त की कि कई वास्तविक दुनिया अनुप्रयोग हैं जैसे कि पहले से ही कई वास्तविक दुनिया कार्यान्वयन हैं

यह बहुत हमेशा के लिए बीएसडीगेड का हिस्सा रहा है ...

> man number




numbers