13

Bochnia * में स्थित सबसे पुरानी पोलिश नमक खदान, वर्ष 1248 में शुरू हुई थी, जिसे हम जादुई संख्या मान सकते हैं । हम देख सकते हैं कि यह घातांक के अनुक्रम से 4 अंकों के बराबर है $2^0\textrm{, }2^1\textrm{, }2^2\textrm{ and }2^3$ :।

जैसा कि तारीख वास्तव में अनुक्रम से 4 अंक है, हम इसे अधिक लंबा कर सकते हैं। जब तक हम अनंत तक नहीं पहुंच जाते, हम इस प्रक्रिया को दोहरा सकते हैं। अनुक्रम इस तरह दिखेगा, अगर हम इसे संख्या तक सीमित करते हैं2048

124816326412825651210242048

इसे थोड़ा बेहतर बनाने के लिए, हम संख्याओं को अलग कर सकते हैं:

1|2|4|8|16|32|64|128|256|512|1024|2048

आइए, तिथि की तुलना में एक कस्टम, लंबे अनुक्रम का प्रयास करें। मान लीजिए, हम चाहते हैं कि इसके 5 अंक हों - एक से अधिक संभावनाएं हैं:

24816
81632
64128

या 3 अंक वाले:

124
248
816

हम इसमें 3 अंकों की संख्या भी जोड़ सकते हैं, लेकिन मान लें कि, एक अनुक्रम में कम से कम दो संख्याएँ होनी चाहिए ।

^{* अंग्रेजी विकिपीडिया पर इस बारे में कोई जानकारी नहीं है। यदि आप पोलिश संस्करण में प्रवेश करते हैं - तो वहाँ है। यदि आप खदान पर जाते हैं, तो श्रमिक आपको यह भी बताएंगे कि यह 1248 में शुरू हुआ था।}

चुनौती

आधार के रूप में 2 से ऊपर के उदाहरणों में एक प्रतिपादक अनुक्रम बनाएं।

सीमा 2-27 से एक संख्या को देखते हुए, इनपुट के बराबर अंकों की मात्रा के साथ अनुक्रम के सभी संभव भागों (2048 एक या बड़ा यदि आप चाहते हैं) का उत्पादन करें। आप एक संख्या में कटौती नहीं कर सकते हैं, इसलिए आउटपुट 481अमान्य है, क्योंकि 16 आधे में कट जाता है।

नियम:

मानक खामियों को मना किया जाता है।
आप मान सकते हैं कि इनपुट सीमा के अंदर एक संख्या है।
आपका प्रोग्राम रेंज (28+) से बड़े इनपुट्स को स्वीकार कर सकता है, लेकिन इससे स्कोर में वृद्धि / कमी नहीं होगी।
आउटपुट में स्पेस को नजरअंदाज किया जाता है। आप आउटपुट को पसंद 124या पसंद कर सकते हैं 4 8 16।
विभिन्न संभावनाओं को सूची से किसी भी चरित्र द्वारा अलग किया जाना चाहिए: ,./|या एक पंक्ति फ़ीड।
आप एक सरणी के रूप में आउटपुट कर सकते हैं।
हर संभावना में कम से कम 2 अलग-अलग संख्याएं शामिल होनी चाहिए ।
आपको अनुक्रम का एक भाग आउटपुट करना होगा , आप उन संख्याओं को नहीं मिला सकते हैं जो एक दूसरे के बगल में नहीं हैं, जैसे 14:।
हार्डकोडेड आउटपुट की अनुमति नहीं है, हालांकि, आप एक स्ट्रिंग / संख्या / सरणी को पूर्ण अनुक्रम वाले हार्डकोड कर सकते हैं।
इनपुट 27 को पूर्ण 2048 अनुक्रम वापस करना चाहिए।
जैसा कि पहले ही उल्लेख किया गया है, संख्या में कटौती न करें । पूर्व। 16रहना चाहिए 16- आप का उपयोग नहीं कर सकते 481- आप का उपयोग करना चाहिए 4816।
संपादित करें: मैंने वहां कुछ गलत कहा होगा; 2048 अंतिम संख्या है जिसे आपके कार्यक्रम का समर्थन करना चाहिए, आप बड़े इंटों के लिए समर्थन जोड़ सकते हैं।

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

इनपुट: 2

12, 24, 48

इनपुट: 3

124, 248, 816

इनपुट: 4

1248, 4816, 1632, 3264

इनपुट: 5

24816, 81632, 64128

इनपुट: 27

124816326412825651210242048

और बाद में संख्या ...

अगर मैंने परीक्षण के किसी भी मामले में गलती की है, तो मुझे प्रश्न बताएं या संपादित करें।

यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf sequence number-theory

— लाल तिपतिया घास
स्रोत

1

तो यह केवल आधार के रूप में 2 के साथ है, सही है? क्या आप प्रश्न में स्पष्ट कर सकते हैं? मुझे यकीन नहीं है कि यह "एक्सपेंशन के अनुक्रम" द्वारा निहित है, लेकिन अगर यह है, तो मुझे यकीन है कि मेरे जैसे लोग हैं जो यह नहीं जानते हैं।

— कोल

@cole वास्तव में, हाँ, यह केवल 2 के साथ है। उल्लेख करने के लिए धन्यवाद!

— RedClover

1

क्या आउटपुट को न्यूलाइन द्वारा अलग किया जा सकता है?

— एच। वाइज

1

कोई चिंता नहीं; जैसा मैंने कहा, मैं इसे आगे बढ़ा रहा था। कुछ चुनौती लेखक आउटपुट फॉर्मेट पर अविश्वसनीय रूप से लचीले हो सकते हैं , इसलिए बाइट या 2 के लिए, यह मूल्य के लायक है;) (नोट: यह सुझाव के रूप में व्याख्यायित नहीं किया जाना चाहिए!)

— झबरा

1

इंट्रो में, आपको पोलिश को कैपिटलाइज़ करना चाहिए। "पॉलिश" एक अलग अंग्रेजी शब्द है ।

— पीटर कॉर्ड्स

7

05AB1E , 12 11 10 बाइट्स

अनुक्रम का समर्थन करता है 2^95 = 39614081257132168796771975168

₃ÝoŒʒg≠}Jù

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

व्याख्या

₃Ý            # push range [0 ... 95]
  o           # raise 2 to the power of each
   Œ          # get a list of all sublists
    ʒ         # filter, keep elements that satisfy:
     g        # length
      ≠       # false (not equal to 1)
       }      # end filter
        J     # join each
         ù    # keep numbers of length matching the input

1 बाइट की बदौलत एरिक आउट्रिकोलर
के लिए धन्यवाद 1 बाइट रिले के लिए धन्यवाद

— Emigna
स्रोत

X›हो सकता है≠

— एरिक आउटगॉल्फ

@EriktheOutgolfer: ओह हाँ। मैं हमेशा यह भूल जाता हूं कि एक अब मौजूद है। धन्यवाद :)

— एमिग्ना

हो सकता Y₃Ýmहै ₃Ýo?

— रिले

@ रिले: हां। मेरे पास पहले भी था, लेकिन किसी कारण से मैंने इसे बदल दिया होगा। धन्यवाद :)

— Emigna

अब कोड की कोशिश कर रहा हूं (चुनौती समाप्त होने के बाद बहुत देर हो चुकी है) ... और आपका समाधान मेरे लिए बहुत सारे खाली सरणियों को लौटाना लगता है ... क्या मैं कुछ गलत कर रहा हूं?

— RedClover

6

पायथ, 22 21 20 17 बाइट्स

fqQlTjLkt#.:^L2yT

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

व्याख्या

fqQlTjLkt#.:^L2yT
            ^L2yT  Get the powers of 2 up to 2^20
        t#.:       Get all consecutive sequences of at least 2
     jLk           Concatenate each
fqQlT              Get the ones whose length is the input

21 बाइट्स:fqQlTmjkdftlT.:m^2d12

— श्री एक्सकोडर

1

20 बाइट्स -fqQlTjLkftlT.:m^2d12

— श्री एक्सकोडर

19 बाइट्स - fqQlTjLkftT.:m^2d12

— Jakube

18 बाइट्स - fqQlTjLkftT.:^L2yT

— Jakube

1

17 बाइट्स - fqQlTjLkt #।: ^ L2yT

— Jakube

4

जेली , 19 18 16 बाइट्स

^{अब एक छोटा समाधान हो सकता है कि हम किसी भी कट-ऑफ का उपयोग कर सकते हैं (केवल 2048 में नहीं), हालांकि विनिर्देश में इस बदलाव ने 32768 के कट-ऑफ पर जाकर इस कार्यान्वयन से एक बाइट को बचाने की अनुमति दी है

। ..}

-2 बाइट्स द एरिक टू द आउटोलफ़र ( Vफ़िल्टर और कसने के निहित सही तर्क की अनुमति देने का उपयोग ) -
हां, यह अब उनके अक्षम के समान है; उसके पास जाओ !

⁴Ḷ2*Ẇṫ17VDL$⁼¥Ðf

एक मोनडिक लिंक एक नंबर ले रहा है और संख्याओं की सूची लौटा रहा है।

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

कैसे?

⁴Ḷ2*Ẇṫ17VDL$⁼¥Ðf - Link: number, n        e.g. 3
⁴                - literal sixteen             16
 Ḷ               - lowered range               [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15]
  2              - literal two                 2
   *             - exponentiate                [1,2,4,8,16,32,...,32768]
    Ẇ            - all sublists                [[1],[2],...,[1,2],[2,4],...,[1,2,4],...]
      17         - literal seventeen           17
     ṫ           - tail from index             [[1,2],[2,4],...,[1,2,4],...]]
        V        - evaluate as Jelly code      [12,24,...,124,...]
              Ðf - filter keep:
             ¥   -   last two links as a dyad
           $     -     last two links as a monad:
         D       -       decimal list (of entry) (i.e. 816 -> [8,1,6] or 24 -> [2,4])
          L      -       length                  (i.e. 816 -> 3, or 24 -> 2)
            ⁼    -   equals (n)                  (i.e. 816 -> 1, or 24 -> 0)
                 - ...resulting in             [816, 124, 248]

— जोनाथन एलन
स्रोत

1

क्या यह भी आपके जैसा ही है? (कृपया ईमानदार

— रहें

पर्याप्त रूप से मैं बस उपयोग करने की कोशिश कर रहा था Vऔर यह 1000 के बजाय 16 के लिए काम करेगा ⁴Ḷ2*Ẇṫ17VDL$⁼¥Ðf:।

— जोनाथन एलन

मैं सबसे अधिक के लिए जा रहा हूँ: पी

— एरिक आउटगॉल्फ

@EriktheOutgolfer वे अब समान हो सकते हैं, लेकिन मैं मन का हूं कि हम दोनों को उन्हें बनाए रखना चाहिए मुझे यकीन है कि आप स्वतंत्र रूप से आपके साथ आए हैं और मुझे यकीन है कि मुझे भी eval ट्रिक मिल गई होगी (क्योंकि मैं बिल्कुल वही देख रहा था , बस सही ढंग से प्राप्त करने के लिए आवश्यक)।

— जोनाथन एलन

@EriktheOutgolfer मैंने यह अनुमान लगाया है कि आप पुरुष हैं, और इस तरह के रूप में संदर्भित किया जाना पसंद करते हैं, लेकिन वास्तव में या तो तथ्य के रूप में नहीं जानते हैं; मुझे पता है अगर आप एक अलग सर्वनाम पसंद करते हैं!

— जोनाथन एलन

4

पर्ल 6 , 62 59 बाइट्स

{grep *.comb==$_,map {[~] 2 X**[...] $_},combinations 12,2}

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

— nwellnhof
स्रोत

4

जाप , 22 20 19 16 बाइट्स

इनपुट का समर्थन करता है, 639लेकिन बाद में अनुक्रम में अंतराल दिखाई देने लगते हैं 234(समर्थित इनपुट श्रेणियों की पूरी सूची यहां देखें )। तार की एक सरणी आउटपुट।

IÆIo!²ãX m¬lUÃ¤c

झसे आज़माओ

I(64) के साथ प्रतिस्थापित किया जा सकता है L(100) लेकिन हम वैज्ञानिक संकेतन और सटीक अशुद्धियों में शामिल हो रहे हैं। उन लोगों को छानना, जाहिर है, बाइट की गिनती बढ़ाते हैं और केवल अधिकतम इनपुट बढ़ाते हैं 736।

                     :Implicit input of integer U
I                    :64
 Æ                   :Map each X in [0,64)
  Io                 :  Range [0,64)
    !²               :  Raise 2 to the power of each
      ãX             :  Subsections of length X
         m           :  Map
          ¬          :    Join
           lU        :  Filter elements of length U
             Ã       :End map
              ¤      :Slice off the first 2 elements
               c     :Flatten

— झबरा
स्रोत

3

पायथन 2 , 105 बाइट्स

lambda l,r=range:[x for x in[''.join(`2**n`for n in r(i,j+2))for i in r(13)for j in r(i,11)]if len(x)==l]

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

— छड़ी
स्रोत

3

हस्क , 18 17 बाइट्स

आउटपुट को न्यूलाइन्स द्वारा अलग किया जाता है

fo=⁰LmṁsftQ↑12¡D1

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

कैसे?

           ↑12¡D1    The sequence [1,2,4...2048]
              ¡      Repeatedly apply function, collecting results in a list
               D     double
                1    initially applying to 1
           ↑12       Take the first 12 elements
          Q          Get all sublists
        ft           With a length greater than 1
     mṁs             Convert each list into a string, e.g [4,8,16] -> "4816"
fo=⁰L                Keep only those whose length is equal to the input

— H.PWiz
स्रोत

3

जेली , 16 बाइट्स

ȷḶ2*ẆṫȷḊVDL$⁼¥Ðf

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

नोट: बहुत अक्षम है। संख्याओं की सूची लौटाता है।

— आउटगोल्फ को एरिक करें
स्रोत

Tio इस कोड को पार्स नहीं कर पा रहा है ... यह हमेशा 60 सेकंड से अधिक होता है ...

— RedClover

1

@Soaku s (यानी ) ऊपरी (कम ऊपरी सीमा) के साथ बदलने काȷ100020 प्रयास करें ।

— 18

1

@ सोकू यह सिद्धांत में काम करता है - यह सिर्फ समय से बाहर है क्योंकि यह बहुत अक्षम है।

— जोनाथन एलन

1

@ सोकू मेरा मतलब मेरी टिप्पणी पर था। मैंने उन्हें पहले ही बदल दिया है, और वहाँ आउटपुट है [12, 24, 48]।

— आउटगॉल्फ

1

@Soaku अगर आप बिना अतिरिक्त लागत के सबसे ज्यादा जा सकते हैं, तो क्यों नहीं? ;)

— एरिक आउटग्राफर

3

जावास्क्रिप्ट (ईएस 7), 102 100 बाइट्स

सभी मिलान उप-अनुक्रमों के साथ प्रिंट करता है alert()।

l=>[...1e11+''].map((_,k,a)=>a.map((_,x)=>(s=(g=n=>x<=k|n<k?'':g(n-1)+2**n)(x)).length-l||alert(s)))

डेमो

एनबी : यह स्निपेट परिणामों को बफर कर रहा है और उपयोगकर्ता-मित्रता के लिए कंसोल पर प्रिंट कर रहा है।

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

let f =

l=>[...1e11+''].map((_,k,a)=>a.map((_,x)=>(s=(g=n=>x<=k|n<k?'':g(n-1)+2**n)(x)).length-l||alert(s)))

alert = s => res += ' ' + s;

for(l = 2; l <= 27; l++) {
  res = '';
  f(l);
  console.log('L = ' + l + ' -->' + res);
}

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

— Arnauld
स्रोत

3

हास्केल , 72 67 बाइट्स

f n=[s|i<-[0..99],j<-[i+1..99],s<-[show.(2^)=<<[i..j]],length s==n]

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

लाईकोनी के लिए धन्यवाद 5 बाइट्स बचाए

मैंने एक सीमा का उपयोग किया है 99क्योंकि 2^99इसकी लंबाई है > 27।

— jferard
स्रोत

यह 27 के इनपुट के लिए अतिरिक्त मामले लौटा रहा है।

— जोनाथन एलन

आप 99 को 11 के साथ बदल सकते हैं, इसलिए यह अधिक मान्य हो जाता है। हालाँकि, मैंने यह नहीं बताया कि संख्या> 2048 अमान्य हैं। मैंने केवल कहा था, कि २०४ 20 न्यूनतम सीमा है।

— RedClover

@JonathanAllan मुझे लगता है कि यह अभी भी सही है: "2048 एक या बड़ा यदि आप चाहते हैं" तो मैंने 633825300114114700748351602688 अनुक्रम लिया, क्योंकि यह गारंटी देता है कि कोई अन्य समाधान नहीं होगा (सीमा 2-27 में)। वास्तव में, मुझे लगता है कि 45 की सीमा पर्याप्त होगी, क्योंकि length$(show$2^44)++(show$2^45)==28।

— jferard

@ जेरार्ड जिसे वास्तव में आपके उत्तर के बाद संपादित किया गया था (यह वास्तव में "पहले 2048 तक सीमित" कहा गया था)। मैं इस मामले में भी मुझे छोटा कर सकता हूं।

— जोनाथन एलन

1

@JonathanAllan हाँ, मुझे वास्तव में एहसास हुआ कि प्रश्न में कुछ नियम गलत हैं और इस एवर को पोस्ट करने के बाद भ्रामक हैं।

— RedClover

2

गणितज्ञ, 122 बाइट्स

(s=#;FromDigits@F[f/@#]&/@Select[Subsequences[Array[2^#&,99,0]],l@#>1&&(l=Length)@(F=Flatten)[(f=IntegerDigits)/@#]==s&])&

इनपुट

[27]

उत्पादन

{879609302220817592186044416, 134217728268435456536870912, 524288104857620971524194304, 163843276865536131072262144, 204840968192163843276865536, 256512102420484096819216384, 641282565121024204840968192, 163264128256512102420484096, 124816326412825651210242048}

Input [1000]
Output  1441151880758558722882303761517117445764607523034234881152921504606846976230584300921369395246116860184273879049223372036854775808184467440737095516163689348814741910323273786976294838206464147573952589676412928295147905179352825856590295810358705651712118059162071741130342423611832414348226068484722366482869645213696944473296573929042739218889465931478580854784377789318629571617095687555786372591432341913615111572745182864683827230223145490365729367654460446290980731458735308812089258196146291747061762417851639229258349412352483570327845851669882470496714065569170333976494081934281311383406679529881638685626227668133590597632773712524553362671811952641547425049106725343623905283094850098213450687247810566189700196426901374495621121237940039285380274899124224247588007857076054979824844849517601571415210995964968969903520314283042199192993792198070406285660843983859875843961408125713216879677197516879228162514264337593543950336158456325028528675187087900672316912650057057350374175801344

— J42161217
स्रोत

2

सी, 170 बाइट्स

i,j;f(n){char t[99],s[12][5]={"1"};for(i=j=1;i<12;)sprintf(s+i++,"%d",j*=2);for(i=0;i<12;++i,strlen(t)-n||j>1&&puts(t))for(j=*t=0;strlen(t)<n&&j+i<12;)strcat(t,s+i+j++);}

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

unrolled:

i,j;
f(n)
{
    char t[99], s[12][5] = {"1"};
    for (i=j=1; i<12;)
        sprintf(s+i++, "%d", j*=2);
    for (i=0; i<12; ++i, strlen(t)-n || j>1 && puts(t))
        for (j=*t=0; strlen(t)<n && j+i<12;)
            strcat(t, s+i+j++);
}

— Steadybox
स्रोत

1

आर , 99 बाइट्स

function(n)for(i in 1:11)for(j in i:11+1)if(sum(nchar(x<-2^(0:11))[i:j])==n)cat(x[i:j],"\n",sep="")

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

— flodel
स्रोत

1

पर्ल 5 , 76 बाइट्स

कोड + 1 के लिए 75 बाइट्स -a

for$i(0..10){$/='',(map$/.=2**$_,$i..$_)&&$F[0]-length$/||say$/for$i+1..11}

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

— Xcali
स्रोत

1

जाप, 24 बाइट्स

उत्थान मत करो

अब मुझे एहसास हुआ कि यह @Shaggy के रूप में करने का एक ही तरीका है, बस कम गोल्फ वाला। (क्या मुझे जवाब निकाल देना चाहिए?)

इस प्रश्न को पोस्ट करने के कुछ समय बाद, मैंने अपनी पहली गोल्फ भाषा सीखी। इस वजह से, मैंने यहां अपनी किस्मत आजमाने का फैसला किया।

2oI,@IÆ2pYÃãX ®q
c f_Ê¥N

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

स्कोर सबसे अच्छा नहीं है, यह भी अच्छा नहीं है, लेकिन मुझे ऐसा करने में बहुत समय लगा ।-

मैं बहुत अधिक स्कोर खो देता हूं, क्योंकि कुछ कारणों से, ã केवल x लंबाई सरणियों को वापस कर सकता है ... यह ~ 10 बाइट्स भी हो सकता है, यदि ऐसा नहीं है।

स्पष्टीकरण:

2oI,@IÆ2pYÃãX ®q # All 2^ combinations:
2oI              # Range 2-64
   ,@            # Map (X as index)
     IÆ          #   Range 0-64, map (Y as index)
       2pY       #   2^Y
          Ã      #   End function (map)
                 #   this = array of powers.
           ãX    #   All combinations with X length
              ®q # Join then (arrays to numbers)

c f_Ê¥N          # Filter length to input:
c                # Flatten
  f_             # Filter
    Ê            #  Length
     ¥           #  ==
      N          #  Parsed input

— लाल तिपतिया घास
स्रोत

0

रूबी , 94 बाइट्स

->n{a=*b=1;a<<b*=2until b>3**n;(2..n).flat_map{|x|a.each_cons(x).map &:join}.grep /^.{#{n}}$/}

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

— जीबी
स्रोत

घातांक अनुक्रम

चुनौती

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

05AB1E , 12 11 10 बाइट्स

पायथ, 22 21 20 17 बाइट्स

व्याख्या

जेली , 19 18 16 बाइट्स

कैसे?

पर्ल 6 , 62 59 बाइट्स

जाप , 22 20 19 16 बाइट्स

पायथन 2 , 105 बाइट्स

हस्क , 18 17 बाइट्स

कैसे?

जेली , 16 बाइट्स

जावास्क्रिप्ट (ईएस 7), 102 100 बाइट्स

डेमो

हास्केल , 72 67 बाइट्स

गणितज्ञ, 122 बाइट्स

सी, 170 बाइट्स

आर , 99 बाइट्स

पर्ल 5 , 76 बाइट्स

जाप, 24 बाइट्स

स्पष्टीकरण:

रूबी , 94 बाइट्स