Ayer dejé mi sándwich en la mesa. Cuando me levanté hoy, había un mordisco ... ¿Era mío? No me acuerdo ...

Problema:

Tome una representación del sándwich y mi patrón de mordida y dígame si fue mi mordida o no.

Ejemplos:

Ejemplo 1:

Mi patrón de mordida:

..
.

Emparedado:

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

Salida:

truthy

Ejemplo 2

Mi patrón de mordida:

..
..

Emparedado:

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

Salida:

falsy

Ejemplo 3

Si hay al menos 1 rotación que cuenta como verdadera, la salida es verdadera.

Mi patrón de mordida:

.
 .
  .

Emparedado:

##.
#.#
.##

Salida:

Dos rotaciones posibles (mordiendo en la esquina noreste o suroeste).

truthy

Algunas picaduras válidas:

..
.

...
.
.

.
 .
  .

..
. .
 ..

 ..
.
. .

Algunas picaduras inválidas:

..

...
.

..
.
 .

Reglas:

• La orientación de mi patrón de mordida siempre será para morder la esquina noroeste. Y debe girarse para morder otras esquinas;

• Siempre habrá 1 y solo 1 bocado en el emparedado;

• La mordida en el emparedado puede estar en cualquiera de los 4 córneos (rotados en consecuencia);

• Los patrones de mordida siempre serán simétricos a lo largo de la diagonal principal;

• Los patrones de mordida siempre serán al menos 1 de ancho y no vacíos;

• El sándwich siempre será un rectángulo con un ancho y una altura igual o mayor que el ancho de mi patrón de mordida;

• En su entrada, puede elegir cualquier 2 caracteres distintos que no sean espacios en blanco para representar el sándwich y la mordida;

• Los espacios en el patrón de mordida significan que mi mordida no toca esa parte del sándwich.

Ruby , 103 bytes 101 bytes

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

Pruébalo en línea!

Ahorró 2 bytes moviendo la asignación al primer uso de a. Aparentemente, Ruby es lo suficientemente inteligente como para no confundir las comas en la definición de matriz y las comas que surgirían de la asignación variable simultánea (al menos en este caso: D)

Python 2 , 134 bytes

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

Toma la entrada como dos listas de cadenas (una para cada línea). Asume que no hay espacios en blanco al final de las líneas.

Pruébalo en línea!

Ejemplos:

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

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

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

Python 2, 173 bytes

Pruébalo en línea

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

Toma entrada como dos listas de listas de caracteres.
Primero - sandwich
Segundo - mordisco

Primero extiende la matriz de mordida al tamaño de la matriz de emparedado:

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]reemplaza todos los espacios para #
(L(S[0])-L(x)),b+[[]]*(L(S)-L(b))calcular el número de elementos faltantes

Luego compara las 4 rotaciones de esta mordida "extendida" con el emparedado:

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 se utiliza para reflejar la lista de listas horizontalmente

En el ejemplo vinculado, sandwich es:

##.
#.#
###

Y la mordida es:

.
 .