नवप्रवर्तन छींटों के लिए माउस को गिनना

Question

इनोवेशन एक ऐसा कार्ड गेम है, जिसमें खिलाड़ी अपने विरोधियों की तुलना में तेज़ी से उपलब्धियां हासिल करने के प्रयास में, उम्र से लेकर आधुनिक समय तक युद्ध करते हैं।

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

खेल में 6 प्रकार के चिह्न (महल, मुकुट, पत्तियां, लाइटबल्ब, कारखाने और घड़ियां) हैं, जिन्हें हम चार्ट का उपयोग करके मनमाने ढंग से प्रतिनिधित्व करेंगे 012345। का उपयोग करते हुए #काले षट्भुज प्रतिनिधित्व करने के लिए, हम प्रत्येक कार्ड पर माउस का प्रतिनिधित्व करने के लिए चार वर्ण का उपयोग कर सकते हैं। उदाहरण के लिए, ऊपर कार्ड हैं

0.. #.. 3.. 1..  -> 03#0 #331 355# 144#
3#0 331 55# 44#

अब, इनोवेशन में, प्ले एरिया में कार्ड्स को बवासीर * में बांटा जाता है, जिसे चार तरीकों में से एक में विभाजित किया जाता है। प्रत्येक उदाहरण के लिए हम ऊपर के कार्ड का उपयोग करेंगे, सबसे बाईं ओर का कार्ड, 03#0ढेर के शीर्ष पर है।

नो स्पलै: केवल शीर्ष कार्ड दिखाई देता है

0..
3#0

Splay छोड़ दिया : शीर्ष कार्ड पूरी तरह से दिखाई देता है, साथ ही नीचे सभी कार्डों का सही तीसरा है

0..|.|.|.|
3#0|1|#|#|

Splay right : शीर्ष कार्ड पूरी तरह से दिखाई देता है, साथ ही नीचे दिए गए सभी कार्डों का तीसरा भाग भी

1|3|#|0..
4|5|3|3#0

Splay up : शीर्ष कार्ड पूरी तरह से दिखाई देता है, साथ ही नीचे के सभी कार्डों का आधा हिस्सा।

0..
3#0
---
331
---
55#
---
44#

चुनौती

इनपुट एक सिंगल-स्पेस-स्ट्रिंग स्ट्रिंग होगा जिसमें दो भाग होंगे:

• एक अलग दिशा, जो एक में से एक है !<>^, क्रमशः, बिना किसी छींटे, बायीं ओर, दायीं ओर या ऊपर की ओर जाती है।
• कार्डों की एक गैर-रिक्त सूची, जिनमें से प्रत्येक 4 वर्णों से लंबी और वर्णों से युक्त होती है 012345#। बाईं ओर का कार्ड ढेर के शीर्ष पर होता है, और प्रत्येक कार्ड में ठीक एक होता है #।

उत्तर कार्य, पूर्ण कार्यक्रम या समकक्ष हो सकते हैं । आप चुन सकते हैं कि स्प्ले दिशा पहले है या आखिरी, यानी नीचे दिए गए दो स्वरूपों में से एक चुनें:

> 03#0 #331 355# 144#
03#0 #331 355# 144# >

आउटपुट प्रत्येक आइकन के लिए गिनती का प्रतिनिधित्व करने वाले छह नंबरों की सूची होगी, उदाहरण के लिए ऊपर दिए गए कार्ड:

! 03#0 #331 355# 144#  ->  2 0 0 1 0 0
< 03#0 #331 355# 144#  ->  2 1 0 1 0 0
> 03#0 #331 355# 144#  ->  2 1 0 3 1 1
^ 03#0 #331 355# 144#  ->  2 1 0 3 2 2

उदाहरण के लिए, नो स्प्ले केस में दो 0आइकन और एक 3आइकन दिखा, जिसमें पहली पंक्ति थी। ध्यान दें कि हम #एस की गिनती नहीं करते हैं , क्योंकि काले हेक्सागोन्स आइकन नहीं हैं।

आप सूची का प्रतिनिधित्व करने का कोई भी उचित और गैर-अस्पष्ट तरीका चुन सकते हैं, उदाहरण के लिए सीमांकित-पृथक या अपनी भाषा की प्राकृतिक सूची प्रतिनिधित्व का उपयोग करना।

परीक्षण के मामलों

! 113#  ->  0 2 0 1 0 0
< 113#  ->  0 2 0 1 0 0
> 113#  ->  0 2 0 1 0 0
^ 113#  ->  0 2 0 1 0 0
! 000# 12#2  ->  3 0 0 0 0 0
< 000# 12#2  ->  3 0 1 0 0 0
> 000# 12#2  ->  3 1 1 0 0 0
^ 000# 12#2  ->  3 0 2 0 0 0
! 000# 111# 222#  ->  3 0 0 0 0 0
< 000# 111# 222#  ->  3 0 0 0 0 0
> 000# 111# 222#  ->  3 2 2 0 0 0
^ 000# 111# 222#  ->  3 2 2 0 0 0
! 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  0 0 0 2 0 1
< 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  1 1 2 5 1 1
> 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  0 3 3 7 1 1
^ 335# #101 21#2 333# 2#20 3#33 4#54 #133 3#33 32#2  ->  2 4 4 10 1 2

ध्यान दें कि ऐसा कुछ !अमान्य इनपुट है, क्योंकि सूची गैर-रिक्त होने की गारंटी है।

---

^{* इस चुनौती के प्रयोजनों के लिए, हम ढेर रंगों की अनदेखी कर रहे हैं।}

Answer 1

CJam, 44 37 36 बाइट्स

मुझे याद दिलाने के लिए Sp3000 का धन्यवाद कि मैं चीजों को कम कर रहा हूं और 7 बाइट्स बचा रहा हूं।

rci7%"3>0<2<1>"2/=6,slS%{W$~+}*fe=p;

इसका परीक्षण यहां करें।

व्याख्या

कुछ अवलोकन:

• हम हमेशा पूरे पहले कार्ड को गिनना चाहते हैं।
• सभी छींटों में एक उपसर्ग या हटाए गए आइकन का एक प्रत्यय होगा। !उन सभी को निकालता है (जो या तो एक उपसर्ग है या चार वर्णों का एक प्रत्यय है), <पहले तीन वर्णों को >हटाता है, अंतिम दो वर्णों को ^हटाता है, पहले वर्ण को हटाता है।

तो हम सभी की जरूरत है एक छोटा तरीका है कि सही मोड में स्प्ले मोड को मैप करें:

rci   e# Read the splay mode and convert to its character code.
7%    e# Take modulo 7. This maps "<!>^" to [4 5 6 3], respectively. Modulo 4 those are
      e# are all distinct (namely [0 1 2 3], respectively).
"3>0<2<1>"
      e# Push this string.
2/    e# Split it into chunks of 2, ["3>" "0<" "2<" "1>"]. Each chunk is CJam code which
      e# performs one of the truncations.
=     e# Select the correct snippet. This works, because array indexing is cyclic in CJam.
6,s   e# Push the string "012345".
lS%   e# Read the remainder of the input and split into space-separated tokens.
{     e# Now we're abusing the fold operation to apply our snippet to every card except
      e# the first, while also combining them all back into a single string.
  W%  e#   Copy the bottom of the stack (the truncation snippet).
  ~   e#   Evaluate it.
  +   e#   Append it the string we're building.
}*
fe=   e# For each character in "012345", count the occurrences in our new string.
p     e# Pretty-print the array.
;     e# Discard the truncation snippet which was still at the bottom of the stack.

हम देख सकते हैं कि ट्रंकेशन स्निपेट्स में वास्तव में बहुत सारी संरचना है। प्रत्येक स्प्ले मोड एक नंबर में [0 1 2 3](विशेष रूप से, क्रम में "!^><") मैप करता है , और उनमें से दो के पास >और दो होते हैं <। मैं दो हैश खोजने की उम्मीद कर रहा था, जो जादुई रूप से अलग-अलग इन हिस्सों का उत्पादन करते हैं, क्योंकि यह बाइट्स के एक झुंड को बचाएगा, लेकिन अभी तक मुझे कुछ भी नहीं मिला था। मैं "!^><"एकांतर समता की संख्या के साथ 31%(से सही चरित्र का चयन करने के लिए "<>") मैप कर सकता हूं , लेकिन मुझे कुछ भी नहीं मिला है जो [0 1 2 3]उस क्रम में बड़े करीने से उन्हें मैप करता है। (भोले समाधान को छोड़कर, "!^><"#जो दुर्भाग्य से किसी भी बाइट को नहीं बचाता है।)

यह भी ध्यान दें कि यह वास्तव में थोड़ा अधिक लचीला है। किसी के लिए भी !लागू किया जा सकता है (एक उपसर्ग के रूप में सब कुछ त्यागते हुए)। दुर्भाग्य से, मैं इस तरह के नक्शे के लिए कोई सरल कार्य नहीं कर पाया।n>n > 3

Answer 2

पायथ, 39 36 33 31 बाइट्स

Jtczdm/s+hJm@yk%*%Chz33T19tJ`d6

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

व्याख्या

• Jtczd: रिक्त स्थान से इनपुट विभाजित करें, पहले भाग को हटा दें, और बाकी को बचाएं J।
• m… 6: 0 से 5 की संख्या के लिए निम्नलिखित दोहराएं।
  • m… tJ: पहले वाले को छोड़कर सभी कार्डों के लिए निम्नलिखित दोहराएं।
    • Chz: इनपुट में पहले वर्ण का कोड बिंदु प्राप्त करें।
    • %*%… 33T19: !<>^0, 4, 5, 14. की संख्याओं के लिए (33, 60, 62, 94) के कोड पॉइंट को मैप करें , जो सटीक गणना की गई है cp % 33 * 10 % 19।
    • yk: वर्तमान कार्ड का अधिकार प्राप्त करें। यह कार्ड के सभी बाद की सूची है।
    • @: पहले गणना किए गए इंडेक्स के अनुरूप अधिकार का आइटम प्राप्त करें।
  • +hJ: परिणाम के लिए पहला कार्ड संलग्न करें।
  • s: प्रोसेस्ड कार्ड को एक साथ मिलाएं।
  • /... `d: परिणाम में वर्तमान संख्या की घटनाओं को गिनें।