लोनली प्रिम्स खोजना

Question

लोनली प्राइम्स (जैसा कि मैं उन्हें कॉल करता हूं) वे प्राइम हैं, जहां चौड़ाई के साथ एक नंबर ग्रिड दिया जाता है w ≥ 3, ऐसे प्राइम हैं, जिनके पास orthogonally या तिरछे से सटे कोई अन्य प्राइम नहीं हैं।

उदाहरण के लिए, यदि हम इस ग्रिड को लेते हैं जहाँ w = 12(primes हाइलाइट किया गया है):

1   2   3   4   5   6   7   8   9   10  11  12
13  14  15  16  17  18  19  20  21  22  23...
 ...86  87  88  89  90  91  92  93  94  95  96
97  98  99  100 101 102 103 104 105 106 107 108
109 110 111 112 113 114 115 116 117 118 119 120

आप देख सकते हैं कि केवल दो primes 103 और 107 में कोई प्रथमिक रूप से या तिरछे सहायक के रूप में नहीं है। मैं एक खंड पर छोड़ दिया है क्योंकि वहाँ कोई अकेला primes है। (37 को छोड़कर, वास्तव में)

आपका कार्य दो इनपुट दिए गए हैं w ≥ 3और i ≥ 1, चौड़ाई के साथ एक संख्या ग्रिड में पहला अकेला प्राइम निर्धारित करें w, जहां कहा गया है कि अकेला प्राइम से अधिक या इसके बराबर होना चाहिए i। इनपुट को किसी भी उचित प्रारूप में लिया जा सकता है (उन्हें स्ट्रिंग्स के रूप में लेने सहित)। यह गारंटी है कि चौड़ाई के लिए एक अकेला प्रमुख होगा w।

ग्रिड चारों ओर लपेट नहीं करता है।

उदाहरण:

w  i   output
11 5   11
12 104 107
12 157 157
9  1   151
12 12  37

जैसा कि यह कोड-गोल्फ है , सबसे छोटा कोड जीतता है!

Comments

अकेला प्रधान क्यों w=12नहीं 37है? इसके आसपास की संख्या में से कोई भी - {25, 26, 38, 49, 50}- प्रमुख हैं।

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

@JonathanFrech हाँ, एक परीक्षण के मामले में यह भी शामिल है।

— 15

Answer 1

सी (जीसीसी) , 159 158 149 बाइट्स

• एक बाइट को xanoetux के लिए धन्यवाद सहेजा गया ; एक newline वर्ण हटा रहा है।
• सेविंग के लिए नौ बाइट्स का धन्यवाद ; एक ब्रेक की हालत में गोल्फ।

P(n,d,b){for(d=b=1<n;n>++d;)b*=n%d>0;n=b;}F(w,i){w=P(i)&!(P(i-w)|P(i+w)|i%w>1&(P(~-i)|P(i+~w)|P(i+~-w))|i%w>0&(P(-~i)|P(-~i-w)|P(i-~w)))?i:F(w,++i);}

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

Comments

आप नई बाइट को छोड़ कर एक बाइट बचा सकते हैं। इसे ऑनलाइन आज़माएं!

— xanoetux

@ceilingcat ठीक सुझाव, धन्यवाद।

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

Answer 2

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

करी सिंटैक्स में इनपुट लेता है (w)(i)।

w=>g=i=>!(C=(k,n=d=i+k)=>n>0?n%--d?C(k,n):d>1:1)(0)&[i,x=1,i-1].every(j=>C(x-w)&C(w+x--)|j%w<1)?i:g(i+1)

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

let f =

w=>g=i=>!(C=(k,n=d=i+k)=>n>0?n%--d?C(k,n):d>1:1)(0)&[i,x=1,i-1].every(j=>C(x-w)&C(w+x--)|j%w<1)?i:g(i+1)

console.log(f(11)(  5)) // 11
console.log(f(12)(104)) // 107
console.log(f(12)(157)) // 157
console.log(f( 9)(  1)) // 151
console.log(f(12)( 12)) // 37

टिप्पणी की गई

w =>                    // main function, taking w
  g = i =>              // g = recursive function, taking i
    !(                  //
      C = (             // define C:
        k,              //   a function taking an offset k
        n = d = i + k   //   and using n and d, initialized to i + k
      ) =>              //
        n > 0 ?         //   if n is strictly positive:
          n % --d ?     //     decrement d; if d does not divide n:
            C(k, n)     //       do a recursive call
          :             //     else:
            d > 1       //       return true if d > 1 (i.e. n is composite)
        :               //   else:
          1             //     return true (n is beyond the top of the grid)
    )(0) &              // !C(0) tests whether i is prime (or equal to 1, but this is safe)
    [                   // we now need to test the adjacent cells:
      i,                //   right side: i MOD w must not be equal to 0
      x = 1,            //   middle    : always tested (1 MOD w is never equal to 0)
      i - 1             //   left side : (i - 1) MOD w must not be equal to 0
    ]                   // for each value j defined above,
    .every(j =>         // and for x = 1, 0 and -1 respectively:
      C(x - w) &        //   test whether i - w + x is composite
      C(w + x--) |      //            and i + w + x is composite
      j % w < 1         //   or j MOD w equals 0, so that the above result is ignored
    ) ?                 // if all tests pass:
      i                 //   return i
    :                   // else:
      g(i + 1)          //   try again with i + 1

Answer 3

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

f=lambda w,i,p=lambda n:all(n%j for j in range(2,n))*(n>1):i*(any(map(p,~-i%w*(i+~w,i-1,i+w-1)+(i-w,i+w)+i%w*(i-w+1,i+1,i-~w)))<p(i))or f(w,i+1)

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

क्रम में तर्क: w, i।

यहां कोई बाहरी मॉड्यूल का उपयोग नहीं किया गया है।

पायथन 2 + सिम्पी, 127 बाइट्स

import sympy
f=lambda w,i,p=sympy.isprime:i*(any(map(p,~-i%w*(i+~w,i-1,i+w-1)+(i-w,i+w)+i%w*(i-w+1,i+1,i-~w)))<p(i))or f(w,i+1)

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

एक अलग पद के योग्य नहीं है, क्योंकि यहां एकमात्र अंतर यह है कि यह sympy.isprimeमैन्युअल रूप से कार्यान्वित प्राइम चेक फ़ंक्शन के बजाय उपयोग करता है।

Answer 4

MATL , 38 बाइट्स

xx`@1G*:5MeZpt3Y6Z+>3LZ)ft2G<~)X<a~}2M

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

व्याख्या

कोड में अनिवार्य रूप से एक लूप होता है जो प्रत्येक पुनरावृत्ति में एक पंक्ति द्वारा चुनौती में वर्णित ग्रिड को बढ़ाता रहता है।

प्रत्येक पुनरावृत्ति पर ग्रिड बनाने के बाद, अंतिम पंक्ति को हटा दिया जाता है (हम यह नहीं जान सकते हैं कि वे प्राइमर एकाकी हैं या नहीं) और शेष नंबरों को देखने के लिए परीक्षण किया जाता है कि कम से कम एक अकेला प्राइम मौजूद है या नहीं। यह 2D कनवल्शन के माध्यम से किया जाता है।

अगर कुछ अकेला प्राइम है तो हम लूप से बाहर निकलते हैं और पहले ऐसे प्राइम को आउटपुट करते हैं। एसे हम अगले पुनरावृत्ति के साथ आगे बढ़ते हैं, जो एक बड़ी ग्रिड की कोशिश करेगा।

(कोड वास्तव में ग्रिड के एक ट्रांसपोज्ड संस्करण का उपयोग करता है, जो पंक्तियों के बजाय स्तंभों द्वारा बढ़ाई गई है।)

xx        % Take two inputs (implicit): w, i. Delete them. They get copied
          % into clipboard G
`         % Do...while
  @       %   Push iteration index (1-based)
  1G      %   Push w
  *       %   Multiply
  :       %   Range from 1 to that
  5M      %   Push w again (from automatic clipboard M)
  e       %   Reshape into a matrix with w rows in column-major order
  Zp      %   Is prime? Element-wise
  t       %   Duplicate
  3Y6     %   Push neighbour mask: [1 1 1; 1 0 1; 1 1 1]
  Z+      %   2D convolution, maintaining size
  >       %   Greater than? Element-wise. Gives true for lonely primes
  3LZ)    %   Remove the last column
  f       %   Find linear indices of nonzeros
  t       %   Duplicate
  2G      %   Push i
  <~      %   Not less than?
  )       %   Use as logical index: this removes lonle primes less than i
  X<      %   Minimum. This gives either empty or a nonzero value
  a~      %   True if empty, false if nonzero. This is the loop condition.
          %   Thus the loop proceeds if no lonely prime was found
}         % Finally (execute on loop exit)
  2M      %   Push the first found lonely prime again
          % End (implicit). Display (implicit)

Answer 5

जूलिया 0.6, 135 बाइट्स

using Primes
f(w,i,p=isprime)=findfirst(j->(a=max(j-1,0);b=min(j+1,w);c=a:b;!any(p,v for v=[c;c+w;c-w]if v>0&&v!=j)&&p(j)&&j>=i),1:w*w)

टीआईओ के पास Primesपैकेज नहीं है । यह 5 बाइट्स छोटा है अगर मुझे सभी एकाकी अपराधों को वापस करने की अनुमति है ( findfirstहो जाता है find)। जूलिया की कार्यक्षमता को बाहर निकालने का प्रयास Baseगोल्फिंग को नुकसान पहुंचा रहा है (जूलिया का लक्ष्य नहीं), Primes0.4 में शामिल किया गया था।

अघोषित (अधिकतर)

function g(w,i)
    for j=i:w*w
        a,b=max(j-1,0),min(j+1,w)
        c=a:b
        !any(isprime,v for v=[c;c+w;c-w]if v>0&&v!=j)&&isprime(j)&&return j
    end
end

Answer 6

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

+‘ÆRœ^ḷ,ḷ’dạ/Ṁ€ṂḊð1#

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

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

+‘ÆRœ^ḷ,ḷ’dạ/Ṁ€ṂḊð1#  Main link. Left argument: i. Right argument: w.

                 ð    Combine the links to the left into a chain and begin a new,
                      dyadic chain with arguments i and w.
                  1#  Call the chain to the left with left argument n = i, i+1, ...
                      and right argument w until 1 of them returns a truthy value.
                      Return the match.
+                       Yield n+w.
 ‘                      Increment, yielding n+w+1.
  ÆR                    Yield all primes in [1, ..., n+w+1].
      ḷ                 Left; yield n.
    œ^                  Multiset OR; if n belongs to the prime range, remove it; if
                        it does not, append it.
       ,ḷ               Wrap the resulting array and n into a pair.
         ’              Decrement all involved integers.
          d             Divmod; map each integer k to [k/w, k%w].
           ạ/           Reduce by absolute difference, subtracting [n/w, n%w] from
                        each [k/w, k%w] and taking absolute values.
             Ṁ€         Take the maximum of each resulting pair.
                        A maximum of 0 means that n is not prime.
                        A maximum of 1 means that n has a prime neighbor.
               Ṃ        Take the minimum of the maxima.
                Ḋ       Dequeue; map the minimum m to [2, ..., m].
                        This array is non-empty/truthy iff m > 1.

Answer 7

पर्ल 6 , 113 104 बाइट्स

->\w,\i{first {is-prime $_&none $_ «+«flat -w,w,(-w-1,-1,w-1)xx!($_%w==1),(1-w,1,w+1)xx!($_%%w)},i..*}

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

Answer 8

क्लीन , 181 ... 145 बाइट्स

import StdEnv
@w i=hd[x+y\\y<-[0,w..],x<-[1..w]|x+y>=i&&[x+y]==[a+b\\a<-[y-w,y,y+w]|a>=0,b<-[x-1..x+1]|0<b&&b<w&&all((<)0o(rem)(a+b))[2..a+b-1]]]

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

Ungolfed:

@ w i
    = hd [
        x+y
        \\ y <- [0, w..]
        ,  x <- [1..w]
        | x+y >= i && [x+y] == [
            a+b
            \\ a <- [y-w, y, y+w]
            | a >= 0
            ,  b <- [x-1..x+1]
            | 0 < b && b < w && all ((<) 0 o (rem) (a+b)) [2..a+b-1]
            ]
        ]

Answer 9

जेली ,  30  29 बाइट्स

_{मेरा अनुमान है कि यह संभवत: उचित अंतर से हराया जा सकता है}

ÆPŒR+€×¥+©⁸’:⁹Ġ®ṁLÞṪFÆPS’¬ð1#

iबाईं wओर दाईं ओर ले जाने वाला एक डाइएडिक लिंक जो एकाकी प्रधानमंत्री को लौटाता है।

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

कैसे?

ÆPŒR+€×¥+©⁸’:⁹Ġ®ṁLÞṪFÆPS’¬ð1# - Link: i, w                     e.g. 37, 12
                           1# - find the 1st match starting at i and counting up of...
                          ð   - ...everything to the left as a dyadic link
                              - (n = i+0; i+1; ... on the left and w on the right):
ÆP                            -   is i prime: 1 if so, 0 if not     1
  ŒR                          -   absolute range: [-1,0,1] or [0]   [-1,0,1]
       ¥                      -   last two links as a dyad (w on the right):
      ×                       -     multiply (vectorises)           [-12,0,12]
    +€                        -     add for €ach       [[-13,-1,11],[-12,0,12],[-11,1,13]]
                              -     - i.e. the offsets if including wrapping
          ⁸                   -   chain's left argument, i
        +                     -   add                  [[24,36,48],[25,37,49],[26,38,50]]
                              -     - i.e. the adjacents if including wrapping
         ©                    -   copy to the register
           ’                  -   decrement            [[23,35,47],[24,36,48],[25,37,49]]
             ⁹                -   chain's right argument, w
            :                 -   integer division               [[1,2,3],[2,3,4],[2,3,4]]
              Ġ               -   group indices by value         [[1],[2,3]]
                              -     - for a prime at the right this would  be [[1,2],[3]]
                              -     - for a prime not at an edge it would be [[1,2,3]]
               ®              -   recall from register [[24,36,48],[25,37,49],[26,38,50]]
                ṁ             -   mould like           [[24,36,48],[[25,37,49],[26,38,50]]]
                  Þ           -   sort by:
                 L            -     length             [[24,36,48],[[25,37,49],[26,38,50]]]
                   Ṫ          -   tail                             [[25,37,49],[26,38,50]]
                              -     - i.e the adjacents now excluding wrapping
                    F         -   flatten                          [25,37,49,26,38,50]
                     ÆP       -   is prime? (vectorises)           [0,1,0,0,0,0]
                       S      -   sum                              1
                        ’     -   decrement                        0
                         ¬    -   not                              1            

Comments

मेरा अनुमान है कि यह शायद एक उचित अंतर से हरा देने योग्य है क्या आप सुनिश्चित हैं? यह गोल्फ भाषाओं के लिए एक आसान बात नहीं है।

— 19

नहीं, लेकिन यह मेरा अनुमान है कि जेली में (यहां तक ​​कि) (यदि भूसी नहीं है!) कि मेरी विधि को बचाने के लिए कुछ तरीके हो सकते हैं, या एक बेहतर तरीका भी हो सकता है।

— जोनाथन एलन

Answer 10

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

w->i->{for(;;i++)if(p(i)&!(p(i-w)|p(i+w)|i%w>1&(p(i-1)|p(i+~w)|p(i+w-1))|i%w>0&(p(i+1)|p(i+1-w)|p(i-~w))))return i;}boolean p(int n){for(int i=2;i<n;n=n%i++<1?0:n);return n>1;}

पोर्ट ऑफ जोनाथन फ्रेच सी उत्तर ।

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