गणित में, यह पता लगाने का एक तरीका है कि किसी दिए गए संबंध का प्रकार (रैखिक, द्विघात, आदि) मतभेदों की गणना करने के लिए क्या है। ऐसा करने के लिए आप y मानों की एक सूची लेते हैं, जिसके लिए संवाददाता x मानों के बीच का अंतर समान होता है, और इसके ऊपर की संख्या से प्रत्येक को घटाएं, संख्याओं की सूची को एक छोटी और फिर पिछली सूची बनाएं। यदि परिणामी सूची पूरी तरह से समान संख्याओं से बनी होती है, तो संबंध में 1 का अंतर होता है (यह रैखिक है)। यदि वे समान नहीं हैं, तो आप नई सूची पर प्रक्रिया को दोहराते हैं। यदि वे अब समान हैं, तो संबंध में 2 का अंतर है (यह द्विघात है)। यदि वे समान नहीं हैं, तो आप इस प्रक्रिया को तब तक जारी रखेंगे जब तक वे हैं। उदाहरण के लिए, यदि आपके पास y मानों की सूची है [१,६,१५,२,,४५,६६] वेतन वृद्धि के लिए x मान निम्न है:

First Differences:

1
6   1-6  =-5
15  6-15 =-9
28  15-28=-13
45  28-45=-17
66  45-66=-21

Second differences:

-5 
-9  -5+9  =4
-13 -9+13 =4
-17 -13+17=4
-21 -17+21=4

As these results are identical, this relation has a difference of 2

आपका कार्य:

एक प्रोग्राम या फ़ंक्शन लिखिए, जब इनपुट के रूप में पूर्णांक की एक सरणी दी जाती है, तो सरणी द्वारा वर्णित संबंध का अंतर, जैसा कि ऊपर बताया गया है, वापस करता है।

इनपुट:

पूर्णांकों की एक सरणी, जो किसी भी लंबाई> 1 हो सकती है।

आउटपुट:

इनपुट द्वारा वर्णित संबंध के अंतर का प्रतिनिधित्व करने वाला पूर्णांक।

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

Input                            => Output
[1,2,3,4,5,6,7,8,9,10]           => 1
[1,4,9,16,25,36]                 => 2
[1,2,1]                          => 2 (when there is only one value left, all values are automatically identical, so the largest difference an array can have is equal to the length of the array-1)
"Hello World"                    => undefined behavior (invalid input)
[1,1,1,1,1,1,1,1,1]              => 0 (all elements are already identical)
[1, 3, 9, 26, 66, 150, 313, 610] => 6

स्कोरिंग:

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

code-golf math array-manipulation

— ग्रीफॉन - मोनिका को बहाल करना
स्रोत

क्या इनपुट "अमान्य" हो सकता है, यदि इनपुट प्रदान किए गए युक्ति के अनुरूप नहीं है, तो क्या हमें त्रुटि होनी चाहिए? आउटपुट के रूप में -1 प्रदान करें?

— मैजिक ऑक्टोपस Urn

व्यवहार अमान्य इनपुट के लिए अपरिभाषित है (मुझे परवाह नहीं है कि आपका कोड क्या करता है)

— ग्राइफॉन -

[1,2,1]2 नहीं देना चाहिए ? [1,2,1] -> [1,-1] -> [-2]

— हाइपरएन्यूट्रिनो

@ हिपरनेत्रो, हाँ, क्षमा करें। मेरा वहां एक मस्तिष्क-गला था

— ग्रिफन -

इस टेस्ट केस को जोड़ें [1,3,9,26,66,150,313,610]-> 6अगर आपको पसंद है

— J42161217

10

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

धन्यवाद लियो ने मुझे उसके संस्करण का उपयोग करने की अनुमति दी जो इसके लिए काम करता है[1,1,1,1,1,1]

←VE¡Ẋ-

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

व्याख्या

   ¡     Repeatedly apply function, collecting results in a list
    Ẋ-     Differences
 VE      Get the index of the first place in the list where all the elements are equal
←        Decrement

— H.PWiz
स्रोत

2

जब भी किसी ने कहा कि हस्क नई जेली है, तो वे बहुत सही थे। > _ <

— Zacharý

अरे, मैं यह पोस्ट करने वाला था । अच्छी नौकरी हालांकि, +1!

— सिंह

@Leo, परीक्षण मामला जो मैंने नहीं देखा [1,1,1,1], क्या मैं आपका उपयोग कर सकता हूं?

— H.PWiz

@ H.PWiz यकीन है, जाओ!

— सिंह

7

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

f=a=>-a.every(x=>i=!x)||1+f(a.map(n=>n-a[++i]))

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

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

f=a=>-a.every(x=>i=!x)||1+f(a.map(n=>n-a[++i]))

console.log(f([1,2,3,4,5,6,7,8,9,10]))    // 1
console.log(f([1,4,9,16,25,36]))          // 2
console.log(f([1,2,1]))                   // 2
console.log(f([1,1,1,1,1,1,1,1,1]))       // 0
console.log(f([1,3,9,26,66,150,313,610])) // 6

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

— Arnauld
स्रोत

7

MATL , 8 बाइट्स

`dta}x@q

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

व्याख्या

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

`      % Do... while
  d    %   Consecutive diffferences. Takes input (implicitly) the first time
  t    %   Duplicate
  a    %   True if any element is nonzero. This is the loop condition
}      % Finally (execute before exiting the loop)
  x    %   Delete. This removes the array of all zeros
  @    %   Push iteration index
  q    %   Subtract 1. Implicitly display
       % End (implicit). Proceed with next iteration if top of the stack is true

— लुइस मेंडो
स्रोत

7

आर , 50 44 बाइट्स

function(l){while(any(l<-diff(l)))F=F+1
F*1}

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

एक ले जाता है diffकी l, सेट इसे करने के लिए l, और जांच करता है कि परिणाम किसी भी अशून्य मान हैं। अगर ऐसा होता है, तो वृद्धि F(प्रारंभिक रूप में FALSEअनुमानित), और इस घटना में F*1परिवर्तित होने के FALSEलिए वापस आती है 0कि सभी lपहले से ही समान हैं।

— ग्यूसेप
स्रोत

+F5 बाइट्स के लिए पूरा कार्यक्रम और चाल । नीट उत्तर btw!

— JayCe

5

मैथेमेटिका, 49 बाइट्स

(s=#;t=0;While[!SameQ@@s,s=Differences@s;t++];t)&

thanx @alephalpa for -6 बाइट्स और @hftf -1 बाइट

और यहाँ @hftf का एक और तरीका है

मैथेमेटिका, 49 बाइट्स

Length@NestWhileList[Differences,#,!SameQ@@#&]-1&

— J42161217
स्रोत

(s=#;t=0;While[UnsameQ@@s,s=Differences@s;t++];t)&

— एलेफल्फा

1

UnsameQ[1,2,1]गलत है; !SameQ[1,2,1]सच हैं। मुझे नहीं लगता कि मैनुअल लूप या तो पात्रों को बचाता है: Length@NestWhileList[Differences,#,!SameQ@@#&]-1&पहले से ही आपकी लंबाई के UnsameQसाथ की जगह है !SameQ।

— hftf

4

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

-Iß$E?‘

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

व्याख्या

-Iß$E?‘  Input: array A
     ?   If
    E    All elements are equal
         Then
-          Constant -1
         Else
   $       Monadic chain
 I           Increments
  ß          Recurse
      ‘  Increment

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

गैर-पुनरावर्ती विकल्प:IÐĿE€ċ0

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

4

जाप , 10 7 बाइट्स

è@=ä-)d

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

इस तथ्य पर निर्भर करता है कि परिणाम इनपुट सरणी की लंबाई के भीतर होने की गारंटी है।

व्याख्या

è@=ä-)d     Implcit input of array U
 @          For each value in U...
  =ä-)      Update U to be equal to its subsections, each reduced by subtraction
      d     Check if any values in that are truthy
è           Count how many items in that mapping are true

अंत तक, यह सरणी
[1, 3, 9, 26, 66, 150, 313, 610]को मैप करेगा [true, true, true, true, true, true, false, false],
जिसमें 6 trues शामिल है ।

पिछला 10 बाइट संस्करण

@=ä-)e¥0}a

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

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

4

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

{($_,{@(.[] Z- .[1..*])}...*.none)-2}

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

स्पष्टीकरण: फ़ंक्शन इनपुट को एक सूची के रूप में लेता है। यह इस तरह एक पुनरावर्ती अनुक्रम बनाता है: पहला तत्व मूल सूची ( $_) है, अगले तत्वों को {@(@$_ Z- .[1..*])}पिछले तत्व पर कॉल करके वापस किया जाता है, और जब तक कि स्थिति *.noneसही न हो, तब तक इसे पुनरावृत्त किया जाता है, जो सूची या तो तब होता है खाली या केवल शून्य (या, तकनीकी रूप से, अन्य गलत मूल्य) शामिल हैं। फिर हम सूची को पकड़ते हैं और उसमें से 2 घटाते हैं, जो इसे पहले संख्यात्मक संदर्भ के लिए मजबूर करता है (और संख्यात्मक संदर्भ में सूची उनके तत्वों की संख्या के बराबर होती है) और, अंत में, तत्वों की संख्या की तुलना में 2 कम रिटर्न देता है। सूची।

अजीब ब्लॉक {@(@$_ Z- .[1..*])}बस दी गई सूची लेता है ( .[]- तथाकथित ज़ेन स्लाइस - खाली कोष्ठक के साथ अनुक्रमण पूरी सूची देता है), शून्य Z-तत्व का उपयोग करके इसे ज़िप करता है ( ) पहले तत्व के बिना एक ही सूची के साथ ( .[1..*]) और इसे सूची में सम्मिलित करता है ( @(...)- हमें इसकी आवश्यकता है क्योंकि ज़िप केवल एक Seq देता है, जो मूल रूप से एक तरह से एक सूची है जिसे केवल एक बार पुनरावृत्त किया जा सकता है। ऐसा कुछ है जो हमें पसंद नहीं है।) और वह यह है।

— Ramillies
स्रोत

दो बाइट को बचाने के @(.[] Z- .[1..*])लिए बदलना [.[] Z-.[1..*]]चाहिए।

— नवलन्होफ़

4

जावा 8, 191 + 58 = 249 198 140 बाइट्स।

51 बाइट्स के लिए धन्यवाद PunPun1000।
धन्यवाद बाइट 58 बाइट्स के लिए।

int f(int[]a){int x=a.length-1,b[]=new int[x];for(;x-->0;)b[x]=a[x+1]-a[x];return java.util.Arrays.stream(a).distinct().count()<2?0:1+f(b);}

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

इसे ऑनलाइन आज़माएं (198 बाइट संस्करण)

तो, यह मेरी पहली बार यहाँ पीपीसीजी में पोस्टिंग है (और पहली बार कोड गोल्फ चैलेंज कर रही है)। किसी भी रचनात्मक आलोचना का स्वागत और सराहना की जाती है। मैंने पोस्टिंग के लिए दिशानिर्देशों का पालन करने की कोशिश की, अगर कुछ भी सही नहीं है तो इसे इंगित करने के लिए स्वतंत्र हैं।

सुशोभित संस्करण:

int f(int[] a) {
    int x = a.length - 1, b[] = new int[x];
    for (; x-- > 0;) {
        b[x] = a[x + 1] - a[x];
    }
    return java.util.Arrays.stream(a).distinct().count() < 2 ? 0 : 1 + f(b);
}

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

3

साइट पर आपका स्वागत है!

— DJMcMayhem

उन मॉड्यूल को आयात करने के बजाय आप बस इस्तेमाल कर सकते हैंjava.util.stream.IntStream k = java.util.Arrays.stream(a);

— PunPun1000

वास्तव में, कुछ बदलाव हैं जो आप मुफ्त में कर सकते हैं। 1) publicबाइट की गिनती में शामिल होने की आवश्यकता नहीं है। 2) आपको दूसरे पैरामीटर को स्वीकार नहीं करना चाहिए, लेकिन इसे हटाने से वास्तव में बाइट्स को बचाया जा सकता है। 3) आप वहां कुछ गैर-जरूरी ब्रैकेट्स निकाल सकते हैं

— पुनपुन 1000

4) नहीं सेवर लेकिन आप एक TIO को शामिल करना चाहिए यदि संभव हो तो, यहां 198 में उन सुझावों के साथ एक उदाहरण है बाइट्स TIO

— PunPun1000

1

140 बाइट्स

— नेवई

3

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

g l|all(==l!!0)l=0|0<1=1+g(zipWith(-)l$tail l)

यह बस पुनरावृत्ति करता है - zipWith(-)l$last lकी अंतर सूची है l। और gवह फ़ंक्शन है जो प्रश्न का उत्तर देता है।

— गर्वित हेकलर
स्रोत

पुनरावर्ती समाधान अच्छा था।

— जेफर्ड

@ जेरार्ड यह बहुत ही सच्चा है

— गर्वित हेकलर

3

कोटलिन , 77 बाइट्स

पहली पोस्ट, kotlin पर अंतिम उत्तर को 2 बार संपादित करने का प्रयास किया; डी

{var z=it;while(z.any{it!=z[0]})z=z.zip(z.drop(1),{a,b->a-b});it.size-z.size}

@jrtapsell से परीक्षण भाग लिया

TryItOnline

— cab404
स्रोत

PPCG में आपका स्वागत है! अच्छा पहला जवाब, एक आउटगोल्फ भी।

— एच। वाइज

3

एपीएल (डायलॉग क्लासिक) , 22 17 बाइट्स

{1=≢∪⍵:0⋄1+∇2-/⍵}

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

-5 बाइट्स के लिए @ngn को धन्यवाद!

कैसे?

{ ... }, कार्यक्रम
1=≢∪⍵:0, यदि प्रत्येक तत्व तर्क में समान है, तो वापस लौटें 0
1+∇2-/⍵, अन्यथा, nअंतर का 1 + लौटाएं (जो है n-1, इस प्रकार इसमें एक जोड़ देता है n)

— जाकारी
स्रोत

यह छोटा है अगर आप पूंछ recursiveness बलिदान:{1=≢∪⍵:0⋄1+∇2-/⍵}

— NGN

2

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

IÐĿEÐḟL

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

व्याख्या

IÐĿEÐḟL  Main link
 ÐĿ      While results are unique (which is never so it stops at [])
I        Take the increments, collecting intermediate values # this computes all n-th differences
    Ðḟ   Filter out
   E     Lists that have all values equal (the first n-th difference list that is all equal will be removed and all difference lists after will be all 0s)
      L  Take the length (this is the number of iterations required before the differences become equal)

-1 जोनाथन एलन को धन्यवाद

— HyperNeutrino
स्रोत

1

@Gryphon किया! :)

— हाइपरनेत्रिनो

IÐĿEÐḟLसात के लिए (मुझे लगता है कि मीलों ने भी एक सात का उपयोग करके पाया)।

— जोनाथन एलन

@JonathanAllan कूल धन्यवाद!

— हाइपरएन्यूट्रीनो

2

05AB1E , 7 बाइट्स

[DË#¥]N

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

व्याख्या

[         # start loop
 D        # duplicate current list
  Ë       # are all elements equal?
   #      # if so, break
    ¥     # calculate delta's
     ]    # end loop
      N   # push iteration counter

— Emigna
स्रोत

2

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

f=a=>+(b=a.slice(1).map((e,i)=>e-a[i])).some(e=>e)&&1+f(b)

— नील
स्रोत

+0, पर्याप्त नहीं Jquery: पी। हालांकि वास्तव में, +1, अच्छा काम, मुझे पता है कि मैं कभी भी जेएस में गोल्फ नहीं कर पाऊंगा।

— 23

2

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

-7 बाइट्स जोनाथन एलन को धन्यवाद।

f=lambda l,c=1:any(l)and f([j-i for i,j in zip(l,l[1:])],c-1)or-c

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

— totallyhuman
स्रोत

एक बाइट को बचाने , घटाने और फिर इस्तेमाल करने cसे बचाएं । 1print-c

— जोनाथन एलन

एक पुनरावर्ती कार्य में बनाकर छह और बचाएं:f=lambda l,c=1:any(l)and f([j-i for i,j in zip(l,l[1:])],c-1)or-c

— जोनाथन एलन

क्या यह सिर्फ मेरे लिए है या पर्याप्त बाइट्स को बचाने के लिए एक पुनरावर्ती लंबोदर पर स्विच नहीं है? : पी थैंक्स!

— पूरी तरह से

मुझे लगता है कि परीक्षण मामलों max(...,0)को पारित करने के लिए इसकी आवश्यकता है [1, 1, 1, 1, ...]।

— योनातन एन

2

दिल्लोग एपीएल, 19 बाइट्स

≢-1+(≢2-/⍣{1=≢∪⍵}⊢)

स्पष्टीकरण:

≢                      length of input
 -1+(             )    minus 1+
     ≢                 length of
      2-/              differences between elements
         ⍣             while
          {1=≢∪⍵}      there is more than 1 unique element
                 ⊢     starting with the input

— मारीनस
स्रोत

1

क्या यह काम करता है? ≢-1+∘≢2-/⍣{1=≢∪⍵}⊢

— जकार्इ

2

k , 21 बाइट्स

#1_(~&/1_=':)(1_-':)\

यह k में काम करता है, लेकिन oK में नहीं, क्योंकि oK का लूप कंडीशन को चेक करने से पहले चलता है (जैसा कि पहले कंडीशन को चेक करने के लिए विरोध किया जाता है, और फिर कोड को चलाने पर)। इसलिए, ओके में, 1 1 1 1 1उदाहरण ठीक से काम नहीं करेगा।

ऑनलाइन OK की कोशिश करो!

स्पष्टीकरण:

   (        )       \ /while(
    ~&/               /      not(min(
       1_=':          /              check equality of all pairs))) {
             (1_-':)  /    generate difference list
                      /    append to output }
#1_                   /(length of output) - 1

— zgrep
स्रोत

~&/1_=':->1<#?

— ngn

2

हास्केल , 66 61 60 बाइट्स

z=(=<<tail).zipWith
f=length.takeWhile(or.z(/=)).iterate(z(-))

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

सहेजे गए 5 बाइट्स क्रिश्चियन सिवर्स को धन्यवाद

गर्व-हेकलर के लिए 1 बाइट धन्यवाद

iterate(z(-)) अंतर सूचियों की गणना करता है।

or.z(/=) परीक्षण अगर उन सूचियों में गैर बराबर तत्व हैं।

length.takeWhile गैर-समान तत्वों के साथ अंतर सूचियों को गिना जाता है।

— jferard
स्रोत

मुझे लगता है कि आप गैर-समान तत्वों के लिए परीक्षण कर सकते हैंor.z(/=)

— क्रिश्चियन सेवर्स

@ChristianSievers धन्यवाद! यही कारण है कि स्पष्ट था, लेकिन मैं इसे नहीं देखा ...

— jferard

तुम भी उपयोग कर सकते हैं z=(=<<tail).zipWith, एक बाइट छोटी

— घमंड haskeller

@proudhaskeller और अधिक सुरुचिपूर्ण, हमेशा बिंदु मुक्त परिभाषाओं के साथ। धन्यवाद!

— 20

2

जावा (ओपनजेडके 8) , 98 94 बाइट्स

a->{int o=0,i,z=1;for(;z!=0;o++)for(i=a.length-1,z=0;i>o;a[i]-=a[--i])z|=a[o]^a[i];return~-o;}

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

— Nevay
स्रोत

2

जाप , 7 बाइट्स

एक अलग कार्यान्वयन के साथ जस्टिन के रूप में एक ही दृष्टिकोण (लेकिन स्वतंत्र रूप से व्युत्पन्न) ।

£=äaÃèx

झसे आज़माओ

व्याख्या

सरणी का निहित इनपुट U।

£   Ã

प्रत्येक तत्व पर नक्शा।

äa

äतत्वों की प्रत्येक अनुक्रमिक जोड़ी ( ) लें Uऔर इसे पूर्ण अंतर से कम करें ( a)।

उस सरणी को पुन: असाइन करें U।

èx

गणना ( è) उप-सरणियों की संख्या जो सत्यता लौटाती है (यानी, गैर-शून्य) जब जोड़ से कम हो जाती है।

— झबरा
स्रोत

1

टीआई-बेसिक, 19 बाइट्स

While max(abs(ΔList(Ans
ΔList(Ans
IS>(A,9
End
A

डिफ़ॉल्ट रूप से, चर शून्य पर शुरू होते हैं। इसके अलावा, कभी नहीं सोचा था कि मैं IS>(किसी भी उपयोगी चीज के लिए उपयोग करूंगा ।

— Timtech
स्रोत

1

सी # (.NET कोर) , 70 69 + 18 बाइट्स

केविन क्रूज़सेन के लिए धन्यवाद

g=a=>i=>a.Distinct().Count()>1?g(a.Zip(a.Skip(1),(y,z)=>y-z))(i+1):i;

सही ढंग से संचालित करने के लिए कॉल करते समय 0 दिया जाना चाहिए। बाइट गिनती में भी शामिल:

using System.Linq;

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

स्पष्टीकरण:

g = a => i =>                      // Function taking two arguments (collection of ints and an int)
    a.Distinct()                   // Filter to unique elements
    .Count() > 1 ?                 // If there's more than one element
        g(                         //     Then recursively call the function with
            a.Zip(                 //     Take the collection and perform an action on corresponding elements with another one
                a.Skip(1),         //         Take our collection starting at second element
                (y, z) => y - z    //         Perform the subtraction
            )
        )(i + 1)                   //     With added counter
        : i;                       // Otherwise return counter

Iterative संस्करण 84 + 18 बाइट्स:

a=>{int i=0;for(;a.Distinct().Count()>1;i++)a=a.Zip(a.Skip(1),(y,z)=>y-z);return i;}

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

— ग्रेज़गोरज़ पुलावस्की
स्रोत

1

आप अनावश्यक स्थान को हटा सकते हैं (y,z)=>y-z। लेकिन अच्छा जवाब, +1 मुझसे।

— केविन क्रूजेसेन

@ केविनक्रूजसेन धन्यवाद! इसके अलावा, उफ़।

— ग्रेजगोरज पूलावस्की

1

क्लोजर, 62 बाइट्स

#(loop[c % i 0](if(apply = c)i(recur(map -(rest c)c)(inc i))))

अच्छी तरह से =किसी भी तर्क ले सकते हैं, और एक भी तर्क "खुद" के समान है। (apply = [1 2 3])के रूप में निष्पादित किया जाता है (= 1 2 3)।

— NikoNyrh
स्रोत

अच्छा, ठीक है कि मैं क्या करने की कोशिश कर रहा था, लेकिन मैं एक कॉम्पैक्ट जोड़ी के लिए संघर्ष कर रहा था। यह शानदार है, मुझे भविष्य के लिए यह याद रखना होगा।

— मट्टपुत्तनम

1

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

W.E.+Q=.+Q=hZ)Z

सभी परीक्षण मामलों की जाँच करें।

कैसे?

स्पष्टीकरण # 1

W.E.+Q=hZ=.+Q)Z   ~ Full program.

W                 ~ While...
 .E.+Q            ~ ... The deltas of Q contain a truthy element.
      =hZ         ~ Increment a variable Z, which has the initial value of 0.
         =        ~ Transform the variable to the result of a function applied to itself...
          .+Q     ~ ... Operate on the current list and deltas.
             )Z   ~ Close the loop and output Z.

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

-1 बाइटWtl{Q=hZ=.+Q)Z

— डेव

@ और भी बेहतर WP{Q=hZ=.+Q)Z:। धन्यवाद!

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

0

पर्ल 5 , 83 + 1 (-ए) = 84 बाइट्स

sub c{$r=0;$r||=$_-$F[0]for@F;$r}for(;c;$i=0){$_-=$F[++$i]for@F;$#F--}say y/ //-$#F

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

एक स्थान से अलग संख्या की सूची के रूप में इनपुट।

— Xcali
स्रोत

0

पाइके , 11 बाइट्स

W$D}ltoK)Ko

यहाँ कोशिश करो!

— नीला
स्रोत

0

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

tf!t{.+FQt

यदि हम 1 से इंडेक्स कर सकते हैं, तो हम अग्रणी को हटाकर एक बाइट बचा सकते हैं t।

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

व्याख्या

tf!t{.+FQt
 f        T  Find the first (1-indexed) value T...
     .+FQt   ... such that taking the difference T - 1 times...
  !t{        ... gives a set with more than one value in it.
t            0-index.

0

कोटलिन , 83 बाइट्स

{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

सजा हुआ

{
    // Make input mutable
    var z=it
    // Count for returning
    var c=0
    // While the array is not identical
    while (z.any { it != z[0] }) {
        // Increment count
        c++
        // Update list to differences
        z = (0..z.size-2).map { z[it+1] - z[it] }
    }
    // Return count
    c
}

परीक्षा

var n:(List<Int>)->Int =
{var z=it
var c=0
while(z.any{it!=z[0]}){c++
z=(0..z.size-2).map{z[it+1]-z[it]}}
c}

data class TestData(var input: List<Int>, var output: Int)

fun main(args: Array<String>) {
    val items = listOf(
        TestData(listOf(1,2,3,4,5,6,7,8,9,10), 1),
        TestData(listOf(1,4,9,16,25,36), 2),
        TestData(listOf(1,2,1), 2),
        TestData(listOf(1,1,1,1,1,1,1,1,1), 0),
        TestData(listOf(1, 3, 9, 26, 66, 150, 313, 610), 6)
    )

    val fails = items.map { it to n(it.input) }.filter { it.first.output != it.second }

    if (fails.isEmpty()) {
        println("Test passed")
    } else {
        fails.forEach {println("FAILED: $it")}
    }
}

TryItOnline

— jrtapsell
स्रोत

अगर कोई मेरी भाषा के संकेतों को ठीक करने के लिए संपादित कर सकता है, तो मैं उन्हें काम पर नहीं

— ला

यह lang-kotlin, kotlinहाइलाइटर के संकेत में नहीं है।

— रुस्लान

0

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

func f(_ a:[Int])->Int{return a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

वैकल्पिक, क्लोजर-आधारित कार्यान्वयन:

var f: ((_ input: [Int]) -> Int)!
f = {a in a.contains{$0 != a[0]} ?f(zip(a, a.dropFirst()).map(-))+1:0}

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

let testcases: [(input: [Int], expected: Int)] = [
    (input: [1,2,3,4,5,6,7,8,9,10],           expected: 1),
    (input: [1,4,9,16,25,36],                 expected: 2),
    (input: [1,2,1],                          expected: 2),
    (input: [1,1,1,1,1,1,1,1,1],              expected: 0),
    (input: [1, 3, 9, 26, 66, 150, 313, 610], expected: 6),
]

for (caseNumber, testcase) in testcases.enumerated() {
    let actual = f(testcase.input)
    assert(actual == testcase.expected,
        "Testcase #\(caseNumber) \(testcase.input) failed. Got \(actual), but expected \(testcase.expected)!")
    print("Testcase #\(caseNumber) passed!")
}

— अलेक्जेंडर - मोनिका को बहाल करें
स्रोत

नथ भेद

आपका कार्य:

इनपुट:

आउटपुट:

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

स्कोरिंग:

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

व्याख्या

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

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

MATL , 8 बाइट्स

व्याख्या

आर , 50 44 बाइट्स

मैथेमेटिका, 49 बाइट्स

मैथेमेटिका, 49 बाइट्स

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

व्याख्या

जाप , 10 7 बाइट्स

व्याख्या

पिछला 10 बाइट संस्करण

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

जावा 8, 191 + 58 = 249 198 140 बाइट्स।

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

कोटलिन , 77 बाइट्स

एपीएल (डायलॉग क्लासिक) , 22 17 बाइट्स

कैसे?

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

व्याख्या

05AB1E , 7 बाइट्स

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

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

दिल्लोग एपीएल, 19 बाइट्स

k , 21 बाइट्स

हास्केल , 66 61 60 बाइट्स

जावा (ओपनजेडके 8) , 98 94 बाइट्स

जाप , 7 बाइट्स

व्याख्या

टीआई-बेसिक, 19 बाइट्स

सी # (.NET कोर) , 70 69 + 18 बाइट्स

क्लोजर, 62 बाइट्स

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

कैसे?

स्पष्टीकरण # 1

पर्ल 5 , 83 + 1 (-ए) = 84 बाइट्स

पाइके , 11 बाइट्स

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

कोटलिन , 83 बाइट्स

सजा हुआ

परीक्षा

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