Die Sequenz

Jeder weiß, dass die einzige gerade Primzahl ist 2. Ho-hum. Aber es gibt bestimmte gerade Zahlen n, bei denen sie, wenn sie miteinander verknüpft werden n-1, zu einer Primzahl werden.

Für den Anfang 1ist nicht in der Liste, weil 10nicht Primzahl. Ähnlich mit 2( 21) und 3( 32). Funktioniert jedoch, 4weil 43es sich um eine Primzahl handelt, sodass es die erste Zahl in der Sequenz ist a(1) = 4. Die nächste Zahl, die funktioniert (weder 6( 65) noch 8( 87)), ist 10, weil 109es Primzahl ist, so a(2) = 10. Dann überspringen wir einen Haufen mehr, bis 22, weil 2221es das Beste ist, also a(3) = 22. Und so weiter.

Offensichtlich sind alle Ausdrücke in dieser Sequenz gerade, weil jede ungerade Zahl, nwenn sie mit verknüpft n-1wird, gerade wird (wie 3sich in verwandelt 32), was niemals eine Primzahl sein wird.

Dies ist die Sequenz A054211 in OEIS.

Die Herausforderung

Wenn Sie eine Eingabenummer haben n, die irgendwo in diese Sequenz passt (dh nmit einer n-1Primzahl verkettet ist), geben Sie ihre Position in dieser Sequenz aus. Sie können zwischen 0- und 1-indiziert wählen. Bitte geben Sie in Ihrem Beitrag an, welche.

Regeln

• Es kann davon ausgegangen werden, dass die Eingabe und Ausgabe in den systemeigenen Ganzzahltyp Ihrer Sprache passen.
• Die Ein- und Ausgabe kann in jedem beliebigen Format erfolgen .
• Es ist entweder ein vollständiges Programm oder eine Funktion zulässig. Bei einer Funktion können Sie die Ausgabe zurückgeben, anstatt sie zu drucken.
• Fügen Sie nach Möglichkeit einen Link zu einer Online-Testumgebung hinzu, damit andere Benutzer Ihren Code ausprobieren können!
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

Beispiele

Die folgenden Beispiele sind 1-indiziert.

n = 4
1

n = 100
11

n = 420
51

Gelee ,  8  7 Bytes

ḊżṖVÆPS

Ein monadischer Link, der ein Sequenzmitglied aufnimmt und dessen Index in der Sequenz zurückgibt.

Probieren Sie es online!

Wie?

ḊżṖVÆPS - Link: number, n
Ḋ       - dequeue (implicit range) = [ 2   , 3   , 4   ,... ,              n         ]
  Ṗ     - pop (implicit range)     = [   1 ,   2 ,   3 ,... ,                  n-1   ]
 ż      - zip                      = [[2,1],[3,2],[4,3],... ,             [n , n-1]  ]
   V    - evaluate as Jelly code   = [ 21  , 32  , 43  ,... ,         int("n"+"n-1") ]
    ÆP  - is prime? (vectorises)   = [  0  ,  0  ,  1  ,... , isPrime(int("n"+"n-1"))]
      S - sum

Haskell , 80 75 70 Bytes

5 Bytes sparen dank Laikoni

p x=all((>0).mod x)[2..x-1]
g n=sum[1|x<-[4..n],p$read$show=<<[x,x-1]]

Probieren Sie es online!

Jelly , 12, 10 , 8 Bytes

;’VÆPµ€S

Probieren Sie es online!

Dank @ nmjmcman101 werden 1-2 Bytes und dank @Dennis 2 Bytes gespart!

Erläuterung:

     µ€   # For N in range(input()):
;         #   Concatenate N with...
 ’        #   N-1
  V       #   And convert that back into an integer
   ÆP     #   Is this number prime?
       S  # Sum that list 

05AB1E , 9 8 7 Bytes

Code

ƒNN<«pO

Verwendet die 05AB1E- Codierung. Probieren Sie es online!

Erläuterung

ƒ          # For N in [0 .. input]..
 NN<«      #   Push n and n-1 concatenated
     p     #   Check for primality
      O    #   Sum the entire stack (which is the number of successes)

Schale , 13 11 10 Bytes

1indizierte Lösung:

#ȯṗdS¤+d←ḣ

Probieren Sie es online!

Ungolfed / Erklärung

         ḣ -- in the range [1..N]
#          -- count the number where the following predicate is true
        ←  --   decrement number,
    S  d   --   create lists of digits of number and decremented 
     ¤+    --   concatenate,
   d       --   interpret it as number and
 ȯṗ        --   check if it's a prime number

Danke @Zgarb für die -3Bytes!

Python 2 , 87 Bytes

-2 Bytes dank @officialaimm . 1-indiziert.

lambda n:sum(all(z%v for v in range(2,z))for i in range(4,n+1)for z in[int(`i`+`i-1`)])

Test Suite.

Pyth , 12 Bytes

smP_s+`d`tdS

Probieren Sie es online! oder Überprüfen Sie alle Testfälle.

Wie?

smP_s+`d`tdSQ  -> Full Program. Takes input from Standard Input. Q means evaluated input
                  and is implicit at the end.

 m         SQ  -> Map over the Inclusive Range: [1...Q], with the current value d.
    s+`d`td    -> Concatenate: d, the current item and: td, the current item decremented. 
                  Convert to int.
  P_           -> Prime?
s              -> Sum, counts the occurrences of True.

Japt , 15 14 12 11 9 8 Bytes

1-indiziert.

ÇsiZÄÃèj

Versuch es

Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes

Röda , 73 Bytes

{seq 3,_|slide 2|parseInteger`$_2$_1`|{|i|[1]if seq 2,i-1|[i%_!=0]}_|sum}

Probieren Sie es online!

1-indiziert. Es verwendet den Stream für die Ein- und Ausgabe.

Erläuterung:

{
seq 3,_| /* Create a stream of numbers from 3 to input */
slide 2| /* Duplicate every number except the first and the last
            to create (n-1,n) pairs */
parseInteger`$_2$_1`| /* Concatenate n and n-1 and convert to integer */
{|i| /* For every i in the stream: */
    [1]if seq 2,i-1|[i%_!=0] /* Push 1 if i is a prime
                                (not divisible by smaller numbers) */
}_|
sum /* Return the sum of numbers in the stream */
}

Pyth , 14 Bytes

lfP_Tms+`d`tdS

Probieren Sie es online!

Erläuterung

              Q    # Implicit input
             S     # 1-indexed range
     m             # For d in range [1, Q]...
      s+`d`td      # Concatenate d and d - 1
 fP_T              # Filter on primes
l                  # Return the length of the list

Perl 6 , 45 Bytes

{first :k,$_,grep {is-prime $_~.pred},1..∞}

Probieren Sie es online!

Das grepergibt die Reihenfolge der qualifizierenden Zahlen, dann suchen wir den Schlüssel ( :k) (dh den Index) der firstZahl in der Liste, die dem Eingabeparameter entspricht $_.

C 99 94 Bytes

1 indiziert. Es schmerzt mich, Primalitätstests zu schreiben, die so rechenintensiv sind, aber Bytes sind immerhin Bytes.

Wenn wir einige wirklich spröde Sachen zulassen, funktioniert das Kompilieren auf meinem Computer ohne Optimierungen mit GCC 7.1.1 mit den folgenden 94 Bytes (danke @Conor O'Brien )

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

Ansonsten erledigen diese viel robusteren 99 Bytes die Arbeit

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}return c;}

Volles Programm, etwas besser lesbar:

i,c,m,k;
f(n){
    c=i=1;
    for(;++i<n;c+=m==k){
        for(k=m=1;m*=10,m<i;);
        for(m=i*m+i-1;++k<m&&m%k;);
    }
    return c;
}

int main(int argc, char *argv[])
{
    printf("%d\n", f(atoi(argv[1])));
    return 0;
}

JavaScript (ES6),  49 48  47 Bytes

1-indiziert. Begrenzt durch die Call-Stack-Größe Ihrer Engine.

f=n=>n&&f(n-2)+(p=n=>n%--x?p(n):x<2)(x=n+[--n])

Probieren Sie es online!

Mathematica, 77 Bytes

Position[Select[Range@#,PrimeQ@FromDigits[Join@@IntegerDigits/@{#,#-1}]&],#]&

QBIC , 25 Bytes

[:|p=p-µa*z^_l!a$|+a-1}?p

Erläuterung

[:|     FOR a = 1 to <n>
p=p-    Decrement p (the counter) by
µ       -1 if the following is prime, or 0 if not
        For the concatenating, we multiply 'a' by 10^LENGTH(a), then add a-1$┘p
        Example 8, len(8) = 1, 8*10^1 = 80, add 8-1=7, isPrime(87) = 0
a*z^_l!a$|+a-1
}       Close the FOR loop - this also terminates the prime-test
?p      Print p, the 0-based index in the sequence.

Dies verwendet ein ziemlich kompliziertes mathematisches Ding mit einem Cast-to-String, auf den man für ein gutes Maß geschlagen hat. Wenn eine Version erstellt wird, erfolgt die Verkettung ausschließlich auf Zeichenfolgenbasis und ist ein Byte länger:

[:|A=!a$+!a-1$┘p=p-µ!A!}?p

PHP , 203 Bytes

<?php $n=($a=$argv[1]).($a-1);$p=[2];$r=0;for($b=2;$b<=$n;$b++){$x=0;if(!in_array($b,$p)){foreach($p as $v)if(!($x=$b%$v))break;if($x)$p[]=$b;}}for($b=1;$b<=$a;$b++)if(in_array($b.($b-1),$p))$r++;die $r;

Probieren Sie es online!

Verwendet einen 1-basierten Index für die Ausgabe. TIO Link enthält die lesbare Version des Codes.

Ruby , 42 + 9 = 51 Bytes

Verwendet die -rprime -nFahnen. 1-indiziert.

Zählt alle Zahlen, die der Eingabe entsprechen oder darunter liegen und die die Bedingung erfüllen (oder, technisch gesehen, alle Zahlen, die die n-1Bedingung erfüllen ). Da die Eingabe garantiert in der Reihenfolge ist, besteht kein Fehlerrisiko, wenn eine solche zufällige Eingabe 7nicht "primiert" wird.

p (?3..$_).count{|i|eval(i.next+i).prime?}

Probieren Sie es online!

Ruby , 62 Bytes

->g{(1..g).count{|r|(2...x=eval([r,r-1]*'')).none?{|w|x%w<1}}}

Probieren Sie es online!

1-indiziert

Python 2 , 85 Bytes

1-indiziert

lambda n:sum(all(z%v for v in range(2,z))for i in range(3,n)for z in[int(`i+1`+`i`)])

Prüfung

Verbesserung der Antwort von Mr. Xcoder

Java 8, 108 Bytes

n->{for(long r=0,q=1,z,i;;){for(z=new Long(q+""+~-q++),i=2;i<z;z=z%i++<1?0:z);if(z>1)r++;if(q==n)return r;}}

0-indiziert

Erläuterung:

Probieren Sie es online aus.

n->{                             // Method with integer parameter and long return-type
  for(long r=0,                  //  Result-long, starting at 0
      q=1,                       //  Loop integer, starting at 1
      z,i;                       //  Temp integers
      ;){                        //  Loop indefinitely
    for(z=new Long(q+""+~-q++),  //   Set z to `q` concatted with `q-1`
        i=2;i<z;z=z%i++<1?0:z);  //   Determine if `z` is a prime,
      if(z>1)                    //   and if it indeed is:
        r++;                     //    Increase the result-long by 1
      if(q==n)                   //   If `q` is now equal to the input integer
        return r;}}              //    Return the result

Stax , 10 Bytes

1- Indiziert

Äm▬á┌╕|°φ♦

Ausführen und Debuggen es Erklärung

Rxr\{$e|pm|+         #Full program, unpacked, implicit input  (Example (4))
R                    #Create [1 to input] range  (ex [1,2,3,4] )             
 x                   #Copy value from x register (ex (4) )
  r                  #Create [0 to input-1] range (ex [0,1,2,3)
   \                 #Create array pair using the range arrays (ex [[1,0],[2,1],[3,2],[4,3]])
    {    m           #Map block
     $e|p            #To string, eval string (toNum), isPrime (ex [1,0] => "10" => 10 => 0)
          |+         #Sum the array to calculate number of truths (ex [0,0,0,1] => 1)

Ordentlich , 33 Bytes

index({n:prime(n.n-1|int)}from N)

Probieren Sie es online!

Erläuterung

Die Grundidee ist, eine Folge der gültigen Zahlen zu erstellen und dann eine Curry-Indexfunktion zurückzugeben.

index({n:prime(n.n-1|int)}from N)
      {n:                }from       select all numbers `n` from...
                               N     the set of natural numbers, such that:
               n.n-1                     `n` concatenated with `n-1`
                    |int                 ...converted to an integer
         prime(         )                ...is prime
index(                          )    function that returns index of input in that sequence