Sfida
Creare una funzione accetta due matrici bidimensionali di caratteri (o stringhe se il linguaggio di programmazione non ha caratteri come tipo di dati) come input: a e b. Se la tua lingua non supporta questi input, puoi utilizzare qualsiasi altra variabile standard a un byte.

Il tuo compito è determinare se b contiene a. In tal caso, restituire true. Altrimenti, restituisci false.

Esempi di casi di test

a:

123
456
789

b:

123
456
789

dovrebbe tornare vero.

a:

code
golf

b:

thisis
code!!
golf!!
ohyeah

dovrebbe tornare vero.

a:

abcd
efgh
ijkl

b:

abcdef
ghijkl
mnopqr

dovrebbe restituire false.

a:

abc
def

b:

1abc2
3def4
5ghi6

dovrebbe tornare vero

a:

ab
cd

b:

#ab##
##cd#

dovrebbe restituire false

Vince il minimo byte.

Brachylog (v2), 4 byte

s\s\

Provalo online!

Il più facilmente può essere eseguito come un programma completo, come al solito per un problema decisionale , con un argomento specificato come riga di comando, b su input standard. La domanda richiede una funzione, e il programma funziona anche come una funzione, con b a sinistra, a a destra, e genera tramite un'eccezione se e solo se la decisione è falsa .

Spiegazione

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 '"asserzione rettangolare" è, ovviamente, inutile, poiché la domanda lo garantisce già. Il resto del programma esegue la ricerca della griglia per noi identificando una sottostringa delle righe e delle colonne, ovvero una matrice secondaria.

Meta-discussione

Abbiamo avuto un domanda molto simile ; Mi aspetto che la maggior parte delle risposte a una domanda siano modificabili in risposte all'altra. Penso che questa sia la versione più ordinata, però.

Python 2 , 67 byte

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

Provalo online!

Accetta input come elenchi di tuple di caratteri.

Cerca tutte le griglie secondarie be verifica se aè tra queste. Le griglie secondarie sono generate dalla ramificazione ricorsiva sulla rimozione della prima fila bo sulla sua rotazione di 90 gradi. Dopo esattamente quattro rotazioni, controlla se il taglio bè uguale a a.

J , ^{21 15 8} 7 byte

1#.,@E.

Provalo online!

-7 byte grazie a Bolce Bussiere

risposta originale

J , ²¹ 15 byte

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

Provalo online!

-6 byte grazie a FrownyFrog

Come

• <@[ scatola a sinistra arg
• $@[<;.3] tutti i rettangoli nell'arg destro con la stessa forma dell'arg sinistro
• ora passa quelli come arg sinistro e destro a ...
• è l'arg sinistra un olmo dell'arg destra, dopo aver appiattito entrambi e.&,

Carbone , 26 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Fortemente basato sulla mia risposta al conteggio delle sottomesse contigue , l'unica differenza è che invece di prendere la somma delle corrispondenze prendo il massimo, e a causa della conversione di stringa implicita dovuta all'uso del ⭆risultato è già una stringa che salva un byte.

05AB1E , 10 byte

øŒεøŒI.å}à

Accetta bcome primo input, acome secondo. Entrambi gli input come matrici di caratteri.

Porta della risposta 05AB1E di @ Mr.Xcoder per questa sfida correlata , quindi assicurati di votarlo!

Provalo online o verifica tutti i casi di test .

Spiegazione:

øŒ          # 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 113 byte

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

Provalo online!

Wolfram Language (Mathematica) , 46 byte

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

Provalo online!

Funzione al curry: chiamare con f[a][b].

Ci sono alternative più brevi a Or@@Or@@@o Dimensions?

JavaScript (ES6) , 131 112 105 byte

105 byte:

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

Provalo online!

I cambiamenti:

• m[i]in xe n[z]in l: totalmente dimenticato che queste variabili erano già state istanziate
• &&in &: Entrambi i lati dell'operatore sono già booleani, quindi un operatore bit a bit funzionerà

112 byte:

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

Provalo online!

I cambiamenti:

• map((c,j)=>{...}).some(s=>s)in some((c,j)=>{...}): ridondanza
• m[i+z].join()in m[i+z]+'': un modo più breve per convertire l'array in una stringa
• indexOf(n[z].join(),j)in indexOf(n[z],j): il indexOf metodo si converte già n[z] in una stringa

131 byte:

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

Provalo online!

Leggibile:

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

Invece di confrontare i singoli valori, ho verificato se le linee della griglia N erano incluse nelle linee della griglia M e, in tal caso, a quali indici. Se tutte le linee sono incluse a partire dallo stesso indice, la griglia N è contenuta nella griglia M.

PowerShell , 71 102 85 98 byte

grazie @Jo King; casi di test aggiunti.

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

Provalo online!

Meno 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 byte

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}

Provalo online