Symulator Friar

73

T on braci z rzędu St Golfus zwięzłej mają tradycję recytując krótką modlitwę, gdy widzą kogoś uczynić znak krzyża . Ze względu na wysoki poziom grzechu mierzony ostatnio wśród turystów, zainstalowali CCTV w klasztorze i zatrudnili cię, aby pomóc im utrzymać dawną tradycję w erze AI.

Twoim zadaniem jest analiza wyników pochodzących z oprogramowania do śledzenia palców braci i określenie liczby modlitw. Dane wejściowe to macierz zawierająca liczby całkowite od 0 do 4. 1,2,3,4 przedstawia pozycje palców w kolejnych momentach w czasie. 0 oznacza brak palców.

One True Way TM, aby się skrzyżować, to:

.1.
3.4
.2.

(„.” pasuje do dowolnej cyfry). Jednak z powodu niepewności co do obrotu kamery i obecności pobożnych braci prawosławnych w tłumie (których One True Way TM jest w przeciwnym kierunku na boki), należy również policzyć wszystkie obroty i odbicia:

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

Jedna cyfra może być częścią wielu krzyżyków. Pomóż braciom w określeniu, ile razy ich AI powinna .pray(), licząc, ile z powyższych submatric 3x3 jest obecnych. Napisz program lub funkcję. Wprowadź dane w dowolnej rozsądnej dogodnej formie.

Przypadki testamentu:

// 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łogosławiony najkrótszy z najkrótszych, albowiem zwycięża królestwo zwolenników”. -Book of St Golfus 13:37

„Nie będziesz używać luk, bo są to niegodziwe uczynki Lucyfera”. - List do Meta 13: 666

Nieznaczna wizualizacja ludzi wykonujących krzyż

Pokaż fragment kodu

Dzięki @Tschallacka za wizualizację.

code-golf  matrix 
— ngn
źródło
57
+1 za wersety na końcu dały mi dobry śmiech: D
— HyperNeutrino
6
Czy jedna cyfra może być częścią wielu krzyżyków?
— Martin Ender
9
O, słodki Jezu, stworzyłeś symulator Brata.
— Magic Octopus Urn
1
Dlaczego pierwsza „T” jest połączona?
— JakeGould,
4
@JakeGould Aby połączyć to pytanie z pytaniem, do którego prowadzi „T”.
— Erik the Outgolfer

Odpowiedzi:

19

Brud , 20 bajtów

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

Wypróbuj online!

Bardzo dosłowne wdrożenie specyfikacji:

  • n` sprawiają, że Grime zlicza liczbę podprostokątów danych wejściowych, które dają dopasowanie.

  • .\1./\3.\4/.\2. definiuje kwadrat 3x3:

    .1.
3.4
.2.

    Gdzie .może być dowolna postać.

  • oOjest modyfikatorem orientacji, który pozwala, aby ten prostokąt pojawiał się w dowolnym obrocie lub odbiciu. vSłuży do obniżenia oów pierwszeństwo tak, że nie potrzebujemy nawiasów wokół placu.
— Martin Ender
źródło
7
Poprawne dla pierwszych dwóch testów, segfault dla ostatnich. Myślę, że powinno to być w porządku, o ile program jest w zasadzie poprawny i jest ograniczony tylko zasobami.
— ngn
FYI: Właśnie przetestowałem ostatni przypadek testowy i dla mnie działał dobrze.
— 3D1T0R
16

Ślimaki , 17 16 bajtów

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

Wypróbuj online!

Wyjaśnienie

Asprawia, że ​​Ślimaki liczą liczbę możliwych pasujących ścieżek na całym wejściu. oustawia kierunek początkowy na dowolny kierunek ortogonalny (zamiast tylko na wschód). Sam wzór znajduje się w drugiej linii:

\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
źródło
7

Haskell, 108 102 93 bajty

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

Wypróbuj online!

Brak wyrażenia regularnego. Dopasuj wzór

.t.
l.r
.b.

w lewym górnym rogu matrycy weź 1if (l*r-1)*(t*b-1)==11i rekurencyjnie przejdź w prawo (upuść .l.) i w dół (upuść pierwszy rząd). Jeśli wzoru nie można dopasować (na prawej lub dolnej granicy), wybierz a 0. Zsumuj wszystkie wyniki.

Edycja: -9 bajtów dzięki @xnor.

— nimi
źródło
Chciałem zaproponować 2^(l*r)+2^(t*b)==4100sprawdzenie liczb, ale wydaje się, że oba nasze rozwiązania są oszukiwane 2,6w miejsce 3,4.
— xnor
@ xnor, ale liczby są ograniczone do0..4
— Οurous
3
@ Οurous Dzięki, tęskniłem za tym. Następnie wyrażenia arytmetyczne można jeszcze bardziej zoptymalizować (l*r-1)*(t*b-1)==11.
— xnor
7

Perl, 70 bajtów

Obejmuje +2 za 0p

Podaj macierz wejściową jako blok cyfr bez spacji na STDIN:

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

Obraca krzyż, obracając cyfry

— Ton Hospel
źródło
6

Retina , 92 83 bajty

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

Wypróbuj online! Wyjaśnienie:

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

Poszukaj wszystkich nakładających się kwadratów 3x3. Lookbehind przechwytuje wcięcie dwa razy, dzięki czemu można je wyrównać na drugiej i trzeciej linii. Zakłada się, że dane wejściowe są prostokątne, więc nie musimy sprawdzać, czy grupy się równoważą. Następnie przechwytuje się dolne / górne środkowe komórki i lewe / prawe środkowe komórki.

/../_O`.

Posortuj każdą parę komórek w kolejności.

1234|3412

Policz pozostałe prawidłowe wzorce.

— Neil
źródło
5

Galaretka , 26 bajtów

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

Wypróbuj online!

Wyjaśnienie

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 bajty dzięki Jonathanowi Allanowi (2) i Mr. Xcoderowi (3) (połączone)

— HyperNeutrino
źródło
@ngn lol kropka ma być pod D. Mój zły, naprawiony.
— HyperNeutrino
Zaoszczędź 2 bajty, używając ...Fµ€ċ4R¤zamiast ...Ḍµ€ċ1234(zwróć też uwagę, że 1234można by je zastąpić, ⁽¡ḋaby zapisać jeden)
— Jonathan Allan
26 bajtów przy użyciu Z3Ƥzamiast ṡ3Z€i ⁼J$µ€Szamiast Ḍµ€ċ1234.
— Pan Xcoder,
@JonathanAllan oh cool, dzięki
— HyperNeutrino
5

Java 8, 135 133 131 bajtów

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 bajty dzięki @tehtmi za krótszą formułę: (l*r-1)*(t*b-1)==11do~(l*r)*~(t*b)==39

Wyjaśnienie:

Wypróbuj 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
źródło
1
Krótsza formuła: ~(l*r)*~(t*b)==39(Haskell ~najwyraźniej nie ma 1 bajtu .)
— tehtmi
3

Łuska , 23 bajty

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

Wypróbuj online!

Wyjaśnienie

#ö§&¦ḣ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
źródło
3

Dyalog APL , 30 29 28 27 26 bajtów ( SBSC )

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

Wypróbuj online!

— H.PWiz
źródło
bardzo dobre! ⌽∘⊖×⊢może być krótszy o 2 bajty, zgadnij jak?
— ngn
@ngn Naprawdę chcę takiego symbolu jak ø;)
— H.PWiz
@ngn Mam×∘⌽∘⊖⍨
— H.PWiz
jest to krótsze:(⌽×⊖)
— ngn
Och, to sprytne, przesunąłeś selfie (... ⍨) na lewo od ⊢/kolejnego -1. Nie myślałem o tym. W tej sytuacji nie powinieneś mnie przypisywać.
— ngn
2

Czysty , 255 ... 162 bajtów

Często nie jest korzystne stosowanie filtrów wzorca w zrozumieniu, ale w tym przypadku tak jest.

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]

Wypróbuj online!

Definiuje funkcję $, przyjmowanie [[Int]]i powrót Int.

Najpierw generuje wszystkie symetrie macierzy m(przekształcając przez f), tailsz których te mają trzy lub więcej wierszy, i synchronicznie sprawdza, ile pierwszych trzech zestawów kolumn z tailskażdego wiersza pasuje do wzoru krzyża.

Jest to równoważne licząc liczbę uszeregowanych tails-of- tailsdopasowanie wzorca [[_,1,_:_],[3,_,4:_],[_,2,_:_]:_]- która z kolei jest logicznie tym samym sprawdzenie, czy dla każdej komórki w macierzy, że komórka jest w lewym górnym rogu każdej obrotu przekroju.

— Obrzydliwe
źródło
2

Python 3, 120 118 bajtów

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

Wypróbuj online!

Wykorzystuje fakt, że iloczyn przeciwnych par liczb w krzyżu musi wynosić odpowiednio 2 i 12, i porównuje z zestawem obejmującym wszystkie różne orientacje. Pobiera dane wejściowe jako tablicę liczb całkowitych 2D.

— Będzie
źródło
1
nie musisz liczyć się f=do wyniku
— ngn
2

Japt -x , 39 38 33 bajtów

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

Wypróbuj online!

-1 bajt dzięki @Shaggy.

-5 bajtów dzięki @ETHproductions przez refaktoryzację tablicy.

Rozpakowane i jak to działa

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

Nie powinno nadal być lepszym sposobem na przetestowanie na krzyżu ...

— Bubbler
źródło
Możesz zapisać bajt, zastępując na końcu kontrolę równości e[2C].
— Kudłaty
Można pozbyć 2się w hotelu ë2?
— Oliver
Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.