Je ne sais pas tout de vous mais je ne me prépare pas pour Halloween –– je n'ai jamais voulu –– mais, mon voisin l'est, alors nous allons l'aider.

Elle a besoin d'aide pour déterminer quelle marque de bonbons elle a, mais elle a tellement de bonbons qu'elle ne pourrait pas finir avant Halloween.

Elle a:

• Snickers
• KitKat
• Starburst
• GummyBears
• Twix

Contribution

Une chaîne multiligne (ou toute autre forme raisonnable) contenant uniquement des lettres et des espaces.

Production

Une valeur falsifiée s'il ne s'agit pas d'un bonbon valide, ou de quel bonbon il s'agit s'il s'agit d'un bonbon.

Comment décider de quel bonbon il s'agit

Un bonbon est valable s'il indique l'une des marques ci-dessus. Cependant, ce n'est pas si simple, car c'est un bonbon valide:

K i t
       K a
           t

Un bonbon valide est celui où:

• les lettres sont en ordre de gauche à droite
• les lettres sont correctement capitalisées
• les lettres, allant de gauche à droite, ne pas à la fois monter et descendre
• les lettres avec des espaces supprimés forment l'une des marques ci-dessus

C'est le code-golf , donc le code le plus court en octets gagne!

Exemples

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 octets

J'espère avoir attrapé tous les cas extrêmes. Base la liste des bonbons compressés.

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

Suite de tests .

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

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)

Essayez-le ici.

Raquette 446 octets

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

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

Essai:

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

Production:

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

JavaScript (ES6), 139 octets

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

Accepte l'entrée en tant que tableau de chaînes à espace rembourré.

R, 199 caractères

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'entrée se présente sous la forme d'une matrice de caractères.

matchprend soin de quel bonbon c'est (il vérifie aussi la capitalisation).

Pour vérifier que les lettres sont une séquence "ascendante" ou "descendante", nous avons juste besoin de vérifier que les emplacements du premier caractère non-espace (s'il y en a) dans chaque ligne augmente ou diminue. Pour ce faire, nous

• prendre le premier emplacement d'un caractère non spatial dans chaque ligne, en utilisant apply
• prenez le diff. Cela pourrait avoir un zéro, sinon devrait être soit tout positif soit tout négatif
• nommez-le diff zet emportez le produit extérieur avec lui-même. Si le diff avait des entrées positives et négatives mixtes, il y aura une entrée négative quelque part dans son produit extérieur. Si c'est le cas, retournez FALSE.

Notez que des cas comme

"    i "
"   w x"
"  T   "

renverra un vecteur de caractère vide (en particulier pas "Twix"), car matchessaiera de faire correspondre "Twxi".

Python 2.7, 254 octets

Je suis sûr que cela peut être joué plus. L'entrée est un tableau de lignes 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

Essayez-le ici!