अंतिम संख्या

Question

चुनौती

एक प्रोग्राम लिखें जो 4 पूर्णांक लेता है ( जो एक निश्चित एल्गोरिथम द्वारा उत्पन्न संख्याओं के अनुक्रम का प्रतिनिधित्व करता है ) और अगले पूर्णांक का अनुसरण करता है।

हम केवल एक निरंतर (यानी गैर-चर) भिन्नता के साथ सरल जोड़, घटाव, गुणा और भाग एल्गोरिदम का उपयोग करेंगे।

विभाजन के लिए हम floorपूर्णांक मानों का उपयोग करेंगे : 133/4 = 33और33/4 = 8

आप मान सकते हैं कि हमेशा एक ही वैध रिटर्न वैल्यू होगी

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

[14,24,34,44] 54 लौटाना चाहिए (इसके अलावा एल्गोरिथम)

[105,45,-15,-75] -135 (घटाव एल्गोरिथ्म) वापस करना चाहिए

[5,25,125,625] 3125 (गुणक एल्गोरिथम) वापस करना चाहिए

[256,64,16,4] 1 (विभाजन एल्गोरिथ्म) वापस करना चाहिए

सामान्य नियम

• यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे छोटा जवाब चुनौती जीतता है।
• मानक खामियों को मना किया जाता है

Comments

यह आगे आने वाले संस्करण का एक सरलीकृत संस्करण है । और सीमा रेखा डुप्लिकेट।

— पीटर टेलर

भविष्य में, मैं आपको लाइव जाने से पहले सैंडबॉक्स में पोस्ट करने की सलाह देता हूं ताकि आप पहले से अन्य लोगों की टिप्पणियों को प्राप्त कर सकें।

— लीकी नून

पूर्णांक विभाजन के लिए आपको वास्तव में कुछ परीक्षण मामलों को जोड़ना चाहिए। लगभग सभी उत्तर [261,65,16,4], [4,2,1,0], या [2,1,0,0]

— डेमियन

मैं डुप्लिकेट वोट (मतों) से असहमत हूं। एल्गोरिथ्म ढूँढना इस अर्थ में सरल है कि विचार करने के लिए केवल एक ही ऑपरेशन है, लेकिन एक ही समय में, यह कठिन है क्योंकि पूर्णांक विभाजन के लिए जिम्मेदार है। मुझे नहीं लगता कि खरोंच से एक लिखने की तुलना में दूसरी चुनौती से जवाब देना काफी आसान होगा।

— डेनिस

आपको शायद गैर-नकारात्मक पूर्णांक निर्दिष्ट करना चाहिए, जब एक विभाजन श्रृंखला नकारात्मक होती है तो दो व्याख्याएं होती हैं। उदाहरण के लिए या -81/4तो है । 21 r 3-20 r -1

— जोनाथन एलन

Answer 1

05AB1E , 18 16 18 बाइट्स

D¥¬QPi`+s-ë`r/s\*î

व्याख्या

D                   # duplicate
 ¥                  # delta's
  ¬Q                # compare first delta to the other deltas
    P               # product (1 if all deltas are equal, otherwise 0)
     i              # if 1 (we're dealing with addition or subtraction)
      `+s-          # add the difference between the elements to the last element
          ë         # else (we're dealing with multiplication or division)
           `r/      # divide the 2nd element by the 1st
              s\*   # multiply with the 4th element
                 î  # round up

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

Comments

[4,2,1,0] के साथ आउटपुट गलत है ...

— डेमियन

@ डैमियन: मुझे बताने के लिए धन्यवाद। मैंने इसे ठीक कर दिया और इसने मुझे बाइट्स की एक जोड़ी भी बचा दी :)

— एमिग्ना

महान। अब यह मेरे सभी परीक्षण मामलों को मान्य करता है।

— डेमियन

चार से विभाजित करने के लिए किनारे मामले की कोशिश करें:[-325, -82, -21, -6]

— जोनाथन एलन

... वास्तव में मुझे लगता है कि प्रश्न या तो केवल गैर-नकारात्मक पूर्णांक के लिए होना चाहिए या यह निर्दिष्ट करना चाहिए कि किस सम्मेलन का उपयोग किया जाना है।

— जोनाथन एलन

Answer 2

जावास्क्रिप्ट (ईएस 6),  44   42  44 बाइट्स (निश्चित)

(a,b,c,d)=>a-b+d-c?d/(a<b?a/b:a/b|0)|0:d+c-b

IsmaelMiguel की सलाह के बाद, 2 बाइट्स सहेजे गए।
के लिए फिक्स्ड संस्करण [2,1,0,0]और [1,0,0,0]के रूप में edc65 ने सुझाव दिया

30 बाइट्स संस्करण

रिकॉर्ड के लिए, मेरा पहला प्रयास 32 30 बाइट था, लेकिन विभाजन के लिए फर्श () समर्थन की कमी थी। यह विशेष मामलों जैसे [2,1,0,0]और के लिए भी विफल रहता है [1,0,0,0]।

(a,b,c,d)=>c-2*b+a?d*c/b:d+c-b

डेमो

var f =
(a,b,c,d)=>a-b+d-c?d/(a<b?a/b:a/b|0)|0:d+c-b

var test = [
  [ 14, 24, 34, 44 ],     // should return 54 (addition Algorithm)
  [ 105, 45, -15, -75 ],  // should return -135 (subtraction algorithm)
  [ 5, 25, 125, 625 ],    // should return 3125 (multiplicative algorithm)
  [ 256, 64, 16, 4 ],     // should return 1 (division algorithm)
  [ 260, 65, 16, 4 ],     // should return 1 (division algorithm with floor())
  [ 2, 1, 0, 0 ],         // should return 0 (special case of division algorithm)
  [ 1, 0, 0, 0 ]          // should return 0 (special case of division algorithm)
];

test.forEach(l => console.log('[' + l.join`, `+ '] => ' + f(...l)));

Comments

वाह, मुझे नहीं पता था कि जेएस में पैटर्न मिलान है।

— लीके नन

@LeakyNun - विनाशकारी असाइनमेंट वास्तव में ES6 में पेश किया गया था। ध्यान दें कि आप [a,b]=>फ़ंक्शन मापदंडों के लिए नहीं कर सकते । कोष्ठक आवश्यक हैं।

— अरनुलड

अच्छा है, लेकिन आपको पूर्णांक विभाजन को संभालना चाहिए: [260, 65, 16, 4] => 0.9846153846153847। यह

— डेमियन

@ डैमियन - आह ठीक है ... मुझे पता था कि कोई नोटिस करेगा। ;-) यह तय है।

— अरनुलद

[2,1,0,0] के बारे में क्या? देना चाहिए 0. मुझे लगता है कि यह b*2==c+a<=> जोड़ / घटाव एल्गोरिथ्म के लिए एकमात्र काउंटर उदाहरण है

— डेमियन

Answer 3

ब्रेकीलॉग , 37 33 27 बाइट्स

b:[E]cL,?:Iz{:+a|:*a|:/a}Lt

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

@LeakyNun की बदौलत 10 बाइट्स बचाए ।

व्याख्या

Input = [A:B:C:D]

b:[E]cL,     L = [B:C:D:E]
?:Iz         Create the list [[B:I]:[C:I]:[D:I]:[E:I]]
{            Either…
    :+a          Sum all couples of that list
|            or…
    :*a          Multiply all couples of that list
|            or…
    :/a          Integer divide all couples of that list
}L          The result is L
t           Output is the last element of L

जैसा कि LeakyNun ने बताया, हमें घटाव के मामले की आवश्यकता नहीं है क्योंकि Iकोई भी पूर्णांक हो सकता है।

Comments

वाह, ब्रेकीलॉग (और प्रोलॉग) कमाल के हैं

— माल्टीसेन ३०'१६

जोड़ और घटाव समान है

— लीक नून

@LeakyNun सही, धन्यवाद!

— घातक

29 बाइट्स

— लीकेय नून

27 बाइट्स

— लीकी नून

Answer 4

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

f l@[a,b,c,d]|[a,b..d]==l=d+b-a|z<-b+0^b=div(d*b)$a-mod(max b a)z

Answer 5

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

lambda(a,b,c,d):[d+c-b,d*c/b][c-2*b+a>0]

इसका शाब्दिक अर्थ है जेएस का जवाब पाइथन (धन्यवाद @LeakyNun!) में लगाया गया है। मेरा पिछला दृष्टिकोण हास्यास्पद रूप से लंबा था, लेकिन यहाँ यह है:

अजगर 2, 169 166 बाइट्स

दूसरा और तीसरा स्तर क्रमशः एक कच्चा टैब और एक कच्चा टैब प्लस एक स्थान है, जो कि वास्तव में मार्कडाउन के साथ बुरी तरह से खेलता है , इसलिए टैब को 2 स्थानों से बदल दिया गया है।

x=input()
q='%d%s%d'
for i in range(max(x)):
 for o in'+-*/':
  a=1
  for e,n in zip(x,x[1:]):
   try:1/(eval(q%(e,o,i))==n)
   except:a=0
  if a:print eval(q%(x[-1],o,i))

बहुत साधारण; हर निरंतर और ऑपरेटर को लगता है कि यह निरंतर हो सकता है, तो यदि सूची में प्रत्येक तत्व के लिए निरंतर / ऑपरेटर संयोजन काम करता है (एक का उपयोग करके try)exceptZeroDivisionError एस से बचने के लिए जोड़ी ), यह सूची में अंतिम तत्व के लिए परिणाम प्रिंट करता है।

मुझे यकीन है कि यहाँ एक बेहतर तरीका है, यह भोली विधि है।

Comments

बेहतर होगा कि आप केवल

— पायस

[1,0,0,0]जिसके लिए ब्रेक चाहिए0

— जोनाथन एलन

Answer 6

TSQL, 55 बाइट्स

यह स्क्रिप्ट एक ही चेक में जोड़ने और घटाने की कोशिश कर रही है, फिर यह गुणा करने की कोशिश करती है, यदि यह विफल रहता है, तो यह विभाजन होना चाहिए।

DECLARE 
@1 INT=6561,
@2 INT=729,
@3 INT=81,
@  INT=9

PRINT IIF(@2-@1=@-@3,@*2-@3,IIF(@1*@2=@3,@*@1,sqrt(@)))

बेला

Answer 7

सी #, 63 बाइट्स

int f(int[]x)=>2*x[1]-x[0]==x[2]?x[3]+x[1]-x[0]:x[3]*x[1]/x[0];

जाँच करता है कि क्या पहले और दूसरे तत्व के बीच का अंतर दूसरे और तीसरे तत्व के बीच का अंतर है। यदि ऐसा है, तो यह जोड़ / घटाव करता है, अन्यथा यह गुणा / भाग करता है।

Answer 8

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

(a,b,c,d)=>(x=b-a,c-b==x&&d-c==x)?d+x:(x=b/a,b*x|0==c&&c*x|0==d)?d*x|0:-1

टेस्ट :

console.log(s.apply(null,[14,24,34,44]), 54);
console.log(s.apply(null,[105,45,-15,-75]), -135);
console.log(s.apply(null,[5,25,125,625]), 3125);
console.log(s.apply(null,[256,64,16,4]), 1);

console.log(s.apply(null,[2,1,0,0]),0);
console.log(s.apply(null,[1,0,0,0]),0);
console.log(s.apply(null,[-325,-82,-21,-6]),-1);

console.log(s.apply(null,[-1,-1,-1,-1]),-1);
console.log(s.apply(null,[0,0,0,0]),0);

उन सभी के लिए काम करता है।

Comments

यहाँ शिष्टाचार के बारे में निश्चित नहीं था। मुझे पता है कि पहले से ही एक और जेएस जवाब है, लेकिन यह किनारे के मामलों को संबोधित नहीं करता है। मेरा लंबा है, लेकिन उन सभी को संभालता है। मुझे बताएं कि क्या मैंने यह अधिकार नहीं किया है।

— पूरे

एक भाषा में एक उत्तर को दूसरे उत्तर के रूप में पोस्ट करने में कुछ भी गलत नहीं है, खासकर यदि आपका उत्तर सही है और दूसरा नहीं है। मुझे नहीं पता कि आपके पास ऐसा करने के लिए पर्याप्त प्रतिनिधि हैं, लेकिन आप उस उत्तर पर टिप्पणी करना भी चाह सकते हैं ताकि उन्हें पता चल सके कि वे किन किन मामलों में गायब हैं।

— जेम्स

मैं वास्तव में उस अन्य पोस्ट से किनारे के मामलों को ले गया, लेकिन उन्होंने इस मुद्दे को हल नहीं किया है। ; पी

— पूर्णाहुति

Answer 9

गेममेकर भाषा, 70 बाइट्स

a=argument0;If a[3]+a[1]=a[2]*2return a[4]*2-a[3]return a[4]*a[4]/a[3]

Answer 10

आर, 68 68४

सरणी: 68 बाइट्स

function(x)if(x[2]-x[1]==x[3]-x[2])x[4]+x[2]-x[1]else x[4]%/%(x[1]%/%x[2])

> (function(x)if(x[2]-x[1]==x[3]-x[2])x[4]+x[2]-x[1]else x[4]*x[2]/x[1])(c(14,24,34,44))
[1] 54

4 इनपुट: 45 बाइट्स

function(a,b,c,d)if(b-a==c-b)d+b-a else d*b/a

साथ बोनस समाधान log, exp, var, 71 बाइट्स

if(var(v<-diff(x<-scan(,1)))==0)x[4]+v[1]else x[4]*exp(diff(log(x)))[1]

अद्यतन: पूर्णांक विभाजन

Comments

क्या यह एक सरणी के बजाय चार चर नहीं ले रहा है? यदि आप b-aएक बाइट को बचाने के लिए चारों ओर कोष्ठक से छुटकारा नहीं पा सकते हैं, (और मैं ध्यान देता हूं कि आपके उदाहरण कॉल वापस रिक्त स्थान जोड़ रहे हैं)।

— जोनाथन एलन

@JonathanAllan आप सही हैं। यह एक सरणी नहीं लेता है। बाइट काउंट को अपडेट कर दिया गया है। दूसरे की वजह से कोष्ठक की आवश्यकता होती है, लेकिन हम इसके बजाय एक स्थान जोड़कर एक बाइट बचा सकते हैं। कॉल के लिए अतिरिक्त स्थान की आवश्यकता नहीं है।

— Vlo

हां, यही कारण है कि मैंने कहा कि आप 2 बजाए 1 बाइट बचा सकते हैं

— जोनाथन एलन

ध्यान दें, यह वर्तमान में पूर्णांक विभाजन की आवश्यकता को पूरी तरह से संभालता नहीं है, उदाहरण के लिए 261,65,16,4रिटर्न के 0.9961686बजाय 1(निश्चित रूप से प्रश्न में इसके लिए एक परीक्षण मामला होना चाहिए)।

— जोनाथन एलन

@JonathanAllan फ़ंक्शन (x) यदि (x [2] -x [1] == x [3] -x [2]) x [4] + x [2] -x [1] और x [4]% / % (x [1]% /% x [२])

— Vlo

Answer 11

जावा, 125 123 बाइट्स

golfed:

int m(int[]a){int r=(a[1]>a[0])?a[1]/a[0]:a[0]/a[1];return(a[0]-a[1]==a[1]-a[2])?a[3]-a[0]+a[1]:(a[0]<a[1])?a[3]*r:a[3]/r;}

Ungolfed:

int m(int[] a)
{
    int r = (a[1] > a[0]) ? a[1] / a[0] : a[0] / a[1];
    return (a[0] - a[1] == a[1] - a[2]) ? a[3] - a[0] + a[1] : (a[0] < a[1]) ? a[3] * r : a[3] / r;
}

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

इसे आज़माएं: https://ideone.com/nELH5I

Answer 12

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

किसी भी TI-83/84 कैलकुलेटर पर काम करता है

Input L1                     gets input into an array
L1(4)²/L1(3                  calculate the fifth number in a geometric series
If not(sum(ΔList(ΔList(L1    if ΔList(ΔList(L1)) yields an array of all zeroes
L1(4)2-L1(3                  calculate the fifth number in an arithmetic series
                             Ans is implicitly returned

Answer 13

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

lambda(a,b,c,d):d*2-c if d-c==b-a else d*b/a or b and d/(a/b)

मेरी पिछली 38 बाइट प्रविष्टि की तुलना में अधिक लंबी है, जिसने विभाजन श्रृंखला को सही ढंग से पूरा नहीं किया (जैसा कि अन्य लोगों ने नहीं किया)।

टेस्ट केस और अधिक एज केस आइडोन पर हैं

नोट: एक नकारात्मक यहाँ पूर्णांक विभाजन भाजक के रूप में एक ही हस्ताक्षर के साथ एक शेष होने के रूप में परिभाषित किया गया है, तो -81/4हो सकता है -21की एक शेष के साथ 3और -81/-4होगा 20के शेष के साथ -1।

Comments

ऋणात्मक संख्या से विभाजित ऋणात्मक संख्या धनात्मक होती है ...-81/-4 != -21

— विनाशकारी नींबू

@DestructibleWatermelon वास्तव में यह है। मैंने संपादित किया है और परीक्षण मामले को जोड़ा है [325, -82,20, -5]।

— जोनाथन एलन

Answer 14

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

ṪḤ_ṪµṪ²:ṪµIE$?

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

ṪḤ_ṪµṪ²:ṪµIE$?  Main Link =
             ?  If
          IE$   [condition]
          I     The differences between consecutive elements
           E    Is equal
ṪḤ_Ṫ            [then]
Ṫ               The last element
 Ḥ              Doubled
  _             Minus
   Ṫ            The last element (second-last of original list)
    µṪ²:Ṫµ      [else]
     Ṫ          The last element
      ²         Squared
       :        Divided by
        Ṫ       The last element (second-last of original list)

Answer 15

पायथ, 18 बाइट्स

?-+vzJEyQ/^E2J-yEJ

इनपुट को मानों की एक नई-अलग-अलग सूची के रूप में स्वीकार करता है।

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

स्पष्टीकरण:

?                         If
 -                          the following are not equal:
  +vzJE                      the sum of first and third values (and call the third value J)
       yQ                    and the second value * 2;
                            (i.e. if it is not an additive or subtractive formula)
          ^E2             Then: square the fourth value
         /   J              and divide by the third
?                         Else:
               yE           double the fourth value
              -  J          and subtract the third