Los enteros no negativos están aburridos de tener siempre los mismos dos * vecinos, por lo que deciden mezclar un poco las cosas. Sin embargo, también son flojos y quieren mantenerse lo más cerca posible de su posición original.

Vienen con el siguiente algoritmo:

• El primer elemento es 0.
• El elemento es el número más pequeño que aún no está presente en la secuencia y que no es vecino del elemento .$n^{th}$$(n-1)^{th}$

Esto genera la siguiente secuencia 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 ...

0Es el primer elemento. 1es el número más pequeño que aún no está en la secuencia, pero es vecino de 0. El siguiente número más pequeño es 2, por lo que es el segundo elemento de la secuencia. Ahora los números restantes son 1,3,4,5,6,..., pero como ambos 1y 3son vecinos de 2, 4es el tercer miembro de la secuencia. Como 1no es vecino 4, finalmente puede tomar su lugar como cuarto elemento.

La tarea

Escriba una función o programa en la menor cantidad de bytes posible que genere la secuencia anterior.

Puedes

• dar salida a la secuencia infinitamente,
• tome una entrada devuelva el elemento de la secuencia, o$n$$n^{th}$
• tome una entrada devuelva los primeros n elementos de la secuencia.$n$$n$

Tanto la indexación cero como la única están bien en caso de que elija una de las dos últimas opciones.

No necesita seguir el algoritmo dado anteriormente, cualquier método que produzca la misma secuencia está bien.

^{Inspirado en Code golf la mejor permutación . Resulta que esto es A277618 .}
_{* Zero tiene literalmente solo un vecino y realmente no le importa.}

JavaScript (ES6), 13 bytes

Devuelve el ^º término de la secuencia.$n$

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

Pruébalo en línea!

¿Cómo?

Esto calcula:

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

Python 2 , 20 bytes

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

Pruébalo en línea!

MathGolf , 5 bytes

⌠5%+⌡

Pruébalo en línea!

Alguna buena simetría aquí. Devuelve el nthelemento de la secuencia.

Explicación:

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

Jalea , 5 bytes

æ%2.+

Pruébalo en línea!

Go go gadget obscure incorporado!

æ%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

Wolfram Language (Mathematica) , 14 bytes

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

Pruébalo en línea!

Imprime el enésimo número entero indexado a cero en la secuencia.

R , 25 23 21 bytes

-2 bytes gracias a Jo King

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

Pruébalo en línea!

nthElemento de salidas en secuencia.

dzaima / APL , 9 bytes

2-⍨⊢+5|2+

La respuesta del puerto de Arnauld.

Pruébalo en línea!

Pip , 14 bytes

02413@a+a//5*5

$n$$a_n$

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

O, la fórmula que todos usan, para 12 bytes :

a-2+(a+2)%5

Lisp común , 67 bytes

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

Pruébalo en línea!

Japt , 8 bytes

U-2Ò°U%5

Intérprete Japt

Un puerto directo de la respuesta Javascript de Arnauld. La versión vinculada se ejecuta a través de los primeros n elementos, pero si -mse elimina la bandera, sigue siendo válida e imprime el enésimo elemento.

En aras de la comparación, aquí está la versión ingenua que implementa el algoritmo proporcionado en la pregunta:

@_aX É«NøZ}a}gNhT

Daré una explicación para este:

              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

05AB1E , 5 bytes

Ì5%+Í

Puerto de la respuesta MathGolf de @ JoKing .

Pruébelo en línea o verifique los primeros 100 números .

Explicación:

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

Limpio , 31 bytes

La fórmula que todos usan.

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

Pruébalo en línea!

Limpio , 80 bytes

Mi enfoque inicial, devolviendo los primeros nartículos.

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

Pruébalo en línea!

Pari / GP , 14 bytes

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

Pruébalo en línea!

Pari / GP , 14 bytes

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

Pruébalo en línea!

J , 30 bytes

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

Pruébalo en línea!

Devuelve una lista de los primeros nnúmeros.

Obviamente, esta solución no es competitiva, pero quería probar un método basado en una matriz.

Explicación:

El argumento es n

2 ,] - agregar 2 a la entrada

   (2,~]) 10
10 2

()@ - y usa esta lista para:

i.- cree una matriz nx 2 con los números en el rango 0..2n-1:

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

4 0$~]- ~invierte los argumentos, entonces es] $ 4 0 - crea una matriz nx 2 repitiendo 4 0

   4 0$~10 2
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0
4 0

- reste la segunda matriz de la primera, de modo que la primera columna se "retrase" con 2 posiciones

   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,./\ atravesar la matriz en grupos no superpuestos de 5 filas y unir las columnas

   _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

[:, desentrañar todo el conjunto

   ,_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}. - suelta los primeros 2 números

   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

{.toma los primeros nnúmeros

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

J , 9 bytes

+_2+5|2+]

Pruébalo en línea!

Devuelve el nelemento th.

La respuesta del puerto de Arnauld

K (ngn / k) , 12 bytes

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

Pruébalo en línea!

Pepe , 65 bytes

REeeeeeeEerEeERRrEEEEEERREeeeeeEeErEEeEeErRrEEEEEEEErRrEEEEEereEE

Pruébalo en línea!

La respuesta del puerto de Jo King.

código de máquina x86, 16 bytes

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

Montaje:

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

Pruébalo en línea!

Rojo , 26 bytes

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

Pruébalo en línea!

La respuesta del puerto de Arnauld

Excel, 17 bytes

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

Nada inteligente Implementa la fórmula común.

C (gcc) POSIX, 20 bytes

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

Pruébalo en línea!

QBasic, 30 bytes

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

Da la entrada indexada 0 de la lista en pos x.

Pruébalo en línea! (Tenga en cuenta que ?se expandió a PRINTporque el intérprete falla de lo contrario ...)

C # (compilador interactivo de Visual C #) , 14 bytes

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

Pruébalo en línea!

La misma lógica que otras respuestas: 1 2

R , 25 bytes

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

Pruébalo en línea!

La respuesta del puerto de Robert S. (y solo agregando solo 4 bytes) gracias a que R es excelente en el manejo de vectores.

Emite los primeros n valores.

dc , 9 bytes

d2+5%+2-p

Pruébalo en línea!

El mismo método que la mayoría. Duplique la parte superior de la pila, agregue 2, mod 5, agregue al original (duplicado anteriormente), reste 2, imprima.

TI-BASIC, 11 bytes

Ans-2+remainder(Ans+2,5

La entrada está adentro Ans.
Salidas$a(n)$.

Un puerto simple de las otras respuestas.

Nota: TI-BASIC es un lenguaje tokenizado. El recuento de caracteres no es igual al recuento de bytes.