Simulador de frei

73

Os irmãos da ordem de São Golfo, o Conciso, têm a tradição de recitar uma breve oração sempre que vêem alguém fazer o sinal da cruz . Devido ao alto nível de pecado medido entre os turistas recentemente, eles instalaram o sistema de CFTV no mosteiro e contrataram você para ajudá-los a manter a velha tradição viva na era da IA.

Sua tarefa é analisar a produção do software de rastreamento de dedos dos frades e dizer quantas orações são devidas. A entrada é uma matriz contendo números inteiros entre 0 e 4. 1,2,3,4 representam as posições dos dedos em momentos consecutivos no tempo. 0 representa não dedos.

O One True Way TM para atravessar a si mesmo é:

.1.
3.4
.2.

("." corresponde a qualquer dígito). No entanto, devido à incerteza sobre a rotação da câmera e à presença de piedosos irmãos ortodoxos orientais na multidão (cuja One True Way TM está na direção oposta lateral), você deve contar todas as rotações e reflexões também:

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

Um dígito pode fazer parte de várias cruzes. Ajude os frades a determinar o número de vezes que sua IA deve .pray()contar contando quantas das submatrizes 3x3 acima estão presentes. Escreva um programa ou uma função. Receba informações de qualquer forma conveniente e razoável.

Casos de 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 seja o menor dos mais curtos, porque vence o reino dos votos positivos." Livro de São Golfo 13:37

"Não usarás brechas, pois são as obras perversas de Lúcifer." - Carta ao Meta 13: 666

Ligeira visualização de pessoas que fazem a cruz

Mostrar snippet de código

Obrigado @Tschallacka pela visualização.

code-golf  matrix 
— ngn
fonte
57
+1 nos versículos no final, eles me deram uma boa risada: D
— HyperNeutrino
6
Um dígito pode fazer parte de várias cruzes?
— Martin Ender
9
Oh, doce Jesus, você fez um simulador de Frei.
— Magic Octopus Urn
11
Por que o primeiro "T" está vinculado?
— JakeGould
4
@JakeGould Para vincular esta pergunta à pergunta que o "T" leva.
— Erik the Outgolfer

Respostas:

19

Grime , 20 bytes

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

Experimente online!

Uma implementação muito literal da especificação:

  • n` faça o Grime contar o número de sub-retângulos da entrada que produzem uma correspondência.

  • .\1./\3.\4/.\2. define o quadrado 3x3:

    .1.
3.4
.2.

    Onde .pode haver qualquer personagem.

  • oOé um modificador de orientação que permite que esse retângulo apareça em qualquer rotação ou reflexão. O vé usado para diminuir oa precedência de s, para que não precisemos de parênteses ao redor do quadrado.
— Martin Ender
fonte
7
Corrija para os dois primeiros testes, segfault para o último. Eu acho que isso deve ficar bom, desde que o programa esteja correto em princípio e seja limitado apenas por recursos.
— NGN
FYI: Acabei de testar o último caso de teste e ele correu bem para mim.
— 3D1T0R
16

Caracóis , 17 16 bytes

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

Experimente online!

Explicação

Afaz com que o Snails conte o número de possíveis caminhos correspondentes em toda a entrada. odefine a direção inicial para qualquer direção ortogonal (em vez de apenas para o leste). O padrão em si está na segunda linha:

\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
fonte
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

Experimente online!

Sem regex. Correspondência de padrões

.t.
l.r
.b.

no canto superior esquerdo da matriz, faça um 1if (l*r-1)*(t*b-1)==11e recursivamente vá para a direita (solte .l.) e para baixo (solte a primeira linha). Se o padrão não puder ser correspondido (na borda direita ou inferior), faça a 0. Soma todos os resultados.

Edit: -9 bytes graças a @xnor.

— nimi
fonte
Eu sugeriria 2^(l*r)+2^(t*b)==4100verificar os números, mas parece que nossas soluções são enganadas 2,6no lugar de 3,4.
— Xnor
@xnor mas os números estão restritos a0..4
— Οurous
3
@ Ousurous Obrigado, eu perdi isso. Então expressões aritméticas podem ser otimizadas ainda mais, como (l*r-1)*(t*b-1)==11.
— Xnor
7

Perl, 70 bytes

Inclui +2 para 0p

Dê matriz de entrada como um bloco de dígitos sem espaços no STDIN:

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

Gira a cruz girando os dígitos

— Ton Hospel
fonte
6

Retina , 92 83 bytes

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

Experimente online! Explicação:

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

Procure todos os quadrados 3x3 sobrepostos. Um lookbehind captura o recuo duas vezes para que ele possa ser equilibrado na segunda e terceira linhas. A entrada é assumida como retangular, portanto não precisamos verificar se os grupos estão equilibrados. As células do meio inferior / superior e as células do meio esquerda / direita são capturadas.

/../_O`.

Classifique cada par de células em ordem.

1234|3412

Conte os padrões válidos restantes.

— Neil
fonte
5

Geléia , 26 bytes

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

Experimente online!

Explicação

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 graças a Jonathan Allan (2) e Sr. Xcoder (3) (mesclado)

— HyperNeutrino
fonte
@ngn lol o ponto é para estar sob o D. Meu mal, fixo.
— HyperNeutrino
Salvar 2 bytes utilizando ...Fµ€ċ4R¤, em vez de ...Ḍµ€ċ1234(note também que 1234poderia ter sido substituído por ⁽¡ḋsalvar um)
— Jonathan Allan
26 bytes usando em Z3Ƥvez de ṡ3Z€e em ⁼J$µ€Svez de Ḍµ€ċ1234.
— Mr. Xcoder
@JonathanAllan oh legal, graças
— 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 graças a @tehtmi para uma fórmula mais curta: (l*r-1)*(t*b-1)==11para~(l*r)*~(t*b)==39

Explicação:

Experimente online.

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
fonte
11
Fórmula mais curto: ~(l*r)*~(t*b)==39(Haskell que não tem um byte ~aparentemente.)
— tehtmi
3

Casca , 23 bytes

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

Experimente online!

Explicação

#ö§&¦ḣ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
fonte
3

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

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

Experimente online!

— H.PWiz
fonte
muito bom! ⌽∘⊖×⊢pode ser menor em 2 bytes, você consegue adivinhar como?
— NGN
@ngn O que eu realmente quero é um símbolo, como o;)
— H.PWiz
@ngn I have×∘⌽∘⊖⍨
— H.PWiz
isso é mais curto:(⌽×⊖)
— ngn 06/02/19
Ah, isso é inteligente, você moveu a selfie (... ⍨) para a esquerda ⊢/para mais -1. Eu não pensei nisso. Nesta situação, você não deveria me creditar.
— NGN
2

Limpo , 255 ... 162 bytes

Não é benéfico usar frequentemente filtros de padrão nas compreensões, mas, neste caso, é.

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]

Experimente online!

Define a função $, recebendo [[Int]]e retornando Int.

Primeiro, gera todas as simetrias da matriz m(transformando via f), pega as tailsquais têm três ou mais linhas e verifica de forma síncrona quantos dos três primeiros conjuntos de colunas da tailslinha correspondente correspondem ao padrão da cruz.

Isto é equivalente à contagem do número de pedi tails-of- tailscorrespondente ao padrão [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_]- que por sua vez é logicamente a mesma que a verificação se, para cada célula na matriz, que é a célula canto superior esquerdo de qualquer rotação da cruz.

— Furioso
fonte
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))

Experimente online!

Usa o fato de que o produto de pares de números opostos na cruz deve ser 2 e 12, respectivamente, e se compara a um conjunto para cobrir todas as orientações diferentes. Recebe a entrada como uma matriz 2D de números inteiros.

— Vai
fonte
11
você não precisa contar f=na pontuação
— ngn 6/18
2

Japt -x , 39 38 33 bytes

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

Experimente online!

-1 byte graças a @Shaggy.

-5 bytes graças a @ETHproductions refatorando a matriz.

Descompactado e como 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

Deve ainda haver uma maneira melhor para testar a cruz ...

— Bubbler
fonte
Você pode salvar um byte, substituindo a verificação de igualdade no final por e[2C].
— Salsicha
Você pode se livrar do 2in ë2?
— Oliver
Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.
Licensed under cc by-sa 3.0 with attribution required.