Die New York Times hat ein tägliches Online-Spiel namens Letter Boxed (der Link befindet sich hinter einer Paywall; das Spiel wird auch hier beschrieben ), das auf einem Quadrat wie folgt dargestellt wird:

Sie erhalten 4 Gruppen mit 3 Buchstaben (jede Gruppe entspricht einer Seite auf dem Bild). kein Buchstabe erscheint zweimal. Das Ziel des Spiels ist es, Wörter zu finden, die aus diesen 12 Buchstaben (und nur diesen Buchstaben) bestehen, so dass:

• Jedes Wort besteht aus mindestens drei Buchstaben.
• Aufeinanderfolgende Buchstaben dürfen nicht von derselben Seite sein.
• Der letzte Buchstabe eines Wortes wird zum ersten Buchstaben des nächsten Wortes;
• Alle Buchstaben werden mindestens einmal verwendet (Buchstaben können wiederverwendet werden).

In dieser Herausforderung erhalten Sie die Buchstaben und eine Liste von Wörtern. Ziel ist es, zu überprüfen, ob die Liste der Wörter eine gültige Letter Boxed-Lösung ist.

Eingang

Die Eingabe besteht aus (1) 4 Gruppen von 3 Buchstaben und (2) einer Liste von Wörtern. Es kann in jedem geeigneten Format vorliegen.

Ausgabe

Ein wahrer Wert, wenn die Liste der Wörter eine gültige Lösung für die Letter Boxed-Herausforderung für diese 4 × 3-Buchstaben ist, und ein falscher Wert, falls dies nicht der Fall ist.

Testfälle

Buchstabengruppen = {{I,C,O}, {M,R,E}, {G,N,S}, {A,P,L}}.

Wahrheitswerte

• PILGERFAHRT, ENCLOSE
• CROPS, SAIL, LEAN, NOPE, ENIGMA

Falsche Werte

• PILGERFAHRT, WIRTSCHAFT (kann kein CO haben, da sie auf der gleichen Seite sind)
• CROPS, SAIL, LEAN, NOPE (G und M wurden nicht verwendet)
• PILGERFAHRT, ENCLOSURE (U ist nicht einer der 12 Buchstaben)
• ENCLOSE, PILGRIMAGE (letzter Buchstabe des 1. Wortes ist nicht der erste Buchstabe des 2. Wortes)
• SCAMS, SO, ORGANIZE, ELOPE (alle Wörter müssen mindestens 3 Buchstaben lang sein).

Beachten Sie, dass es uns bei dieser Herausforderung egal ist, ob die Wörter gültig sind (Teil eines Wörterbuchs).

Wertung:

Dieser Code-Golf , niedrigste Punktzahl in Bytes gewinnt!

JavaScript (ES6),  130  126 Bytes

(letters)(words)$0$$1$

L=>W=>L.every(a=>a.every(x=>(W+'').match(x,a.map(y=>s+='|'+x+y))),p=s=1)&W.every(w=>w[2]&&p|w[0]==p&!w.match(s,p=w.slice(-1)))

Probieren Sie es online!

Schritt 1

$L$$s$

L.every(a =>              // for each group of letter a[] in L[]:
  a.every(x =>            //   for each letter x in a[]:
    (W + '')              //     coerce W[] to a string
    .match(               //     and test whether ...
      x,                  //       ... x can be found in it
      a.map(y =>          //       for each letter y in a[]:
        s += '|' + x + y  //         append '|' + x + y to s
      )                   //       end of map()
    )                     //     end of match()
  ),                      //   end of inner every()
  p = s = 1               //   start with p = s = 1
)                         // end of outer every()

Schritt 2

$W$

W.every(w =>              // for each word w in W[]:
  w[2] &&                 //   is this word at least 3 characters long?
  p |                     //   is it the first word? (p = 1)
  w[0] == p &             //   or does it start with the last letter of the previous word?
  !w.match(               //   and finally make sure that ...
    s,                    //     ... it doesn't contain any invalid pair of letters
    p = w.slice(-1)       //     and update p to the last letter of w
  )                       //   end of match()
)                         // end of every()

Gelee , 30 29 Bytes

FQṢ=Ṣ},i@€€’:3Iʋ,Ẉ>2ɗ,U=ḢɗƝ{Ȧ

Probieren Sie es online!

Ein dyadischer Link, der die Liste der Wörter als linkes Argument und die abgeflachte Liste der Buchstaben im Feld als rechtes Argument verwendet. Es kehrt 1für wahr und 0falsch zurück.

Erläuterung

F                               | Flatten the word list
 Q                              | Unique
  Ṣ                             | Sort
   =                            | Is equal to
    Ṣ}                          |   The sorted letterbox letters
      ,        ʋ                | Pair this with the following:
       i@€€                     |   The index of each letter of each word in the letterbox            
           ’                    |   Decrease by 1
            :3                  |   Integer divide by 3
              I                 |   Differences between consecutive ones (will be zero if any two consecutive letters in a word from same side of box)
                ,   ɗ           | Pair everything so far with the following:
                 Ẉ>2            |   Whether length of each input word is greater than 2
                     ,   ɗƝ{    | Pair everything so far with the following, applied to each neighbouring pair of the input word list
                      U         |   Upend (reverse) first word
                       =        | Compare characters to second
                        Ḣ       |   Take first (i.e. last character of first word equals first character of second)
                            Ȧ   | Flatten all of the above and check there are no false values

05AB1E , 37 35 33 32 31 29 28 Bytes

εk3÷üÊ}DO2@¹ü«εüQO}²{¹˜êQ)˜P

-2 Bytes durch Inspiration des êAnsatzes @Emigna, der in seiner 05AB1E-Antwort verwendet wurde .
-3 Bytes dank @Grimy .

Nimmt eine Liste mit Zeichen für die Wörter als erste Eingabe und die abgeflachte Liste mit zwölf Buchstaben als zweite Eingabe.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

ε         # Map over the character-lists `y` of the (implicit) input-list of words:
 k        #  Get the index of each character in the (implicit) input-list of letters
  3÷      #  Integer-divide each index by 3
    üÊ    #  Check for each overlapping pair of integers that they are NOT equal
}D        # After the map: duplicate the resulting list
  O       #  Get the sum of each inner list of truthy/falsey values
   2@     #  And check that each is larger than 2 (so all words had at least 3 letters)
¹ü        # Get all overlapping pairs of character-lists from the input-list of words:
  «       #  And merge them together to a flattened list of characters
   ε   }  # Map over those merged character lists:
    üQ    #  Check for each overlapping pair of characters in the list that they are equal
      O   #  And take the sum of this (where we'd expect 1/truthy if the last character of
          #  the first word and the first character of the second word are equal)
          #  (NOTE: This could fail for inputs with identical adjacent characters,
          #   but the earlier check of `εk3÷üÊ}` already covers for this)
²{        # Push the input-list of letters, and sort them
  ¹˜      # Push the input-list of list of word-letters, flattened,
    ê     # and then uniquified and sorted as well
     Q    # And check if both lists of characters are the same
)˜        # Then wrap everything on the stack into a list, and deep flatten it
  P       # And check if everything is truthy by taking the product
          # (which is output implicitly as result)

05AB1E , 42 Bytes

εg2›}P¹εεUIεXå}ƶO}üÊP}P¹ü‚ε`нsθQ}P¹Jê²JêQP

Probieren Sie es online!

Python 2 , 171 Bytes

lambda l,w:(set(sum(l,[]))==set(''.join(w)))*all(a[-1]==b[0]for a,b in zip(w,w[1:]))*all((a in g)+(b in g)<2for x in w for a,b in zip(x,x[1:])for g in l)*min(map(len,w))>2

Probieren Sie es online!

Jelly , 34 Bytes

Ṫ=¥/ƝḢ€Ạȧ⁸Fe€ⱮZḄ;IẠƊȧF}fƑF{
ẈṂ>2ȧç

Ein dyadischer Link, der die Wörter auf der linken Seite und die Buchstabengruppen auf der rechten Seite akzeptiert, was ergibt, 1ob gültig und 0wenn nicht.

Probieren Sie es online! Oder sehen Sie sich die Testsuite an .

Haskell , 231 Bytes

import Data.List
l&w=all((>2).length)w&&c w&&all(l!)w&&(h l)%(h w)
h=concat
l%w=null[x|x<-l,x`notElem`w]
l!(a:b:c)=a#l?(b#l)&&l!(b:c)
l!_=1>0
Just a?Just b=a/=b
_?_=1<0
c#l=findIndex(elem c)l
c(a:b:t)=last a==head b&&c(b:t)
c _=1>0

Probieren Sie es online!

Nicht das beste Ergebnis. Einige Haskell-Guru werden das wahrscheinlich unter 100 Bytes schaffen.

Verwendung

["ICO","MRE","GNS","APL"]&["CROPS", "SAIL", "LEAN", "NOPE", "ENIGMA"]

Erläuterung

import Data.List
l&w = all((>2).length)w &&      -- Every word has length > 2
      c w &&                    -- Every word ends with the same letter as the next one starts with
      all(l!)w &&               -- For every word: Consecutive letters are on different sides (and must exist on a side)
      (h l)%(h w)               -- All letters are used

h=concat                        -- Just a shorthand

l%w=null[x|x<-l,x`notElem`w]    -- The letters of l, with all letters of w removed, is empty

l!(a:b:c)=a#l?(b#l)&&l!(b:c)    -- Sides of the first two letters are different, recurse from second letter
l!_=1>0                         -- Until fewer than 2 letters remain

Just a?Just b=a/=b              -- Both sides must be different
_?_=1<0                         -- And must exist

c#l=findIndex(elem c)l          -- Find the side of letter c

c(a:b:t)=last a==head b&&c(b:t) -- Last letter of the first word must be same as first letter of second word, recurse starting from second word
c _=1>0                         -- Until there are fewer than 2 words

Haskell , 231 Bytes

Eine andere Haskell-Variante, genau so groß wie @Paul Mutser's :)

import Data.List
f x=filter(\a->length a>1)$concatMap subsequences x
g=nub.concat.f
p l(x:y)=foldl(\(m,n)c->(c,n&&length c>2&&(not$any(`isInfixOf`c)(f l))&&last m==head c))(x,True)y
z l w=null(g l\\g w)&&null(g w\\g l)&&(snd$p l w)

Probieren Sie es online!

Ungolfed

-- generate all invalid substrings
f :: [String] -> [String] 
f xs = filter (\x -> length x > 1) $ concatMap subsequences xs

-- utility function to flatten and remove duplicates
g :: [String] -> String
g  = nub $ concat $ f

-- verify that all conditions are satisfied along the list
p :: [String] -> [String] -> (String, Bool)
p l (x:xs) = foldl (\(m,n) c -> (c , n && length c > 2 && (not $ any (`isInfixOf` c)(f l)) && last m == head c)) (x, True) xs

-- put all the pieces together and consume input
z :: [String] -> [String] -> Bool
z l w = null (g l \\ g w) && null (g w \\ g l) && (snd $ p l w)

Ruby , 126 Bytes

->l,w{(/(_|^)..(_|$)/!~s=w*?_)&&!!s.chars.uniq[12]&&/__|^_|_$|(_.*)\1/!~s.gsub(/(.)_\1/,'\1').chars.map{|x|l.grep(/#{x}/)}*?_}

Probieren Sie es online!

Java (JDK) , 188 Byte

g->w->{var v=0<1;int x=0,l,i=0,j,p,z,y=w[0][0];for(;i<w.length;i++)for(l=w[i].length,v&=y==w[i][0]&l>2,j=0,p=-9;j<l;v&=z>=0&z/3!=p/3,x|=2<<(p=z))z=g.indexOf(y=w[i][j++]);return v&x==8190;}

Probieren Sie es online!

Erklärungen

g->w->{     // Lambda accepting letter groups as a string and a list of words, in the form of an array of char arrays.
 var v=0<1;     // Validity variable
 int x=0,       // The letter coverage (rule 4)
     l,         // The length of w[i]
     i=0,       // The w iterator
     j,         // The w[i] iterator
     p,         // The previous group
     z,         // The current group
     y=w[0][0]; // The previous character
 for(;i<w.length;i++) // For each word...
  for(
     l=w[i].length,     // make a shortcut for the length
     v&=y==w[i][0]&l>2, // check if the last character of the previous word is the same as the first of the current.
                        // Also, check if the length is at least 3
     j=0,               // Reset the iteration
     p=-9               // Set p to an impossible value.
    ;
     j<l                // 
    ;
     v&=z>=0&z/3!=p/3,  // Check that each letter of the word is in the letter pool,
                        //  and that the current letter group isn't the same as the previous one.
     x|=2<<(p=z)      // After the checks, assign z to p,
                        //  and mark the letter of the pool as used.
   )
   z=g.indexOf(y=w[i][j++]); // Assign the current letter to y so that it contains the last at the end of the loop.
                             //  and fetch the position of the letter in the pool.
 return v&x==8190; // Return true if all matched
                   //  and if the rule 4 is enforced.
}

Credits

• -2 Bytes dank ceilingcat

Kohle , 63 Bytes

⌊⁺⁺⁺⭆η›Ｌι²⭆⪫ηω№⪫θωι⭆⪫θω№⪫ηωι⭆η⭆ι⎇μ¬⁼Φθ№νλΦθ№ν§ι⊖μ∨¬κ⁼§ι⁰§§η⊖κ±¹

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

⌊⁺⁺⁺

Verketten Sie die folgenden Ausdrücke und geben Sie sie aus, 0wenn einer von ihnen a enthält0 anderes enthält 1.

⭆η›Ｌι²

Geben Sie für jedes Wort in der Lösung aus, ob seine Länge mindestens 3 beträgt.

⭆⪫ηω№⪫θωι

Geben Sie für jeden Buchstaben in der Lösung aus, ob er im Puzzle angezeigt wird.

⭆⪫θω№⪫ηωι

Für jeden Buchstaben im Puzzle wird ausgegeben, ob er in der Lösung erscheint.

⭆η⭆ι⎇μ¬⁼Φθ№νλΦθ№ν§ι⊖μ∨¬κ⁼§ι⁰§§η⊖κ±¹

Überprüfen Sie für jeden Buchstaben in der Lösung, dass der vorherige Buchstabe nicht zur selben Gruppe gehört, es sei denn, es ist der erste Buchstabe eines Wortes. In diesem Fall überprüfen Sie, ob er dem letzten Buchstaben des vorherigen Wortes entspricht, sofern es nicht der erste ist Buchstabe der Lösung, in diesem Fall einfach ignorieren.

Python 2 , 168 156 Bytes

lambda l,w,J=''.join:(set(J(w))==set(J(l)))*all((v<1or u[-1]==v[0])*u[2:]*(2>(x in p)+(y in p))for u,v in zip(w,w[1:]+[0])for x,y in zip(u,u[1:])for p in l)

Probieren Sie es online!

Returns 1für truthy, 0für Falsey.