Window เป็นสี่เหลี่ยมจัตุรัส ASCII-art ที่มีความยาวด้านคี่อย่างน้อย 3 เส้นโดยมีเส้นขอบตัวอักษรหนึ่งเส้นล้อมรอบขอบเช่นเดียวกับลายเส้นแนวตั้งและแนวนอนตรงกลาง:

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

ของ MS หน้าต่างเป็นหน้าต่างที่ชายแดนจะทำเฉพาะของตัวละครและM Sงานของคุณคือการเขียนโปรแกรม (หรือฟังก์ชั่น) ที่ใช้สตริงและเอาท์พุทค่าความจริงถ้าอินพุตเป็น MS Window ที่ถูกต้องและค่าเท็จถ้ามันไม่ได้

ข้อมูลจำเพาะ

• คุณสามารถรับอินพุตเป็นสตริงที่คั่นด้วยบรรทัดใหม่หรืออาร์เรย์ของสตริงที่แทนแต่ละบรรทัด
• เส้นขอบของหน้าต่าง 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

Pyke, 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")

เรติน่า , 68 67 ไบต์

จำนวนไบต์ถือว่าการเข้ารหัส ISO 8859-1

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

ลองออนไลน์!

Grime , 39 38 ไบต์

ขอบคุณ Zgarb ที่ช่วยประหยัด 1 ไบต์

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

ลองออนไลน์!

ฉันไม่แน่ใจว่าจะมีวิธีที่ง่ายกว่าในการบังคับใช้อัตราส่วนภาพสี่เหลี่ยมจัตุรัสของส่วนประกอบหน้าต่างแต่ละตัวแทนที่จะใช้แบบเรียกซ้ำแบบไม่ระบุชื่อ แต่สิ่งนี้ดูเหมือนว่าจะทำงานได้ค่อนข้างดี

คำอธิบาย

เป็นการดีที่สุดที่จะอ่านโปรแกรมจากล่างขึ้นบน

W=[MS

สิ่งนี้จะนิยาม nonterminal (ซึ่งคุณคิดว่าเป็นรูทีนย่อยที่ตรงกับรูปสี่เหลี่ยมผืนผ้า) 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ตามลำดับ)

JavaScript (ES6), 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)))

จะเข้าเป็น array ของอาร์เรย์ของตัวละคร (เพิ่ม 5 ไบต์สำหรับอาร์เรย์ของสตริง) และส่งกลับหรือ1 0หลังจากตรวจสอบว่าความสูงเป็นเลขคี่ทุกแถวจะถูกตรวจสอบเพื่อให้แน่ใจว่าอาร์เรย์เป็นสี่เหลี่ยมจัตุรัสและอักขระทุกตัวได้รับการตรวจสอบว่าเป็นหนึ่งในอักขระที่เราคาดหวังในตำแหน่งนั้น แก้ไข: บันทึก 2 ไบต์ด้วย @PatrickRoberts

เพิร์ล 124 123 119 95 93 84

สคริปต์ Perl ต่อไปนี้อ่านหนึ่งหน้าต่าง MS ของผู้สมัครจากอินพุตมาตรฐาน จากนั้นจะออกโดยมีสถานะออกเป็นศูนย์หากผู้สมัครเป็น MS Window และมีสถานะออกไม่เป็นศูนย์หากไม่มี

มันทำงานได้โดยการสร้างนิพจน์ทั่วไปสองนิพจน์สำหรับด้านบนกลางและล่างและอีกหนึ่งบรรทัดสำหรับบรรทัดอื่นและตรวจสอบอินพุตกับพวกเขา

ขอบคุณ @Dada และอีกครั้ง.

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

Mathematica, 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]]&

ฟังก์ชั่นที่ไม่มีชื่อสละรายชื่อของรายการของตัวละครที่เป็น input และกลับหรือ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"จากอักขระที่ควรจะเว้นวรรค จากนั้นบรรทัดที่ห้าและเจ็ดจะตรวจสอบว่าพวกเขาเป็นสิ่งที่ควรจะเป็นจริงหรือไม่

JavaScript (ES6), 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'
]));

JavaScript (ES6), 140 138 141 140 ไบต์

ฉันรู้ว่านี่ไม่ใช่การนับไบต์ที่ชนะ (แม้ว่าต้องขอบคุณ Patrick Roberts ที่ -3 และฉันรู้ว่ามันโยนผลบวกปลอมสำหรับ 1 แทน M / S: +3) แต่ฉันทำมันแตกต่างออกไปเล็กน้อยฉัน ' ใหม่สำหรับสิ่งนี้และมันสนุก ...

ยอมรับอาร์เรย์ของสตริงหนึ่งรายการสำหรับแต่ละบรรทัดและส่งคืนค่าจริงหรือเท็จ เพิ่มบรรทัดใหม่เพื่อความชัดเจน (ไม่รวมอยู่ในจำนวนไบต์)

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

JavaScript (ES6), 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));});