The New York Times has a daily online game called Letter Boxed (the link is behind a paywall; the game is also described here), presented on a square as follows:

You are given 4 groups of 3 letters (each group corresponds to one side on the picture); no letter appears twice. The aim of the game is to find words made of those 12 letters (and those letters only) such that:

• Each word is at least 3 letters long;


• Consecutive letters cannot be from the same side;


• The last letter of a word becomes the first letter of the next word;


• All letters are used at least once (letters can be reused).

In this challenge, you are given the letters and a list of words. The goal is to check whether the list of words is a valid Letter Boxed solution.

Input

Input consists of (1) 4 groups of 3 letters and (2) a list of words. It can be in any suitable format.

Output

A truthy value if the list of words is a valid solution to the Letter Boxed challenge for those 4×3 letters, and a falsey value otherwise.

Test cases

Groups of letters=I,C,O, M,R,E, G,N,S, A,P,L.

Truthy values

• PILGRIMAGE, ENCLOSE


• CROPS, SAIL, LEAN, NOPE, ENIGMA

Falsey values

• PILGRIMAGE, ECONOMIES (can't have CO since they are on the same side)


• CROPS, SAIL, LEAN, NOPE (G and M have not been used)


• PILGRIMAGE, ENCLOSURE (U is not one of the 12 letters)


• ENCLOSE, PILGRIMAGE (last letter of 1st word is not first letter of 2nd word)


• SCAMS, SO, ORGANISE, ELOPE (all words must be at least 3 letters long).

Note that in this challenge, we do not care whether the words are valid (part of a dictionary).

Scoring:

This code-golf, lowest score in bytes wins!

05AB1E, 42 bytes

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

Try it 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

Try it online!

Jelly, 34 bytes

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

A dyadic Link accepting the words on the left and the letter groups on the right which yields 1 if valid and 0 if not.

Try it online! Or see the test-suite.

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

Try it online!

Not the best score. Some Haskell guru will probably be able to get this under 100 bytes.

Usage

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

Explanation

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

A different Haskell variation, exactly the same size as @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)

Try it 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^_

Try it online!