Ontem, deixei meu sanduíche na mesa. Quando me levantei hoje, havia uma mordida ... Era minha? Não me lembro ...

Problema:

Faça uma representação do sanduíche e do meu padrão de mordida e me diga se foi minha mordida ou não.

Exemplos:

Exemplo 1:

Meu padrão de mordida:

..
.

Sanduíche:

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

Resultado:

truthy

Exemplo 2:

Meu padrão de mordida:

..
..

Sanduíche:

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

Resultado:

falsy

Exemplo 3:

Se houver pelo menos 1 rotação que conta como verdade, a saída é verdadeira.

Meu padrão de mordida:

.
 .
  .

Sanduíche:

##.
#.#
.##

Resultado:

Duas rotações possíveis (mordendo no canto nordeste ou sudoeste).

truthy

Algumas mordidas válidas:

..
.

...
.
.

.
 .
  .

..
. .
 ..

 ..
.
. .

Algumas mordidas inválidas:

..

...
.

..
.
 .

Regras:

• Minha orientação do padrão de mordida será sempre para morder o canto noroeste. E deve ser girado para morder outros cantos;

• Sempre haverá 1 e apenas 1 mordida no sanduíche;

• A mordida no sanduíche pode estar em qualquer uma das 4 córneas (rotacionada de acordo);

• Os padrões de mordida sempre serão simétricos ao longo da diagonal principal;

• Os padrões de mordida sempre terão pelo menos 1 de largura e não estarão vazios;

• O sanduíche sempre será um retângulo com largura e altura iguais ou maiores que a largura do meu padrão de mordida;

• Na sua entrada, você pode escolher quaisquer 2 caracteres distintos que não sejam espaços em branco para representar o sanduíche e a mordida;

• Espaços no padrão de mordida significa que minha mordida não toca nessa parte do sanduíche.

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

Experimente online!

Economizou 2 bytes movendo a atribuição para o primeiro uso de a. Aparentemente, Ruby é inteligente o suficiente para não confundir as vírgulas na definição da matriz e vírgulas que surgiriam da atribuição simultânea de variáveis ​​(pelo menos neste 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))

Recebe a entrada como duas listas de strings (uma para cada linha). Não assume nenhum espaço em branco à direita nas linhas.

Experimente online!

Exemplos:

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

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

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

Python 2, 173 bytes

Experimente 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

Aceita entrada como duas listas de listas de caracteres.
Primeiro - sanduíche
Segundo - mordida

Primeiro, ele estende a matriz de mordida ao tamanho da matriz de sanduíche:

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]substitui todos os espaços para #
(L(S[0])-L(x)),b+[[]]*(L(S)-L(b))calcular o número de elementos ausentes

Em seguida, ele compara todas as 4 rotações dessa mordida "estendida" ao sanduíche:

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 é usado para espelhar a lista de listas horizontalmente

No exemplo vinculado, o sanduíche é:

##.
#.#
###

E mordida é:

.
 .