La sequenza saltellante

19

Considera la seguente sequenza:

0 1 3 2 5 4 8 6 7 12 9 10 11 17 13 14 15 16 23 ...

Sembra abbastanza privo di schemi, giusto? Ecco come funziona. A partire da 0, salta su ninteri, con a npartire da 1. Questo è il prossimo numero nella sequenza. Quindi aggiungi tutti i numeri "saltati" e non ancora visti in ordine crescente. Quindi, incrementa ne salta dall'ultimo numero aggiunto. Ripeti questo schema.

Quindi, per esempio, quando raggiungiamo 11, siamo a n=5. Aumentiamo nper essere n=6, saltiamo su 17, quindi aggiungiamo 13 14 15 16poiché quelli non sono stati ancora visti. Il nostro prossimo salto è n=7, quindi l'elemento successivo nella sequenza è 23.

La sfida

Dato input x, emette il xtermine di questa sequenza, i primi xtermini della sequenza o crea un elenco infinito di termini della sequenza. Puoi scegliere l'indicizzazione 0 o 1.

I / O e regole

L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
Si può presumere che l'input e l'output si adattino al tipo di numero nativo della tua lingua.
È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
Sono vietate le scappatoie standard .
Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

code-golf sequence

— AdmBorkBork
fonte

Apparentemente non è (ancora?) Su OEIS

— JayCe il

@JayCe Non sono sorpreso: è una sequenza abbastanza arbitraria.

— AdmBorkBork,

Risposte:

24

JavaScript (ES7), 41 byte

Restituisce l' ennesimo termine della sequenza, indicizzato 0.

n=>(d=(n--*8-23)**.5)%1?n:'121'[n]^n-~d/2

Provalo online!

Come?

Caso principale: $n > 3$

I primi quattro termini della sequenza sono speciali, quindi mettiamoli da parte per ora.

Per , la sequenza è simile alla seguente: $n > 3$

 n  | [4] 5 [6] 7 8 [ 9] 10 11 12 [13] 14 15 16 17 [18] 19 20 21 22 23 [24] 25 26 27 ...
----+------------------------------------------------------------------------------------
a(n)| [5] 4 [8] 6 7 [12]  9 10 11 [17] 13 14 15 16 [23] 18 19 20 21 22 [30] 24 25 26 ...
----+------------------------------------------------------------------------------------
 k  |  2  -  3  - -   4   -  -  -   5   -  -  -  -   6   -  -  -  -  -   7   -  -  - ...

Possiamo notare che ci sono in realtà due sotto-sequenze interlacciate:

La maggior parte dei valori appartiene alla sottosequenza per la quale abbiamo semplicemente: $A$

$A (n) = n - 1$ $A(n) = n - 1$
Alcuni altri valori appartengono alla sottosequenza (evidenziata tra parentesi nel diagramma sopra) i cui indici seguono la sequenza aritmetica 3, 3, 4, 6, 9, 13, 18, 24 ... e per i quali abbiamo: $B$

$B (n, K) = n + K - 1$ $B(n,k) = n + k - 1$
dove è l'indice della sequenza principale e è l'indice nella sequenza secondaria . $n$ $k$ $B$

Gli indici di nella sequenza principale sono dati da: $B$

n_{K} = \frac{K^{2} - K + 6}{2}

$n_k = \frac{k^2 - k + 6}{2}$

Dato , sappiamo che il termine corrispondente nella sequenza principale appartiene a se è una soluzione intera dell'equazione quadratica: $n$ $B$ $n$

x^{2} - x + 6 - 2 n = 0

$x^2 - x + 6 - 2n = 0$

il cui discriminante è:

Δ = 1 - 4 (6 - 2 n) = 8 n - 23

$\Delta = 1 - 4(6 - 2n) = 8n - 23$

e la cui soluzione positiva è:

x = \frac{1 + \sqrt{Δ}}{2}

$x = \frac{1 + \sqrt{\Delta}}{2}$

Ci aspettiamo deve essere un numero intero. Da qui il test: $\sqrt{\Delta}$

(d = (n-- * 8 - 23) ** .5) % 1

Casi speciali: $0 \le n \le 3$

Per , il discriminante è negativo e prendendo i suoi risultati di radice quadrata in NaN . Per , il discriminante è . Pertanto, questi primi quattro termini della sequenza sono considerati appartenere alla sequenza secondaria . $n < 3$ $n = 3$ $1$ $B$

Dovremmo solo applicare la nostra formula standard n - ~ d / 2 , otterremmo:

- \frac{1}{2}, \frac{1}{2}, \frac{3}{2}, 3

$-\frac 1 2, \frac 1 2, \frac 3 2, 3$

invece di:

0, 1, 3, 2

$0, 1, 3, 2$

Questo è il motivo per cui XOR questi risultati con rispettivamente. $0,1,2\text{ and }1$

— Arnauld
fonte

10

Buccia , 12 byte

Θṁṙ_1C+ḣ2tNN

Provalo online!

Emette come un elenco infinito. Qui è una versione che stampa il primo N .

Spiegazione

Θṁṙ_1C + ḣ2tNN - Programma completo. Non accetta input, output su STDOUT.
         tN: crea l'elenco infinito di numeri naturali, a partire da 2.
      + ḣ2 - E aggiungi [1, 2] ad esso. Rendimento [1,2,2,3,4,5,6,7,8,9,10,11, ...].
     CN - Taglia la lista infinita di numeri interi positivi in pezzi di quelli
               dimensioni. Resa [[1], [2,3], [4,5], [6,7,8], [9,10,11,12], ...].
 ṁ - Mappa e appiattisci i risultati in seguito.
  ṙ_1 - Ruota ciascuno a destra di 1 unità.
               Rendimento [1,3,2,5,4,8,6,7,12,9,10,11, ...]
Θ - Prepara uno 0. Rendimento [0,1,3,2,5,4,8,6,7,12,9,10,11, ...]

— Mr. Xcoder
fonte

7

Haskell , 43 byte

0:1:3:2:5!3
a!n=a:[a-n+2..a-1]++(a+n)!(n+1)

Provalo online!

Definisce un elenco infinito:

  0:1:3:2:(5!3)
≡ 0:1:3:2:5:4:(8!4)
≡ 0:1:3:2:5:4:8:6:7:(12!5)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:(17!6)
≡ 0:1:3:2:5:4:8:6:7:12:9:10:11:17:13:14:15:16:(23!7) …

— Lynn
fonte

4

Gelatina , 15 byte

+‘ɼṪRṙ-œ|@
0Ç¡ḣ

Questo è un programma completo che, dato n , stampa i primi n elementi della sequenza.

Provalo online!

Come funziona

0Ç¡ḣ        Main link. Argument: n

0           Set the return value to 0.
 Ç¡         Call the helper link n times, first with argument 0, then n-1 times
            with the previous return value as argument.
   ḣ        Head; extract the first n items of the last return value.


+‘ɼṪRṙ-œ|@  Helper link. Argument: A (array)

 ‘ɼ         Increment the value in the register (initially 0) and yield it.
+           Add that value to all items in the sequence.
   Ṫ        Tail; extract the last item.
    R       Range; map k to [1, .., k].
     ṙ-     Rotate -1 units to the left, yielding [k, 1, ..., k-1].
       œ|@  Perform multiset union of A and the previous return value.

— Dennis
fonte

3

C (gcc), 73 67 64 byte

t,d;f(x){for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);t=x<4?x^x/2:x-1;}

Provalo online!

Definisce una funzione fche accetta 0-indicizzata ne produce il nnumero th nella sequenza.

Possiamo analizzare la sequenza come segue:

f(n)  = n   where n = 0, 1

f(2)  = 3   // 2 and 3 are swapped
f(3)  = 2

f(4)  = 5   // (+2,+3)
f(6)  = 8   // (+3,+4)
f(9)  = 12  // (+4,+5)
f(13) = 17  // (...)
...

f(n)  = n-1 // for all cases not yet covered

Innanzitutto gestiamo la sezione centrale:

for(t=4,d=2;d<x;t+=d++)x-t||(d+=x+=d);

Nota che gli argomenti a sinistra (4, 6, 9, 13, ...) seguono uno schema: prima aggiungi due, poi aggiungi tre, quindi aggiungi quattro e così via. Iniziamo da t=4e aggiungiamo d(che inizia da 2) ogni iterazione del ciclo, incrementando dnel processo.

Il corpo del loop è più interessante. Ricorda che vogliamo mappare da 4 a 5, da 6 a 8, da 9 a 12, ecc .; questo è solo aggiungere d-1se lo xè t. Tuttavia, questa logica viene prima dell'ultimo caso, f(n) = n - 1quindi sappiamo che alla fine sottrarremo 1. Pertanto, possiamo semplicemente aggiungere dif x == t( x-t||(x+=d)). Tuttavia, ci sarà anche bisogno di uscire dal giro subito dopo - in modo da aggiungiamo che per dottenere l'assurdo aspetto d+=x+=d, che sarà sempre rendere la d<xcondizione di sicuro.

Questo copre tutto tranne i primi quattro valori. Guardandoli in binario, otteniamo:

00 -> 00
01 -> 01
10 -> 11
11 -> 10

Quindi, vogliamo capovolgere l'ultimo bit se 2 <= x < 4. Questo si ottiene con x^x/2. x/2fornisce il secondo bit meno significativo, quindi XORing questo con il numero originale lancia l'ultimo bit se il numero è 2 o 3.

— Maniglia
fonte

3

Gelatina , 13 10 byte

-3 Grazie a Dennis (utilizzare l'indicizzazione 0 per salvare 2 dall'impostazione della somma cumulativa e un decremento finale)

Ḷ»2Äi+_>2$

Un collegamento monadico che accetta un numero intero, 0 -indexed n , che restituisce un numero intero, a (n)

Provalo online! O vedi una suite di test

— Jonathan Allan
fonte

Bello! Ho avuto ḶÄ+3i+’, ma non ho idea di come gestire i casi limite.

— Dennis,

Ho anche Ḷ»ạ¥3per Ḋ3,2;- Sembra che ci dovrebbe essere terser per questo bit.

— Jonathan Allan,

Ḷ»2Äi+_>2$salva 3 byte, con indicizzazione basata su 0.

— Dennis,

Oh golf fantastico! Ero bloccato in un terreno a 1 indice.

— Jonathan Allan,

2

Perl 5 con `-pl`, 70 byte

$"="|";push@f,$;=$f[-1]+$-++,grep!/^(@f|$;)$/,0..$;for 0..$_;$_=$f[$_]

Provalo online!

— Dom Hastings
fonte

2

MATL , 22 byte

1y:"t0)@+h5M:yX-h]qw:)

Emette i primi ntermini della sequenza.

Provalo online!

Spiegazione

1         % Push 1
y         % Implicit input: n. Duplicate from below
":        % For each k in [1 2 ... n]
  t0)     %   Duplicate sequence so far. Get last entry, say m
  @+      %   Add k: gives m+k
  h       %   Concatenate horizontally
  5M      %   Push m+k again
  :       %   Range [1 2 ... m+k]
  y       %   Duplicate from below
  X-      %   Set difference
  h       %   Concatenate horizontally
]         % End
q         % Subtract 1, element-wise
w         % Swap. Brings original copy of n to the top
:)        % Keep the first n entries. Implicit display

— Luis Mendo
fonte

Alla fine mi piace la faccina, ora voglio che tutti i miei programmi MATL finiscano con un sorriso. :)

— Sundar - Ripristina Monica l'

Sì, sono felice che sia un linguaggio relativamente comune in MATL :-D

— Luis Mendo,

2

Haskell , 51 byte

0:1:do(a,b)<-zip=<<(1:)$scanl(+)3[2..];b:[a+1..b-1]

Provalo online!

Abbastanza un po 'più a lungo della risposta di Lynn Haskell , ma il diverso approccio potrebbe essere interessante comunque.

— Laikoni
fonte

1

Rubino , 73 byte

f=->x,l,n{!l[x]&&(i=l[-1];f[x,l+[i+n]+([*(i+1...i+n)]-l),n+1])||l[0...x]}

Provalo online!

Funzione ricorsiva che restituisce i primi x numeri dell'elenco.

— crashoz
fonte

1

QBasic, 58 byte

DO
b=r+j
?b
r=b
FOR x=a+1TO b-1
?x
r=x
NEXT
a=b
j=j+1
LOOP

Uscite indefinitamente. Potresti voler aggiungere un SLEEP 1ciclo interno LOOP WHILE b<100o crearlo o qualcosa del genere per vedere i risultati.

Questo in pratica implementa solo le specifiche. Osserva che i numeri per cui torniamo indietro saranno sempre i numeri tra l'ultimo numero saltato e il numero saltato prima di quello. Quindi memorizziamo questi limiti come ae be usiamo un FORciclo per stampare tutti i numeri tra di loro.

— DLosc
fonte

1

05AB1E , 14 byte

0)sƒ¤N+LÁ«}Ùs£

Provalo online!

— Emigna
fonte

1

R , 70 byte

function(e){for(i in 1:e)F=c(setdiff((F+i):1-1,F),F[1]+i,F);rev(F)[e]}

Provalo online!

1-indicizzato
-4 byte usando Fcostante grazie al suggerimento @JAD
-5 byte invertendo la lista grazie al suggerimento di @Giuseppe
-2 byte rimuovendo le parentesi inutili per il loop grazie al suggerimento @JAD
-2 byte usando setdiffinvece dix[x %in% y]

Versione precedente (79 byte)

— digEmAll
fonte

2

79 byte

— JAD

@JAD: Ho sempre dimenticato di usare F / T ... Non posso farci niente, sono troppo propenso ad evitare "codice non sicuro": D

— digEmAll

1

Costruire l'elenco al contrario salva 5 bytese provoca un sacco di avvertimenti!

— Giuseppe,

Non è nemmeno pericoloso se F/Tnon vengono ridefiniti nella definizione della funzione. (IIRC) non modifica il valore globale perF/T

— JAD il

1

72 byte

— JAD

1

Python 2 , 123 byte

def f(z):[s.extend([s[-1]+n]+[x for x in range(s[-1]+1,s[-1]+n)if not x in s]) for n in range(1,z)if len(s)<z];return s

Provalo online!

Dato input x, genera i primi x termini della sequenza,

Sto imparando Python e queste sfide rendono le cose più interessanti.

Modifica: radere alcuni spazi bianchi

— Dente medio
fonte

Benvenuti in PPCG! Si può sbarazzarsi di alcuni più spazi in for n in range(1,z) if len(s) < z]; return s: for n in range(1,z)if len(s)<z];return s.

— Laikoni,

0

Gelatina , 16 byte

RÄṬŻk²Ḋ$ṙ€-Ø.;Fḣ

Provalo online!

Un byte più lungo della risposta esistente di Jelly, ma è possibile che si possa giocare un po 'a golf. RÄṬŻk²Ḋ$potrebbe essere più breve.

RÄṬŻk²Ḋ$‘ṙ€1FŻŻỤ’ḣ

Più lungo ma diverso.

— dylnan
fonte

0

Rubino , 63 byte

->x,n=0{n+=1while 0>d=n*n+n<=>2*x-6;[0,1,3,2][x]||[x+n,x-1][d]}

Provalo online!

0-indicizzati. Probabilmente si può giocare a golf.

— Ripristina Monica - notmaynard
fonte

0

Perl 6 , 52 byte

(0,{((^max @_)∖@_).min.?key//(1+@_[*-1]+$++)}...*)

Provalo online!

Questa è un'espressione del generatore che utilizza l' ...operatore. Cerca lacune nella sequenza precedente @_tramite ((^max @_)∖@_).min.?key:

      @_  # prior sequence values         [0,1,3]
  max @_  # largest prior sequence value       3
 ^        # the Range 0..max @_            0,1,2
(       )∖@_  # set subtract prior seq     -0,1  -> (2=>True)
            .min  # smallest unseen value  2=>True
                .?key  # set yields pairs  2

Il ?è necessario che il valore iniziale che non ha una .key. Se non vengono trovati spazi vuoti, allora aggiunge n (qui nella $variabile) all'ultimo valore nell'elenco, più uno per off per 0 errori.

— Phil H
fonte

0

Python 3 , 104 byte

def f(x):
 n=a=0
 l=list(range(x*x))
 while n<x:print(l[a+n],*l[a+2-(n<3):a+n],end=' ');a=a+n-(a>0);n+=1

Provalo online!

Dato input x, genera le prime x "sequenze"

— frosqh
fonte

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.

Licensed under cc by-sa 3.0 with attribution required.