Desafio

Escreva um programa que utilize uma matriz de 4 números inteiros ( que representa uma sequência de números gerados por um determinado algoritmo ) e retorne o próximo número inteiro a seguir.

Usaremos apenas algoritmos simples de adição, subtração, multiplicação e divisão com uma variação constante (ou seja, não variável).

Para divisão, usaremos os floorvalores inteiros: 133/4 = 33e33/4 = 8

Você pode assumir que sempre haverá um único valor de retorno válido

Casos de teste

[14,24,34,44] deve retornar 54 (algoritmo de adição)

[105,45,-15,-75] deve retornar -135 (algoritmo de subtração)

[5,25,125,625] deve retornar 3125 (algoritmo multiplicativo)

[256,64,16,4] deve retornar 1 (algoritmo de divisão)

Regras gerais

Isso é código-golfe , então a resposta mais curta em bytes vence o desafio.
As brechas padrão são proibidas

code-golf number

— Daniel
fonte

2

Esta é uma versão simplificada do que vem a seguir? e duplicado limítrofe.

— Peter Taylor

7

No futuro, recomendo que você poste no Sandbox antes de ir ao ar para poder receber os comentários de outras pessoas com antecedência.

— Leaky Nun

5

Você realmente deve adicionar alguns casos de teste para divisão inteira. Quase todas as respostas não dão resultado correto para [261,65,16,4], [4,2,1,0], ou [2,1,0,0]

— Damien

5

Não concordo com os votos duplicados. Encontrar o algoritmo é mais simples no sentido de que há apenas uma operação a ser considerada, mas, ao mesmo tempo, é mais difícil porque a divisão de números inteiros deve ser considerada. Não acho que expor uma resposta do outro desafio seja substancialmente mais fácil do que escrever uma do zero.

— Dennis

3

Você provavelmente deve especificar números inteiros não negativos, pois quando uma série de divisão é negativa, há duas interpretações. Por exemplo, -81/4é 21 r 3ou -20 r -1.

— Jonathan Allan

6

05AB1E , 18 16 18 bytes

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

Explicação

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

Experimente online!

— Emigna
fonte

A saída está errado com [4,2,1,0] ...

— Damien

@ Damien: Obrigado por me avisar. Eu

— consertei

Ótimo. Agora ele valida todos os meus casos de teste.

— Damien

Tente um argumento de ponta para dividir por quatro:[-325, -82, -21, -6]

— Jonathan Allan

... na verdade, acho que a pergunta deve ser apenas para números inteiros não negativos ou deve especificar qual convenção deve ser usada.

— Jonathan Allan

14

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

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

Economizou 2 bytes, seguindo o conselho de IsmaelMiguel.
Versão fixa para [2,1,0,0]e[1,0,0,0] como sugerido por edc65

Versão de 30 bytes

Para constar, minha primeira tentativa foi de ~~32 a~~ 30 bytes, mas faltava suporte floor () para a divisão. Também falha em casos especiais como [2,1,0,0]e [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)));

Expandir snippet

— Arnauld
fonte

Uau, eu não sabia que js tem correspondência de padrões.

— Freira vazada

@LeakyNun - A atribuição de desestruturação foi realmente introduzida no ES6. Observe que você não pode fazer os [a,b]=>parâmetros de função. Os parênteses são obrigatórios.

— Arnauld

Bom, mas você deve lidar com a divisão inteira: [260, 65, 16, 4] => 0.9846153846153847. Deve dar 1

— Damien

@ Damien - Ah bem ... eu sabia que alguém iria notar. ;-) Está consertado.

— Arnauld

E quanto a [2,1,0,0]? Deve dar 0. Eu acho que é o único exemplo de contador para b*2==c+a<=> algoritmo de adição / subtração

— Damien

11

Brachylog , 37 33 27 bytes

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

Experimente online!ou verifique todos os casos de teste .

Guardou 10 bytes graças a @LeakyNun .

Explicação

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 LeakyNun apontou, não precisamos do caso de subtração porque Ipode ser qualquer número inteiro.

— Fatalizar
fonte

4

wow, brachylog (& prólogo) são impressionantes

— Maltysen

2

Adição e subtração são as mesmas #

— Leaky Nun

1

@LeakyNun Correto, obrigado!

— Fatalize 30/08/19

3

29 bytes

— Freira vazada

3

27 bytes

— Freira vazada

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
fonte

5

Python 2, 40 bytes

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

É literalmente a resposta do JS portada para o Python (obrigado @LeakyNun!). Minha abordagem anterior foi ridiculamente longa, mas aqui está:

Python 2, 169 166 bytes

O segundo e o terceiro níveis são uma guia bruta e uma guia bruta mais um espaço, respectivamente, que joga muito mal com o Markdown; portanto, as guias foram substituídas por 2 espaços.

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

Bem simples; tenta todas as constantes e operadores que acha que podem ser as constantes; se a combinação constante / operador funcionar para todos os elementos da lista (usando um par try/ exceptpara evitar ZeroDivisionErrors), ela imprimirá o resultado do último elemento da lista.

Tenho certeza de que existe um método melhor aqui, este é o método ingênuo.

— Cobre
fonte

É melhor apenas port os js responder em Python

— Leaky Nun

Pausas para [1,0,0,0]que deve saída0

— Jonathan Allan

3

TSQL, 55 bytes

Este script está tentando adicionar e subtrair na mesma verificação e tenta multiplicar; se isso falhar, deve ser divisão.

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

Violino

— t-clausen.dk
fonte

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

Verifica se a diferença entre o primeiro e o segundo elemento é a mesma que a diferença entre o segundo e o terceiro elemento. Nesse caso, faz adição / subtração, caso contrário, faz multiplicação / divisão.

— Scepheo
fonte

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

Testes :

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 eles.

— Quem diabos é isso
fonte

1

Não tinha certeza da etiqueta aqui. Eu sei que já existe outra resposta JS, mas não trata dos casos extremos. O meu é mais longo, mas lida com tudo isso. Deixe-me saber se eu não fiz isso direito.

— Whothehellisthat

1

Não há nada errado em postar uma resposta no mesmo idioma que outra resposta, especialmente se a sua resposta estiver correta e a outra não. Não sei se você tem representante suficiente para fazê-lo, mas também pode comentar essa resposta para que eles saibam quais casos extremos estão faltando.

— DJMcMayhem

Na verdade, peguei os casos extremos desse outro post, mas eles não resolveram o problema. ; P

— Whothehellisthat 31/08/16

2

Idioma do 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
fonte

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

Solução com bónus 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: divisão inteira

— Vlo
fonte

Isso não leva quatro variáveis em vez de uma matriz? Caso contrário, você pode se livrar dos parênteses ao redor b-apara salvar um byte (e notei que suas chamadas de exemplo estão adicionando espaços novamente).

— Jonathan Allan

@ JonathanAllan Você está certo. Não é necessário um array. A contagem de bytes foi atualizada. Os parênteses são necessários devido a outra coisa, mas podemos salvar um byte adicionando um espaço. As chamadas não precisam de espaços adicionais.

— Vlo 30/08/16

Sim, foi por isso que eu disse que você poderia economizar 1 byte em vez de 2

— Jonathan Allan

Observe que, atualmente, ele não atende totalmente ao requisito de divisão inteira, por exemplo, 261,65,16,4retorna em 0.9961686vez de 1(é claro que deve haver um caso de teste para isso na questão).

— Jonathan Allan

1

@ Função Jonathan Jonathan (x) if (x [2] -x [1] == x [3] -x [2]) x [4] + x [2] -x [1] else x [4]% / % (x [1]% /% x [2])

— Vlo 01/09/16

1

Java, 125 123 bytes

Golfe:

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

Esse código certamente tem alguns problemas, pois não lida com a divisão por zero e outras coisas. É claro que também não funcionará se houver mais (ou menos) que 4 números inteiros na matriz de entrada a. O que torna isso estúpido, mas eu me diverti :)

Experimente: https://ideone.com/nELH5I

— peech
fonte

1

TI-Basic, 37 bytes

Funciona em qualquer 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
fonte

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)

Muito mais tempo do que minha entrada anterior de 38 bytes, que não atendia corretamente à série de divisões (da mesma forma que a maioria das outras).

Casos de teste e mais casos extremos estão no ideone

Nota: a divisão inteira para um negativo aqui é definida como tendo um restante com o mesmo sinal que o divisor, portanto, -81/4seria -21com um restante de 3e -81/-4seria 20com um restante de -1.

— Jonathan Allan
fonte

1

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

— Destrutível Lemon

@DestructibleWatermelon Na verdade é. Eu editei isso e adicionei o caso de teste [325, -82,20, -5].

— Jonathan Allan

1

Gelatina , 14 bytes

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

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

— HyperNeutrino
fonte

0

Pyth, 18 bytes

?-+vzJEyQ/^E2J-yEJ

Aceita entrada como uma lista de valores separados por nova linha.

Experimente online!

Explicação:

?                         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.
fonte

O número final

Desafio

Casos de teste

Regras gerais

05AB1E , 18 16 18 bytes

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

Versão de 30 bytes

Demo

Brachylog , 37 33 27 bytes

Explicação

Haskell, 65 bytes

Python 2, 40 bytes

Python 2, 169 166 bytes

TSQL, 55 bytes

C #, 63 bytes

JavaScript, 73 bytes

Idioma do GameMaker, 70 bytes

R, 68 74

Java, 125 123 bytes

TI-Basic, 37 bytes

Python 2, 75 66 65 61 bytes

Gelatina , 14 bytes

Pyth, 18 bytes