Dada una matriz rectangular no entera de enteros de 0a 9, genera la cantidad de celdas que son 8y no tienen un vecino que es 8. Vecino se entiende aquí en el sentido de Moore , es decir, incluyendo diagonales. Entonces cada celda tiene 8vecinos, excepto las celdas en los bordes de la matriz.

Por ejemplo, dada la entrada

8 4 5 6 5
9 3 8 4 8
0 8 6 1 5
6 7 9 8 2
8 8 7 4 2

la salida debería ser 3. Las tres celdas de calificación serían las siguientes, marcadas con un asterisco (pero solo se debería mostrar la cantidad de tales entradas):

* 4 5 6 5
9 3 8 4 *
0 8 6 1 5
6 7 9 * 2
8 8 7 4 2

Reglas adicionales

• Opcionalmente, puede tomar dos números que definen el tamaño de la matriz como entradas adicionales.

• La entrada puede tomarse por cualquier medio razonable . El formato es flexible como de costumbre. Por ejemplo, puede ser una matriz de caracteres 2D, o una lista de listas de números, o una lista plana.

• Se permiten programas o funciones , en cualquier lenguaje de programación . Las lagunas estándar están prohibidas.

• El código más corto en bytes gana.

Casos de prueba

1. Entrada:

   8 4 5 6 5
   9 3 8 4 8
   0 8 6 1 5
   6 7 9 8 2
   8 8 7 4 2
   

   Salida: 3

2. Entrada

   8 8
   2 3
   

   Salida: 0

3. Entrada:

   5 3 4
   2 5 2
   

   Salida: 0

4. Entrada:

   5 8 3 8
   

   Salida: 2

5. Entrada:

   8
   0
   8
   

   Salida: 2.

6. Entrada:

   4 2 8 5
   2 6 1 8
   8 5 5 8
   

   Salida: 1

7. Entrada:

   4 5 4 3 8 1 8 2
   8 2 7 7 8 3 9 3
   9 8 7 8 5 4 2 8
   4 5 0 2 1 8 6 9
   1 5 4 3 4 5 6 1
   

   Salida 3.

8. Entrada:

   8
   

   Salida: 1

9. Entrada:

   8 5 8 1 6 8 7 7
   9 9 2 8 2 7 8 3
   2 8 4 9 7 3 2 7
   9 2 9 7 1 9 5 6
   6 9 8 7 3 1 5 2
   1 9 9 7 1 8 8 2
   3 5 6 8 1 4 7 5
   

   Salida: 4.

10. Entrada:

    8 1 8
    2 5 7
    8 0 1
    

    Salida: 3.

Entradas en formato MATLAB:

[8 4 5 6 5; 9 3 8 4 8; 0 8 6 1 5; 6 7 9 8 2; 8 8 7 4 2]
[8 8; 2 3]
[5 3 4; 2 5 2]
[5 8 3 8]
[8; 0; 8]
[4 2 8 5; 2 6 1 8; 8 5 5 8]
[4 5 4 3 8 1 8 2; 8 2 7 7 8 3 9 3; 9 8 7 8 5 4 2 8; 4 5 0 2 1 8 6 9; 1 5 4 3 4 5 6 1]
[8]
[8 5 8 1 6 8 7 7; 9 9 2 8 2 7 8 3; 2 8 4 9 7 3 2 7; 9 2 9 7 1 9 5 6; 6 9 8 7 3 1 5 2; 1 9 9 7 1 8 8 2; 3 5 6 8 1 4 7 5]
[8 1 8; 2 5 7; 8 0 1]

Entradas en formato Python:

[[8, 4, 5, 6, 5], [9, 3, 8, 4, 8], [0, 8, 6, 1, 5], [6, 7, 9, 8, 2], [8, 8, 7, 4, 2]]
[[8, 8], [2, 3]]
[[5, 3, 4], [2, 5, 2]]
[[5, 8, 3, 8]]
[[8], [0], [8]]
[[4, 2, 8, 5], [2, 6, 1, 8], [8, 5, 5, 8]]
[[4, 5, 4, 3, 8, 1, 8, 2], [8, 2, 7, 7, 8, 3, 9, 3], [9, 8, 7, 8, 5, 4, 2, 8], [4, 5, 0, 2, 1, 8, 6, 9], [1, 5, 4, 3, 4, 5, 6, 1]]
[[8]]
[[8, 5, 8, 1, 6, 8, 7, 7], [9, 9, 2, 8, 2, 7, 8, 3], [2, 8, 4, 9, 7, 3, 2, 7], [9, 2, 9, 7, 1, 9, 5, 6], [6, 9, 8, 7, 3, 1, 5, 2], [1, 9, 9, 7, 1, 8, 8, 2], [3, 5, 6, 8, 1, 4, 7, 5]]
[[8, 1, 8], [2, 5, 7], [8, 0, 1]]

Salidas:

3, 0, 0, 2, 2, 1, 3, 1, 4, 3

MATL , 21 17 10 bytes

8=t3Y6Z+>z

Pruébalo en línea!

Gracias a Luis Mendo por su ayuda en el chat y por sugerir una convolución 2D.

Explicación:

	#implicit input, m
8=	#equal to 8? matrix of 1 where m is 8, 0 otherwise
t	#duplicate
3Y6	#push [1 1 1; 1 0 1; 1 1 1], "neighbor cells" for convolution
Z+	#2D convolution; each element is replaced by the number of neighbors that are 8
>	#elementwise greater than -- matrix of 1s where an 8 is single, 0s otherwise
z	#number of nonzero elements -- number of single eights
	#implicit output

R , 117 63 59 bytes

function(m)sum(colSums(as.matrix(dist(which(m==8,T)))<2)<2)

Pruébalo en línea!

distcalcula distancias (el valor predeterminado es Euclidiano) entre filas de una matriz. whichcon el segundo argumento TRUEdevuelve las coordenadas donde el predicado es verdadero.

Las coordenadas son vecinas si la distancia entre ellas no es mayor que la raíz cuadrada de 2, pero el interior <2es lo suficientemente bueno porque la posible distancia salta de sqrt(2)ro 2.

APL (Dyalog Classic) , 29 28 25 bytes

≢∘⍸16=2⊥¨3,⌿3,/8=(⍉0,⌽)⍣4

Pruébalo en línea!

Jalea , ₁₈ 15 bytes

8=µ+Ż+ḊZµ⁺ỊṖḋµS

Pruébalo en línea!

Cómo funciona

8=µ+Ż+ḊZµ⁺ỊṖḋµS    Main link (monad). Input: digit matrix
8=              1) Convert elements by `x == 8`
  µ             2) New chain:
   +Ż+Ḋ              x + [0,*x] + x[1:] (missing elements are considered 0)
                     Effectively, vertical convolution with [1,1,1]
       Z             Transpose
        µ⁺      3) Start new chain, apply 2) again
          ỊṖ       Convert elements by `|x| <= 1` and remove last row
            ḋ      Row-wise dot product with result of 1)
             µS 4) Sum

Solución anterior, 18 bytes

æc7B¤ZḊṖ
8=µÇÇỊḋµS

Pruébalo en línea!

Quería compartir otro enfoque, aunque esto es 1 byte más largo que la solución de Jonathan Allan .

Cómo funciona

æc7B¤ZḊṖ    Auxiliary link (monad). Input: integer matrix
æc7B¤       Convolution with [1,1,1] on each row
     ZḊṖ    Zip (transpose), remove first and last elements

8=µÇÇỊḋµS    Main link (monad). Input: digit matrix
8=           Convert 8 to 1, anything else to 0 (*A)
  怀        Apply aux.link twice (effective convolution with [[1,1,1]]*3)
     Ịḋ      Convert to |x|<=1, then row-wise dot product with A
       µS    Sum the result

JavaScript (Node.js) , 88 85 bytes

a=>g=(x,y=0,c=0)=>a.map(p=>p.map((q,j)=>c+=q-8?0:1/x?(x-j)**2+y*y<3:g(j,-y)<2)&--y)|c

Pruébalo en línea!

Gracias Arnauld por 2 bytes

J , 43, 40 37 bytes

-3 bytes gracias a Bubbler

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4

Pruébalo en línea!

Explicación:

La primera parte del algoritmo asegura que podemos aplicar una ventana deslizante de 3x3 a la entrada. Esto se logra al anteponer una fila de ceros y una rotación de 90 grados, que se repite 4 veces.

1#.1#.3 3(16=8#.@:=,);._3(0|:@,|.)^:4
                         (       )^:4 - repeat 4 times
                          0|:@,|.     - reverse, prepend wit a row of 0 and transpose
                     ;._3             - cut the input (already outlined with zeroes)
      3 3                             - into matrices with size 3x3
         (          )                 - and for each matrix do
                   ,                  - ravel (flatten)
             8    =                   - check if each item equals 8
              #.@:                    - and convert the list of 1s and 0s to a decimal
          16=                         - is equal to 16?
   1#.                                - add (the result has the shape of the input)
1#.                                   - add again

Retina 0.8.2 , 84 bytes

.+
_$&_
m`(?<!(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.|8)8(?!8|.(.)*¶.*8.?.?(?<-2>.)*$(?(2).))

Pruébalo en línea! Explicación:

.+
_$&_

Envuelva cada línea en 8caracteres que no sean caracteres para que todos 8tengan al menos un carácter en cada lado.

m`

Esta es la última etapa, por lo que está implícito contar partidos. El mmodificador hace que los caracteres ^y $coincidan al principio o al final de cualquier línea.

(?<!...|8)

No coincida con un personaje directamente después de un 8, o ...

(?(1).)^(?<-1>.)*.?.?8.*¶(.)*.

... un personaje debajo de un 8; el (?(1).)^(?<-1>.)*coincide con la misma columna que ¶(.)*en la línea siguiente, pero .?.?permite 8que quede 1 a la izquierda o derecha del personaje después .de la línea siguiente.

8

Partido 8s.

(?!8|...)

No coincida con un 8 inmediatamente antes de un 8, o ...

.(.)*¶.*8.?.?(?<-2>.)*$(?(2).)

... un personaje con un 8 en la línea de abajo; de nuevo, el (?<-2>.)*$(?(2).)juego la misma columna que el (.)*¶en la línea anterior, pero la .?.?permite el 8que se 1 hacia la izquierda o derecha de la 8antes de la .en la línea anterior.

Jalea , 17 bytes

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL

Pruébalo en línea! O vea el conjunto de pruebas .

¿Cómo?

=8ŒṪµŒcZIỊȦƲƇẎ⁸ḟL - Link: list of lists of integers (digits)
=8                - equals 8?
  ŒṪ              - multidimensional truthy indices (pairs of row & column indices of 8s)
    µ             - start a new monadic chain
     Œc           - all pairs (of the index-pairs) 
            Ƈ     - filter keep if:  (keep those that represent adjacent positions)
           Ʋ      -   last four links as a monad:
       Z          -     transpose
        I         -     incremental differences
         Ị        -     insignificant? (abs(x) <= 1)
          Ȧ       -     all?
             Ẏ    - tighten (to a list of all adjacent 8's index-pairs, at least once each)
              ⁸   - chain's left argument (all the index-pairs again)
               ḟ  - filter discard (remove those found to be adjacent to another)
                L - length (of the remaining pairs of indices of single 8s)

J, 42 bytes

[:+/@,8=]+[:+/(<:3 3#:4-.~i.9)|.!.0(_*8&=)

Pruébalo en línea!

explicación

El enfoque de alto nivel aquí es similar al utilizado en la solución APL clásica para el juego de la vida: https://www.youtube.com/watch?v=a9xAKttWgP4 .

En esa solución, cambiamos nuestra matriz en las 8 direcciones vecinas posibles, creando 8 duplicados de la entrada, los apilamos y luego sumamos los "planos" para obtener los recuentos de vecinos.

Aquí, usamos un truco de "multiplicar por infinito" para adaptar la solución a este problema.

[: +/@, 8 = ] + [: +/ (neighbor deltas) (|.!.0) _ * 8&= NB. 
                                                        NB.
[: +/@,                                                 NB. the sum after flattening
        8 =                                             NB. a 0 1 matrix created by
                                                        NB. elmwise testing if 8
                                                        NB. equals the matrix
            (the matrix to test for equality with 8   ) NB. defined by...
            ] +                                         NB. the original input plus
                [: +/                                   NB. the elmwise sum of 8
                                                        NB. matrices defined by
                                                _ *     NB. the elmwise product of 
                                                        NB. infinity and
                                                    8&= NB. the matrix which is 1
                                                        NB. where the input is 8
                                                        NB. and 0 elsewhere, thus
                                                        NB. creating an infinity-0
                                                        NB. matrix
                                        (|.!.0)         NB. then 2d shifting that 
                                                        NB. matrix in the 8 possible
                                                        NB. "neighbor" directions
                      (neighbor deltas)                 NB. defined by the "neighbor
                                                        NB. deltas" (see below)
                                                        NB. QED.
                                                        NB. ***********************
                                                        NB. The rest of the
                                                        NB. explanation merely
                                                        NB. breaks down the neighbor
                                                        NB. delta construction.


                      (neighbor deltas  )               NB. the neighbor deltas are
                                                        NB. merely the cross product
                                                        NB. of _1 0 1 with itself,
                                                        NB. minus "0 0"
                      (<: 3 3 #: 4 -.~ i.9)             NB. to create that...
                       <:                               NB. subtract one from
                          3 3 #:                        NB. the base 3 rep of
                                       i.9              NB. the numbers 0 - 8
                                 4 -.~                  NB. minus the number 4
                                                        NB.
                                                        NB. All of which produces
                                                        NB. the eight "neighbor"
                                                        NB. deltas:
                                                        NB. 
                                                        NB.       _1 _1
                                                        NB.       _1  0
                                                        NB.       _1  1
                                                        NB.        0 _1
                                                        NB.        0  1
                                                        NB.        1 _1
                                                        NB.        1  0
                                                        NB.        1  1

Java 8, 181 157 156 bytes

(M,R,C)->{int z=0,c,f,t;for(;R-->0;)for(c=C;c-->0;z+=f>1?0:f)for(f=0,t=9;M[R][c]==8&t-->0;)try{f+=M[R+t/3-1][c+t%3-1]==8?1:0;}catch(Exception e){}return z;}

-24 bytes gracias a @ OlivierGrégoire .

Toma las dimensiones como parámetros adicionales R(cantidad de filas) y C(cantidad de columnas).

Las células se comprueban bastante similares como lo hice en mi simulador de la freidora respuesta .

Pruébalo en línea.

Explicación:

(M,R,C)->{                    // Method with integer-matrix as parameter & integer return
  int z=0,                    //  Result-counter, starting at 0
      c,f,t;                  //  Temp-integers, starting uninitialized
  for(;R-->0;)                //  Loop over the rows:
    for(c=C;c-->0             //   Inner loop over the columns:
           ;                  //     After every iteration:
            z+=f==1?          //      If the flag-integer is larger than 1:
                0             //       Leave the result-counter the same by adding 0
               :              //      Else:
                f)            //       Add the flag-integer (either 0 or 1)
      for(f=0,                //    Reset the flag to 0
          t=9;M[R][c]==8&     //    If the current cell contains an 8:
              t-->0;)         //     Inner loop `t` in the range (9, 0]:
        try{f+=               //      Increase the flag by:
               M[R+t/3-1]     //       If `t` is 0, 1, or 2: Look at the previous row
                              //       Else-if `t` is 6, 7, or 8: Look at the next row
                              //       Else (`t` is 3, 4, or 5): Look at the current row
                [c+t%3-1]     //       If `t` is 0, 3, or 6: Look at the previous column
                              //       Else-if `t` is 2, 5, or 8: Look at the next column
                              //       Else (`t` is 1, 4, or 7): Look at the current column
                ==8?          //       And if the digit in this cell is 8:
                 1            //        Increase the flag-integer by 1
                :0;           //       Else: leave it the same
        }catch(Exception e){} //      Catch and ignore ArrayIndexOutOfBoundsExceptions
                              //      (try-catch saves bytes in comparison to if-checks)
  return z;}                  //  And finally return the counter

Python 2 , 130 bytes

lambda a:sum(sum(u[~-c*(c>0):c+2].count(8)for u in a[~-r*(r>0):r+2])*8==8==a[r][c]for r in range(len(a))for c in range(len(a[0])))

Pruébalo en línea!

Powershell, 121 bytes

param($a)(($b='='*4*($l=($a|% Le*)[0]))+($a|%{"!$_!"})+$b|sls "(?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})" -a|% m*).Count

Menos guión de prueba de golf:

$f = {

param($a)

$length=($a|% Length)[0]
$border='='*4*$length
$pattern="(?<=[^8]{3}.{$length}[^8])8(?=[^8].{$length}[^8]{3})"
$matches=$border+($a|%{"!$_!"})+$border |sls $pattern -a|% Matches
$matches.count

}

@(

,(3,"84565","93848","08615","67982","88742")
,(0,"88","23")
,(0,"534","252")
,(2,"5838")
,(2,"8","0","8")
,(1,"4285","2618","8558")
,(3,"45438182","82778393","98785428","45021869","15434561")
,(1,"8")
,(4,"85816877","99282783","28497327","92971956","69873152","19971882","35681475")
,(3,"818","257","801")
,(0,"")

) | % {
    $expected,$a = $_
    $result = &$f $a
    "$($result-eq$expected): $result : $a"
}

Salida:

True: 3 : 84565 93848 08615 67982 88742
True: 0 : 88 23
True: 0 : 534 252
True: 2 : 5838
True: 2 : 8 0 8
True: 1 : 4285 2618 8558
True: 3 : 45438182 82778393 98785428 45021869 15434561
True: 1 : 8
True: 4 : 85816877 99282783 28497327 92971956 69873152 19971882 35681475
True: 3 : 818 257 801
True: 0 : 

Explicación:

Primero, el script calcula una longitud de la primera cadena.

En segundo lugar, agrega un borde adicional a las cadenas. Me gusta de cadena de realidad aumentada :

....=========!84565! !93848! !08615! !67982! !88742!===========....

representa la cadena multilínea:

...=====
=======
!84565!
!93848!
!08615!
!67982!
!88742!
=======
========...

Nota 1: el número de =es suficiente para una cadena de cualquier longitud.

Nota 2: una gran cantidad de =no afecta la búsqueda de ochos.

A continuación, la expresión regular (?<=[^8]{3}.{$l}[^8])8(?=[^8].{$l}[^8]{3})busca el dígito 8con los no ochos anteriores (?<=[^8]{3}.{$l}[^8])y los siguientes no ochos (?=[^8].{$l}[^8]{3}):

.......
<<<....
<8>....
>>>....
.......

Finalmente, se devuelve el número de coincidencias como resultado.

Jalea , 12 bytes

œẹ8ạṀ¥þ`’Ạ€S

Pruébalo en línea!

Cómo funciona

œẹ8ạṀ¥þ`’Ạ€S  Main link. Argument: M (matrix)

œẹ8           Find all multidimensional indices of 8, yielding an array A of pairs.
      þ`      Table self; for all pairs [i, j] and [k, l] in A, call the link to the
              left. Return the results as a matrix.
   ạ              Absolute difference; yield [|i - k|, |j - l|].
    Ṁ             Take the maximum.
        ’     Decrement all the maxmima, mapping 1 to 0.
         Ạ€   All each; yield 1 for each row that contains no zeroes.
           S  Take the sum.

JavaScript (ES6), 106 bytes

a=>a.map((r,y)=>r.map((v,x)=>k+=v==8&[...'12221000'].every((d,i,v)=>(a[y+~-d]||0)[x+~-v[i+2&7]]^8)),k=0)|k

Pruébalo en línea!

Enfoque bit a bit, 110 bytes

a=>a.map(r=>r.map(v=>x=x*2|v==8,x=k=0)|x).map((n,y,b)=>a[0].map((_,x)=>(n^1<<x|b[y-1]|b[y+1])*2>>x&7||k++))&&k

Pruébalo en línea!

Clojure , 227 198 bytes

(fn[t w h](let[c #(for[y(range %3 %4)x(range % %2)][x y])e #(= 8(get-in t(reverse %)0))m(fn[[o p]](count(filter e(c(dec o)(+ o 2)(dec p)(+ p 2)))))](count(filter #(= 1(m %))(filter e(c 0 w 0 h))))))

Ay. Definitivamente no es el más corto aquí de ninguna manera. 54 bytes de paréntesis son asesinos. Sin embargo, todavía estoy relativamente feliz con eso.

-29 bytes creando una función auxiliar que genera un rango ya que lo estaba haciendo dos veces, cambiando el reducea un(count (filter configuración y deshaciéndome de la macro de subprocesos después del golf.

(defn count-single-eights [td-array width height]
  ; Define three helper functions. One generates a list of coords for a given range of dimensions, another checks if an eight is
  ; at the given coord, and the other counts how many neighbors around a coord are an eight
  (letfn [(coords [x-min x-max y-min y-max]
            (for [y (range y-min y-max)
                  x (range x-min x-max)]
              [x y]))
          (eight? [[x y]] (= 8 (get-in td-array [y x] 0)))
          (n-eights-around [[cx cy]]
            (count (filter eight?
                           (coords (dec cx) (+ cx 2), (dec cy) (+ cy 2)))))]

    ; Gen a list of each coord of the matrix
    (->> (coords 0 width, 0 height)

         ; Remove any coords that don't contain an eight
         (filter eight?)

         ; Then count how many "neighborhoods" only contain 1 eight
         (filter #(= 1 (n-eights-around %)))
         (count))))

(mapv #(count-single-eights % (count (% 0)) (count %))
      test-cases)
=> [3 0 0 2 2 1 3 1 4 3]

¿Dónde test-casesestá una matriz que contiene todos los "casos de prueba de Python"

Pruébalo en línea!