दो सकारात्मक पूर्णांक p और q को देखते हुए , आपका कार्य निम्न एल्गोरिथम को लागू करके बनाई गई सरणी A को वापस करना है:

साथ प्रारंभ एक = [p, q] और घ = 2
प्रत्येक जोड़ी के लिए (एक्स, वाई) में सन्निहित संख्या की एक जिसका योग से विभाज्य है घ , सम्मिलित (x + y) / डी के बीच एक्स और वाई ।
यदि कम से कम एक मिलान जोड़ी मिली, तो वृद्धि d और चरण # 2 के साथ आगे बढ़ें। अन्यथा, बंद और बदले एक ।

उदाहरण

नीचे p = 1 और q = 21 के लिए प्रक्रिया का विस्तार है ।

  1  21             | Iteration #1: we start with d = 2 and A = [1, 21]
   \/               |               1 + 21  is divisible by 2 -> we insert 11
 22/2=11            |
                    |
  1  11 21          | Iteration #2: d = 3, A = [1, 11, 21]
   \/               |               1 + 11  is divisible by 3 -> we insert 4
 12/3=4             |
                    |
  1 4 11  21        | Iteration #3: d = 4, A = [1, 4, 11, 21]
        \/          |               11 + 21 is divisible by 4 -> we insert 8
      32/4=8        |
                    |
  1    4    11 8 21 | Iteration #4: d = 5, A = [1, 4, 11, 8, 21]
    \/   \/         |               1 + 4   is divisible by 5 -> we insert 1
  5/5=1 15/5=3      |               4 + 11  is divisible by 5 -> we insert 3
                    |
  1 1 4 3 11 8 21   | Iteration #5: d = 6, A = [1, 1, 4, 3, 11, 8, 21]
                    |               no sum of two contiguous numbers is divisible by 6
                    |               -> we stop here

इसलिए अपेक्षित आउटपुट: [१, १, ४, ३, ११, [, २१]

स्पष्टीकरण और नियम

इनपुट और आउटपुट को किसी भी उचित प्रारूप में संभाला जा सकता है। पूर्णांक p और q 0. से अधिक होने की गारंटी है। यदि यह मदद करता है, तो आप मान सकते हैं कि q । P।
एल्गोरिथ्म के दूसरे चरण को उन तत्वों पर पुनरावर्ती रूप से लागू नहीं किया जाना चाहिए जो केवल एक ही पुनरावृत्ति पर सम्मिलित किए गए हैं। उदाहरण के लिए, A = [1, 1] और d = 2 को नेतृत्व करना चाहिए [1, 1, 1] (1 की अनंत सूची नहीं)।
यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम जवाब जीतता है!

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

  p |   q | Output
----+-----+-------------------------------------------------------------------------------
  1 |   1 | [1,1,1]
  1 |   2 | [1,2]
  1 |   3 | [1,1,2,3]
  2 |   6 | [2,1,2,1,4,1,2,6]
  3 |  13 | [3,1,8,1,3,1,7,1,2,1,5,1,3,2,13]
  9 |   9 | [9,6,9,6,9]
 60 |  68 | [60,13,1,4,31,2,3,5,2,19,64,7,13,1,2,5,2,27,44,3,4,8,2,1,12,1,5,3,28,2,4,16,1,
    |     |  2,12,1,2,1,10,1,6,68]
144 | 336 | [144,68,3,4,8,1,12,1,4,2,28,13,128,44,17,92,240,58,108,5,17,1,2,5,3,28,3,1,11,
    |     |  60,3,6,2,42,2,4,26,192,54,132,7,1,15,1,3,1,18,1,4,2,30,3,1,12,1,9,78,46,336]

यदि आप अपने कोड को थोड़े बड़े परीक्षण मामले में परखना चाहते हैं, तो यहां अपेक्षित उत्पादन है:

पी = १२० ९ ^६ (२ ^६ * ३ ^३ * 2)
q = 24192 (2 ⁷ * 3 ³ * 7)

code-golf array-manipulation

— Arnauld
स्रोत

6

05AB1E , 28 19 18 बाइट्स

[Ðü+NÌ/‚ζ˜ʒ.ï}DŠQ#

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

एह, निश्चित रूप से कट्टर सुधार किया जा सकता है। अभी भी रिफ्लेक्टर के लिए काम कर रहा है।

~~शायद जितना अच्छा मुझे मिल रहा है।~~

-1 के लिए धन्यवाद, लेकिन कौन है, एमिग्ना! इंगित करने के लिए स्वैप रजिस्टर से बेहतर काम किया।

[                   // Infinite loop.
 Ð                  // Triplicate [p, ..., q]
  U                 // Pop 1 of 3 copies into register X.
   ü+               // Pairwise addition.
     NÌ/            // Divide by current iteration + 2 (which is d).
        ‚           // Group original [p, ..., q] with pairwise additives.
         ζ˜         // Transpose together and flatten.
           ʒ.ï}     // Filter out non-integer entities (includes the space added by zip).
               DXQ  // Dupe result, see if equal to original.
                  # // If new array is original array, nothing happened, quit & return.

इसके लिए डिबग डंप करें [p,q] = [1,3]:

Full program: [ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> [  ||  stack: []
ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: []
current >> U  ||  stack: [[1, 3], [1, 3], [1, 3]]
current >> ü  ||  stack: [[1, 3], [1, 3]]
Full program: +
current >> +  ||  stack: [1, 3]
stack > [4]
current >> N  ||  stack: [[1, 3], [4]]
current >> Ì  ||  stack: [[1, 3], [4], 0]
current >> /  ||  stack: [[1, 3], [4], 2]
current >> ‚  ||  stack: [[1, 3], [2.0]]
current >> ζ  ||  stack: [[[1, 3], [2.0]]]
current >> ˜  ||  stack: [[[1, 2.0], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 2.0, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 2.0, 3]]
current >> X  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
current >> Q  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 3]]
current >> #  ||  stack: [[1, 2.0, 3], 0]
stack > [[1, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 2.0, 3]]
current >> U  ||  stack: [[1, 2.0, 3], [1, 2.0, 3], [1, 2.0, 3]]
current >> ü  ||  stack: [[1, 2.0, 3], [1, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 2.0]
stack > [3.0]
Full program: +
current >> +  ||  stack: [3.0, 2.0, 3]
stack > [3.0, 5.0]
current >> N  ||  stack: [[1, 2.0, 3], [3.0, 5.0]]
current >> Ì  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 1]
current >> /  ||  stack: [[1, 2.0, 3], [3.0, 5.0], 3]
current >> ‚  ||  stack: [[1, 2.0, 3], [1.0, 1.6666666666666667]]
current >> ζ  ||  stack: [[[1, 2.0, 3], [1.0, 1.6666666666666667]]]
current >> ˜  ||  stack: [[[1, 1.0], [2.0, 1.6666666666666667], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 1.0, 2.0, 1.6666666666666667, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.6666666666666667]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 0]
stack > [[1, 1.0, 2.0, 3]]
Full program: ÐUü+NÌ/‚ζ˜ʒ.ï}DXQ#
current >> Ð  ||  stack: [[1, 1.0, 2.0, 3]]
current >> U  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> ü  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
Full program: +
current >> +  ||  stack: [1, 1.0]
stack > [2.0]
Full program: +
current >> +  ||  stack: [2.0, 1.0, 2.0]
stack > [2.0, 3.0]
Full program: +
current >> +  ||  stack: [2.0, 3.0, 2.0, 3]
stack > [2.0, 3.0, 5.0]
current >> N  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0]]
current >> Ì  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 2]
current >> /  ||  stack: [[1, 1.0, 2.0, 3], [2.0, 3.0, 5.0], 4]
current >> ‚  ||  stack: [[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]
current >> ζ  ||  stack: [[[1, 1.0, 2.0, 3], [0.5, 0.75, 1.25]]]
current >> ˜  ||  stack: [[[1, 0.5], [1.0, 0.75], [2.0, 1.25], [3, ' ']]]
current >> ʒ  ||  stack: [[1, 0.5, 1.0, 0.75, 2.0, 1.25, 3, ' ']]
Filter: .ï
Full program: .ï
current >> .  ||  stack: [1]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.5]
stack > [0]
Full program: .ï
current >> .  ||  stack: [1.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [0.75]
stack > [0]
Full program: .ï
current >> .  ||  stack: [2.0]
stack > [1]
Full program: .ï
current >> .  ||  stack: [1.25]
stack > [0]
Full program: .ï
current >> .  ||  stack: [3]
stack > [1]
Full program: .ï
current >> .  ||  stack: [' ']
invalid literal for int() with base 10: ' '
stack > []
current >> D  ||  stack: [[1, 1.0, 2.0, 3]]
current >> X  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> Q  ||  stack: [[1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3], [1, 1.0, 2.0, 3]]
current >> #  ||  stack: [[1, 1.0, 2.0, 3], 1]
[1, 1.0, 2.0, 3]
stack > [[1, 1.0, 2.0, 3]]

डिबग के साथ इसे ऑनलाइन आज़माएं!

— जादू ऑक्टोपस Urn
स्रोत

ओह, तो यह है कि कैसे üकाम करता है ... इसने मुझे मेरे पिछले उत्तरों में से एक को सुधारने की अनुमति दी :-)

— स्कूटनीट

@scottinet [1,2,3,4] ü = [[1,2],[2,3],[3,4]], अगर आप 05AB1E चलाते समय तर्कों में "-d" जोड़ते हैं, तो यह "डीबग" आउटपुट को उत्पन्न करता है जिसे मैंने ऊपर संलग्न किया है। (ऊपर डिबग लिंक भी जोड़ा गया)। जोड़ीदार साफ-सुथरा इसलिए है क्योंकि जो कमांड अपने आप वेक्टर हो जाती हैं, उनके लिए यह सिर्फ कमांड जोड़ी को लागू करता है ( ü)किसी सूची पर चलना इस बात को अच्छी तरह दिखाता है)।

— मैजिक ऑक्टोपस यूरन

मुझे पता चला कि इसने मुझे उस उत्तर पर 1 बाइट बचाने की अनुमति दी है । के रूप में -d... मैं इसे ,q"प्रिंट और बंद करो" के साथ "डिबगिंग" के बाद बहुत देर हो चुकी थी । यह दर्दनाक था।

— स्कूटनीट

@scottinet मैं एक पूरे वर्ष के लिए 05AB1E का उपयोग कर रहा था इसके बारे में :( सीखने से पहले मैं हुआ करता था। =क्योंकि यह पॉप नहीं है, और अभी पिछले आइटम ढेर करने के लिए धक्का दिया प्रिंट करता है।

— जादू ऑक्टोपस कलश

यदि आप को दूर Uआप की जगह ले सकता Xसाथ Š।

— एमिगा

8

गणितज्ञ, 72 64 59 58 बाइट्स

(d=2;#//.x_:>Riffle[x,(x+{##2,}&@@x)/d++]~Cases~_Integer)&

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

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

हम इनपुट को एक सूची के रूप में लेते हैं {p,q}। पुनरावृति कदम का सुधार इस प्रकार है:

हर दो तत्वों के (a+b)/dबीच डालें और : अंत में , के साथ अनुक्रम की गणना करता है । हम विभाजित करते हैं , और प्रत्येक के बीच और सम्मिलित करते हैं । वृद्धि ।ab(x+{##2,}&@@x)a+ba+NulldRiffle(a+b)/dabd
Integerपरिणामी सूची के तत्वों को बाहर निकालें । (यह भी, Nullद्वारा शुरू की छुटकारा मिल जाता {##2,}है।)

यह तब तक दोहराया जाता है जब तक कि परिणाम नहीं बदल जाता (जो केवल हो सकता है क्योंकि हमने सभी नए तत्वों को हटा दिया, क्योंकि उनमें से कोई भी पूर्णांक नहीं थे)।

-8 बाइट्स @MartinEnder के //.बजाय FixedPoint(और एक सूची के रूप में इनपुट लेने से) का उपयोग करने के लिए धन्यवाद ।

-6 अधिक क्योंकि ListConvolveवास्तव में वह महान नहीं है

— मिशा लावरोव
स्रोत

1

//.ट्रम्प्स FixedPoint, और मैं सिर्फ दो अलग-अलग पूर्णांकों के बजाय पूर्णांक की एक जोड़ी के रूप में इनपुट लूंगा:(d=2;#//.x_:>x~Riffle~ListConvolve[{1,1}/d++,x]~Cases~_Integer)&

— मार्टिन एंडर

धन्यवाद! मैं बदलने के लिए भूल जाते हैं //.के साथ FixedPoint, क्योंकि मैं वास्तव में बहुत पसंद है, FixedPoint।

— मिशा लावरोव

1

यह केवल 64 बाइट्स है। ऐसा लगता है कि आपने दो unprintables अंदर डाले Integer।

— मार्टिन एंडर

एक बार फिर धन्यवाद! मुझे नहीं पता था कि परिवर्तन के बाद मेरा कोड क्यों विफल रहा, और जब मैंने ऐसी चीजें कीं जो वास्तव में एक अंतर नहीं होनी चाहिए, तो काम पर वापस चली जाएगी।

— मिशा लावरोव

1

टिप्पणियों में कोड स्निपेट में कभी-कभी ये अनपेक्षित वर्ण होते हैं, खासकर जब कोड स्निपेट में लाइनब्रेक होता है। यकीन नहीं है कि एसई उन्हें क्यों सम्मिलित करता है।

— मार्टिन एंडर

4

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

->a,d=2{*b=a[0];a.each_cons 2{|x,y|z=x+y;b+=z%d>0?[y]:[z/d,y]};b==a ?a:f[b,d+1]}

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

fसरणी के रूप में इनपुट लेने वाले पुनरावर्ती कार्य [p, q]।

— नाश्ता
स्रोत

4

हास्केल, 85 81 बाइट्स

(a:b:c)#d=a:[div(a+b)d|mod(a+b)d<1]++(b:c)#d
l#d=l
l%d|l==l#d=l|e<-d+1=l#d%e
(%2)

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

इनपुट को एक सूची के रूप में लिया जाता है, जैसे [1,2]।

संपादित करें: -4 बाइट्स @ लिकोनी के लिए धन्यवाद।

— nimi
स्रोत

के साथ दो बाइट्स सहेजें l%d|l==l#d=l|e<-d+1=l#d%e।

— लैकोनी

@ लैकोनी: वास्तव में यह चार बाइट्स है। धन्यवाद!

— नीमी

3

पायथन 2 , 112 110 108 105 103 बाइट्स

^{-2 बाइट्स}^{की बदौलत}^{जोनाथन फ्रेच}
^{-5 बाइट्स की बदौलत एरिक द आउटगॉल्फ}

y=input()
x=d=1
while x!=y:
 d+=1;x=y;y=x[:1]
 for a,b in zip(x,x[1:]):c=a+b;y+=[c/d,b][c%d>0:]
print x

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

— छड़ी
स्रोत

के y+=[...]*(...);y+=b,बराबर नहीं है y+=[...]*(...)+[b]?

— जोनाथन फ्रीच

@ जोनाथनफ्रेच हां

— रॉड

103 बाइट्स

— आउटगॉल्फ

@EriktheOutgolfer मैं ऐसा करने की कोशिश कर रहा था, लेकिन 110b @ पर था। @

— Rod

3

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

f=lambda A,B=0,d=2:A*(A==B)or f(sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1]),A,d+1)

के रूप में आह्वान किया f([p,q])। इसे ऑनलाइन आज़माएं!

जोनाथन एलन ने 12 बाइट बचाए। धन्यवाद ~!

व्याख्या

fएक पुनरावर्ती समारोह है: f(A, B, d)evalutes लिए f(next_A, A, d+1), जब तक A == Bहै, जो मामले में यह रिटर्न A। (यह द्वारा नियंत्रित किया जाता है A*(A==B)or …: यदि A A*(A==B)is B, खाली सूची है, जो गलत-y है, इसलिए …भाग का मूल्यांकन किया जाता है; यदि A = B तब A*(A==B)है A, जो गैर-रिक्त है और इस प्रकार सत्य है, और यह वापस आ जाता है।)

next_A इस प्रकार गणना की जाती है:

sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])

यह सबसे अच्छा उदाहरण द्वारा समझाया गया है। जब उदा d = 5 और A = [1, 4, 11, 8, 21]:

  sum([[(l+r)/d,r][(l+r)%d>0:]for l,r in zip(A,A[1:])],A[:1])
= sum([[(1+4)/d, 4], [(4+11)/d, 11], [8], [21]], [1])
= [1] + [1, 4] + [3, 11] + [8] + [21]
= [1, 1, 4, 3, 11, 8, 21]

— लिन
स्रोत

8 बाइट्स सहेजें एक का उपयोग कर zipकी गणना के स्थान पर और का उपयोग कर [A[0]]के रूप में sumकी प्रारंभिक मूल्य।

— जोनाथन एलन

पुनरावर्ती कार्य का उपयोग करके एक और 4 बचाएं

— जोनाथन एलन

@JonathanAllan अच्छा लगा! मैं एक बाइट की जगह बचाया [A[0]]साथ A[:1]:)

— लिन

1

और अब मैं 3 बाइट्स के लिए धन्यवाद कर रहा हूं A*(A==B)।

— लिन

2

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

A=input()
m=d=1
while m:
 m=o=0;d+=1
 while A[o+1:]:
	o+=1;s=A[o-1]+A[o]
	if s%d<1:A[o:o]=s/d,;m=1;o+=1
print A

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

-8 रॉड के लिए धन्यवाद ।
-2 लिन को धन्यवाद ।

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

आप की जरूरत नहीं है iऔर a[x:x]है से कमa.insert

— रॉड

@ राड नीस (एब) का उपयोग o: पी

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

भूल जाओ zipऔर दो बाइट्स बचाओ !

— लिन

एक वैकल्पिक 111: पूरे forलूप को बदलेंwhile A[o+1:]:o+=1;s=A[o-1]+A[o];b=s%d<1;A[o:o]=[s/d]*b;m|=b;o+=b

— लिन

2

हस्क , 22 बाइट्स

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN

एक 2-तत्व सूची लेता है, पूर्णांक और फ़्लोट्स की सूची देता है। इसे ऑनलाइन आज़माएं!

व्याख्या

→UG`λf£NΣẊṠeo/⁰+:.)⁰tN  Input is a list L.
  G                 tN  Cumulative reduce over the list [2,3,4..
                   ⁰    with initial value L
   `λ             )     using flipped version of this function:
     f£NΣẊṠeo/⁰+:.       Arguments are a list, say K=[1,3,3], and a number, say d=4.
                :.       Prepend 0.5: [0.5,1,2,3]
         Ẋ               For each adjacent pair,
               +         take their sum,
            o/⁰          divide by d,
          Ṡe             and pair it with the right number in the pair: [[0.375,1],[1.0,3],[1.5,3]]
        Σ                Concatenate: [0.375,1,1.0,3,1.5,3]
     f£N                 Remove non-integers: [1,1.0,3,3]
                        Now we have an infinite list of L threaded through 2,3,4.. using the expansion operation.
 U                      Take longest prefix of unique elements,
→                       then last element of that.

— Zgarb
स्रोत

1

पर्ल 5 , 92 + 1 ( `-a`) = 93 बाइट्स

do{$c=0;@n=shift@F;$.++;push@n,($t=$_+$n[-1])%$.?$_:($c=$t/$.,$_)for@F;@F=@n}while$c;say"@F"

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

— Xcali
स्रोत

1

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

\d+
$*1;
^
11@
{+`(1+); (1+);
$1; $1$2 $2;
(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1; 
 1+ 
 
.*a
1$&
)`a

1+@

1+
$.&
;

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

अंतरिक्ष अलग संख्या के रूप में इनपुट लेता है। पर्याप्त रूप से दिए गए एल्गोरिथ्म का अनुसरण करता है, एक निशान के प्रतीक का उपयोग करने के लिए एकमात्र उल्लेखनीय तकनीक है a, यह नोट करने के लिए कि किसी भी संख्या को रखा गया था। यह रेटिना की कुछ सीमित लूपिंग क्षमताओं के साथ काम करने के लिए उपयोग किया जाता है, जो आपको केवल तब तक लूप करने की अनुमति देता है जब तक कि चरणों का एक सेट उन चरणों के इनपुट में समग्र परिवर्तन नहीं करता है।

स्पष्टीकरण:

यह प्रश्न में उसी उदाहरण का उपयोग करेगा।

\d+
$*1;

हम संख्याओं के इनपुट सरणी को एक अर्धविराम से अलग किए गए अनार्य सरणी में बदलते हैं, इसलिए हमारे पास होगा:

1; 111111111111111111111;

^
11@

dशुरुआत में हमारे कोड में डाल , हमें दे:

11@1; 111111111111111111111;

{+`(1+); (1+);
$1; $1$2 $2;

यह थोड़ा अधिक जटिल है। {चरणों का एक समूह शुरू होता है जो तब तक निष्पादित किया जाएगा जब तक कि वे एक निश्चित बिंदु तक नहीं पहुंचते। फिर, +इंगित करता है कि एक निश्चित बिंदु तक इस चरण को स्वयं निष्पादित किया जाना चाहिए। यह चरण आसन्न संख्याओं के प्रत्येक जोड़े को जोड़ता है लेकिन अतिरिक्त अर्धविराम के बिना उन्हें सम्मिलित करता है। अब हमारे पास होगा:

11@1; 1111111111111111111111 111111111111111111111;

(?<=(?=(1+)).*) (\1)+ 
 a$#2$*1;

अन्य मुश्किल चरण, यह एक पहले कैप्चर समूह में हमारे भाजक को जमा करता है, और हमारी सूची में किसी भी संख्या को एक अनुगामी अर्धविराम के बिना उस संख्या से विभाजित करता है d। हम aइन नंबरों के लिए एक अग्रणी भी जोड़ते हैं , यह इंगित करने के लिए कि कुछ रखा गया था, साथ ही ;यह इंगित करने के लिए कि यह स्थायी रूप से सरणी का हिस्सा होना चाहिए। अब हमारे पास होगा:

11@1; a11111111111; 111111111111111111111;

1+

यह उन संख्याओं को हटाता है जो dइस दौर से पहले और न ही सरणी में विभाज्य थे । यह हमारे उदाहरण में कोई बदलाव नहीं करता है।

.*a
1&$

यह लालच स्ट्रिंग की शुरुआत से aइनपुट में अंतिम अक्षर तक मेल खाता है । इसका मतलब है कि अधिकांश एक मैच में हो सकता है। यदि हमने कोई बदलाव किया है, तो हम एक को जोड़ते हैं d, अन्यथा इसे छोड़ देते हैं ताकि हम लूप से बाहर निकल सकें।

111@1; a11111111111; 111111111111111111111;

)`a

)पाश द्वारा शुरू किया बंद कर देता है {(यह सवाल नहीं है!) और अन्यथा इस स्तर सिर्फ मार्कर हम पहले नीचे रख निकाल देता है। चूंकि यह लूप का अंत है, हम उपरोक्त चरणों को कई बार दोहराएंगे, हालांकि मैं बस जारी रखने जा रहा हूं, हालांकि मैं लूप को भूल गया था, क्योंकि यह उदाहरण को और अधिक निरंतर बनाता है।

111@1; 11111111111; 111111111111111111111;

1+@

यह चरण हमारे आउटपुट से निकालता है:

1; 11111111111; 111111111111111111111;

1+
$.&

यह चरण दशमलव संख्याओं के साथ असमान संख्याओं को प्रतिस्थापित करता है:

1; 11; 21;

अंतिम चरण अर्धविराम से छुटकारा दिलाता है:

1 11 21

जाहिर है, लूप पर आउट करने से हमारे यहां गलत परिणाम होता है, लेकिन उम्मीद है कि यह बहुत भ्रामक नहीं है।

— FryAmTheEggman
स्रोत

मेरा मार्कअप पूर्वावलोकन मेरे द्वारा देखे जा रहे आउटपुट से भिन्न दिखता है - किसी के पास कोई विचार है? विशेष रूप से कोड ब्लॉक का एक समूह एक साथ जुड़ रहा है जब मुझे नहीं लगता कि उन्हें होना चाहिए।

— FryAmTheEggman

1

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

धन्यवाद @Arnauld -2 बाइट्स के लिए और 5 और बाइट्स बचाने में मदद करने के लिए।

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

एक सरणी के रूप में इनपुट लेता है f([p,q]):।

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

f=(a,d=2,r)=>a.map(v=>b.push(v,...(v+=a[++i])%d<1?[r=v/d]:[]),b=i=[])|r?f(b,d+1):a

;[[1,1],[1,2],[1,3],[2,6],[3,13],[9,9],[60,68],[144,336],[12096,24192]]
.forEach(test=>O.innerText+=JSON.stringify(test)+" -> "+JSON.stringify(f(test))+"\n")

<pre id=O></pre>

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

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

मुझे लगता है कि आप 1 बाइट बचाने के लिए उपयोग करने के बजाय अपडेट v( v+=b[++i]) कर सकते हैं s। आप |rइसके बजाय एक और बाइट बचा सकते हैं &&r(मुझे लगता है कि यह सुरक्षित है लेकिन मैंने दोबारा जांच नहीं की)।

— Arnauld

@ अरनल्ड धन्यवाद! का उपयोग करते हुए |rवास्तव में सभी परीक्षण मामलों को पारित कर दिया।

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

यहाँ 85-बाइट वेरिएंट का उपयोग किया गया है push()।

— अरनौलड

@ अर्नुलड नाइस, मैंने मूल रूप pushसे दो बार के बजाय एक बार उपयोग करने के बारे में सोचा था ; उस विचार की समीक्षा के बाद मैं के लिए आया था इस 86 बाइट्स के लिए। शायद इसमें सुधार किया जा सकता है?

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

आप कर सकते हैं push(v,...)और फिर 84 बाइट्स केv+= लिए फिर से उपयोग करें ।

— Arnauld

1

रोड़ा , 90 बाइट्स

f a,d=2{A=[a()|slide 2|[_,(_1+_)/d]if[(_1+_2)%d=0]else[_1]]+a[-1]f A,d=d+1 if[a!=A]else A}

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

— fergusq
स्रोत

1

जावा 8, 180 बाइट्स

import java.util.*;p->q->{List<Integer>r=new Stack();r.add(p);r.add(q);for(int d=1,f=d,i;f==d++;)for(i=1;i<r.size();i++)if((q=r.get(i)+r.get(i-1))%d<1)r.add(i++,q/(f=d));return r;}

स्पष्टीकरण:

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

import java.util.*;           // Required import for List and Stack

p->q->{                       // Method with two integer parameters and List return-type
  List<Integer>r=new Stack(); //  Result-list
  r.add(p);r.add(q);          //  Add the two input-integers to the List
  for(int d=1,                //  Divisible integer (starting at 1)
          f=d,                //  Temp integer (starting at `d` / also 1)
          i;                  //  Index-integer
      f==d++;)                //  Loop (1) as long as `f` and `d` are equal
                              //  (and raise `d` by 1 so it starts at 2 inside the loop)
    for(i=1;                  //   Reset index-integer to 1
        i<r.size();i++)       //   Inner loop (2) over the List
      if((q=r.get(i)+r.get(i-1)) 
                              //    If the current + previous items (stored in `q`)
         %d<1)                //    are divisible by `d`:
        r.add(i++,q/(f=d));   //     Insert `q` divided by `d` to the List at index `i`
                              //     (and raise `i` by 1 and set `f` to `d` in the process)
                              //   End of inner loop (2) (implicit / single-line body)
                              //  End of loop (1) (implicit / single-line body)
  return r;                   //  Return the result-List
}                             // End of method

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

1

सी #, 280 बाइट्स

using System.Linq;class A{static void Main(string[] p){var l=new System.Collections.Generic.List<int>(p.Select(int.Parse));int r,d=2,c;do{c=0;for(int i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);l.ForEach(v=>System.Console.Write((v+" ")));}}

कोड गोल्फ में पहला प्रयास, जो पूरा कार्यक्रम है। झसे आज़माओ

प्रयास 2, 159 बाइट्स

मचान को हटाकर, चूंकि कार्य एक ऐसा फ़ंक्शन प्रदान करना है जो संख्याओं की जोड़ी ले सकता है (एक सरणी काम करता है) और एक सरणी देता है। यह देखते हुए कि एक फंक <int [], int []> F का उपयोग आवश्यकताओं को पूरा करने के लिए किया जा सकता है, बस F को परिभाषित करें :

F=v=>{var l=new List<int>(v);int i,r,d=2,c;do{c=0;for(i=1;i<l.Count;++i){if((r=l[i-1]+l[i])%d==0){l.Insert(i++,r/d);++c;}}++d;}while(c>0);return l.ToArray();};

पूर्ण कार्यक्रम यहां देखें

यह छोटा हो सकता है यदि एक सामान्य सूची को एक वैध आउटपुट माना जाता है (10। को बचाने के लिए .ToArray () को छोड़ दें)।

यदि इनपुट को संशोधित भी किया जा सकता है, तो एक सरणी के बजाय एक सूची <int> में पास करना आउटपुट को इनिशियलाइज़ करने की आवश्यकता को हटा देता है (126 बाइट्स पर निकलता है)।

इसे एक कदम आगे बढ़ाते हुए, इस मामले में वास्तव में रिटर्न वैल्यू होने की आवश्यकता नहीं है। बदले में एक स्टेटमेंट का उपयोग करके रिटर्न स्टेटमेंट द्वारा उपयोग किए गए 9 बाइट्स को हटा देता है।

— फ़ैशन
स्रोत

PPCG में आपका स्वागत है! अच्छा पहला जवाब।

— अरनौलद

1

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

®‘©‘÷@+2\⁸żFfṀR$µÐL

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

— डेनिस
स्रोत

एक विस्तार सरणी

उदाहरण

स्पष्टीकरण और नियम

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

05AB1E , 28 19 18 बाइट्स

गणितज्ञ, 72 64 59 58 बाइट्स

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

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

हास्केल, 85 81 बाइट्स

पायथन 2 , 112 110 108 105 103 बाइट्स

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

व्याख्या

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

हस्क , 22 बाइट्स

व्याख्या

पर्ल 5 , 92 + 1 ( -a) = 93 बाइट्स

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

स्पष्टीकरण:

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

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

रोड़ा , 90 बाइट्स

जावा 8, 180 बाइट्स

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

पर्ल 5 , 92 + 1 ( `-a`) = 93 बाइट्स