Cửa sổ là một hình vuông nghệ thuật ASCII có chiều dài cạnh lẻ ít nhất là 3, với một đường viền ký tự duy nhất xung quanh cạnh cũng như các nét dọc và ngang ở giữa:

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

Cửa sổ MS là một cửa sổ nơi đường viền chỉ được tạo từ các ký tự Mvà S. Nhiệm vụ của bạn là viết một chương trình (hoặc hàm) lấy một chuỗi và xuất ra một giá trị trung thực nếu đầu vào là một Cửa sổ MS hợp lệ và giá trị falsey nếu không.

Thông số kỹ thuật

• Bạn có thể lấy đầu vào là một chuỗi phân tách dòng mới hoặc một chuỗi các chuỗi đại diện cho mỗi dòng.
• Đường viền của Cửa sổ MS có thể chứa hỗn hợp các ký tự M và S, nhưng bên trong sẽ luôn bao gồm các khoảng trắng.
• Bạn có thể chọn chỉ phát hiện các cửa sổ có dòng mới, hoặc chỉ cửa sổ mà không theo dõi dòng mới, nhưng không phải cả hai.

Các trường hợp thử nghiệm

Sự thật:

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 byte

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

Hãy thử nó ở đây!

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

Võng mạc , 68 67 byte

Số lượng byte giả định mã hóa ISO 8859-1.

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

Hãy thử trực tuyến!

Grime , 39 38 byte

Cảm ơn Zgarb vì đã tiết kiệm 1 byte.

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

Hãy thử trực tuyến!

Tôi không chắc liệu có cách nào đơn giản hơn để thực thi tỷ lệ khung hình vuông của các thành phần cửa sổ riêng lẻ hay không bằng cách sử dụng một nonterminal đệ quy, nhưng điều này dường như đang hoạt động khá tốt.

Giải trình

Tốt nhất là đọc chương trình từ dưới lên.

W=[MS

Điều này chỉ đơn giản là định nghĩa một nonterminal (mà bạn có thể nghĩ là chương trình con khớp với hình chữ nhật) Wkhớp với một Mhoặc một S(có một ẩn ]ở cuối dòng).

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

Điều này xác định một thiết bị đầu cuối Bkhông khớp với khoảng một phần tư đầu ra, tức là một bảng điều khiển cửa sổ với đường viền bên trái và trên cùng. Một cái gì đó như thế này:

MSM
S  
M  

Để đảm bảo rằng bảng điều khiển cửa sổ này là hình vuông, chúng tôi xác định Bđệ quy. Đó là một nhân vật cửa sổ W, hoặc nó B/W\ * W/\ /*thêm một lớp ở bên phải và ở dưới cùng. Để xem làm thế nào nó làm điều này, hãy loại bỏ một số đường cú pháp:

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

Điều này là giống nhau, bởi vì ghép nối ngang có thể được viết ABhoặc A B, nhưng cái sau có độ ưu tiên thấp hơn so với nối dọc /trong khi đối với cái trước có giá trị cao hơn. Vì vậy, B/W[ ]*một Bvới một nhân vật cửa sổ và một hàng không gian bên dưới. Và sau đó chúng tôi nối thêm vào W/[ ]/*đó là một ký tự cửa sổ với một cột khoảng trắng.

Cuối cùng, chúng tôi lắp ráp các nonterminals này thành hình dạng cửa sổ cuối cùng:

BB/BB/W+ W/+

Đó là bốn ô cửa sổ Btheo sau là một hàng ký tự cửa sổ và một cột ký tự cửa sổ. Lưu ý rằng chúng tôi không khẳng định rõ ràng rằng bốn bảng cửa sổ có cùng kích thước, nhưng nếu chúng không thể ghép chúng thành hình chữ nhật.

Cuối cùng, e`phần đầu chỉ đơn giản là một cấu hình cho Grime kiểm tra xem toàn bộ đầu vào có thể được khớp với mẫu này không (và nó in 0hoặc 1theo đó).

JavaScript (ES6), 115 113 byte

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

Lấy đầu vào là một mảng các mảng ký tự (thêm 5 byte cho một chuỗi các chuỗi) và trả về 1hoặc 0. Sau khi xác minh rằng chiều cao là số lẻ, mọi hàng được kiểm tra để đảm bảo mảng là hình vuông và mỗi ký tự được xác minh là một trong các ký tự mà chúng tôi mong đợi ở vị trí cụ thể đó. Chỉnh sửa: Đã lưu 2 byte nhờ @PatrickRoberts.

Perl, 124 123 119 95 93 84

Kịch bản Perl sau đây đọc một ứng dụng MS Window từ đầu vào tiêu chuẩn. Sau đó, nó thoát với trạng thái thoát bằng 0 nếu ứng viên là Cửa sổ MS và với trạng thái thoát khác không nếu không.

Nó hoạt động bằng cách tạo hai biểu thức chính quy, một cho dòng trên cùng, giữa và dưới cùng và một cho mọi dòng khác và kiểm tra đầu vào đối với chúng.

Cảm ơn, @Dada. Và một lần nữa.

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

Toán học, 166 byte

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

Hàm không tên lấy danh sách các danh sách các ký tự làm đầu vào và trả về Truehoặc False. Đây là một phiên bản ít chơi gôn hơn:

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

Dòng đầu tiên xác định hàm t, phân tách một danh sách độ dài dthành hai phần, phần đầu tiên là mục đầu tiên, giữa và cuối cùng của danh sách và phần thứ hai là tất cả phần còn lại. Dòng thứ hai kiểm tra xem đầu vào là một mảng vuông ở vị trí đầu tiên. Dòng thứ tư sử dụng thai lần, một lần cho chính đầu vào và một lần trên tất cả * các chuỗi trong đầu vào, để phân tách các ký tự được cho là "M"hoặc "S"từ các ký tự được coi là khoảng trắng; sau đó các dòng thứ năm và thứ bảy kiểm tra xem chúng có thực sự là những gì chúng được cho là không.

JavaScript (ES6), 108 106 byte

Đầu vào: mảng chuỗi / Đầu ra: 0hoặc1

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)

Các trường hợp thử nghiệm

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 byte

Tôi biết đây không phải là số byte chiến thắng (mặc dù nhờ Patrick Roberts cho -3 và tôi nhận ra rằng nó đã ném dương tính giả cho 1 thay vì M / S: +3), nhưng tôi đã làm theo cách hơi khác, tôi ' Tôi mới làm điều này, và nó rất vui ...

Chấp nhận một chuỗi các chuỗi, một chuỗi cho mỗi dòng và trả về true hoặc false. Dòng mới được thêm vào cho rõ ràng (không bao gồm trong số byte).

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

Thay vì kiểm tra đầu vào theo mẫu tổng quát, tôi xây dựng cửa sổ 'M' có cùng kích thước, thay S bằng M trên đầu vào và so sánh hai cửa sổ.

Bị đánh cắp

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

Các trường hợp thử nghiệm

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 byte

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

Chỉnh sửa : Whoa, Arnauld đã lưu cho tôi 6 byte bằng cách thay đổi s.split`\n`.lengththành s.search`\n`! Cảm ơn!

Điều này cần một chuỗi đa dòng đơn và xây dựng RegExpxác nhận dựa trên cơ sở bằng cách sử dụng độ dài của chuỗi đầu vào. Trả về truehoặc false. Giả định một cửa sổ hợp lệ có không có một ký tự dòng mới.

Bản giới thiệu

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