प्रगति में ASCII जल्लाद


21

( कोड समीक्षा पर एक सवाल से प्रेरित )

माना कि दो लोग जल्लाद का किरदार निभा रहे हैं , लेकिन आपने केवल खेल को सुना है और वर्तमान स्थिति को आकर्षित करना चाहते हैं।

इनपुट के रूप में दो शब्दों को देखते हुए, जहां शब्द प्रत्येक मैच [A-Z]+या [a-z]+(आपकी पसंद) हैं, नीचे दिए गए नियमों का पालन करते हुए, एएससीआईआई कला के रूप में जल्लाद खेल की वर्तमान स्थिति का उत्पादन करते हैं।

  • पहला शब्द अनुमान लगाया जाने वाला शब्द है, और दूसरा शब्द पहले से अनुमानित अक्षर है। इन्हें किसी भी क्रम में इनपुट के रूप में लिया जा सकता है।
  • शब्द का अनुमान लगाया जाना गैर-रिक्त है, लेकिन पहले से ही अनुमानित अक्षर खाली हो सकते हैं (जैसे कि यह खेल की शुरुआत है)।
  • खेल हमेशा एक वैध जल्लाद खेल होगा (यानी, अनुमान लगाए गए पत्रों को डुप्लिकेट नहीं किया जाएगा, खेल के अंत में अक्षरों का अनुमान नहीं लगाया जाएगा, आप केवल इनपुट, आदि के रूप में पत्र प्राप्त करेंगे)।
  • जल्लाद ड्राइंग के नीचे _अक्षरों के स्थान पर अभी तक अज्ञात, रिक्त स्थान द्वारा अलग किए गए शब्द होने चाहिए । उदाहरण के लिए, यदि शब्द का अनुमान लगाया जाना था BOAT, तो नीचे जल्लाद ड्राइंग होना चाहिए _ _ _ _। यदि शब्द अनुमान के BOATसाथ था A, तो ड्राइंग के नीचे होना चाहिए _ _ A _
  • अनुमान लगाए जाने वाले शब्द के नीचे अक्षरों का पहले से ही अनुमान होना चाहिए कि शब्द में नहीं हैं । ये किसी भी क्रम में हो सकते हैं, और यदि चाहें तो किसी भी गैर-वर्णानुक्रमिक विभाजक द्वारा अलग किए जा सकते हैं।

यहाँ जल्लाद खेल की अवस्थाएँ हैं, आरंभिक खेल से लेकर अंत तक। प्रत्येक गलत तरीके से अनुमानित पत्र राज्य को एक करके आगे बढ़ाता है। तो पहला गलत अनुमानित पत्र सिर को Oप्रकट करता है, अगला शरीर को |प्रकट करता है, आदि।

  +---+
  |   |
      |
      |
      |
      |
=========

  +---+
  |   |
  O   |
      |
      |
      |
=========

  +---+
  |   |
  O   |
  |   |
      |
      |
=========

  +---+
  |   |
  O   |
 /|   |
      |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
      |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========

  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========

इनपुट

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

उत्पादन

जैसा कि ऊपर वर्णित है, ए.एस.आई.आई.आई. कला की प्रगति में जल्लाद खेल का प्रतिनिधित्व, फिर से किसी भी सुविधाजनक प्रारूप में।

नियम

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

उदाहरण

# 1

BOAT तथा ATG

  +---+
  |   |
  O   |
      |
      |
      |
=========
_ _ A T
G

# 2

ZEPPELIN तथा

  +---+
  |   |
      |
      |
      |
      |
=========
_ _ _ _ _ _ _ _

# 3

ZEPPELIN तथा EATOLINSHR

  +---+
  |   |
  O   |
 /|\  |
 / \  |
      |
=========
_ E _ _ E L I N
A T O S H R

# 4

RHYTHM तथा ABCDE

  +---+
  |   |
  O   |
 /|\  |
 /    |
      |
=========
_ _ _ _ _ _
EDCBA

# 5

BOAT तथा ATOB

  +---+
  |   |
      |
      |
      |
      |
=========
B O A T

# 6

AIRPLANE तथा AJKEI

  +---+
  |   |
  O   |
  |   |
      |
      |
=========
A I _ _ _ A _ E
KJ

गलत अक्षर इनपुट क्रम को बनाए रखना चाहिए?
रॉड

@ नहीं, गलत अनुमानों के क्रम को संरक्षित करने की आवश्यकता नहीं है।
AdmBorkBork

2
कृपया एक परीक्षण का मामला जोड़ें जहां सभी अक्षर सही अनुमान लगाते हैं और एक जहां सभी का अनुमान लगाया गया है
श्री एक्सकोडर

@ Mr.Xcoder मैंने परीक्षण केस # 5 जोड़ा है जहां व्यक्ति ने तुरंत "BOAT" का अनुमान लगाया है।
AdmBorkBork

मैंने एक परीक्षण मामला जोड़ा है जिसमें केवल 2 गलत पत्र हैं जो सही बिल्डिंग ऑर्डर और बिल्डिंग टॉप-टू-बॉटम / लेफ्ट-टू-राइट के बीच अंतर कर सकते हैं।
जस्टिन मेरिनर

जवाबों:


10

पायथन 2 , 215 192 184 183 बाइट्स

-8 बाइट्स धन्यवाद राफेल कोटे
-1 बाइट के लिए धन्यवाद जोनाथन फ्रीच को

a,b=input()
j=' '.join
s=b-set(a)
print"""  +---+
  |   |
  %s   |
 %s%s%s  |
 %s %s  |
      |
=========
"""%tuple('O/|\/\\'[:len(s)].ljust(6)),j(['_',i][i in b]for i in a),'\n',j(s)

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


सभी \ n को नई कथनों में परिवर्तित करके और "" "के साथ" "किसी भी सुविधाजनक प्रारूप" का उपयोग करके और सेट कॉल को इनपुट में सेट करके, मैं 172 बाइट्स तक छोड़ने में सक्षम था।
राफेल कोटे।

हम्म, क्या आप परिवर्तनों को लिंक कर सकते हैं? मैं केवल
रॉड

184 अच्छा है: कोड से सेट को हटाने से वास्तव में आउटपुट टूट गया, जिससे काम नहीं हुआ। \ N बदलते हुए इसलिए वे नई सुर्खियाँ
Raphaël Côté

1
मेरा मानना ​​है कि आपको |बाएं हाथ के बजाय शरीर का टुकड़ा ( ) दिखाना चाहिए /जब 2 गलत पत्र होते हैं: इसे ऑनलाइन आज़माएं
जस्टिन मैरिनर

"\\/"के बराबर है "\/"
जोनाथन फ्रेच

8

चारकोल , 83 69 68 बाइट्स

Fη¿№θι⁰«ι→⊞υι»←⸿Fθ«⎇№ηιι_→»←⸿×=⁸↖=←↑⁵←+←³↓+|FLυ≡ι⁰↓O¹←|²/|³\⁴⸿ /⁵ \«

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। संपादित करें: 14 बाइट्स पर स्विच करके सहेजा गया switch। एकल |को शाब्दिक रूप से मुद्रित करके 1 बाइट को बचाया । नोट: समय सवाल है, स्थापित किया गया था switchशब्दाडंबरपूर्ण मोड में सब पर काम नहीं किया था और उनके पीछे की जरूरत «संक्षिप्त मोड (तो यह 67 बाइट्स के रूप में संक्षिप्त अनुवाद चलता TIO पर वर्तमान संस्करण है, न तो बग है) में है, जबकि Map's बग ने मुझे उपयोग करने से रोका Print(Join(Map(q, Ternary(Count(h, i), i, "_")), " "));। सौभाग्य से मैं एक ही लंबाई के लिए एक कीचड़ के साथ आने में कामयाब रहा (और वास्तव में मैंने दूसरे लूप को मैप पर स्विच करने की भी कोशिश की, लेकिन यह भी उसी लंबाई में निकला)। स्पष्टीकरण:

Fη              For each letter in the guess,
  ¿№θι⁰«        if the word to be guessed does not contain the letter,
        ι→      print the failed guess, leave a gap,
          ⊞υι»  and push the letter to the array.

←⸿              Move to the start of the previous line.

Fθ«             For each letter in the word to be guessed,
   ⎇№ηιι        if the letter has been guessed then print it
        _       otherwise print a _.
         →»     Either way, leave a gap.

←⸿              Move to the start of the previous line.

×=⁸             Print 8 =s
   ↖=←          Print a 9th =, moving into position to
      ↑⁵        print 5 |s upwards,
        ←+←³    a + and 3 -s left,
            ↓+| and a + and a | down.

FLυ             Loop once for each incorrect guess.
   ≡ι           Choose what to print based on the loop index.
     ⁰↓O        For the first incorrect guess, print an O.
     ¹←|        For the second incorrect guess, print a |.
     ²/         For the third incorrect guess, print a /.
     ³|\        For the fourth incorrect guess, print a \.
     ⁴⸿ /       For the fifth incorrect guess, print a / on the next line.
     ⁵ \        For the sixth incorrect guess, print another \.

2
यह भाषा ... यह मुझे डराती है।
सर्गेई ग्रिनेव जूल

@SergeyGrinev D: यह इतना डरावना क्यों है
केवल

@ ASCII- केवल मैंने आपको निश्चित मानचित्र (स्ट्रिंग, अभिव्यक्ति) पर ध्यान दिया था, लेकिन मानचित्र (सरणी, अभिव्यक्ति) अभी भी छोटी है - यह एक कमांड के बजाय एक अभिव्यक्ति के रूप में उपयोग किए जाने पर मूल सरणी को बदल देता है। इसे ऑनलाइन आज़माएं!
नील

@ ASCII- ही हे, यह एक भाषा के लिए एक महान विचार है, लेकिन स्क्रिप्ट कुछ ऐसा लगता है जैसे लवक्राफ्ट Cthulhu जादू को बुलाने के लिए उपयोग करेगा।
सर्गेई ग्रिनेव

@Neil का अभिप्राय व्यवहार से है, इसलिए ज्यादातर यह सेल के डेटाटाइप को मैप करते समय कैनवास को संशोधित करता है, लेकिन मुझे लगता है कि हाँ आपको अक्सर मानचित्र के बाद मूल डेटा का उपयोग करने की आवश्यकता होगी, यह कल तक तय किया जाना चाहिए
ASCII-only

7

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

x,y=input()
x=[['_',k][k in y]for k in x]
y-=set(x)
s='''  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
'''
for i in range(6):s=s.replace(`i`,[' ','O|/\\/\\'[i]][len(y)>i])
print s+'='*9+'\n'+' '.join(x)+'\n'+''.join(y)

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

-35 बाइट्स के लिए धन्यवाद रैफेल कोटे
-20 बाइट्स का उपयोग करके सेट
-1 बाइट माइकस्टेपिक के लिए धन्यवाद


3
संख्याओं के साथ "बदलें" के लिए अच्छा विचार :)
वी। कोर्टोइस

@ V.Courtois धन्यवाद :) मैं उपयोग करने जा रहा था, translateलेकिन यह अधिक लंबा निकला।
HyperNeutrino

हाय @ हैपरनेट्रिनो, सबमिशन के साथ अच्छी नौकरी! मुझे लगता है कि अंत में 2 छोरों को एक में रखा जा सकता है, इस का उपयोग करके for i in range(7):s=s.replace(`i`,'O|/\\/\\'[i] if i<c else ' ')। यह आपको एक लूप देता है और यदि आप सी पर हैं तो आप केवल प्रतिस्थापन को बंद कर देते हैं। आप इस तरह से 251 बाइट्स कम कर सकते हैं :)
राफेल कोल्ट

@ RaphaëlCôté अच्छा गोल्फ। धन्यवाद!
हाइपरएन्यूट्रीनो

c बस बेकार हो गया। बस len (y) का उपयोग करें और 4 बाइट्स बचाएं! हम मस्ती करते है!
राफेल कोटे

5

जेली ,  72  73 बाइट्स

+1 फिक्सिंग का एक इक्का गेम बग जो पूर्ण रूप से लटका हुआ व्यक्ति दिखा ( अंत के निकट बदल LNगया Lạ6)

e€a⁸o”_$,ḟ@©K€Y,@“¥[$⁼Ż⁸½c¤ṫȷṃl®ḌvNṂeL©?Ḥ’ṃ“ -¶|O/\=+”¤Y⁶“$"÷ȷñŒ‘ḣ®Lạ6¤¤¦

बाईं ओर शब्द लेने वाला एक डाइएडिक लिंक और दाईं ओर अद्वितीय (भीतर और भीतर का) अक्षर, वर्णों की एक सूची, या कमांड लाइन के तर्क के रूप में इनपुट लेने और परिणाम को प्रिंट करने के लिए एक पूर्ण कार्यक्रम।

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

कैसे?

पहले तो:

“¥[$⁼Ż⁸½c¤ṫȷṃl®ḌvNṂeL©?Ḥ’ - base 250 number
                            = 305169639782226039115281574830092231403740634016078676

आधार 9, जहां 9 अंकों के प्रत्येक पात्रों में से एक का प्रतिनिधित्व में पूर्ण फांसी व्यक्ति के संख्यात्मक मूल्य है: <space>, <newline>, -, |, O, /,\ , =, या+

कार्यक्रम के बाकी:

e€a⁸o”_$,ḟ@©K€Y,@“...’ṃ“...”¤Y⁶“...‘ḣ®Lạ6¤¤¦ - Main link word, letters
e€                                           - exists in letters for €ach char in word
  a⁸                                         - and with word (word with 0 at un-guessed)
    o”_$                                     - or with '_' (word with _ at un-guessed)
         ḟ@                                  - filter remove (incorrect guesses)
           ©                                 - copy the result to the register and yield
        ,                                    - pair
            K€                               - join €ach with spaces
              Y                              - join with (a) newlines
                            ¤                - nilad followed by link(s) as a nilad:
                 “...’                       - the number described above
                       “...”                 - list of chars " -¶|O/\=+" (¶ = a newline)
                      ṃ                      - base decompress using the chars as digits
               ,@                            - pair (using swapped @rguments)
                             Y               - join with (a) newlines
                                           ¦ - sparse application:
                              ⁶              -   of: a space character
                                             -   to indexes:
                                          ¤  -     nilad followed by links as a nilad:
                               “...‘         -       literal [36,34,28,26,27,19]
                                         ¤   -       another nilad chain:
                                     ®       -         recall from register
                                      L      -         length (# of bad guesses)
                                       ạ6    -         absolute difference with 6
                                    ḣ        -       head (get the indexes to "erase"
                                             -             by applying the space char)
                                             - as a full program: implicit print

यह परीक्षण BOATऔर ATOBपरीक्षण के मामले में विफल रहता है । इसे ऑनलाइन आज़माएं!
फायरफ्लेम २४१ १२

आह इशारा करने के लिए धन्यवाद कि, मैं इसे 2 बाइट्स के लिए ठीक कर दूंगा ... बस एक स्पष्टीकरण लिख रहा हूं।
जोनाथन एलन

किया, और उस 1 बाइट को बनाते हैं।
जोनाथन एलन

नोट: लोगों के सामने आने पर "लटका" के लिए पिछला तनाव "लटका हुआ" है, न कि "लटका हुआ"। बस एक
नाइटपिक में

@ ,Ρ IN̛ευτŗιͷo हे, मैं एक स्थान पर लटका था और दूसरे में लटका हुआ था और बाद में बदल गया था। (मैंने "पूरी तरह से" भी कहा, जैसे कि अधूरे व्यक्ति को भी पूरी तरह से फांसी नहीं दी गई थी)।
जोनाथन एलन

3

जाप v2 , 94 91 83 81 बाइट्स

इस से @ETHproductions के दृष्टिकोण के कुछ विचारों से -3 बाइट्स ।
मल्टीलाइन स्ट्रिंग रोटेशन का उपयोग करके -8 बाइट्स।
V2 का उपयोग करके -2 बाइट्स।

["+|||||
-
-
-  35
+|01
   24
"r\d_¨VkU l ?S:"O|/\\/\\"gZÃz '=³³¡VøX ?X:'_øVkU]·

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

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

व्याख्या

लागू: Uऔर Vइनपुट चार सरणियाँ हैं।

["..."

एक सरणी शुरू करें और 90 ° घुमाए गए हैंगिंग मैन प्रारूप स्ट्रिंग को पुश करें।

r\d_

निम्नलिखित फ़ंक्शन के साथ rहर अंक ( \d) को बदलें :

¨VkU l ?S:"O|/\\/\\"gZÃ

यदि अंकों है >=( ¨गलत अनुमान (की राशि) VkU l), एक अंतरिक्ष ( S), अन्यथा, कि अंकों के लिए उपयुक्त शरीर के अंग मिल ( "..."gZ)।

z '=³³

लटकते हुए आदमी को 90 ° घुमाएँ और सरणी में =3 * 3 ( ³³) बार दोहराया जाए ।

¡VøX ?X:'_Ã

शब्द-से-अनुमान को पुश करें, अक्षरों के साथ मैप किए गए ( ¡) या तो स्वयं ( X) में निहित होने पर V( VøX), या _यदि नहीं, और रिक्त स्थान ( ¸) के साथ सरणी में शामिल हो गए ।

VkU]·

kआउटपुट सरणी के लिए हटाए गए शब्द (से ) में अक्षरों के साथ, अनुमानित अक्षरों को पुश करें । सरणी को बंद करें और newlines ( ·) के साथ जुड़ें ।

रोटेशन की कल्पना:

+|||||      +---+
-           |   |
-      ->   0   |
-  35      213  |
+|01       4 5  |
   24             

मेरे पास कुछ ऐसा ही था: ethproductions.github.io/japt/… (हालांकि अब मुझे लगता है कि मेरे पास मध्य तीन खंड गलत क्रम में हैं)। मुझे आपके कुछ हिस्से दिखाई दे रहे हैं जो मैंने कैसे किए, उससे कम हैं, हो सकता है कि हमारे उत्तर कुछ छोटे से भी गठबंधन कर सकते हैं।
ETHproductions

@ETHproductions मुझे नहीं लगता कि वेतन वृद्धि का आपका विचार Wकाम कर सकता है क्योंकि शरीर के अंग बाएं-से-दाएं / ऊपर से नीचे दिखाई नहीं देते हैं। मैं आपके संस्करण से कुछ बाइट्स को बचाने में सक्षम था, हालांकि।
जस्टिन मेरिनर

2

05AB1E , 83 बाइट्स

•LO„Ÿ¼Ì‘Šη…ÔÆ#δʒΣ•6B4ÝJ"+ -|="‡²¹SK©Ùg"O/|\/\"s£v5y.;}7ô»„==«5ð:¹D²SKDg'_ׇSðý®Sðý»

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


बिटमैप:

05AB1E , 18 बाइट्स

•LO„Ÿ¼Ì‘Šη…ÔÆ#δʒΣ• # Push number described below in base-10.

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

यह निम्न बिटमैप योजना को आगे बढ़ाता है:

1102220
1131113
1151113
1555113
1515113
1111113
4444444

जहां निम्नलिखित अतिरिक्त बाइट्स हैं:

05AB1E , 13 बाइट्स

6B            # Convert to base-6.
  4ÝJ         # Push 01234.
     "+ -|="  # Push that string.
            ‡ # Replace numbers with those letters.

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

बिटमैप के टुकड़ों को उपयुक्त पात्रों से बदलें, बाद में जल्लाद के टुकड़ों को बदलने के लिए 5 छोड़ दें:

  +---+
  |   |
  5   |
 555  |
 5 5  |
      |
=======

लटकाया गया आदमी:

अगला, हम गणना करते हैं कि दूसरे इनपुट में जो अक्षर हैं, उन्हें पकड़कर उपयोगकर्ता ने कितनी बार गलत अनुमान लगाया, लेकिन पहले इनपुट में नहीं:

05AB1E , 6 बाइट्स

²¹SK   # Get wrong guesses.
    ©Ù # Store them, and get unique wrong letters.

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


अंत में, हम फंसे हुए आदमी में स्थानापन्न करने के लिए एक माध्यमिक बिटमैप का उपयोग करते हैं, नई कथनों से अलग करते हैं और इसे अंतिम प्रिंट के लिए तैयार करते हैं:

05AB1E , 26 बाइट्स

g                           # Get the number of "messups".                       
 "O/|\/\"s£                 # Only that many chars of the hanged "bitmap".
           v5y.;}           # Replace 5's with "bitmap".
                 7ô»        # Split into rows.
                    „==«5ð: # Remove additional 5's.

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

इसका परिणाम पहले टुकड़ों में है, केवल शेष टुकड़े एक विस्तृत प्रारूप में नीचे दो शब्दों का उत्पादन कर रहे हैं ...


नीचे दिए गए शब्द:

लापता अनुमान के बिना पहला शब्द प्रिंट करें:

05AB1E , 15 बाइट्स

¹D²SK          # Word without the missing guesses.
     Dg'_ׇ    # Replace missing guesses with "_".
           Sðý # Join by spaces.

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


05AB1E , 5 बाइट्स

®     # Print stored missing guesses.
 Sðý  # Separated by spaces.
    » # Print everything in stack with newlines.

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

एक रजिस्टर में संग्रहीत पहले से गणना की गई गलत अनुमानों को प्रिंट करें।


1
मुझे वास्तव में बिटमैप विचार पसंद है (इसे अपने स्वयं के उत्तर में लागू करने की कोशिश कर रहा है, यहां तक ​​कि), लेकिन आपका उत्तर /शरीर से पहले बाएं हाथ ( ) को रखता है ( |)। दो गलत पत्रों के परिणामस्वरूप सिर और शरीर के टुकड़े दिखाई देने चाहिए। इसे ऑनलाइन आज़माएं
जस्टिन मेरिनर

1

जेली , 86 बाइट्स

3ȷ6Dẋ6Ḍ+“Ȧṇ⁹c’
œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S+¢Dị“+-|/\O ”Us7Y,”=x9¤Y;⁷,œ-ðjɓi@€ị³;”_¤K;⁷

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

वाह ... यह मजेदार था। मैंने कभी इतने का उपयोग नहीं किया¤ किरदारों का ।

यह काम किस प्रकार करता है

3ȷ6Dẋ6Ḍ+“Ȧṇ⁹c’ (1) the literal 300000030000003000000300000030003001222100
3ȷ6              - literal 3*10^6 = 3000000
   D             - digits
    ẋ6           - repeat six times
      Ḍ          - return to integer: 300000030000003000000300000030000003000000
       +         - add
        “Ȧṇ⁹c’   - literal 2998222100

œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S+¢Dị“+-|/\O ”Us7Y,”=x9¤Y,œ-;⁷ð,ɓi@€ị³;”_¤K;⁷
œ-Lḣ@“Ñæçðøþ‘⁵*$€×“µI,’D¤¤S - representation of the body parts
œ-L                           - wrong letters length
   ḣ@                         - get that many elements from the start of
                        ¤¤    - the literal:
     “Ñæçðøþ‘                   - [16, 22, 23, 24, 29, 31]
             ⁵*$€               - 10 to the power of each of them
                 ×              - multiplies by
                  “µI,’D        - the list [6, 4, 3, 5, 4, 5]
                          S   - sum
+¢Dị“+-|/\O ”Us7Y,”=x9¤;⁷  - complete the man
+                           - add
 ¢                          - the literal 3000000...1222100 calculated by link 1
  D                         - digits
   ị“+-|/\O ”               - index into the string “+-|/\O ”
             Us7Y           - reverse, split into lines of 7, join by linefeeds
                 ,          - append
                  ”=x9¤;⁷     - the string “=========”
                       ;⁷    - add a newline
,œ-                 - append missed letters:
,                      - append
 œ-                    - set difference
ð,ɓi@€ị³;”_¤K;⁷     - append the blanks        
ð,ɓ                   - append
   i@€ị³;”_¤            - each letter if it is included in guesses, _ otherwise
            K         - join by spaces  
             ;⁷       - add a newline

यह आदमी को गलत क्रम में खींचता है; धड़ को बाएं हाथ से पहले, सिर के बाद आना चाहिए।
झबरा

1

सी #, 305 296 बाइट्स

using System.Linq;w=>g=>{var r=string.Concat(g.Where(c=>!w.Contains(c)));var n=r.Length;return$@"  +---+
  |   |
  {(n>0?"O":" ")}   |
 {(n>2?"/":" ")+(n>1?"|":" ")+(n>3?"\\":" ")}  |
 {(n>4?"/":" ")} {(n>5?"\\":" ")}  |
      |
=========
{string.Join(" ",w.Select(c=>g.Contains(c)?c:'_'))}
"+r;}

Srazed 9 बाइट्स @raznagul की बदौलत।

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

पूर्ण / स्वरूपित संस्करण:

using System;
using System.Linq;

class P
{
    static void Main()
    {
        Func<string, Func<string, string>> f = w=>g=>
        {
            var r = string.Concat(g.Select(c => !w.Contains(c) ? c + "" : ""));
            var n = r.Length;

            return $@"  +---+
  |   |
  {(n > 0 ? "O" : " ")}   |
 {(n > 2 ? "/" : " ") + (n > 1 ? "|" : " ") + (n > 3 ? "\\" : " ")}  |
 {(n > 4 ? "/" : " ")} {(n > 5 ? "\\" : " ")}  |
      |
=========
{string.Join(" ", w.Select(c => g.Contains(c) ? c : '_'))}
" + r;
        };

        Console.WriteLine(f("BOAT")("ATG") + "\n");
        Console.WriteLine(f("ZEPPELIN")("") + "\n");
        Console.WriteLine(f("ZEPPELIN")("EATOLINSHR") + "\n");
        Console.WriteLine(f("RHYTHM")("ABCDE") + "\n");
        Console.WriteLine(f("BOAT")("ATOB") + "\n");

        Console.ReadLine();
    }
}

यह भी 314 बाइट्स के लिए काम करता है (शायद अभी भी कम हो सकता है):

using System.Linq;w=>g=>{var r=string.Concat(g.Select(c=>!w.Contains(c)?c+"":""));var s=$@"  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
=========
{string.Join(" ",w.Select(c=>g.Contains(c)?c:'_'))}
"+r;for(int i=0;i<6;++i)s=s.Replace(i+"",i<r.Length?i<1?"O":i<2?"|":i<3?"/":i<4?"\\":i<5?"/":"\\":" ");return s;}

आप बदल सकते हैं g.Select(c=>!w.Contains(c)?c+"":"")के साथ g.Where(c=>!w.Contains(c))
राजनागुल

@raznagul धन्यवाद!
द लीथेलकोडर

1

जावास्क्रिप्ट (ईएस 6), 203 196 187 186 185 184 180 177 176 बाइट्स

वाक्यविन्यास में अलग-अलग वर्णों के 2 सरणियों के रूप में इनपुट लेता है।

a=>g=>`  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
${a.map(x=>g[s="includes"](x)?x:"_")}
`.replace(/\d|,/g,m=>" O|/\\/\\"[!!w[~-m]*~~m],w=g.filter(x=>!a[s](x)))+w

इसे खेलने की कोशिश करें

o.innerText=(f=
a=>g=>`  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
${a.map(x=>g[s="includes"](x)?x:"_")}
`.replace(/\d|,/g,m=>" O|/\\/\\"[!!w[~-m]*~~m],w=g.filter(x=>!a[s](x)))+w)([...i.value="ZEPPELIN"])([...j.value=""])
oninput=_=>o.innerText=f([...i.value.toUpperCase()])([...j.value.toUpperCase()])
label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}
<label for=i>Word: </label><input id=i type=password><label for=j>Guesses: </label><input id=j><pre id=o>


मध्यम "शरीर" टुकड़ा दूसरे आना चाहिए और बाएं हाथ के तीसरे, तो अपनी स्ट्रिंग की संख्या हिस्सा होना चाहिए 1, 324, 5 6(पिछले परीक्षण का मामला देखें)।
जस्टिन मेरिनर

उफ़, डननो मैंने ऐसा कैसे किया। इसे इंगित करने के लिए धन्यवाद, @JustinMariner
Shaggy

0

स्काला , 392 389 बाइट्स

यह अभी भी हो सकता है भी भारी गोल्फ ।

यह एक फ़ंक्शन लेने sऔर tपैरामीटर के रूप में है, जिसमें sअनुमान लगाने के लिए शब्द और tपहले से ही कोशिश किए गए अक्षरों से युक्त स्ट्रिंग है।

var f=s.map(x=>if(t contains x)x else"_") mkString " "
var o="""  +---+
  |   |
  0   |
 213  |
 4 5  |
      |
=========
"""
var c=0
var g=t.filter(x=>if(s contains x){false}else{c match{case 0=>o=o.replace("0","o")
case 1=>o=o.replace("1","|")
case y if y==2|y==5=>o=o.replace(y+"","\\")
case y if y==3|y==4=>o=o.replace(y+"","/")
case _=>()}
c+=1
true})
o.replaceAll("\\d"," ")+f+"\n"+g

संपादित करें:
-1 बाइट: t.contains(x) -> t contains x
-1 बाइट: s.contains(x) -> s contains x
-1 बाइट:.mkString(" ") -> mkString " "

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


0

PHP 7, 246 बाइट्स

for($t="  +---+
  |   |
  1   |
 324  |
 5 6  |
      |
=========
";$c=($w=$argv[1])[$i++];)$t.=strstr($g=$argv[2],$c)?"$c ":"_ ";for($t.="
";$c=$g[$k++];)strstr($w,$c)?:$t.=$c.!++$n." ";for(;$p++<6;)$t=strtr($t,$p," O|/\/\\"[$p>$n?0:$p]);echo$t;

कमांड लाइन तर्कों से इनपुट लेता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें

for($t="  +---+\n  |   |\n  1   |\n 324  |\n 5 6  |\n      |\n=========\n";
    $c=($w=$argv[1])[$i++]; # 1. loop $c through word
)
    $t.=strstr($g=$argv[2],$c)  # if guessed,
        ?"$c ":"_ ";                # then append letter, else append underscore
for($t.="\n";$c=$g[$k++];)  # 2. loop through guesses
    strstr($w,$c)?:             # if not in word
        $t.=$c.!++$n." ";           # add to output, increment $n
for(;$p++<6;)               # 3. loop through possible false guesses
    $t=strtr($t,$p," O|/\/\\"[  # replace digit:
        $p>$n                   # if above no. of wrong guesses
            ?0:$p                   # then with space, else with hangman character
    ]);
echo$t;                     # 4. print
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.