Défi
Créer une fonction prend en deux tableaux bidimensionnels de caractères (ou chaînes si le langage de programmation n'a pas de caractères comme type de données) comme entrées: a et b. Si votre langue ne prend pas en charge ces entrées, vous pouvez utiliser toute autre variable standard à un octet.

Votre tâche consiste à déterminer si b contient a. Si tel est le cas, retournez true. Sinon, retournez false.

Exemples de cas de test

a:

123
456
789

b:

123
456
789

devrait retourner vrai.

a:

code
golf

b:

thisis
code!!
golf!!
ohyeah

devrait retourner vrai.

a:

abcd
efgh
ijkl

b:

abcdef
ghijkl
mnopqr

devrait retourner faux.

a:

abc
def

b:

1abc2
3def4
5ghi6

devrait retourner vrai

a:

ab
cd

b:

#ab##
##cd#

devrait retourner faux

Le moins d'octets l'emporte.

Brachylog (v2), 4 octets

s\s\

Essayez-le en ligne!

Exécutez le plus facilement en tant que programme complet, comme d'habitude pour un problème de décision , avec un argument spécifié comme ligne de commande, b sur l'entrée standard. La question demande une fonction, et le programme fonctionne également comme une fonction, avec b à gauche, a à droite et sortie via la production d'une exception si et seulement si la décision est fausse .

Explication

s\s\
s     a substring of rows of {the left input}
 \…\  assert rectangular; swap row and column operations
  s   a substring of <s>rows</s> columns of {the above matrix}
      {implicit} assert that the result can be {the right input}

L '«assertion rectangulaire» est évidemment inutile, comme la question le garantit déjà. Le reste du programme effectue la recherche de grille pour nous en identifiant une sous-chaîne des lignes et des colonnes, c'est-à-dire une sous-matrice.

Méta-discussion

Nous avons déjà posé une question très similaire ; Je m'attends à ce que la plupart des réponses à une question soient modifiables en réponses à l'autre. Je pense que c'est la version plus soignée de celui-ci, cependant.

Python 2 , 67 octets

f=lambda a,b,r=4:b*r and f(a,b[1:],r)|f(a,zip(*b)[::-1],r-1)or a==b

Essayez-le en ligne!

Prend la saisie sous forme de listes de tuples de caractères.

Essaie toutes les sous-grilles de bet vérifie s'il en afait partie. Les sous-grilles sont générées en se ramifiant récursivement en supprimant la première rangée bou en la faisant pivoter de 90 degrés. Après exactement quatre rotations, vérifie si la réduction best égale à a.

J , ^{21 15 8} 7 octets

1#.,@E.

Essayez-le en ligne!

-7 octets grâce à Bolce Bussiere

réponse originale

J , ²¹ 15 octets

<@[e.&,$@[<;.3]

Essayez-le en ligne!

-6 octets grâce à FrownyFrog

Comment

• <@[ arg de boîte gauche
• $@[<;.3] tous les rectangles dans l'arg droit avec la même forme que l'arg gauche
• passer maintenant ceux-ci comme l'argument gauche et droit à ...
• est l'arg de gauche un orme de l'arg de droite, après aplatissement à la fois e.&,

Fusain , 26 octets

⌈⭆η⭆ι⁼θＥ✂ηκ⁺Ｌθκ¹✂νμ⁺Ｌ§θ⁰μ¹

Essayez-le en ligne! Le lien est vers la version détaillée du code. Fortement basé sur ma réponse à Count les sous - matrices contiguës , la seule différence étant qu'au lieu de prendre la somme des correspondances, je prends le maximum, et à cause de la conversion de chaîne implicite due à l'utilisation du ⭆résultat est déjà une chaîne qui enregistre un octet.

05AB1E , 10 octets

øŒεøŒI.å}à

Prend bcomme première entrée, acomme deuxième. Les deux entrées sous forme de matrices de caractères.

Port de la réponse 05AB1E de @ Mr.Xcoder pour ce défi connexe , alors assurez-vous de lui donner un vote positif!

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

øŒ          # Get the sublists of every column of the (implicit) input `b`
  ε         # Map each list of sublists to:
   øŒ       #  Get the sublists of every column again
            #  (now we have all sub-matrices of `b`)
     I.å    #  Check if the second input `a` is in this list of sub-matrices
        }à  # After the map: check if any are truthy by taking the maximum
            # (which is output implicitly as result)

Python 2 , 106 118 118 113 octets

lambda a,b,L=len:any(sum(A==B[j:j+L(A)]for A,B in zip(a,b[i:]))==L(a)for i in range(L(b))for j in range(L(b[0])))

Essayez-le en ligne!

Wolfram Language (Mathematica) , 46 octets

nOr@@Or@@@BlockMap[#==n&,#,Dimensions@n,1]&

Essayez-le en ligne!

Fonction curry: appeler avec f[a][b].

Existe-t-il des alternatives plus courtes à Or@@Or@@@ou Dimensions?

JavaScript (ES6) , 131 112 105 octets

105 octets:

f=(m,n)=>m.some((x,i)=>i<=m.length-n.length&x.some((c,j)=>n.every((l,z)=>(m[i+z]+'').indexOf(l,j)==2*j)))

Essayez-le en ligne!

Changements:

• m[i]dans xet n[z]dans l: totalement oublié que ces variables ont déjà été instanciées
• &&dans &: les deux côtés de l'opérateur sont déjà des booléens donc un opérateur au niveau du bit fonctionnera

112 octets:

f=(m,n)=>m.some((x,i)=>i<=m.length-n.length&&m[i].some((c,j)=>n.every((l,z)=>(m[i+z]+'').indexOf(n[z],j)==2*j)))

Essayez-le en ligne!

Changements:

• map((c,j)=>{...}).some(s=>s)en some((c,j)=>{...}): Redondance
• m[i+z].join()en m[i+z]+'': un moyen plus court de convertir le tableau en chaîne
• indexOf(n[z].join(),j)en indexOf(n[z],j): la indexOf méthode est déjà convertie n[z] en chaîne

131 octets:

f=(m,n)=>m.some((x,i)=>i<=m.length-n.length&&m[i].map((c,j)=>n.every((l,z)=>m[i+z].join().indexOf(n[z].join(),j)==2*j)).some(s=>s))

Essayez-le en ligne!

Lisible:

function f (m, n) {
  return m.some((x, i) => {
    return i <= m.length - n.length
      && m[i].map((c, j) => {
        return n.every((l, z) => {
          return m[i + z].join().indexOf(n[z].join(), j) == 2 * j
        })
      })
        .some(s => s)
  })
}

Au lieu de comparer les valeurs individuelles, j'ai vérifié si les lignes de la grille N étaient incluses dans les lignes de la grille M, et si oui, à quels indices. Si toutes les lignes sont incluses à partir du même indice, la grille N est contenue dans la grille M.

PowerShell , 71 102 85 98 octets

merci @Jo King; cas de test ajoutés.

param($a,$b)!!($a|%{$p=[regex]::Escape($_)
$b|sls $p -a -ca|% m*}|group index|?{"$a"-ceq$_.Group})

Essayez-le en ligne!

Moins golfé:

param($a,$b)

$matches = $a|%{
    $pattern = [regex]::Escape($_)
    $b|Select-String $pattern -AllMatches -CaseSensitive|% Matches
}

$relevantGroupsByMatchPosition = $matches|group index|?{
    "$a"-ceq$_.Group  # the '$_.Group' contains matches in source order
                      # -ceq is case sensitivity equation operator
                      # -ceq performs an implicit conversion to the left operand type
}

!!($relevantGroupsByMatchPosition)  # true if the variable is not $null

Javascript, 150 octets

f=(a,b)=>{_='length';for(r=i=0;i<=b[_]-a[_];i++)for(j=0;j<=b[0][_]-a[0][_];j++){u=0;a.map((l,y)=>l.map((c,x)=>u=u||b[i+y][j+x]!=c));r=r||!u;}return r}

Essayez-le en ligne