Simulatore frate

73

I fratelli dell'ordine di San Golfus il Conciso hanno la tradizione di recitare una breve preghiera ogni volta che vedono qualcuno che fa il segno della croce . A causa dell'elevato livello di peccato misurato recentemente tra i turisti, hanno installato telecamere a circuito chiuso nel monastero e ti hanno assunto per aiutarli a mantenere viva la vecchia tradizione nell'era dell'IA.

Il tuo compito è analizzare l'output del software di monitoraggio delle dita dei frati e dire quante preghiere sono dovute. L'input è una matrice contenente numeri interi compresi tra 0 e 4. 1,2,3,4 rappresentano le posizioni delle dita in momenti consecutivi nel tempo. 0 rappresenta non dita.

L'unico vero modo TM per incrociarsi è:

.1.
3.4
.2.

("." corrisponde a qualsiasi cifra). Tuttavia, a causa dell'incertezza sulla rotazione della telecamera e sulla presenza di pii fratelli ortodossi orientali nella folla (il cui One True Way TM è nella direzione opposta lateralmente), dovresti contare anche tutte le rotazioni e le riflessioni:

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

Una cifra può far parte di più croci. Aiuta i frati a determinare il numero di volte in cui la loro IA dovrebbe .pray()contare contando quante delle precedenti matrici 3x3 presenti. Scrivi un programma o una funzione. Prendi input in qualsiasi forma conveniente conveniente.

Testamenti:

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

"Sia benedetto il più breve dei più corti, perché vince il regno dei voti." -Libro di St Golfus 13:37

"Non userai scappatoie, perché sono le opere malvagie di Lucifero." -Letter a Meta 13: 666

Leggera visualizzazione delle persone che fanno la croce

Mostra snippet di codice

Grazie @Tschallacka per la visualizzazione.

code-golf  matrix 
— NGN
fonte
57
+1 per i versi alla fine, mi hanno fatto una bella risata: D
— HyperNeutrino
6
Una cifra può far parte di più croci?
— Martin Ender,
9
Oh dolce Gesù, hai fatto un simulatore Frate.
— Magic Octopus Urn,
1
Perché la prima "T" è collegata?
— Jake Gould
4
@JakeGould Per collegare questa domanda alla domanda che porta la "T".
— Erik the Outgolfer,

Risposte:

19

Grime , 20 byte

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

Provalo online!

Un'implementazione molto letterale delle specifiche:

  • n` fai in modo che Grime conti il ​​numero di sottorecuperi dell'input che producono una corrispondenza.

  • .\1./\3.\4/.\2. definisce il quadrato 3x3:

    .1.
3.4
.2.

    Dove .può essere qualsiasi personaggio.

  • oOè un modificatore di orientamento che consente a questo rettangolo di apparire in qualsiasi rotazione o riflesso. Il vè usato per abbassare os precedenza in modo che non abbiamo bisogno di parentesi intorno alla piazza.
— Martin Ender
fonte
7
Corretto per i primi due test, segfault per l'ultimo. Immagino che questo dovrebbe andare bene finché il programma è corretto in linea di principio ed è limitato solo dalle risorse.
— ngn
Cordiali saluti: Ho appena testato l'ultimo caso di test e ha funzionato bene per me.
— 3D1T0R
16

Lumache , 17 16 byte

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

Provalo online!

Spiegazione

Afa sì che le lumache contino il numero di possibili percorsi corrispondenti nell'intero input. oimposta la direzione iniziale su qualsiasi direzione ortogonale (anziché solo verso est). Il modello stesso è sulla seconda riga:

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

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

Provalo online!

Nessuna regex. Corrispondenza del modello

.t.
l.r
.b.

nell'angolo in alto a sinistra della matrice, prendi un 1if (l*r-1)*(t*b-1)==11e ricorsivamente vai a destra (rilascia .l.) e in basso (rilascia la prima riga). Se non è possibile abbinare il motivo (sul bordo destro o inferiore) prendere a 0. Somma tutti i risultati.

Modifica: -9 byte grazie a @xnor.

— Nome del modello
fonte
Stavo per suggerire 2^(l*r)+2^(t*b)==4100di controllare i numeri, ma sembra che entrambe le nostre soluzioni siano state ingannate 2,6al posto di 3,4.
— xnor
@xnor ma i numeri sono limitati a0..4
— Οurous
3
@ Grazie mille, mi sono perso. Quindi le espressioni aritmetiche possono essere ottimizzate ancora di più, come (l*r-1)*(t*b-1)==11.
— xnor
7

Perl, 70 byte

Include +2 per 0p

Dai una matrice di input come un blocco di cifre senza spazi su STDIN:

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

Ruota la croce ruotando le cifre

— Ton Hospel
fonte
6

Retina , 92 83 byte

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

Provalo online! Spiegazione:

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

Cerca tutti i quadrati 3x3 sovrapposti. Uno sguardo dietro cattura il rientro due volte in modo che possa essere bilanciato sulla seconda e terza riga. Si presume che l'input sia rettangolare, quindi non è necessario verificare il bilanciamento dei gruppi. Vengono quindi catturate le celle centrali inferiori / superiori e le celle centrali sinistra / destra.

/../_O`.

Ordina ogni coppia di celle in ordine.

1234|3412

Conta i restanti schemi validi.

— Neil
fonte
5

Gelatina , 26 byte

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

Provalo online!

Spiegazione

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 byte grazie a Jonathan Allan (2) e Mr. Xcoder (3) (uniti)

— HyperNeutrino
fonte
@ngn lol il punto è pensato per essere sotto il D. Mio cattivo, risolto.
— HyperNeutrino,
Salva 2 byte usando ...Fµ€ċ4R¤invece di ...Ḍµ€ċ1234(nota anche che 1234avrebbe potuto essere sostituito da ⁽¡ḋper salvarne uno)
— Jonathan Allan
26 byte usando Z3Ƥinvece di ṡ3Z€e ⁼J$µ€Sinvece di Ḍµ€ċ1234.
— Mr. Xcoder,
@JonathanAllan oh fantastico, grazie
— HyperNeutrino il
5

Java 8, 135 133 131 byte

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 byte grazie a @tehtmi per una formula più breve: (l*r-1)*(t*b-1)==11a~(l*r)*~(t*b)==39

Spiegazione:

Provalo 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
1
Formula più breve: ~(l*r)*~(t*b)==39( ~apparentemente Haskell non ha 1 byte .)
— tehtmi
3

Buccia , 23 byte

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

Provalo online!

Spiegazione

#ö§&¦ḣ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 byte ( SBSC )

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

Provalo online!

— H.PWiz
fonte
molto bene! ⌽∘⊖×⊢potrebbe essere più breve di 2 byte, puoi indovinare come?
— ngn
@ngn Quello che voglio davvero è un simbolo come ø;)
— H.Pw,
@ngn I have×∘⌽∘⊖⍨
— H.PWiz,
questo è più breve:(⌽×⊖)
— ngn
Oh, è intelligente, hai spostato il selfie (... ⍨) a sinistra di ⊢/un altro -1. Non ci ho pensato. In questa situazione non dovresti farmi credito.
— ngn,
2

Gelatina , 36 byte

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

Provalo online!

37 byte

Per qualche motivo non riesco a spostare il Ḋm2$$collegamento in alto.

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

Provalo online!

— fireflame241
fonte
2

Pulito , 255 ... 162 byte

Non è utile che spesso usi i filtri di pattern per comprendere, ma in questo caso lo è.

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]

Provalo online!

Definisce la funzione $, prendendo [[Int]]e ritornando Int.

In primo luogo genera tutte le simmetrie della matrice m(trasformando via f), prende le tailscui hanno tre o più righe e verifica in modo sincrono quante delle prime tre serie di colonne tailsdi ciascuna riga corrispondono al modello della croce.

Ciò equivale a contare il numero di ordinate tails-of- tailscorrispondenti al modello [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_]- che è a sua volta logicamente lo stesso che verificare se, per ogni cella della matrice, quella cella è l'angolo superiore sinistro di qualsiasi rotazione della croce.

— Οurous
fonte
2

Python 3, 120 118 byte

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

Provalo online!

Utilizza il fatto che il prodotto di coppie opposte di numeri nella croce deve essere rispettivamente 2 e 12 e confronta con un set per coprire tutti i diversi orientamenti. Accetta input come una matrice 2D di numeri interi.

— Volontà
fonte
1
non devi contare f=nel punteggio
— ngn
2

Japt -x , 39 38 33 byte

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

Provalo online!

-1 byte grazie a @Shaggy.

-5 byte grazie a @ETHproductions refactoring dell'array.

Disimballato e come funziona

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

Dovrebbe esserci ancora un modo migliore per testare la croce ...

— bubbler
fonte
È possibile salvare un byte sostituendo il controllo di uguaglianza alla fine con e[2C].
— Shaggy,
Puoi sbarazzarti di 2dentro ë2?
— Oliver
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.