# algorithm - हरण - सबसे छोटा पूर्णांक

## एक पूर्णांक के मानव पठनीय प्रतिनिधित्व करना (4)

99 9 मिलियन तक का समर्थन करता है, लेकिन कोई ऋणात्मक संख्या नहीं:

``````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";
}
}
``````

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

• मानव रिडीबल (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
``````