บทนำ

สำหรับวัตถุประสงค์ของการท้าทายนี้เราจะกำหนดเพื่อนบ้านขององค์ประกอบในตารางเมทริกซ์ (เช่น ) เป็นรายการทั้งหมดของ ที่อยู่ติดกันในแนวทแยงมุมแนวนอนหรือแนวตั้งเป็น (เช่นพวกเขา"ล้อมรอบ"โดยไม่ต้องล้อมรอบ)A E = A i , j A $E$$A$$E=A_{i,j}$$A$$E$ $E$

สำหรับ pedants คำนิยามอย่างเป็นทางการของเพื่อนบ้านของสำหรับ matixคือ (ดัชนี 0): โดยที่ n×n N ฉัน$A_{i,\:j}$$n\times n$$A$E ฉัน

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

สมมติว่าองค์ประกอบที่ indexอาศัยอยู่ในความเป็นศัตรูถ้ามันเป็น 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$ที่แสดงถึงพื้นที่ใกล้เคียงที่เป็นมิตร

การใช้งานอ้างอิงใน Physica - รองรับไวยากรณ์Pythonและ I / O คุณสามารถนำเข้าและส่งออกผ่านวิธีการมาตรฐานและในรูปแบบที่เหมาะสมใด ๆ ในขณะที่ทราบว่าช่องโหว่เหล่านี้เป็นสิ่งต้องห้ามโดยค่าเริ่มต้น นี่คือโค้ดกอล์ฟดังนั้นโค้ดที่สั้นที่สุดเป็นไบต์ (ทุกภาษา) ชนะ!

ยิ่งกว่านั้นคุณสามารถใช้ขนาดเมทริกซ์เป็นอินพุตด้วยและสามารถใช้เมทริกซ์เป็นรายการแบบแบนได้เนื่องจากมันจะเป็นรูปสี่เหลี่ยมจัตุรัสเสมอ

ตัวอย่าง

พิจารณาเมทริกซ์ต่อไปนี้:

$$\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)]

APL (Dyalog)ขนาด 17 ไบต์

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

ลองออนไลน์! (เครดิตเป็น ngn สำหรับการแปลกรณีทดสอบเป็น APL)

คำอธิบายสั้น ๆ

(×/∘,↓)⌺3 3 รับผลิตภัณฑ์ของแต่ละองค์ประกอบกับเพื่อนบ้าน

จากนั้นฉันก็หารด้วยข้อโต้แย้ง÷⊢เพื่อให้แต่ละรายการในเมทริกซ์นั้นถูกแมปกับผลคูณของเพื่อนบ้าน

ในที่สุดฉันก็หาค่า gcd ของอาร์กิวเมนต์ด้วยเมทริกซ์นี้⊢∨และตรวจสอบความเท่าเทียมกับ 11=

หมายเหตุเช่นเดียวกับคำตอบของ ngnสิ่งนี้จะล้มเหลวสำหรับอินพุตบางอันเนื่องจากจุดบกพร่องในล่าม

JavaScript (ES6), 121 ไบต์

ส่งคืนเมทริกซ์ของค่าบูลีนโดยที่falseหมายถึงเป็นศัตรู

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)

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]

APL (Dyalog Classic) , 23 22 ไบต์

-1 ไบต์ต้องขอบคุณ @ H.PWiz

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

ลองออนไลน์!

ไม่รองรับเมทริกซ์ที่เล็กกว่า 3x3 เนื่องจากมีบั๊กในล่าม

เยลลี่ 24 ไบต์

^{อืมดูเหมือนยาว}

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

Monadic Link ยอมรับรายการของจำนวนเต็มบวกที่คืนค่ารายการของแต่ละค่าที่อยู่ในละแวกที่เป็นมิตร (รุ่น 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

Python 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

ลองออนไลน์!

แสดงรายการรายการที่มีรายการจริง / เท็จ

Haskell , 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; ก็จะส่งกลับรายการของรายการในความเป็นปรปักษ์