M और S अक्षर से बनी ASCII- आर्ट विंडो का पता लगाएं

Question

विंडो एक ASCII- कला वर्ग है जिसमें कम से कम 3 की विषम लंबाई होती है, जिसके किनारे के चारों ओर एक एकल वर्ण सीमा के साथ-साथ ऊर्ध्वाधर और क्षैतिज स्ट्रोक होते हैं:

#######
#  #  #
#  #  #
#######
#  #  #
#  #  #
#######

एक MS Window एक विंडो होती है जहाँ बॉर्डर केवल वर्णों से बना होता है Mऔर S। आपका कार्य एक प्रोग्राम (या फ़ंक्शन) लिखना है जो एक स्ट्रिंग लेता है और एक सत्य मान को आउटपुट करता है यदि इनपुट एक वैध एमएस विंडो है, और एक गलत मूल्य है यदि यह नहीं है।

विशेष विवरण

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

परीक्षण के मामलों

Truthy:

MMM
MMM
MMM

SMSMS
M M S
SMSMM
S S M
SMSMS

MMMMMMM
M  S  M
M  S  M
MSSSSSM
M  S  M
M  S  M
MMMMMMM

Falsey:

Hello, World!

MMMM
MSSM
MS M
MMMM

MMSMM
M S.M
sSSSS
M S M
MMSMM

MMMMMMM
M  M  M
MMMMMMM
M  M  M
MMMMMMM

MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM

MMSSMSSMM
M   M   M
S   S   S
S   S  S
MMSSMSSMM
S   S   S
S   S   S
M   M   M
MMSSMSSMM

Comments

यह ASCII कला पर एक महान मोड़ है, एक निश्चित संरचना का पता लगाने के लिए एक निर्णय समस्या है।

— ५

@xnor मुझे लगता है कि हम इस तरह रिवर्स ASCII कला के लिए एक अलग टैग चाहते हैं।

— बजे फल

जबकि आस्की कला के लिए विशिष्ट नहीं, पैटर्न मिलान एक नए टैग के लिए एक अच्छा विकल्प हो सकता है

— विनाशकारी नींबू

क्या आप एक परीक्षण केस या दो जोड़ सकते हैं जहां स्ट्रिंग आयताकार सरणी नहीं बनाती है?

— ग्रेग मार्टिन

@ मैस्ट, तुम काफी सही हो! शायद चुनौती को स्पष्ट करने की आवश्यकता है

— क्रिस एम

Answer 1

पाइके, 34 31 बाइट्स

lei}t\Mcn+it*i\M*+s.XM"QJ\S\M:q

यहाँ यह कोशिश करो!

lei                              -         i = len(input)//2
   }t                            -        (^ * 2) - 1
     \Mc                         -       "M".center(^)
        n+                       -      ^ + "\n"
          it*                    -     ^ * (i-1)
                 +               -    ^ + V
             i\M*                -     "M"*i
                  s              -   palindromise(^)
                   .XM"          -  surround(^, "M")
                               q - ^ == V
                       QJ        -   "\n".join(input)
                         \S\M:   -  ^.replace("S", "M")

Answer 2

रेटिना , 68 67 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

S
M
^(M((M)*M)\2)((?<-9>¶M((?<9-3> )*(?(3)!)M|\5)\5)*(?(9)!)¶\1)\4$

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

Answer 3

ग्रिम , 39 38 बाइट्स

1 बाइट बचाने के लिए ज़गरब को धन्यवाद।

e`BB/BB/W+ W/+
B=W|B/W\ * W/\ /*
W=[MS

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

मुझे यकीन नहीं है कि एक पुनरावर्ती nonterminal का उपयोग करने की तुलना में व्यक्तिगत खिड़की के घटकों के वर्ग पहलू अनुपात को लागू करने के लिए एक सरल तरीका है, लेकिन यह काफी अच्छी तरह से काम कर रहा है।

व्याख्या

कार्यक्रम को नीचे से ऊपर तक पढ़ना सबसे अच्छा है।

W=[MS

यह बस एक नॉनटर्मिनल को परिभाषित करता है (जिसे आप एक सबरूटीन के रूप में सोच सकते हैं जो एक आयत से मेल खाता है) Wजो या तो एक Mया एक से मेल खाता है S( ]लाइन के अंत में एक निहित है )।

B=W|B/W\ * W/\ /*

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

MSM
S  
M  

यह सुनिश्चित करने के लिए कि यह विंडो पैनल वर्गाकार है, हम Bपुनरावर्ती रूप से परिभाषित करते हैं । यह या तो एक खिड़की का पात्र है W, या यह B/W\ * W/\ /*एक परत को दाईं ओर और नीचे जोड़ता है। यह देखने के लिए कि यह ऐसा कैसे करता है, आइए कुछ कृत्रिम शर्करा हटा दें:

(B/W[ ]*)(W/[ ]/*)

यह वही है, क्योंकि क्षैतिज संघनन ABया तो लिखा जा सकता है या A B, लेकिन उत्तरार्द्ध में ऊर्ध्वाधर अवतरण की तुलना में कम पूर्वता है /जबकि पूर्व के लिए उच्च है। तो B/W[ ]*एक है Bएक खिड़की चरित्र और नीचे रिक्त स्थान की एक पंक्ति के साथ। और फिर हम क्षैतिज रूप से जोड़ते हैं W/[ ]/*जो रिक्त स्थान के स्तंभ के साथ एक खिड़की का चरित्र है।

अंत में, हम इन अप्रतिष्ठानों को अंतिम विंडो आकृति में इकट्ठा करते हैं:

BB/BB/W+ W/+

वह चार विंडो पैनल हैं जिनके Bबाद विंडो कैरेक्टर की एक पंक्ति और विंडो कैरेक्टर का एक कॉलम है। ध्यान दें कि हम इस बात को स्पष्ट नहीं करते हैं कि चार विंडो पैनल एक ही आकार के हैं, लेकिन यदि वे आयत में समाप्‍त करना असंभव नहीं है।

अंत में e`शुरुआत में बस एक कॉन्फ़िगरेशन है जो Grime को बताता है कि पूरे इनपुट को इस पैटर्न से मिलान किया जा सकता है (और यह प्रिंट 0या 1तदनुसार)।

Answer 4

जावास्क्रिप्ट (ईएस 6), 115 113 बाइट्स

a=>(l=a.length)&a.every((b,i)=>b.length==l&b.every((c,j)=>(i&&l+~i-i&&l+~i&&j&&l+~j-j&&l+~j?/ /:/[MS]/).test(c)))

वर्णों के सरणियों की एक सरणी के रूप में इनपुट लेता है (तार की एक सरणी के लिए 5 बाइट्स जोड़ें) और रिटर्न 1या 0। यह सत्यापित करने के बाद कि ऊँचाई विषम है, सरणी को वर्गाकार करने के लिए प्रत्येक पंक्ति की जाँच की जाती है, और प्रत्येक वर्ण को उस विशेष स्थिति में अपेक्षित वर्ण (नों) में से एक के रूप में सत्यापित किया जाता है। संपादित करें: @PatrickRoberts के लिए 2 बाइट्स धन्यवाद सहेजे गए।

Comments

आप 1 बाइट बचाने के (...).includes(c)लिए बदल सकते हैं~(...).search(c)

— पैट्रिक रॉबर्ट्स

वास्तव में, बेहतर है कि आप इसे (...?/ /:/[MS]/).test(c)केवल 1 के बजाय 2 बाइट्स को बचाने के लिए बदल सकते हैं

— पैट्रिक रॉबर्ट्स

@PatrickRoberts प्यारा, धन्यवाद!

— नील

Answer 5

पर्ल, 124 123 119 95 93 84

निम्न पर्ल स्क्रिप्ट मानक इनपुट से एक उम्मीदवार एमएस विंडो को पढ़ती है। यह तब शून्य निकास स्थिति के साथ बाहर निकलता है यदि उम्मीदवार एक एमएस विंडो है और गैर-शून्य निकास स्थिति के साथ यदि यह नहीं है।

यह दो नियमित अभिव्यक्ति उत्पन्न करता है, एक शीर्ष, मध्य और नीचे की रेखा के लिए और प्रत्येक दूसरी पंक्ति के लिए एक, और उनके खिलाफ इनपुट की जाँच करके।

धन्यवाद, @ दादा। और फिर।

map{$s=$"x(($.-3)/2);$m="[MS]";($c++%($#a/2)?/^$m$s$m$s$m$/:/^${m}{$.}$/)||die}@a=<>

Comments

मुझे यकीन है कि परिणाम देने की अनुमति नहीं है क्योंकि बाहर निकलने की स्थिति की अनुमति है (मेरे पास प्रासंगिक मेटा पोस्ट देखने के लिए समय नहीं है)। भले ही, आप कुछ बाइट्स बचा सकते हैं:@a=<>;$s=$"x(($.-3)/2);$m="[MS]";map{$a[$_]!~($_%($./2)?"$m$s$m$s$m":"$m${m}{$.}")&&die}0..--$.

— दादा

@ दादा: धन्यवाद! यह एक प्रभावशाली सुधार है: 24 वर्ण। (आपके कोड में एक भटका हुआ "$ m" था, इसलिए यह पहले की तुलना में भी छोटा है।) मुझे यकीन नहीं था कि यदि किसी निकास कोड के साथ परिणाम की रिपोर्ट करने की अनुमति सामान्य रूप से दी गई थी, लेकिन मैंने "प्रोग्राम लिखें" ( या समारोह) "इस विशेष मामले में परिणाम कैसे लौटाया जाता है, इसके साथ लचीले होने की अनुमति देना;" एक्ज़िट कोड व्यावहारिक रूप से * निक्स पर्यावरण के फ़ंक्शन रिटर्न मान हैं। :-)

— रात्रि n:

वह २६ पात्र बना लें।

— nwk

वास्तव में, मैं कर रहा हूँ decrementing $.अंत में दो बार का उपयोग कर से बचने के लिए $.-1(विशेष रूप से के बाद पहली बार यह था ($.-1)/2, तो यह कुछ अतिरिक्त कोष्ठक आवश्यक) तो $mमें $m${m}{$.}एक गलती नहीं है। इसके अलावा, मुझे अभी पता चला है, लेकिन रेगेक्स के साथ घिरा होना चाहिए ^...$(इसलिए अंत में अतिरिक्त चरित्र या शुरुआत उन्हें विफल बनाते हैं), या कम: के neबजाय का उपयोग करें !~।

— दादा

कोई बात नहीं, जाहिर है आप neइसके बजाय उपयोग नहीं कर सकते !~(मैं सिर्फ 15 मिनट के लिए जाग गया था जब मैं संदेश नहीं लिखना चाहिए!)। तो तुम ^...$दोनों regex मैं डर रहा हूँ में उपयोग करना होगा ।

— दादा

Answer 6

मैथेमेटिका, 166 बाइट्स

Union[(l=Length)/@data]=={d=l@#}&&{"M","S"}~(s=SubsetQ)~(u=Union@*Flatten)@{#&@@(p={#,(t=#~TakeDrop~{1,-1,d/2-.5}&)/@#2}&@@t@#),p[[2,All,1]]}&&{" "}~s~u@p[[2,All,2]]&

इनपुट और वापसी Trueया के रूप में वर्णों की सूची की सूची ले रहा है False। यहाँ एक कम गोल्फ संस्करण है:

(t = TakeDrop[#1, {1, -1, d/2 - 0.5}] &; 
Union[Length /@ data] == {d = Length[#1]}
  &&
(p = ({#1, t /@ #2} &) @@ t[#1];
SubsetQ[{"M", "S"}, Union[Flatten[{p[[1]], p[[2, All, 1]]}]]]
  && 
SubsetQ[{" "}, Union[Flatten[p[[2, All, 2]]]]])) &

पहली पंक्ति फ़ंक्शन को परिभाषित करती है t, जो लंबाई की एक सूची dको दो भागों में विभाजित करती है, जिनमें से पहली सूची की पहली, मध्य और अंतिम प्रविष्टियां होती हैं, और दूसरी जो बाकी है। दूसरी पंक्ति यह जांचती है कि इनपुट पहली जगह में वर्गाकार सरणी है या नहीं। चौथी पंक्ति tदो बार उपयोग करती है , एक बार इनपुट पर और एक बार इनपुट में स्ट्रिंग्स के सभी * पर, उन वर्णों को अलग करने के लिए जो रिक्त स्थान होने वाले हैं "M"या "S"जिन वर्णों से माना जाता है; फिर पाँचवीं और सातवीं पंक्तियाँ जाँचती हैं कि क्या वे वास्तव में वही हैं जो उन्हें होना चाहिए।

Answer 7

जावास्क्रिप्ट (ईएस 6), 108 106 बाइट्स

इनपुट: स्ट्रिंग्स की सरणी / आउटपुट: 0या1

s=>s.reduce((p,r,y)=>p&&r.length==w&(y==w>>1|++y%w<2?/^[MS]+$/:/^[MS]( *)[MS]\1[MS]$/).test(r),w=s.length)

परीक्षण के मामलों

let f =

s=>s.reduce((p,r,y)=>p&&r.length==w&(y==w>>1|++y%w<2?/^[MS]+$/:/^[MS]( *)[MS]\1[MS]$/).test(r),w=s.length)

console.log('Testing truthy test cases...');

console.log(f([
  'MMM',
  'MMM',
  'MMM'
]));

console.log(f([
  'SMSMS',
  'M M M',
  'SMSMS',
  'M M M',
  'SMSMS'
]));

console.log(f([
  'MMMMMMM',
  'M  S  M',
  'M  S  M',
  'MSSSSSM',
  'M  S  M',
  'M  S  M',
  'MMMMMMM'
]));

console.log('Testing falsy test cases...');

console.log(f([
  'Hello, World!'
]));

console.log(f([
  'MMMM',
  'MSSM',
  'MS M',
  'MMMM'
]));

console.log(f([
  'MMSMM',
  'M S.M',
  'sSSSS',
  'M S M',
  'MMSMM'
]));

console.log(f([
  'MMMMMMM',
  'M  M  M',
  'MMMMMMM',
  'M  M  M',
  'MMMMMMM'
]));

console.log(f([
  'MMMMMMM',
  'M M M M',
  'MMMMMMM',
  'M M M M',
  'MMMMMMM',
  'M M M M',
  'MMMMMMM'
]));

Answer 8

जावास्क्रिप्ट (ईएस 6), 140 138 141 140 बाइट्स

मुझे पता है कि यह एक जीतने वाली बाइट की गिनती नहीं है (हालांकि -3 के लिए पैट्रिक रॉबर्ट्स के लिए धन्यवाद, और मुझे एहसास हुआ कि एम / एस: +3 के बजाय 1 के लिए झूठी सकारात्मकता फेंक दी), लेकिन मैंने इसे थोड़ा अलग तरीके से किया, मैंने ' यह नया है, और यह मजेदार था ...

तार की एक सरणी को स्वीकार करता है, प्रत्येक पंक्ति के लिए एक और सही या गलत लौटाता है। न्यूलाइन को स्पष्टता के लिए जोड़ा गया (बाइट गिनती में शामिल नहीं)।

f=t=>t.every((e,i)=>e.split`S`.join`M`==[...p=[b='M'.repeat(s=t.length),
...Array(z=-1+s/2|0).fill([...'MMM'].join(' '.repeat(z)))],...p,b][i])

सामान्यीकृत पैटर्न के खिलाफ इनपुट की जांच करने के बजाय, मैं उसी आकार की 'M' विंडो बनाता हूं, S को इनपुट पर M से प्रतिस्थापित करता हूं और दोनों की तुलना करता हूं।

Ungolfed

f = t => t.every( // function returns true iff every entry in t
                  // returns true below
  (e, i) => e.split`S`.join`M` // replace all S with M
                                 // to compare to mask
  == [ // construct a window of the same size made of Ms and
       // spaces, compare each row 
      ...p = [ // p = repeated vertical panel (bar above pane)
               // which will be repeated
              b = 'M'.repeat(s = t.length),
                  // b = bar of Ms as long as the input array
              ...Array(z = -1 + s/2|0).fill([...'MMM'].join(' '.repeat(z)))],
              // z = pane size; create enough pane rows with
              // Ms and enough spaces
      ...p, // repeat the panel once more
      b][i] // finish with a bar
)

console.log(f(["111","111","111"]))

console.log(f(["MMMMM","M S M","MSSSM","M S M","MSSSM"]))

परीक्षण के मामलों

f=t=>t.every((e,i)=>e.split`S`.join`M`==[...p=[b='M'.repeat(s=t.length),
...Array(z=-1+s/2|0).fill([...'MMM'].join(' '.repeat(z)))],...p,b][i])


truthy=`MMM
MMM
MMM

SMSMS
M M M
SMSMS
M M M
SMSMS

MMMMMMM
M  S  M
M  S  M
MSSSSSM
M  S  M
M  S  M
MMMMMMM`.split('\n\n')

falsey=`Hello, World!

MMMM
MSSM
MS M
MMMM

MMSMM
M S.M
sSSSS
M S M
MMSMM

MMMMMMM
M  M  M
MMMMMMM
M  M  M
MMMMMMM

MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM`.split('\n\n')

truthy.forEach(test=>{
  console.log(test,f(test.split('\n')))
})

falsey.forEach(test=>{
  console.log(test,f(test.split('\n')))
})

Comments

भविष्य के संदर्भ के लिए, जब तक कि फ़ंक्शन पुनरावर्ती f=नहीं होता , तब तक उसे बाइट काउंट में शामिल करने की आवश्यकता नहीं होती है, इसलिए यह वास्तव में 138 बाइट सबमिशन है।

— पैट्रिक रॉबर्ट्स

आप बदल सकते हैं z=-1+s/2|0के साथ z=(s-3)/2करने के लिए सेव 1 बाइट

— पैट्रिक रॉबर्ट्स

तुम भी जगह ले सकता है e.replace(/S/g,'M')==...के साथ e.split`S`.join`M`==...एक और बाइट को बचाने के लिए

— पैट्रिक रॉबर्ट्स

धन्यवाद! z=-1+s/2|0वहाँ s == 1 और यहां तक ​​कि s के लिए एक सकारात्मक पूर्णांक वापस करने के लिए है, यानी फ़ंक्शन Array () को क्रैश किए बिना गलत लौटाता है। अन्यथा आवश्यक तर्क ने इसे लंबा कर दिया। स्प्लिट / जॉइन पर शानदार टिप, धन्यवाद

— क्रिस एम

अच्छी पकड़ है, मैं इस s=1मामले पर विचार नहीं किया , क्योंकि मेरे अवैध regex बस चुपचाप विफल रहता है।

— पैट्रिक रॉबर्ट्स

Answer 9

जावास्क्रिप्ट (ईएस 6), 109 107 106 105 99 बाइट्स

s=>!s.split`S`.join`M`.search(`^((M{${r=s.search`
`}})(
(M( {${w=(r-3)/2}})M\\5M
){${w}}))\\1\\2$`)

संपादित करें : वाह, Arnauld मुझे बदलकर 6 बाइट्स बचा लिया s.split`\n`.lengthकरने के लिए s.search`\n`! धन्यवाद!

यह एक एकल मल्टीलाइन स्ट्रिंग लेता है और RegExpइनपुट स्ट्रिंग की लंबाई का उपयोग करके एक- आधारित मान्यता का निर्माण करता है। लौटाता है trueया false। मान लें कि एक मान्य विंडो में एक अनुगामी न्यूलाइन नहीं है ।

डेमो

f=s=>!s.split`S`.join`M`.search(`^((M{${r=s.search`
`}})(
(M( {${w=(r-3)/2}})M\\5M
){${w}}))\\1\\2$`);
`MMM
MMM
MMM

SMSMS
M M M
SMSMS
M M M
SMSMS

MMMMMMM
M  S  M
M  S  M
MSSSSSM
M  S  M
M  S  M
MMMMMMM

Hello, World!

MMMM
MSSM
MS M
MMMM

MMSMM
M S.M
sSSSS
M S M
MMSMM

MMMMMMM
M  M  M
MMMMMMM
M  M  M
MMMMMMM

MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM
M M M M
MMMMMMM`.split`

`.forEach(test=>{console.log(test,f(test));});

Comments

अच्छा तरीका! के r=s.search('\n')बजाय आप का उपयोग कर सकते हैं split / length?

— अरनौलद

@ अर्नुलद भयानक सुझाव, धन्यवाद!

— पैट्रिक रॉबर्ट्स

s=>!s.split`S`.join`M`.search([...])सिंटैक्स त्रुटियों को पैदा किए बिना, कोष्ठक को हटाया जा सकता है।

— इस्माइल मिगुएल

@IsmaelMiguel सही है, लेकिन फिर स्ट्रिंग एक टेम्पलेट के रूप में पारित हो जाती है, जो निहित को अमान्य करती हैRegExp

— पैट्रिक रॉबर्ट्स

यह बेकार है ... मैं वास्तव में उम्मीद नहीं कर रहा था कि ...

— इस्माइल मिगुएल