New York Times, Letter Boxed adında bir günlük çevrimiçi oyuna sahiptir (bağlantı bir ödeme duvarının arkasındadır; oyun burada da açıklanmaktadır ), aşağıdaki gibi bir meydanda sunulmaktadır:

Size 3 harflik 4 grup verilir (her gruba resmin bir tarafına karşılık gelir); iki kere mektup görünmez. Oyunun amacı, şu 12 harften (ve yalnızca bu harflerden) oluşan kelimeleri bulmaktır:

• Her kelime en az 3 harf uzunluğundadır;
• Ardışık harfler aynı taraftan olamaz;
• Bir kelimenin son harfi bir sonraki kelimenin ilk harfi olur;
• Tüm harfler en az bir kez kullanılır (harfler tekrar kullanılabilir).

Bu mücadelede, size mektuplar ve kelimelerin bir listesi verilir. Amaç, kelime listesinin geçerli bir Letter Boxed çözümü olup olmadığını kontrol etmektir.

Giriş

Giriş (1) 4 grup 3 harften ve (2) kelime listesinden oluşur. Herhangi bir uygun formatta olabilir.

Çıktı

Sözcük listesi, bu 4 x 3 harf için Letter Boxed mücadelesine geçerli bir çözüm ve aksi takdirde bir falsey değeri ise, gerçek olmayan bir değer.

Test durumları

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

Truthy değerleri

• YOLCULUK, KAPSAM
• BİTKİLER, YELKEN, YAĞ, NOPE, ENIGMA

Falsey değerleri

• PILGRIMAGE, ECONOMIES (aynı tarafta oldukları için CO sahibi olamaz)
• CROPS, SAIL, LEAN, NOPE (G ve M kullanılmamış)
• PILGRIMAGE, ENCLOSURE (U, 12 harften biri değildir)
• ENCLOSE, PILGRIMAGE (1. kelimenin son harfi, 2. kelimenin ilk harfi değildir)
• ALDATMACA, SO, ORGANİZE, ELOPE (tüm kelimeler en az 3 harf uzunluğunda olmalıdır).

Bu zorlukta, kelimelerin geçerli olup olmadığına dikkat etmeyiz (sözlüğün bir parçası).

puanlama:

Bu kod-golf , bayt cinsinden en düşük puanı kazanır!

JavaScript (ES6),  130  126 bayt

Girişi olarak alır (letters)(words). $0$ veya $1$ döndürür .

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

Çevrimiçi deneyin!

Aşama 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()

Adım 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()

Jöle , 30 29 bayt

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

Çevrimiçi deneyin!

Kelimelerin listesini sol argüman olarak ve kutudaki düzleştirilmiş harflerin listesini doğru argüman olarak alan bir ikili bağlantı. 1Doğru ve 0yanlış için döner .

açıklama

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 bayt

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

-2 baytında 05AB1E cevabında kullanılan @Emignaê yaklaşımından ilham alarak . @Grimy sayesinde -3 bayt .

İlk giriş olarak kelimelerin karakter listesini ve ikinci giriş olarak on iki harften oluşan düz listeyi alır.

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

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

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

Çevrimiçi deneyin!

Python 2,171 bayt

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

Çevrimiçi deneyin!

Jöle , 34 bayt

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

Soldaki kelimeleri ve sağdaki harf gruplarını 1kabul eden ve 0eğer geçerliyse vermeyen bir dyadic Link .

Çevrimiçi deneyin! Veya test odasına bakın .

Haskell , 231 bayt

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

Çevrimiçi deneyin!

En iyi skor değil. Bazı Haskell gurusu muhtemelen bunu 100 baytın altında alabilecek.

kullanım

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

açıklama

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 bayt

Farklı bir Haskell varyasyonu, @Paul Mutser's :) ile aynı boyutta

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)

Çevrimiçi deneyin!

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 bayt

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

Çevrimiçi deneyin!

Java (JDK) , 188 bayt

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

Çevrimiçi deneyin!

açıklamalar

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

Kredi

• Ceilingcat sayesinde -2 bayt

Kömür , 63 bayt

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

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı bir versiyonudur. Açıklama:

⌊⁺⁺⁺

Aşağıdaki ifadeleri birleştirin ve 0bunlardan biri varsa0 aksi1 .

⭆η›Ｌι²

Çözümdeki her sözcük için uzunluğu en az 3 olsun.

⭆⪫ηω№⪫θωι

Çözümdeki her harf için bulmacanın içinde görünüp görünmediğine bakın.

⭆⪫θω№⪫ηωι

Yapbozdaki her harf için, çözümde görünüp görünmediği.

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

Çözümdeki her harf için, bir kelimenin ilk harfi olmadığı sürece önceki harfin aynı grupta olmadığını kontrol edin; bu durumda, bir önceki kelimenin son harfi ile aynı olmadığını kontrol edin. Çözüm mektubu, bu durumda sadece görmezden gelin.

Python 2 , 168 156 bayt

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)

Çevrimiçi deneyin!

İade 1truthy için, 0Falsey için.