Nuova sequenza vicina

24

Gli interi non negativi si annoiano di avere sempre gli stessi due vicini, quindi decidono di mescolare un po 'le cose. Tuttavia, sono anche pigri e vogliono stare il più vicino possibile alla loro posizione originale.

Vengono fuori con il seguente algoritmo:

Il primo elemento è 0.
L' elemento è il numero più piccolo che non è ancora presente nella sequenza e che non è un vicino dell'elemento . $n^{th}$ $(n-1)^{th}$

Questo genera la seguente sequenza infinita:

0,2,4,1,3,5,7,9,6,8,10,12,14,11,13,15,17,19,16,18,20,22,24,21,23,25,27,29,26,28 ...

0è il primo elemento. 1è il numero più piccolo non ancora nella sequenza, ma è un vicino di 0. Il prossimo numero più piccolo è 2, quindi è il secondo elemento della sequenza. Ora i numeri rimanenti sono 1,3,4,5,6,..., ma come entrambi 1e 3vicini di casa 2, 4è il terzo membro della sequenza. Poiché 1non è un vicino di casa 4, può finalmente prendere il suo posto come quarto elemento.

L'obiettivo

Scrivi una funzione o un programma nel minor numero di byte possibile che genera la sequenza sopra.

Potresti

emette la sequenza all'infinito,
accetta un input e restituisce l' elemento della sequenza, oppure $n$ $n^{th}$
accetta un input e restituisce i primi elementi della sequenza. $n$ $n$

L'indicizzazione zero o una va bene nel caso in cui si scelga una delle due ultime opzioni.

Non è necessario seguire l'algoritmo sopra indicato, qualsiasi metodo che produce la stessa sequenza va bene.

^{Ispirato da Code golf la migliore permutazione . Si scopre che questo è A277618 .}
_{* Zero ha letteralmente un solo vicino e non gliene importa nulla.}

code-golf sequence integer

— Laikoni
fonte

Post sandbox (cancellato)

— Laikoni

Risposte:

18

JavaScript (ES6), 13 byte

Restituisce il^° termine della successione. $n$

n=>n-2-~++n%5

Provalo online!

Come?

Questo calcola:

n - 2 + ((n + 2) mod 5)

$n-2+((n+2) \bmod 5)$

           n |  0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 ...
-------------+--------------------------------------------------
       n - 2 | -2 -1  0  1  2  3  4  5  6  7  8  9 10 11 12 ...
 (n+2) mod 5 |  2  3  4  0  1  2  3  4  0  1  2  3  4  0  1 ...
-------------+--------------------------------------------------
         sum |  0  2  4  1  3  5  7  9  6  8 10 12 14 11 13 ...

— Arnauld
fonte

8

Python 2 , 20 byte

lambda n:2*n%5+n/5*5

Provalo online!

— Chas Brown
fonte

8

MathGolf , 5 byte

⌠5%+⌡

Provalo online!

Qualche bella simmetria qui. Restituisce l' nthelemento della sequenza.

Spiegazione:

⌠      Increment input by 2
 5%    Modulo by 5
   +   Add to copy of input
    ⌡  Decrement by 2

— Jo King
fonte

6

Gelatina , 5 byte

æ%2.+

Provalo online!

Vai vai gadget oscuro incorporato!

æ%2.      Symmetric modulo 5: map [0,1,2,3,4,5,6,7,8,9] to [0,1,2,-2,-1,0,1,2,-2,-1]
    +     Add to input

— Lynn
fonte

4

Wolfram Language (Mathematica) , 14 byte

#+Mod[#,5,-2]&

Provalo online!

Stampa l'n-esimo numero zero indicizzato nella sequenza.

— Misha Lavrov
fonte

4

R , 25 23 21 byte

-2 byte grazie a Jo King

n=scan();n-2+(n+2)%%5

Provalo online!

Emette l' nthelemento in sequenza.

— Robert S.
fonte

3

dzaima / APL , 9 byte

2-⍨⊢+5|2+

La risposta di Port of Arnauld.

Provalo online!

— Quintec
fonte

3

Pip , 14 byte

02413@a+a//5*5

$n$ $a_n$

$a_{n+5} = a_n+5$

Oppure, la formula utilizzata da tutti, per 12 byte :

a-2+(a+2)%5

— DLosc
fonte

2

Lisp comune , 67 byte

(defun x(n)(loop for a from 0 to n collect(+(mod(+ a 2)5)(- a 2))))

Provalo online!

— JRowan
fonte

Penso solo (defun x(n)(+(mod(+ n 2)5)(- n 2))), o (lambda(n)(+(mod(+ n 2)5)(- n 2)))è abbastanza: restituire l'ennesimo termine, piuttosto che una sequenza di termini.

— Misha Lavrov,

2

Japt , 8 byte

U-2Ò°U%5

Interprete Japt

Una porta diretta della risposta Javascript di Arnauld. La versione collegata attraversa i primi n elementi, ma se il -mflag viene rimosso è ancora valido e stampa invece l'ennesimo elemento.

Per fare un confronto, ecco la versione ingenua che implementa l'algoritmo fornito nella domanda:

@_aX É«NøZ}a}gNhT

Darò una spiegazione per questo:

              NhT    Set N to [0]
@           }g       Get the nth element of N by filling each index with:
 _        }a          The first integer that satisfies:
  aX É                 It is not a neighbor to the previous element
      «NøZ             And it is not already in N

— Kamil Drakari
fonte

-3 byte sulla seconda soluzione e probabilmente può essere ulteriormente migliorato.

— Shaggy,

2

05AB1E , 5 byte

Ì5%+Í

Porta della risposta MathGolf di @ JoKing .

Provalo online o verifica i primi 100 numeri .

Spiegazione:

Ì        # Increase the (implicit) input by 2
 5%      # Take modulo-5
   +     # Add the (implicit) input to it
    Í    # Decrease by 2 (and output implicitly)

— Kevin Cruijssen
fonte

2

Pulito , 31 byte

La formula che tutti usano.

import StdEnv
?n=n-2+(n+2)rem 5

Provalo online!

Pulito , 80 byte

Il mio approccio iniziale, restituendo i primi nelementi.

import StdEnv
$n=iter n(\l=l++[hd[i\\i<-[0..]|all((<>)i)l&&abs(i-last l)>1]])[0]

Provalo online!

— Οurous
fonte

2

Pari / GP , 14 byte

n->2*n%5+n\5*5

Provalo online!

Pari / GP , 14 byte

n->n-2+(n+2)%5

Provalo online!

— alephalpha
fonte

2

J , 30 byte

{.2}.[:,_5,./\2(i.-4 0$~])@,~]

Provalo online!

Restituisce un elenco di primi nnumeri

Questa soluzione è ovviamente non competitiva, ma volevo provare un metodo basato su array.

Spiegazione:

L'argomento è n

2 ,] - aggiungere 2 all'ingresso

   (2,~]) 10
10 2

()@ - e utilizzare questo elenco per:

i.- crea una matrice nx 2 con i numeri nell'intervallo 0..2n-1:

4 0$~]- ~inverte gli argomenti, quindi è] $ 4 0 - crea una matrice nx 2 ripetendo 4 0

- sottrarre la seconda matrice dalla prima, in modo che la prima colonna sia "ritardata" con 2 posizioni

   2(i.-4 0$~])@,~] 10
_4  1
_2  3
 0  5
 2  7
 4  9
 6 11
 8 13
10 15
12 17
14 19

_5,./\ attraversare la matrice in gruppi non sovrapposti di 5 file e cucire le colonne

   _5,./\2(i.-4 0$~])@,~] 10
_4 _2  0  2  4
 1  3  5  7  9

 6  8 10 12 14
11 13 15 17 19

[:, Ravel l'intero array

   ,_5,./\2(i.-4 0$~])@,~] 10
_4 _2 0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19

2}. - rilascia i primi 2 numeri

   2}.,_5,./\2(i.-4 0$~])@,~] 10
0 2 4 1 3 5 7 9 6 8 10 12 14 11 13 15 17 19

{.prendi i primi nnumeri

   ({.2}.[:,_5,./\2(i.-4 0$~])@,~]) 10
0 2 4 1 3 5 7 9 6 8

J , 9 byte

+_2+5|2+]

Provalo online!

Restituisce l' nelemento th.

La risposta di Port of Arnauld

— Galen Ivanov
fonte

2

K (ngn / k) , 12 byte

{-2+x+5!x+2}

Provalo online!

— Thaufeki
fonte

1

-2+x+->x-2-

— ngn

2

Pepe , 65 byte

REeeeeeeEerEeERRrEEEEEERREeeeeeEeErEEeEeErRrEEEEEEEErRrEEEEEereEE

Provalo online!

La risposta di Port of Jo King.

— non definito
fonte

1

codice macchina x86, 16 byte

00000000: 31d2 89c8 4949 4040 b305 f7f3 9201 c8c3 1...II@@........

Montaggio:

section .text
	global func
func:	;function uses fastcall conventions, 1st arg in ecx, returns in eax
	;reset edx to 0 so division works
	xor edx, edx

	mov eax, ecx
	;calculate ecx (1st func arg) - 2
	dec ecx
	dec ecx

	;calculate (ecx+2) mod 5
	inc eax
	inc eax
	mov bl, 5
	div ebx
	xchg eax, edx
	
	;add (ecx-2) and ((ecx+2) mod 5), returning in eax
	add eax, ecx
	ret

Provalo online!

— Logern
fonte

1

Rosso , 26 byte

func[n][n + 2 % 5 + n - 2]

Provalo online!

La risposta di Port of Arnauld

— Galen Ivanov
fonte

1

Excel, 17 byte

=A1-2+MOD(A1+2,5)

Niente di intelligente. Implementa la formula comune.

— Wernisch
fonte

1

C (gcc) POSIX, 20 byte

f(n){n=n-2+(n+2)%5;}

Provalo online!

— Dipendente
fonte

1

QBasic, 30 byte

INPUT x 
x=x+2 
?-4+x*2-(x\5)*5

Fornisce la voce con indice 0 dell'elenco in pos x.

Provalo online! (Nota che è ?stato espanso PRINTperché l'interprete non riesce altrimenti ...)

— Steenbergh
fonte

1

C # (compilatore interattivo Visual C #) , 14 byte

n=>2*n%5+n/5*5

Provalo online!

Stessa logica delle altre risposte: 1 2

— aloisdg dice Reinstate Monica
fonte

1

R , 25 byte

n=1:scan()-1;n-2+(n+2)%%5

Provalo online!

La risposta di Port of Robert S. (e solo aggiungendo solo 4 byte) grazie a R che è eccellente nella gestione dei vettori.

Emette i primi n valori.

— Sumner18
fonte

1

dc , 9 byte

d2+5%+2-p

Provalo online!

Stesso metodo della maggior parte. Duplica top-of-stack, aggiungi 2, mod 5, aggiungi all'originale (duplicato in precedenza), sottrai 2, stampa.

— brhfl
fonte

0

TI-BASIC, 11 byte

Ans-2+remainder(Ans+2,5

L'ingresso è in Ans.
Uscite $a(n)$ .

Una semplice porta delle altre risposte.

Nota: TI-BASIC è un linguaggio tokenizzato. Il conteggio dei caratteri non equivale al conteggio dei byte.

— Tau
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.