Eine andere Sequenz, eine andere Herausforderung. *

Definition

Ein herausragendes pin dieser Sequenz ist, nennen wir es A, genau dann , wenn für jede Ziffer din p‚s Dezimalentwicklung, Sie ersetzen dmit dKopien dund die resultierende ganze Zahl ist noch prime; Nullen sind nicht erlaubt.

Zum Beispiel 11ist trivial in dieser Reihenfolge (es ist übrigens die erste Zahl). Als nächstes kommt in der Sequenz 31, weil 3331es auch Primzahl ist; dann ist 53da 55555333auch prime und so weiter.

Herausforderung

Bei einer Eingabe nreturn A(n), dh das nth Element in dieser Reihenfolge.

Beispiele

Hier sind die ersten 20 Begriffe, mit denen Sie beginnen können. Dies ist A057628 bei OEIS.

11, 31, 53, 131, 149, 223, 283, 311, 313, 331, 397, 463, 641, 691, 937, 941, 1439, 1511, 1741, 1871

Dieses Mittel A(0) = 11, A(1) = 31usw., bei der Verwendung von Null Indizierung.

Regeln

• Sie können null- oder einsbasierte Indizierung wählen. Bitte geben Sie in Ihrer Antwort an, welche.
• Anstatt nur das nth-Element zurückzugeben, können Sie auch die ersten nTerme zurückgeben.
• Sie können davon ausgehen, dass die Eingabe / Ausgabe nicht größer ist als das native Ganzzahlformat Ihrer Sprache. Die wiederholte Primzahl kann jedoch größer sein als das native Format Ihrer Sprache, sodass dies berücksichtigt werden muss.
• Zum Beispiel hat 1871die letzte Nummer der Beispiele eine entsprechende Primzahl von 18888888877777771, die ziemlich viel größer als die von Standard-INT32 ist.
• 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.
• Die Ausgabe kann an die Konsole erfolgen, von einer Funktion zurückgegeben, in einem Warnungs-Popup usw. angezeigt werden.
• Standardlücken sind verboten.
• Dies ist Codegolf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Byte) gewinnt.

* Um fair zu sein, ich hatte mir die ersten Begriffe der Sequenz ausgedacht und nur ein paar Zahlen ausprobiert und bin dann zu OEIS gegangen, um den Rest der Sequenz abzurufen.

Schale , 15 Bytes

!fo§&öεpd´ṘΠdİp

Probieren Sie es online!

!                 Index into
             İp     the list of primes
 f                    for which:
            d            the digits of p
  o§&                      satisfy both:
     öεpd´Ṙ                  repeated "themselves" times, they form a prime.
           Π                 they are all nonzero.

Erik der Outgolfer hat ein Byte gespeichert. Die Verwendung von ṗanstatt εpwürde ein weiteres Byte speichern, aber das macht das Programm so langsam, dass es unsere Gerade für n = 2 ergibt.

05AB1E , 14 13 Bytes

-1 Byte Danke an Emigna !

µNSÐPŠ×JpNpPĀ½

Probieren Sie es online!

Erläuterung

µNSÐPŠ×JpNpPĀ½
µ              # Do until the input is reached...
 N              # Push the iteration counter
  S             # Split it to its digits
   Ð            # And push two copies of it to the stack
    P           # Get the digital product of the counter
     Š          # And place it two places down the stack
      ×J        # Repeat each digit by itself and join it back to a number
        p       # Check for primality on that result
         Np     # And on the original counter as well
           PĀ   # Create the product and truthify the result
                # Implicit: If it is true increment the input number

Jelly , 18 bis 14 Bytes

ÆPaDxDḌÆPaDẠµ#

Probieren Sie es online!

Mr. Xcoder: -1 Byte (logisch alles)

Erik der Outgolfer: -2 Bytes (eine Zeile statt zwei)

HyperNeutrino: -1 Byte (erste n Elemente der Sequenz zurückgeben)

Erläuterung

ÆPaDxDḌÆPaDẠµ#     First Link
ÆP                Is prime?
  a               logical and
   D              convert number to list of digits
    xD            repeat each digit as many times as it's value
      Ḍ           convert to an integer
       ÆP         is prime?
         a        logical and
          D       list of digits
           Ạ      logical all
            µ     the following link as a monad
             #    Do this until n matches are found and return them all

Bearbeiten: Ursprünglich wurde eine Antwort gesendet, die Zahlen mit 0 in der Dezimaldarstellung enthielt, was ausdrücklich nicht zulässig ist.

Wolfram Language (Mathematica) , 100 Byte

Nest[#+1//.i_/;!PrimeQ@FromDigits[##&@@#~Table~#&/@(l=IntegerDigits@i)]||Min@l<1:>NextPrime@i&,1,#]&

Probieren Sie es online!

Jonathan Frech sparte 3 Bytes

und -7 Bytes von JungHwan min

-15 Bytes von Martin Ender

auch danke an Jenny Mathy

Alice , 72 70 66 62 56 Bytes

Danke an Leo für das Speichern von 5 Bytes.

/.\&wh...tz~F0/*$\W.tzt$W?K/ o
\i/&.,a:.$K;d&\FR/K.!w.a%

Probieren Sie es online!

Verwendet 1-basierte Eingabe.

Erläuterung

Der sauberste Golf - Trick (auch wenn es nur ein paar Bytes speichert) ist , dass ich einen Primzahltest bin mit der gibt 0für Composite - n für nfür Nicht-Verbund n . Auf diese Weise müssen wir das Ergebnis nicht direkt in einer Bedingung verwenden, sondern können es direkt an den nächsten Teil weitergeben, der prüft, ob die Eingabe keine Nullen enthält.

/i\       Read all input in Ordinal mode (the usual way to read decimal input).
&w        Push the current IP position onto the return address stack (RAS)
          n times. This effectively begins our main loop. We will return
          here after each number we've checked, but whenever we come across
          a repeated digit prime (RDP), we will pop one copy of the address
          from the RAS, so that the loops ends once we've found n RDPs.

h.        Increment our main loop iterator X (initially an implicit zero on
          the empty stack) and duplicate it.
.         Make another copy.
.tz       Drop all factors less than X. This gives X for prime X and 1 for
          non-prime X.
~F        Check whether X divides this value. Of course, X divides X so this
          gives X for non-composite X. But X doesn't divide 1 (unless X is 1),
          so we get 0 for composite X. Call this Y.
0         Push a 0.
\         Switch to Ordinal mode.
F         Implicitly convert both to string and check whether Y contains 0.
$/K       If it does, return to the w. Either way, switch back to Cardinal mode.
          Note that the only numbers that get to this point are 1 and prime
          numbers which don't contain 0. It's fine that we let 1 through here,
          because we'll use a proper primality test for the digit-expanded
          version later on.
.!        Store a copy of X on the tape. Let's call the copy that remains on
          the stack Z, which we're now decomposing into digits while expanding
          them.
w         Push the current IP position to the RAS. This marks the beginning
          of an inner loop over the digits of Z.

  .a%       Duplicate Z and retrieve its last digit D by taking Z % 10.
  \./       Duplicate D (in Ordinal mode but that doesn't matter).
  &.        Duplicate D, D times. So we end up with D+1 copies of D.
  ,         Pop the top D and pull up the Dth stack element, which is Z.
  a:        Discard the last digit by taking Z / 10.
  .$K       If Z is zero now, skip the K and end the inner loop, otherwise
            repeat the inner loop.
;         Discard the 0 (what used to be Z).
          We now have D copies of each digit D on the stack, but the digits
          were processed in reverse order, so the last digit is at the bottom.
d&        Repeat the next command once for each stack element.
\*        Concatenate in Ordinal mode. This joins all the digits on the
          stack into a single string.
R         Reverse that string. This is the digit-expanded version of X.
/         Switch back to Cardinal mode.
W         Pop the inner loop's return address from the RAS. We could have done
          this right after the most recent K, but putting it here helps lining
          up the two Ordinal sections in the program layout.
.tzt      Is the digit-expanded number a prime?
$W        If so, we've found an RDP. Pop one copy of the main loop address 
          from the RAS.
g         Recover the current value of X from the top left grid cell.
K         Jump back to the w if any copies of the return address are left 
          on the RAS. Otherwise, we leave the main loop.
/o        Implicitly convert the result to a string and print it in
          Ordinal mode.
          The IP will then bounce off the top right corner and start
          travelling through the program in reverse. Whatever it does
          on the way back is utter nonsense, but it will eventually get
          back to the division (:). The top of the stack will be zero
          at that point and therefore the division terminates the program.

Python 2 , 130 Bytes

• Vielen Dank an ArBo für diese vier Byte kürzere Lösung.

f=lambda n,c=9:n and f(n-(('0'in`c`)<p(c)*p(int("".join(d*int(d)for d in`c`)))),c+1)or~-c
p=lambda n:all(n%m for m in xrange(2,n))

Probieren Sie es online!

Python 2 , 195 179 167 140 138 136 135 134 Bytes

• 27 Bytes dank ovs gespart ; Verwenden xrangestatt range, umgeht damit a MemoryErrorund verdichtet die Primfunktion; Verbesserung der Ganzzahlenzählung.
• Zwei Bytes gespeichert; Verwenden von binären Pipes oder Operationen |zum Speichern von Bytes or.
• Zwei Bytes gespeichert; Umkehren der Primzahlfunktion und weitere logische Manipulation.
• Ein Byte gespeichert; Verwenden von ~-anstelle von 0**zum Invertieren der Existenz einer Null in j, &gefolgt von einem echten Booleschen Wert, um die Boolesche Eigenschaft dieses Werts zu isolieren.
• Sparte ein Byte dank Lynn ; Golfen ~-A&B&C(gleichbedeutend mit (not A) and B and C) mit A, B, CBooleschen sein A<B==C.

def f(n,j=9,p=lambda n:all(n%j for j in xrange(2,n))):
 while n:j+=1;n-=("0"in`j`)<p(j)==p(int("".join(d*int(d)for d in`j`)))
 print j

Probieren Sie es online! (1-indiziert)

Erläuterung

Definiert eine Hauptfunktion, fdie einen ganzzahligen Index nund einen voreingestellten Wert annimmt j, die aktuelle Sequenz ( 9zur Verbesserung der Leistung bei gleichzeitiger Beibehaltung der Programmgröße) und eine Hauptprüffunktion .
Solange nnicht Null ist, wurde der n-te Sequenzeintrag noch nicht gefunden. Somit jwird inkrementiert und num eins dekrementiert, wenn f jeine Zahl ist, die die erforderlichen Eigenschaften erfüllt.
Wenn die Schleife endet, jwird der n-te Sequenzeintrag und damit gedruckt.

Pyth , 21 Bytes

.f&.AKjZT&P_ss*VK`ZP_

Probieren Sie es hier aus!

Vielmehr lange wie Pyth kein hat Dezimalentwicklung eingebaut.

• Nehmen Sie die ersten N positiven ganzen Zahlen ( .f), die:
  • Habe alle Ziffern wahrheitsgemäß ( .AKjZT) und ( &) ...
  • Die vektorisierte Multiplikation ihrer Zeichenfolgendarstellung mit ihren *VK`Zzusammengefügten und in eine Ganzzahl ( ss) konvertierten Ziffern ( ) sind prime ( P_) und ( &) ...
  • Das sind die Primzahlen selbst ( P_).

Perl 6 , 51 Bytes

{(grep {!/0/&is-prime $_&S:g/./{$/x$/}/},2..*)[$_]}

Probieren Sie es online!

• grep {...}, 2..*Filtert die unendliche Folge natürlicher Zahlen ab 2 mithilfe der Prädikatfunktion zwischen den geschweiften Klammern. (...)[$_]Indexiert mit dem Argument der Funktion in diese gefilterte Liste $_.
• !/0/ filtert Zahlen heraus, die eine Null enthalten.
• S:g/./{$/ x $/}/ repliziert jede Ziffer in der Dezimalerweiterung der Testnummer.
• is-prime $_ & S:g/./{$/ x $/}/ ruft die eingebauten is-prime Funktion mit einem und einer Verknüpfung von $_, der Testnummer und der Nummer auf, die sich aus der Replikation ihrer Ziffern ergibt. Die Funktion gibt true zurück, wenn beide Member von and-junction Primzahlen sind.

J, 81 Bytes

f=.[:1&p:(*@(*/)*x:@#~)&.(10&#.inv)
[:{.(4&p:@{.@]([,]+f@[){:@])^:([>{:@])^:_&2 0

Das ist eine dieser Situationen, für die ich noch keine gute J-Lösung gefunden habe.

Trotzdem poste ich dies in der Hoffnung, etwas Neues zu lernen.

fsagt uns, ob eine gegebene Zahl eine "wiederholte Ziffern-Primzahl" ist. Es setzt sich wie folgt zusammen:

[:1&p:                               is the following a prime?
      (*@                            the signum of...
         (*/)                        the product of the digits
             *                       times...
              x:@                    force extended precision of...
                 #~)                 self-duplicated digits
                    &.               "Under": perform this, then perform its inverse at the end
                      (10&#.inv)     convert to a list of digits

Und schließlich das Haupt-Do ... While-Verb mit seinem lästigen, scheinbar unvermeidbaren Boilerplate, das sich aus der Tatsache ergibt, dass wir eine Liste zum Speichern unseres Fortschritts verwenden müssen, für die sowohl "aktuelle Primzahlen" als auch "bisher gefundene" Register erforderlich sind , da unser linkes Argument bereits verwendet wird, um die Stoppbedingung zu speichern, dh n. Dies bedeutet, dass wir für die einfache Aufgabe, args ( [und ]) anzugeben und unsere 2-Element-Liste ( {.und {:) zu entpacken, viele wertvolle Bytes verwenden müssen :

[:{.                                                take the first element of the final result, of the following Do... While:
    (4&p:@                                          the next prime after...
          {.@                                       the first element of...
             ]                                      the right arg 
                       {:@])                        the last (2nd) elm of the arg...
              ([,]+f@[)                             those two now become the left and right args to this verb...
               [,                                   left arg appended to...
                 ]+                                 right arg plus...
                   f@[                              f of the left arg...
                             ^:(      )^:_          keep doing all that while...
                                [>                  the left is bigger than...
                                  {:@]              the last elm of the right arg
                                          &2 0      seed the process with 2 0, ie,
                                                    the first prime, and 0 rdps found so far.

Probieren Sie es online!