अनुक्रम चरण प्राप्त करें

17

चुनौती

संख्याओं के अनुक्रम को देखते हुए, एक फ़ंक्शन बनाएं जो अनुक्रम चरणों को वापस करता है।

  • एक अनुक्रम मान लिया जाएगा N >= 3
  • अनुक्रम कम से कम एक बार इसे दोहराएगा
  • अनुक्रम में केवल प्राकृतिक संख्याएँ होंगी
  • आपके फ़ंक्शन या प्रोग्राम को चरणों का सबसे कम संभव अनुक्रम वापस करना चाहिए

उदाहरण:

इनपुट: [1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17]

आउटपुट: [1, 1, 2]

स्पष्टीकरण: प्रारंभिक अनुक्रम से जाता है 1 => 2 (1 step), 2 => 3 (1 step), 3 => 5 (2 steps)। फिर दोहराता है। आउटपुट तो है[1 step, 1 step, 2 steps] => [1, 1, 2]

एक और उदाहरण:

इनपुट: [2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20]

आउटपुट: [3, 1, 1, 1]

[2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20]
 \  /\ /\ /\ / 
  3   1  1  1  Then it repeats...

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

Input: [1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28] => Output: [3,4,1,1]

Input: [6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] => Output: [5,2]

Input: [2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47] => Output: [4,4,3,4]

Input: [5, 6, 7] => Output: [1]

स्पष्टीकरण

  • इनपुट लंबाई - 1 आउटपुट लंबाई से विभाज्य है
  • मान लें कि अनुक्रम हमेशा बढ़ता जा रहा है

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

code-golf  sequence  array-manipulation 
— लुइस फेलिप डी जेउस मुनोज़
स्रोत
— AdmBorkBork
6
मैंने कुछ चुनौतियाँ देखी हैं जिन्हें आपने हाल ही में बहुत सी स्पष्ट टिप्पणियों के साथ पोस्ट किया है, और एक जोड़े को "अस्पष्ट" के रूप में बंद किया है, और आपके द्वारा उपयुक्त संपादन करने के बाद बाद में फिर से खोला गया है। क्या आपने कुछ दिनों / सप्ताह में सैंडबॉक्स में इन्हें पोस्ट करने पर विचार किया है ? मैंने आपकी चुनौतियों का आनंद लिया है क्योंकि वे काफी स्वीकार्य हैं, लेकिन सभी चुनौतियाँ, चाहे वे कितनी भी सरल हों या जिनके द्वारा वे पोस्ट की गईं हों, शोधन का उपयोग कर सकती हैं।
— ग्यूसेप
2
@Giuseppe आपके सुझाव के लिए धन्यवाद। मैंने रेत बॉक्स में कुछ अन्य चुनौतियां पोस्ट की हैं (आमतौर पर अगर मुझे इसके साथ एक चुनौती बनाने का सही तरीका नहीं मिला तो मैं इसे हटा दूंगा)। इन चुनौतियों के लिए मुझे लगा कि वे पर्याप्त स्पष्ट हैं और इसलिए मैंने तुरंत पोस्ट किया लेकिन मैं उन्हें सैंडबॉक्स में पोस्ट करना शुरू कर दूंगा। धन्यवाद
— लुइस फेलिप डी जीसस मुनोज
2
@LuisMendo विधर्मी! 0 एक प्राकृतिक संख्या है! बिली जोएल ने भी एक पूरी एल्बम पीनो मैन को समर्पित की थी!
— एनजी
1
@AdmBorkBork, यह मनमानी-लंबाई ऑपरेशन सूचियों से निपटने के गुण से संबंधित है।
— पीटर टेलर

जवाबों:

10

जेली , ९ by बाइट्स

IsJEƇḢḢ

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

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

IsJEƇḢḢ  Main link. Argument: A (array)

I        Increment; compute D, the array of A's forward differences.
  J      Indices; yield [1, ..., len(A)].
 s       Split D into chunks of length k, for each k in [1, ..., len(A)].
   EƇ    Comb equal; keep only partitions of identical chunks.
     Ḣ   Head; extract the first matching parititon.
      Ḣ  Head; extract the first chunk.
— डेनिस
स्रोत
9

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

एक अल्पविराम से अलग स्ट्रिंग (एक प्रमुख अल्पविराम के साथ) आउटपुट करता है।

a=>(a.map(p=x=>-(p-(p=x)))+'').match(/N((,\d+)*?)\1*$/)[1]

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

या 56 बाइट्स यदि हम ,-विभाजक के रूप में उपयोग करते हैं और हम मानते हैं कि अनुक्रम हमेशा है कड़ाई से है बढ़ रहा है।

कैसे?

हम पहले इनपुट सरणी [a] को लगातार भिन्नताओं की सूची में परिवर्तित करते हैं :

a.map(p = x => -(p - (p = x)))

क्योंकि पी को शुरू में एक नॉन-न्यूमेरिक मान ( मैप के कॉलबैक फंक्शन () ) पर सेट किया जाता है, पहला पुनरावृत्ति NaN देता है ।

उदाहरण:

[6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41]
[ NaN, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2 ]

हम फिर परिणाम को एक स्ट्रिंग के लिए ले जाते हैं:

"NaN,5,2,5,2,5,2,5,2,5,2"

अंत में, हम अल्पविराम से अलग किए गए पूर्णांक 1 के सबसे छोटे पैटर्न की तलाश करते हैं ( ,\d+) "NaN" के ठीक बाद शुरू होता है और स्ट्रिंग के अंत तक दोहराता है:

match(/N((,\d+)*?)\1*$/)

1: गैर-लालची का उपयोग करना *?

— Arnauld
स्रोत
मैं उसी रेगेक्स विचार के आधार पर एक समाधान पोस्ट कर रहा हूं, लेकिन कार्यान्वयन में बहुत अलग है। बेशक, मेरा विकास करने से पहले मैंने अन्य समाधानों को नहीं देखा था, और यह काफी अलग लगता है, और शायद यह पहली बार है जब मैं यहां से बेहतर स्कोर करने का प्रबंधन करता हूं।
— edc65
1
53 बाइट्स: /(,.+?)\1*$/।
— नील
6

ब्रेकीलॉग , 11 बाइट्स

s₂ᶠ-ᵐṅᵐ~j₍t

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

5 बाइट्स होंगे यदि लगातार अंतर के लिए एक अंतर्निहित था।

व्याख्या

Example input: [6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] 

s₂ᶠ             Find all substrings of length 2: [[6,11],[11,13],…,[34,39],[39,41]]
   -ᵐ           Map subtraction: [-5,-2,-5,-2,-5,-2,-5,-2,-5,-2]
     ṅᵐ         Map negate: [5,2,5,2,5,2,5,2,5,2]
       ~j₍      Anti-juxtapose the list of differences; the shortest repeated list is found
                  first, with the biggest number of repetitions: [5,[5,2]]
            t   Tail: [5,2]
— Fatalize
स्रोत
क्या आप एक बाइट को बचाने के लिए पूंछ के बाद नकार सकते हैं?
— रॉड
@ मुझे अभी भी इसे मैप करने की आवश्यकता होगी, इसलिए यह एक ही लंबाई होगी। नेगेट दो नंबरों के बीच एक विधेय है, यह अन्य भाषाओं की तरह सूचियों के लिए स्वचालित रूप से वेक्टर नहीं करता है (अन्यथा यह अज्ञात इनपुट / आउटपुट के साथ अच्छी तरह से काम नहीं करेगा जो कि घोषणात्मक कार्यक्रमों में सामान्य हैं)
— घातक।
5

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

<J.+Qf.<IJT

इसे यहाँ आज़माएँ

व्याख्या

<J.+Qf.<IJT
 J.+Q          Call the sequence of differences in the input J.
     f         Find the first positive integer T...
      .<IJT    ... where rotating J by T doesn't change it.
<J             Take that many elements of J.
5

आर , 49 46 बाइट्स

पूरा कार्यक्रम:

d=diff(scan());while(any((s=d[1:T])-d))T=T+1;s

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

आर , 72 58 54 बाइट्स

एक ही स्थान पर सभी परीक्षण मामलों के साथ मूल कार्य प्रस्तुत करना:

function(a,d=diff(a)){while(any((s=d[1:T])-d))T=T+1;s}

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

फुल प्रोग्राम रूट और फंक्शन पर -4 बाइट्स सुझाने के लिए JayCe को धन्यवाद, और आगे -3 के लिए Giuseppe को।

— किरिल एल।
स्रोत
— JayCe
@JayCe को a<-यहाँ की आवश्यकता नहीं है
— Giuseppe
4

जे , 22 19 बाइट्स

3 बाइट्स FrownyFrog के लिए धन्यवाद बचा लिया! 

0{"1[:~./:|."{}.-}:

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

[इसे ऑनलाइन आज़माएं!] [TIO-ji2uiwla]

कैसे?

                 -      find the successive differences by subtracting 
                  }:    the list with last element dropped
               }.       from the list with the first element dropped 
           |."{         rotate the list of differences
         /:             0..length-1 times (the input graded up)
     [:~.               remove duplicating rows
 0{"1                   take the first element of each row
— गैलेन इवानोव
स्रोत
यदि आप /:इसके बजाय #\, आप 0{"1[:~.1 बाइट बचा सकते हैं ।
— फ्रॉन्फ्रोग में
और "0 1है"{
— FrownyFrog
@FrownyFrog धन्यवाद, एक बार फिर!
— गैलेन इवानोव
1
यह शानदार है।
— योना
@ जोना हां, फ्रॉन्फ्रॉग के लिए धन्यवाद!
— गैलेन इवानोव
4

05AB1E , 8 बाइट्स

केविन क्रूज़सेन के लिए 3 बाइट्स का धन्यवाद दिया ।

¥.œʒË}нн

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

05AB1E , 11 बाइट्स

āεI¥ô}ʒË}нн

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

¥ FullI ε ô} ʒË} нн पूरा कार्यक्रम।
Length लंबाई सीमा। धक्का [1 ... लेन (inp)]।
 ε} प्रत्येक के लिए ...
  I of ô ... डेल्टा को इसी आकार के टुकड़ों में काट लें
      ʒË} केवल उन सभी को रखें जिनके सभी तत्व समान हैं।
         нн और पहले पहले वाले के पहले तत्व को पुनः प्राप्त करते हैं।

13 बाइट्स

एक प्यारा विकल्प, IMO:

¥©ηʒDg®ôÙ˜Q}н

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

¥©ηʒDg®ôÙ˜Q}н   Full program.
¥               Push the deltas.
 ©              Copy them to the register.
  ηʒ       }    And filter the prefixes by...
    D     Q     ... Is the prefix itself equal to...
     g®ô        ... The deltas, split into chunks of its length...
        Ù˜      ... Deduplicated and flattened?
            н   Head.
— मिस्टर एक्सकोडर
स्रोत
1
8 बाइट्स का उपयोग करके.œ।
— केविन क्रूज़सेन
3

जावास्क्रिप्ट, 49 56 बाइट्स

7 बाइट्स संपादित संपादित धन्यवाद (अनुमान कौन?) अरनौल

अर्नेल्द के रूप में एक ही रेगेक्स विचार, लेकिन कार्यान्वयन में उत्सुकता से अलग ...

अलग किए गए स्टेप्स के साथ कॉमा लौटना (और एक लीडिंग कॉमा)

p=>/N(.+?)\1+$/.exec(p.map(p=v=>[v-p,p=v][0]))[1]

परीक्षा

var F=
p=>/N(.+?)\1+$/.exec(p.map(p=v=>[v-p,p=v][0]))[1]

;[[1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17]
,[1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28]
,[6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41] 
,[2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47]
,[5, 6, 7]]
.forEach(x=>console.log(x + ' -> ' + F(x)))
स्निपेट का विस्तार करें

— edc65
स्रोत
उपयोग करना matchमेरा एक खराब निर्णय था। आप मुझे कुछ और कर सकते हैं । :-)
— अरनुलद
3

MATL , 14 13 12 बाइट्स

dt5YLFTF#Xu)

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

बस पता चला है कि MATL एक परिचालित कार्य करता है!

व्याख्या

d - एक सरणी के रूप में, क्रमिक शब्दों के बीच अंतर प्राप्त करें

t5YL- डुप्लिकेट कि, फिर YL('गैलरी') फ़ंक्शन 5('सर्कुलेट') विकल्प के साथ कॉल करें । पहली पंक्ति के रूप में दिए गए वेक्टर के साथ एक मैट्रिक्स बनाता है, फिर क्रमिक पंक्तियों को एक ही वेक्टर को परिपत्र रूप से स्थानांतरित किया जाता है, जब तक कि यह चारों ओर लपेटता नहीं है।

FTF#Xu- अद्वितीय पंक्तियों के लिए जाँच करें और उनकी पंक्ति संख्या प्राप्त करें (यदि यह करने का एक छोटा तरीका है तो सुनिश्चित नहीं है)। जब अनुक्रम चरण दोहराते हैं, तो गोलाकार रूप से स्थानांतरित पंक्ति पहली पंक्ति के समान होगी, और बाद की पंक्तियां दोहराई जाएंगी। इसलिए यह दोहराए जाने से पहले अनुक्रम चरणों के पहले रन के संकेत मिलते हैं।

) - मूल अंतर सरणी में इसका उपयोग सूचकांक, जवाब पाने के लिए।

पुराने:

d`tt@YS-a}@:)

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

(Giuseppe के लिए -1 बाइट)

स्पष्टीकरण:

d   % Get the differences between successive terms, as an array
`   % Start do-while loop
  tt  % duplicate the difference array twice
  @   % push the current loop index value
  YS  % circularly shift the difference array by that amount
  -   % subtract the shifted diffs from the original diffs
  a   % see if the subtraction resulted in any non-zeros
    % if it did, shifted differences were not equal to original differences, so continue loop 
}@ % if it didn't, then get loop index
:) % get the differences upto the loop index, before they started repeating
   % implicit loop end
— sundar - मोनिका को बहाल करना
स्रोत
2

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

def f(l):d=[y-x for x,y in zip(l,l[1:])];g=len(l);print[d[:k]for k in range(1,g+1)if g/k*d[:k]==d][0]

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

सबसे पहले डेल्टा उत्पन्न d , तो पहले उपसर्ग पाता पी की घ कि जब बार-बार ⌊len (एल) / LEN (पी) ⌋ बार पैदावार एल , जहां एल इनपुट सूची है।

— मिस्टर एक्सकोडर
स्रोत
2

माणिक , 62 बाइट्स

रेनेक्स तर्क पर निर्भर अरनुल्ड के जवाब से अनुकूलित ।

->a{i=-2;a.map{|x|(i+=1)>=0?x-a[i]:0}*?,=~/((,\d+)*?)\1*$/;$1}

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

वैकल्पिक मतभेदों का निर्धारण, 62 बाइट्स:

->a{[0,*a.each_cons(2).map{|x,y|y-x}]*?,=~/((,\d+)*?)\1*$/;$1}

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

— किरिल एल।
स्रोत
2

जावा 10, 104 100 बाइट्स

a->{var t="";for(int i=a.length;i-->1;t+=a[i]-a[i-1]+" ");return t.replaceAll("( ?.+?)\\1*$","$1");}

@ अर्नुलड्स जावास्क्रिप्ट (ES6) के उत्तर पर @Neil की टिप्पणी के स्थान पर( ?.+?)\1*$ सबसे छोटा दोहराव के लिए Regex ।

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

स्पष्टीकरण:

a->{                        // Method with integer-array parameter and String return-type
  var t="";                 //  Temp-String, starting empty
  for(int i=a.length;i-->1; //  Loop backward over the input-array, skipping the first item
    t+=a[i]-a[i-1]          //   Calculate the difference between two adjacent items
       +" ");               //   And append this with a space to the temp-String
  return t.replaceAll("( ?.+?)\\1*$", 
                            //  Find the shortest repeating substring
                     "$1");}//  And only keep one such substring
— केविन क्रूज़सेन
स्रोत
1

एपीएल + विन, 39 बाइट्स

इनपुट के लिए शीघ्र

(↑((⍴v)=+/¨(⊂v)=(⍳⍴v)⌽¨⊂v)/⍳⍴v)↑v←-2-/⎕

इसे ऑनलाइन आज़माएं! दरियाल क्लासिक के सौजन्य से

स्पष्टीकरण:

v←-2-/⎕ Prompt for input and take successive differences

(⍳⍴v)⌽¨⊂v create a nested vector ans sequentially rotate by one to length of v

+/¨(⊂v)= compare to original v and sum positions where there is match

(⍴v)= identify where all elements match

(↑(....) identify number of rotations giving a first complete match

(↑(...)↑v take first number of elements from above from v as repeated sequence
— ग्राहम
स्रोत
1

रेटिना 0.8.2 , 42 बाइट्स

\d+
$*
(?<=(1+),)\1

1+(.+?)\1*$
$1
1+
$.&

इसे ऑनलाइन आज़माएं! लिंक में परीक्षण के मामले शामिल हैं। आउटपुट में प्रमुख अल्पविराम शामिल हैं। स्पष्टीकरण:

\d+
$*

यूनीरी में बदलें।

(?<=(1+),)\1

पहले नंबर को छोड़कर आगे के अंतर की गणना करें, जो पीछे छूट जाता है।

1+(.+?)\1*$
$1

मैच दोहराता अंतर।

1+
$.&

दशमलव में परिवर्तित करें।

— नील
स्रोत
1

05AB1E , 14 13 बाइट्स

¥DηvÐNƒÁ}QD—#

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

मुझे पता है कि @ Mr.Xcoder द्वारा पहले से ही दो छोटे 05AB1E उत्तर पोस्ट किए गए हैं , लेकिन मैं रोटेशन और समानता की जांच का उपयोग करके इस वैकल्पिक दृष्टिकोण की कोशिश करना चाहता था।
यह छोड़ने के बिना कुछ बाइट्स नीचे गोल्फ में सक्षम हो सकता हैÁ ।

की नोक के बाद 1 बाइट @Emigna global_variable रजिस्टरों (दूर करने के लिए ©और 2x ®) एक डुप्लिकेट (और प्रयोग D) और एक तीन प्रतियों ( Ð) के बजाय।

स्पष्टीकरण:

¥             # Calculate the deltas of the input-array
              #  i.e. [1,2,3,5,6,7,9] → [1,1,2,1,1,2]
 D            # Duplicate it
  η           # Push all its prefixes
              #  [1,1,2,1,1,2] → [[1],[1,1],[1,1,2],[1,1,2,1],[1,1,2,1,1],[1,1,2,1,1,2]]
v             # For-each over these prefixes
 Ð            #  Triplicate the (duplicated) deltas-list
  NƒÁ}        #  Rotate the deltas-list N+1 amount of times,
              #  where N is the prefix index (== prefix_length-1)
              #   i.e. [1,1,2] and [1,1,2,1,1,2] (rotate 3 times) → [1,1,2,1,1,2]
      Q       #  If the rotated deltas and initial deltas are equal
              #   [1,1,2,1,1,2] and [1,1,2,1,1,2] → 1
       D—#    #  Print the current prefix-list, and stop the for-each loop
— केविन क्रूज़सेन
स्रोत
1
यहां एक 9 (अलग जवाब है क्योंकि यह एक बहुत अलग अहंकार है, हालांकि यह ¥ (साझा करता है)।
— ग्रिममी
@Grimy क्या आप मेरे सभी 05AB1E उत्तर और गोल्फ में से प्रत्येक के माध्यम से जा रहे हैं, हाहा? ; पी अच्छा जवाब हालांकि (अभी तक फिर से), मुझ से +1।
— केविन क्रूज़सेन
1
उन सभी को नहीं, मैं सिर्फ इस पोस्ट से जुड़े लोगों के माध्यम से जा रहा हूं ।
— ग्रिम्मी
@Grimy आह ठीक है, यह समझ में आता है। :)
— केविन क्रूज़सेन
1

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

let i=map(uncurry(-))$zip(tail x)(init x)in head$filter(\s->take(length i)(concat$repeat s)==i)(tail$inits i)

x इनपुट ऐरे है।

— misja111
स्रोत
विशेष रूप से PPCG और हास्केल गोल्फ में आपका स्वागत है! आप इनपुट को एक निश्चित चर में मौजूद होने का अनुमान नहीं लगा सकते हैं, हालांकि यह आसानी से पूर्व निर्धारित करके तय किया गया है f x=। इसके अलावा initsआवश्यकता का उपयोग import Data.List, क्योंकि यह प्रस्तावना का हिस्सा नहीं है: इसे ऑनलाइन आज़माएं!
— लकोनी
हालाँकि, आप काफी कुछ बाइट्स बचा सकते हैं: (init x)सिर्फ xइसलिए हो सकता है कि zipसूचियों में से एक दूसरे की तुलना में लंबी होने पर स्वचालित रूप से छोटा हो जाए। और के लिए map(uncurry(-))$zipएक निर्माण में मौजूद है: zipWith(-)। इसके बजाय f x=let i=...inआप एक पैटर्न गार्ड का उपयोग कर सकते हैं f x|i<-...=:।
— लकोनी
इसके अलावा आप के बजाय एक सूची समझ का उपयोग कर सकते हैं filter , !!0के बजाय headऔर cycleके बजाय concat$repeat: यह ऑनलाइन कोशिश करो!
— लकोनी
@ लिकोनी आपके सुधार के लिए बहुत बहुत धन्यवाद! आप सही हैं, मेरे कोड को फ़ंक्शन घोषणा और Data.List.inits के लिए एक आयात की आवश्यकता है। लेकिन मैं सोच रहा था, क्या इसे कोड की लंबाई में जोड़ा जाना चाहिए? मैं पूछ रहा हूं क्योंकि कुछ अन्य कोड नमूने कुछ अतिरिक्त कोड पर भी भरोसा करते हैं।
— misja111
हां, यह आम सहमति है कि उन बाइट्स को स्कोर में शामिल किया गया है। हमारे पास हास्केल में गोल्फिंग नियमों के लिए एक गाइड है जो इनमें से अधिकांश मामलों को कवर करता है।
— लकोनी
1

स्टैक्स , 8 6 बाइट्स

░»F\☺»

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

यह कैसे काम करता है यह दिखाने के लिए यहां एक अनकैप्ड एनोटेट संस्करण है।

:-  pairwise differences
:(  all leftward rotations of array
u   keep only unique rotations
mh  output the first element from each unique rotation

इसको चलाओ

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

पर्ल 6 , 57 बाइट्स

{~(.rotor(2=>-1).map:{.[1]-.[0]})~~/^(.+?){}" $0"+$/;~$0}

झसे आज़माओ

आउटपुट अलग हो गया है ("1 1 2" )

विस्तारित:

{      # bare block lambda with implicit parameter $_

  ~(   # stringify (space separated)

    .rotor( 2 => -1 )     # from the input take 2 backup 1, repeat
    .map: { .[1] - .[0] } # subtract each pair to find the differences
  )

  ~~   # smartmatch

  /    # regex

    ^  # beginning of string

    ( .+? ) # match at least one character, but as few as possible
    {}      # make sure $0 is set (probably a compiler bug)
    " $0"+  # match $0 one or more times (with a leading space)

    $  # end of string
  /;

  ~$0  # return the stringified $0
}
— ब्रैड गिल्बर्ट b2gills
स्रोत
पूरा पहला भाग हो सकता है~(.skip Z-$_)
— जो किंग
1

05AB1E , 9 बाइट्स

¥©η.ΔÞ®Å?

स्पष्टीकरण:

          # take input implicitly
¥         # deltas, eg [4, 5, 7, 8, 10] -> [1, 2, 1, 2]
 ©        # save this to the global register
  η       # prefixes, eg [1, 2, 1, 2] -> [[1], [1, 2], ...]
   .Δ     # find the first one such that
     Þ    # cycled infinitely, eg [1, 2] -> [1, 2, 1, 2, ...]
       Å? # starts with
      ®   # the global register
          # and implicitly print the found element

वैकल्पिक 9-बाइट:

¥η.ΔÞ.¥-Ë

समान अहंकार, लेकिन डेल्टास की सूची (जिसे बचाने / बहाल करने की आवश्यकता है) की तुलना करने के बजाय, यह उपयोग करता है .¥ डेल्टास (undelta) इनपुट (अंतर्निहित) इनपुट की तुलना करता है।

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

— ग्रिमी
स्रोत
0

K4 , 30 बाइट्स

समाधान:

(*&d~/:c#'(!c:#d)#\:d)#d:1_-':

उदाहरण:

q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':2, 5, 6, 7, 8, 11, 12, 13, 14, 17, 18, 19, 20
3 1 1 1
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':1, 2, 3, 5, 6, 7, 9, 10, 11, 13, 14, 15, 17
1 1 2
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':1, 4, 8, 9, 10, 13, 17, 18, 19, 22, 26, 27, 28
3 4 1 1
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':6, 11, 13, 18, 20, 25, 27, 32, 34, 39, 41
5 2
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':2, 6, 10, 13, 17, 21, 25, 28, 32, 36, 40, 43, 47
4 4 3 4
q)k)(*&d~/:c#'(!c:#d)#\:d)#d:1_-':5 6 7
,1

स्पष्टीकरण:

लगता है कि हम क्या हल करने की कोशिश कर रहे हैं। इनपुट के डेल्टास प्राप्त करें और फिर अनुक्रमों का निर्माण करें और सबसे कम निर्धारित करें जो इसे मेल खाता है।

(*&d~/:c#'(!c:#d)#\:d)#d:1_-': / the solution
                           -': / deltas 
                         1_    / drop first
                       d:      / save as d
                      #        / take (#) from
(                    )         / do this together
                 #\:d          / take (#) each-left (\:) from d
          (     )              / do this together
              #d               / count length of d
            c:                 / save as c
           !                   / range 0..c-1
       c#'                     / take c copies of each
   d~/:                        / d equal (~) to each right (/:)
  &                            / where true
 *                             / first one
— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.