शर्तें

एक कीड़ा nonnegative पूर्णांक की कोई भी सूची है, और इसके सबसे दाहिने (यानी, अंतिम ) तत्व को सिर कहा जाता है । यदि सिर 0 नहीं है, तो कृमि में एक सक्रिय खंड होता है जिसमें तत्वों का सबसे लंबा खंड होता है जिसमें सिर शामिल होता है और इसके सभी तत्व कम से कम सिर के समान बड़े होते हैं । कम सक्रिय खंड सिर 1. उदाहरण के लिए द्वारा कम कर के साथ सक्रिय खंड है, कीड़ा 3 1 2 3 2सक्रिय खंड है 2 3 2कम सक्रिय खंड है, और 2 3 1।

विकास के नियम

एक कीड़ा कदम-दर-कदम इस प्रकार विकसित होता है:

चरण t (= 1, 2, 3, ...) में,
यदि सिर 0 है: सिर को हटा दें
: सक्रिय सेगमेंट को t + 1 से कम सक्रिय सेगमेंट की संक्षिप्त प्रतियों द्वारा प्रतिस्थापित करें।

तथ्य : कोई भी कीड़ा अंततः खाली सूची में विकसित होता है , और ऐसा करने के लिए चरणों की संख्या कीड़ा का जीवनकाल है ।

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

उदाहरण (कोष्ठक में सक्रिय खंड)

कीड़ा: 0,1

step    worm
         0(1)
1        0 0 0
2        0 0 
3        0
4           <- lifetime = 4

कीड़ा: 1,0

step    worm
         1 0
1       (1)
2        0 0 0
3        0 0 
4        0
5           <- lifetime = 5

कीड़ा: 1,1

step    worm
        (1 1)
1        1 0 1 0 
2        1 0(1) 
3        1 0 0 0 0 0
4        1 0 0 0 0
5        1 0 0 0
...
8       (1) 
9        0 0 0 0 0 0 0 0 0 0
10       0 0 0 0 0 0 0 0 0
...
18       0
19           <- lifetime = 19

इल्ली: २

step    worm
        (2)
1       (1 1)
2        1 0 1 0 1 0
3        1 0 1 0(1)
4        1 0 1 0 0 0 0 0 0
5        1 0 1 0 0 0 0 0
6        1 0 1 0 0 0 0
...
10       1 0(1)
11       1 0 0 0 0 0 0 0 0 0 0 0 0 0
12       1 0 0 0 0 0 0 0 0 0 0 0 0
...
24      (1)
25       0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
...
50       0
51          <- lifetime = 51

कीड़ा: 2,1

        (2 1)
1        2 0 2 0
2        2 0(2)
3        2 0(1 1 1 1)
4        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0
5        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0(1 1 1)
6        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0
7        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0(1 1)
8        2 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0 1 1 0{1 0}^9
...
??          <- lifetime = ??

इल्ली: ३

step    worm
        (3)
1       (2 2)
2       (2 1 2 1 2 1)
3        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 
4        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1(2)
5        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0(2 1 2 1 1 1 1 1 1 1)
6        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^7
7        2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0{2 1 2 1 1 1 1 1 1 0}^6 (2 1 2 1 1 1 1 1 1) 
...      ...
??          <- lifetime = ??

अलग

कृमि जीवनकाल आम तौर पर बहुत बड़ा होता है, जैसा कि कार्यों के मानक तेजी से बढ़ते पदानुक्रम के संदर्भ में निम्न सीमा द्वारा दिखाया गया है : _α :

worm                lower bound on lifetime
----------------    ------------------------------------------
11..10 (k 1s)       f_k(2)
2                   f_ω(2)
211..1 (k 1s)       f_(ω+k)(2)
2121..212 (k 2s)    f_(ωk)(2)
22..2 (k 2s)        f_(ω^k)(2)
3                   f_(ω^ω)(2)
...
n                   f_(ω^ω^..^ω)(2) (n-1 ωs)  >  f_(ε_0) (n-1)

उल्लेखनीय रूप से, कृमि [3] का पहले से ही एक जीवनकाल है जो ग्राहम की संख्या , G को पार करता है :

च _{ω ^ω} (2) = च _{ω ²} (2) = च _ω2 (2) = च _{ω + 2} (2) = च _{ω + 1} (च _{ω + 1} (2)) >> च _{ω + 1} (64) > जी।

कोड गोल्फ चैलेंज

निम्नलिखित व्यवहार के साथ कम से कम संभव फ़ंक्शन उपप्रोग्राम लिखें:

इनपुट : कोई कीड़ा
आउटपुट : कृमि का जीवनकाल।

कोड का आकार बाइट्स में मापा जाता है।

यहाँ एक उदाहरण (पायथन, गोल्फ के बारे में 167 बाइट्स) है:

from itertools import *
def T(w):
    w=w[::-1]
    t=0
    while w:
        t+=1
        if w[0]:a=list(takewhile(lambda e:e>=w[0],w));a[0]-=1;w=a*(t+1)+w[len(a):]
        else:w=w[1:]
    return t

NB : यदि t (n) कृमि का जीवनकाल है [n], तो t (n) की वृद्धि की दर मोटे तौर पर गुडस्टीन फ़ंक्शन की है । इसलिए अगर इसे 100 बाइट्स से नीचे रखा जा सकता है, तो यह सबसे बड़े नंबर प्रिंट करने योग्य प्रश्न का एक अच्छा जवाब दे सकता है । (उस उत्तर के लिए, एन-स्टेप-काउंटर को हमेशा n पर शुरू करके विकास-दर को बहुत तेज़ी से बढ़ाया जा सकता है - वर्म [n] के समान मूल्य - इसे 0. पर शुरू करने के बजाय।)

code-golf array-manipulation function

— रेस
स्रोत

मैं आपके कोड से भ्रमित हूं। आपने कहा कि सिर सबसे सही तत्व है, लेकिन आपके पायथन उदाहरण में, आप सिर को w[0]उस सूची का सबसे छोटा तत्व मानते हैं ?

@LegoStormtroopr यदि आप किसी सूची को बाएँ और दाएँ होने पर विचार कर सकते हैं। यदि आप केवल पहले और अंतिम पर विचार करते हैं, तो आप प्रारंभिक स्ट्रिंग को पढ़ते समय सबसे पहले या आखिरी में सबसे सही मैप कर सकते हैं - जो सवाल का हिस्सा नहीं है। लेकिन फ़ंक्शन इनपुट सख्ती से परिभाषित नहीं थे।

— बॉब

@LegoStormtroopr - अच्छी पकड़; मैंने इनपुट वर्म को उलटने के लिए एक लाइन जोड़कर कोड को ठीक किया, जिसका सिर वास्तव में दाईं ओर माना जाता है (यानी सूची w में अंतिम तत्व)। यह दक्षता के लिए है कि कार्यक्रम उलटा कीड़ा पर संचालित होता है।

— रेस

सही हो रही है जवाब के लिए 2 1एक उचित समय में पूछने के लिए बहुत ज्यादा हो सकता है, लेकिन एक उपयोगी परीक्षण है कि अनुक्रम शुरू कर देना चाहिए (2 1), 2 0 2 0, 2 0 (2), 2 0 (1 1 1 1), ...

— पीटर टेलर

1

@ ThePlasmaRailgun - हार्वे फ्राइडमैन को पैराफेयर करने के लिए, TREE (3) की तुलना में तेजी से बढ़ते पदानुक्रम (जैसे कीड़ा-जीवनकाल) में स्तर at_0 पर कार्यों से प्राप्त संख्याएं पूरी तरह से असंगत हैं ।

— रेस

15

GolfScript ( 56 54 चार्ट )

{-1%0\{\)\.0={.0+.({<}+??\((\+.@<2$*\+}{(;}if.}do;}:L;

ऑनलाइन डेमो

मुझे लगता है कि यहाँ की चाल शायद कृमि को उल्टे क्रम में रख रही है। इसका मतलब है कि सक्रिय खंड की लंबाई को खोजने के लिए यह बहुत कॉम्पैक्ट है: .0+.({<}+??(जहां यह 0सुनिश्चित करने के लिए एक गार्ड के रूप में जोड़ा जाता है कि हम एक तत्व को सिर से छोटा पाते हैं)।

एक तरफ के रूप में, कृमि जीवन काल के कुछ विश्लेषण। मैं age, head tailसिर और पूंछ में पुनरावृत्ति को इंगित करने के लिए घातांक का उपयोग करके कृमि को (प्रश्न के अंकन से उल्टा क्रम में) के रूप में निरूपित करूँगा : जैसे 2^3है 2 2 2।

लेम्मा : किसी भी सक्रिय सेगमेंट के लिए xs, एक फ़ंक्शन f_xsऐसा है जो age, xs 0 tailरूपांतरित करता है f_xs(age), tail।

प्रमाण: कोई भी सक्रिय खंड कभी भी शामिल नहीं हो सकता है 0, इसलिए जब तक हम पूंछ से स्वतंत्र होने से पहले हर चीज को हटा देते हैं तब तक आयु केवल एक फ़ंक्शन है xs।

लेम्मा : किसी भी सक्रिय खंड के लिए xs, कीड़ा age, xsउम्र में मर जाता है f_xs(age) - 1।

प्रमाण: पिछले लेम्मा द्वारा, में age, xs 0रूपांतरित होता है f_xs(age), []। अंतिम चरण उस का विलोपन है 0, जिसे पहले नहीं छुआ गया है क्योंकि यह कभी भी एक सक्रिय सेगमेंट का हिस्सा नहीं बन सकता है।

उन दो लेम्मेटा के साथ, हम कुछ सरल सक्रिय खंडों का अध्ययन कर सकते हैं।

के लिए n > 0,

age, 1^n 0 xs -> age+1, (0 1^{n-1})^{age+1} 0 xs
              == age+1, 0 (1^{n-1} 0)^{age+1} xs
              -> age+2, (1^{n-1} 0)^{age+1} xs
              -> f_{1^{n-1}}^{age+1}(age+2), xs

इसलिए f_{1^n} = x -> f_{1^{n-1}}^{x+1}(x+2)(आधार मामले के साथ f_{[]} = x -> x+1, या यदि आप चाहें f_{1} = x -> 2x+3)। हम देखते हैं कि एकरमैन-पेटर फ़ंक्शन f_{1^n}(x) ~ A(n+1, x)कहाँ Aहै।

age, 2 0 xs -> age+1, 1^{age+1} 0 xs
            -> f_{1^{age+1}}(age+1)

यह एक प्रश्न पर 1 2( 2 1प्रश्न की संकेतन में) जानकारी प्राप्त करने के लिए पर्याप्त है :

1, 1 2 -> 2, 0 2 0 2
       -> 3, 2 0 2
       -> f_{1^4}(4), 2
       -> f_{1^{f_{1^4}(4)+1}}(f_{1^4}(4)+1) - 1, []

इसलिए दिए गए इनपुट से 2 1हमें आउटपुट ~ की उम्मीद है A(A(5,4), A(5,4))।

1, 3 -> 2, 2 2
     -> 3, 1 2 1 2 1 2
     -> 4, 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> 5, 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2 0 2 1 2 1 2
     -> f_{21212}^4(5) - 1

age, 2 1 2 1 2 -> age+1, (1 1 2 1 2)^{age+1}
               -> age+2, 0 1 2 1 2 (1 1 2 1 2)^age
               -> age+3, 1 2 1 2 (1 1 2 1 2)^age

और मैं वास्तव में समझाना शुरू कर सकता हूं कि यह फ़ंक्शन इतनी पागलपन से क्यों बढ़ता है।

— पीटर टेलर
स्रोत

बहुत ही शांत। मुझे लगता है कि यह कार्यक्रम सबसे कम समाप्ति वाले कार्यक्रम का एक विजयी उत्तर देगा, जिसका आउटपुट आकार ग्राहम की संख्या से अधिक है । (वर्तमान विजेता हस्केल कोड के 63 बाइट्स हैं।) जैसे, 55 बाइट्स में, कुछ ऐसा है (जब से मैं सिंटैक्स त्रुटियों से ग्रस्त हूं) 9{-1%0\{\)\.0={.0+.({<}+??\((\+.@<2$*\+}{(;}if.}do;}:L~कीड़ा के जीवनकाल की गणना करता है [9], जो ग्राहम की संख्या से अधिक है - और हो सकता है और आगे बढ़ा।

— रेस

9

गोल्फस्क्रिप्ट, 69 62 वर्ण

{0:?~%{(.{[(]{:^0=2$0+0=<}{\(@\+}/}{,:^}if;^?):?)*\+.}do;?}:C;

फ़ंक्शन Cस्टैक पर कृमि की अपेक्षा करता है और परिणाम द्वारा प्रतिस्थापित करता है।

उदाहरण:

> [1 1]
19

> [2]
51

> [1 1 0]
51

— हावर्ड
स्रोत

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

— रेस

मैंने आपको वहां पर कुछ भी पोस्ट करते हुए नहीं देखा, इसलिए मैंने आगे बढ़कर इस कोड का एक संशोधन पोस्ट किया, जिसे मैं वहां अब तक जीता हुआ जवाब मानता हूं - यह मानते हुए कि *और ^इसे मल्टीमीटर के अंकगणितीय ऑपरेटरों के रूप में उपयोग नहीं किया जा रहा है और घातांक। निश्चित रूप से, यदि आप अपना खुद का (निस्संदेह श्रेष्ठ) उत्तर वहां जमा करना चाहते हैं, तो मैं ख़ुशी से मेरा निकाल दूंगा।

— रेस

7

रूबी - 131 अक्षर

मुझे पता है कि यह ऊपर दिए गए गोल्फस्क्रिप्ट समाधानों के साथ प्रतिस्पर्धा नहीं कर सकता है और मुझे पूरा यकीन है कि यह एक अंक या अधिक वर्णों को कम कर सकता है, लेकिन ईमानदारी से मैं इस समस्या को हल करने में सक्षम होने के लिए खुश हूं। महान पहेली!

f=->w{t=0;w.reverse!;until w==[];t+=1;if w[0]<1;w.shift;else;h=w.take_while{|x|x>=w[0]};h[0]-=1;w.shift h.size;w=h*t+h+w;end;end;t}

मेरा पूर्व गोल्फ समाधान जिसमें से उपरोक्त व्युत्पन्न है:

def life_time(worm)
  step = 0
  worm.reverse!
  until worm.empty?
    step += 1
    if worm.first == 0
      worm.shift
    else
      head = worm.take_while{ |x| x >= worm.first }
      head[0] -= 1
      worm.shift(head.size)
      worm = head * (step + 1) + worm
    end
  end
  step
end

— OI
स्रोत

जेनेरिक टिप: कई गोल्फ समस्याएं गैर-नकारात्मक पूर्णांक पर काम करती हैं, जिस स्थिति में if foo==0इसे ट्रिम किया जा सकता है if foo<1। जो आपको यहां एक चार को बचा सकता है।

— पीटर टेलर

संयोग से, मुझे यह आकर्षक लगता है कि यह एक सेकंड के बिना काम करता है reverse।

— पीटर टेलर

आह, यह नहीं है। यह सिर्फ परीक्षण के मामलों पर काम करता है क्योंकि उनके पास केवल पैलिंड्रोमिक सक्रिय खंड होते हैं।

— पीटर टेलर

गोल्फ टिप के लिए धन्यवाद, @PeterTaylor। इसके अलावा, दूसरे सेकंड के लापता होने पर अच्छी पकड़। मैंने इसे इसमें जोड़ा है। मैं बाद में रिवर्स का उपयोग किए बिना इसे फिर से लिखने का प्रयास करूंगा। मुझे पूरा यकीन है कि मैं elseएक लाइन के लिए क्लॉज प्राप्त कर सकता हूं और फिर if..else..endएक टर्नरी स्टेटमेंट के लिए स्वैप कर सकता हूं । मुझे लगता है कि कुछ पात्रों को बचाने के लिए मैं एक मेमने का उपयोग भी कर सकता हूं।

— OI

6

स्किलिंग (43 अक्षर)

글坼가⑴감套擘終長①加⒈丟倘⓶增⓶가采⓶擘❷小終⓷丟❶長貶❷가掊貶插①增復合감不가終終

यह इनपुट को अंतरिक्ष-पृथक सूची के रूप में उम्मीद करता है। यह 1 1और के लिए सही उत्तर का आउटपुट देता है 2, लेकिन इसके लिए 2 1या 3तो बहुत लंबा समय लगता है इसलिए मैंने इसके खत्म होने का इंतजार करना छोड़ दिया।

कमेंट्री के साथ:

글坼 | split at spaces
가⑴ | iteration count = 0

감套 | while:
  擘終長①加⒈丟 | remove zeros from end and add to iteration count
  倘 | if the list is not empty:
    ⓶增⓶ | increment iteration count
    가采⓶擘❷小終⓷丟 | separate out active segment
    ❶長貶❷가掊貶插 | compute reduced active segment
    ①增復合 | repeat reduced active segment and concat
    감 | continue while loop
  不 | else
    가 | stop while loop
  終 | end if
終 | end while

— Timwi
स्रोत

2

एक दुभाषिया के लिए एक लिंक आसान होगा ... इसके अलावा, यूटीएफ -16 का उपयोग करते हुए, 86 बाइट्स?

— पीटर टेलर

@PeterTaylor: धन्यवाद, लेख में दुभाषिया के लिए लिंक जोड़ा गया। और हाँ, 43 BMP वर्ण UTF-16 में 86 बाइट्स में अनुवाद करते हैं।

— टिमवी

5

के (83)

worm:{-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;|,/x)}

यह शायद आगे गोल्फ हो सकता है, क्योंकि यह सिर्फ पुनरावृत्ति को काफी सरलता से लागू करता है।

बुनियादी विकास कार्य, {x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}65 वर्ण है, और कृमि के मरने पर उम्र बढ़ने को रोकने के लिए कुछ तरकीबों का उपयोग करता है। आवरण एक सूची में एक एकल पूर्णांक के इनपुट को जुटाता है, इनपुट को उलट देता है (यह आपके अंकन से उलट एक कीड़ा के संदर्भ में पुनरावृत्ति को लिखने के लिए छोटा होता है), फ़िक्सप्वाइंट के लिए पूछता है, आउटपुट के रूप में आयु का चयन करता है, और परिणाम समायोजित करता है। अंतिम पीढ़ी में ओवरशूट के लिए खाता है।

अगर मैं मैन्युअल रूप से जोर और उलट करता हूं, तो यह 80 ( {-1+*({x,,(,/((x+:i)#,@[y@&w;(i:~~#y)#0;-1+]),y@&~w:&\~y<*y;1_y)@~*y}.)/(1;x)}) तक गिर जाता है ।

कुछ उदाहरण:

  worm 1 1 0
51
  worm 2
51
  worm 1 1
19

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

विशेष रूप से, worm 2 1और worm 3बस मंथन (और शायद फेंक देगा 'wsfull(स्मृति से बाहर) अगर मैं उन्हें जाने देता रहूं)।

— हारून डेविस
स्रोत

मैंने इस ऑनलाइन इंटरप्रेटर के साथ आपका प्रोग्राम चलाने की कोशिश की है , लेकिन यह कोई आउटपुट नहीं दिखाता है। (एक्सटेंशन के साथ एक टेक्स्ट फ़ाइल जमा करना। K दुभाषिया को बुलाना माना जाता है।) क्या आप जानते हैं कि आउटपुट को स्टडआउट भेजने के लिए क्या किया जा सकता है?

— रेस

ऐसा लग रहा है कि kona चल रहा है, k3 का एक ओपन-सोर्स क्लोन। मेरा कोड k4 में लिखा गया है, और k3 के साथ संगत होने की संभावना नहीं है। आप kx.com/software-download.php पर q / k4 की एक समय-सीमित निःशुल्क प्रति प्राप्त कर सकते हैं ; एक बार जब आपके पास ऐसा हो, तो REPL शुरू करें, ` to switch from q kकोड टाइप करें , और मेरा कोड पेस्ट करें। वैकल्पिक रूप से, आप मेरे कोड को .kएक्सटेंशन वाली फ़ाइल में सहेज सकते हैं और इसे दुभाषिया में लोड कर सकते हैं।

— आरोन डेविस

2

एपीएल (Dyalog यूनिकोड) , 52 बाइट्स ^SBCS

@Ngn और @ Adám की बदौलत 7 बाइट्स बचाए।

0{⍬≡⍵:⍺⋄n←⍺+1⋄0=⊃⍵:n∇1↓⍵⋄n∇∊(⊂1n/-∘1@1¨)@1⊆∘⍵⍳⍨⌊\⍵}⌽

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

स्पष्टीकरण:

0{...}⌽    ⍝ A monadic function train. We define a recursive function with two
           ⍝ arguments: zero (our counter), and the reverse of our input
⍬≡⍵:⍺      ⍝ Our base case - if our input is an empty list, return our counter
n←⍺+1      ⍝ Define 'n' as our counter plus 1
0=⊃⍵:n∇1↓⍵ ⍝ If the first element of the input is zero, recurse with the tail
           ⍝ of our input and n
⌊\⍵        ⍝ Minimum-expand: creates a new list from our input where each element
           ⍝ is the incremental minimum     
⍳⍨         ⍝ Applies above to both sides of the index-of function. Index-of returns
           ⍝ the index of the first occurence of each element in the left-side list.
           ⍝ At this point, a (reversed) input list of [3 4 5 2 3 4] would result
           ⍝ in [1 1 1 4 4 4]
⊆∘⍵        ⍝ Partition, composed with our input. Partition creates sublists of the
           ⍝ right input whenever the integer list in the left input increases.
           ⍝ This means we now have a list of sub-lists, with the first element
           ⍝ being the worm's active segment.
(...)@1    ⍝ Take the active segment and apply the following function train...
-∘1@1¨     ⍝ Subtract 1 from the first element of the active segment
1n/        ⍝ Replicate the resultant list above n+1 times
⊂          ⍝ Enclose the above, so as to keep the original shape of our sub-array
∊          ⍝ Enlist everything above together - this recursively concatenates our
           ⍝ new active segment with the remainder of the list
n∇         ⍝ Recurse with the above and n

— voidhawk
स्रोत

मुझे लगा कि एपीएल इसके लिए वास्तव में एक स्वच्छ समाधान होगा, क्या यह एक सरणी-आधारित भाषा नहीं है?

— thePlasmaRailgun

1

स्काला, 198

type A=List[Int]
def T(w:A)={def s(i:Int,l:A):Stream[A]=l match{case f::r=>l#::s(i+1,if(f<1)r
else{val(h,t)=l.span(_>=l(0));List.fill(i)(h(0)-1::h.tail).flatten++t})
case _=>Stream()};s(2,w).length}

उपयोग:

scala> T(List(2))
res0: Int = 51

— ValarDohaeris
स्रोत

1

के, 95

{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}

।

k)worm:{i::0;#{~x~,0}{((x@!b),,[;r]/[i+:1;r:{@[x;-1+#x;-1+]}@_(b:0^1+*|&h>x)_x];-1_x)@0=h:*|x:(),x}\x}
k)worm 2
51
k)worm 1 1
19
q)worm 1 1 0 0 0 0
635

— tmartin
स्रोत

1

सी (जीसीसी) , 396 बाइट्स

#define K malloc(8)
typedef*n;E(n e,n o){n s=K,t=s;for(*s=*o;o=o[1];*t=*o)t=t[1]=K;t[1]=e;e=s;}main(c,f,l,j,a)n*f;{n w=K,x=w;for(;l=--c;x=x[1]=K)*x=atoi(f[c]);for(;w&&++l;)if(*w){n v=K,z=v,u=w,t=K;for(a=*v=*w;(u=u[1])&&*u>=*w;*z=*u)z=z[1]=K;for(x=v[1],v=K,*v=a-1,1[u=v]=x;u;u=u[1])w=w[1];for(j=~l;j++;)u=t=E(t,v);for(;(u=u[1])&&(x=u[1])&&x[1];);u[1]=0;w=w?E(w,t):t;}else w=w[1];printf("%d",--l);}

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

मुझे पता है कि मैं पार्टी के लिए बहुत देर से आया हूं, लेकिन मुझे लगा कि मैं सी में इस पर अपना हाथ आजमाऊंगा, जिसे एक लिंक्ड-लिस्ट कार्यान्वयन की आवश्यकता थी। यह वास्तव में सभी पहचानकर्ताओं को एकल वर्णों में बदलने के अलावा बिल्कुल नहीं है, लेकिन यह कार्य करता है!

सब सब, मैं बहुत खुश हूँ इस पर विचार 3 C / C ++ प्रोग्राम मैंने कभी लिखा है।

— ThePlasmaRailgun
स्रोत

क्या आपको वास्तव में एक लिंक की गई सूची की आवश्यकता है? सिर्फ सरणियाँ आवंटित क्यों नहीं? चूंकि यह कोड गोल्फ है, इसलिए जब आप काम कर रहे हों तो आपको उन्हें परेशान करने की जरूरत नहीं है। आप हो सकता है यहां तक कि कॉल स्टैक (यकीन नहीं) पर उन्हें स्टोर करने के लिए एक रास्ता खोजने के लिए सक्षम हो।

— dfeuer

इसके अलावा, आपको एक मुख्य कार्य की आवश्यकता नहीं है। बस एक फ़ंक्शन लिखें जो कृमि को तर्क के रूप में लेता है और उसके जीवनकाल को वापस करता है। कृमि एक सरणी और उसकी लंबाई हो सकती है, या एक ऋणात्मक संख्या में समाप्त होने वाली सरणी हो सकती है।

— dfeuer

1

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

(0!).reverse
n!(x:y)|x<1=(n+1)!y|(a,b)<-span(>=x)y=(n+1)!(([-1..n]*>x-1:a)++b)
n!_=n

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

@Xnor को दो बाइट के लिए धन्यवाद।

मुझे लगता है कि आम वेतन वृद्धि का एक अच्छा तरीका होना चाहिए, लेकिन मुझे अभी तक कोई छोटा नहीं मिला है।

— dfeuer
स्रोत

1

दो छोटे गोल्फ : खाली सूची के मामले की दूसरी जांच करें, और nनीचे शिफ्ट करें

— xnor

मुझे भी लगता है कि (n+1)!दो बार नहीं लिखने का एक तरीका होना चाहिए , लेकिन मेरा प्रयास केवल बंधा हुआ है।

— xnor

0

पर्ल 5 `-pa` , 92 बाइट्स

while(@F){++$\;my@a;if($b=pop@F){unshift@a,pop@F while$F[-1]>=$b;push@F,(@a,--$b)x($\+1)}}}{

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

— Xcali
स्रोत

0

स्टैक्स , 31 बाइट्स

àîz7αan♣óàNµK2☻₧⌡▐`Γl½f{♂♂_KZÖÄ

इसे चलाएं और डीबग करें

— पुनरावर्ती
स्रोत

एक कृमि का जीवनकाल

शर्तें

विकास के नियम

उदाहरण (कोष्ठक में सक्रिय खंड)

अलग

कोड गोल्फ चैलेंज

GolfScript ( 56 54 चार्ट )

गोल्फस्क्रिप्ट, 69 62 वर्ण

रूबी - 131 अक्षर

स्किलिंग (43 अक्षर)

के (83)

एपीएल (Dyalog यूनिकोड) , 52 बाइट्स SBCS

स्काला, 198

के, 95

सी (जीसीसी) , 396 बाइट्स

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

पर्ल 5 -pa , 92 बाइट्स

स्टैक्स , 31 बाइट्स

एपीएल (Dyalog यूनिकोड) , 52 बाइट्स ^SBCS

पर्ल 5 `-pa` , 92 बाइट्स