No sé acerca de todo lo que estoy pero no se prepara para Halloween - nunca lo hizo nunca - pero, es mi vecino, lo que vamos a ayudar a salir.

Necesita ayuda para determinar qué marca de dulces tiene, pero tiene tantos dulces que no podría terminar antes de Halloween.

Ella tiene:

• Snickers
• Kit Kat
• Starburst
• Ositos de goma
• Twix

Entrada

Una cadena multilínea (o cualquier otra forma razonable) que contenga solo letras y espacios.

Salida

Un valor falso si no es un dulce válido, o qué dulce es si es un dulce.

Cómo decidir qué dulce es

Un caramelo es válido si dice una de las marcas anteriores en él. Sin embargo, no es tan simple, porque este es un dulce válido:

K i t
       K a
           t

Un dulce válido es aquel donde:

• las letras están en orden de izquierda a derecha
• las letras están en mayúscula correctamente
• las letras, yendo de izquierda a derecha, no tanto subir y bajar
• las letras con espacios en blanco eliminados forman una de las marcas anteriores

Este es el código de golf , por lo que gana el código más corto en bytes.

Ejemplos

Truthys

1.
              kers
           c
        i
       n
    S    

2.
  Kit K a t

3. 
St a
    r b u
         r st 

4.
         Bear s
G ummy

5.
T w i
                          x

Falsys:

1.
SNICKERS

2.
 C   n

   a   d y

3. 
xiwT

4.
S C I
       ss o
              r       s

5.
Kit
Kat

Pyth - 72 bytes

Espero haber captado todos los casos límite. Basará comprimir la lista de dulces.

&sSIM_Bmxdh-d;fnd{TK.tQd}-sKdc"Snickers KitKat Starburst GummyBears Twix

Test Suite .

JavaScript (ES6), 221 218 216 212 208 205 201 bytes

f=a=>(c=d=L=0,e=1,s=[],[...a].map(a=>a=='\n'?c=L=0:c++-(a!=' '&&(s[c]?e=0:(!L&&(d?d-1?e&=c>Q>d-3:d=c>Q>2:d=1),L=s[Q=c]=a)))),e&&'Snickers0KitKat0Starburst0GummyBears0Twix'.split(0).indexOf(s.join``)+1)

Pruébalo aquí.

Raqueta 446 bytes

(let((lr list-ref)(ls list-set)(sl string-length)(ss substring)(l(string-split s "\n")))(let loop((changed #f))(for((i(sub1(length l))))
(let*((s(lr l i))(r(lr l(add1 i)))(n(sl s))(m(sl r)))(when(> n m)(set! l(ls l i(ss s 0 m)))(set! l(ls l(add1 i)
(string-append r(ss s m n))))(set! changed #t))))(if changed(loop #f)(begin(let*((l(for/list((i l))(string-trim i)))(l(string-join l))
(l(string-replace l " " "")))(ormap(λ(x)(equal? x l))cl))))))

Sin golf:

(define (f s cl)
  (let ((lr list-ref)
        (ls list-set)
        (sl string-length)
        (ss substring)
        (l (string-split s "\n")))
    (let loop ((changed #f))
      (for ((i (sub1 (length l))))
        (let* ((s (lr l i))
               (r (lr l (add1 i)))
               (n (sl s))
               (m (sl r)))
               (when (> n m)
                 (set! l (ls l i (ss s 0 m)))
                 (set! l (ls l (add1 i)(string-append r (ss s m n))))
                 (set! changed #t))))
        (if changed (loop #f)
            (begin
              (let* ((l (for/list ((i l))
                          (string-trim i)))
                     (l (string-join l))
                     (l (string-replace l " " "")))
                (ormap (λ(x) (equal? x l)) cl)))
            ))))

Pruebas:

(f "
              kers
           c
        i
       n
    S"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))


(f "  Kit K a t"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "St a
    r b u
         r st "
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "         Bear s
G ummy"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "T w i
                          x"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "SNICKERS"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))
(f " C   n
          y
   a   d"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "xiwT"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "S C I
       ss o
              r       s"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

(f "Kit
Kat"
   (list "Snickers""KitKat""Starburst""GummyBears""Twix"))

Salida:

#t
#t
#t
#t
#t
#f
#f
#f
#f
#t

JavaScript (ES6), 139 bytes

a=>/^(Snickers|KitKat|Starburst|GummyBears|Twix)$/.test(a.reduce((s,t)=>s.replace(/./g,(c,i)=>c<'!'?t[i]:t[i]<'!'?c:'!')).replace(/ /g,''))

Acepta entradas como una matriz de cadenas rellenas de espacio.

R, 199 caracteres

function(M){if(any(outer(z<-diff(apply(M,1,function(r)which.min(r==" ")))),z<0))return(F);C=c("Twix","KitKat","Starburst","Snickers","GummyBears");C[match(paste0(gsub(" ","",c(t(M))),collapse=""),C)}

La entrada tiene la forma de una matriz de caracteres.

matchse encarga de qué dulce es (también comprueba las mayúsculas).

Para verificar que las letras son una secuencia "ascendente" o "descendente", solo tenemos que verificar que las ubicaciones del primer carácter no espacial (si existe) en cada fila estén aumentando o disminuyendo. Para hacer esto, nosotros

• tomar la primera ubicación de un carácter no espacial en cada fila, usando apply
• tomar el diff. Esto podría tener algo de cero, de lo contrario debería ser todo positivo o todo negativo
• nombra el diff zy toma el producto externo consigo mismo. Si el diferencial tenía entradas mixtas positivas y negativas, habrá una entrada negativa en algún lugar de su producto externo. Si es así, devuelve FALSE.

Tenga en cuenta que casos como

"    i "
"   w x"
"  T   "

devolverá un vector de caracteres vacío (en particular, no "Twix"), ya matchque intentará hacer coincidir "Twxi".

Python 2.7, 254 bytes

Estoy seguro de que se puede jugar más al golf. La entrada es una matriz de líneas s.

x=len
p=lambda a:x(a)-x(a.lstrip())
g=sorted
a=map(p,l)
j=''.join
z=[i.replace(' ','')for i in l]
if g(a)==a:q=j(z)
elif g(a)==a[::-1]:q=j(z[::-1])
else:q=''
if x(set(a))<x(a):q=''
print 1if q in('Snickers','KitKat','Starburst','GummyBears','Twix')else 0

Pruébalo aquí!