Bir emirp , tersine çevrildiğinde de asal olan palindromik olmayan bir asaldır.

10 tabanındaki emirps listesi bulunabilir OEIS . İlk altısı:

13, 17, 31, 37, 71, 73

Ancak, tersine çevirme kuralı nedeniyle, emirpler her bir bazda farklıdır. Örneğin, ilk altı ikili emir:

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

... ve onaltılı olarak, bunlar:

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

_{Eğlenceli Gerçek: her sayı bir palindrom olduğu için tek başına emirp yoktur .}

Meydan okuma

Senin görevin, iki parametre alır bir işlev (veya tam programı) oluşturmaktır ve ve ilk bir listesini oluşturur baz içinde emirps .$n$$b$$n$$b$

Ayrıntılar / Kurallar:

• $n$ ve ikisi de büyük pozitif tamsayılardır .$b$$0$
• olduğunu varsayabilirsiniz : yani, taban ikili ve onaltılık arasında olacaktır.$2 ≤ b ≤ 16$
• kadar olan değerlerini hesaplayabilmelisiniz .$n$$~100$
• Oluşturulan liste, cevabınızda belirttiğiniz sürece, tabanında veya dilinizin standart tam sayı tabanında olabilir.$b$
• Dahili emirp kontrollerine izin verilmez (yerleşik öncelik testlerine uygundur)
• Emirleri sabit olarak kodlayamaz veya harici dosyalardan okuyamazsınız.
• Standart boşluklar her zamanki gibi yasaklanmıştır.
• Bu kod golf , bu yüzden en kısa cevap (bayt cinsinden) kazanır.

Test Durumları

Her test durumu için, listeyi tabana bve tabanına 10 eşdeğerine dahil ettim .

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] 

Sen benim (ungolfed) Python Örneğin karşı daha da programı test edebilirsiniz repl.it

Jöle , 16 bayt

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

TryItOnline!

Nasıl?

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

* Not btabanında bolduğu [1,0]ters döndü hangi zaman [0,1]olduğu 1asal değildir ki; daha küçük bbir şey tabanda bir rakam bve dolayısıyla palindromiktir.

05AB1E , 17 bayt

CP-1252 kodlamasını kullanır .

Giriş sırası n, b
Çıkış taban-10'dur.

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

Çevrimiçi deneyin!

açıklama

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

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

İçin çalışır 0 <= n <= 100ve 2 <= b <= 16. Listeden Prime@Range@437ilk 437asal bulmak Cases pnerede IntegerReverse rait ptabanında #2eşit değildir pve ayrıca asal olduğunu, daha sonra ilk almak #böyle p.

İşte keyfi olarak çalışan 95 baytlık bir çözüm n>=0ve 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 bayt

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

Okunabilir:

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

ctaban içine belirli bir numara çevirir $bve dbaz, belirli bir sayıda dönüştürür $bdöner baz-bahsedilen birinci sayı bularak ondalık içine geri $biletilen zaman sayısı c. For döngüsü daha sonra bunun bir palindrom olup olmadığını ve her iki sayının bileşik normal ifadeyi kullanarak birincil olup olmadığını kontrol eder.

Mathematica 112 bayt

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

Misal

Hex'de ilk 10 Emip'i bulun; Ondalık olarak döndür.

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 bayt

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

Taban 10'daki emirpların listesini döndürür.

Piton 3 , 232 214 191 188 bayt

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

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

Çevrimiçi deneyin!

Cı, 293 286 261 bayt

@Ceilingcat , 261 bayt tarafından geliştirilmiştir :

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

Çevrimiçi deneyin!

(Bu kişi sürekli PPCG etrafında beni takip etmek ve yorumlarda eşyalarımı geliştirmek gibi ve ona teşekkür etmek için cevap verir vermez sadece yorumu siler ve lol kaybolur. Welp, tekrar teşekkürler!)

@Movatica tarafından geliştirildi , 286 bayt:

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

Çevrimiçi deneyin!

Orijinal cevabım, 293 bayt:

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

İle derleyin gcc emirp.c -o emirp -lmve ile çalıştırın ./emirp <b> <n>. Taban-10'da boşlukla ayrılmış emirp yazdırır.

JavaScript (ES6), 149 148 141 140 bayt

B tabanındaki boşluklardan ayrılmış bir emirp listesi döndürür. (Bunun yerine ondalık bir liste döndürerek 2 bayt daha kısa olabilir.)

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

Test senaryoları

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 bayt

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

Çevrimiçi deneyin!

Her sayıyı taban 10'da yeni bir satıra çıkarır

APL (NARS), 87 karakter, 174 bayt

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

Sonuç 10 bazında olacaktır. Test ve sonuçlar:

  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+⍺⍟⍵)⊤⍵}⍵baz ⍺, dizi tamsayı sonucunun dönüşümünü yapar ; 0π⍵[1] true değerini döndürür ⍵, eğer asal ise 0 döndürür.