Aquí hay un desafío de matriz bidimensional relativamente simple.

Imagina un campo de batalla de 625 soldados de a pie. Tú mandas a las tropas impares , pero desafortunadamente la fuerza de las tropas pares te abruma. Afortunadamente, tus soldados tienen un poder secreto: si el poder de cada tropa extraña y los aliados extraños que los rodean es divisible por un número de poder secreto, ¡desatan su último ataque y ganan! Debes honrar a cada soldado victorioso.

Reglas

Dada una matriz entera de 25 x 25 donde cada elemento contiene el producto de su posición xey más 1, devuelve las coordenadas de cada elemento impar "victorioso" que cumple con los siguientes criterios:

La suma del valor del elemento y sus elementos impares adyacentes (arriba, abajo, izquierda y derecha) es divisible por la entrada (número de potencia secreto). Debe tener elementos adyacentes a él en los cuatro lados y no estar en un borde.

Los envíos pueden ser una función o un programa completo que requiere una sola entrada. La salida puede ser en cualquier orden.

Nuestra matriz de 25 x 25, el campo de batalla, se ve así:

1, 1, 1, 1,...
1, 2, 3, 4,...
1, 3, 5, 7,...
1, 4, 7, 10,...
etc.

Ejemplo

Aquí hay un ejemplo de 3 x 3:

43, 57, 71
46, 61, 76
49, 65, 81

Para determinar si un elemento (61, en el centro) gana, sumamos sus valores y los elementos impares adyacentes.

61 + 57 + 65 = 183

Si el total es divisible por la entrada, se imprime la posición x e y del elemento. Si nuestra entrada es 3, porque 183 es ​​divisible por 3, se imprime "1, 1".

Salida

Si la entrada (número de poder secreto) es 37, los elementos devueltos (soldados victoriosos para ser elogiados) deben ser:

2, 18
3, 12
4, 9
5, 22
6, 6
8, 23
9, 4
10, 11
11, 10
12, 3
18, 2
22, 5
23, 8

Si la entrada es 191, los elementos devueltos deben ser:

10, 19
19, 10

Una entrada de 3:

1, 2
1, 4
1, 6
1, 8
1, 10
1, 12
1, 14
1, 16
1, 18
1, 20
1, 22
2, 1
2, 3
2, 4
2, 5
2, 7
2, 9
2, 10
2, 11
2, 13
2, 15
2, 16
2, 17
2, 19
2, 21
2, 22
2, 23
3, 2
3, 4
3, 6
3, 8
3, 10
3, 12
3, 14
3, 16
3, 18
3, 20
3, 22
4, 1
4, 2
4, 3
4, 5
4, 7
4, 8
4, 9
4, 11
4, 13
4, 14
4, 15
4, 17
4, 19
4, 20
4, 21
4, 23
5, 2
5, 4
5, 6
5, 8
5, 10
5, 12
5, 14
5, 16
5, 18
5, 20
5, 22
6, 1
6, 3
6, 5
6, 7
6, 9
6, 11
6, 13
6, 15
6, 17
6, 19
6, 21
6, 23
7, 2
7, 4
7, 6
7, 8
7, 10
7, 12
7, 14
7, 16
7, 18
7, 20
7, 22
8, 1
8, 3
8, 4
8, 5
8, 7
8, 9
8, 10
8, 11
8, 13
8, 15
8, 16
8, 17
8, 19
8, 21
8, 22
8, 23
9, 2
9, 4
9, 6
9, 8
9, 10
9, 12
9, 14
9, 16
9, 18
9, 20
9, 22
10, 1
10, 2
10, 3
10, 5
10, 7
10, 8
10, 9
10, 11
10, 13
10, 14
10, 15
10, 17
10, 19
10, 20
10, 21
10, 23
11, 2
11, 4
11, 6
11, 8
11, 10
11, 12
11, 14
11, 16
11, 18
11, 20
11, 22
12, 1
12, 3
12, 5
12, 7
12, 9
12, 11
12, 13
12, 15
12, 17
12, 19
12, 21
12, 23
13, 2
13, 4
13, 6
13, 8
13, 10
13, 12
13, 14
13, 16
13, 18
13, 20
13, 22
14, 1
14, 3
14, 4
14, 5
14, 7
14, 9
14, 10
14, 11
14, 13
14, 15
14, 16
14, 17
14, 19
14, 21
14, 22
14, 23
15, 2
15, 4
15, 6
15, 8
15, 10
15, 12
15, 14
15, 16
15, 18
15, 20
15, 22
16, 1
16, 2
16, 3
16, 5
16, 7
16, 8
16, 9
16, 11
16, 13
16, 14
16, 15
16, 17
16, 19
16, 20
16, 21
16, 23
17, 2
17, 4
17, 6
17, 8
17, 10
17, 12
17, 14
17, 16
17, 18
17, 20
17, 22
18, 1
18, 3
18, 5
18, 7
18, 9
18, 11
18, 13
18, 15
18, 17
18, 19
18, 21
18, 23
19, 2
19, 4
19, 6
19, 8
19, 10
19, 12
19, 14
19, 16
19, 18
19, 20
19, 22
20, 1
20, 3
20, 4
20, 5
20, 7
20, 9
20, 10
20, 11
20, 13
20, 15
20, 16
20, 17
20, 19
20, 21
20, 22
20, 23
21, 2
21, 4
21, 6
21, 8
21, 10
21, 12
21, 14
21, 16
21, 18
21, 20
21, 22
22, 1
22, 2
22, 3
22, 5
22, 7
22, 8
22, 9
22, 11
22, 13
22, 14
22, 15
22, 17
22, 19
22, 20
22, 21
22, 23
23, 2
23, 4
23, 6
23, 8
23, 10
23, 12
23, 14
23, 16
23, 18
23, 20
23, 22

Una entrada de 5:

1, 4
1, 14
2, 2
2, 4
2, 6
2, 7
2, 8
2, 10
2, 12
2, 14
2, 16
2, 17
2, 18
2, 20
2, 22
3, 8
3, 18
4, 1
4, 2
4, 4
4, 6
4, 8
4, 10
4, 11
4, 12
4, 14
4, 16
4, 18
4, 20
4, 21
4, 22
6, 2
6, 4
6, 6
6, 8
6, 9
6, 10
6, 12
6, 14
6, 16
6, 18
6, 19
6, 20
6, 22
7, 2
7, 12
7, 22
8, 2
8, 3
8, 4
8, 6
8, 8
8, 10
8, 12
8, 13
8, 14
8, 16
8, 18
8, 20
8, 22
8, 23
9, 6
9, 16
10, 2
10, 4
10, 6
10, 8
10, 10
10, 12
10, 14
10, 16
10, 18
10, 20
10, 22
11, 4
11, 14
12, 2
12, 4
12, 6
12, 7
12, 8
12, 10
12, 12
12, 14
12, 16
12, 17
12, 18
12, 20
12, 22
13, 8
13, 18
14, 1
14, 2
14, 4
14, 6
14, 8
14, 10
14, 11
14, 12
14, 14
14, 16
14, 18
14, 20
14, 21
14, 22
16, 2
16, 4
16, 6
16, 8
16, 9
16, 10
16, 12
16, 14
16, 16
16, 18
16, 19
16, 20
16, 22
17, 2
17, 12
17, 22
18, 2
18, 3
18, 4
18, 6
18, 8
18, 10
18, 12
18, 13
18, 14
18, 16
18, 18
18, 20
18, 22
18, 23
19, 6
19, 16
20, 2
20, 4
20, 6
20, 8
20, 10
20, 12
20, 14
20, 16
20, 18
20, 20
20, 22
21, 4
21, 14
22, 2
22, 4
22, 6
22, 7
22, 8
22, 10
22, 12
22, 14
22, 16
22, 17
22, 18
22, 20
22, 22
23, 8
23, 18

Este es el código de golf , el código de conteo de bytes más bajo sin usar lagunas estándar es el ganador.

Como esta es mi primera presentación, cualquier consejo es muy apreciado. ¡Gracias!

JavaScript (ES6),  83 81 80  76 bytes

$x,y$

f=(n,x=y=23,k=5,v=x*y)=>y?(v&1|~v*k%n?[]:[x,y]+' ')+f(n,--x||23|!y--,k^6):[]

Pruébalo en línea!

¿Cómo?

$c_{x,y}=xy+1$$(x,y)$

$0<x<24$$0<y<24$

$c_{x,y}$$x$$y$

$x$$c_{x-1,y}$$c_{x+1,y}$$y$$c_{x,y-1}$$c_{x,y+1}$

$$s_{x,y}=c_{x,y}+c_{x-1,y}+c_{x+1,y}=3c_{x,y}$$

$y$

$$s_{x,y}=c_{x,y}+c_{x,y-1}+c_{x,y+1}=3c_{x,y}$$

$x$$y$

$$s_{x,y}=c_{x,y}+c_{x-1,y}+c_{x+1,y}+c_{x,y-1}+c_{x,y+1}=5c_{x,y}$$

$3$$5$$k$

Comentado

f = (                // f is a recursive function taking:
  n,                 //   n      = input
  x = y = 23,        //   (x, y) = current coordinates, starting at (23, 23)
  k = 5,             //   k      = multiplier (3 or 5)
  v = x * y          //   v      = x * y (value of the current cell - 1)
) =>                 //
  y ?                // if y is greater than 0:
    ( v & 1 |        //   if v is odd (meaning that v + 1 is not)
      ~v * k % n ?   //   or n is not a divisor of -(v + 1) * k:
        []           //     append nothing
      :              //   else:
        [x, y] + ' ' //     append the coordinates followed by a space
    ) +              //
    f(               //   append the result of a recursive call:
      n,             //     pass n unchanged
      --x ||         //     decrement x; if the result is 0:
        23 | !y--,   //       pass 23 instead and decrement y
      k ^ 6          //     update k (5 -> 3 -> 5 -> ...)
    )                //   end of recursive call
  :                  // else:
    []               //   stop recursion

C # (compilador interactivo de Visual C #) , 97 93 91 90 bytes

x=>{for(int i=0,d=0,j;++i<24;d=5)for(j=0;++j<24;d^=6)if(i*j%2+(i*j+1)*d%x<1)Print((i,j));}

¡Guardado 6 bytes gracias a @Kevin Cruijssen!

Pruébalo en línea!

Stax , 25 bytes

âÖÅ{┼îÄï$εS╢,σδXú(Γ°#↑√nG

Ejecutar y depurarlo

Esto es principalmente solo fuerza bruta, con una observación marginalmente inteligente. Todas las tropas impares tienen 2 o 4 vecinos impares. Y la suma total de estos más la soldadura original es 3po 5pdónde pestá el poder del soldado. El coeficiente (3 o 5) se puede determinar por gcd(2, x, y) * 2 + 1)dónde xy yson las coordenadas del soldado.

Python 2 , 83 bytes

lambda n:[(x,y)for x in R for y in R if~(x*y)*[5,3][x+y&1]%n<1>x*y%2]
R=range(1,24)

Pruébalo en línea!

Gracias a Arnauld por guardar un byte.

JavaScript (SpiderMonkey) , 69 bytes

x=>{for(i=24;--i;)for(j=24,d=5;--j;d^=6)i*j%2+~(i*j)*d%x||print(j,i)}

Pruébalo en línea!

Jalea , 22 bytes

23×þ`‘µḤḤÐeÐe+×Ḃ³ḍaƊŒṪ

Pruébalo en línea!

Un programa completo que toma un solo argumento, el número de poder secreto, e imprime implícitamente una lista de [x, y]pares. Utiliza la observación que otros han hecho sobre múltiplos de 3 y 5.

Wolfram Language (Mathematica) , 60 58 bytes

Position[If[2∣+##,5,3](1+1##)&~Array~{23,23},a_/;#∣a]&

Pruébalo en línea!

Miré a mi alrededor después de publicar y me di cuenta de que realmente necesitaba encender mi cerebro ...