क्रम

सभी जानते हैं कि केवल प्राइम नंबर ही है 2। उबाऊ। लेकिन, कुछ निश्चित संख्याएँ भी हैं n, जहाँ, जब n-1उन्हें समाप्‍त किया जाता है , तो वे एक प्रमुख संख्‍या बन जाती हैं ।

शुरुआत 1के लिए, सूची में नहीं है, क्योंकि 10प्रमुख नहीं है। इसी तरह 2( 21), और 3( 32) के साथ। हालाँकि, 4काम करता है क्योंकि 43प्रधान है, इसलिए यह अनुक्रम में पहला नंबर है a(1) = 4। अगली संख्या जो काम करती है (न तो 6( 65) और न ही 8( 87) काम) 10, क्योंकि 109प्रधान है, इसलिए a(2) = 10। तब हम तब तक एक गुच्छा छोड़ते हैं 22, जब तक 2221कि प्राइम न हो जाए a(3) = 22। और इसी तरह।

स्पष्ट रूप से इस क्रम में सभी शब्द सम हैं, क्योंकि किसी भी विषम संख्या के nसाथ समाप्‍त होने पर n-1भी (जैसे 3बदल जाता है 32), जो कभी भी प्रधान नहीं होगा।

यह OEIS पर अनुक्रम A054211 है।

चुनौती

एक इनपुट नंबर दिया गया है nजो इस क्रम में कहीं फिट बैठता है (यानी, के nसाथ संक्षिप्त रूप n-1से अभाज्य है), इस क्रम में अपनी स्थिति को आउटपुट करता है। आप 0- या 1-अनुक्रमित दोनों में से कोई भी चुन सकते हैं, लेकिन कृपया अपनी प्रविष्टि में बताएं।

नियम

इनपुट और आउटपुट को आपकी भाषा के मूल पूर्णांक प्रकार में फिट करने के लिए ग्रहण किया जा सकता है।
इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में दिए जा सकते हैं ।
या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
यदि संभव हो, तो कृपया ऑनलाइन परीक्षण वातावरण का लिंक शामिल करें ताकि अन्य लोग आपके कोड को आज़मा सकें!
मानक खामियों को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

उदाहरण

नीचे दिए गए उदाहरण 1-अनुक्रमित हैं।

— AdmBorkBork
स्रोत

1

आपको इसे रिवर्स में क्यों करना है? CQuents में वह मोड नहीं है :(

— स्टीफन

4

@StepHen गति के परिवर्तन के लिए; सामान्य से कुछ अलग।

— AdmBorkBork

9

मुझे लगता है कि निर्णय की समस्या के रूप में यह बेहतर होगा।

— गेहूं जादूगर

4

न केवल 2 केवल 2 से विभाज्य अभाज्य संख्या है, 3 भी केवल 3 से विभाज्य अभाज्य संख्या है, और 5 केवल 5 से विभाज्य अभाज्य संख्या है। सामान्य रूप से, एक अभाज्य संख्या nहमेशा से ही अभाज्य संख्या है n। यह विशेष नहीं है - कि सिर्फ प्राइम नंबर कैसे काम करते हैं।

— बजे फल

11

जेली , 8 7 बाइट्स

ḊżṖVÆPS

एक सीक्वेंस लिंक एक सदस्य ले रहा है और अनुक्रम में अपना सूचकांक वापस कर रहा है।

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

कैसे?

ḊżṖVÆPS - Link: number, n
Ḋ       - dequeue (implicit range) = [ 2   , 3   , 4   ,... ,              n         ]
  Ṗ     - pop (implicit range)     = [   1 ,   2 ,   3 ,... ,                  n-1   ]
 ż      - zip                      = [[2,1],[3,2],[4,3],... ,             [n , n-1]  ]
   V    - evaluate as Jelly code   = [ 21  , 32  , 43  ,... ,         int("n"+"n-1") ]
    ÆP  - is prime? (vectorises)   = [  0  ,  0  ,  1  ,... , isPrime(int("n"+"n-1"))]
      S - sum

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

TIO मेरे लिए नीचे नहीं है, शायद यह बस वापस मिल गया?

— कॉनर ओ'ब्रायन

1

2 मिनट पहले के रूप में फिक्स्ड :)

— जोनाथन एलन

सुंदर! वह zip(head(), pop())चाल वाकई मस्त है। :)

— DJMcMayhem

7 बाइट्स किस एन्कोडिंग में है?

— काइलफिन

1

@kylefinn जेली का अपना कोड-पेज है, इसे देखने के लिए हेडर में बाइट्स लिंक पर क्लिक करें।

— जोनाथन एलन

8

हास्केल , 80 75 70 बाइट्स

5 बाइट्स लाईकोनी के लिए धन्यवाद बचाते हैं

p x=all((>0).mod x)[2..x-1]
g n=sum[1|x<-[4..n],p$read$show=<<[x,x-1]]

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

— गेहूं का जादूगर
स्रोत

1

मुझे लगता है कि आप छोटे प्राइम टेस्ट का उपयोग कर सकते हैं p x=all((>0).mod x)[2..x-1]जो 1 के लिए विफल रहता है, लेकिन इस मामले में यह बात नहीं होनी चाहिए।

— लकोनी

1

को भी show x++show(x-1)छोटा किया जा सकता है show=<<[x,x-1]।

— लकोनी

@ Laikoni सुझावों के लिए धन्यवाद! मैंने सोचा था कि यह showएक छोटी विधि में किया जा सकता है, लेकिन मैंने किसी कारण के लिए एक संक्षिप्त मानचित्र के बारे में नहीं सोचा।

— गेहूं जादूगर

6

जेली , 12, 10 , 8 बाइट्स

;’VÆPµ€S

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

1-2 बाइट्स ने @ nmjmcman101 को धन्यवाद दिया, और 2 बाइट्स ने @ डेनिस को धन्यवाद दिया!

स्पष्टीकरण:

     µ€   # For N in range(input()):
;         #   Concatenate N with...
 ’        #   N-1
  V       #   And convert that back into an integer
   ÆP     #   Is this number prime?
       S  # Sum that list

— DJMcMayhem
स्रोत

क्या आप केवल R को ड्रॉप कर सकते हैं और निहित सीमा का उपयोग कर सकते हैं?

— nmjcman101

@ nmjcman101 मैं पूरी तरह से नहीं जानता था कि यह एक चीज़ थी। धन्यवाद!

— DJMcMayhem

5

05AB1E , 9 8 7 बाइट्स

कोड

ƒNN<«pO

05AB1E एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

व्याख्या

ƒ          # For N in [0 .. input]..
 NN<«      #   Push n and n-1 concatenated
     p     #   Check for primality
      O    #   Sum the entire stack (which is the number of successes)

— अदनान
स्रोत

बेशक यह इस तथ्य का फायदा उठाता है कि 05AB1E त्रुटियों की अनदेखी करता है ... क्योंकि मुझे नहीं लगता कि आप जांच सकते हैं कि क्या '0-1'प्रमुख है।

— आउटगॉल्फ

5

भूसी , १३ ११ १० बाइट्स

1-अंधेरा समाधान:

#ȯṗdS¤+d←ḣ

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

Ungolfed / स्पष्टीकरण

         ḣ -- in the range [1..N]
#          -- count the number where the following predicate is true
        ←  --   decrement number,
    S  d   --   create lists of digits of number and decremented 
     ¤+    --   concatenate,
   d       --   interpret it as number and
 ȯṗ        --   check if it's a prime number

धन्यवाद @ बगर -3बाइट्स के लिए!

— ბიმო
स्रोत

1

£İpके बराबर है ṗ। इसके अलावा, आप के #…ḣबजाय के साथ एक बाइट बचा सकता है £f…N।

— जर्ग्ब

4

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

-2 बाइट्स @officialaimm को धन्यवाद । 1 अनुक्रमित।

lambda n:sum(all(z%v for v in range(2,z))for i in range(4,n+1)for z in[int(`i`+`i-1`)])

परीक्षण सूट।

— मिस्टर एक्सकोडर
स्रोत

मैं इसे जल्द से जल्द पूरा कर रहा हूं। सुझावों का स्वागत है।

— श्री एक्सकोडर

87 बाइट्स

— आधिकारिक

4

पायथ , 12 बाइट्स

smP_s+`d`tdS

इसे ऑनलाइन आज़माएं! या सभी टेस्ट मामलों को सत्यापित करें।

कैसे?

smP_s+`d`tdSQ  -> Full Program. Takes input from Standard Input. Q means evaluated input
                  and is implicit at the end.

 m         SQ  -> Map over the Inclusive Range: [1...Q], with the current value d.
    s+`d`td    -> Concatenate: d, the current item and: td, the current item decremented. 
                  Convert to int.
  P_           -> Prime?
s              -> Sum, counts the occurrences of True.

— मिस्टर एक्सकोडर
स्रोत

4

जाप , 15 14 12 11 9 8 बाइट्स

1 अनुक्रमित।

ÇsiZÄÃèj

कोशिश करो

Ç            :Map each Z in the range [0,input)
 s           :  Convert to string
  i          :    Prepend
   ZÄ        :    Z+1
     Ã       :End map
      è      :Count
       j     :  Primes

— झबरा
स्रोत

1

11 बाइट्स

— ओलिवर

गाह! मेरे पास इस तरह के अंधा के लिए Æऔर Çक्यों है! धन्यवाद, @ ओलिवर; कंप्यूटर पर वापस आने पर मैं अपडेट करूंगा।

— झबरा

2o+X(अनुगामी स्थान के साथ) के स्थान पर काम करेगा [XXÉ], हालांकि यदि मैं कभी भी ऑटो-बैलेंसिंग []ब्रैकेट के आसपास पहुंचता हूं तो आपका समाधान एक बाइट छोटा होगा। (वास्तव में 2, चूंकि आप तब कर सकते थे õ_ZÉ]¬nÃèj)

— ETHproductions

@ETHproductions: इन दिनों, एक सरणी के साथ काम करते समय मैं जो मुट्ठी भर काम करता हूं वह यह देखने के लिए जांचता है कि क्या ऑटो-बैलेंसिंग के लिए जोड़ा गया है []! : डी

— झबरा

किसी कारण से मुझे लगता है कि अर्धविराम ने पूरी तरह से काम करना बंद कर दिया है, इसलिए मैं इसे ठीक करने की कोशिश करूंगा। मुझे नहीं लगता कि कल दोपहर तक मेरे पास एक मौका होगा।

— ETHproductions

3

रोड़ा , 73 बाइट्स

{seq 3,_|slide 2|parseInteger`$_2$_1`|{|i|[1]if seq 2,i-1|[i%_!=0]}_|sum}

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

1 अनुक्रमित। यह इनपुट और आउटपुट करने के लिए स्ट्रीम का उपयोग करता है।

स्पष्टीकरण:

{
seq 3,_| /* Create a stream of numbers from 3 to input */
slide 2| /* Duplicate every number except the first and the last
            to create (n-1,n) pairs */
parseInteger`$_2$_1`| /* Concatenate n and n-1 and convert to integer */
{|i| /* For every i in the stream: */
    [1]if seq 2,i-1|[i%_!=0] /* Push 1 if i is a prime
                                (not divisible by smaller numbers) */
}_|
sum /* Return the sum of numbers in the stream */
}

— fergusq
स्रोत

2

अजगर , 14 बाइट्स

lfP_Tms+`d`tdS

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

व्याख्या

              Q    # Implicit input
             S     # 1-indexed range
     m             # For d in range [1, Q]...
      s+`d`td      # Concatenate d and d - 1
 fP_T              # Filter on primes
l                  # Return the length of the list

— जिम
स्रोत

आप मुझे कुछ सेकंड के लिए हरा देते हैं, मैं आपको कुछ बाइट्स से हरा देता हूं: पी

— श्री एक्सकोडर

@ Mr.Xcoder मेरा पहला संस्करण था lfTmP_s+`d`tdS, यह दुर्भाग्यपूर्ण है कि मुझे उस समय आपकी चाल खुद नहीं मिली :)

— जिम

2

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

{first :k,$_,grep {is-prime $_~.pred},1..∞}

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

grepसंख्या योग्यता के अनुक्रम पैदा करता है, तो हम कुंजी (देखने के लिए :k) (यानी, इंडेक्स) की firstसूची है कि इनपुट पैरामीटर के बराबर होती है में संख्या $_।

— शॉन
स्रोत

30 बाइट्स

— जो राजा

2

सी, ९९ 94 बाइट्स

1 अनुक्रमित। यह मुझे इस बात की पीड़ा देता है कि मैं प्रायोगिक परीक्षण लिख रहा हूं, जो कि कम्प्यूटेशनल रूप से बेकार हैं, लेकिन बाइट्स बाइट्स हैं।

अगर हम जीसीसी 7.1.1 के साथ अनुकूलन के बिना मेरी मशीन पर कुछ वास्तव में भंगुर सामान की अनुमति देते हैं, तो निम्नलिखित 94 बाइट्स काम करता है (धन्यवाद @ कोरोन ओ'ब्रायन )

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

अन्यथा ये अधिक मजबूत 99 बाइट्स काम करता है

i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}return c;}

पूर्ण कार्यक्रम, थोड़ा अधिक पठनीय:

i,c,m,k;
f(n){
    c=i=1;
    for(;++i<n;c+=m==k){
        for(k=m=1;m*=10,m<i;);
        for(m=i*m+i-1;++k<m&&m%k;);
    }
    return c;
}

int main(int argc, char *argv[])
{
    printf("%d\n", f(atoi(argv[1])));
    return 0;
}

— algmyr
स्रोत

अपने संकलक के आधार पर, आप n=c;इसके बजाय का उपयोग करके कुछ बाइट्स को बचाने में सक्षम हो सकते हैं return c;:i,c,m,k;f(n){c=i=1;for(;++i<n;c+=m==k){for(k=m=1;m*=10,m<i;);for(m=i*m+i-1;++k<m&&m%k;);}n=c;}

— कॉनर ओ'ब्रायन

मैं यह नहीं कह सकता कि मैं उन चीजों का उपयोग करना चाहता हूं जो अनुकूलन स्तरों के साथ भी बदलती हैं। GCC का उपयोग करना, जिसमें कोई अनुकूलन नहीं है -O0 यह काम करता है, अन्य अनुकूलन झंडे के साथ यह नहीं करता है। दिलचस्प है -O1 -O2 और -O3 में यह 0 लौटाता है, -O के साथ यह 1 रिटर्न देता है, साथ-साथ यह n-1 देता है।

— अल्जीमर

आप हमेशा अपने जवाब में निर्दिष्ट कर सकते हैं कि आपका कार्यक्रम कैसे संकलित किया जाना चाहिए।

— कॉनर ओ'ब्रायन

मुझे लगता है, थोड़ा सस्ता लगता है। लेकिन मैं एक विकल्प जोड़ सकता हूं।

— अल्जीमर

मैं समझता हूं, लेकिन मुझे ऐसा करने में कोई बुरा नहीं लगेगा - यह सी में गोल्फिंग के लिए सुझावों में से एक है

— कॉनर ओ'ब्रायन

2

जावास्क्रिप्ट (ईएस 6), 49 48 47 बाइट्स

1 अनुक्रमित। आपके इंजन के कॉल स्टैक आकार द्वारा सीमित।

f=n=>n&&f(n-2)+(p=n=>n%--x?p(n):x<2)(x=n+[--n])

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

— Arnauld
स्रोत

1

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

Position[Select[Range@#,PrimeQ@FromDigits[Join@@IntegerDigits/@{#,#-1}]&],#]&

— J42161217
स्रोत

0

QBIC , 25 बाइट्स

[:|p=p-µa*z^_l!a$|+a-1}?p

व्याख्या

[:|     FOR a = 1 to <n>
p=p-    Decrement p (the counter) by
µ       -1 if the following is prime, or 0 if not
        For the concatenating, we multiply 'a' by 10^LENGTH(a), then add a-1$┘p
        Example 8, len(8) = 1, 8*10^1 = 80, add 8-1=7, isPrime(87) = 0
a*z^_l!a$|+a-1
}       Close the FOR loop - this also terminates the prime-test
?p      Print p, the 0-based index in the sequence.

यह अच्छा उपाय के लिए एक कास्ट-टू-स्ट्रिंग थप्पड़ के साथ कुछ बहुत ही शामिल गणित-चीज़ का उपयोग करता है। वर्जन हैट बनाना पूरी तरह से स्ट्रिंग-बेस्ड कॉन्टेक्टेशन एक बाइट लंबा है:

[:|A=!a$+!a-1$┘p=p-µ!A!}?p

— steenbergh
स्रोत

0

PHP , 203 बाइट्स

<?php $n=($a=$argv[1]).($a-1);$p=[2];$r=0;for($b=2;$b<=$n;$b++){$x=0;if(!in_array($b,$p)){foreach($p as $v)if(!($x=$b%$v))break;if($x)$p[]=$b;}}for($b=1;$b<=$a;$b++)if(in_array($b.($b-1),$p))$r++;die $r;

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

आउटपुट के लिए 1-आधारित इंडेक्स का उपयोग करता है। TIO लिंक में कोड का पठनीय संस्करण है।

— Mic1780
स्रोत

0

माणिक , 42 + 9 = 51 बाइट्स

का उपयोग करता है -rprime -nझंडे का । 1 अनुक्रमित।

सभी संख्याओं के बराबर या नीचे इनपुट के साथ काम करता है जो शर्त को पूरा करते हैं (या अधिक तकनीकी रूप से, सभी संख्या जो n-1शर्त को पूरा करते हैं)। चूंकि इनपुट के अनुक्रम में होने की गारंटी है, इसलिए यादृच्छिक इनपुट से त्रुटि का कोई खतरा नहीं है, जैसे 7कि "प्रधान नहीं होता"।

p (?3..$_).count{|i|eval(i.next+i).prime?}

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

— मूल्य स्याही
स्रोत

0

रूबी , 62 बाइट्स

->g{(1..g).count{|r|(2...x=eval([r,r-1]*'')).none?{|w|x%w<1}}}

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

1 अनुक्रमित

— जीबी
स्रोत

0

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

1 अनुक्रमित

lambda n:sum(all(z%v for v in range(2,z))for i in range(3,n)for z in[int(`i+1`+`i`)])

परीक्षा

श्री Xcoder के जवाब में सुधार

— हलवार्ड वुल्फ
स्रोत

0

जावा 8, 108 बाइट्स

n->{for(long r=0,q=1,z,i;;){for(z=new Long(q+""+~-q++),i=2;i<z;z=z%i++<1?0:z);if(z>1)r++;if(q==n)return r;}}

0 अनुक्रमित

स्पष्टीकरण:

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

n->{                             // Method with integer parameter and long return-type
  for(long r=0,                  //  Result-long, starting at 0
      q=1,                       //  Loop integer, starting at 1
      z,i;                       //  Temp integers
      ;){                        //  Loop indefinitely
    for(z=new Long(q+""+~-q++),  //   Set z to `q` concatted with `q-1`
        i=2;i<z;z=z%i++<1?0:z);  //   Determine if `z` is a prime,
      if(z>1)                    //   and if it indeed is:
        r++;                     //    Increase the result-long by 1
      if(q==n)                   //   If `q` is now equal to the input integer
        return r;}}              //    Return the result

— केविन क्रूज़सेन
स्रोत

0

स्टैक्स , 10 बाइट्स

1- अनुक्रमित

Äm▬á┌╕|°φ♦

भागो और डिबग यह स्पष्टीकरण

Rxr\{$e|pm|+         #Full program, unpacked, implicit input  (Example (4))
R                    #Create [1 to input] range  (ex [1,2,3,4] )             
 x                   #Copy value from x register (ex (4) )
  r                  #Create [0 to input-1] range (ex [0,1,2,3)
   \                 #Create array pair using the range arrays (ex [[1,0],[2,1],[3,2],[4,3]])
    {    m           #Map block
     $e|p            #To string, eval string (toNum), isPrime (ex [1,0] => "10" => 10 => 0)
          |+         #Sum the array to calculate number of truths (ex [0,0,0,1] => 1)

— मल्टी
स्रोत

0

साफ , 33 बाइट्स

index({n:prime(n.n-1|int)}from N)

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

व्याख्या

मूल विचार यह है कि वैध संख्याओं का अनुक्रम बनाया जाए और फिर एक अनुक्रमित इंडेक्स फ़ंक्शन को लौटाया जाए।

index({n:prime(n.n-1|int)}from N)
      {n:                }from       select all numbers `n` from...
                               N     the set of natural numbers, such that:
               n.n-1                     `n` concatenated with `n-1`
                    |int                 ...converted to an integer
         prime(         )                ...is prime
index(                          )    function that returns index of input in that sequence

— कोनोर ओ ब्रायन
स्रोत

क्या संख्याएँ भी प्रधान हो सकती हैं?

क्रम

चुनौती

नियम

उदाहरण

जेली , 8 7 बाइट्स

कैसे?

हास्केल , 80 75 70 बाइट्स

जेली , 12, 10 , 8 बाइट्स

05AB1E , 9 8 7 बाइट्स

कोड

व्याख्या

भूसी , १३ ११ १० बाइट्स

Ungolfed / स्पष्टीकरण

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

पायथ , 12 बाइट्स

कैसे?

जाप , 15 14 12 11 9 8 बाइट्स

रोड़ा , 73 बाइट्स

अजगर , 14 बाइट्स

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

सी, ९९ 94 बाइट्स

जावास्क्रिप्ट (ईएस 6), 49 48 47 बाइट्स

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

QBIC , 25 बाइट्स

व्याख्या

PHP , 203 बाइट्स

माणिक , 42 + 9 = 51 बाइट्स

रूबी , 62 बाइट्स

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

जावा 8, 108 बाइट्स

स्टैक्स , 10 बाइट्स

साफ , 33 बाइट्स

व्याख्या