Une émirpe est un nombre premier non palindromique qui, une fois inversé, est également un nombre premier.

La liste des émirps de base 10 se trouve sur OEIS . Les six premiers sont:

13, 17, 31, 37, 71, 73

Cependant, en raison de la règle d'inversion, les émirps sont différents dans chaque base. Par exemple, les six premiers émirps binaires sont:

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

... et en hexadécimal, ce sont:

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

_{Fait amusant: il n'y a pas d'émirps dans l' unaire car chaque nombre est un palindrome.}

Le défi

Votre tâche consiste à créer une fonction (ou un programme complet) qui prend deux paramètres, et , et génère une liste des premiers émirps de la base .$n$$b$$n$$b$

Règles / Détails:

• $n$b 0 et sont tous deux des entiers positifs supérieurs à .$b$$0$
• Vous pouvez supposer : c'est-à-dire que la base sera comprise entre binaire et hexidécimal.$2 ≤ b ≤ 16$
• Vous devriez pouvoir calculer des valeurs de jusqu'à .$n$100$~100$
• La liste générée peut être en base , ou en base d'entiers standard de votre langue, tant que vous le spécifiez dans votre réponse.$b$
• Les contrôles Emirp intégrés ne sont pas autorisés (les tests de primalité intégrés sont corrects)
• Vous ne pouvez pas coder en dur les émirps ou lire à partir de fichiers externes.
• Les failles standard sont interdites, comme toujours.
• Il s'agit de code-golf , donc la réponse la plus courte (en octets) l'emporte.

Cas de test

Pour chaque cas de test, j'ai inclus la liste en base bet ses équivalents en base 10.

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] 

Vous pouvez tester votre programme plus en détail par rapport à mon exemple Python (non golfé) sur repl.it

Gelée , 16 octets

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

TryItOnline!

Comment?

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

* La note ben base best [1,0], qui, lorsqu'elle est inversée, est [0,1]ce qui est 1, ce qui n'est pas un nombre premier; rien de moins qu'un bchiffre dans la base bet donc palindromique.

05AB1E , 17 octets

Utilise l' encodage CP-1252 .

L'ordre d'entrée est n, b
Sortie est en base 10.

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

Essayez-le en ligne!

Explication

                    # 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 octets

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

Fonctionne pour 0 <= n <= 100et 2 <= b <= 16. Dans la liste Prime@Range@437des premiers 437nombres premiers, trouvez Cases poù la base IntegerReverse rde pin #2n'est pas égale à pet est également premier, puis prenez le premier #tel p.

Voici une solution de 95 octets qui fonctionne pour arbitraire n>=0et 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 octets

($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

Lisible:

($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

cconvertit un nombre donné en base $bet dconvertit un nombre donné de la base $ben décimal en trouvant le premier nombre qui renvoie ledit $bnombre de base lorsqu'il est passé à c. La boucle for vérifie ensuite s'il s'agit d'un palindrome et si les deux nombres sont premiers à l'aide de l'expression rationnelle composite.

Mathematica 112 octets

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

Exemple

Trouvez les 10 premiers émips dans l'hex. retournez-les en décimal.

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}

Non golfé

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 octets

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

Renvoie la liste des émirps en base 10.

Python 3 , 232 214 191 191 188 octets

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

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

Essayez-le en ligne!

C, 293 286 261 octets

Amélioré par @ceilingcat , 261 octets:

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

Essayez-le en ligne!

(Cette personne est comme me suivre constamment autour de PPCG et améliorer mes trucs dans les commentaires, et dès que je réponds pour le remercier, il supprime simplement le commentaire et disparaît lol. Welp, merci encore!)

Amélioré par @movatica , 286 octets:

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

Essayez-le en ligne!

Ma réponse d'origine, 293 octets:

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

Compilez avec gcc emirp.c -o emirp -lmet exécutez avec ./emirp <b> <n>. Imprime des émirps séparés par des espaces en base 10.

JavaScript (ES6), 149 148 141 140 octets

Renvoie une liste d'émirps séparés par des espaces dans la base b. (Peut être 2 octets plus court en renvoyant une liste décimale à la place.)

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):''

Cas de test

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 octets

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

Essayez-le en ligne!

Sort chaque numéro sur une nouvelle ligne, en base 10

APL (NARS), 87 caractères, 174 octets

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

Le résultat sera en base 10. Test et résultats:

  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+⍺⍟⍵)⊤⍵}ferait la conversion de ⍵dans la base ⍺, résultat entier de tableau; 0π⍵retournerait vrai [1] si ⍵est premier sinon il retournerait 0.