Desafío

Escriba un programa que tome una matriz de 4 enteros ( que representa una secuencia de números generados por un cierto algoritmo ) y devuelva el siguiente entero que seguiría.

Solo usaremos algoritmos simples de suma, resta, multiplicación y división con una variación constante (es decir, no variable).

Para la división usaremos los floorvalores enteros: 133/4 = 33y33/4 = 8

Puede suponer que siempre habrá un único valor de retorno válido

Casos de prueba

[14,24,34,44] debería devolver 54 (Algoritmo adicional)

[105,45,-15,-75] debería devolver -135 (algoritmo de resta)

[5,25,125,625] debería devolver 3125 (algoritmo multiplicativo)

[256,64,16,4] debería devolver 1 (algoritmo de división)

Reglas generales

• Este es el código de golf , por lo que la respuesta más corta en bytes gana el desafío.
• Las lagunas estándar están prohibidas

05AB1E , 18 16 18 bytes

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

Explicación

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

Pruébalo en línea!

Javascript (ES6),  44   42  44 bytes (fijo)

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

Guardado 2 bytes, siguiendo el consejo de IsmaelMiguel.
Versión fija para [2,1,0,0]y [1,0,0,0]según lo sugerido por edc65

Versión de 30 bytes

Para el registro, mi primer intento fue de 32 a 30 bytes, pero carecía de soporte de floor () para la división. También falla para casos especiales como [2,1,0,0]y [1,0,0,0].

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

Manifestación

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

Pruébalo en línea! o verificar todos los casos de prueba .

Guardado 10 bytes gracias a @LeakyNun .

Explicación

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

Como señaló LeakyNun, no necesitamos el caso de resta porque Ipuede ser cualquier número entero.

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 literalmente la respuesta de JS portada a Python (¡gracias @LeakyNun!). Mi enfoque anterior fue ridículamente largo, pero aquí está:

Pitón 2, 169 166 bytes

El segundo y tercer nivel son una pestaña sin procesar y una pestaña sin procesar más un espacio, respectivamente, que juega muy mal con Markdown, por lo que las pestañas han sido reemplazadas por 2 espacios.

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

Bastante simple; prueba cada constante y operador que cree que podría ser la constante, luego, si la combinación constante / operador funciona para cada elemento de la lista (usando un try/ exceptpar para evitarZeroDivisionError s), imprime el resultado para el último elemento de la lista.

Estoy seguro de que hay un mejor método aquí, este es el método ingenuo.

TSQL, 55 bytes

Este script intenta sumar y restar en la misma verificación, luego intenta multiplicar, si eso falla, debe ser una división.

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

Violín

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

Comprueba si la diferencia entre el primer y el segundo elemento es la misma que la diferencia entre el segundo y el tercer elemento. Si es así, suma / resta, de lo contrario, multiplica / divide.

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

Pruebas :

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

Funciona para todos ellos.

Lenguaje GameMaker, 70 bytes

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

Matriz: 68 bytes

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 entradas: 45 bytes

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

Solución de experiencia con 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]

actualización: división entera

Java, 125 123 bytes

Golfizado:

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

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

Este código seguramente tiene algunos problemas, ya que no maneja la división por cero y esas cosas. Por supuesto, tampoco funcionará si hay más (o menos) de 4 enteros en la matriz de entrada a. Lo que lo hace más que estúpido, pero me divertí :)

Pruébelo: https://ideone.com/nELH5I

TI-Basic, 37 bytes

Funciona en cualquier calculadora 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 bytes

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

Mucho más tiempo que mi entrada anterior de 38 bytes que no satisfacía correctamente la serie de división (al igual que la mayoría de los demás).

Los casos de prueba y más casos extremos están en ideone

Nota: la división entera para un negativo aquí se define como tener un resto con el mismo signo que el divisor, por -81/4lo que sería -21con un resto de 3y -81/-4sería 20con un resto de -1.

Jalea , 14 bytes

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

Pruébalo en línea!

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

Acepta entradas como una lista de valores separada por una nueva línea.

Pruébalo en línea!

Explicación:

?                         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