Definieren Sie eine 1-indizierte Sequenz wie folgt:

• A083569(1) = 1
• A083569(n)wobei neine ganze Zahl größer ist als 1, ist die kleinste ganze Zahl m, die nicht früher auftritt, so dass m+nes sich um eine Primzahl handelt.

Ihre Aufgabe ist es, aufzunehmen nund zurückzukehren 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

Weitere Testfälle finden Sie hier . Die Originalsequenz zu OEIS finden Sie hier .

Das ist Code-Golf . Kürzeste Antwort in Bytes gewinnt. Es gelten Standardlücken .

Haskell , 87 86 83 80 74 69 Bytes

Vielen Dank an xnor für die Vorschläge zu Änderungen, mit denen 3 Byte eingespart wurden!

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

Probieren Sie es online!

Ich bin neu in Haskell und Haskell Golf, Feedback wird geschätzt!

Erläuterung

Wir definieren eine Funktion f n. Wir definieren f nals erstes Element !!0der Liste:

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

Aufgeschlüsselt ist das:

[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

Jelly , 16-15 Bytes

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

Dies setzt A083569 (n) ≤ n² voraus (die Sequenz scheint linear zu wachsen).

Probieren Sie es online!

Wie es funktioniert

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

Vielen Dank an @isaacg, dass du mir zwei Bytes gespart hast!

Zurück auf dieser Seite, nach einer Weile beschäftigt, wird hoffentlich dieses weiter Golf spielen.

esmaYf&-TYP_+Th

Probieren Sie es hier online aus .

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

Probieren Sie es online!

Bei weitem die meisten ineffizienter Weg , um die Ergebnisse zu berechnen, bitte so Refrain aus der Berechnung f(n)für n>=30mit diesem Code. Der erste Schritt ist , um rekursiv die Werte zu berechnen , die von f(1)zu f(n-1)und dann zu berechnen , geht f(n)durch die ersten Benutzer , iso dass eine n+iPrimzahl ist , und iist nicht auf der vorherige Werte - Liste.

x86-64-Assembly, 57-55 Byte

Ich bin neu im Golfsport, daher sind Kommentare / Rückmeldungen erwünscht.

Hinweis: Dies ist für die Länge des Maschinencodes optimiert, nicht für die Länge der Quelle.

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

Definiert eine Funktion unter Verwendung der Standardkonvention (dh Rückgabewert in eax, erstes Argument in edi, alle vom Aufrufer gespeicherten Register außer ebx), die eine vorzeichenlose 32-Bit-Ganzzahl verwendet und das kleinste m usw. zurückgibt.

Quelle:

    .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

Probieren Sie es online!

Clojure, 158 155 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))))

Dies könnte noch etwas Fett haben, mit dem ich nicht ganz zufrieden bin, (+ 1 i j)aber dies war der einfachste Weg, mit dem Basisfall n = 1und dem Rest umzugehen. ((set r)j)Gibt zurück, nilwenn jes sich nicht in der Menge befindet, und (seq ())in einer leeren Liste gibt es auch null zurück. Berechnet n = 1000in 48 Sekunden.

Update: entfernt nilvon =Kontrolle , da der Code korrekt auch ohne es funktioniert.

Ruby , 62 + 8 = 70 Bytes

Verwendet die -rprimeFlagge.

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

Probieren Sie es online!

Python, 194 170 110 Bytes

84 Bytes von Leaky Nun gespeichert

2 Bytes von Mathmandan gespeichert

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

Definiert eine Funktion s (n), die eine Zahl als Eingabe annimmt und A083569 (n) zurückgibt.

Probieren Sie es online