Definire una sequenza indicizzata come segue:

• A083569(1) = 1
• A083569(n)dove nè un numero intero maggiore di 1, è il numero intero più piccolo m che non si verifica prima in modo tale che m+nsia un numero primo.

Il tuo compito è accettare ne tornare 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

Altri test possono essere trovati qui . La sequenza originale su OEIS è disponibile qui .

Questo è code-golf . Vince la risposta più breve in byte. Si applicano scappatoie standard .

Haskell , 87 86 83 80 74 69 byte

Grazie a xnor per aver suggerito alcune modifiche che hanno salvato 3 byte!

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

Provalo online!

Sono nuovo di Haskell e Haskell golf, il feedback è apprezzato!

Spiegazione

Definiamo una funzione f n. Definiamo f nessere il primo elemento !!0dell'elenco:

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

Ripartito che è:

[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

Gelatina , 16 15 byte

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

Ciò presuppone A083569 (n) ≤ n² (la sequenza sembra crescere in modo lineare).

Provalo online!

Come funziona

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 byte

Grazie a @isaacg per avermi salvato due byte!

Tornato su questo sito, dopo essere stato impegnato per un po ', si spera che questo golf ulteriormente.

esmaYf&-TYP_+Th

Provalo online qui .

C # (.NET Core) , 169 byte

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;}}

Provalo online!

Di gran lunga il modo più inefficiente per calcolare i risultati, quindi si prega di astenersi dal calcolo f(n)per n>=30questo codice. Il primo passo è calcolare ricorsivamente i valori da f(1)a f(n-1)e quindi procedere al calcolo f(n)cercando il primo itale che n+isia primo e che inon sia nell'elenco dei valori precedenti.

x86-64 Assembly, 57 55 byte

Sono nuovo nel golf, quindi i commenti / feedback sono apprezzati.

Nota: questo è ottimizzato per la lunghezza del codice macchina, non per la lunghezza della sorgente.

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

Definisce una funzione, utilizzando la convenzione standard (ovvero valore restituito in eax, primo argomento in edi, tutti i registri salvati dal chiamante tranne ebx) che accetta un numero intero a 32 bit senza segno e restituisce il più piccolo m ecc.

Fonte:

    .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

Provalo online!

Clojure, 158 155 byte

#(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))))

Questo potrebbe avere ancora un po 'di grasso, non sono abbastanza soddisfatto, (+ 1 i j)ma questo è stato il modo più semplice per gestire il case base n = 1e il resto. ((set r)j)ritorna nilse jnon è nel set e (seq ())su un elenco vuoto restituisce anche zero. Calcola n = 1000in 48 secondi.

Aggiornamento: rimosso nildal =controllo poiché il codice funziona correttamente anche senza di esso.

Rubino , 62 + 8 = 70 byte

Usa la -rprimebandiera.

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

Provalo online!

Python, 194 170 110 byte

84 byte salvati da Leaky Nun

2 byte salvati da 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

Definisce una funzione s (n) che accetta un numero come input e restituisce A083569 (n).

Provalo online