Ein Emirp ist eine nicht-palindrome Primzahl, die umgekehrt auch eine Primzahl ist.

Die Liste der Basis-10-Emirps finden Sie auf OEIS . Die ersten sechs sind:

13, 17, 31, 37, 71, 73

Aufgrund der Umkehrregel unterscheiden sich die Emirps jedoch in jeder Basis. Zum Beispiel sind die ersten sechs binären Emirps:

Bin  | 1011, 1101, 10111, 11101, 101001, 100101
Dec  | (11 , 13  , 23   , 29   , 37    , 41   ) 

... und hexadezimal sind dies:

Hex |  17, 1F, 35, 3B, 3D, 53
Dec | (23, 31, 53, 59, 61, 83)

_{Fun Fact: Es gibt keine emirps in einstelligen als jede Zahl ein Palindrom ist.}

Die Herausforderung

Ihre Aufgabe ist es, eine Funktion (oder ein vollständiges Programm) zu erstellen, die die beiden Parameter $n$ und $b$ und eine Liste der ersten $n$ Emirps in der Basis $b$ .

Regeln / Details:

• $n$ und$b$ sind beide positive ganze Zahlen größer als$0$ .
• Sie können $2 ≤ b ≤ 16$ annehmen , dh die Basis liegt zwischen binär und hexadezimal.
• Sie sollten in der Lage sein, für Werte von $n$ bis zu 100 zu berechnen .$~100$
• Die generierte Liste kann sich in der Basis $b$ oder in der Standard-Ganzzahlbasis Ihrer Sprache befinden, sofern Sie dies in Ihrer Antwort angeben.
• Eingebaute Emirp-Prüfungen sind nicht zulässig (eingebaute Primalitätstests sind in Ordnung).
• Sie können die Emirps nicht fest codieren oder aus externen Dateien lesen.
• Standardlücken sind wie immer verboten.
• Das ist Code-Golf , also gewinnt die kürzeste Antwort (in Bytes).

Testfälle

Für jeden Testfall habe ich die Liste in base bund ihre 10-Äquivalente aufgenommen.

B = 2, N = 10

BIN: [1011, 1101, 10111, 11101, 100101, 101001, 101011, 101111, 110101, 111101]
DEC: [11, 13, 23, 29, 37, 41, 43, 47, 53, 61] 


B = 3, N = 5

BASE3: [12, 21, 102, 201, 1011]
DEC:   [5, 7, 11, 19, 31]


B = 12, N = 7

BASE12: [15, 51, 57, 5B, 75, B5, 107]
DEC: [17, 61, 67, 71, 89, 137, 151]


B = 16, N = 4

HEX: [17, 1F, 35, 3B]
DEC: [23, 31, 53, 59] 

Sie können Ihr Programm weiter mit meinem (ungolfed) Python-Beispiel auf repl.it testen

Gelee , 16 Bytes

bµU,ḅ⁹QÆPḄ=3
⁸ç#

TryItOnline!

Wie?

bµU,ḅ⁹QÆPḄ=3 - Link 1, in-sequence test: n, b
b            - convert n to base b - a list
 µ           - monadic chain separation
  U          - reverse the list
   ,         - pair with the list
     ⁹       - link's right argument, b
    ḅ        - convert each of the two lists from base b
      Q      - get unique values (if palindromic a list of only one item)
       ÆP    - test if prime(s) - 1 if prime, 0 if not
         Ḅ   - convert to binary
          =3 - equal to 3? (i.e. [reverse is prime, forward is prime]=[1,1])

⁸ç# - Main link: b, N
  # - count up from b *see note, and find the first N matches (n=b, n=b+1, ...) for:
 ç  - last link (1) as a dyad with left argument n and right argument
⁸   - left argument, b

* Anmerkung bin der Basis bist [1,0], was, wenn umgekehrt, [0,1]was ist 1, was nicht Primzahl ist; alles andere als beine Ziffer in der Basis bund damit palindromisch.

05AB1E , 17 Bytes

Verwendet die CP-1252- Codierung.

Die Eingabereihenfolge ist Die n, b
Ausgabe erfolgt zur Basis 10.

µN²BÂD²öpŠÊNpPD–½

Probieren Sie es online!

Erläuterung

                    # implicit input a,b
µ                   # loop until counter is a
 N²B                # convert current iteration number to base b
    ÂD              # create 2 reversed copies
      ²ö            # convert one reversed copy to base 10
        p           # check for primality
         ŠÊ         # compare the normal and reversed number in base b for inequality
           Np       # check current iteration number for primality
             P      # product of all
              D     # duplicate
               –    # if 1, print current iteration number
                ½   # if 1, increase counter

Mathematica, 70 Bytes

Cases[Prime@Range@437,p_/;(r=p~IntegerReverse~#2)!=p&&PrimeQ@r]~Take~#&

Funktioniert für 0 <= n <= 100und 2 <= b <= 16. Aus der Liste Prime@Range@437der ersten 437Primzahlen, finden die , Cases pwo die IntegerReverse rvon pin der Basis #2nicht gleich pund ist auch prime, dann die ersten nehmen #solche p.

Hier ist eine 95-Byte-Lösung, die für beliebige n>=0und funktioniert b>=2:

(For[i=1;a={},Length@a<#,If[(r=IntegerReverse[p=Prime@i,#2])!=p&&PrimeQ@r,a~AppendTo~p],i++];a)&

Perl, 262 Bytes

($b,$n)=@ARGV;$,=',';sub c{my$z;for($_=pop;$_;$z=(0..9,a..z)[$_%$b].$z,$_=($_-$_%$b)/$b){};$z}sub d{my$z;for(;c(++$z)ne@_[0];){}$z}for($p=2;@a<$n;$p++){$r=qr/^1?$|^(11+?)\1+$/;(c($p)eq reverse c$p)||((1x$p)=~$r)||(1x d($x=reverse c($p)))=~$r?1:push@a,c($p);}say@a

Lesbar:

($b,$n)=@ARGV;
$,=',';
sub c{
    my$z;
    for($_=pop;$_;$z=(0..9,a..z)[$_%$b].$z,$_=($_-$_%$b)/$b){};
    $z
}
sub d{
    my$z;
    for(;c(++$z)ne@_[0];){}
    $z
}
for($p=2;@a<$n;$p++){
    $r=qr/^1?$|^(11+?)\1+$/;
    (c($p)eq reverse c$p)||((1x$p)=~$r)||(1x d($x=reverse c($p)))=~$r?1:push@a,c($p)
}
say@a

c wandelt eine gegebene Zahl in eine Basis um $b und dkonvertiert eine gegebene Zahl von einer Basis $bzurück in eine Dezimalzahl, indem die erste Zahl ermittelt wird, die die Basiszahl zurückgibt, $bwenn sie an übergeben wird c. Die for-Schleife prüft dann, ob es sich um ein Palindrom handelt und ob beide Zahlen mit dem zusammengesetzten regulären Ausdruck Primzahlen sind.

Mathematica 112 Bytes

Cases[Table[Prime@n~IntegerDigits~#2,{n,500}],x_/;x!=(z=Reverse@x)&&PrimeQ[z~(f=FromDigits)~#2]:>x~f~#2]~Take~#&

Beispiel

Finde die ersten 10 Emips in hex; Gib sie dezimal zurück.

Cases[Table[Prime@n~IntegerDigits~#2, {n, 500}], 
x_ /; x != (z = Reverse@x) && PrimeQ[z~(f = FromDigits)~#2] :> x~f~#2]~Take~# &[10, 16]


{23, 31, 53, 59, 61, 83, 89, 113, 149, 179}

Ungolfed

Take[Cases[                                             (* take #1 cases; #1 is the first input argument *)
   Table[IntegerDigits[Prime[n], #2], {n, 500}],        (* from a list of the first 500 primes, each displayed as a list of digits in base #2 [second argument] *) 
   x_ /;                                                (* x, a list of digits, such that *)
   x != (z = Reverse[x]) && PrimeQ[FromDigits[z, #2]]   (* the reverse of the digits is not the same as the list of digits; and the reverse list, when composed, also constitutes a prime *)
   :> FromDigits[x, #2]],                               (* and return the prime *)
   #1] &                                                (* [this is where #1 goes, stating how many cases to Take] *)

Perl 6 , 91 Bytes

->\n,\b{(grep {.is-prime&&{$_ ne.flip &&.parse-base(b).is-prime}(.base(b).flip)},1..*)[^n]}

Gibt die Liste der Emirps in Basis 10 zurück.

Python 3 , 232 214 191 188 Bytes

• Herman L -14 Bytes
• Jo King -3 Bytes

p=lambda n:all(n%i for i in range(2,n))
def f(b,n):
 s=lambda n:(''if n<b else s(n//b))+f'{n%b:X}';l=[];i=3
 while n:i+=1;c=s(i);d=c[::-1];a=(c!=d)*p(i)*p(int(d,b));l+=[c]*a;n-=a
 return l

Probieren Sie es online!

C 293 286 261 Bytes

Verbessert um @ceilingcat , 261 Bytes:

v,t,i,j,c,g,s[9],r[9],b;main(n,a)int**a;{for(b=n=atoi(a[1]);g^atoi(a[2]);t|v|!wcscmp(s,r)||printf("%u ",n,++g)){i=j=0;for(c=++n;s[i]=c;c/=b)s[i++]=c%b+1;for(;r[j]=i;)r[j++]=s[--i];p(n);for(t=v;r[i];)c+=~-r[i]*pow(b,i++);p(c);}}p(n){for(j=1,v=0;++j<n;n%j||v++);}

Probieren Sie es online!

(Diese Person verfolgt mich ständig durch PPCG und verbessert meine Inhalte in den Kommentaren. Sobald ich ihm danke, löscht er den Kommentar und verschwindet lol. Welp, nochmals danke!)

Verbessert von @movatica , 286 Bytes:

u,v,t,i,j,c,n,g;main(int x,char**a){char s[9],r[9],b=n=atoi(a[1]);x=atoi(a[2]);for(;g^x;){i=j=0;for(c=++n;c;c/=b)s[i++]=c%b+1;s[i]=c=0;for(;i;r[j++]=s[--i]);r[j]=0;p(n);t=v;for(;r[i];)c+=(r[i]-1)*pow(b,i++);p(c);t|v|!strcmp(s,r)?:printf("%u ",n,++g);}}p(n){for(u=1,v=0;++u<n;n%u?:v++);}

Probieren Sie es online!

Meine ursprüngliche Antwort, 293 Bytes:

u,v,t,i,j,c,n,g;main(int x,char**a){char s[9],r[9],b=n=atoi(a[1]);x=atoi(a[2]);for(++n;g^x;++n){i=j=0;for(c=n;c;c/=b)s[i++]=c%b+1;s[i]=c=0;for(;i;r[j++]=s[--i]);r[j]=0;p(n);t=v;for(--i;r[++i];)c+=(r[i]-1)*pow(b,i);p(c);t|v|!strcmp(s,r)?:printf("%u ",n,++g);}}p(n){for(u=1,v=0;++u<n;n%u?:v++);}

Kompiliere mit gcc emirp.c -o emirp -lmund starte mit ./emirp <b> <n>. Gibt durch Leerzeichen getrennte Emirps in Basis 10 aus.

JavaScript (ES6), 149 148 141 140 Byte

Gibt eine durch Leerzeichen getrennte Liste von Emirps in der Basis b zurück. (Könnte 2 Bytes kürzer sein, wenn stattdessen eine Dezimalliste zurückgegeben wird.)

f=(b,n,i=2)=>n?((p=(n,k=n)=>--k<2?k:n%k&&p(n,k))(i)&p(k=parseInt([...j=i.toString(b)].reverse().join``,b))&&k-i&&n--?j+' ':'')+f(b,n,i+1):''

Testfälle

f=(b,n,i=2)=>n?((p=(n,k=n)=>--k<2?k:n%k&&p(n,k))(i)&p(k=parseInt([...j=i.toString(b)].reverse().join``,b))&&k-i&&n--?j+' ':'')+f(b,n,i+1):''

console.log(f(2,10));
console.log(f(3,5));
console.log(f(12,7));
console.log(f(16,4));

Python 2 , 133 Bytes

p=lambda n:all(n%i for i in range(2,n))
b,n=input()
i=b
while n:
 j=i=i+1;r=0
 while j:r=r*b+j%b;j/=b
 if(i-r)*p(i)*p(r):print i;n-=1

Probieren Sie es online!

Gibt jede Zahl in einer neuen Zeile in Basis 10 aus

APL (NARS), 87 Zeichen, 174 Byte

r←a f w;i
i←1⋄r←⍬
→2×⍳∼{∼0π⍵:0⋄k≡v←⌽k←{(a⍴⍨⌊1+a⍟⍵)⊤⍵}⍵:0⋄0πa⊥v:1⋄0}i+←1⋄r←r,i⋄→2×⍳w>≢r

Das Ergebnis wird in Base 10 angezeigt. Test und Ergebnisse:

  3 f 1
5 
  2 f 10
11 13 23 29 37 41 43 47 53 61 
  3 f 5
5 7 11 19 31 
  12 f 7
17 61 67 71 89 137 151 
  16 f 4
23 31 53 59 

{(⍺⍴⍨⌊1+⍺⍟⍵)⊤⍵}würde die Umwandlung von ⍵in base ⍺, array integer result durchführen; 0π⍵würde true [1] zurückgeben, wenn ⍵prime else ist, würde 0 zurückgegeben.