Simulador de fraile

73

Los hermanos del orden de San Golfus el Conciso tienen la tradición de recitar una breve oración cada vez que ven a alguien hacer la señal de la cruz . Debido al alto nivel de pecado medido recientemente entre los turistas, han instalado CCTV en el monasterio y te han contratado para ayudarlos a mantener viva la vieja tradición en la era de la IA.

Su tarea es analizar el resultado del software de rastreo de dedos de los frailes y decir cuántas oraciones se deben. La entrada es una matriz que contiene enteros entre 0 y 4. 1,2,3,4 representan las posiciones de los dedos en momentos consecutivos en el tiempo. 0 representa no dedos.

La One True Way TM para persignarse es:

.1.
3.4
.2.

("." coincide con cualquier dígito). Sin embargo, debido a la incertidumbre sobre la rotación de la cámara y la presencia de piadosos hermanos ortodoxos orientales en la multitud (cuyo One True Way TM está en la dirección lateral opuesta), también debe contar todas las rotaciones y reflexiones:

.4. .2. .3. .1. .3. .2. .4.
1.2 4.3 2.1 4.3 1.2 3.4 2.1
.3. .1. .4. .2. .4. .1. .3.

Un dígito puede ser parte de cruces múltiples. Ayude a los frailes a determinar la cantidad de veces que su IA debería .pray()contar contando cuántas de las submatrices 3x3 anteriores están presentes. Escribe un programa o una función. Tomar aportes en cualquier forma conveniente y razonable.

Casos del testamento:

// in
[[0,4,2,0],
 [1,3,2,4],
 [2,3,1,0]]

// out
2

// in
[[4,3,3,2,4,4,1,3,2,2],
 [0,3,0,2,1,1,2,3,2,3],
 [0,3,1,3,2,4,3,3,1,1],
 [4,3,2,3,2,4,1,4,2,3],
 [0,4,2,3,4,0,2,3,2,4],
 [2,1,0,0,2,0,0,1,2,4],
 [4,0,3,1,3,2,0,3,2,3],
 [1,4,3,3,1,4,0,1,4,4],
 [0,2,4,3,4,3,1,3,0,4],
 [3,0,1,0,4,0,3,3,3,3]]

// out
3

// in
[[3,2,3,1,0,3,4,2,1,1,1,1,4,0,1,3,1,1,2,1,1,3,0,1,0,1,1,0,0,1,0,3,4,0,1,1,2,3,1,2,4,1,0,2,3,0,2,4,3,2],
 [2,4,1,1,0,3,0,2,4,2,3,2,1,3,0,2,3,2,4,4,4,3,2,1,1,3,2,1,2,3,2,4,0,3,1,4,4,1,1,0,1,1,0,2,2,3,1,2,0,2],
 [3,4,0,0,4,4,0,3,4,4,1,3,2,1,3,2,3,2,2,0,4,0,1,2,3,0,4,3,2,2,2,0,3,3,4,4,2,2,1,4,4,1,3,1,1,2,0,1,1,0],
 [1,4,2,2,2,1,3,4,1,1,2,1,4,0,3,2,2,4,1,3,3,0,4,1,1,0,0,1,2,2,1,3,4,0,4,1,0,1,1,0,2,1,3,1,4,4,0,4,3,2],
 [4,4,2,0,4,4,1,1,2,2,3,3,2,3,0,3,2,1,0,3,3,4,2,2,2,1,1,4,3,2,1,1,4,3,4,2,4,0,1,0,2,4,2,2,0,3,3,0,3,2],
 [4,3,3,1,3,1,1,3,3,1,0,1,4,3,4,3,4,1,2,2,1,1,2,1,4,2,1,1,1,1,1,3,3,3,1,1,4,4,0,0,3,3,1,4,4,3,2,3,3,0],
 [1,4,1,4,0,0,1,3,1,2,2,1,1,2,3,3,2,0,3,4,3,2,1,2,2,3,3,1,4,2,1,1,4,1,3,2,0,0,0,1,2,4,1,1,3,0,4,2,3,1],
 [2,2,3,0,0,4,2,1,2,3,1,2,4,1,0,1,0,2,4,1,3,4,4,0,0,4,0,4,4,2,0,0,2,2,3,3,4,1,0,3,2,1,0,1,1,0,3,0,3,2],
 [1,2,4,3,4,3,1,2,2,3,0,1,2,4,4,4,3,1,2,3,4,3,3,2,0,0,2,0,3,4,4,2,3,2,0,2,4,3,0,0,0,4,4,0,4,4,0,3,3,3],
 [4,4,1,2,0,2,2,0,0,3,2,3,2,3,4,1,0,2,3,0,3,2,1,1,4,3,0,2,3,1,0,4,1,2,4,1,1,4,4,4,2,2,2,3,0,1,0,3,0,1],
 [4,0,3,0,2,2,0,3,2,2,2,4,0,4,0,1,0,1,4,3,3,2,3,1,2,2,4,4,0,3,2,3,1,4,1,0,3,2,3,2,2,0,1,2,4,0,3,0,4,4],
 [0,4,0,1,0,2,3,2,1,3,1,1,2,0,3,2,1,4,0,1,4,4,1,3,4,4,1,0,4,1,0,3,4,0,3,2,4,3,3,3,3,1,2,2,3,3,3,1,3,4],
 [3,4,1,2,1,1,1,0,4,0,1,1,0,4,1,3,1,1,2,0,2,1,4,1,4,4,3,2,0,3,0,3,0,1,1,2,1,3,0,4,4,2,2,2,1,3,4,1,1,1],
 [3,0,1,4,2,0,0,3,1,1,1,4,4,0,2,2,0,4,0,3,1,0,2,2,4,4,4,0,4,4,4,4,4,4,3,0,4,4,4,1,2,4,4,3,0,0,4,0,4,2],
 [2,0,1,2,1,1,3,0,3,1,0,4,3,1,2,1,1,3,0,1,2,4,2,1,2,3,4,2,4,4,2,2,3,4,0,0,1,0,0,4,1,3,3,4,1,2,1,3,3,2],
 [4,0,2,0,3,1,2,1,1,1,1,2,3,0,3,1,0,4,3,0,0,0,2,0,1,4,0,2,1,3,4,2,2,4,2,3,1,2,0,2,0,2,4,0,1,2,3,4,1,3],
 [3,0,2,4,2,0,3,4,3,2,3,4,2,0,4,1,0,4,3,3,1,0,2,2,2,1,3,3,1,1,0,3,3,0,3,2,1,1,0,1,2,2,0,4,4,2,0,1,3,1],
 [0,4,4,4,0,3,0,3,0,2,2,0,1,2,3,3,4,3,0,4,1,2,3,3,0,2,2,3,0,0,0,2,4,2,3,4,2,3,4,0,2,0,1,1,3,4,2,2,4,4],
 [2,1,2,3,4,3,1,2,0,0,0,0,0,0,3,4,3,3,1,2,2,1,3,4,1,2,4,0,1,4,1,0,0,0,2,1,1,1,3,0,0,3,1,1,4,2,1,3,4,1],
 [1,0,3,0,2,1,4,2,3,3,1,1,3,4,4,0,1,2,1,3,0,3,1,1,3,0,2,4,4,4,2,3,1,4,3,4,0,1,4,1,1,1,4,0,0,2,3,4,0,4]]

// out
8

"Bendito sea el más corto de los más cortos, porque gana el reino de los votos". -Libro de San Golfus 13:37

"No usarás lagunas, porque son las obras malvadas de Lucifer". -Carta al Meta 13: 666

Ligera visualización de personas haciendo la cruz.

Mostrar fragmento de código

Gracias @Tschallacka por la visualización.

code-golf matrix ngn
fuente
57
+1 para los versos al final, me dieron una buena carcajada: D
HyperNeutrino
66
¿Puede un dígito ser parte de cruces múltiples?
Martin Ender
9
Oh dulce Jesús, hiciste un simulador de fraile.
Urna mágica del pulpo
1
¿Por qué está vinculada la primera "T"?
JakeGould
44
@JakeGould Para vincular esta pregunta a la pregunta que lleva la "T".
Erik the Outgolfer

Respuestas:

19

Grime , 20 bytes

n`.\1./\3.\4/.\2.voO

Pruébalo en línea!

Una implementación muy literal de la especificación:

  • n` hacer que Grime cuente el número de subrectangulos de la entrada que producen una coincidencia.

  • .\1./\3.\4/.\2. define el cuadrado 3x3:

    .1.
3.4
.2.

    Donde .puede ser cualquier personaje.

  • oOes un modificador de orientación que permite que este rectángulo aparezca en cualquier rotación o reflexión. Se vusa para reducir ola precedencia de s para que no necesitemos paréntesis alrededor del cuadrado.
Martin Ender
fuente
77
Correcto para las dos primeras pruebas, segfault para la última. Supongo que esto debería estar bien siempre que el programa sea correcto en principio y solo esté limitado por los recursos.
ngn
FYI: Acabo de probar el último caso de prueba y funcionó bien para mí.
3D1T0R
16

Caracoles , 17 16 bytes

Ao
\1.=\2o=\3b\4

Pruébalo en línea!

Explicación

Ahace que Snails cuente el número de posibles rutas coincidentes en toda la entrada. oestablece la dirección de inicio en cualquier dirección ortogonal (en lugar de solo hacia el este). El patrón en sí está en la segunda línea:

\1    Match a 1.
.     Match an arbitrary character (the one in the centre).
=\2   Check that the next character ahead is a 2, but don't move there.
o     Turn to any orthogonal direction. In practice, this will only be one
      of the two directions from the centre we haven't checked yet.
=\3   Check that the next character ahead is a 3.
b     Turn around 180 degrees.
\4    Match a 4 in that direction.
Martin Ender
fuente
7

Haskell, 108 102 93 bytes

f((_:t:x):w@((l:q@(_:r:_)):(_:b:z):_))=sum$f((t:x):q:[b:z]):f w:[1|(l*r-1)*(t*b-1)==11]
f _=0

Pruébalo en línea!

Sin expresiones regulares. Coincidencia de patrones

.t.
l.r
.b.

en la esquina superior izquierda de la matriz, tome un 1if (l*r-1)*(t*b-1)==11y recursivamente vaya a la derecha (soltar .l.) y hacia abajo (soltar la primera fila). Si el patrón no puede coincidir (en el borde derecho o inferior), tome a 0. Suma todos los resultados.

Editar: -9 bytes gracias a @xnor.

nimi
fuente
Iba a sugerir 2^(l*r)+2^(t*b)==4100que verificara los números, pero parece que ambas soluciones están engañadas 2,6en lugar de 3,4.
xnor
@xnor pero los números están restringidos a0..4
Οurous
3
@ Οurous Gracias, me perdí eso. Entonces las expresiones aritméticas se pueden optimizar aún más, como (l*r-1)*(t*b-1)==11.
xnor
7

Perl, 70 bytes

Incluye +2 para 0p

Dé la matriz de entrada como un bloque de dígitos sin espacios en STDIN:

perl -0pe '$_=map{/.$/m+y/1-4/3421/;/(?=1.{@{-}}(3.4|4.3).{@{-}}2)/sg}($_)x4'
0420
1324
2310
^D

Gira la cruz girando los dígitos

Ton Hospel
fuente
6

Retina , 92 83 bytes

L$v`(?<=((.))*).(.)..*¶(?<-1>.)*(.).(.).*¶(?<-2>.)*.(.)
$6$3$4$5
/../_O`.
1234|3412

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

L$v`(?<=((.))*).(.)..*¶(?<-1>.)*(.).(.).*¶(?<-2>.)*.(.)
$6$3$4$5

Busque todos los cuadrados superpuestos de 3x3. Una mirada atrás captura la sangría dos veces para que pueda equilibrarse en la segunda y tercera línea. Se supone que la entrada es rectangular, por lo que no tenemos que verificar que los grupos se equilibren. Las celdas medias inferior / superior y las celdas medias izquierda / derecha se capturan.

/../_O`.

Ordenar cada par de celdas en orden.

1234|3412

Cuente los patrones válidos restantes.

Neil
fuente
5

Jalea , 26 bytes

Z3Ƥṡ€3ẎµFḊm2ṙ-s2Ṣ€ṢFµ€ċ4R¤

Pruébalo en línea!

Explicación

Z3Ƥṡ€3ẎµFḊm2ṙ-s2Ṣ€ṢFµ€ċ4R¤  Main Link
 3Ƥ                         For each 3 rows
Z                           Zip the rows
   ṡ€3                      Get all arrangements of 3 consecutive columns from these rows. At this step, we have all 3x3 contiguous submatrices
      Ẏ                     Unwrap by one layer; previously grouped by rows, now ungrouped
       µ           µ€       For each 3x3 submatrix
        F                   Flatten it
         Ḋ                  Get rid of the first element
          m2                Take every second element (this only keeps the edges)
            ṙ-              Rotate right 1 element
              s2            Group into pairs; now the top and bottom are grouped and the left and right are grouped
                Ṣ€          Sort each pair
                  Ṣ         Sort the pairs
                   F        Flatten
                      ċ4R¤  Count the number of occurrences of range(4); i.e. [1,2,3,4]

-3 bytes gracias a Jonathan Allan (2) y Mr. Xcoder (3) (fusionado)

Hiperneutrino
fuente
@ngn lol el punto está destinado a estar debajo de D. Mi mal, arreglado.
HyperNeutrino
Ahorre 2 bytes usando en ...Fµ€ċ4R¤lugar de ...Ḍµ€ċ1234(también tenga en cuenta que 1234podría haber sido reemplazado por ⁽¡ḋguardar uno)
Jonathan Allan
26 bytes usando en Z3Ƥlugar de ṡ3Z€y en ⁼J$µ€Slugar de Ḍµ€ċ1234.
Sr. Xcoder
@JonathanAllan oh genial, gracias
HyperNeutrino
5

Java 8, 135 133 131 bytes

m->{int r=0,i=0,j;for(;++i<m.length-1;)for(j=1;j<m[i].length-1;)if(~(m[i-1][j]*m[i+1][j])*~(m[i][j-1]*m[i][++j])==39)r++;return r;}

-2 bytes gracias a @tehtmi por una fórmula más corta: (l*r-1)*(t*b-1)==11a~(l*r)*~(t*b)==39

Explicación:

Pruébalo en línea.

m->{                     // Method with integer-matrix parameter and integer return-type
  int r=0,               //  Result-integer, starting at 0
      i=0,j;             //  Index integers
  for(;++i<m.length-1;)  //  Loop over the rows, skipping the first and last
    for(j=1;j<m[i].length-1;)
                         //   Inner loop over the columns, skipping the first and last
      if(~(m[i-1][j]*m[i+1][j])*~(m[i][j-1]*m[i][++j])==39)
                         //    If (-(bottom*top)-1) * (-(left*right)-1) is exactly 39:
        r++;             //     Increase the result-counter by 1
  return r;}             //  Return the result-counter
Kevin Cruijssen
fuente
1
Fórmula más corta: ~(l*r)*~(t*b)==39(Haskell ~aparentemente no tiene 1 byte ).
tehtmi
3

Casco , 23 bytes

#ö§&¦ḣ4SδΛ≈↔Ċ2tΣṁoX3TX3

Pruébalo en línea!

Explicación

#ö§&¦ḣ4SδΛ≈↔Ċ2tΣṁoX3TX3  Implicit input, a list of lists of integers.
                     X3  Length-3 slices.
                ṁ        Map over them and concatenate:
                    T     Transpose,
                 oX3      then get length-3 slices.
                         Now we have a list of 3x3-arrays of the (transposed) input.
#ö                       Return number of 3x3-arrays that satisfy this:
                          Take m = [[0,3,0],[2,4,1],[1,4,0]] as an example.
               Σ          Concatenate: [0,3,0,2,4,1,1,4,0]
              t           Tail: [3,0,2,4,1,1,4,0]
            Ċ2            Take every second element: c = [3,2,1,4]
  §&                      c satisfies both of the following:
    ¦                     1) It contains every element of
     ḣ4                      the range [1,2,3,4].
       Sδ                 2) If you zip c
           ↔                 with its reverse,
         Λ                   then each corresponding pair
          ≈                  has absolute difference at most 1.
                         Implicitly print the result.
Zgarb
fuente
3

Dyalog APL , 30 29 28 27 26 bytes ( SBSC )

+/∘,{12 2⍷×∘⌽⍨⊢/4 2⍴⍵}⌺3 3

Pruébalo en línea!

H.PWiz
fuente
¡muy bien! ⌽∘⊖×⊢podría ser más corto en 2 bytes, ¿puedes adivinar cómo?
ngn
@ngn Lo que realmente quiero es un símbolo como ø;)
H.PWiz
@ngn tengo×∘⌽∘⊖⍨
H.PWiz
esto es más corto:(⌽×⊖)
NGN
Oh, eso es inteligente, moviste la selfie (... ⍨) a la izquierda ⊢/para otro -1. No pensé en eso. En esta situación no deberías darme crédito.
ngn
2

Jalea , 36 bytes

“ƒɦƈạ%ȤFE’b4s4
ṡ3µZṡ3F€µ€ẎḊm2$$€’f¢L

Pruébalo en línea!

37 bytes

Por alguna razón, no puedo mover Ḋm2$$al enlace superior.

ṙ1s2I€FPA,P⁼1,24
ṡ3µZṡ3F€µ€ẎḊm2$$€Ç€S

Pruébalo en línea!

fireflame241
fuente
2

Limpio , 255 ... 162 bytes

No es beneficioso que a menudo use filtros de patrones en las comprensiones, pero en este caso, lo es.

import StdEnv,StdLib
? =reverse
@ =transpose
t=tails
$m=sum[1\\f<-[id,@,?,?o@,@o?,@o?o@,?o@o?o@,?o@o?],[a,b,c:_]<-t(f m),[_,1:_]<-t a&[3,_,4:_]<-t b&[_,2:_]<-t c]

Pruébalo en línea!

Define la función $, tomar [[Int]]y regresar Int.

Primero genera todas las simetrías de la matriz m(transformando vía f), toma las tailsque tienen tres o más filas y verifica sincrónicamente cuántos de los primeros tres conjuntos de columnas tailsde cada fila coinciden con el patrón de la cruz.

Esto es equivalente a contar el número de ordenadas, que tailscoinciden tailscon el patrón [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_], que lógicamente es lo mismo que verificar si, para cada celda de la matriz, esa celda es la esquina superior izquierda de cualquier rotación de la cruz.

Οurous
fuente
2

Python 3, 120 118 bytes

lambda x:sum({x[i+1][j]*x[i+1][j+2],x[i][j+1]*x[i+2][j+1]}=={2,12}for i in range(len(x)-2)for j in range(len(x[0])-2))

Pruébalo en línea!

Utiliza el hecho de que el producto de pares opuestos de números en la cruz debe ser 2 y 12 respectivamente, y se compara con un conjunto para cubrir todas las diferentes orientaciones. Toma datos como una matriz 2D de enteros.

Será
fuente
1
no tienes que contar f=en el marcador
ngn
2

Japt -x , 39 38 33 bytes

ã3 Ëmã3 y x@[XXy]®g1 ë2 ×Ãn e[2C]

Pruébalo en línea!

-1 byte gracias a @Shaggy.

-5 bytes gracias a @ETHproductions refactorizando la matriz.

Desempaquetado y cómo funciona

Uã3 mD{Dmã3 y xX{[XXy]mZ{Zg1 ë2 r*1} n e[2C]

       Input: 2D Array of numbers
Uã3    Generate an array of length 3 segments of U
mD{    Map... (D = 2D array of numbers having 3 rows)
Dmã3     Map over each row of D to generate an array of length 3 segments
y        Transpose; make an array of 3x3 subsections
xX{      Map and sum... (x = 3x3 2D array of numbers)
[XXy]      Array of X and X transposed
mZ{        Map...
Zg1 ë2 r*1   Take row 1, take 0th and 2nd elements, reduce with *
}
n          Sort the array
e[2C]      Equals [2,12] element-wise?
           Implicit cast from boolean to number

       Result: 1D array of counts
-x     Sum of the result array

No debe todavía ser una mejor manera de probar la cruz ...

Bubbler
fuente
Puede guardar un byte reemplazando la verificación de igualdad al final con e[2C].
Shaggy
Puede deshacerse de la 2de ë2?
Oliver