Thời báo New York có một trò chơi trực tuyến hàng ngày có tên Letter Boxed (liên kết nằm phía sau một tường thành; trò chơi cũng được mô tả ở đây ), được trình bày trên một hình vuông như sau:

Bạn được cung cấp 4 nhóm 3 chữ cái (mỗi nhóm tương ứng với một bên trên hình); không có thư xuất hiện hai lần. Mục đích của trò chơi là tìm những từ được tạo thành từ 12 chữ cái đó (và chỉ những chữ cái đó) sao cho:

• Mỗi từ dài ít nhất 3 chữ cái;
• Các chữ cái liên tiếp không thể từ cùng một phía;
• Chữ cái cuối cùng của một từ trở thành chữ cái đầu tiên của từ tiếp theo;
• Tất cả các chữ cái được sử dụng ít nhất một lần (các chữ cái có thể được sử dụng lại).

Trong thử thách này, bạn được cung cấp các chữ cái và danh sách các từ. Mục tiêu là để kiểm tra xem danh sách các từ có phải là giải pháp Hộp thư hợp lệ hay không.

Đầu vào

Đầu vào bao gồm (1) 4 nhóm gồm 3 chữ cái và (2) một danh sách các từ. Nó có thể ở bất kỳ định dạng phù hợp.

Đầu ra

Giá trị trung thực nếu danh sách các từ là một giải pháp hợp lệ cho thử thách Đóng hộp thư cho các chữ cái 4 × 3 đó và giá trị falsey khác.

Các trường hợp thử nghiệm

Nhóm chữ cái ={{I,C,O}, {M,R,E}, {G,N,S}, {A,P,L}} .

Giá trị thật

• PILGRIMAGE, KẾT LUẬN
• CROPS, SAIL, LEAN, NOPE, ENIGMA

Giá trị Falsey

• PILGRIMAGE, KINH TẾ (không thể có CO vì chúng ở cùng một phía)
• CROPS, SAIL, LEAN, NOPE (G và M chưa được sử dụng)
• PILGRIMAGE, ENCLOSURE (U không phải là một trong 12 chữ cái)
• KẾT LUẬN, PILGRIMAGE (chữ cái cuối của từ 1 không phải là chữ cái đầu tiên của từ thứ 2)
• LỪA ĐẢO, SO, ORGANIZE, ELOPE (tất cả các từ phải dài ít nhất 3 chữ cái).

Lưu ý rằng trong thử thách này, chúng tôi không quan tâm liệu các từ có hợp lệ hay không (một phần của từ điển).

Ghi điểm:

Đây mã golf , điểm số thấp nhất trong byte thắng!

JavaScript (ES6),  130  126 byte

Đưa đầu vào là (letters)(words). Trả về $0$ hoặc $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)))

Hãy thử trực tuyến!

Bước 1

Đầu tiên chúng ta lặp lại $L$ để xây dựng một chuỗi phân tách bằng ống$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()

Bước 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()

Thạch , 30 29 byte

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

Hãy thử trực tuyến!

Một liên kết dyadic lấy danh sách các từ làm đối số bên trái và danh sách các chữ cái được làm phẳng trong hộp làm đối số bên phải. Nó trở lại1 đúng và0 sai.

Giải trình

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 byte

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

-2 byte bằng cách lấy cảm hứng từ êcách tiếp cận @Emigna được sử dụng trong câu trả lời 05AB1E của mình .
-3 byte nhờ @Grimy .

Lấy danh sách danh sách các ký tự cho các từ làm đầu vào đầu tiên và danh sách được làm phẳng gồm mười hai chữ cái làm đầu vào thứ hai.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

ε         # 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 byte

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

Hãy thử trực tuyến!

Con trăn 2 , 171 byte

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

Hãy thử trực tuyến!

Thạch , 34 byte

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

Một liên kết dyadic chấp nhận các từ bên trái và các nhóm chữ bên phải sẽ sinh ra 1nếu hợp lệ và 0nếu không.

Hãy thử trực tuyến! Hoặc xem bộ thử nghiệm .

Haskell , 231 byte

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

Hãy thử trực tuyến!

Không phải là điểm số tốt nhất. Một số guru Haskell có thể sẽ có thể có được điều này dưới 100 byte.

Sử dụng

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

Giải trình

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 byte

Một biến thể Haskell khác nhau, có cùng kích thước với @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)

Hãy thử trực tuyến!

Bị đánh cắp

-- 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 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Giải thích

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

Tín dụng

• -2 byte nhờ trần

Than , 63 byte

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

Hãy thử trực tuyến! Liên kết là phiên bản dài dòng của mã. Giải trình:

⌊⁺⁺⁺

Nối các biểu thức và đầu ra dưới đây 0nếu bất kỳ trong số chúng bao gồm một 0cách khác 1.

⭆η›Ｌι²

Đối với mỗi từ trong đầu ra giải pháp cho dù độ dài của nó ít nhất là 3.

⭆⪫ηω№⪫θωι

Đối với mỗi chữ cái trong đầu ra giải pháp cho dù nó xuất hiện trong câu đố.

⭆⪫θω№⪫ηωι

Đối với mỗi chữ cái trong đầu ra câu đố cho dù nó xuất hiện trong giải pháp.

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

Đối với mỗi chữ cái trong giải pháp kiểm tra rằng chữ cái trước đó không nằm trong cùng một nhóm, trừ khi đó là chữ cái đầu tiên của một từ, trong trường hợp đó kiểm tra xem nó có bằng chữ cái cuối cùng của từ trước hay không, trừ khi đó là chữ cái đầu tiên thư của giải pháp, trong trường hợp chỉ cần bỏ qua nó.

Python 2 , 168 156 byte

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)

Hãy thử trực tuyến!

Trả lại 1cho sự thật, 0cho falsey.