Wczoraj zostawiłem kanapkę na stole. Kiedy dzisiaj wstałem, poczułam, że coś gryzie ... Czy to było moje? Nie pamiętam ...

Problem:

Zrób reprezentację wzoru kanapki i mojego zgryzu i powiedz, czy to był mój zgryz, czy nie.

Przykłady:

Przykład 1:

Mój wzór ugryzienia:

..
.

Kanapka:

#####
.####
..###

Wynik:

truthy

Przykład 2:

Mój wzór ugryzienia:

..
..

Kanapka:

...##
..###
.####

Wynik:

falsy

Przykład 3:

Jeśli istnieje co najmniej 1 obrót, który liczy się jako prawda, wynik jest prawdziwy.

Mój wzór ugryzienia:

.
 .
  .

Kanapka:

##.
#.#
.##

Wynik:

Dwie możliwe rotacje (gryzienie w północno-wschodnim lub południowo-zachodnim rogu).

truthy

Niektóre ważne brania:

..
.

...
.
.

.
 .
  .

..
. .
 ..

 ..
.
. .

Niektóre nieprawidłowe brania:

..

...
.

..
.
 .

Zasady:

• Moja orientacja wzoru ugryzienia będzie zawsze dotyczyła gryzienia północno-zachodniego rogu. I muszą być obracane, aby gryźć inne rogi;

• W kanapce zawsze będzie 1 i tylko 1 kęs;

• Ugryzienie kanapki może nastąpić w dowolnym z 4 rogów (odpowiednio obróconych);

• Wzory zgryzu zawsze będą symetryczne wzdłuż głównej przekątnej;

• Wzory zgryzu zawsze będą miały co najmniej 1 szerokość i nie będą puste;

• Kanapka zawsze będzie prostokątem o szerokości i wysokości równej lub większej niż szerokość mojego wzoru zgryzu;

• W danych wejściowych możesz wybrać dowolne 2 różne znaki niebiałe, aby reprezentować kanapkę i ugryzienie;

• Odstępy we wzorze zgryzu oznaczają, że mój zgryz nie dotyka tej części kanapki.

Rubinowy , 103 bajty 101 bajtów

->b,s{[a=s.map(&:reverse),s,s.reverse,a.reverse].any?{|t|b.zip(t).all?{|y,x|y==x.tr(?#,' ').rstrip}}}

Wypróbuj online!

Zaoszczędzono 2 bajty, przenosząc przypisanie do pierwszego użycia znaku a. Najwyraźniej Ruby jest wystarczająco sprytny, aby nie mylić przecinków w definicji tablicy i przecinków, które powstałyby z jednoczesnego przypisania zmiennych (przynajmniej w tym przypadku: D)

Python 2 , 134 bajty

b,s=input()
a=[''.join(l[::-1])for l in s]
print any(b==[l.replace('#',' ').rstrip()for l in x][:len(b)]for x in(a,a[::-1],s[::-1],s))

Pobiera dane wejściowe jako dwie listy ciągów (po jednej dla każdej linii). Nie zakłada końcowych spacji w liniach.

Wypróbuj online!

Przykłady:

Input: ['..','.'],['#####','.####','..###'] (example 1)
>True

Input: ['..','..'],['...##','..###','.####'] (example 2)
>False

Input: ['',' .'],['#####','#.###','#####'] (no bite in top row)
>True

Python 2, 173 bajtów

Wypróbuj online

S,b=input()
L=len
B=map(lambda x:[y<'.'and'#'or y for y in x]+['#']*(L(S[0])-L(x)),b+[[]]*(L(S)-L(b)))
R=map(lambda x:x[::-1],B)
print S==B or S==B[::-1]or S==R[::-1]or S==R

Pobiera dane wejściowe jako dwie listy list znaków.
Po pierwsze - kanapka
Po drugie - ugryzienie

Najpierw rozszerza tablicę zgryzów do rozmiaru tablicy kanapkowej:

B=map(lambda x:[y<'.'and'#'or y for y in x]+['#']*(L(S[0])-L(x)),b+[[]]*(L(S)-L(b)))

[y<'.'and'#'or y for y in x]zastępuje wszystkie spacje, aby #
(L(S[0])-L(x)),b+[[]]*(L(S)-L(b))obliczyć liczbę brakujących elementów

Następnie porównuje wszystkie 4 obroty tego „przedłużonego” ugryzienia z kanapką:

R=lambda:map(lambda x:x[::-1],B)
print S==B or S==B[::-1]or S==R()or S==R()[::-1]
print any(map(S.__eq__,[B,B[::-1],R(),R()[::-1]])) #longer but pretty

lambda R służy do tworzenia kopii lustrzanej listy w poziomie

W połączonym przykładzie kanapka to:

##.
#.#
###

A ugryzienie to:

.
 .