introduction

Aux fins de ce défi, nous définirons les voisins d'un élément dans une matrice carrée (telle que ) comme toutes les entrées de qui sont immédiatement adjacentes en diagonale, horizontalement ou verticalement à (c'est-à-dire qu'ils "entourent" , sans s'enrouler).$E$$A$$E=A_{i,j}$$A$$E$ $E$

Pour les pédants, une définition formelle des voisins de pour un matix est (0-indexée): où $A_{i,\:j}$$n\times n$$A$

$$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\}$$

Disons que l'élément d'index vit en hostilité s'il est coprime avec tous ses voisins (c'est-à-dire, ). Malheureusement, cette pauvre entrée ne peut même pas emprunter une tasse de sucre à ses résidents grossiers à proximité ...$i,\:j$$\gcd(A_{i,\:j},\:n)=1\:\forall\:n\in N_{i,\:j}$

Tâche

Assez d'histoires: étant donné une matrice carrée $M$ d'entiers positifs, sortez l'un des éléments suivants:

• Une liste plate d'éléments (dédupliqués ou non) indiquant toutes les entrées qui occupent certains indices $i,j$ dans $M$ tels que les voisins $N_{i,\:j}$ sont hostiles.
• Une matrice booléenne avec $1$ s aux positions où les voisins sont hostiles et $0$ sinon (vous pouvez choisir n'importe quelle autre valeur cohérente à la place de $0$ et $1$ ).
• La liste des paires d'indices $i,\:j$ qui représentent des quartiers hostiles.

Implémentation de référence dans Physica - prend également en charge la syntaxe Python pour les E / S. Vous pouvez prendre des entrées et fournir des sorties par n'importe quelle méthode standard et dans n'importe quel format raisonnable, tout en prenant note que ces failles sont interdites par défaut. C'est du code-golf, donc le code le plus court en octets (dans toutes les langues) gagne!

De plus, vous pouvez également prendre la taille de la matrice en entrée et prendre la matrice comme une liste plate car elle sera toujours carrée.

Exemple

Considérez la matrice suivante:

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

Les voisins correspondants de chaque élément sont:

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

Et donc la sortie doit être l'une des suivantes:

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

Cas de test

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 octets

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

Essayez-le en ligne! (crédits à ngn pour la traduction des cas de test en APL)

Brève explication

(×/∘,↓)⌺3 3 obtient le produit de chaque élément avec ses voisins.

Ensuite, je divise par l'argument ÷⊢, de sorte que chaque entrée de la matrice a été mappée au produit de ses voisins.

Enfin, je prends le pgcd de l'argument avec cette matrice ⊢∨et vérifie l'égalité avec 1,1=

Notez, comme avec la réponse de ngn , cela échoue pour certaines entrées en raison d'un bogue dans l'interpréteur.

JavaScript (ES6), 121 octets

Renvoie une matrice de valeurs booléennes, où false signifie hostile.

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))))

Essayez-le en ligne!

Comment?

La méthode utilisée pour isoler les 8 voisins de chaque cellule est similaire à celle que j'ai décrite ici .

Commenté

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 octets

tTT1&Ya3thYC5&Y)Zd1=A)

L'entrée est une matrice. La sortie est tous les nombres avec des voisins hostiles.

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication avec exemple travaillé

Considérez la saisie [38, 77, 11; 17, 51, 32; 66, 78, 19]comme exemple. Le contenu de la pile est affiché de bas en haut.

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 octets

-1 octet grâce à @ H.PWiz

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

Essayez-le en ligne!

ne prend pas en charge les matrices inférieures à 3x3 en raison d' un bogue dans l'interpréteur

Gelée , 24 octets

^{Hmm, ça semble long.}

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

Un lien monadique acceptant une liste de listes d'entiers positifs qui renvoie une liste de chacune des valeurs qui se trouvent dans des quartiers hostiles (version 1 sans déduplication).

Essayez-le en ligne! Ou consultez une suite de tests .

Comment?

ỊẠ€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 octets

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

Essayez-le en ligne!

Produit une liste de listes avec des entrées Vrai / Faux.

Haskell , 95 octets

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]]

Essayez-le en ligne!

La fonction ?prend la matrice mcomme une liste de listes et la taille de la matrice n; il renvoie la liste des entrées en hostilité .