Herausforderung

Schreiben Sie ein Programm, das ein Array mit 4 Ganzzahlen verwendet ( das eine Folge von Zahlen darstellt, die von einem bestimmten Algorithmus generiert wurden ) und die nächste Ganzzahl zurückgibt, die folgen würde.

Wir werden nur einfache Additions-, Subtraktions-, Multiplikations- und Divisionsalgorithmen mit einer konstanten (dh nicht variablen) Variation verwenden.

Für die Division verwenden wir die floorganzzahligen Werte: 133/4 = 33und33/4 = 8

Sie können davon ausgehen, dass es immer einen einzigen gültigen Rückgabewert gibt

Testfälle

[14,24,34,44] sollte 54 zurückgeben (Additionsalgorithmus)

[105,45,-15,-75] sollte -135 zurückgeben (Subtraktionsalgorithmus)

[5,25,125,625] sollte 3125 zurückgeben (multiplikativer Algorithmus)

[256,64,16,4] sollte 1 zurückgeben (Teilungsalgorithmus)

Allgemeine Regeln

• Das ist Code-Golf , also gewinnt die kürzeste Antwort in Bytes die Herausforderung.
• Standardlücken sind verboten

05AB1E , 18 16 18 Bytes

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

Erläuterung

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

Probieren Sie es online!

Javascript (ES6),  44   42  44 Bytes (fest)

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

2 Bytes gespart, gemäß IsmaelMiguels Rat.
Feste Version für [2,1,0,0]und [1,0,0,0]wie von edc65 vorgeschlagen

30-Byte-Version

Mein erster Versuch war 32 - 30 Bytes, aber es fehlte die Unterstützung von floor () für die Division. Es schlägt auch für Sonderfälle wie [2,1,0,0]und fehl [1,0,0,0].

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

Demo

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)));

Brachylog , 37 33 27 Bytes

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

Probieren Sie es online! oder überprüfen Sie alle Testfälle .

10 Bytes dank @LeakyNun gespart .

Erläuterung

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

Wie LeakyNun hervorhob, brauchen wir den Subtraktionsfall nicht, da es Isich um eine beliebige Ganzzahl handeln kann.

Haskell, 65 Bytes

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

Python 2, 40 Bytes

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

Es ist buchstäblich die in Python portierte JS-Antwort (danke @LeakyNun!). Mein bisheriger Ansatz war lächerlich lang, aber hier ist es:

Python 2, 169 166 Bytes

Die zweite und dritte Ebene sind ein Raw-Tab und ein Raw-Tab sowie ein Leerzeichen, was sehr schlecht mit Markdown funktioniert. Die Tabs wurden also durch zwei Leerzeichen ersetzt.

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))

Ziemlich einfach; probiert jede Konstante und jeden Operator aus, von dem sie glaubt, dass sie die Konstante sein könnte. Funktioniert die Konstante / Operator-Kombination dann für jedes Element in der Liste (mit einem try/exceptZeroDivisionError gibt man das Ergebnis für das letzte Element in der Liste aus -Paar, um s zu vermeiden ).

Ich bin sicher, dass es hier eine bessere Methode gibt, das ist die naive Methode.

TSQL, 55 Bytes

Dieses Skript versucht, in derselben Prüfung zu addieren und zu subtrahieren. Dann wird versucht, zu multiplizieren. Wenn dies fehlschlägt, muss es dividiert werden.

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(@)))

Geige

C #, 63 Bytes

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

Überprüft, ob der Unterschied zwischen dem ersten und dem zweiten Element gleich dem Unterschied zwischen dem zweiten und dem dritten Element ist. In diesem Fall wird addiert / subtrahiert, andernfalls wird multipliziert / dividiert.

JavaScript, 73 Bytes

(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

Tests :

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);

Funktioniert für alle.

GameMaker-Sprache, 70 Byte

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

R 68 74

Array: 68 Byte

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 Eingänge: 45 Bytes

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

Bonus - Lösung mit log, exp,var , 71 Bytes

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

update: ganzzahlige Division

Java, 125 123 Bytes

Golf gespielt:

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;
}

Dieser Code hat sicherlich einige Probleme, da er die Division durch Null und dergleichen nicht behandelt. Es funktioniert natürlich auch nicht, wenn das Eingabearray mehr (oder weniger) als 4 Ganzzahlen enthält a. Das macht es überaus dumm, aber ich hatte Spaß :)

Probieren Sie es aus: https://ideone.com/nELH5I

TI-Basic, 37 Bytes

Funktioniert mit jedem TI-83/84-Taschenrechner

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

Python 2, 75 66 65 61 Bytes

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

Viel länger als mein vorheriger 38-Byte-Eintrag, der die Teilungsserie nicht korrekt berücksichtigte (so wie die meisten anderen nicht).

Testfälle und mehr Randfälle sind auf ideone

Anmerkung: Ganzzahl - Division für eine negative hier definiert ist als ein Rest mit dem gleichen Vorzeichen wie der Divisor aufweist, so -81/4wäre -21mit einem Rest von 3und -81/-4wäre 20mit einem Rest von -1.

Jelly , 14 Bytes

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

Probieren Sie es online!

ṪḤ_ṪµṪ²:Ṫµ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)

Pyth, 18 Bytes

?-+vzJEyQ/^E2J-yEJ

Akzeptiert Eingaben als durch Zeilenumbrüche getrennte Liste von Werten.

Probieren Sie es online!

Erläuterung:

?                         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