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

code-golf number

— Daniel
fuente

2

Esta es una versión simplificada de ¿Qué viene después? y límite duplicado.

— Peter Taylor

77

En el futuro, te recomiendo que publiques en Sandbox antes de publicarlo para que puedas recibir los comentarios de otras personas de antemano.

— Leaky Nun

55

Realmente debería agregar algunos casos de prueba para la división de enteros. Casi todas las respuestas no dan el resultado correcto para [261,65,16,4], [4,2,1,0] o [2,1,0,0]

— Damien

55

No estoy de acuerdo con los votos duplicados. Encontrar el algoritmo es más simple en el sentido de que solo hay una operación a considerar, pero al mismo tiempo, es más difícil porque la división de enteros debe tenerse en cuenta. No creo que trasladar una respuesta del otro desafío sea mucho más fácil que escribir una desde cero.

— Dennis

3

Probablemente debería especificar números enteros no negativos, ya que cuando una serie de división es negativa hay dos interpretaciones. Por ejemplo -81/4es 21 r 3o -20 r -1.

— Jonathan Allan

6

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!

— Emigna
fuente

La salida está mal con [4,2,1,0] ...

— Damien

@Damien: Gracias por hacérmelo saber. Lo arreglé e incluso me ahorró un par de bytes :)

— Emigna

Excelente. Ahora valida todos mis casos de prueba.

— Damien

Pruebe el caso límite para dividir por cuatro:[-325, -82, -21, -6]

— Jonathan Allan

... en realidad, supongo que la pregunta debería ser solo para enteros no negativos o debería especificar qué convención se utilizará.

— Jonathan Allan

14

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

Expandir fragmento

— Arnauld
fuente

Wow, no sabía que js tiene coincidencia de patrones.

— Leaky Nun

@LeakyNun: la asignación de desestructuración se introdujo en ES6. Tenga en cuenta que no puede hacer [a,b]=>para los parámetros de la función. Los paréntesis son obligatorios.

— Arnauld

Agradable, pero debes manejar la división de enteros: [260, 65, 16, 4] => 0,9846153846153847. Debería dar 1

— Damien

@Damien - Ah, bueno ... Sabía que alguien se daría cuenta. ;-) Eso está arreglado.

— Arnauld

¿Qué pasa con [2,1,0,0]? Debería dar 0. Creo que es el único contraejemplo para b*2==c+a<=> algoritmo de suma / resta

— Damien

11

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.

— Fatalizar
fuente

44

wow, brachylog (y prolog) son increíbles

— Maltysen

2

Sumar y restar es lo mismo

— Leaky Nun

1

@LeakyNun Correcto, gracias!

— Fatalize

3

29 bytes

— Leaky Nun

3

27 bytes

— Leaky Nun

6

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

— Damien
fuente

5

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.

— Cobre
fuente

Será mejor que transfieras la respuesta js a Python

— Leaky Nun

Descansos para los [1,0,0,0]que debería salir0

— Jonathan Allan

3

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

— t-clausen.dk
fuente

3

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.

— Scepheo
fuente

2

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.

— Quién diablos es él
fuente

1

No estaba seguro de la etiqueta aquí. Sé que ya hay otra respuesta JS, pero no aborda los casos límite. El mío es más largo, pero maneja todos esos. Avísame si no hice esto bien.

— Whothehellisthat

1

No hay nada de malo en publicar una respuesta en el mismo idioma que otra respuesta, especialmente si su respuesta es correcta y la otra no. No sé si tiene suficiente representante para hacerlo, pero es posible que también desee comentar esa respuesta para hacerles saber qué casos límite faltan.

— DJMcMayhem

De hecho, tomé los casos extremos de esa otra publicación, pero no han resuelto el problema. ; P

— Whothehellisthat

2

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]

— Timtech
fuente

2

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

— Vlo
fuente

¿No es esto tomar cuatro variables en lugar de una matriz? Si no, puedes deshacerte de los paréntesis b-apara guardar un byte (y noto que tus llamadas de ejemplo están agregando espacios de nuevo).

— Jonathan Allan

@ JonathanAllan Tienes razón. No toma una matriz. El recuento de bytes ha sido actualizado. Los paréntesis son necesarios debido a lo contrario, pero podemos guardar un byte agregando un espacio en su lugar. Las llamadas no necesitan espacios adicionales.

— Vlo

Sí, es por eso que dije que podía ahorrar 1 byte en lugar de 2

— Jonathan Allan

Tenga en cuenta que actualmente no maneja el requisito de división de enteros por completo, por ejemplo, 261,65,16,4retornos en 0.9961686lugar de 1(por supuesto, debería haber un caso de prueba para esto en la pregunta).

— Jonathan Allan

1

@JonathanAllan función (x) if (x [2] -x [1] == x [3] -x [2]) x [4] + x [2] -x [1] más x [4]% / % (x [1]% /% x [2])

— Vlo

1

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

— peech
fuente

1

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

— Timtech
fuente

1

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.

— Jonathan Allan
fuente

1

el número negativo dividido por el número negativo es positivo ...-81/-4 != -21

— Destructible Lemon

@DestructibleWatermelon De hecho lo es. Lo edité y agregué el caso de prueba [325, -82,20, -5].

— Jonathan Allan

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)

— Hiperneutrino
fuente

0

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

— Steven H.
fuente

El número final

Desafío

Casos de prueba

Reglas generales

05AB1E , 18 16 18 bytes

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

Versión de 30 bytes

Manifestación

Brachylog , 37 33 27 bytes

Explicación

Haskell, 65 bytes

Python 2, 40 bytes

Pitón 2, 169 166 bytes

TSQL, 55 bytes

C #, 63 bytes

JavaScript, 73 bytes

Lenguaje GameMaker, 70 bytes

R, 68 74

Java, 125 123 bytes

TI-Basic, 37 bytes

Python 2, 75 66 65 61 bytes

Jalea , 14 bytes

Pyth, 18 bytes