चार की दूरी

Question

यह चुनौती इस वीडियो पर आधारित है । मेरा सुझाव है कि इस चुनौती को आजमाने से पहले आप इसे देखें।

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

जैसा कि इस प्रक्रिया को दोहराते हुए किसी भी संख्या से शुरू होने वाले वीडियो में दिखाया जाता है, आखिरकार एक चार में परिणाम होगा, जो हमेशा के लिए अपने आप में मैप हो जाएगा।

यहाँ एक क्रूड निर्देशित ग्राफ है जो 16 से कम संख्याओं की कक्षाओं को दर्शाता है:

  12 11
    \|      
15 2 6 1 10 14 13
  \ \|/ /  /  /
   7 3-/  8--/
    \|   /
 9 0 5--/
  \ \|
   \-4

आपकी चुनौती यह है कि चार चरणों तक पहुंचने से पहले (यानी इस फ़ंक्शन को किसी संख्या पर लागू किया जाना चाहिए) संख्याओं के चरणों को निर्धारित करना है (यानी निर्देशित चित्र पर स्तर)।

अंग्रेजी नंबर बनाने

इस चुनौती के लिए किसी को अंग्रेजी शब्द कैसे बनाने चाहिए, इसकी संक्षिप्त व्याख्या इस प्रकार है:

उन्नीस के माध्यम से नंबर एक हैं:

एक, दो, तीन, चार, पांच, छह, सात, आठ, नौ, दस, ग्यारह, बारह, तेरह, चौदह, पंद्रह, सोलह, सत्रह, अठारह, उन्नीस

उन्नीस से अधिक संख्या के लिए प्रक्रिया इस प्रकार है:

यदि संख्या में एक सैकड़ों जगह है तो सैकड़ों जगह और "सौ" में अंक के नाम से शुरू होगा।

जैसे

100 -> "onehundred"

यदि शेष बीस से कम है तो शेष अंग्रेजी का प्रतिनिधित्व करें।

जैसे

714 -> "sevenhundredfourteen"

अन्यथा अगर दहाई का अंक शून्य नहीं है तो उचित प्रतिनिधित्व को जोड़ें:

2-> twenty
3-> thirty
4-> forty
5-> fifty
6-> sixty
7-> seventy
8-> eighty
9-> ninety

जैसे

470 -> "fourhundredseventy"

अंत में अगर कोई अंक है तो उसका प्रतिनिधित्व बढ़ाएँ

जैसे

681 -> "sixhundredeightyone"

आगे की शर्तें

• एक सौ से अधिक संख्या के लिए आपको अक्षरों की संख्या गिनते समय "और" छोड़ देना चाहिए। उदाहरण के लिए 577 "फाइवहेसवेंटीवेन" है जिसमें 23 अक्षर हैं।

• आपके प्रोग्राम को मानक विधियों के माध्यम से इनपुट के रूप में 0 से अधिक और 1,000 से कम सभी पूर्णांक को स्वीकार करना चाहिए।

• आपके प्रोग्राम को मानक आउटपुट विधियों के लिए आवश्यक चरणों की संख्या को आउटपुट करना होगा।

• यह कोडगॉल्फ है इसलिए सबसे कम बाइट्स जीत के साथ समाधान।

परीक्षण के मामलों

1 -> 3
4 -> 0
7 -> 2
23 -> 5
577 -> 6
600 -> 4 

Comments

संबंधित मुझे लगा कि यह एक धोखा था, लेकिन मैं इसे नहीं पा सकता हूं।

— जेम्स

"और" क्या हुआ? या बल्कि, क्यों बाहर छोड़ दिया और ?!

— जोनाथन एलन

@JonathanAllan cuz 'Murica

— LegionMammal978

Answer 1

जावास्क्रिप्ट (ईएस 6), 106 बाइट्स

f=(n,a="03354435543668877998")=>n-4&&1+f(7*(n>99)-(-a[n/100|0]-(a[n%=100]||a[n%10])-"0066555766"[n/10|0]))

अंकीय रूपांतरण ओवरहेड होने के बावजूद, स्ट्रिंग्स लंबाई को एन्कोड करने का सबसे अच्छा तरीका है।

Comments

गोश, यह लगभग वैसा ही है जैसा मेरा (लगभग पोस्ट किया गया) उत्तर दिखता है, केवल 11 बाइट्स छोटे।

— ETHproductions

@ETHproductions अच्छी बात है कि मैंने इसे पोस्ट करने से पहले 16 बाइट्स उड़ाए!

— नील

Answer 2

पायथन, अंक 2 के साथ, 97 113 115 94 93 92 बाइट्स

+16 बाइट्स (उस हाइफ़न को भूल गए जो num2words लागू होता है जो वास्तव में परीक्षण के किसी भी मामले के परिणामों को नहीं बदलता है, भले ही 23और 577प्रत्येक में एक हाइफ़न है)
+2 बाइट्स ( f=पुनरावर्ती शामिल करने के लिए भूल गए )
-20 बाइट्स (उपयोग re)
-8 बाइट्स @Wheat जादूगर के लिए धन्यवाद (उपयोग ~, की जगह n!=4के साथ n-4, और ... एक पंक्ति आयात> _ <)
-1 बाइट धन्यवाद @Cyoce करने के लिए (से अंतरिक्ष 4 and)

import re,num2words as w
f=lambda n:n-4and-~f(len(re.sub('\W|and','',w.num2words(n))))

बस चरणों की संख्या मायने रखता है; विशाल और नकारात्मक पूर्णांक के लिए भी काम करता है ( \Wअंक 2 के परिणाम में रिक्त स्थान, अल्पविराम और हाइफ़न पाता है):

>>> for test in (1,4,7,23,577,600,-1*2**96,3**96):
...     print('test: {0}  ->  {1}'.format(test, f(test)))
...
test: 1  ->  3
test: 4  ->  0
test: 7  ->  2
test: 23  ->  5
test: 577  ->  6
test: 600  ->  4
test: -79228162514264337593543950336  ->  4
test: 6362685441135942358474828762538534230890216321  ->  5

यहाँ है कि आखिरी मामला, कदम दर कदम:

sixquattuordecillionthreehundredsixtytwotredecillionsixhundredeightyfiveduodecillionfourhundredfortyoneundecilliononehundredthirtyfivedecillionninehundredfortytwononillionthreehundredfiftyeightoctillionfourhundredseventyfourseptillioneighthundredtwentyeightsextillionsevenhundredsixtytwoquintillionfivehundredthirtyeightquadrillionfivehundredthirtyfourtrilliontwohundredthirtybillioneighthundredninetymilliontwohundredsixteenthousthreehundredtwentyone
fourhundredfiftyone
nineteen
eight
five

Comments

f=अपने लैम्ब्डा फंक्शन से पहले आपको ज़रूरत नहीं है

— तदर्थ गार्फ हंटर

import re,num2words as rदो अलग-अलग कथनों के बजाय प्रयास करें ।

— तदर्थ गार्फ हंटर

n-4के रूप में एक ही बात हैn!=4

— तदर्थ गार्फ हंटर

@WheatWizard num2wordsहै w, reअब भी है re- कि दोनों मॉड्यूल और समारोह कहा जाता है नोटnum2words

— जोनाथन एलन

ठीक है पिछले एक, एक बाइट बचाने के लिए के and 1+साथ प्रतिस्थापित किया जा सकता हैand-~

— एड हॉक गार्फ हंटर

Answer 3

पायथ - 54 बाइट्स

रिफैक्ट करने की कोशिश करेंगे।

KjC"Y©åláóê¤"Ttl.u?<NyT@KNs+V@LKJ_jNT[Z@jC"Ckg"ThtJ7

टेस्ट सूट ।

Answer 4

मैथेमेटिका, 89 बाइट्स

Length@FixedPointList[StringLength@StringReplace[IntegerName@#,{" "->"","-"->""}]&,#]-2&

विशिष्ट गणितज्ञ: अंतर्निहित कार्य अच्छे, लंबे कार्य नाम खराब। FixedPointListजब तक जवाब नहीं बदलता है, तब तक अपना पहला तर्क (एक फ़ंक्शन) दूसरे तर्क पर लागू करता है, सभी परिणामों को सूचीबद्ध करता है; परिणामों में मूल इनपुट और दोहराया आउटपुट की दो प्रतियां शामिल हैं, इसलिए -2अंत में। Mathematica के अंतर्निहित IntegerNameरिक्त स्थान और हाइफ़न शामिल हैं, इसलिए हमें हाथ से उन से छुटकारा पाने की आवश्यकता है।

सामान्य तौर पर, IntegerName'के उत्पादन में चरित्र होता है "-" (यूनिकोड # 8208) सामान्य हाइफ़न के बजाय; यही कारण है कि यह सबमिशन 88 के बजाय 89 बाइट्स है। (और मैं चार स्पेस के साथ ऊपर दिए गए कोड को पहले नहीं ले सकता था और क्या यह यूनिकोड के चरित्र को स्वीकार करता है - कोई मदद? - यदि उपरोक्त कोड ठीक से काम नहीं करेगा यदि कट और पेस्ट किया गया है? ।)

Answer 5

पायथन 2.7, 344 216 208 बाइट्स:

x=`input()`;c=0;y=lambda v:dict(zip(range(0,10),[0]+v));l=[3,3,5,4,4,3,5,5,4];d=y(l);e=y([3,6,6,6,5,5,7,7,6]);f=y([i+7for i in l])
while x!='4':x=`sum([q[int(r)]for q,r in zip([d,e,f],x[::-1])])`;c+=1
print c

अन्य पायथन उत्तर के विपरीत किसी भी बाहरी पुस्तकालयों का उपयोग नहीं करता है। के माध्यम से इनपुट stdinऔर आउटपुट के लिए ले जाता है stdout।

सभी टेस्ट मामलों के साथ प्रतिकृति।

व्याख्या

पहले हर एक के साथ 3 शब्द बनाता [1,9]है, क्रमशः अंक , दहाई और सैंकड़ों स्थान पर बंद अंतराल में दर्शाए गए अंक के लिए प्रत्येक संख्या के अंग्रेजी शब्द प्रतिनिधित्व की लंबाई को जोड़ते हैं। उदाहरण के लिए, शब्दकोश में पहली प्रविष्टि dहै 1:3के रूप में 1लिखा जाता है oneअंग्रेजी में और है 3पत्र।

फिर, कुछ स्ट्रिंग इनपुट में प्रत्येक अंक xको इसके संबंधित शब्दकोश में सौंपा जाता है, जिसके बाद प्रत्येक स्थान के प्रत्येक नंबर को संबंधित शब्दकोश में इसके मूल्य के साथ मिलान किया जाता है। उदाहरण के लिए, मान लीजिए कि इनपुट नंबर था 23। 20दहाई के स्थान में शब्दकोश के साथ रखा जाएगा e, जिसमें यह साथ मिलान किया जाता है 6, और 3इकाई के स्थान में शब्दकोश के साथ रखा जाएगा d, जिसमें यह साथ मिलान किया जाता है 5। इन मिलान किए गए अंकों को फिर संख्या के अंग्रेजी प्रतिनिधित्व की लंबाई का प्रतिनिधित्व करने के लिए एक साथ जोड़ा जाता है, जिसे xएक स्ट्रिंग के रूप में सौंपा गया है और, जब तक कि x!='4'लूप आगे बढ़ता है, तब तक वृद्धि होती cहै1इस प्रकार अब तक उठाए गए कदमों की संख्या का प्रतिनिधित्व करने के लिए। इसलिए, के 23अनुरूप होगा 11, जो बारी के अनुरूप 6होगा 3और फिर से 5और अंत में 4, जिसके परिणामस्वरूप 5कुल कदम होंगे।

अंत में, एक बार लूप खत्म होने के बाद, "डिस्टेंस टू फोर" का प्रतिनिधित्व cकरने के stdoutलिए आउटपुट है , जो इस मामले में होगा 5।

Answer 6

जावा, 556 295 बाइट्स

261 बाइट बचाने के लिए @KevinCruijssen को धन्यवाद

  void int(n) {int s[]={0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7,7,9,9,8,6,9,9,11,10,6,6,5,5,7,7,6};int c=0,t=(int)Math.pow(10,(int)Math.log10(n)),v=1;while(n>0){if(n/100>0)c+=(s[n/100]+7);else {if(n>0&n<25){c+=s[n];break;}else{c+=s[(n/10)+22];}}n=n%t;t=t/10;}while(c!=4){v++;c=s[c];}System.out.print(v);}

Ungolfed:

  void int(n) {

    int s[]={0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7,7,9,9,8,6,9,9,11,10,6,6,5,5,7,7,6};
     int c=0,t=(int)Math.pow(10,(int)Math.log10(n)),v=1;
         while(n>0){
            if(n/100>0)
                c+=(s[n/100]+7);
            else {if(n>0&n<25){
                c+=s[n];
            break;
            }
            else{
                c+=s[(n/10)+22];

            }
            }
            n=n%t;
            t=t/10;
        }

        while(c!=4)
        {
            v++;
        c=s[c];
        }
System.out.print(v);
}

Comments

मुझे लगता है कि आपके कोड में गलती है, क्योंकि s++स्ट्रिंग-एरे पर संभव नहीं है ..: S

— केविन क्रूज़सेन

@KevinCruijssen मैं S (काउंटर) को INT घोषित करता हूं और स्ट्रॉन्ग भी करता हूं .... जावा अपने आप यह तय कर लेता है कि यह एक INT है।

— 7

ठीक है, अगर मैं आपके कोड को आइडोन या मेरी ग्रहण आईडीई में चलाता हूं, तो यह विफल हो जाता है क्योंकि आपके पास दो हैं s। Btw, आप अपने कोड को इस तरह से काफी बड़ी मात्रा में गोल्फ कर सकते हैं:int c(int n){int s[]={0,3,3,5,4,4,3,5,5,4,3,6,6,8,8,7,7,9,8,8,6,9,9,11,10,6,5,5,5,7,6,6},c=0,t=(int)Math.pow(10,(int)Math.log10(n)),x=1;while(n>0)if(n/100>0)c+=s[n/100]+7;else{if(n>0&n<25){c+=s[n];break;}else c+=s[(n/10)+22];}n%=t;t/=10;}for(;c!=4;x++,c=s[c]);return x;}

— केविन क्रूज़सेन

मैं हैरान हूं ...... मेरे कोड का क्या हुआ और धन्यवाद @ केविनक्रूजसेन..और मैं इसे सही कर रहा हूं ... फिर से धन्यवाद।

— नंबरनोट

एनपी :) मुझे लगता है कि इसे किसी और तरह से बिना इफ़ेक्ट के इस्तेमाल किया जा सकता है और वहां ब्रेक (लेकिन मैं किसी और को छोड़ दूँगा), लेकिन चुनौती से निपटने के लिए आपका प्रारंभिक कोड एक बहुत बड़ा आधार था, इसलिए +1 मुझ से।

— केविन क्रूज़सेन