Ieri ho lasciato il mio panino sul tavolo. Quando mi sono alzato oggi, c'era un morso ... Era mio? Non ricordo

Problema:

Prendi una rappresentazione del sandwich e del mio schema del morso e dimmi se era il mio morso o meno.

Esempi:

Esempio 1:

Il mio modello di morso:

..
.

Sandwich:

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

Produzione:

truthy

Esempio 2:

Il mio modello di morso:

..
..

Sandwich:

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

Produzione:

falsy

Esempio 3:

Se esiste almeno 1 rotazione che conta come verità, l'output è verità.

Il mio modello di morso:

.
 .
  .

Sandwich:

##.
#.#
.##

Produzione:

Due possibili rotazioni (mordere nell'angolo nord-est o sud-ovest).

truthy

Alcuni morsi validi:

..
.

...
.
.

.
 .
  .

..
. .
 ..

 ..
.
. .

Alcuni morsi non validi:

..

...
.

..
.
 .

Regole:

• Il mio orientamento del morso sarà sempre per mordere l'angolo nord-ovest. E deve essere ruotato per mordere altri angoli;

• Ci sarà sempre 1 e solo 1 morso nel sandwich;

• Il morso nel sandwich può essere in uno dei 4 angoli (ruotato di conseguenza);

• I motivi del morso saranno sempre simmetrici lungo la diagonale principale;

• I modelli di morso saranno sempre almeno 1 di larghezza e non vuoti;

• Il sandwich sarà sempre un rettangolo con larghezza e altezza uguali o maggiori della larghezza del mio modello di morso;

• Nel tuo input, puoi scegliere 2 caratteri distinti non bianchi per rappresentare il sandwich e il morso;

• Gli spazi nel modello del morso indicano che il mio morso non tocca quella parte del panino.

Rubino , 103 byte 101 byte

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

Provalo online!

Salvato 2 byte spostando l'assegnazione al primo utilizzo di a. Apparentemente Ruby è abbastanza intelligente da non confondere le virgole nella definizione dell'array e le virgole che deriverebbero dall'assegnazione variabile simultanea (almeno in questo caso: D)

Python 2 , 134 byte

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

Accetta input come due elenchi di stringhe (una per ogni riga). Non presuppone spazi vuoti finali sulle linee.

Provalo online!

Esempi:

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

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

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

Python 2, 173 byte

Provalo 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

Accetta input come due elenchi di elenchi di caratteri.
Primo - sandwich
Secondo - morso

Innanzitutto estende l'array di morsi alle dimensioni dell'array di sandwich:

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]sostituisce tutti gli spazi per #
(L(S[0])-L(x)),b+[[]]*(L(S)-L(b))calcolare il numero di elementi mancanti

Quindi confronta tutte e 4 le rotazioni di questo morso "esteso" con il sandwich:

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 viene utilizzato per specchiare l'elenco di elenchi in orizzontale

Nell'esempio collegato sandwich è:

##.
#.#
###

E morso è:

.
 .