14

से प्रेरित होकर इस सीएमसी

0 से अधिक एक सकारात्मक पूर्णांक को देखते हुए, इस पर निम्न ऑपरेशन करें:

यदि सभी दस एकल अंक ( 1234567890) कम से कम एक बार संख्या में हैं, तो गिनती को आउटपुट करें और प्रोग्राम से बाहर निकलें
अन्यथा, संख्या को दोगुना करें और गिनती बढ़ाएं।

गिनती 0 से शुरू होती है और इनपुट दोगुनी होने की संख्या है। उदाहरण के लिए, यदि इनपुट 617283945 था, तो इसे एक बार दोगुना करना होगा क्योंकि 1234567890 में सभी 10 अंक हैं।

यह एक कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है। यदि आप चाहें तो इनपुट को एक स्ट्रिंग के रूप में लिया जा सकता है।

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

input => output

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

— केर्ड सिक्काहिराहिंग
स्रोत

क्या हम एक स्ट्रिंग के रूप में इनपुट ले सकते हैं?

— स्टीफन

@Stephen आप एक स्ट्रिंग के रूप में इनपुट ले सकते हैं।

— caird coinheringaahing

3

क्या यह गारंटी है कि किसी के लिए nकुछ kऐसा मौजूद है nkजो पंडितगील है? मुझे एक प्रमाण देखना अच्छा लगेगा।

— शुकी

1

@bfontaine चैट मिनी चैलेंज

— caird coinheringaahing

3

@shooqie सबूत! किसी भी n के लिए जो कि 10 तक का है, यह भी 10 ^ 10 का coprime है, और इसलिए कुछ k मौजूद है जैसे nk 1 mod 10 ^ 10 है। फिर 1234567890 * nk = 1234567890 mod 10 ^ 10 है, इसलिए प्रत्येक अंक आवश्यक रूप से कम से कम एक बार दिखाई देता है। यदि नहीं, तो 10 के साथ अंतिम गैर-शून्य अंक कोप्राइम बनाने के लिए 2, 5 या 25 से गुणा करें, और उपरोक्त प्रमाण कार्यों का एक प्रकार है (औपचारिक रूप से, n = 10 ^ m * p, जहां p उपरोक्त स्थिति को संतुष्ट करता है। , तो 1234567890 * p * k जैसा कि ऊपर पैंडिजीटल है, इसलिए 1234567890 * p * k * 10 ^ m = 1234567890 * k * n है)। :)

— बी। मेहता

6

पायथन 3 , 39 बाइट्स

f=lambda n:len({*str(n)})<10and-~f(n*2)

इसे ऑनलाइन आज़माएं!

आउटपुट Falseके लिए 0।

— लीक नन
स्रोत

4

जे , 24 23 बाइट्स

(]1&(+$:)2**)10>#@~.@":

इसे ऑनलाइन आज़माएं!

व्याख्या

(]1&(+$:)2**)10>#@~.@":  Input: integer n
                     ":  Format as string
                  ~.@    Unique
                #@       Length
             10>         Less than 10
           *             Multiply, gives n if previous was true, else 0
         2*              Multiply by 2
 ]                       Get the previous condition
  1&(   )                Execute this if true on 2n, else return 0
      $:                   Recurse
  1  +                     Add 1

— मील की दूरी पर
स्रोत

अच्छा लगा। मैं परिणामों को इकट्ठा करने पर अटक गया था, उस प्रकार के पुनरावर्ती कार्य का उपयोग करने के बारे में नहीं सोचा था।

— कॉनर ओ'ब्रायन

4

05AB1E , 11 10 बाइट्स

स्कॉटीनेट के लिए -1 बाइट धन्यवाद

[D9ÝåË#·]N

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

[          // Start infinity loop
 D         // Duplicate current value (or input)
  9Ý       // Push [0,1,2,3,4,5,6,7,8,9]
    å      // Does each exist in the current value
     Ë#    // Break if all equal (if every digit exists)
       ·   // Else double the current value
        ]N // End loop and print the number of times through the loop

— रिले
स्रोत

-1 बाइट

— स्कॉटीनेट

@scottinet धन्यवाद! मुझे नहीं पता कि मैं कैसे चूक गया।

— रिले

@ रिले कहने जा रहा था use xलेकिन वह भी 10 ... अच्छा जवाब। सोचा xसे छुटकारा मिल जाएगा D, लेकिन यह एक ही विचार है।

— मैजिक ऑक्टोपस उर्फ़

3

पर्ल 6 ,31 28 बाइट्स (27 वर्ण)

-3 बाइट्स @ जोशुआ को धन्यवाद

{($_,2×*...*.comb.Set>9)-1}

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण: फिर भी सूची को पुन: उत्पन्न करने के लिए एक ही निर्माण। पहला तत्व दी गई संख्या ( $_) है, प्रत्येक अगला तत्व पिछले से 2 गुना है ( 2×*- हम × का उपयोग करते हैं, क्योंकि, हालांकि 2 बाइट चरित्र, यह अभी भी 1 बाइट से सस्ता है 2 * *), और हम ऐसा तब तक करते हैं जब तक कि अंतिम स्थिति *.comb.unique>9संतुष्ट न हो जाए , यानी जब संख्या में 9 से अधिक अद्वितीय अक्षर हों। (तकनीकी रूप से, हम स्ट्रिंग को अक्षरों की एक सूची के साथ तोड़ते हैं .comb, इसे एक सेट के साथ मजबूर करते हैं .Set(निश्चित रूप से, सेट में प्रत्येक तत्व केवल एक बार होता है), और 9 के साथ तुलना करते हैं, जो सेट को संख्यात्मक संदर्भ में मजबूर करता है, जो बदले में देता है। तत्वों की संख्या।)

अंत में, हम इस सूची से 1 घटाते हैं। फिर से, सूची को संख्यात्मक संदर्भ में मजबूर किया जाता है, इसलिए हम जो वापसी करते हैं, वह उस सूची की लंबाई से 1 कम है।

— Ramillies
स्रोत

आप 3 बाइट्स को बचाने के .Setबजाय उपयोग कर सकते हैं .unique।

— जोशुआ

@ जोशुआ, अच्छी बात! धन्यवाद। मैंने ऐसा कभी नहीं सोचा था।

— रामलीज

3

जावास्क्रिप्ट (ES6) + big.js , 84 74 73 70 बाइट्स

धन्यवाद @ ConorO'Brien सुझाव देकर 10 बाइट्स को बचाने के लिए big.js bignumber.js के बजाय
के लिए धन्यवाद @Rick हिचकॉक के लिए -1 बाइट
के लिए धन्यवाद @Shaggy के लिए -3 बाइट्स

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

स्ट्रिंग के रूप में इनपुट लेता है; उस बिंदु से आगे होने वाले स्वचालित वैज्ञानिक संकेतन रूपांतरण के कारण लगभग 2 ⁶⁹ तक का समर्थन करता है ।

टेस्ट स्निपेट

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))

;[617283945, 2, 66833, 1234567890, 100, 42].forEach(t=>console.log(`f(${t}) = `+f(t)))

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>

स्निपेट का विस्तार करें

अनंत सीमा, 106 88 87 84 बाइट्स

स्ट्रिंग्स में संख्याओं को परिवर्तित करते समय वैज्ञानिक संकेतन को प्रभावी रूप से अक्षम करने के लिए कॉन्फ़िगरेशन विकल्प का उपयोग करके, हमारे पास लगभग अनंत सीमा हो सकती है।

कोड स्निपेट दिखाएं

f=n=>[..."4"+2**29].every(d=>RegExp(d).test(c=Big(n)),Big.E_POS=1e9)?0:1+f(c.mul(2))

let num = `${Math.random()*1e6|0}`.repeat(100)
O.innerText=`f(\n${num}\n) = ${f(num)}`

<script src="https://cdn.rawgit.com/MikeMcl/big.js/c6fadd08/big.min.js"></script>
<pre id=O style="width:100%;white-space:normal;overflow-wrap:break-word"></pre>

स्निपेट का विस्तार करें

— जस्टिन मेरिनर
स्रोत

शायद आप big.jsBigNumber का उपयोग करके थोड़ा छोटा कर सकते हैं ?

— कॉनर ओ'ब्रायन

@ ConorO'Brien निश्चित रूप से मदद करेगा, क्योंकि विशेष रूप से newएक में वैकल्पिक है। अपडेट करेंगे, धन्यवाद!

— जस्टिन मैरिनर

एक बाइट के साथ सहेजें f=n=>[..."0123456789"].every(d=>RegExp(d).test(c=Big(n)))?0:1+f(c.mul(2))।

— रिक हिचकॉक

हमें बड़े पूर्णांकों को संभालने की आवश्यकता नहीं है, ताकि आप बड़े.जेएस को छोड़ सकें, यदि आप चाहते हैं, तो आपको 61 बाइट्स तक लाएंगे। और आप अंकों की स्ट्रिंग को बदलकर 3 बाइट्स बचा सकते हैं "4"+2**29: tio.run/##BcGxDkAwEADQb2GQO41LNBBbbb7BgbbX7AKgbhKkSu.jZSX1/…

— Shaggy

2

जेली , 12 , 11 बाइट्स

QLn⁵
ḤÇÐ¿L’

इसे ऑनलाइन आज़माएं!

जल्दी जाना है!

स्पष्टीकरण:

        # Helper link, takes one argument 'z'
Q       # The unique digits of 'z'
 L      # Length
  n     # Does not equal
   ⁵    # 10
        #
        # Main link
  Ð¿    # While <condition> is true, run <body> and return all intermediate results
        # Condition:
 Ç      #   The helper link
        # Body:
Ḥ       #   Double the input
        # Now we have a list of all the 'z's that we passed to the helper link
    L   # Return it's length
     ’  # minus one

— जेम्स
स्रोत

टेस्ट सुइट

— caird coinheringaahing

2

हास्केल , 46 बाइट्स

f n|all(`elem`show n)['0'..'9']=0|1<3=1+f(2*n)

इसे ऑनलाइन आज़माएं!

— Laikoni
स्रोत

2

जे , 43 बाइट्स

f=:(,$:@+:@{.)`[@.(9<[:#@~.10&#.inv)
<:@#@f

इसे ऑनलाइन आज़माएं!

एक अनाम फ़ंक्शन को परिभाषित करता है। संग्रह के परिणाम काफी सूक्ष्म रूप से दिखाई देते हैं। की जाँच करें यहाँ मील का बेहतर जवाब!

— कोनोर ओ ब्रायन
स्रोत

पुनरावृत्ति की कोई आवश्यकता नहीं है, उपयोग करें ^:a::1#@}.+:^:(10>#@~.@":)^:a:

— FrownyFrog

2

हास्केल, 44 बाइट्स

until(\c->all(`elem`show(n*2^c))['0'..'9'])(+1)0

— jkabrg
स्रोत

2

क्लोजर, 115 89 82 बाइट्स

-26 बाइट्स केवल एक स्ट्रिंग का उपयोग करके वर्णों की सूची (डुह, रेट्रोस्पेक्ट में) का प्रतिनिधित्व करने के लिए, और पुनरावृत्ति का उपयोग करने से बदलकर loop, जिसने मुझे कुछ अनुकूलन करने की अनुमति दी।

-7 बाइट्स से छुटकारा पाने के लिए कॉल करने के लिए bigint। जाहिरा तौर पर हम केवल इनपुट कि एक अतिप्रवाह का कारण नहीं होगा संभाल करने की जरूरत है।

#(loop[n % c 0](if(empty?(remove(set(str n))"1234567890"))c(recur(* 2 n)(inc c))))

Pregolfed:

(defn pan [num]
  (loop [n num
         cnt 0]

    ; Remove all the characters from the stringified input
    ;  that are numeric. If the result is an empty list, all
    ;  the numbers were present.
    (if (empty? (remove (set (str n)) "1234567890"))
      cnt
      (recur (* 2 n) (inc cnt)))))

— Carcigenicate
स्रोत

आप every?इसके बजाय 7 बाइट्स बचा सकते हैं empty? (remove …:#(loop[n % c 0](if(every?(set(str n))"1234567890")c(recur(* 2 n)(inc c)))))

— bfontaine

@bfontaine ओह, तुम सही हो! धन्यवाद। बाद में ठीक कर दूंगा। धन्यवाद।

— 21

2

रेटिना , 85 बाइट्स

^\d*
$&¶$&
D`.(?=.*¶)
\d{10}¶\d+|\d*¶

[5-9]
#$&
T`d`EE
T`_d#`d_`\d#
#
1
}`\d\b
$&@
@

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। रन समय के लिए थोड़ा अनुकूलित। स्पष्टीकरण:

^\d*
$&¶$&

इनपुट नंबर डुप्लिकेट करें।

D`.(?=.*¶)

पहली कॉपी में अंकों को डुप्लिकेट करें।

\d{10}¶\d+|\d*¶

यदि 10 अंक शेष हैं, तो दोनों संख्याओं को हटा दें, अन्यथा केवल पहली प्रति हटाएं। ध्यान दें कि दोनों संख्याओं को हटाने से बाकी का लूप नो-ऑप हो जाता है।

[5-9]
#$&

#बड़े अंकों से पहले रखें ।

T`d`EE

प्रत्येक अंक को डबल करें।

T`_d#`d_`\d#

कैरियों में जोड़ें।

#
1

एक प्रमुख कैरी से निपटें।

}`\d\b
$&@

@जब तक सभी 10 अंक नहीं मिलते हैं, तब तक लूप और लूप को जोड़ें ।

@जोड़े गए s की संख्या प्रिंट करें ।

— नील
स्रोत

2

एपीएल (डायलॉग यूनिकोड) , 19 + 2 = 21 बाइट्स

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵}

इसे ऑनलाइन आज़माएं!

यह एक डाइएडिक है Dfn( d irect f unctio n ), 0 को इसके बाएं तर्क के रूप में और दाएं के रूप में पूर्णांक। चूंकि इनपुट को केवल पूर्णांक माना जाता है, इसलिए मैंने 0∘बाइट काउंट के तर्क के लिए 2 बाइट्स जोड़े ।

f←बाइट गिनती में शामिल नहीं है, क्योंकि यह आवश्यक नहीं है । यह सिर्फ परीक्षण मामलों का निर्माण करना आसान बनाता है।

यह काम किस प्रकार करता है:

हेडर: मैंने एपीएल कमरे में कुछ चैटिंग के बाद बाइट की गिनती से उन लोगों को हटा दिया, क्योंकि फ़ंक्शन वही करता है जो उसे करना चाहिए था और परिणाम केवल एपीएल की आरईपीएल की डिफ़ॉल्ट सेटिंग्स के कारण गलत हैं।

⎕FR←1287F- lo R R को १२ RE- बिट दशमलव पर सेट करता है ('s APL के REPL में दशमलव के लिए कोड है)। P rint P को 34 अंको तक ⎕PP←34सेट करता है । इन दोनों की आवश्यकता है, क्योंकि बड़ी संख्या के लिए एपीएल का डिफ़ॉल्ट प्रतिनिधित्व उन्हें वैज्ञानिक संकेतन में बदल देता है (जैसे 3.14159265359E15) जो कोड को बड़े समय तक गड़बड़ करता है।

0∘{∧/⎕D∊⍕⍵:⍺⋄⍺+1∇2×⍵} ⍝ Dyadic Dfn
0∘                     ⍝ Fixes 0 as the left argument  
          :            ⍝ If
     ⎕D                ⍝ String representation of all digits [0, 9]
       ∊               ⍝ "is in"
        ⍕⍵             ⍝ String representation of the input
   ∧/                  ⍝ AND-reduction. Yields 1 (true) iff all digits are in the right argument.
           ⍺           ⍝ return the left argument
            ⋄          ⍝ Else
                 2×⍵   ⍝ Double the right arg
             ⍺+1       ⍝ increment the left arg
                ∇      ⍝ Recursively call this function with the new arguments.

— जे। सल्ल
स्रोत

2

जावा 8, 132 110 87 74 बाइट्स

n->{int c=0;for(;(n+"").chars().distinct().count()!=10;n*=2)c++;return c;}

-57 बाइट्स @ OlivierGrégoire को धन्यवाद ।

स्पष्टीकरण:

इसे यहाँ आज़माएँ। (नोट: परीक्षण का मामला 2अक्षम है क्योंकि इसे 2 ⁶⁸ पर रोकना चाहिए , लेकिन इसका आकार long2 ⁶³ -1 तक सीमित है ।)

n->          // Method with long parameter and integer return-type
  int c=0;   //  Count-integer, starting at 0
  for(;(n+"").chars().distinct().count()!=10;
             //  Loop (1) as long as the unique amount of digits in the number are not 10
    n*=2)    //    After every iteration: multiply the input by 2
   c++;      //   Increase the count by 1
             //  End of loop (1) (implicit / single-line body)
  return c;  //  Return the counter
}            // End of method

इनपुट और रेगेक्स का उपयोग करके पुराने 132 बाइट्स का उत्तर String:

n->f(n,0)int f(String n,int c){String t="";for(int i=0;i<10;t+="(?=.*"+i+++")");return n.matches(t+".*")?c:f(new Long(n)*2+"",c+1);}

इसे यहाँ आज़माएँ। (ध्यान दें: के लिए परीक्षण मामला 2अक्षम है क्योंकि यह एक StackOverflowException के कारण थोड़ा बहुत पुनरावृत्ति करता है)।

जाँच करने के लिए कुल regex अगर स्ट्रिंग में सभी 9 अंक हो जाते हैं ^(?=.*0)(?=.*1)(?=.*2)(?=.*3)(?=.*4)(?=.*5)(?=.*6)(?=.*7)(?=.*8)(?=.*9).*$, जो पूरे स्ट्रिंग के लिए एक सकारात्मक रूप-आगे का उपयोग करता है।

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

1

111 बाइट्स (यूप, बाइट काउंट एक "यूनी-डिजिटल" है; ;-)

— ओलिवियर ग्राएगोइरे

ध्यान दें कि 2 कभी भी काम नहीं करेगा क्योंकि हम 2^68पहले पंडित के रूप में उम्मीद करते हैं , लेकिन जावा में लंबे समय तक सीमित हैं 2^63-1।

— ओलिवियर ग्रेजायर

1

87 बाइट्स । धन्यवाद reduce\ _ /

— ओलिवियर ग्रेजायर

1

74 बाइट्स । यहाँ रोक ;-)

— ओलिवियर ग्रेजायर

1

@KevinCruijssen मुझे पता है कि आपने अपनी पुरानी पद्धति को समाप्त कर दिया है, लेकिन केवल यह बताना चाहते हैं कि आप सभी 10 अंकों के मिलान के लिए निम्नलिखित regex का उपयोग कर सकते हैं:(?:.*?(\d)(?!.*\1)){10}

— jaytea

1

भूसी , 10 बाइट्स

←Vö>9Lud¡D

इसे ऑनलाइन आज़माएं!

व्याख्या

        ¡D    Repeatedly double the input, collecting results in a list
 V            Return the first index where the following is true
     L          The length of
       d        the digits
      u         with duplicates removed
  ö>9           is greater than 9
←             Decrement (as Husk uses 1-indexing)

— H.PWiz
स्रोत

1

गणितज्ञ, ५ ९ ४ 46 ४ 46 ४६ ३ by बाइट्स

-9 बाइट्स जेनी_मैथी को धन्यवाद।

If[!FreeQ[DigitCount@#,0],#0[2#]+1,0]&

मैथिक्स का उपयोग करके इसे ऑनलाइन आज़माएं!

— totallyhuman
स्रोत

2

46 बाइट्स: यदि [Tr [1 ^ यूनियन @ IntegerDigits @ #] <10, # 0 [2 #] + 1,0] &

— J42161217

गणितज्ञ अनाम पुनरावर्ती कार्यों के लिए अनुमति देता है। : ओ थैंक्स!

— पूरी तरह से

2

38 बाइट्स: अगर [! FreeQ [DigitCount @ #, 0], # 0 [2 #] + 1,0] और

— J42161217

धन्यवाद! BTW, `` कोड के लिए इस्तेमाल किया जा सकता है लेकिन प्रमुख व्हाट्सएप की अनुमति नहीं है। aकाम करेंगे, लेकिन `ए नहीं करेंगे।

— पूरी तरह से

बीटीडब्ल्यू! आप इस पाद लेख का उपयोग TIOPrint/@f/@{617283945,2,66833,1234567890,100,42}

— J42161217

1

आर , 74 बाइट्स

function(x){while(!all(0:9%in%el(strsplit(c(x,""),"")))){F=F+1;x=2*x};F*1}

इसे ऑनलाइन आज़माएं! ध्यान दें कि f(2)भाषा बड़े पूर्णांक को कैसे संग्रहीत करती है, इसकी सीमाओं के कारण R गलत उत्तर देगा ।

स्पष्टीकरण: पंडितता के परीक्षण के लिए, इनपुट को एक चरित्र वेक्टर के लिए एक खाली स्ट्रिंग के साथ जोड़कर और फिर व्यक्तिगत अंकों में विभाजित किया जाता है। फिर हम जांचते हैं कि क्या सभी 0: 9 परिणामी वेक्टर में मौजूद हैं; यदि नहीं, तो हम काउंटर को बढ़ाते हैं, इनपुट को दोहराते हैं और दोहराते हैं।

काउंटर F का उपयोग करता है जो FALSE के रूप में आरंभ होता है। यह सुनिश्चित करने के लिए कि यह संख्यात्मक के लिए बाध्य है, हम लौटने से पहले एक से गुणा करते हैं।

— user2390246
स्रोत

का उपयोग कर के c(x,"")लिए एक साफ चाल हैel(strsplit(...))

— Giuseppe

1

पॉवरशेल , 70 69 बाइट्स

for($n=[bigint]$args[0];([char[]]"$n"|group).count-le9;$n*=2){$i++}$i

इसे ऑनलाइन आज़माएं!

(लगभग दो बार जब तक अजगर जवाब देता है: - \)

इनपुट लेता है $args[0], इसे एक के रूप में रखता है [bigint], इसे बचाता है $n। एक forपाश में प्रवेश करता है। प्रत्येक पुनरावृत्ति हम इस बात की जाँच करते हैं कि क्या $number को एक स्ट्रिंग में परिवर्तित किया गया है, तो एक charऐरे में, जब, Group-Objectd एक साथ, की .count -lतुलना में एक eयोग्यता है 9। मतलब, यह एकमात्र तरीका है कि यह 10 के बराबर है यदि प्रत्येक संख्या 1234567890का कम से कम एक अंक मौजूद है। यदि हाँ, तो हम लूप से बाहर निकलते हैं। यदि नहीं, तो हम $n*=2और जारी रखेंगे। लूप के अंदर प्रत्येक पुनरावृत्ति, हम केवल वृद्धि कर रहे हैं $i। जब हम लूप से बाहर निकलते हैं, हम बस आउटपुट करते हैं $i।

ध्यान दें कि इनपुट के लिए 1234567890जहां हर अंक पहले से ही है, यह कुछ भी आउटपुट नहीं करेगा, जो कि PowerShell में एक गलत मूल्य है, और 0जब एक के रूप में डाला जाता है तो बराबर होता है [int]। यदि यह ठीक नहीं है, तो हम +आउटपुट के सामने केवल $iएक पूर्णांक के रूप में स्पष्ट रूप से डालने के लिए डाल सकते हैं।

रोलाँ हीथ को बाइट धन्यवाद दिया।

— AdmBorkBork
स्रोत

आप ne10 के बजाय le9 का उपयोग कर सकते हैं? मैं पावरशेल से परिचित नहीं हूं, लेकिन यह एक बाइट बचा सकता है।

— रोलैंड हीथ

@ रोलैंडहाइट वास्तव में; अच्छा निर्णय। धन्यवाद!

— AdmBorkBork

0

अजगर , 11 बाइट्स

f>l{`.<QT9Z

टेस्ट सूट ।

पहली प्राकृतिक संख्या Tजहां input << Tआवश्यकता को पूरा करती है।

— लीक नन
स्रोत

0

पर्ल 5 , 52 + 1 (-पी) = 53 बाइट्स

$/=10;for$i(0..9){$/-=/$i/}$_*=2;++$\;$/&&redo}{$\--

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

0

पर्ल, 43 + 1 बाइट्स

for$x(0..9){$_*=2,++$\,redo LINE if!/$x/}}{

-pझंडे का उपयोग करना । यह ऊपर Xcali द्वारा प्रदान समाधान पर बनाता है।

0

स्विफ्ट 4 , 111 बाइट्स

func p(_ x:Int,_ c:Int=0)->Int{if !(String(Set(String(x)).sorted())=="0123456789"){return p(x*2,c+1)};return c}

नोट: अतिप्रवाह के कारण x = 2 के लिए काम नहीं करेंगे।

स्पष्टीकरण - इनपुट x को पहले स्ट्रिंग में टाइपकास्ट किया गया है। फिर सेट () दोहराए जाने वाले वर्णों को निकालता है। फिर उसे परिणाम से मिलान करने के लिए हल किया जाता है। यदि यह मेल नहीं खाता है, तो x युगल है और काउंटर बढ़ा हुआ है।

— नरेश
स्रोत

1

यह wok नहीं है क्योंकि var 64 बिट्स है। एक ही समस्या के साथ कई अन्य जवाब।

— नरेश

@FunkyComputerMan यह उन मामलों के लिए चुनौतियों को प्रतिबंधित करने के लिए आम बात है, जहां इनपुट, आउटपुट और / या मध्यवर्ती की पसंद के एल्गोरिथ्म भाषा की मूल संख्या प्रकार में फिट होते हैं। कम से कम इनपुट और आउटपुट के लिए, यह आमतौर पर माना जाता है भले ही चुनौती विनिर्देश में नहीं कहा गया हो।

— user2390246

अगर आपको लगता है कि इसे ओपी के साथ लाने की अनुमति दी जानी चाहिए। यह आम बात हो सकती है, लेकिन ओपी ने विशेष रूप से इसकी अनुमति नहीं दी है और

— टेस्टकेस

1

@FunkyComputerMan वास्तव में, मैंने उन उत्तरों की अनुमति दी जो भाषा की सीमा के बाहर संख्या को संभाल नहीं सकते हैं, लेकिन लगता है कि शैगी ने उस बारे में पूछने वाली टिप्पणी को हटा दिया है। यह उत्तर ठीक है।

— caird coinheringaahing

0

माणिक, 46 45 39 38 बाइट्स

def f n;n.digits.uniq[9]?0:1+f(n*2)end

इसे ऑनलाइन आज़माएं!

अपडेट:

के def f n;बजाय का उपयोग करके -1 def f(n);।
के …[9]बजाय का उपयोग करके -6….size==10
-1 अर्धविराम को हटाकर

— bfontaine
स्रोत

0

जाप , 15 बाइट्स

LÆ*2pXÃbì_â Ê¥A

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U।

LÆ    Ã

से पूर्णांकों की एक सरणी बनाने 0के लिए 99और एक समारोह जहां के माध्यम से प्रत्येक पारित Xवर्तमान तत्व है।

*2pX

Uकी शक्ति से 2 गुणा बढ़ा X।

निम्नलिखित फ़ंक्शन से गुजरने पर पहले तत्व tha रिटर्न का इंडेक्स प्राप्त करें।

ì_â

अंकों की एक सरणी में विभाजित करें और डुप्लिकेट को हटा दें।

Ê¥A

सरणी की लंबाई प्राप्त करें और समानता के लिए जांच करें 10।

वैकल्पिक, 15 बाइट्स

@*2pX)ìâ sÊ¥A}a

कोशिश करो

व्याख्या

पूर्णांक का निहित इनपुट U।

@            }a

इसके साथ शुरू करते हुए 0, पहले नंबर को लौटाएं Xजो वर्तमान फ़ंक्शन के साथ, निम्न फ़ंक्शन से गुजरने पर वापस लौटे ।

*2pX)

ऊपर, Uकी शक्ति से 2 से गुणा करें X।

ìâ

अंकों की एक सरणी में विभाजित करें, डुप्लिकेट को हटा दें और एक पूर्णांक में फिर से जोड़ दें।

sÊ

एक स्ट्रिंग में कनवर्ट करें, लंबाई प्राप्त करें और एक पूर्णांक में परिवर्तित करें।

¥A

के साथ समानता के लिए जाँच करें 10।

— झबरा
स्रोत

0

QBIC , 48 बाइट्स, एन.सी.

{q=1[z|q=q*instr(!:$,!a-1$)]~q>0|_Xp\p=p+1┘b=b*2

यह काम करना चाहिए, सिद्धांत रूप में। हालाँकि, व्यवहार में यह विफल रहता है क्योंकि QBasic वैज्ञानिक अंकन के लिए दस अंकों की संख्या (सभी अंकों को प्राप्त करने के लिए कम से कम) की आवश्यकता होती है ... मैंने इसे इसके कारण गैर-प्रतिस्पर्धी के रूप में चिह्नित किया है।

व्याख्या

{             DO ad infinitum
q=1           set q to 1
[z|           FOR a = 1 to 10
q=q*instr     multiply q by the position
(!:$             - in 'b' (read from cmd line at start) cast to string (! ... $)
,!a-1$)          - of the number a-1 [0-9] cast to string
]             NEXT
~q>0          IF any character was not found, instr gave a 0. If q != 0 all digits were present
|_Xp          THEN quit, printing  p (is 0 at start)
\p=p+1        ELSE increase step counter p
┘b=b*2        and double 'b'

— steenbergh
स्रोत

0

जीएनयू डीसी, 61 बाइट्स

इनपुट को स्टैक के ऊपर से कॉपी किया जाता है (जो अन्यथा खाली होना चाहिए); आउटपुट स्टैक के शीर्ष पर धकेल दिया जाता है।

[I~1r:ad0<s]ss[d1+r;a1=p]sp[d2*lfx]sh[0Sadlsxlpx11!=h]dsfxz1-

व्याख्या

हम सरणी चर का उपयोग करते हैं a, a[d]यदि अंक dमौजूद है, तो 1 को संग्रहीत करना , अन्यथा वापस 0 पर गिरना। हम ~एक आदेश में भागफल और शेष प्राप्त करने के लिए GNU एक्सटेंशन का उपयोग करते हैं ।

# populate a[0-9] from the digits
[I~1r:ad0<s]ss

# check pandigit
# return 1 more than lowest unset element of a[]
# start with stack=0
[d1+r;a1=p]sp

# Test for pandigit; double and repeat if needed
[dd+lfx]sh
[0Sadlsxlpx11!=h]dsfx

# We left one value on the stack for each doubling, plus the original
z1-

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

परीक्षा

for i in 617283945 2 66833 1234567890 100 42
do
    printf '%s => ' $i
    dc -e $i \
       -e '[I~1r:ad0<s]ss[d1+r;a1=p]sp[dd+lfx]sh[0Sadlsxlpx11!=h]dsfxz1-' \
       -e p
done

617283945 => 1
2 => 67
66833 => 44
1234567890 => 0
100 => 51
42 => 55

— टोबी स्पाईट
स्रोत

0

REXX, 57 बाइट्स

arg n
do b=0 while verify(0123456789,n)>0
  n=n*2
  end
say b

— idrougge
स्रोत

0

क्यू / केडीबी + , ३३ बाइट्स

समाधान:

(#)1_{x*2 1 min!:[10]in 10 vs x}\

उदाहरण:

q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[100]
51
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[1234567890]
0
q)(#)1_{x*2 1 min!:[10]in 10 vs x}\[42]
55

स्पष्टीकरण:

सभी बाइट्स समानता में हैं, इसे थोड़ा और नीचे करने में सक्षम हो सकते हैं। क्यू के scanक्रिया विशेषण का उपयोग करता है :

count 1_{x*2 1 min til[10] in 10 vs x}\ / ungolfed solution
        {                            }\ / scan over this lambda until it yields same result
                              10 vs x   / convert to base 10
                           in           / left list in right list, returns boolean list
                   til[10]              / range 0..9
               min                      / return the minimum of the list, 0 or 1
           2 1                          / list (2;1) indexed into with 0 or 1
         x*                             / return x multiplied by either 2 or 1
      1_                                / 1 drop, drop one element from front of list
count                                   / count the length of the list

टिप्पणियाँ:

अगर हम kसंकेत देना छोड़ दें तो हमारे पास 25 बाइट का घोल हो सकता है। वर्णों की सूची में संख्या को परिवर्तित करता है:

q)\
  #1_{x*2 1@&/($!10)in$$x}\[100]
51

— streetster
स्रोत

पंडितलाल दुबलिंग

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

पायथन 3 , 39 बाइट्स

जे , 24 23 बाइट्स

व्याख्या

05AB1E , 11 10 बाइट्स

पर्ल 6 ,31 28 बाइट्स (27 वर्ण)

जावास्क्रिप्ट (ES6) + big.js , 84 74 73 70 बाइट्स

टेस्ट स्निपेट

अनंत सीमा, 106 88 87 84 बाइट्स

जेली , 12 , 11 बाइट्स

हास्केल , 46 बाइट्स

जे , 43 बाइट्स

हास्केल, 44 बाइट्स

क्लोजर, 115 89 82 बाइट्स

रेटिना , 85 बाइट्स

एपीएल (डायलॉग यूनिकोड) , 19 + 2 = 21 बाइट्स

यह काम किस प्रकार करता है:

जावा 8, 132 110 87 74 बाइट्स

भूसी , 10 बाइट्स

व्याख्या

गणितज्ञ, ५ ९ ४ 46 ४ 46 ४६ ३ by बाइट्स

आर , 74 बाइट्स

पॉवरशेल , 70 69 बाइट्स

अजगर , 11 बाइट्स

पर्ल 5 , 52 + 1 (-पी) = 53 बाइट्स

पर्ल, 43 + 1 बाइट्स

स्विफ्ट 4 , 111 बाइट्स

माणिक, 46 45 39 38 बाइट्स

जाप , 15 बाइट्स

व्याख्या

वैकल्पिक, 15 बाइट्स

व्याख्या

QBIC , 48 बाइट्स, एन.सी.

व्याख्या

जीएनयू डीसी, 61 बाइट्स

व्याख्या

परीक्षा

REXX, 57 बाइट्स

क्यू / केडीबी + , ३३ बाइट्स