소개

이러한 과제의 목적을 위해, 우리는 정의 할 이웃 하는 소자의 $E$ 정사각형 행렬에 (되도록 )의 엔트리 모두 같은 수평 또는 수직 대각선 바로 인접 (즉, 그들은 감싸지 않고 "서라운드" ). $A$ $E=A_{i,j}$ $A$ $E$ $E$

어린이의 경우 이웃에 대한 공식적인 정의 $A_{i,\:j}$ 위해 $n\times n$ MATIX $A$ (0 인덱스)이다 :

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

$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} \ {i, j}

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

하자 말 그 인덱스에있는 요소 $i,\:j$ $\gcd(A_{i,\:j},\:n)=1\:\forall\:n\in N_{i,\:j}$

직무

충분한 이야기 : 양의 정수로 구성된 정사각 행렬 이 주어지면 다음 중 하나를 출력하십시오. $M$

이웃 가 적대적 있도록 에서 일부 인덱스 를 차지하는 모든 항목을 나타내는 요소의 중복 된 목록 (중복되거나 축소되지 않은) . $i,j$ $M$ $N_{i,\:j}$
이웃이 적대적인 위치에 이 있고 그렇지 않으면 이 있는 부울 행렬입니다 ( 과 대신 다른 일관된 값을 선택할 수 있음 ). $1$ $0$ $0$ $1$
적대적인 이웃을 나타내는 인덱스 쌍 의 목록 . $i,\:j$

Physica의 참조 구현 – I / O에 대한 Python 구문도 지원합니다 . 이러한 허점 은 기본적으로 금지되어 있음을 유의하면서 모든 표준 방법 과 합리적인 형식으로 입력하고 출력 할 수 있습니다 . 이것은 코드 골프이므로 모든 언어에서 가장 짧은 바이트 코드가 이깁니다!

또한 행렬 크기를 입력으로 사용할 수도 있고 행렬이 항상 정사각형이므로 평면 목록으로 추가 할 수도 있습니다.

예

다음 매트릭스를 고려하십시오.

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

— 미스터 Xcoder
소스

적대적인 이웃으로부터 물건을 빌리십니까? 어떤 이유로, 이것은 나에게 Jeff Minter의 게임 호버 Bovver를 생각 나게합니다 ...

— Arnauld

행렬 크기를 입력으로 사용할 수 있습니까?

— Delfad0r

@ Delfad0r 항상 언급하는 것을 잊어 버렸습니다. 예, 행렬 크기를 입력으로 사용할 수 있습니다.

— Mr. Xcoder

3

APL (Dyalog) , 17 바이트

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

온라인으로 사용해보십시오! (테스트 사례를 APL로 번역하기위한 ngn의 신용)

간단한 설명

(×/∘,↓)⌺3 3 이웃과 함께 각 요소의 곱을 얻습니다.

그런 다음 인수로 나누면 ÷⊢행렬의 각 항목이 이웃의 곱에 매핑됩니다.

마지막 으로이 행렬을 사용하여 인수의 gcd를 가져 와서 ⊢∨1과 같은지 확인합니다.1=

참고로 같은 NGN의 대답 이 때문에 인터프리터의 버그로 일부 입력에 실패합니다.

— H.PWiz
소스

2

자바 스크립트 (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)

— 아르나 울드
소스

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보다 큰 경우이 기능이 작동합니까?

— Robert Fraser

@RobertFraser 예, 절차는 매트릭스 크기에 의존하지 않습니다. 예를 들어 마지막 테스트 사례 참조

— Luis Mendo

1

APL (Dyalog Classic) , 23 22 바이트

@ H.PWiz 덕분에 -1 바이트

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

온라인으로 사용해보십시오!

인터프리터 의 버그 로 인해 3x3보다 작은 행렬을 지원하지 않습니다.

— ngn
소스

@ H.PWiz 매우 영리합니다. 자신의 것으로 게시 하시겠습니까?

— ngn

물론, 당신은 또한 사용할 수 있습니다 (⊃∨⊢)-> ∨∘⊂⍨내 생각에

— 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

온라인으로 사용해보십시오!

True / False 항목이있는 목록 목록을 출력합니다.

— 체스 브라운
소스

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. 적대성 있는 항목 목록을 리턴합니다 .

— 델 파드
소스

누구의 이웃이 적대적인가?

소개

직무

예

테스트 사례

APL (Dyalog) , 17 바이트

간단한 설명

자바 스크립트 (ES6), 121 바이트

어떻게?

댓글

MATL , 22 바이트

효과적인 예제 설명

APL (Dyalog Classic) , 23 22 바이트

젤리 , 24 바이트

어떻게?

파이썬 (2) , 182 (177) 166 바이트

하스켈 , 95 바이트