क्या हम प्रधान समूह को साझा करते हैं?

Question

प्रधानमंत्री क्लस्टर एक पूर्णांक के एन से अधिक 2 के रूप में जोड़ी उच्चतम प्रधानमंत्री द्वारा गठित परिभाषित किया गया है सख्ती से कम एन और सबसे कम प्रधानमंत्री सख्ती से अधिक एन ।

ध्यान दें कि ऊपर दी गई परिभाषा के बाद, यदि पूर्णांक स्वयं एक अभाज्य है, तो इसका मुख्य क्लस्टर पूर्ववर्ती और इसे सफल करने वाले युग्मों की जोड़ी है।

कार्य

दो पूर्णांकों के पूर्णांक एन , एम ( एन, एम, 3 ) को देखते हुए , एन और एम के समान प्राइम क्लस्टर के आधार पर एक सत्य / मिथ्या मूल्य का उत्पादन करते हैं ।

यह कोड-गोल्फ है , इसलिए इसका उद्देश्य जितना संभव हो सके आपकी बाइट की संख्या को कम करना है। इस प्रकार, हर प्रोग्रामिंग भाषा में सबसे छोटा कोड जीत जाता है।

परीक्षण के मामले / उदाहरण

उदाहरण के लिए, 9 का मुख्य समूह है [7, 11], क्योंकि:

• 7 उच्चतम प्रधानता है जो कड़ाई से 9 से कम है , और
• 11 , 9 की तुलना में सबसे कम प्रधान सख्ती है ।

इसी प्रकार, 67 का प्रधान समूह है [61, 71](ध्यान दें कि 67 एक प्रधान है)।

सच्ची जोड़ी

8, 10
२०, २२
65, 65
73, 73
86, 84
326, 318
513, 518 है

झूठा जोड़ा

4, 5
६, 8
409, 401
348, 347
419, 418
311, 313
326, 305

Comments

क्या सत्य / मिथ्या मूल्यों के दो अलग-अलग मूल्य हैं या क्या कोई अपने प्रोग्राम के आउटपुट से एक सत्य / मिथ्या मूल्य और आउटपुट (संभावित रूप से असीम) कई अलग-अलग मानों की मैपिंग को परिभाषित कर सकता है?

— जोनाथन फ्रीच

@JonathanFrech ट्रू / फ़ैसली प्रति फ़ैसला-समस्या परिभाषा, ज़रूरी नहीं कि लगातार संगत हो, लेकिन डिस्टिक्ट और ट्रुथ / फाल्सी

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

Answer 1

जेली , 6 4 3 5 4 बाइट्स

rÆPE

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

यह काम किस प्रकार करता है

rÆPE    Main link. Arguments: N, M
r       Yield the range of integers between N and M, inclusive.
 ÆP     For each integer, yield 1 if it is prime, 0 otherwise.
   E    Yield 1 if all items are equal (none in the range were prime,
        or there's only one item).

काम करता है क्योंकि दो संख्याओं में अलग-अलग प्रधान समूह होते हैं यदि उनके बीच कोई प्राइम है, या तो संख्या स्वयं प्राइम है; जब तक दोनों संख्याएँ समान नहीं होती हैं, तब तक किसी भी स्थिति में Eरिटर्न 1(एकल-आइटम सरणी में सभी आइटम समान हैं)।

Comments

आपके कार्यक्रम स्रोत अनुकूल नहीं दिखते ...

— स्टेन स्ट्रम

Answer 2

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

{[eqv] @_».&{(($_...0),$_..*)».first(*.is-prime)}}

झसे आज़माओ

विस्तारित:

{  # bare block lambda with implicit slurpy input ｢@_｣

  [eqv]               # see if each sub list is equivalent

    @_».&{            # for each value in the input

      (

        ( $_ ... 0 ), # decreasing Seq
          $_ ..  *    # Range

      )».first(*.is-prime) # find the first prime from both the Seq and Range

    }
}

Answer 3

पायथन 3 , 103 95 91 बाइट्स

lambda*z:len({*z})<2or[1for i in range(min(z),max(z)+1)if all(i%k for k in range(2,i))]<[0]

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

Answer 4

रूबी , ₅₇ 54 बाइट्स

->n,m{[*n..m,*m..n].all?{|x|?1*x=~/^(11+)\1+$/}||n==m}

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

संबंधित प्रश्न के लिए मेरे उत्तर से भयानक रेगेक्स प्राइमलिटी टेस्ट का उपयोग करता है (जिसे मैं भूल गया था जब तक कि मैंने उस पर क्लिक नहीं किया) क्या यह संख्या एक प्रमुख है? । चूंकि हमारे पास N, M we 3 है, इसलिए 1 के लिए चेक को पैटर्न से हटाया जा सकता है, जिससे बाइट की गिनती बिल्ट-इन का उपयोग करने से कम होती है।

नोट: रेगेक्स प्राइमलिटी टेस्ट पैथोलॉजिकल रूप से, प्रफुल्लित रूप से अक्षम है। मेरा मानना ​​है कि यह कम से कम हे (एन!) है, हालांकि मेरे पास अभी इसे समझने का समय नहीं है। 100,001 की जांच करने में इसे बारह सेकंड का समय लगा, और इसे रद्द करने से पहले 1,000,001 पर पांच या दस मिनट के लिए पीस रहा था। अपने जोखिम पर उपयोग / दुरुपयोग।

Comments

उस दर पर यह संभावना है n²। तुम्हें पता है, 100001! = 2824257650254427477772164512240315763832679701040485762827423875723843380680572028502730496931545301922349718873479336571104510933085749261906300669827923360329777024436472705878118321875571799283167659071802605510878659379955675120386166847407407122463765792082065493877636247683663198828626954833262077780844919163487776145463353109634071852657157707925315037717734498612061347682956332369235999129371094504360348686870713719732258380465223614176068 ... (Warning: The output exceeded 128 KiB and was truncated.)जो मिलन को चलाने के लिए ले जाएगा।

— user202729

Answer 5

रेटिना , 58 बाइट्स

\b(.+)¶\1\b

.+
$*
O`
+`\b(1+)¶11\1
$1¶1$&
A`^(11+)\1+$
^$

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

\b(.+)¶\1\b

यदि दोनों इनपुट समान हैं, तो बस सब कुछ हटा दें, और अंत में आउटपुट 1 पर गिरें।

.+
$*

यूनीरी में बदलें।

O`

क्रम में क्रमबद्ध करें।

+`\b(1+)¶11\1
$1¶1$&

सभी नंबरों की एक सीमा तक विस्तार करें।

A`^(11+)\1+$

सभी समग्र संख्याओं को हटाएं।

^$

यदि कोई संख्या शेष नहीं है, तो आउटपुट 1, अन्यथा 0।

Answer 6

PARI / GP, 28 बाइट्स

v->s=Set(v);#s<2||!primes(s)

सभी परीक्षण मामलों के साथ इसे ऑनलाइन आज़माएं!

रिटर्न ( 0या 1सामान्य PARI / GP "बूलियन" मान)।

स्पष्टीकरण:

vदो नंबरों के साथ Nऔर Mनिर्देशांक के रूप में एक वेक्टर (या एक कॉलम वेक्टर, या एक सूची) होना चाहिए । उदाहरण के लिए [8, 10]। फिर sइन नंबरों से बना "सेट" होगा, जो या तो एक-समन्वित वेक्टर (यदि है N==M), या दो-समन्वित वेक्टर के साथ क्रमबद्ध प्रविष्टियों के साथ अन्यथा।

फिर यदि #sनिर्देशांक की संख्या sसिर्फ एक है, तो हम 1(सत्य) प्राप्त करते हैं । अन्यथा, primesसे बंद अंतराल में सभी अभाज्य संख्या का एक वेक्टर वापस आ जाएगी s[1]करने के लिए s[2]। निषेध !है कि दे देंगे 1अगर वेक्टर, खाली है, जबकि एक या अधिक गैर शून्य प्रविष्टियों (यहाँ एक या अधिक अभाज्य संख्या) का एक वेक्टर का निषेध दे देंगे 0।

Answer 7

जावास्क्रिप्ट (ईएस 6), 57 56 बाइट्स

करी सिंटैक्स में इनपुट लेता है (a)(b)। लौटाता है 0या 1।

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

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

let f =

a=>b=>a==b|!(g=k=>a%--k?g(k):k<2||a-b&&g(a+=a<b||-1))(a)

console.log('Truthy')
console.log(f(8)(10))
console.log(f(20)(22))
console.log(f(65)(65))
console.log(f(73)(73))
console.log(f(86)(84))
console.log(f(326)(318))
console.log(f(513)(518))

console.log('Falsy')
console.log(f(4)(5))
console.log(f(6)(8))
console.log(f(409)(401))
console.log(f(348)(347))
console.log(f(419)(418))
console.log(f(311)(313))

कैसे?

a => b =>                 // given a and b
  a == b |                // if a equals b, force success right away
  !(g = k =>              // g = recursive function taking k
    a % --k ?             //   decrement k; if k doesn't divide a:
      g(k)                //     recursive calls until it does
    :                     //   else:
      k < 2 ||            //     if k = 1: a is prime -> return true (failure)
      a - b &&            //     if a equals b: neither the original input integers nor
                          //     any integer between them are prime -> return 0 (success)
      g(a += a < b || -1) //     else: recursive call with a moving towards b
  )(a)                    // initial call to g()

Answer 8

आर , 63 46 बाइट्स

-17 Giuseppe द्वारा

function(a,b)!sd(range(numbers::isPrime(a:b)))

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

ETHProductions 'जेली समाधान के सुंदर सरल अनुप्रयोग । मुख्य दिलचस्प बात यह है कि आर बूलियन वैक्टर any(x)==all(x)के बराबर है min(x)==max(x)।

Comments

आर में गोल्फ के लिए यह टिप यहां लागू है; और TIO ने numbersइसके बजाय

— Giuseppe

साथ ही, चूंकि min(x)==max(x)यह जांचने के लिए बराबर है कि सभी तत्व is_prime(a:b)समान हैं, इसलिए हम इस अंतिम ट्रिक का उपयोग 46 बाइट्स के लिए primesया तो numbersपैकेज के साथ कर सकते हैं।

— ग्यूसेप

Answer 9

सी (जीसीसी), 153 146 बाइट्स

i,B;n(j){for(B=i=2;i<j;)B*=j%i++>0;return!B;}
#define g(l,m,o)for(l=o;n(--l););for(m=o;n(++m););
a;b;c;d;h(e,f){g(a,b,e)g(c,d,f)return!(a-c|b-d);}

-7 जोनाथन फ्रेच से

एक फ़ंक्शन को परिभाषित करता है hजो दो intएस में लेता है 1और 0सच्चाई के लिए और फ़ासी के लिए लौटता है

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

n एक ऐसा फंक्शन है जो 1 लौटाता है यदि उसका तर्क प्रधान नहीं है।

g एक मैक्रो है जो अपने पहले और दूसरे तर्कों को अगले प्राइम से कम (क्रमशः) की तुलना में कम और अधिक से अधिक सेट करता है

hकरता है gदोनों इनपुट और आउटपुट जाँच करता है कि एक ही हैं के लिए।

Comments

return a==c&&b==d;हो सकता है return!(a-c|b-d);।

— जोनाथन फ्रीच

146 बाइट्स ।

— जोनाथन फ्रीच

@JonathanFrech ने TIO लिंक को ठीक किया।

— pizzapants184

Answer 10

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

ÆpżÆnE

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

-2 धन्यवाद डेनिस ।

Answer 11

एपीएल (डायलॉग यूनिकोड) , 18 + 16 = 34 24 बाइट्स

⎕CY'dfns'
∧/=/4 ¯4∘.pco⎕

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

10 बाइट्स के लिए Adám को धन्यवाद ।

डिफ़ॉल्ट Dyalog APL इंस्टॉल के साथ शामिल dfns ( d ynamic f unctio ns ) संग्रह को आयात करने के लिए लाइन ⎕CY'dfns'( C OP Y ) की आवश्यकता होती है ।

यह काम किस प्रकार करता है:

∧/=/4 ¯4∘.pco⎕ ⍝ Main function. This is a tradfn body.
             ⎕ ⍝ The 'quad' takes the input (in this case, 2 integers separated by a comma.
          pco  ⍝ The 'p-colon' function, based on p: in J. Used to work with primes.
    4 ¯4∘.     ⍝ Applies 4pco (first prime greater than) and ¯4pco (first prime smaller than) to each argument.
  =/           ⍝ Compares the two items on each row
∧/             ⍝ Applies the logical AND between the results.
               ⍝ This yields 1 iff the prime clusters are equal.

Answer 12

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

lambda*v:v[0]==v[1]or{1}-{all(v%i for i in range(2,v))for v in range(min(v),max(v)+1)}

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

Comments

मुझे आपका सेट उपयोग पसंद है, भले ही इसके लिए 87 बाइट्स की आवश्यकता न हो ।

— जोनाथन फ्रीच

@

— जोनाथनफ्रेच

Answer 13

सी (जीसीसी) , 103 बाइट्स 100 बाइट्स

i,j,p,s;f(m,n){s=1;for(i=m>n?i=n,n=m,m=i:m;i<=n;i++,p?s=m==n:0)for(p=j=2;j<i;)p=i%j++?p:0;return s;}

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

Answer 14

हास्केल , 81 बाइट्स

एक सीधा समाधान:

p z=[x|x<-z,all((0/=).mod x)[2..x-1]]!!0
c x=(p[x-1,x-2..],p[x+1..])
x!y=c x==c y

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

Answer 15

गणितज्ञ, ३ ९ २ by २६ बाइट्स

Equal@@#~NextPrime~{-1,1}&

विस्तारित:

                         &  # pure function, takes 2-member list as input
       #~NextPrime~{-1,1}   # infix version of NextPrime[#,{-1,1}], which
                            # finds the upper and lower bounds of each
                              argument's prime clusters
Equal@@                     # are those bounds pairs equal?

उपयोग:

Equal@@#~NextPrime~{-1,1}& [{8, 10}]
(*  True  *)

Equal@@#~NextPrime~{-1,1}& [{6, 8}]
(*  False  *)

Equal@@#~NextPrime~{-1,1}& /@ {{8, 10}, {20, 22}, {65, 65}, 
    {73, 73}, {86, 84}, {326, 318}, {513, 518}}
(*  {True, True, True, True, True, True, True}  *)

Equal@@#~NextPrime~{-1,1}& /@ {{4, 5}, {6, 8}, {409, 401}, 
    {348, 347}, {419, 418}, {311, 313}}
(*  {False, False, False, False, False, False}  *)

योगदान: -12 बाइट्स जेनी_माथी द्वारा , मार्टिन एंडर द्वारा -1 बाइट

Comments

यह केवल अगले प्रधानमंत्री की जाँच करता है। NextPrime का प्रयास करें [#, {- 1,1}]

— J42161217

@ जेनी_मथी: मैं देख रहा हूं कि आप सही हैं। "348, 347" टेस्ट केस द्वारा पकड़ा गया, जिसे अब पास करने के लिए प्रदर्शित किया गया है।

— एरिक टॉवर्स

27 बाइट्स: Equal@@NextPrime[#,{-1,1}]&इनपुट के रूप में लेता है [{N,M}]या यदि आप मूल इनपुट इस 30 बाइट्स का उपयोग करना चाहते हैं:Equal@@NextPrime[{##},{-1,1}]&

— J42161217

@ जेनी_मैथी: ठीक है, ..., निर्दिष्ट इनपुट दो पूर्णांक है, सूची नहीं है, इसलिए ...

— एरिक टॉवर्स

@ एरिकटॉवर्स की सूची लेना ठीक है । इसके अलावा, आप infix संकेतन का उपयोग करके एक बाइट बचा सकते हैं #~NextPrime~{-1,1}।

— मार्टिन एंडर

Answer 16

जे , 15 बाइट्स

-:&(_4&p:,4&p:)

यह काम किस प्रकार करता है:

   &(           ) - applies the verb in the brackets to both arguments
            4&p:  - The smallest prime larger than y
      _4&p:       - The largest prime smaller than y
           ,      - append
 -:               - matches the pairs of the primes

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