क्या आप इस शब्द को इन पासा से जोड़ सकते हैं?

Question

शब्द खेल में पत्र पासा आम है। उदाहरण के लिए, बोगल पासा के साथ मजाकिया शब्दों को बोलने की कोशिश करना मज़ेदार हो सकता है। यदि आप एक मुट्ठी भर पासा पकड़ते हैं, तो संभावना है कि आप कुछ शब्दों का जादू नहीं कर पाएंगे। यह चुनौती उस विचार का एक सामान्यीकरण है।

चुनौती

पासा की एक सूची को देखते हुए, जिनमें से प्रत्येक में कम से कम 1 चेहरा और एक शब्द है, आपका कार्य यह निर्धारित करना है कि क्या दिए गए पासा का उपयोग करके उस शब्द को वर्तनी देना संभव है (किस मामले में, यह एक सत्य परिणाम लौटना चाहिए)। प्रत्येक डाई से केवल एक अक्षर का उपयोग किया जा सकता है और एक डाई का उपयोग केवल एक बार किया जा सकता है। आपको दिए गए पासा के सभी का उपयोग करने की आवश्यकता नहीं है।

उदाहरण

एक तुच्छ उदाहरण में, पासा [[A], [C], [T]] और स्ट्रिंग CAT के साथ, परिणाम सत्य है। BAT, निश्चित रूप से, झूठे लौटेगा क्योंकि B पर उनके साथ कोई पासा नहीं है

यदि पासा के सेट के रूप में [[ए, ई, आई, ओ, यू], [ए, बी, सी, टी], [एन, पी, आर]] दिए गए हैं, तो आप ART, TON, और CUR के लिए सही साबित होंगे। , लेकिन कैट, ईएटी, और पैन के लिए गलत है क्योंकि उन तार को पुन: उपयोग करने की आवश्यकता होती है। यह भी स्पष्ट रूप से स्पष्ट होना चाहिए कि सीआरएबी को इन पासा के साथ नहीं जोड़ा जा सकता है क्योंकि पर्याप्त पासा नहीं है।

यदि पासा के सेट के रूप में [[ए, बी, सी], [ए, ई, आई], [ई, ओ, यू], [एल, एन, आर, एस, टी]] दिया जाता है, तो आप CAT, BEE, BEAN, TEA, BEET, और BAN, लेकिन आप LONE, CAB, BAIL, TAIL, BAA, या TON वर्तनी नहीं कर पाएंगे।

एक ही मौत के गुणक हो सकते हैं। यदि [[ए, बी, सी], [ए, बी, सी], [ए, बी, सी]] दिया जाता है, तो आप कैब, बीएए, एएए, आदि को वर्तनी में सक्षम कर सकते हैं ... लेकिन स्पष्ट रूप से ए के बिना कुछ भी नहीं है, इसमें बी, या सी।

नियम

• कोई शोषण मानक कमियां नहीं
• यह कोड-गोल्फ है , इसलिए सबसे छोटा कोड जीतता है।
• आप मान सकते हैं कि शब्द और पासा दोनों ही बड़े अक्षरों से बने होंगे।
• आप मान सकते हैं कि यह शब्द हमेशा कम से कम 1 अक्षर लंबा होगा और हमेशा कम से कम 1 मरना होगा।
• आप यह मान सकते हैं कि मरने के बाद कभी भी एक ही अक्षर से अधिक नहीं होगा।
• इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं।

Comments

नए टैग क्यों बना रहे हैं?

— user202729

क्या इनपुट के रूप में वर्णों की एक सूची (वेक्टर) (एक पासा के समान प्रारूप) ले सकते हैं? एक दोस्त के लिए पूछना जो 27 बाइट्स को बचाना चाहता है।

— JayCe

@JayCe "इनपुट और आउटपुट किसी भी सुविधाजनक प्रारूप में हो सकते हैं", इसलिए हाँ।

— बीफस्टर

Answer 1

ब्रेकीलॉग , 5 बाइट्स

∋ᵐ⊇pc

इसे ऑनलाइन आज़माएं!

हम शब्द के लिए पासा और आउटपुट चर के लिए इनपुट चर का उपयोग करते हैं। true.जब यह शब्द और false.अन्यथा वर्तनी संभव हो तो यह आउटपुट करता है ।

व्याख्या

∋ᵐ        Map element: Take one side from each die
  ⊇       Subset
   p      Permute
    c     Concatenate into a string: will only succeed if it results in the output word

Answer 2

हास्केल , 48 44 बाइट्स

import Data.List
(.mapM id).any.(null.).(\\)

यह एक अनाम फ़ंक्शन है। कुछ पहचानकर्ता के साथ fइसका उपयोग किया जा सकता है f "ART" ["AEIOU", "ABCT", "NPR"], जिसकी पैदावार होती है True। इसे ऑनलाइन आज़माएं!

गैर-बिंदु मुक्त समकक्ष है

f word dice = any(\s -> null $ word\\s) $ mapM id dice

mapM idसूचियों की सूची में सूची के Monadउदाहरण का उपयोग किया जाता है और इसे गैर-नियतात्मक विकल्प के रूप में देखा जा सकता है । इस प्रकार जैसे mapM id ["AB","123"]पैदावार ["A1","A2","A3","B1","B2","B3"]।

उन पासा संयोजनों में से प्रत्येक के लिए, हम जाँचते (\\)हैं कि दिए गए शब्द की सूची का अंतर और संयोजन एक खाली सूची देता है या नहीं।

Comments

@LuisMendo इंगित करने के लिए धन्यवाद! 4 बाइट की बचत को समाप्त करने वाली एक अन्य विधि पर स्विच करके फिक्स्ड।

— लकोनी

Answer 3

जावास्क्रिप्ट (ईएस 6), 68 बाइट्स

f=([c,...w],a)=>!c||a.some((d,i)=>d.match(c)&&f(w,a.filter(_=>i--)))

<div oninput=o.textContent=f(i.value,d.value.split`\n`)>
<textarea id=d rows=9>
ABC
AEI
EOU
LNRST
</textarea>
<br>
<input id=i value=BEAN>
<pre id=o>true

Comments

@RickHitchcock के लिए असफल EEE।

— नील

Answer 4

पायथन 2 , 82 बाइट्स

f=lambda d,w:w==''or any(w[0]in x>0<f(d[:i]+d[i+1:],w[1:])for i,x in enumerate(d))

इसे ऑनलाइन आज़माएं!

f=lambda d,w:w==''                                                                 # Base case: we can spell '' with any dice.
                  or any(                                 for i,x in enumerate(d)) # Otherwise, we check if there is some die x such that...
                         w[0]in x                                                  # the first letter is on this die,
                                 >0<                                               # and
                                    f(d[:i]+d[i+1:],w[1:])                         # we can spell the rest of the word with the rest of the dice.

तुलना श्रृंखला w[0]in x>0<f(...)के बराबर है: w[0]in x और x>0 और 0<f(...) ।

उन लोगों में से दूसरा हमेशा सच होता है ( str> int) और तीसरा उन लोगों के बराबर होता है f(...), ताकि पूरी बात लिखने का एक छोटा तरीका होw[0]in x and f(...)

Answer 5

जावास्क्रिप्ट (ईएस 6), 74 बाइट्स

करी वाक्यविन्यास में इनपुट लेता है (w)(a), जहाँ w वह शब्द है जिसकी हम तलाश कर रहे हैं और एक पासा का वर्णन करने वाले तार की एक सूची है। रिटर्न 0 या 1 ।

w=>P=(a,m='')=>w.match(m)==w|a.some((w,i)=>P(a.filter(_=>i--),m+`[${w}]`))

इसे ऑनलाइन आज़माएं!

टिप्पणी की गई

हम पासा के प्रत्येक उप-क्रमांकन को एक नियमित अभिव्यक्ति पैटर्न में बदल देते हैं और लक्ष्य शब्द के खिलाफ उनका परीक्षण करते हैं।

w =>                        // w = target word
  P =                       // P = recursive function taking:
    (a,                     //   a[] = list of dice
        m = '') =>          //   m   = search pattern
    w.match(m) == w |       // force a truthy result if w matches m
    a.some((w, i) =>        // for each word w at position i in a[]:
      P(                    //   do a recursive call:
        a.filter(_ => i--), //     using a copy of a[] without the current element
        m + `[${w}]`        //     and adding '[w]' to the search pattern
      )                     //   end of recursive call
    )                       // end of some()

Answer 6

भूसी , 5 बाइट्स

~V`¦Π

इसे ऑनलाइन आज़माएं!

एक शून्य-शून्य मान लौटाता है यदि शब्द को शून्य करना संभव है, अन्यथा नहीं।

व्याख्या

~V`¦Π  Arguments: word [Char], dice [[Char]]
 V     Checks if any element of a list (2) satisfies a predicate (1)
~      Composes both arguments of the above function
  `¦     (1) Is the word a subset of the element?
    Π    (2) Cartesian product of the dice list

Answer 7

पर्ल 5 -plF , 48 46 बाइट्स

@DomHastings ने 2 बाइट्स बचाए

$_=grep/@{[sort@F]}/,map"@{[sort/./g]}",glob<>

इसे ऑनलाइन आज़माएं!

इनपुट:

word               # The word to validate
{A,B,C}{D,E,F}     # Each die is surrounded by braces, commas between the letters

आउटपुट:

0ऐसे शब्द के लिए जो मान्य नहीं है। किसी शब्द के लिए कोई भी सकारात्मक पूर्णांक जो मान्य है

कैसे?

यह स्पष्टीकरण निष्पादन के क्रम में कोड को देखता है, इस एक-लाइनर के लिए प्रभावी रूप से दाएं-बाएं।

-F             # The first line of input is automatically split by the -F command option into the @F array.
glob<>         # Read the rest of the input and enumerate all of the permutations of it
map"@{[sort/./g]}",  # Split the permutation into separate letters, sort them and put them back together
/@{[sort@F]}/, # use the sorted letters of the target to match against
$_=grep        # check all of those permutations to see if the desired word is in them
-p             # Command line option to output the contents of $_ at the end

Answer 8

जावास्क्रिप्ट (Node.js) , 98 बाइट्स

f=(s,d,u=[])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(s,e=[...d],[...u,x],e.splice(i,1)))

इसे ऑनलाइन आज़माएं!

यह मानते हुए कि पर्याप्त पासा है

जावास्क्रिप्ट (Node.js) , 100 बाइट्स

f=(s,d,u=[''])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(s,e=[...d],[...u,x],e.splice(i,1)))

इसे ऑनलाइन आज़माएं!

जावास्क्रिप्ट (Node.js) , 99 बाइट्स

s=>f=(d,u=[''])=>d<1?s.every(t=>u.pop().match(t)):d.some((x,i)=>f(e=[...d],[...u,x],e.splice(i,1)))

इसे ऑनलाइन आज़माएं!

Answer 9

जेली ,  १०  9 बाइट्स

-1 एरिक द आउटगोलर ( wइसके बजाय उपयोग) के लिए धन्यवादẇ@ >। <)

Œ!Œp€Ẏw€Ṁ

बाईं ओर (पासा) वर्णों की सूची और दाईं ओर वर्णों की सूची (शब्द) को स्वीकार करने वाला एक डायडिक लिंक, जो यदि संभव हो तो 1 और यदि नहीं तो 0 लौटाता है।

इसे ऑनलाइन आज़माएं! या देखें परीक्षण-सूट देखें ।

कैसे?

Œ!Œp€Ẏw€Ẹ - Link: list of lists of characters Dice, list of characters Word
Œ!        - all permutations of the dice (i.e. all ways to order the dice)
  Œp€     - Cartesian product of €ach (i.e. all ways to roll each ordering)
     Ẏ    - tighten (i.e. all ordered ways to roll the dice)
       €  - for each:
      w   -   first index (of sublist W) in the result (positive if there, 0 otherwise)
        Ẹ - any truthy? (1 if it is possible to roll the word, 0 otherwise)

---

तेज़ एल्गोरिथम (9 बाइट्स भी):

एक ही इनपुट प्रारूप के साथ एक डायडिक लिंक जो संभव होने पर सकारात्मक पूर्णांक (सत्य) देता है और 0 (फाल्सी) अन्यथा।

Œpf€Ṣ€ċṢ} - Link: list of lists of characters Dice, list of characters Word
Œp        - Cartesian product of the dice (all rolls of the dice)
  f€      - filter keep for €ach (keep the rolled letters if they are in the word)
    Ṣ€    - sort €ach result
       Ṣ} - sort Word
      ċ   - count occurrences

Answer 10

आर , 192 185 135 117 111 109 बाइट्स

function(x,...)s(x)%in%apply(expand.grid(lapply(list(...),c,"")),1,s)
s=function(x)paste(sort(x),collapse="")

इसे ऑनलाइन आज़माएं!

-2 चार Giuseppe के लिए धन्यवाद।

Comments

यदि कोई शब्द आपके पास पासा से कम है तो यह विफल हो जाएगा।

— ग्यूसेप

मुझे लगता है कि आप इसे 21 बाइट्स की कीमत पर बचा सकते हैं, इसे यहां आज़माएं

— Giuseppe

@Giuseppe आपने दिन बचा लिया!

— JayCe

आपको जरूरत नहीं हैF=

— Giuseppe

Answer 11

पायथ , 21 बाइट्स

.Em}eQdsm.ps.nd.U*bZh

परीक्षण सूट

स्पष्टीकरण:

.Em}eQdsm.ps.nd.U*bZhQ # Code with implicit variables
.E                     # Print whether any of
       sm.ps  d        # all positive length permutations of each element in
        m   .nd.U*bZhQ # the Cartesian product of the list of dice
  m}eQd                # contain the target word