यह निर्धारित करें कि एक ग्रिड में दूसरा ग्रिड होता है या नहीं

Question

चुनौती
क्रिएटर्स के दो 2-आयामी सरणियों में एक फ़ंक्शन लेता है (या स्ट्रिंग्स यदि प्रोग्रामिंग भाषा में वर्णक के रूप में वर्ण नहीं हैं) इनपुट के रूप में: a और b। यदि आपकी भाषा इन सूचनाओं का समर्थन नहीं करती है, तो आप किसी अन्य मानक एक-बाइट चर का उपयोग कर सकते हैं।

आपका कार्य यह निर्धारित करना है कि क्या बी में ए है। यदि ऐसा है, तो सही लौटें। नहीं तो झूठा लौट आता है।

नमूना परीक्षण मामले

a:

123
456
789

b:

123
456
789

सच लौटना चाहिए।

a:

code
golf

b:

thisis
code!!
golf!!
ohyeah

सच लौटना चाहिए।

a:

abcd
efgh
ijkl

b:

abcdef
ghijkl
mnopqr

झूठे लौटना चाहिए।

a:

abc
def

b:

1abc2
3def4
5ghi6

सच लौटना चाहिए

a:

ab
cd

b:

#ab##
##cd#

झूठे लौटना चाहिए

कम से कम बाइट्स जीतता है।

Comments

हाय और कोडगुफ़ में आपका स्वागत है! मैंने आपके परीक्षण मामलों को संपादित किया (उम्मीद है) उन्हें थोड़ा और स्पष्ट कर देगा। ध्यान दें कि हमारे पास मुख्य पोस्ट करने से पहले चुनौतियों पर काम करने के लिए एक सैंडबॉक्स है । सौभाग्य!

— FryAmTheEggman

इसके अलावा, क्या मैं पहली सरणी को स्ट्रिंग्स की एक सरणी के रूप में ले सकता हूं और दूसरी को नई कहानियों द्वारा अलग किए गए स्ट्रिंग के रूप में, भले ही मेरी भाषा (C #) में एक चरित्र प्रकार बनाया गया हो?

— अज्ञानता का अवतार

@ नील टेस्ट केस 2 और 3 वर्ग नहीं हैं।

— रॉबिन राइडर

क्या आप एक सत्य परीक्षण मामले को जोड़ सकते हैं, जहां बाएं किनारे aपर नहीं है bऔर एक गलत परीक्षण मामला है, जहां प्रत्येक पंक्ति aनिरंतर रेखाओं में दिखाई देती है, bलेकिन उनके बाएं किनारों को कंपित किया गया है?

— झबरा

@EmbodimentofIgnorance हाँ

— खतरा

Answer 1

ब्रेकीलॉग (v2), 4 बाइट्स

s\s\

इसे ऑनलाइन आज़माएं!

सबसे आसानी से एक पूरा कार्यक्रम के रूप में एक के लिए हमेशा की तरह, चलाने के निर्णय समस्या , साथ एक एक कमांड लाइन तर्क, के रूप में निर्दिष्ट ख मानक इनपुट पर। सवाल एक समारोह के लिए पूछता है, और कार्यक्रम भी एक समारोह के रूप में काम करता है के साथ, ख बाईं तरफ, एक सही है, और उत्पादन पर के माध्यम से एक अपवाद यदि और केवल यदि निर्णय गलत है उत्पादन ।

व्याख्या

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}

"जोरदार आयताकार", स्पष्ट रूप से, व्यर्थ है, क्योंकि प्रश्न पहले से ही गारंटी देता है। बाकी कार्यक्रम पंक्तियों और स्तंभों की एक सबमिशन यानी सबमेट्रिक्स की पहचान करके हमारे लिए ग्रिड-खोज करता है।

मेटा-चर्चा

हमने पहले भी इसी तरह का प्रश्न किया है ; मुझे उम्मीद है कि एक प्रश्न के अधिकांश उत्तर दूसरे के उत्तर में परिवर्तनीय होंगे। मुझे लगता है कि यह इसका नटखट संस्करण है, हालांकि।

Comments

यहाँ सबसे छोटा जवाब है, इसलिए मैं इसे स्वीकार करूँगा।

— खतरा

Answer 2

पायथन 2 , 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वर्णों की सूची के रूप में इनपुट लेता है।

bयदि aउनमें से है, तो सभी उप-ग्रिड की जाँच करता है। उप-ग्रिडों को पहली पंक्ति को हटाने bया इसे 90 डिग्री तक घुमाने पर पुनरावर्ती शाखा द्वारा उत्पन्न किया जाता है । ठीक चार घुमाव के बाद, जांच की जाती है कि क्या नीचे छंटनी की गई bहै a।

Comments

@ mazzy मुझे लगता है कि इनपुट ग्रिड आयतों को माना जाता है।

— xnor

Answer 3

जे , ^{21 15 8} 7 बाइट्स

1#.,@E.

इसे ऑनलाइन आज़माएं!

-7 बाइट्स बोल्स बूसिएर का धन्यवाद

मूल उत्तर

जे , ²¹ 15 बाइट्स

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

इसे ऑनलाइन आज़माएं!

-6 बाइट्स FrownyFrog के लिए धन्यवाद

किस तरह

• <@[ बॉक्सिंग बाएँ आर्ग
• $@[<;.3] सभी आयताकार दाएं arg में बाएं arg के समान आकार के साथ
• अब उन्हें बाएं और दाएं arg पास करें ...
• दोनों के चपटे होने के बाद बाएं आर्ग दायें आर्ग का एक एल्म है e.&,

Comments

मुझे लगता है कि यह हो सकता है<@[e.&,$@[<;.3]

— FrownyFrog

आह, टीसी! यदि आप एक चुनौती चाहते हैं, तो इस राक्षसी

— योना

-7 बाइट्स +/@:,@E.:। ई। इस चुनौती के लिए बहुत सुंदर है।

— बोल्से बूसियर

tyvm @BolceBussiere। मैं इसे आज रात को अपडेट करूंगा।

— जोनाह

Answer 4

चारकोल , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। भारी उपमाओं की गणना करने के लिए मेरे जवाब के आधार पर भारी , केवल अंतर यह है कि मैचों के योग के बजाय मैं अधिकतम लेता हूं, और ⭆परिणाम के उपयोग के कारण अंतर्निहित स्ट्रिंग रूपांतरण के कारण पहले से ही एक स्ट्रिंग है जो बचाता है बाइट।

Answer 5

05AB1E , 10 बाइट्स

øŒεøŒI.å}à

bपहले इनपुट के रूप में लेता है , aदूसरे के रूप में। दोनों इनपुट के रूप में चरित्र- matrices।

इस संबंधित चुनौती के लिए @ Mr.Xcoder के 05AB1E उत्तर का पोर्ट , इसलिए उसे सुनिश्चित करना सुनिश्चित करें!

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

øŒ          # 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)

Answer 6

पायथन 2 , 106 118 113 बाइट्स

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

इसे ऑनलाइन आज़माएं!

Comments

@ नील: अब तय हो गया।

— चास ब्राउन

Answer 7

वोल्फ्राम भाषा (गणितज्ञ) , 46 बाइट्स

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

इसे ऑनलाइन आज़माएं!

करी समारोह: साथ बुलाओ f[a][b]।

Or@@Or@@@या करने के लिए छोटे विकल्प हैं Dimensions?

Answer 8

जावास्क्रिप्ट (ईएस 6) , 131 112 105 बाइट्स

105 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

परिवर्तन:

• m[i]में xऔर n[z]में l: पूरी तरह से भूल गए कि ये चर पहले से ही अस्थिर थे
• &&में &: ऑपरेटर के दोनों पक्ष पहले से ही बूलियन हैं इसलिए एक बिटवाइज़ ऑपरेटर काम करेगा

---

112 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

परिवर्तन:

• map((c,j)=>{...}).some(s=>s)में some((c,j)=>{...}): अतिरेक
• m[i+z].join()में m[i+z]+'': सरणी को एक स्ट्रिंग में बदलने का एक छोटा तरीका
• indexOf(n[z].join(),j)में indexOf(n[z],j): पद्धति पहले से ही बदल देता है एक स्ट्रिंग में indexOf n[z]

---

131 बाइट्स:

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

इसे ऑनलाइन आज़माएं!

पठनीय:

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

व्यक्तिगत मूल्यों की गणना करने के बजाय, मैंने जाँच की कि क्या ग्रिड N की पंक्तियों को ग्रिड M की पंक्तियों में शामिल किया गया था, और यदि ऐसा है, तो उस अनुक्रमणिका पर। यदि सभी पंक्तियों को एक ही सूचकांक से शुरू करना शामिल है तो ग्रिड N ग्रिड M में निहित है।

Answer 9

पॉवरशेल , 71 102 85 98 बाइट्स

धन्यवाद @ जो राजा; परीक्षण के मामले जोड़े गए।

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

इसे ऑनलाइन आज़माएं!

कम गोल्फ वाला:

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

Answer 10

जावास्क्रिप्ट, 150 बाइट्स

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}

इसे ऑनलाइन आज़माएं