Io non so voi tutti, ma sto non preparando per Halloween - non ha mai fatto mai sarà - ma, il mio vicino è, quindi dovremo darle una mano.

Ha bisogno di aiuto per capire quale marca di caramelle ha, ma ha così tante caramelle che non sarebbe in grado di finire prima di Halloween.

Lei ha:

• Snickers
• KitKat
• starburst
• Orsetti gommosi
• Twix

Ingresso

Una stringa multilinea (o qualsiasi altra forma ragionevole) contenente solo lettere e spazi.

Produzione

Un valore falso se non è una caramella valida o quale caramella è se è una caramella.

Come decidere quale caramella è

Una caramella è valida se riporta una delle marche sopra riportate. Tuttavia, non è così semplice, perché questa è una caramella valida:

K i t
       K a
           t

Una caramella valida è quella in cui:

• le lettere sono in ordine da sinistra a destra
• le lettere sono in maiuscolo correttamente
• le lettere, che vanno da sinistra a destra, non salgono e scendono entrambe
• le lettere con spazi bianchi rimossi formano uno dei marchi di cui sopra

Questo è code-golf , quindi vince il codice più corto in byte!

Esempi

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 byte

Spero di aver colto tutti i casi limite. Baserà comprimere l'elenco di caramelle.

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

Test Suite .

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

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)

Provalo qui.

Racchetta 446 byte

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

test:

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

Produzione:

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

JavaScript (ES6), 139 byte

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

Accetta l'input come una matrice di stringhe riempite di spazio.

R, 199 caratteri

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

L'input ha la forma di una matrice di caratteri.

matchsi prende cura di quali caramelle è (controlla anche le maiuscole).

Per verificare che le lettere siano una sequenza "crescente" o "decrescente", è sufficiente verificare che le posizioni del primo carattere non spaziale (se presente) in ogni riga siano in aumento o in diminuzione. Per fare, questo noi

• prendere la prima posizione di un carattere non spaziale in ogni riga, usando apply
• prendere il diff . Questo potrebbe avere qualche zero, altrimenti dovrebbe essere tutto positivo o tutto negativo
• nominare il diff z, e prendere il prodotto esterno con se stesso. Se il diff avesse voci positive e negative miste, ci sarebbe una voce negativa da qualche parte nel suo prodotto esterno. In tal caso, restituire FALSE.

Si noti che casi simili

"    i "
"   w x"
"  T   "

restituirà un vettore di caratteri vuoto (in particolare non "Twix"), poiché matchtenterà di far corrispondere "Twxi".

Python 2.7, 254 byte

Sono sicuro che questo può essere giocato di più. L'input è una matrice di linee 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

Provalo qui!