पासा पलटना

Question

पासा पलटना

इसलिए, मैं कुछ समय पहले पासा पलट रहा था और एक चुनौती के बारे में सोचा था।

इनपुट से लिए गए जाल और चाल की सूची के साथ क्यूब को देखते हुए, अंत में नीचे की तरफ वर्ग का पता लगाएं।

मैं इस छवि का उपयोग यहां के उदाहरणों के लिए करूंगा।

इनपुट

आप चाल की सूची के साथ एक स्ट्रिंग में लेते हैं। स्ट्रिंग में केवल कैपिटल ASCII अक्षर N, S, W और E शामिल हैं। ये क्यूब को उस दिशा में एक कदम आगे बढ़ाने के लिए मेल खाते हैं।

तस्वीर में, एक एन नीचे के चेहरे को एक 6. बना देगा। इस छवि में, उत्तर कैमरे से दूर है, दक्षिण की ओर है, पूर्व दाएं है, और पश्चिम बचा है।

आप निम्न प्रारूप में एक स्ट्रिंग भी लेते हैं: 1P 2P 3P 4P 5P 6P, जहां प्रत्येक P N, S, W, E, T से एक स्थिति है, और B. T & B नीचे और ऊपर है।

संख्याएं उस संख्या के साथ चेहरा होती हैं, और अक्षर उस स्थिति का प्रतिनिधित्व करता है जिसमें चेहरा होता है। यदि यह स्पष्ट नहीं है, तो नेट हमेशा संख्या द्वारा आदेश दिया जाएगा, इसलिए 1P 2P 3P 4P 5P 6P, कभी भी 2B 1T 3N नहीं 4S 5W 6E।

छवि में स्थिति 1S 2B 3E 4W 5T 6N है।

उत्पादन

आपका कार्यक्रम नीचे की ओर का प्रतिनिधित्व करते हुए एक नंबर आउटपुट होना चाहिए।

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

(nothing), 1S 2B 3E 4W 5T 6N -> 2
N, 1S 2B 3E 4W 5T 6N -> 6
NS, 1S 2B 3E 4W 5T 6N -> 2
NWS, 1S 2B 3E 4W 5T 6N -> 2
NWSNWS, 1S 2B 3E 4W 5T 6N -> 2
NWSS, 1S 2B 3E 4W 5T 6N -> 3
NNNNNN, 1S 2B 3E 4W 5T 6N -> 5
SNWEEWS, 1N 2T 3E 4W 5B 6S, 6
SNEEWS, 1N 2T 3W 4S 5B 6E, 4

अन्य नियम

आप यह भी मान सकते हैं कि घन एक अनंत समतल तल पर है, शायद किसी प्रकार के घर्षण के साथ।

मानक खामियों को दूर किया, भले ही मुझे कोई नहीं मिल रहा है।

अमान्य इनपुट के लिए, आपका कोड सर्वनाश शुरू करने के अलावा कुछ भी कर सकता है।

क्योंकि यह कार्यक्रम मेरे पासा पर फिट होना चाहिए, यह जितना संभव हो उतना छोटा होना चाहिए। मैं बाइट्स में गिनता हूं, फोल्डर्स जैसी भाषाओं के लिए कुछ अपवादों के साथ ।

Comments

क्या पहला परीक्षण मामला इस बात के साथ (nothing) -> 2है कि कोई नेट प्रदान नहीं किया गया है, या कहीं नेट होना चाहिए?

— Sp3000

" तस्वीर में, एक एन नीचे के चेहरे को 2 बना देगा " नीचे का चेहरा पहले से ही 2 नहीं है?

— १०

@ Sp3000, संपादित, नेट प्रदान किया जाना चाहिए, लेकिन आपके कोड को कोई आंदोलन कमांड को संभालने में सक्षम होना चाहिए।

— R

आप बाइट में अपने पासा के आकार को मापते हैं?

— साइयो

@Cyoce नहीं, प्रत्येक चेहरे पर सिर्फ पाठ। तो उस पर the के साथ चेहरा 4 बाइट्स होगा। इस चुनौती के लिए, मैं अपने पासा पर आपके द्वारा लिखे गए कोड को फिट करने में सक्षम होना चाहता हूं। ऐसा करने के लिए, मुझे छोटे कोड की आवश्यकता है।

— R

Answer 1

CJam, 43 40 37 34 बाइट्स

6 बाइट बचाने में मेरी मदद करने के लिए डेनिस का धन्यवाद।

lW%3/$1f=q{i8%"ÉĔɠƂ!"=i\m!=}/c

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

व्याख्या

lW%    e# Read the first line and reverse it.
S/     e# Split it around spaces.
$      e# Sort it. This puts the faces in order [B E N S T W].
1f=    e# Select the second character from each face, which is the number.
q      e# Read the remainder of the input (the instructions).
{      e# For each instruction...
  i8%  e#   Convert the character (NWSE) to an integer and take modulo 8.
  "ÉĔɠƂ!"=i
       e#   Use that to (cyclically) index this string and convert *that* character
       e#   to an integer.
  \    e#   Swap with the list of faces.
  m!   e#   Generate all permutations of the faces.
  =    e#   Select the permutation corresponding to the above integer.
}/     e# At the end of the loop, the bottom face will be the first character.
c      e# Convert the string to a character, which discards everything but the bottom face.

क्रमांकन के लिए निर्देश वर्णों की मैपिंग कैसे काम करती है, इसके लिए यहां एक उपयोगी तालिका दी गई है:

   i   8%  5%  ""=   i   [0 1 2 3 4 5]m!=

N  78   6   1   Ĕ   276  [2 1 4 0 3 5]
W  87   7   2   ɠ   608  [5 0 2 3 1 4]
S  83   3   3   Ƃ   386  [3 1 0 4 2 5]
E  69   5   0   É   201  [1 4 2 3 5 0]

मैंने 5%कॉलम को शामिल किया है क्योंकि यह वही है जो स्ट्रिंग में चक्रीय अनुक्रमण करता है। चार क्रमपरिवर्तन के लिए हम देख सकते हैं कि उनमें से प्रत्येक दो (विपरीत) पक्षों को अछूता छोड़ देता है और अन्य चार को चक्रीय रूप से अनुमति देता है।

Comments

आप उन यूनिकोड वर्णों के रूप में क्रमपरिवर्तन का प्रतिनिधित्व कैसे करते हैं? 2 N [2 1 4 0 3 5] के क्रमचय का प्रतिनिधित्व कैसे करता है? मैं इसे घंटों तक घूर रहा हूं।

— १।

@paulvs का वर्ण कोड Ĕहै 276। 6e!आपको सभी 720 क्रमोन्नति की सूची देता है [0 1 2 3 4 5]। और उस सूची 276का सूचकांक बन [2 1 4 0 3 5]जाता है।

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

मैं चाहता था कि और लोग जवाब दें, लेकिन आप सबसे छोटे थे। बधाई।

— 21

Answer 2

पर्ल, 166 158 154 144 139 135 134 132 116 बाइट्स

के लिए +1 शामिल है -p

s/(\d)(.)/$h{$2}=$1/eg;$N='NTSB',$S='STNB',$E='ETWB',$W='WTEB';map{@h{@l}=@h{(@l=$$_=~/./g)[1..3,0]}}/\w/g;$_=$h{B}

टिप्पणियों के साथ:

                                    # example input: "NS, 1S 2B 3E 4W 5T 6N"
s/(\d)(.)/$h{$2}=$1/eg;             # construct %h ( S=>1, B=>2, E=>3, W=>4, B=>2, N=>6 )

                                    # = Transformations =
$N='NTSB',                          # N becomes T, T becomes S, S becomes B, B becomes N
$S='STNB',
$E='ETWB',
$W='WTEB';

map {                               # iterate the moves "NS"
    @h{ @l } =                      # LHS: bulk-assign new values; @l defined in RHS
      @h{                           # RHS: init @l, transform
          (@l=$$_=~/./g)            # get transform, put ('N','T','S','B') in @l for LHS
          [1..3,0]                  # construct a rotated slice for RHS
    }    
} /\w/g;                            # match the movements in list context

$_=$h{B}                            # assign the bottom face to output.

---

इनपुट फ़ाइल:

, 1S 2B 3E 4W 5T 6N
N, 1S 2B 3E 4W 5T 6N
NS, 1S 2B 3E 4W 5T 6N
NWS, 1S 2B 3E 4W 5T 6N
NWSNWS, 1S 2B 3E 4W 5T 6N
NWSS, 1S 2B 3E 4W 5T 6N
NNNNNN, 1S 2B 3E 4W 5T 6N
SNWEEWS, 1N 2T 3E 4W 5B 6S
SNEEWS, 1N 2T 3W 4S 5B 6E

साथ दौड़ो

perl -p dice.pl < input.txt

आउटपुट: 262223564

---

• अद्यतन 8 बाइट्स $N, $S, $E, $Wको %t = {N=>, S=>, E=>, $W=>}सहेजने के बजाय वैश्विक चर का उपयोग करना ।

• 154 अपडेट करें क्योंकि आवश्यकता यह है कि प्रोग्राम एक नंबर आउटपुट करता है, न कि न्यूलाइन print "$h{B}\n"को प्रिंट करने से 4 बाइट्स बचते हैं print $h{B}:।

• 144 अपडेट करें 10 बाइट्स बचाकर करें

  ($s)=/^(\w+),/;            s/(\d)(.)/$h{$2}=$1/eg;
  

  के बजाय

  ($s,@i)=split /,? |\n/;    %h=reverse map{split//}@i;
  

• अपडेट 139 एक चर को खत्म करने के लिए कमांड के लिए रेजेक्स को 6 बाइट्स में सहेज कर रखें।

• अद्यतन 135 सहेजें 4 बाइट्स के @l[0..3,0]बजाय पर @l[1..3],$l[0]।

• @l=split//,$$_मान के रूप में असाइनमेंट का उपयोग करके 134 सहेजें 1 बाइट को अपडेट करें ।

• अद्यतन 132 सहेजें 2 बाइट्स के /^\w+/ && $&बजाय करने से /^(\w+)/ && $1।

• अद्यतन 129 प्रिंट के लिए $ _ और असाइन -pकरने के बजाय 3 बाइट्स सहेजें -n।

• अद्यतन 116 सहेजें 13 लिख कर बाइट्स split//, /^\w+/ && $&में /^\w+/g।

Comments

— क्रोस

Answer 3

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

सोचा कि यह मेरे अपने सवाल का जवाब देने का समय है।

def x(p,m):
    d={p[3*i-2]:i for i in range(1,7)}
    for j in m:n=2if j in'NE'else-2;x='BSTN'if j in'NS'else'BETW';d[x[0]],d[x[1]],d[x[2]],d[x[3]]=d[x[1+n]],d[x[(2+n)%4]],d[x[(3+n)%4]],d[x[0+n]]
    print d['B']

बहुत कम नहीं, लेकिन काम करता है।

ऐसे दोड़ो:

x('1B 2T 3N 4S 5W 6E','SNEEWS')
#Output: 4

संपादित करें : बाइट्स गलत गिने। अब लंबे समय तक। :(

Comments

बीटीडब्ल्यू, अजगर मैक्रो के लिए धन्यवाद xnor।

— R