Hier, j'ai laissé mon sandwich sur la table. Quand je me suis levé aujourd'hui, il y avait une bouchée dedans ... C'était la mienne? Je ne me souviens pas ...

Problème:

Prenez une représentation du sandwich et de ma morsure et dites-moi si c'était ma morsure ou non.

Exemples:

Exemple 1:

Mon schéma de morsure:

..
.

Sandwich:

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

Production:

truthy

Exemple 2:

Mon schéma de morsure:

..
..

Sandwich:

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

Production:

falsy

Exemple 3:

S'il y a au moins 1 rotation qui compte comme véridique, la sortie est véridique.

Mon schéma de morsure:

.
 .
  .

Sandwich:

##.
#.#
.##

Production:

Deux rotations possibles (mordre dans le coin nord-est ou sud-ouest).

truthy

Quelques bouchées valides:

..
.

...
.
.

.
 .
  .

..
. .
 ..

 ..
.
. .

Quelques piqûres invalides:

..

...
.

..
.
 .

Règles:

• Mon orientation de morsure sera toujours pour mordre le coin nord-ouest. Et doit être tourné pour mordre d'autres coins;

• Il y aura toujours 1 et seulement 1 bouchée dans le sandwich;

• La morsure dans le sandwich peut être dans l'un des 4 cornes (tourné en conséquence);

• Les motifs de morsure seront toujours symétriques le long de la diagonale principale;

• Les motifs de morsure seront toujours au moins 1 larges et non vides;

• Le sandwich sera toujours un rectangle dont la largeur et la hauteur seront égales ou supérieures à la largeur de ma morsure;

• Dans votre saisie, vous pouvez choisir 2 caractères distincts non blancs pour représenter le sandwich et la morsure;

• Les espaces dans le motif de morsure signifient que ma morsure ne touche pas cette partie du sandwich.

Ruby , 103 octets 101 octets

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

Essayez-le en ligne!

Enregistré 2 octets en déplaçant l'affectation à la première utilisation d'un. Apparemment, Ruby est suffisamment intelligent pour ne pas confondre les virgules dans la définition du tableau et les virgules qui résulteraient de l'affectation simultanée de variables (au moins dans ce cas: D)

Python 2 , 134 octets

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

Prend l'entrée comme deux listes de chaînes (une pour chaque ligne). Ne suppose aucun espace de fin sur les lignes.

Essayez-le en ligne!

Exemples:

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

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

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

Python 2, 173 octets

Essayez-le en ligne

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

Prend la saisie sous la forme de deux listes de listes de caractères.
Première - sandwich
Deuxième - morsure

Tout d'abord, il étend le réseau de morsures à la taille du réseau 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]remplace tous les espaces pour #
(L(S[0])-L(x)),b+[[]]*(L(S)-L(b))calculer le nombre d'éléments manquants

Ensuite, il compare les 4 rotations de cette bouchée "étendue" au 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 est utilisé pour refléter horizontalement la liste des listes

Dans l'exemple lié, le sandwich est:

##.
#.#
###

Et la morsure c'est:

.
 .