Simulateur de frère

73

Les frères de l'ordre de St Golfus le Concise ont l'habitude de réciter une courte prière chaque fois qu'ils voient quelqu'un faire le signe de la croix . En raison du niveau élevé de péché observé récemment par les touristes, ceux-ci ont installé un système de vidéosurveillance dans le monastère et ils vous ont embauché pour les aider à garder la vieille tradition vivante à l'ère de l'IA.

Votre tâche consiste à analyser les résultats du logiciel de suivi des doigts des frères et à dire combien de prières doivent être faites. L'entrée est une matrice contenant des entiers compris entre 0 et 4. 1,2,3,4 représentent les positions des doigts à des instants consécutifs. 0 représente les non-doigts.

La One True Way TM pour se croiser, c'est:

.1.
3.4
.2.

("." correspond à n'importe quel chiffre). Cependant, en raison de l'incertitude entourant la rotation de la caméra et de la présence de pieux frères orthodoxes orientaux dans la foule (dont One True Way TM est dans la direction opposée), vous devez également compter toutes les rotations et réflexions:

.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 chiffre peut faire partie de plusieurs croix. Aidez les frères à déterminer le nombre de fois que leur IA devrait .pray()compter en comptant le nombre de sous-matrices 3x3 ci-dessus présentes. Ecrivez un programme ou une fonction. Prenez des entrées sous toute forme convenable raisonnable.

Cas de testament:

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

"Béni soit le plus court des shortests, car il gagne le royaume des upvotes." Livre de St Golfus 13:37

"Tu n'utiliseras pas de meurtrières, car ce sont les mauvaises oeuvres de Lucifer." - Lettre aux Meta 13: 666

Légère visualisation des personnes faisant la croix

Afficher l'extrait de code

Merci @Tschallacka pour la visualisation.

code-golf  matrix 
— ngn
source
57
+1 pour les vers à la fin, ils m'ont bien
— amusé
6
Un chiffre peut-il faire partie de plusieurs croix?
— Martin Ender
9
Oh mon Dieu, tu as fait un simulateur de frère.
— Urne Magic Octopus
1
Pourquoi le premier «T» est-il lié?
— JakeGould
4
@JakeGould Pour relier cette question à la question à laquelle mène le "T".
— Erik the Outgolfer

Réponses:

19

Grime , 20 octets

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

Essayez-le en ligne!

Une implémentation très littérale de la spécification:

  • n` make Grime compte le nombre de sous-segments de l'entrée qui donne une correspondance.

  • .\1./\3.\4/.\2. définit le carré 3x3:

    .1.
3.4
.2.

    Où .peut être n'importe quel personnage.

  • oOest un modificateur d'orientation qui permet à ce rectangle d'apparaître dans n'importe quelle rotation ou réflexion. Le vest utilisé pour réduire la opriorité afin de ne pas avoir besoin de parenthèses autour du carré.
— Martin Ender
source
7
Corrigez pour les deux premiers tests, segfault pour le dernier. Je suppose que cela devrait être acceptable tant que le programme est correct en principe et n’est limité que par des ressources.
— ngn
FYI: Je viens de tester le dernier cas de test et tout s'est bien passé pour moi.
— 3D1T0R
16

Escargots , 17 à 16 octets

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

Essayez-le en ligne!

Explication

Afait que Snails compte le nombre de chemins correspondants possibles dans l’entrée entière. odéfinit la direction de départ sur n'importe quelle direction orthogonale (au lieu de simplement vers l'est). Le motif lui-même est sur la deuxième ligne:

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

Haskell, 108 102 93 octets

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

Essayez-le en ligne!

Pas de regex. Correspondance de modèle

.t.
l.r
.b.

dans le coin supérieur gauche de la matrice, prenez un 1if (l*r-1)*(t*b-1)==11et allez récursivement à droite (lâcher .l.) et vers le bas (lâcher la première ligne). Si le motif ne peut pas être assorti (à droite ou en bas), prenez un 0. Somme tous les résultats.

Edit: -9 octets grâce à @xnor.

— nimi
source
J'allais suggérer 2^(l*r)+2^(t*b)==4100de vérifier les chiffres, mais il semble que nos deux solutions sont trompées 2,6à la place de 3,4.
— xnor
@xnor mais les nombres sont limités à0..4
— urous
3
@ Οurous Merci, ça m'a échappé. Ensuite, les expressions arithmétiques peuvent être optimisées encore plus, comme (l*r-1)*(t*b-1)==11.
— xnor
7

Perl, 70 octets

Comprend +2 pour 0p

Donne la matrice d’entrée sous forme de bloc de chiffres sans espaces sur STDIN:

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

Fait pivoter la croix en tournant les chiffres

— Ton Hospel
source
6

Retina , 92 83 octets

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

Essayez-le en ligne! Explication:

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

Recherchez tous les carrés 3x3 qui se chevauchent. Un regard en arrière capture le retrait deux fois afin qu'il puisse être équilibré sur les deuxième et troisième lignes. L'entrée est supposée être rectangulaire, nous n'avons donc pas à vérifier que les groupes s'équilibrent. Les cellules du centre en bas / haut et les cellules du milieu gauche / droite sont ensuite capturées.

/../_O`.

Triez chaque paire de cellules dans l'ordre.

1234|3412

Comptez les modèles valides restants.

— Neil
source
5

Gelée , 26 octets

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

Essayez-le en ligne!

Explication

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 octets grâce à Jonathan Allan (2) et à M. Xcoder (3) (fusionnés)

— HyperNeutrino
source
@ngn lol le point est censé être sous le D. Mon mauvais, réparé.
— HyperNeutrino
Économisez 2 octets en utilisant ...Fµ€ċ4R¤plutôt que ...Ḍµ€ċ1234(notez également que cela 1234aurait pu être remplacé par ⁽¡ḋpour en économiser un)
— Jonathan Allan
26 octets en utilisant Z3Ƥau lieu de ṡ3Z€et ⁼J$µ€Sau lieu de Ḍµ€ċ1234.
— M. Xcoder
@ JonathanAllan oh cool, merci
— HyperNeutrino
5

Java 8, 135 133 131 octets

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 octets merci à @tehtmi pour une formule plus courte: (l*r-1)*(t*b-1)==11to~(l*r)*~(t*b)==39

Explication:

Essayez-le en ligne.

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
source
1
Formule plus courte: ~(l*r)*~(t*b)==39(Haskell n'a ~apparemment pas 1 octet .)
— tehtmi
3

Coque , 23 octets

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

Essayez-le en ligne!

Explication

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

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

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

Essayez-le en ligne!

— H.PWiz
source
très bon! ⌽∘⊖×⊢pourrait être plus court de 2 octets, pouvez-vous deviner comment?
— NDGN
@ngn Ce que je veux vraiment, c'est un symbole comme ø;)
— H.PWiz
@ngn j'ai×∘⌽∘⊖⍨
— H.PWiz
c'est plus court:(⌽×⊖)
— ngn
Oh, c'est intelligent, vous avez déplacé le selfie (...) vers la gauche ⊢/pour -1. Je n'ai pas pensé à ça. Dans cette situation, vous ne devriez pas me créditer.
— ngn
2

Nettoyer , 255 ... 162 octets

Il n'est pas avantageux d'utiliser souvent des filtres de modèle dans les compréhensions, mais dans ce cas, ça l'est.

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]

Essayez-le en ligne!

Définit la fonction $, en prenant [[Int]]et en revenant Int.

Il génère d’abord toutes les symétries de la matrice m(transformation via f), prend celles tailsqui ont trois rangées ou plus et vérifie de manière synchrone combien des trois premiers ensembles de colonnes de la tailsde chaque rangée correspondent au motif de la croix.

Ceci est équivalent à compter le nombre de commandé tails-OF- tailscorrespondant au motif [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_]- qui est à son tour logiquement identique à vérifier si, pour chaque cellule dans la matrice, cette cellule est le coin supérieur gauche de toute rotation de la croix.

— Οurous
source
2

Python 3, 120 118 octets

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

Essayez-le en ligne!

Utilise le fait que le produit des paires opposées de nombres dans la croix doit être 2 et 12 respectivement, et se compare à un ensemble pour couvrir toutes les orientations différentes. Prend l'entrée sous forme de tableau 2D d'entiers.

— Volonté
source
1
vous ne devez pas compter f=dans le score
— ngn
2

Japt -x , 39 38 33 octets

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

Essayez-le en ligne!

-1 octet grâce à @Shaggy.

-5 octets grâce à @ETHproductions en refacturant le tableau.

Déballé et comment ça marche

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

Il devrait encore y avoir un meilleur moyen de tester la croix ...

— Barboteur
source
Vous pouvez sauvegarder un octet en remplaçant le contrôle d'égalité à la fin par e[2C].
— Shaggy
Pouvez - vous vous débarrasser de l' 2en ë2?
— Oliver
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.