Eu não sei sobre todos vocês, mas não estou me preparando para o Halloween - nunca nunca soube - mas meu vizinho é, então vamos ajudá-la.

Ela precisa de ajuda para descobrir qual tipo de doce ela tem, mas ela tem tantos doces que não conseguiria terminar antes do Halloween.

Ela tem:

• Snickers
• KitKat
• Starburst
• GummyBears
• Twix

Entrada

Uma sequência multilinha (ou qualquer outra forma razoável) contendo apenas letras e espaços.

Resultado

Um valor falso se não for um doce válido ou qual é o doce se for um doce.

Como decidir qual doce é

Um doce é válido se houver uma das marcas acima. No entanto, não é tão simples, porque este é um doce válido:

K i t
       K a
           t

Um doce válido é aquele em que:

• as letras estão em ordem da esquerda para a direita
• as letras são maiúsculas corretamente
• as letras, indo da esquerda para a direita, não tanto subir e descer
• as letras com espaços em branco removidos formam uma das marcas acima

Isso é código-golfe , então o código mais curto em bytes ganha!

Exemplos

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

Pitão - 72 bytes

Espero ter pego todos os casos extremos. Base irá comprimir lista de doces.

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

Conjunto de Teste .

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)

Experimente aqui.

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

Ungolfed:

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

Teste:

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

Resultado:

#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,''))

Aceita entrada como uma matriz de cadeias de caracteres preenchidas com espaço.

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

A entrada está na forma de uma matriz de caracteres.

matchcuida de qual doce é (verifica também a capitalização).

Para verificar se as letras são uma sequência "ascendente" ou "descendente", basta verificar se os locais do primeiro caractere não espacial (se houver) em cada linha estão aumentando ou diminuindo. Para fazer isso, nós

• pegue o primeiro local de um caractere não espacial em cada linha, usando apply
• pegue o diff. Isso pode ter algum zero, caso contrário, deve ser tudo positivo ou tudo negativo
• nomeie diff ze leve o produto externo consigo. Se o diff tiver entradas positivas e negativas mistas, haverá uma entrada negativa em algum lugar do produto externo. Nesse caso, retorne FALSE.

Observe que casos como

"    i "
"   w x"
"  T   "

retornará um vetor de caractere vazio (em particular não "Twix"), pois matchestará tentando corresponder a "Twxi".

Python 2.7, 254 bytes

Tenho certeza que isso pode ser jogado mais. Entrada é uma matriz de linhas 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

Experimente aqui!