Sfida

Scrivi un programma che accetta una matrice di 4 numeri interi ( che rappresenta una sequenza di numeri generati da un certo algoritmo ) e restituisce il numero intero successivo che seguirà.

Useremo solo algoritmi di addizione, sottrazione, moltiplicazione e divisione con una variazione costante (cioè non variabile).

Per la divisione useremo i floorvalori interi: 133/4 = 33e33/4 = 8

Puoi presumere che ci sarà sempre un singolo valore di ritorno valido

Casi test

[14,24,34,44] dovrebbe restituire 54 (algoritmo di aggiunta)

[105,45,-15,-75] dovrebbe restituire -135 (algoritmo di sottrazione)

[5,25,125,625] dovrebbe restituire 3125 (algoritmo moltiplicativo)

[256,64,16,4] dovrebbe restituire 1 (algoritmo di divisione)

Regole generali

Questo è code-golf , quindi la risposta più breve in byte vince la sfida.
Sono vietate le scappatoie standard

code-golf number

— Daniel
fonte

2

Questa è una versione semplificata di Cosa viene dopo? e duplicato limite.

— Peter Taylor,

7

In futuro, ti consiglio di pubblicare su Sandbox prima di andare in diretta in modo da poter ricevere in anticipo i commenti di altre persone.

— Leaky Nun,

5

Dovresti davvero aggiungere alcuni casi di test per la divisione di numeri interi. Quasi tutte le risposte non danno il risultato corretto per [261,65,16,4], [4,2,1,0] o [2,1,0,0]

— Damien,

5

Non sono d'accordo con i voti duplicati. Trovare l'algoritmo è più semplice nel senso che c'è una sola operazione da considerare, ma allo stesso tempo, è più difficile perché la divisione intera deve essere presa in considerazione. Non credo che il porting di una risposta dall'altra sfida sia sostanzialmente più semplice che scriverne una da zero.

— Dennis,

3

Probabilmente dovresti specificare numeri interi non negativi, poiché quando una serie di divisioni è negativa ci sono due interpretazioni. Ad esempio -81/4è 21 r 3o -20 r -1.

— Jonathan Allan,

6

05AB1E , 18 16 18 byte

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

Spiegazione

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

Provalo online!

— Emigna
fonte

L'output è sbagliato con [4,2,1,0] ...

— Damien,

@Damien: grazie per avermelo fatto notare. L'ho risolto e mi ha anche salvato un paio di byte :)

— Emigna il

Grande. Ora convalida tutti i miei casi di test.

— Damien,

Prova il caso limite per dividere per quattro:[-325, -82, -21, -6]

— Jonathan Allan il

... in realtà suppongo che la domanda dovrebbe essere solo per numeri interi non negativi o specificare quale convenzione deve essere utilizzata.

— Jonathan Allan,

14

Javascript (ES6), 44 42 44 byte (fisso)

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

Salvato 2 byte, seguendo i consigli di IsmaelMiguel.
Versione fissa per [2,1,0,0]e [1,0,0,0]come suggerito da edc65

Versione 30 byte

Per la cronaca, il mio primo tentativo è stato 32 30 byte ma mancava il supporto floor () per la divisione. Non riesce anche per casi speciali come [2,1,0,0]e [1,0,0,0].

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

dimostrazione

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

Espandi frammento

— Arnauld
fonte

Wow, non sapevo che js avesse un pattern matching.

— Leaky Nun,

@LeakyNun - L' incarico di destrutturazione è stato effettivamente introdotto in ES6. Nota che non puoi fare [a,b]=>per i parametri di funzione. Sono necessarie le parentesi.

— Arnauld,

Bene, ma dovresti gestire la divisione intera: [260, 65, 16, 4] => 0.9846153846153847. Dovrebbe dare 1

— Damien il

@Damien - Ah bene ... sapevo che qualcuno se ne sarebbe accorto. ;-) È risolto.

— Arnauld,

Che dire di [2,1,0,0]? Dovrei dare 0. Penso che sia l'unico contro esempio per b*2==c+a<=> algoritmo di addizione / sottrazione

— Damien

11

Brachylog , 37 33 27 byte

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

Provalo online! o verifica tutti i casi di test .

Salvato 10 byte grazie a @LeakyNun .

Spiegazione

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

Come ha sottolineato LeakyNun, non abbiamo bisogno del caso di sottrazione perché Ipuò essere qualsiasi numero intero.

— Fatalize
fonte

4

wow, brachylog (& prolog) sono fantastici

— Maltysen,

2

Addizione e sottrazione sono uguali

— Leaky Nun,

1

@LeakyNun Corretto, grazie!

— Fatalizza il

3

29 byte

— Leaky Nun,

3

27 byte

— Leaky Nun,

6

Haskell, 65 byte

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 byte

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

È letteralmente la risposta JS trasferita in Python (grazie @LeakyNun!). Il mio approccio precedente era ridicolmente lungo, ma eccolo qui:

Python 2, 169 166 byte

Il secondo e il terzo livello sono una scheda non elaborata e una scheda non elaborata più uno spazio, rispettivamente, che gioca davvero male con Markdown, quindi le schede sono state sostituite da 2 spazi.

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

Abbastanza semplice; prova ogni costante e operatore che ritiene possa essere la costante, quindi se la combinazione costante / operatore funziona per ogni elemento nell'elenco (usando una try/ exceptcoppia per evitareZeroDivisionError s), stampa il risultato per l'ultimo elemento nell'elenco.

Sono sicuro che c'è un metodo migliore qui, questo è il metodo ingenuo.

— Rame
fonte

Faresti meglio a trasferire la risposta js in Python

— Leaky Nun il

Pause per le [1,0,0,0]quali dovrebbe uscire0

— Jonathan Allan il

3

TSQL, 55 byte

Questo script sta provando ad aggiungere e sottrarre nello stesso controllo, quindi tenta di moltiplicarsi, se fallisce, deve essere una divisione.

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 byte

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 la differenza tra il primo e il secondo elemento è uguale alla differenza tra il secondo e il terzo elemento. Se è così, fa addizione / sottrazione, altrimenti fa moltiplicazione / divisione.

— Scepheo
fonte

2

JavaScript, 73 byte

(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

Test :

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

Funziona per tutti loro.

— Chi diavolo è quello
fonte

1

Non ero sicuro dell'etichetta qui. So che c'è già un'altra risposta JS, ma non affronta i casi limite. Il mio è più lungo, ma gestisce tutti quelli. Fammi sapere se non ho fatto bene.

— Whothehellisthat

1

Non c'è niente di sbagliato nel pubblicare una risposta nella stessa lingua di un'altra risposta, specialmente se la tua risposta è corretta e l'altra no. Non so se hai abbastanza rappresentante per farlo, ma potresti anche voler commentare quella risposta per far loro sapere quali casi marginali mancano.

— DJMcMayhem

In realtà ho preso i casi limite da quell'altro post, ma non hanno risolto il problema. ; P

— Whothehellisthat

2

Lingua GameMaker, 70 byte

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

Matrice: 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 ingressi: 45 byte

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

Soluzione di Bonus con log, exp,var , 71 byte

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

aggiornamento: divisione intera

— Vlo
fonte

Questo non sta prendendo quattro variabili piuttosto che un array? Altrimenti puoi liberarti delle parentesi b-aper salvare un byte (e noto che le tue chiamate di esempio aggiungono spazi).

— Jonathan Allan,

@JonathanAllan Hai ragione. Non richiede un array. Il conteggio dei byte è stato aggiornato. La parentesi è necessaria a causa di altro, ma possiamo salvare un byte aggiungendo invece uno spazio. Le chiamate non hanno bisogno di spazi aggiuntivi.

— Vlo,

Sì, è per questo che ho detto che potresti risparmiare 1 byte anziché 2

— Jonathan Allan il

Nota, attualmente non gestisce completamente il requisito di divisione intera, ad es. 261,65,16,4Restituisce 0.9961686piuttosto che 1(ovviamente ci dovrebbe essere un caso di prova per questo nella domanda).

— Jonathan Allan,

1

Funzione @JonathanAllan (x) if (x [2] -x [1] == x [3] -x [2]) x [4] + x [2] -x [1] else x [4]% / % (x [1]% /% x [2])

— Vlo

1

Java, 125 123 byte

golfed:

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

Questo codice ha sicuramente alcuni problemi poiché non gestisce la divisione per zero e cose del genere. Inoltre, non funzionerà ovviamente se ci sono più (o meno) di 4 numeri interi nell'array di input a. Il che lo rende oltre stupido, ma mi sono divertito :)

Provalo: https://ideone.com/nELH5I

— Peech
fonte

1

TI-Basic, 37 byte

Funziona su qualsiasi calcolatrice 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 byte

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

Molto più lungo della mia precedente voce da 38 byte che non soddisfaceva correttamente la serie di divisioni (proprio come la maggior parte degli altri non ha fatto).

I casi di test e altri casi limite sono su ideone

Nota: la divisione intera per un negativo qui è definita come avente un resto con lo stesso segno del divisore, quindi -81/4sarebbe -21con un resto di 3e -81/-4sarebbe 20con un resto di -1.

— Jonathan Allan
fonte

1

il numero negativo diviso per il numero negativo è positivo ...-81/-4 != -21

— Limone distruttibile

@DestructibleWatermelon In effetti lo è. L'ho modificato e ho aggiunto il test case [325, -82,20, -5].

— Jonathan Allan,

1

Gelatina , 14 byte

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

Provalo 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 byte

?-+vzJEyQ/^E2J-yEJ

Accetta input come un elenco di valori separato da nuova riga.

Provalo online!

Spiegazione:

?                         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

Il numero finale

Sfida

Casi test

Regole generali

05AB1E , 18 16 18 byte

Javascript (ES6), 44 42 44 byte (fisso)

Versione 30 byte

dimostrazione

Brachylog , 37 33 27 byte

Spiegazione

Haskell, 65 byte

Python 2, 40 byte

Python 2, 169 166 byte

TSQL, 55 byte

C #, 63 byte

JavaScript, 73 byte

Lingua GameMaker, 70 byte

R, 68 74

Java, 125 123 byte

TI-Basic, 37 byte

Python 2, 75 66 65 61 byte

Gelatina , 14 byte

Pyth, 18 byte