आप किस का इंतजार कर रहे हैं? (एक माहजोंग सॉल्वर)

Question

चैट में चर्चा से @ मार्टिनबटनर को धन्यवाद

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

- PPCG महजोंग में, वहाँ तीन सूट कर रहे हैं m, pऔर s- और टाइल्स से गिने जा रहे हैं 1करने के लिए 9। वहाँ वास्तव में प्रत्येक टाइल के चार प्रतियां हैं, और टाइल्स इसकी संख्या अपने सूट के बाद (जैसे से चिह्नित हैं 3m, 9s)।

एक पूरा पीपीसीजी माहजोंग हाथ में कुल 14 टाइलों के लिए तीन और एक जोड़ी के चार सेट होते हैं।

तीन का एक सेट या तो हो सकता है:

• एक ही टाइल के तीन (जैसे 4s 4s 4s, लेकिन नहीं 4m 4p 4s), या
• एक ही सूट में तीन लगातार टाइल्स का एक क्रम (जैसे 1s 2s 3sया 6p 7p 8pलेकिन नहीं 3s 4m 5mया नहीं 3p 5p 7p)। अनुक्रम लपेटता नहीं है (इसलिए 9m 1m 2mअमान्य है)।

एक जोड़ी बस दो समान टाइल (जैसे 5s 5s) है।

चुनौती

आपके कार्यक्रम को 13 टाइलों का एक अलग-अलग हाथ प्राप्त होगा, जिसमें प्रत्येक टाइल चार बार से अधिक नहीं दिखाई देगी। आप एक पूर्ण कार्यक्रम या एक फ़ंक्शन लिख सकते हैं जो एक स्ट्रिंग में लेता है।

अपने काम के लिए सभी संभव 14 वीं टाइल ("इंतजार") है, जो जब हाथ में जोड़ा जाता है, एक पूरा पीपीसीजी माहजोंग हाथ बनाने के लिए है। आउटपुट की गई टाइलें अंतरिक्ष-अलग होनी चाहिए, लेकिन किसी भी क्रम में हो सकती हैं। व्हाट्सएप को लीड या ट्रेल करने की अनुमति है।

आपका कार्यक्रम उचित समय पर चलना चाहिए, एक मिनट से अधिक नहीं।

उदाहरण

Input: 1m 1m 1m 4s 4s 4s 7p 7p 7p 3m 3m 3m 9s
Output: 9s

Input: 1m 1m 1m 3m 3m 3m 5m 5m 5m 2s 3s 7p 8p
Output:

Input: 1m 2m 2m 3m 3m 3m 3m 4m 1s 1s 9s 9s 9s
Output: 1s

Input: 1m 1m 1m 2m 3m 4m 5m 6m 7m 8m 9m 9m 9m
Output: 1m 2m 3m 4m 5m 6m 7m 8m 9m

Input: 1m 1m 1m 5p 2m 3m 5p 7s 8s 5p 9s 9s 9s
Output: 1m 4m 6s 9s 

पहले उदाहरण में, 1m 4s 7p 3mसभी फार्म मौजूदा ट्रिपल हैं, जो 9sएक जोड़ी बनाने के लिए अकेला छोड़ते हैं ।

दूसरे उदाहरण में, 2s 3sऔर 7p 8pकेवल अनुक्रम बना सकते हैं, और शेष टाइलें केवल ट्रिपल बना सकती हैं। इसलिए कोई जोड़ी नहीं बनाई जा सकती है, और कोई आउटपुट नहीं है।

तीसरे उदाहरण में, हाथ में विभाजन होता है 1m2m3m 2m3m4m 3m3m 1s1s 9s9s9s। आम तौर पर यह एक प्रतीक्षा होगी 3m 1s, लेकिन जैसा कि सभी चार 3mका उपयोग किया गया है, केवल उपलब्ध प्रतीक्षा है 1s।

चौथे उदाहरण में, सभी mटाइलें हाथ से पूरी होती हैं। उदाहरण के लिए, उदाहरण के लिए, एक पूरा हाथ 1mहो सकता है 1m1m1m 1m2m3m 4m5m6m 7m8m9m 9m9m।

चौथे उदाहरण के बाकी हिस्सों और पांचवें उदाहरण के बाहर काम करने की कोशिश करें :)

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे कम बाइट्स में समाधान जीतता है। मानक खामियां लागू होती हैं।

Comments

वास्तव में (आइएमओ कष्टप्रद) टाइलों का उपयोग करके त्यागी के बजाय, जो कि वे "माहेर" शब्द सुनते हैं, पश्चिमी लोगों को लगता है कि ऐसा करने के लिए महामहिम को धन्यवाद देने के लिए धन्यवाद।

— जस्टिन

@Quincunx मजेदार तथ्य: यह चुनौती इस बारे में आई क्योंकि मैं ASCII के महजोंग सोलिटेयर के प्रतिनिधित्व के साथ एक चुनौती करना चाहता था (जो मैं अभी भी किसी बिंदु पर कर सकता हूं ...)। हालांकि मैंने इसे "महजोंग सोलिटेयर" कहा था। ;)

— मार्टिन एंडर

@Quincunx: मुझे नहीं लगता कि यह उनकी गलती है। यह गेम डेवलपर्स की गलती है कि वे अपने "महजोंग सॉलिटेयर" गेम "माहजोंग" को बुलाएंगे और कुछ नहीं।

— जो Z.

सात जोड़े के बारे में क्या? तेरह अनाथ? आप आपको लगता है कि यह अगर मैं एक codegolf कि गणना करने के लिए पूछता है बनाने के बाहर के उद्देश्य है सम्मान के साथ कुछ और भी जटिल कर सकता है :) क्या shanten (होने से पहले की जरूरत टाइल्स की न्यूनतम संख्या tenpai एक हाथ की - जीतने के लिए तैयार)?

— वी। कोर्टोइस

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

— Sp3000

Answer 1

अजगर, 312 281 बाइट्स

def W(S):H=lambda C,n=0,t=1:sum([m<C[0]and H([c-s for c in C][:l]+C[l:],n+1,u)for m,s,l,u in(2,3,1,t),(t,2,1,4),(4-5*all(C[:3]),1,3,t)])|H(C[1:],n,t)if C[2:]and max(C)<5else n>4;T=[i+s for s in"mps"for i in"12345678900"];return" ".join(t for t in T if("1"<t)*H(map((S+t).count,T)))

W इनपुट के रूप में एक स्ट्रिंग लेता है और आउटपुट के रूप में एक स्ट्रिंग लौटाता है।

टाइल्स की छोटी संख्या (27) यह परीक्षण करने के लिए पर्याप्त तेजी से बनाती है यदि उनमें से प्रत्येक हाथ पूरा करता है। समस्या यह जांचने के लिए बन जाती है कि क्या कोई हाथ वैध है। फ़ंक्शन एक सरल बैकट्रैकिंग एल्गोरिथ्म का उपयोग करता है जो सेट और जांच के सभी संभावित विकल्पों पर विचार करता है यदि उनमें से कोई भी पूर्ण हाथ जोड़ता है।

हाथों को टाइल हिस्टोग्राम के रूप में दर्शाया जाता है, यानी टाइल की गिनती की सूची (सभी टाइलों के लिए, न केवल हाथ में वाले।) यह दोनों चेक को आसान बनाता है अगर हमारे पास एक निश्चित टाइल की एक निश्चित संख्या है, और यदि हम। आसन्न टाइलों का एक क्रम है (विभिन्न सूटों की टाइलों के बीच पैडिंग मल्टी-सूट दृश्यों को रोकती है।)

Comments

आह, आपने मुझे हराया: पी वैसे भी, ऐसा लगता है कि आप mapकुछ स्थानों में उपयोग कर सकते हैं, जैसे:H(map((S+t).count,T))

— FryAmTheEggman

@FryAmTheEggman को याद किया। धन्यवाद!

— एल

@ Sp3000 यह पायथन 2. अजीब है; यह मेरे लिए 2.7.8 पर ठीक काम करता है।

— एल

@Ell 2.7.8 में काम करता है - 2.7.5 को 5else पसंद नहीं आया: P

— Sp3000

Answer 2

जावास्क्रिप्ट (E6) 306

F=h=>(
  R=(a,p,n=1)=>(a=[...a]).splice(p,n)&&a,
  K=(t,d=3)=>
    !t[0]
    |t.some(
      (v,p)=>
        v==t[p+1]&v==t[p+d-1]&&
        K(R(t,p,d))
      ||
        ~((r=t.indexOf((x=-~v[0])+v[1]))|(s=t.indexOf(-~x+v[1])))&&
        K(R(R(R(t,s),r),p))
    ),
  o=[],
  [for(s of'mps')for(i of'123456789')h.replace(t=i+s,s,'g')[34]
  &&K([t,...h.split(' ')].sort(),2)&&o.push(t)
  ],o
)

व्याख्या की

F=hand=>(
  Remove=(a,p,n=1)=>                // function to remove 1 or more element from an array, returning a new shorter array
    ((a=[...a]).splice(p,n), a),    // using array.splice on a new created array 

  Check=(ckHand, dim)=>  // recursive function to check hand. 
                         // removing pairs (at iteration 0) or sequence of three, if at last the hand remain empty then success
                         // parameter dim is 2 or 3 indicating how many equal elements are to be removed
    !ckHand[0]           // check if empty (element 0 does not exist)
    |ckHand.some(        // else traverse all array checking what can be removed
      (value, position)=> 
        value == ckHand[position + 1] 
        & value == ckHand[position + dim-1] &&   // look for 3 (or 2) equal elements
        Check(Remove(ckHand, position, dim), 3)   // if found, then remove elements and check again
      ||
        ~((r = ckHand.indexOf((x=-~value[0]) + value[1]))     // value[0] is number, value[1] is suit 
        |(s = ckHand.indexOf(-~x + value[1]))) &&              // look for an ascending sequence in following elements (the array is sorted)
        Check(Remove(Remove(Remove(ckHand, s), r), position),3) // if sequence found, remove elements and check again
    ),
  output=[], // start with an empty solution list
  [ // using array comprehension to implement a double loop
    for(s of'mps')        // loop for all suits
    for(i of'123456789')  // loop for all numbers
    (
       tile=i+s, // current tile 
       (hand.replace(tile,' ','g').length > 34)      // if tile is present 4 times in hand, the replaced length is 38-4 == 34
       && (                                       // else proceed with check
         ckHand = hand.split(' '), 
         ckHand.push(tile),    // in ckHand (as an array) the hand to be checked, that is base hand + current tile
         ckHand.sort(),        // sorting the array simplfy the checks
         Check(ckHand, 2)      // start checks looking for a pair
       )
       && 
         output.push(tile)   // if check ok, add tile to the solution list
    )   
  ],
  output // last expression in list is the function return value 
)

FireFox / FireBug कंसोल में टेस्ट करें

;["1m 1m 1m 4s 4s 4s 7p 7p 7p 3m 3m 3m 9s", "1m 1m 1m 3m 3m 3m 5m 5m 5m 2s 3s 7p 8p",
 "1m 2m 2m 3m 3m 3m 3m 4m 1s 1s 9s 9s 9s", "1m 1m 1m 2m 3m 4m 5m 6m 7m 8m 9m 9m 9m",
 "1m 1m 1m 5p 2m 3m 5p 7s 8s 5p 9s 9s 9s"].forEach(s=>console.log(s+' => '+F(s)))

उत्पादन

1m 1m 1m 4s 4s 4s 7p 7p 7p 3m 3m 3m 9s => 9s
1m 1m 1m 3m 3m 3m 5m 5m 5m 2s 3s 7p 8p =>
1m 2m 2m 3m 3m 3m 3m 4m 1s 1s 9s 9s 9s => 1s
1m 1m 1m 2m 3m 4m 5m 6m 7m 8m 9m 9m 9m => 1m,2m,3m,4m,5m,6m,7m,8m,9m
1m 1m 1m 5p 2m 3m 5p 7s 8s 5p 9s 9s 9s => 1m,4m,6s,9s