20

एक एमिरप एक नॉन- पैलिंड्रोमिक प्राइम है, जो उलटा होने पर भी प्राइम होता है।

आधार 10 अमीरों की सूची OEIS पर देखी जा सकती है । पहले छह हैं:

13, 17, 31, 37, 71, 73

हालांकि, प्रतिवर्ती नियम के कारण, प्रत्येक आधार में अमीरात अलग-अलग होते हैं। उदाहरण के लिए, पहले छह बाइनरी अमीरात हैं:

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

... और हेक्साडेसिमल में वे हैं:

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

_{मज़ा तथ्य: में कोई emirps देखते हैं एकल के रूप में हर संख्या विलोमपद।}

चुनौती

आपका कार्य एक फ़ंक्शन (या पूर्ण प्रोग्राम) बनाना है जो दो पैरामीटर लेता है, और , और आधार में पहले अमीरात की सूची बनाता है । $n$ $b$ $n$ $b$

/ विवरण नियम:

$n$ और दोनों से बड़े धनात्मक पूर्णांक हैं । $b$ $0$
आप मान सकते हैं कि : : यह कहना है, आधार बाइनरी और हेक्सिडेसिमल के बीच होगा। $2 ≤ b ≤ 16$
आपको तक मूल्यों के लिए गणना करने में सक्षम होना चाहिए । $n$ $~100$
जब तक आप इसे अपने उत्तर में निर्दिष्ट करते हैं, तब तक उत्पन्न सूची आधार , या आपकी भाषा के मानक पूर्णांक आधार में हो सकती है। $b$
बिलिन एमिरप चेक की अनुमति नहीं है (बिल्टिन प्राइमलिटी टेस्ट ठीक हैं)
आप एमिरप्स को हार्ड-कोड नहीं कर सकते, या किसी बाहरी फाइल से नहीं पढ़ सकते हैं।
मानक खामियों पर हमेशा की तरह प्रतिबंध लगा दिया जाता है।
यह कोड-गोल्फ है , इसलिए सबसे छोटा उत्तर (बाइट्स में) जीतता है।

परीक्षण के मामलों

प्रत्येक परीक्षण मामले के लिए, मैंने सूची को आधार bऔर इसके आधार 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]

आप पर मेरी (ungolfed) अजगर उदाहरण के खिलाफ आगे अपने कार्यक्रम का परीक्षण कर सकते repl.it

— FlipTack
स्रोत

6

जेली , 16 बाइट्स

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

TryItOnline!

कैसे?

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

* नोट bबेस में bहै [1,0], जो उलटा होने पर [0,1]है 1, जो कि प्रमुख नहीं है; कुछ भी कम bआधार में एक अंक है bऔर इसलिए palindromic है।

— जोनाथन एलन
स्रोत

जीतने पर बधाई!

— FlipTack

8

05AB1E , 17 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

इनपुट ऑर्डर n, b
आउटपुट बेस -10 में है।

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

इसे ऑनलाइन आज़माएं!

व्याख्या

                    # 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

— Emigna
स्रोत

4

गणितज्ञ, 70 बाइट्स

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

0 <= n <= 100और के लिए काम करता है 2 <= b <= 16। सूची से Prime@Range@437पहले की 437अभाज्य संख्या, लगता है Cases pजहां IntegerReverse rके pआधार में #2के बराबर नहीं है pऔर यह भी प्रधानमंत्री है, तो पहले ले #इस तरह के p।

यहाँ एक 95 बाइट समाधान है जो मनमाने ढंग से काम करता है n>=0और b>=2:

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

— ngenisis
स्रोत

+1 IntegerReverse। बेशक! अच्छा लगा।

— डेविड जेएन

मनमाने ढंग से नायब समाधान के लिए 79 बाइट्स ; 77 बाइट्स यदि Reapपाद में आईएनजी की अनुमति है:For[i=j=0,j<#,If[(r=IntegerReverse[p=Prime@++i,#2])!=p&&PrimeQ@r,j++;Sow@p]]&

— रोमन

3

पर्ल, 262 बाइट्स

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

पठनीय:

($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किसी दिए गए नंबर को आधार में परिवर्तित करता है $b, और dकिसी दिए गए नंबर को आधार से $bवापस दशमलव में बदलकर पहला नंबर ढूंढता है जो कहा गया है कि आधार $bनंबर को पास कर दिया गया है c। लूप के लिए यह जाँचता है कि क्या यह एक पैलिंड्रोम है और यदि दोनों संख्याएँ मिश्रित रेगेक्स का उपयोग कर रही हैं।

— गेब्रियल बेनामी
स्रोत

3

गणितज्ञ 112 बाइट्स

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

उदाहरण

हेक्स में पहले 10 Emips खोजें; उन्हें दशमलव में लौटा दें।

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] *)

— DavidC
स्रोत

2

पर्ल 6 , 91 बाइट्स

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

आधार 10 में अमीरात की सूची लौटाता है।

— शॉन
स्रोत

81 बाइट्स

— जो किंग

2

पायथन 3 , 232 214 191 188 बाइट्स

हरमन एल -14 बाइट्स
जो राजा -3 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— movatica
स्रोत

1

200 बाइट्स

— हरमन एल

अच्छा पकड़ा! लाया कि 191 बाइट्स के लिए

— जंगम

अच्छा लगा, @JoKing!

— १६:४

2

सी, 293 286 261 बाइट्स

@Ceilingcat द्वारा बेहतर , 261 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

(यह व्यक्ति पीपीसीजी के आसपास लगातार मेरा पीछा करने और टिप्पणियों में अपना सामान सुधारने की तरह है, और जैसे ही मैं उसे धन्यवाद देने के लिए उत्तर देता हूं वह सिर्फ टिप्पणी हटा देता है और लोल गायब हो जाता है। फिर से धन्यवाद!)

@Movatica द्वारा बेहतर , 286 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

मेरा मूल उत्तर, 293 बाइट्स:

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

के साथ संकलन करें gcc emirp.c -o emirp -lmऔर चलाएं ./emirp <b> <n>। आधार -10 में प्रिंट-स्पेस-अलग-अलग अमीरात।

— OverclockedSanic
स्रोत

@ फीलटैक आप सही कह रहे हैं। मुझे इसे कल ठीक करना होगा।

— ओवरक्लॉक्डसैनिक

@FlipTack फिक्स्ड और यह सुनिश्चित करने के लिए परीक्षण किया गया है कि यह आपके परीक्षण पास करता है। क्या यह अच्छा है?

— ओवरक्लॉक्ड

वाकई है! और कोड गोल्फ में आपका स्वागत है।

— 17

1

अच्छा काम! मैं तुम्हें करने के लिए नीचे पाने के लिए कुछ वेतन वृद्धि ऑपरेटरों चले गए 286

— movatica

1

@movatica बहुत बढ़िया! मैंने अपने उत्तर में आपके सुधार जोड़े। धन्यवाद!

— ओवरक्लॉकडासनिक

1

जावास्क्रिप्ट (ईएस 6), 149 148 141 140 बाइट्स

बेस b में अमीरात की एक अलग-अलग सूची लौटाता है। (इसके बजाय एक दशमलव सूची लौटाकर 2 बाइट्स छोटे हो सकते हैं।)

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

परीक्षण के मामलों

कोड स्निपेट दिखाएं

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

स्निपेट का विस्तार करें

— Arnauld
स्रोत

1

पायथन 2 , 133 बाइट्स

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

इसे ऑनलाइन आज़माएं!

बेस 10 में प्रत्येक संख्या को एक नई लाइन पर आउटपुट करता है

— नकारात्मक सात
स्रोत

0

एपीएल (एनएआरएस), 87 चार्ट, 174 बाइट्स

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

परिणाम आधार १० में होगा। टेस्ट और परिणाम:

  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+⍺⍟⍵)⊤⍵}⍵आधार ⍺, सरणी पूर्णांक परिणाम का रूपांतरण करेगा ; 0π⍵अगर ⍵यह दूसरा है तो यह सच होगा [१] वापस आ जाएगा।

— RosLuP
स्रोत

अमीरात खोजें!

चुनौती

परीक्षण के मामलों

जेली , 16 बाइट्स

कैसे?

05AB1E , 17 बाइट्स

गणितज्ञ, 70 बाइट्स

पर्ल, 262 बाइट्स

गणितज्ञ 112 बाइट्स

पर्ल 6 , 91 बाइट्स

पायथन 3 , 232 214 191 188 बाइट्स

सी, 293 286 261 बाइट्स

जावास्क्रिप्ट (ईएस 6), 149 148 141 140 बाइट्स

परीक्षण के मामलों

पायथन 2 , 133 बाइट्स

एपीएल (एनएआरएस), 87 चार्ट, 174 बाइट्स