परिचय

इस चुनौती के प्रयोजनों के लिए, हम एक वर्ग मैट्रिक्स (जैसे कि ) में तत्व के पड़ोसियों को परिभाषित करेंगे क्योंकि की सभी प्रविष्टियाँ तुरंत आसन्न तिरछे, क्षैतिज या अनुलंब रूप से (यानी वे "चारों ओर" , चारों ओर लपेटे बिना)। $E$ $A$ $E=A_{i,j}$ $A$ $E$ $E$

पेडेंट के लिए, के पड़ोसियों की एक औपचारिक परिभाषा एक के लिएmatixहै (0 अनुक्रमित): $A_{i,\:j}$ $n\times n$ $A$ जहां

{एन}_{मैं, जे} = {ए_{ए, ख} | (ए, ख) \in इ_{मैं, जे} \cap ([0, n) \cap जेड)^{2}}

$N_{i,\:j}=\{A_{a,\:b}\mid(a,b)\in E_{i,\:j}\:\cap\:([0,\:n)\:\cap\:\Bbb{Z})^2\}$

इ_{मैं, जे} = {मैं - 1, मैं, मैं + 1} \times {जे - 1, जे, जे + 1} \ {मैं, जे}

$E_{i,\:j}=\{i-1,\:i,\:i+1\}\times \{j-1,\:j,\:j+1\} \text{ \\ } \{i,\:j\}$

मान लीजिए कि सूचकांक में तत्व है दुश्मनी में रहती है अगर यह coprime हैसबअपने पड़ोसियों (यह है कि, $i,\:j$ )। अफसोस की बात है कि यह खराब प्रविष्टि अपने आस-पास के निवासियों से चीनी का एक कप भी उधार नहीं ले सकती ... $\gcd(A_{i,\:j},\:n)=1\:\forall\:n\in N_{i,\:j}$

कार्य

पर्याप्त कहानियां: सकारात्मक पूर्णांक के वर्ग मैट्रिक्स को देखते हुए , निम्न में से एक आउटपुट: $M$

तत्वों का एक फ्लैट सूची (deduplicated या नहीं) सभी प्रविष्टियों कि कुछ सूचकांकों पर कब्जा का संकेत में ऐसी है कि पड़ोसियों $i,j$ $M$ शत्रुतापूर्ण हैं। $N_{i,\:j}$
एक बूलियन मैट्रिक्स जिसमें एस पदों पर है जहां पड़ोसी शत्रुतापूर्ण और अन्यथा (आप और स्थान पर किसी भी अन्य सुसंगत मूल्यों को चुन सकते हैं )। $1$ $0$ $0$ $1$
सूचकांकों के जोड़े की सूची कि शत्रुतापूर्ण पड़ोस का प्रतिनिधित्व करते हैं। $i,\:j$

भौतिकी में संदर्भ कार्यान्वयन - पायथन सिंटैक्स के साथ-साथ I / O के लिए भी समर्थन करता है । आप इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से और किसी भी उचित प्रारूप में आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। यह कोड-गोल्फ है, इसलिए बाइट्स में (हर भाषा में) सबसे छोटा कोड जीतता है!

इसके अलावा, आप मैट्रिक्स का आकार इनपुट के रूप में भी ले सकते हैं और इसके अलावा मैट्रिक्स को एक फ्लैट सूची के रूप में ले सकते हैं क्योंकि यह हमेशा चौकोर होगा।

उदाहरण

निम्नलिखित मैट्रिक्स पर विचार करें:

(\begin{matrix} 64 & 10 & 14 \\ 27 & 22 & 32 \\ 53 & 58 & 36 \end{matrix})

$\left(\begin{matrix} 64 & 10 & 14 \\ 27 & 22 & 32 \\ 53 & 58 & 36 \\ \end{matrix}\right)$

प्रत्येक तत्व के संबंधित पड़ोसी हैं:

i j – E  -> Neighbours                          | All coprime to E?
                                                |
0 0 – 64 -> {10; 27; 22}                        | False
0 1 – 10 -> {64; 14; 27; 22; 32}                | False
0 2 – 14 -> {10; 22; 32}                        | False
1 0 – 27 -> {64; 10; 22; 53; 58}                | True
1 1 – 22 -> {64; 10; 14; 27; 32; 53; 58; 36}    | False
1 2 – 32 -> {10; 14; 22; 58; 36}                | False
2 0 – 53 -> {27; 22; 58}                        | True
2 1 – 58 -> {27; 22; 32; 53; 36}                | False
2 2 – 36 -> {22; 32; 58}                        | False

और इस प्रकार आउटपुट निम्नलिखित में से एक होना चाहिए:

{27; 53}
{{0; 0; 0}; {1; 0; 0}; {1; 0; 0}}
{(1; 0); (2; 0)}

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

Input –> Version 1 | Version 2 | Version 3

[[36, 94], [24, 69]] ->
    []
    [[0, 0], [0, 0]]
    []
[[38, 77, 11], [17, 51, 32], [66, 78, 19]] –>
    [38, 19]
    [[1, 0, 0], [0, 0, 0], [0, 0, 1]]
    [(0, 0), (2, 2)]
[[64, 10, 14], [27, 22, 32], [53, 58, 36]] ->
    [27, 53]
    [[0, 0, 0], [1, 0, 0], [1, 0, 0]]
    [(1, 0), (2, 0)]
[[9, 9, 9], [9, 3, 9], [9, 9, 9]] ->
    []
    [[0, 0, 0], [0, 0, 0], [0, 0, 0]]
    []
[[1, 1, 1], [1, 1, 1], [1, 1, 1]] ->
    [1, 1, 1, 1, 1, 1, 1, 1, 1] or [1]
    [[1, 1, 1], [1, 1, 1], [1, 1, 1]]
    [(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]
[[35, 85, 30, 71], [10, 54, 55, 73], [80, 78, 47, 2], [33, 68, 62, 29]] ->
    [71, 73, 47, 29]
    [[0, 0, 0, 1], [0, 0, 0, 1], [0, 0, 1, 0], [0, 0, 0, 1]]
    [(0, 3), (1, 3), (2, 2), (3, 3)]

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

शत्रुतापूर्ण पड़ोसियों से उधार सामान? किसी कारण के लिए, यह जेफ गढ़नेवाला के खेल की मुझे याद दिलाता है होवर Bovver ...

— Arnauld

क्या हम मैट्रिक्स के आकार को इनपुट के रूप में ले सकते हैं?

— Delfad0r

@ Delfad0r मैं हमेशा इसका उल्लेख करना भूल जाता हूं। हां, आप इनपुट के रूप में मैट्रिक्स का आकार ले सकते हैं।

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

3

एपीएल (डायलॉग) , 17 बाइट्स

1=⊢∨(×/∘,↓)⌺3 3÷⊢

इसे ऑनलाइन आज़माएं! (परीक्षण मामलों को एपीएल में अनुवाद करने के लिए उदासीनता का श्रेय)

संक्षिप्त विवरण

(×/∘,↓)⌺3 3 अपने पड़ोसियों के साथ प्रत्येक तत्व का उत्पाद प्राप्त करता है।

फिर मैं तर्क से विभाजित करता हूं ÷⊢, ताकि मैट्रिक्स में प्रत्येक प्रविष्टि को उसके पड़ोसियों के उत्पाद में मैप किया गया हो।

अंत में मैं इस मैट्रिक्स के साथ तर्क के gcd ले ⊢∨, और 1 के साथ समानता के लिए जाँच करें,1=

नोट, ngn के जवाब के साथ के रूप में , यह दुभाषिया में एक बग के कारण कुछ इनपुट के लिए विफल रहता है।

— H.PWiz
स्रोत

2

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

बूलियन मूल्यों का एक मैट्रिक्स लौटाता है, जहां झूठ का अर्थ शत्रुतापूर्ण है।

m=>m.map((r,y)=>r.map((v,x)=>[...'12221000'].some((k,j,a)=>(g=(a,b)=>b?g(b,a%b):a>1)(v,(m[y+~-k]||0)[x+~-a[j+2&7]]||1))))

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

कैसे?

प्रत्येक सेल के 8 पड़ोसियों को अलग करने के लिए उपयोग की जाने वाली विधि मेरे द्वारा यहां वर्णित के समान है ।

टिप्पणी की गई

m =>                            // m[] = input matrix
  m.map((r, y) =>               // for each row r[] at position y in m[]:
    r.map((v, x) =>             //   for each value v at position x in r[]:
      [...'12221000']           //     we consider all 8 neighbors
      .some((k, j, a) =>        //     for each k at position j in this array a[]:
        ( g = (a, b) =>         //       g is a function which takes 2 integers a and b
            b ?                 //       and recursively determines whether they are
              g(b, a % b)       //       coprime to each other
            :                   //       (returns false if they are, true if they're not)
              a > 1             //
        )(                      //       initial call to g() with:
          v,                    //         the value of the current cell
          (m[y + ~-k] || 0)     //         and the value of the current neighbor
          [x + ~-a[j + 2 & 7]]  //
          || 1                  //         or 1 if this neighbor is undefined
  ))))                          //         (to make sure it's coprime with v)

— Arnauld
स्रोत

2

MATL , 22 बाइट्स

tTT1&Ya3thYC5&Y)Zd1=A)

इनपुट एक मैट्रिक्स है। शत्रुतापूर्ण पड़ोसियों के साथ आउटपुट सभी संख्याएं हैं।

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

काम के उदाहरण के साथ स्पष्टीकरण

[38, 77, 11; 17, 51, 32; 66, 78, 19]उदाहरण के रूप में इनपुट पर विचार करें । स्टैक सामग्री को नीचे से ऊपर तक दिखाया गया है।

t         % Implicit input. Duplicate
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
TT1&Ya    % Pad in the two dimensions with value 1 and width 1
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1,  1,  1,  1,  1;
                    1,  38, 77, 11, 1;
                    1,  17, 51, 32, 1;
                    1,  66, 78, 19, 1
                    1,  1,  1,  1,  1]
3thYC     % Convert each sliding 3×3 block into a column (in column-major order)
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [ 1,  1,  1,  1, 38, 17,  1, 77, 51;
                     1,  1,  1, 38, 17, 66, 77, 51, 78;
                     1,  1,  1, 17, 66,  1, 51, 78,  1;
                     1, 38, 17,  1, 77, 51,  1, 11, 32;
                    38, 17, 66, 77, 51, 78, 11, 32, 19;
                    17, 66,  1, 51, 78,  1, 32, 19,  1;
                     1, 77, 51,  1, 11, 32,  1,  1,  1;
                    77, 51, 78, 11, 32, 19,  1,  1,  1;
                    51, 78,  1, 32, 19,  1,  1,  1,  1]
5&Y)      % Push 5th row (centers of the 3×3 blocks) and then the rest of the matrix
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [38, 17, 66, 77, 51, 78, 11, 32, 19]
                   [ 1,  1,  1,  1, 38, 17,  1, 77, 51;
                     1,  1,  1, 38, 17, 66, 77, 51, 78;
                     1,  1,  1, 17, 66,  1, 51, 78,  1;
                     1, 38, 17,  1, 77, 51,  1, 11, 32;
                    17, 66,  1, 51, 78,  1, 32, 19,  1;
                     1, 77, 51,  1, 11, 32,  1,  1,  1;
                    77, 51, 78, 11, 32, 19,  1,  1,  1;
                    51, 78,  1, 32, 19,  1,  1,  1,  1]
Zd        % Greatest common divisor, element-wise with broadcast
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1,  1,  1,  1,  1,  1,  1,  1,  1;
                    1,  1,  1,  1, 17,  6, 11,  1,  1;
                    1,  1,  1,  1,  3,  1,  1,  2,  1;
                    1,  1,  1,  1,  1,  3,  1,  1,  1;
                    1,  1,  1,  1,  3,  1,  1,  1,  1;
                    1,  1,  3,  1,  1,  2,  1,  1,  1;
                    1, 17,  6, 11,  1,  1,  1,  1,  1;
                    1,  1,  1,  1,  1,  1,  1,  1,  1]
1=        % Compare with 1, element-wise. Gives true (1) or false (0)
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1, 1, 1, 1, 1, 1, 1, 1, 1;
                    1, 1, 1, 1, 0, 0, 0, 1, 1;
                    1, 1, 1, 1, 0, 1, 1, 0, 1;
                    1, 1, 1, 1, 1, 0, 1, 1, 1;
                    1, 1, 1, 1, 0, 1, 1, 1, 1;
                    1, 1, 0, 1, 1, 0, 1, 1, 1;
                    1, 0, 0, 0, 1, 1, 1, 1, 1;
                    1, 1, 1, 1, 1, 1, 1, 1, 1]
A         % All: true (1) for columns that do not contain 0
          % STACK: [38, 77, 11;
                    17, 51, 32;
                    66, 78, 19]
                   [1, 0, 0, 0, 0, 0, 0, 0, 1]
)         % Index (the matrix is read in column-major order). Implicit display
          % [38, 19]

— लुइस मेंडो
स्रोत

यदि मैट्रिक्स 3x3 से बड़ा है तो क्या यह काम करेगा?

— रॉबर्ट फ्रेजर

@RobertFraser हां, प्रक्रिया मैट्रिक्स आकार पर निर्भर नहीं करती है। उदाहरण के लिए अंतिम परीक्षण का मामला देखें

— लुइस मेंडो

1

एपीएल (डायलॉग क्लासिक) , 23 22 बाइट्स

-1 बाइट @ H.PWiz को धन्यवाद

{∧/1=1↓∨∘⊃⍨1⌈4⌽,⍵}⌺3 3

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

दुभाषिया में बग के कारण 3x3 से छोटे मेट्रिक्स का समर्थन नहीं करता है

— NGN
स्रोत

@ H.PWiz यह बहुत स्मार्ट है, क्या आप इसे अपने रूप में पोस्ट करना चाहते हैं?

— ngn 16'18

ज़रूर, आप भी इस्तेमाल कर सकते हैं (⊃∨⊢)-> ∨∘⊂⍨मुझे लगता है

— H.PWiz

1

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

^{हम्म, लंबा लगता है।}

ỊẠ€T
ŒJ_€`Ç€ḟ"J$ịFg"FÇịF

एक सकारात्मक लिंक जो सकारात्मक पूर्णांकों की सूची की एक सूची को स्वीकार करता है, जो उन प्रत्येक मूल्यों की सूची देता है जो शत्रुतापूर्ण पड़ोस में हैं (संस्करण 1 जिसमें कोई दोहराव नहीं है)।

इसे ऑनलाइन आज़माएं! या एक परीक्षण-सूट देखें ।

कैसे?

ỊẠ€T - Link 1: indices of items which only contain "insignificant" values: list of lists
Ị    - insignificant (vectorises) -- 1 if (-1<=value<=1) else 0 
  €  - for €ach:
 Ạ   -   all?
   T - truthy indices

ŒJ_€`Ç€ḟ"J$ịFg"FÇịF - Main Link: list of lists of positive integers, M
ŒJ                  - multi-dimensional indices
    `               - use as right argument as well as left...
   €                -   for €ach:
  _                 -     subtract (vectorises)
      €             - for €ach:
     Ç              -   call last Link (1) as a monad
          $         - last two links as a monad:
         J          -   range of length -> [1,2,3,...,n(elements)]
        "           -   zip with:
       ḟ            -     filter discard (remove the index of the item itself)
            F       - flatten M
           ị        - index into (vectorises) -- getting a list of lists of neighbours
               F    - flatten M
              "     - zip with:
             g      -   greatest common divisor
                Ç   - call last Link (1) as a monad
                  F - flatten M
                 ị  - index into

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

1

पायथन 2 , 182 177 166 बाइट्स

lambda a:[[all(gcd(t,a[i+v][j+h])<2for h in[-1,0,1]for v in[-1,0,1]if(h|v)*(i+v>-1<j+h<len(a)>i+v))for j,t in E(s)]for i,s in E(a)]
from fractions import*
E=enumerate

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

ट्रू / गलत प्रविष्टियों के साथ सूचियों की सूची को आउटपुट करता है।

— चास ब्राउन
स्रोत

1

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

m?n|l<-[0..n-1]=[a|i<-l,j<-l,a<-[m!!i!!j],2>sum[1|u<-l,v<-l,(i-u)^2+(j-v)^2<4,gcd(m!!u!!v)a>1]]

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

फ़ंक्शन ?मैट्रिक्स mको सूचियों की सूची और मैट्रिक्स आकार के रूप में लेता है n; यह शत्रुता में प्रविष्टियों की सूची लौटाता है ।

— Delfad0r
स्रोत

किसके पड़ोसी शत्रुतापूर्ण हैं?

परिचय

कार्य

उदाहरण

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

एपीएल (डायलॉग) , 17 बाइट्स

संक्षिप्त विवरण

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

कैसे?

टिप्पणी की गई

MATL , 22 बाइट्स

काम के उदाहरण के साथ स्पष्टीकरण

एपीएल (डायलॉग क्लासिक) , 23 22 बाइट्स

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

कैसे?

पायथन 2 , 182 177 166 बाइट्स

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