Defina una secuencia indexada de 1 de la siguiente manera:

• A083569(1) = 1
• A083569(n)donde nes un número entero mayor que 1, es el número entero más pequeño m que no aparece antes, de modo que m+nes un número primo.

Su tarea es acoger ny regresar A083569(n).

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

Más casos de prueba se pueden encontrar aquí . La secuencia original en OEIS se puede encontrar aquí .

Este es el código de golf . La respuesta más corta en bytes gana. Se aplican lagunas estándar .

Haskell , 87 86 83 80 74 69 bytes

¡Gracias a xnor por sugerir algunos cambios que ahorraron 3 bytes!

f n=[m|m<-[1..],all((>0).mod(n+m))[2..n+m-1],all((/=m).f)[1..n-1]]!!0

Pruébalo en línea!

Soy nuevo en Haskell, y en Haskell golf, ¡se agradecen sus comentarios!

Explicación

Definimos una función f n. Definimos f nser el primer elemento !!0de la lista:

[m|m<-[1..],all((>0).mod(n+m))[2..n+m-1],all((/=m).f)[1..n-1]]

Desglosado que es:

[m|          # Numbers m
m<-[1..],    # From the integers greater than 0
all          # Forall x
(>0).mod(n+m)# n+m mod x is not zero
[2..n+m-1]   # from the integers from 2 to n+m-1
all          # Forall
((/=m).f)    # when f is applied the result is not m
[1..n-1]     # from the integers from 1 to n-1

Jalea , 16 15 bytes

Rɓ²R+⁸ÆPTḟḢṭµ/Ṫ

Esto supone A083569 (n) ≤ n² (la secuencia parece estar creciendo linealmente).

Pruébalo en línea!

Cómo funciona

Rɓ²R+⁸ÆPTḟḢṭµ/Ṫ  Main link. Argument: n

R                Range; yield [1, ..., n].
 ɓ               Begin a dyadic chain with swapped arguments.
            µ/   Reduce the range by that chain.
                 If we call the chain f, this computes f(2,1), then f(3,f(2,1)),
                 then f(4,f(3,f(2,1)), etc.
                 The left argument is an integer k, the right one an array A.
  ²                Square; yield k².
   R               Range; yield [1, ..., k²].
    +⁸             Add k, yielding [1+k, ..., k²+k].
      ÆP           Test each sum for primality.
        T          Truth; get all indices of 1‘s. This finds all m in [1, ..., k²]
                   such that m+k is prime.
         ḟ         Filterfalse; remove all resulting elements that appear in A.
          Ḣ        Head; extract the first remaining result.
           ṭ       Tack; append the extracted integer to A.
                 This computes the first n elements of the sequence.
              Ṫ  Tail; extract the last, n-th element.

Pyth - 18 17 15 bytes

¡Gracias a @isaacg por salvarme dos bytes!

De vuelta en este sitio, después de haber estado ocupado por un tiempo, esperamos que este golf aún más.

esmaYf&-TYP_+Th

Pruébelo en línea aquí .

C # (.NET Core) , 169 bytes

n=>{if(n<2)return 1;var p=new int[n-1];int i=0,j,s;for(;i<n-1;)p[i]=f(++i);for(i=1;;i++){for(j=2,s=i+n;j<s&&s%j++>0;);if(j==s&!System.Array.Exists(p,e=>e==i))return i;}}

Pruébalo en línea!

Con mucho, la forma más eficiente para el cálculo de los resultados, así que por favor absténgase de cálculo f(n)para n>=30con este código. El primer paso es calcular de forma recursiva los valores de f(1)a f(n-1)y luego proceder a calcular f(n)mediante la búsqueda de la primera ide tal manera que n+ies primo y ino está en la lista de valores anterior.

Conjunto x86-64, 57 55 bytes

Soy nuevo en el golf, por lo que se agradecen los comentarios / comentarios.

Nota: esto está optimizado para la longitud del código de máquina, no para la longitud de la fuente.

0: 89 f8 ff cf 74 32 97 89 fe 89 f1 ff c6 89 f0 99
1: f7 f1 85 d2 e0 f7 85 c9 75 ed 89 f9 ff c9 56 29
2: fe 56 57 51 89 fc e8 d3 ff ff ff 59 5f 5e 39 c6
3: e0 ef 96 5e 74 d1 c3

Define una función, utilizando la convención estándar (es decir, valor de retorno en eax, primer argumento en edi, todos los registros guardados por el llamador excepto ebx) que toma un entero de 32 bits sin signo y devuelve el m más pequeño, etc.

Fuente:

    .globl a083569
    // edi = original, probably don't touch
    // esi = candidate prime, if it's not a repeat we return edi-this
a083569:
    mov %edi, %eax
    dec %edi
    jz end
    xchg %eax, %edi
    mov %edi, %esi
primecheck:
    mov %esi, %ecx
    inc %esi
primeloop:
    mov %esi, %eax
    cdq
    div %ecx
    test %edx, %edx
    loopnz primeloop
/* end */
    // if esi isn't prime, then ecx is now one or greater.
    test %ecx, %ecx
    jnz primecheck
    // esi is now our target prime: check if it's not already one
    mov %edi, %ecx
    dec %ecx
    push %rsi   /* we need a flag-safe way to restore this later */
    sub %edi, %esi
chkdup:
    push %rsi
    push %rdi
    push %rcx
    mov %ecx, %edi
    call a083569
    pop %rcx
    pop %rdi
    pop %rsi
    cmp %eax, %esi
    loopne chkdup
/* end loop - chkdup */
    xchg %esi, %eax
    pop %rsi
    je primecheck
/* end outer loop - primecheck */
end:
    ret

Pruébalo en línea!

Clojure, 158155 bytes

#(loop[r[0 1]i 1](if(= i %)(last r)(recur(conj r(nth(for[j(range):when(=((set r)j)(seq(for[k(range 2(+ 1 i j)):when(=(mod(+ 1 i j)k)0)]j)))]j)0))(inc i))))

Esto aún podría tener algo de grasa, no estoy muy contento, (+ 1 i j)pero esta fue la forma más fácil de manejar el caso base n = 1y el resto. ((set r)j)devuelve nilsi jno está en el conjunto, y (seq ())en una lista vacía también devuelve nil. Calcula n = 1000en 48 segundos.

Actualización: eliminado nilde la =verificación ya que el código funciona correctamente también sin él.

Ruby , 62 + 8 = 70 bytes

Usa la -rprimebandera.

f=->n,o=[]{o<<f[n-1,o]if n>1;Prime.find{|i|i>n&&o|[i-n]!=o}-n}

Pruébalo en línea!

Python, 194 170 110 bytes

84 bytes guardados por Leaky Nun

2 bytes guardados por Mathmandan

def s(n):
 a=[s(j)for j in range(1,n)];i=1
 while(i in a)|any((i+n)%j<1for j in range(2,i+n)):i+=1
 return i

Define una función s (n) que toma un número como entrada y devuelve A083569 (n).

Pruébalo en línea