Défi

Écrivez un programme qui prend un tableau de 4 entiers ( qui représente une séquence de nombres générée par un certain algorithme ) et retourne le prochain entier qui suivrait.

Nous n'utiliserons que des algorithmes simples d'addition, de soustraction, de multiplication et de division avec une variation constante (c'est-à-dire non variable).

Pour la division, nous utiliserons les floorvaleurs entières: 133/4 = 33et33/4 = 8

Vous pouvez supposer qu'il y aura toujours une seule valeur de retour valide

Cas de test

[14,24,34,44] devrait renvoyer 54 (algorithme d'addition)

[105,45,-15,-75] devrait retourner -135 (algorithme de soustraction)

[5,25,125,625] devrait retourner 3125 (algorithme multiplicatif)

[256,64,16,4] devrait retourner 1 (algorithme de division)

Règles générales

• C'est le code-golf , donc la réponse la plus courte en octets remporte le défi.
• Les failles standard sont interdites

05AB1E , 18 16 18 octets

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

Explication

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

Essayez-le en ligne!

Javascript (ES6),  44   42  44 octets (fixe)

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

Enregistré 2 octets, suivant les conseils d'IsmaelMiguel.
Version fixe pour [2,1,0,0]et [1,0,0,0]comme suggéré par edc65

Version 30 octets

Pour mémoire, ma première tentative était de 32 30 octets mais manquait de support floor () pour la division. Il échoue également pour des cas spéciaux tels que [2,1,0,0]et [1,0,0,0].

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

Démo

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 octets

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

Essayez-le en ligne! ou vérifiez tous les cas de test .

10 octets enregistrés grâce à @LeakyNun .

Explication

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

Comme l'a souligné LeakyNun, nous n'avons pas besoin du cas de soustraction car il Ipeut s'agir de n'importe quel entier.

Haskell, 65 octets

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 octets

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

C'est littéralement la réponse JS portée en Python (merci @LeakyNun!). Mon approche précédente était ridiculement longue, mais la voici:

Python 2, 169 166 octets

Les deuxième et troisième niveaux sont un onglet brut et un onglet brut plus un espace, respectivement, qui jouent vraiment mal avec Markdown, donc les onglets ont été remplacés par 2 espaces.

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

Assez simple; essaie chaque constante et opérateur qu'il pense être la constante, puis si la combinaison constante / opérateur fonctionne pour chaque élément de la liste (en utilisant une paire try/ exceptpour éviter ZeroDivisionErrors), il imprime le résultat du dernier élément de la liste.

Je suis sûr qu'il y a une meilleure méthode ici, c'est la méthode naïve.

TSQL, 55 octets

Ce script essaie d'ajouter et de soustraire dans la même vérification, puis il essaie de se multiplier, si cela échoue, ce doit être la division.

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

Violon

C #, 63 octets

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

Vérifie si la différence entre le premier et le deuxième élément est la même que la différence entre le deuxième et le troisième élément. Si c'est le cas, il fait l'addition / la soustraction, sinon il fait la multiplication / la division.

JavaScript, 73 octets

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

Fonctionne pour tous.

Langue GameMaker, 70 octets

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

Tableau: 68 octets

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 entrées: 45 octets

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

Solution de bonus avec log, exp,var , 71 octets

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

mise à jour: division entière

Java, 125 123 octets

Golfé:

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

Non golfé:

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

Ce code a sûrement quelques problèmes car il ne gère pas la division par zéro et de telles choses. Cela ne fonctionnera pas non plus s'il y a plus (ou moins) de 4 entiers dans le tableau d'entréea . Ce qui le rend plus que stupide, mais je me suis amusé :)

Essayez-le: https://ideone.com/nELH5I

TI-Basic, 37 octets

Fonctionne sur n'importe quelle calculatrice 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

Python 2, 75 66 65 61 octets

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

Beaucoup plus long que mon entrée précédente de 38 octets qui ne répondait pas correctement à la série de division (tout comme la plupart des autres).

Les cas de test et plus de cas marginaux sont sur idéone

Remarque: la division entière pour un négatif ici est définie comme ayant un reste avec le même signe que le diviseur, -81/4serait donc -21avec un reste de 3et -81/-4serait 20avec un reste de -1.

Gelée , 14 octets

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

Essayez-le en ligne!

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

?-+vzJEyQ/^E2J-yEJ

Accepte l'entrée comme une liste de valeurs séparées par des sauts de ligne.

Essayez-le en ligne!

Explication:

?                         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