Una ventana es un cuadrado de arte ASCII con una longitud lateral impar de al menos 3, con un borde de un solo carácter alrededor del borde, así como trazos verticales y horizontales en el medio:

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

Una ventana de MS es una ventana donde el borde está hecho solo de los caracteres My S. Su tarea es escribir un programa (o función) que tome una cadena y genere un valor verdadero si la entrada es una ventana de MS válida, y un valor falso si no lo es.

Presupuesto

• Puede tomar la entrada como una cadena separada por una nueva línea o una matriz de cadenas que representan cada línea.
• El borde de una ventana de MS puede contener una mezcla de caracteres M y S, pero el interior siempre estará compuesto de espacios.
• Puede elegir detectar solo ventanas con nuevas líneas finales, o solo ventanas sin nuevas líneas finales, pero no ambas.

Casos de prueba

Verdad:

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 bytes

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

Pruébalo aquí!

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

Retina , 68 67 bytes

El recuento de bytes asume la codificación ISO 8859-1.

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

Pruébalo en línea!

Grime , 39 38 bytes

Gracias a Zgarb por guardar 1 byte.

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

Pruébalo en línea!

No estoy seguro de si hay una forma más simple de aplicar la relación de aspecto cuadrado de los componentes de la ventana individual que usar un terminal no recursivo, pero parece estar funcionando bastante bien.

Explicación

Es mejor leer el programa de abajo hacia arriba.

W=[MS

Esto simplemente define un no terminal (que se puede considerar como una subrutina que coincide con un rectángulo) Wque coincide con an Mo an S(hay un implícito ]al final de la línea).

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

Esto define un no terminal Bque coincide con aproximadamente una cuarta parte de la salida, es decir, un panel de ventana con el borde izquierdo y superior. Algo como esto:

MSM
S  
M  

Para garantizar que este panel de ventana sea cuadrado, definimos Brecursivamente. Es un personaje de ventana Wo es el B/W\ * W/\ /*que agrega una capa a la derecha y al fondo. Para ver cómo hace esto, eliminemos un poco de azúcar sintáctica:

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

Esto es lo mismo, porque la concatenación horizontal puede escribirse ABo bien A B, pero la última tiene una precedencia menor que la concatenación vertical, /mientras que la primera tiene mayor. Entonces B/W[ ]*es un Bcon un carácter de ventana y una fila de espacios a continuación. Y luego agregamos horizontalmente W/[ ]/*que es un carácter de ventana con una columna de espacios.

Finalmente, ensamblamos estos no terminales en la forma final de la ventana:

BB/BB/W+ W/+

Son cuatro paneles de ventana Bseguidos de una fila de caracteres de ventana y una columna de caracteres de ventana. Tenga en cuenta que no hacemos ninguna afirmación explícita de que los cuatro paneles de ventana son del mismo tamaño, pero si no lo son, es imposible concatenarlos en un rectángulo.

Finalmente, e`al principio es simplemente una configuración que le dice a Grime que verifique que toda la entrada pueda coincidir con este patrón (e imprime 0o en 1consecuencia).

JavaScript (ES6), 115 113 bytes

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

Toma la entrada como una matriz de matrices de caracteres (agrega 5 bytes para una matriz de cadenas) y devuelve 1o 0. Después de verificar que la altura es impar, se verifica cada fila para garantizar que la matriz sea cuadrada, y se verifica que cada carácter sea uno de los caracteres que esperamos en esa posición en particular. Editar: Guardado 2 bytes gracias a @PatrickRoberts.

Perl 124 123 119 95 93 84

El siguiente script de Perl lee una ventana MS candidata desde la entrada estándar. Luego sale con un estado de salida cero si el candidato es una ventana de MS y con un estado de salida distinto de cero si no lo es.

Funciona generando dos expresiones regulares, una para la línea superior, media e inferior y otra para cada línea, y verificando la entrada contra ellas.

Gracias, @Dada. Y otra vez.

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

Mathematica, 166 bytes

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

Función sin nombre que toma una lista de listas de caracteres como entrada y regresa Trueo False. Aquí hay una versión menos golfista:

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

La primera línea define la función t, que separa una lista de longitud den dos partes, la primera de las cuales es la primera, intermedia y última entrada de la lista, y la segunda es el resto. La segunda línea verifica si la entrada es una matriz cuadrada en primer lugar. La cuarta línea usa tdos veces, una en la entrada en sí y otra en todas * las cadenas en la entrada, para separar los caracteres que se supone que son "M"o "S"de los caracteres que se supone que son espacios; luego las líneas quinta y séptima verifican si realmente son lo que se supone que deben ser.

Javascript (ES6), 108 106 bytes

Entrada: conjunto de cadenas / Salida: 0o1

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)

Casos de prueba

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 bytes

Sé que este no es un conteo de bytes ganador (aunque gracias a Patrick Roberts por -3, y me di cuenta de que arrojó falsos positivos para 1 en lugar de M / S: +3), pero lo hice de una manera ligeramente diferente, yo ' Soy nuevo en esto, y fue divertido ...

Acepta una serie de cadenas, una para cada línea y devuelve verdadero o falso. Nueva línea agregada para mayor claridad (no incluida en el recuento de bytes).

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

En lugar de verificar la entrada contra un patrón generalizado, construyo una ventana 'M' del mismo tamaño, reemplazo S con M en la entrada y comparo las dos.

Sin golf

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

Casos de prueba

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 bytes

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

Editar : Whoa, Arnauld me ahorró 6 bytes al cambiar s.split`\n`.lengtha s.search`\n`! ¡Gracias!

Esto toma una sola cadena multilínea y construye una RegExpvalidación basada en la longitud de la cadena de entrada. Devolucionestrue o false. Asume una ventana válida tiene no tiene un salto de línea final.

Manifestación

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