OEIS tiene una variación (A111439) en la secuencia de Golomb . Como en la secuencia de Golomb, A(n)describe con qué frecuencia naparece en la secuencia. Pero además, no hay dos números consecutivos pueden ser idénticos. Al construir la secuencia, A(n)siempre se elige como el entero positivo más pequeño que no viola estas dos propiedades. Debido a números idénticos consecutivos no permitidos, la serie se tambalea ligeramente hacia arriba y hacia abajo a medida que crece. Aquí están los primeros 100 términos:

1, 2, 3, 2, 3, 4, 3, 4, 5, 6, 5, 6, 5, 6, 7, 6, 7, 8, 7, 8, 9, 8, 9, 8, 9, 
10, 9, 10, 9, 10, 11, 10, 11, 10, 11, 10, 11, 12, 11, 12, 13, 12, 13, 12, 
13, 12, 13, 12, 13, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 14, 15, 16, 15, 
16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 18, 17, 18, 17, 18, 19, 18, 19, 18, 
19, 18, 19, 18, 19, 18, 19, 20, 19, 20, 21, 20, 21, 20, 21, 20, 21, 20

La lista completa de los primeros 10,000 números se puede encontrar en OEIS .

El desafío es escribir un programa o función que compute A(n), dado n. nestá 1basado para garantizar que la propiedad autodescriptiva funcione.

Reglas

Puede escribir un programa o una función y utilizar cualquiera de nuestros métodos estándar para recibir entradas y proporcionar salidas.

Puede usar cualquier lenguaje de programación , pero tenga en cuenta que estas lagunas están prohibidas de forma predeterminada.

Este es el código de golf , por lo que gana la respuesta válida más corta, medida en bytes .

Casos de prueba

n     A(n)
1     1
4     2
10    6
26    10
100   20
1000  86
1257  100
10000 358

Haskell , 67 bytes

f k|k<4=k|p<-k-1=[n|n<-[1..],n/=f p,sum[1|a<-[1..p],f a==n]<f n]!!0

Define una función f. Pruébalo en línea! Es muy lento, la informática f 15agota el tiempo de espera en TIO.

Explicación

Simplemente siguiendo la definición: en cada etapa, elija el número positivo mínimo nque satisfaga las restricciones (no es igual a la entrada anterior, y aún no ha ocurrido f nveces).

f k             -- Define f k:
 |k<4=k         -- If k < 4, it's k.
 |p<-k-1=       -- Otherwise, bind k-1 to p,
  [n|           -- compute the list of numbers n where
   n<-[1..],    -- n is drawn from [1,2,3,...],
   n/=f p,      -- n is not equal to f p, and
   sum[1|       -- the number of
    a<-[1..p],  -- those elements of [1,2,3,...,p]
    f a==n]     -- whose f-image equals n
   <f n]        -- is less than f n,
  !!0           -- and take the first element of that list.

Mathematica, 69 68 bytes

¡Gracias a Martin Ender por encontrar un –1 byte extra para mí!

Last@Nest[{##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&,{},#]&

Función sin nombre que toma un entero positivo ncomo entrada y devuelve un entero positivo. Construimos la lista completa de los primeros nelementos de esta secuencia, luego tomamos el Lastelemento. La lista se construye comenzando con la lista vacía {}y operando con una función nveces en una fila (vía Nest).

La función en cuestión es {##&@@#,1//.x_/;x==Last@#||#~Count~x==#[[x]]->x+1}&, que toma una lista parcial de valores de secuencia (esencialmente ##&@@#) y le agrega el siguiente valor. El siguiente valor se calcula a partir de x=1, a continuación, varias veces la sustitución xpor x+1el tiempo que la condición x==Last@#||#~Count~x==#[[x]]se cumple, en otras palabras, si bien xes el elemento anterior, o bien xya está en la lista el número correcto de veces. Esta función escupe algunos errores, ya que (por ejemplo) no deberíamos llamar al xelemento th de la lista inicial {}; sin embargo, los valores son todos correctos.

Python 2, 99 86 bytes

¡Gracias a @Dennis por varias mejoras por un total de 13 bytes!

s=0,1,2,3
exec't=1\nwhile t==s[-1]or s.count(t)/s[t]:t+=1\ns+=t,;'*input()
print s[-4]

El programa funciona de manera bastante ingenua: realiza un seguimiento de la lista de valores que se determinó hasta ahora y busca agregar el siguiente valor. Intenta agregar 1a al final de la lista si puede; si no, entonces intenta ay 2así hasta que se permita algo.

Ahora, comenzamos sembrando los resultados para 1,2,3ser 1,2,3. Esto se hace para evitar cualquier problema con la lista de los valores calculados ya es demasiado corto-: I conjetura que si nes al menos 4entonces a(n)es estrictamente menor que n. (En este programa, s[n]es igual a a(n). Nuestra lista en realidad se inicializa [0,1,2,3]porque las listas están 0indexadas en Python. Entonces, por ejemplo a(1)=s[1]=1, y a(2)=s[2]=2).

Entonces, digamos que estamos tratando de determinar s[m], lo que significa que nuestra lista ya incluye s[0], s[1], ..., s[m-1]. Comenzaremos en t=1e intentaremos configurar s[m]=1. Cuando eso no funciona, vamos t=2y tratamos de configurar s[m]=2. Cada vez que incrementamos t, verificamos si s.count(t)==s[t]... pero el lado derecho no producirá un error siempre y cuando nunca tengamos que llegar tan alto t=m. La conjetura dice que nunca tenemos que hacerlo, ya que el primer valor que calculamos es en realidad s[4].

Esta implementación calcula 3 valores más de la secuencia de los que necesita. Por ejemplo, si nes 8así, calculará s[11]antes de devolver el valor de s[8].

Me alegraría ver una prueba de la conjetura. Creo que se puede probar por inducción (¿fuerte?).

Editar: Aquí hay una prueba de la conjetura . De hecho, demostramos una forma ligeramente más fuerte de la declaración, ya que no implica trabajo adicional.

Teorema: para todo nmayor o igual que 4, el término a(n)es menor o igual que (n-2).

Prueba (por Inducción Fuerte): (Base n=4): La afirmación es verdadera para n=4, desde entonces a(4) = 2 = 4-2.

Ahora suponga que a(k)es menor o igual que k-2para todos kde 4hasta n, inclusivo (y suponga que nes al menos 4). En particular, esto significa que todos los términos anteriores de la secuencia eran como máximo (n-2). Necesitamos demostrar que a(n+1)será como mucho (n-1). Ahora, por definición, a(n)es el entero positivo más pequeño que no viola ninguna de las condiciones, por lo que solo debemos mostrar que el valor (n-1)no violará ninguna de las condiciones.

El valor (n-1)no violará la condición de "no repeticiones consecutivas", porque según la hipótesis de inducción, la entrada anterior era como máximo (n-2). Y no violará la condición " a(m)es el número de veces que maparece", a menos que (n-1)ya se haya alcanzado a(n-1)veces. Pero por la fuerte suposición de inducción, (n-1)anteriormente se había alcanzado 0tiempos, y a(n-1)no es igual a 0como a(m)es positivo para todos m.

Por a(n+1)lo tanto, es menor o igual que n-1 = (n+1)-2, según se desee. QED

Jalea , 17 bytes

Ṭ€S<;1Tḟ®Ḣ©ṭ
⁸Ç¡Ṫ

Los últimos tres casos de prueba son demasiado para TIO. He verificado 1000 y 1257 localmente.

Pruébalo en línea! o verificar los primeros 100 términos .

Cómo funciona

⁸Ç¡Ṫ          Main link. No arguments.

⁸             Yield [].
 Ç¡           Execute the helper link n times (where n is an integer read from
              STDIN), initially with argument [], then with the previous return
              value as argument. Yield the last return value.
              Tail; yield the last element of the result.


Ṭ€S<;1Tḟ®Ḣ©ṭ  Helper link. Argument: A (array)

Ṭ€            Untruth each convert each k into an array of k-1 zeroes and one 1.
  S           Sum; column-wise reduce by +, counting the occurrences of all
              between 1 and max(A).
   <          Compare the count of k with A[k] (1-indexed), yielding 1 for all
              integers that still have to appear once or more times.
    ;1        Append a 1 (needed in case the previous result is all zeroes).
      T       Truth; find all indices of ones.
       ḟ®     Filter-false register; remove the value of the register (initially 0)
              from the previous result.
         Ḣ©   Head copy; yield the first (smallest) value of the result and save
              it in the register.
           ṭ  Tack; append the result to A.

Python 2 , 77 74 bytes

f=lambda n,k=1:n*(n<4)or map(f,range(n)+k*[n-1]).count(k)<f(k)or-~f(n,k+1)

Esta es una implementación recursiva del algoritmo de @ mathmandan .

La implementación es O (demente) : la entrada 9 tarda 2 segundos localmente, la entrada 10 52 segundos y la entrada 11 17 minutos y 28 segundos. Sin embargo, si se declara como una función regular en lugar de una lambda, la memorización se puede utilizar para verificar los casos de prueba.

Pruébalo en línea!

Tenga en cuenta que incluso con memoization, TIO no puede cómputo f (1257) o F (10,000) (ambos verifican localmente).

05AB1E , 32 31 bytes

XˆXˆG[N¯2(è<›¯¤NÊsN¢¯Nè‹&&#]N.ˆ

Pruébalo en línea!

Explicación

XˆXˆ                             # initialize global list as [1,1]
    G                            # input-1 times do:
     [                    #]     # loop until expression is true     
      N¯2(è<›                    # n > list[-2]-1
             ¯¤NÊ                # list[-1] != N
                 sN¢¯Nè‹         # count(list, N) < list[N]
                        &&       # logical AND of the 3 expressions
                            N.ˆ  # add N to global list 
                                   and output last value in list and end of program

Técnicamente estamos en bucle Gcuando agregamos N a la lista global, pero todos los bucles en 05AB1E usan la misma variable N como índice, por lo que el bucle interno [...]ha sobrescrito el N de Gsignificado, podemos agregarlo fuera del bucle.

Los problemas con bucles anidados y condicionales nos impiden hacer esto dentro del bucle.

Befunge, 141 136 bytes

<v9\0:p8\2:*2:-1<9
v>p1+:3\8p0\9p:#^_&
>1-:#v_1.@>$8g.@
*+2%\>1-:!|>$!:::9g!\!9g!*\:8g\!8g`
9\+1g9::< \|`g9\g8+2::p
g2+\8p2+^:<>:0\9p::8

Pruébalo en línea!

Debido a las limitaciones de memoria de Befunge, no es realmente práctico realizar un seguimiento de todas las entradas de entradas anteriores en la secuencia, por lo que esta solución utiliza un algoritmo con una huella de memoria más baja que calcula los valores más directamente.

Dicho esto, todavía estamos limitados por el tamaño de la celda, que en el intérprete de referencia Befunge-93 es un valor de 8 bits con signo, por lo que el número par más alto admitido en la secuencia es A(1876) = 126, y el número impar más alto es A(1915) = 127.

Si desea probar valores más grandes, deberá usar un intérprete con un tamaño de celda más grande. Eso debería incluir la mayoría de las implementaciones de Befunge-98 (¡ Pruébelo en línea! ).

Python 2, 117 bytes

Meh No es tan corto. La solución iterativa simple.

L=[1,2,3]
n=input()
while len(L)<n:
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:L+=[i];break
print L[n-1]

Pruébalo en línea

Aquí hay un intento realmente malo de una solución recursiva (129 bytes):

def f(n,L=[1,2,3]):
 if len(L)>=n:print L[n-1];exit(0)
 for i in range(2,n):
    if L.count(i)<L[i-1]and L[-1]!=i:f(n,L+[i])
 f(n,L)