रैंडम बोगल बोर्ड उत्पन्न करें

Question

पत्र / रिक्त स्थान की 4x12 ग्रिड उत्पन्न करें:

प्रत्येक डाई को एक बार ठीक से दिखाई देना चाहिए, स्थान को यादृच्छिक रूप से चुना गया। स्थान एक समान यादृच्छिक पासा के क्रमपरिवर्तन होना चाहिए। प्रत्येक मर के एक यादृच्छिक (फिर, लगभग समान) चेहरा प्रदर्शित करें। 3-वर्ण विंडो में चेहरे को वाम-औचित्य दें। उदाहरण के लिए,

A  E  A  A
E  C  D  E
D  A  Qu E
E  A  H  D

मेरे इच्छित प्रारूप में एक गैर-यादृच्छिक बोर्ड है। ट्रेलिंग स्पेस की अनुमति है।

पासा:

A  A  E  E  G  N
E  L  R  T  T  Y
A  O  O  T  T  W
A  B  B  J  O  O
E  H  R  T  V  W
C  I  M  O  T  U
D  I  S  T  T  Y
E  I  O  S  S  T
D  E  L  R  V  Y
A  C  H  O  P  S
H  I  M  N  Qu U
E  E  I  N  S  U
E  E  G  H  N  W
A  F  F  K  P  S
H  L  N  N  R  Z
D  E  I  L  R  X

मनोरंजक तथ्य: सेट में केवल 1 K है। क्या अन्य पत्र विशेष रूप से शेयरों कि मर जाते हैं?

यह कोड-गोल्फ है इसलिए सबसे कम बायटेकाउंट जीत के साथ कार्यक्रम!

Comments

यदि के के हैं तो F नहीं हो सकता है। इसका मतलब है कि आप च को जादू नहीं कर सकते ... iretruck! : पी

— ब्लेज़र

@ ब्लेज़र: हाँ, और आप एफ ... olk या तो जादू नहीं कर सकते। : पी

— Ry-

Answer 1

गोल्फस्क्रिप्ट, 116 बाइट्स

चूंकि स्कोरिंग बाइट्स में है, इसलिए मुझे लगता है कि हम समाधान में सभी बाइट्स का उपयोग कर सकते हैं। प्रिंट करने योग्य ASCII सेट के बाहर जाने से पीटर टेलर की तुलना में कुछ हद तक समाधान की अनुमति मिलती है , यहां कोड को प्रदर्शित करने के लिए कोड को कठिन बना दिया जाता है। बिना डेटा के, मेरा कोड इस तरह दिखता है:

'57 BYTES OF BINARY DATA HERE'256base 26base 6/{;9.?rand}${6rand=65+.81='  u '2/=}%8/n*

यह पीटर टेलर के समाधान के समान सुंदर है, और मैं इसे बेशर्मी से उधार लेने वाले बिट्स (जैसे .81=' u '2/=चाल) के रूप में स्वीकार करता हूं , हालांकि मुझे लगता है कि मैं बेहतर फेरबदल के लिए एक अतिरिक्त चार बाइट खर्च करने के बाद भी उसके फेरबदल को थोड़ा कम करने में कामयाब रहा ।

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

0000000: 2701 8302 7c56 97d5 ec9c 52e3 462e 44d7  '...|V....R.F.D.
0000010: a8d2 81c9 6115 fc80 4da4 6cd3 b06f a6d8  ....a...M.l..o..
0000020: 4e7e 2029 12a9 f331 0b83 3481 de36 81e2  N~ )...1..4..6..
0000030: 41b4 534d dee8 13f7 ccfd 2732 3536 6261  A.SM......'256ba
0000040: 7365 2032 3662 6173 6520 362f 7b3b 392e  se 26base 6/{;9.
0000050: 3f72 616e 647d 247b 3672 616e 643d 3635  ?rand}${6rand=65
0000060: 2b2e 3831 3d27 2020 7520 2732 2f3d 7d25  +.81='  u '2/=}%
0000070: 382f 6e2a                                8/n*

लिनक्स पर, या xxdइंस्टॉल किए गए उपयोगिता वाले किसी भी सिस्टम पर , इस हेक्स डंप को 116-बाइट गोल्फस्क्रिप्ट प्रोग्राम से गुजरकर वापस चालू किया जा सकता है xxd -r।

संपादित करें: बदला 999randके साथ 9.?randके लिए ज्यादा बेहतर अनियमितता। फेरबदल अब लगभग सही होना चाहिए जैसा कि अंतर्निहित RNG अनुमति देता है।

Comments

आह - मैं भूल गया था कि आप एक मानचित्रण द्वारा सॉर्ट कर सकते हैं।

— पीटर टेलर

Answer 2

पायथन 2.7, 253 229 215 चार्ट

from random import*
j=0
for x in map(choice,sample("AAEEGN ELRTTY AOOTTW ABBJOO EHRTVW CIMOTU DISTTY EIOSST DELRVY ACHOPS HIMNQU EEINSU EEGHNW AFFKPS HLNNRZ DEILRX".split(),16)):j+=1;print x+' u'[x=='Q']+'\n'[j%4:],

अधिकांश पात्र केवल स्वयं पासा हैं। मैं इसे बहुत कम करने की कोशिश में बहुत समय बिताना नहीं चाहता था

मामूली संपादन: हटाए गए 2 अनावश्यक बाइट्स (अतिरिक्त स्थान)

edit2: 229 से नीचे

edit3: 215 से नीचे

Comments

आप अपने कोड को अनुक्रमण के साथ तंग कर सकते हैं, print a+' u'[a=='Q']औरprint'\n'[j%4:]

— कीथ रान्डेल

@ धन्यवाद धन्यवाद! मैंने उन दो चालों को मिलाकर इसे और भी कठिन बना दिया :)

— ब्लेज़र

मैं इसे मारे बिना 218 तक लाने में कामयाब रहा (मुझे लगता है?): 1) आयात विवरण को from random import*सभी को बदलें और निकालें r.। 2) स्ट्रिंगर्स को `` (स्पेस) में बदलें और str.split's डिफॉल्ट' तर्क का लाभ उठाएँ । ३) किसी भी चीज़ से छुटकारा पाना jऔर उपयोग करना '\n'[len(d)%4:]। 4) list.popडिफ़ॉल्ट तर्क का उपयोग करें । 5) ... 6) लाभ!

— डिलन कॉवर

@ डीडीसी आह धन्यवाद! मुझे आश्चर्य है कि मैंने उनकी अनदेखी की। लेकिन मुझे लगता है कि मुझे इसे कुछ ही मिनटों में लिखने के लिए मिलता है: पी

— ब्लेज़र

और मैंने इसे 3 चार्ट्स से थोड़ा कम करके एक छोटा मानचित्र चाल का उपयोग किया, लेकिन मुझे j=0...+'\n'[j%4:]इसे काम करने के लिए रखना था

— ब्लेज़र

Answer 3

GolfScript ( 141 139 137 वर्ण बाइट्स)

जिनमें से 94 का विस्तार स्ट्रिंग से होता है जिसमें पासा होता है। चित्र में इसे लपेटने के लिए डाली गई अनावश्यक न्यूलाइन शामिल नहीं है ताकि कोड को स्क्रॉल किए बिना देखा जा सके:

'Y
ISY
XIAOOW
VYAAEEGNABBJOOEHRTVWCIMOTUEIOSSTACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZ'n/'TTELRD'*
6/{[6rand=99rand\]}%${1=.81='  u '2/=}%8/n*

Comments

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

— पीटर टेलर

मैं पासा को इंटरलाइस करके और रन-लंबाई एन्कोडिंग का उपयोग करके तालिका को 96 से 84 वर्णों तक नीचे लाने में सक्षम था। डिकोडिंग जो अंतर बना सकता है ... यह निश्चित रूप से अजगर के लिए करता है।

— बूथ 24

आप 30 बिट्स में 6 अक्षरों को एनकोड कर सकते हैं, फिर 5 प्रिंट करने योग्य पात्रों में, 16 बाइट्स बचा सकते हैं। लेकिन आपको उन्हें निकालने के लिए कुछ बदलाव / मुखौटा की आवश्यकता होगी।

— ugoren

@ युगोरेन, इल्मरी ने पहले ही ऐसा कर लिया है

— पीटर टेलर

@PeterTaylor, यदि आप कहते हैं कि उसने किया था, तो मेरा मानना ​​है कि आप (मैं गोल्फ कोर्स सीखने के लिए कभी परेशान नहीं हुआ)। लेकिन वह 57 अचूक चरित्रों का उपयोग करता दिख रहा है, जबकि मैंने 80 प्रिंट करने योग्य सुझाव दिए।

— बदसूरत

Answer 4

रूबी, 201 197 चरस

%W(AAEEGN ELRTTY AOOTTW ABBJOO EHRTVW CIMOTU DISTTY EIOSST DELRVY ACHOPS HIMNQU EEINSU EEGHNW AFFKPS HLNNRZ DEILRX).sample(16).map{|c|c[rand 6]}.each_slice(4){|x|puts x.join("  ").gsub(/Q ?/,"Qu")}

(और यह वन-लाइनर है)

1 संपादित करें: .split और उद्धरणों की एक जोड़ी से बचने के लिए% W () का उपयोग किया।

संपादन 2: इसे युक्ति के लिए बनाया (प्रत्येक आउटपुट कॉलम के बीच दो स्थान)

Comments

मैंने अभी इस उत्तर के लिए "एक अनाम उपयोगकर्ता" द्वारा एक संपादन को मंजूरी दी है; मुझे लगता है कि आप, मार्क थे, और आप बस लॉग इन करना भूल गए थे। (Ps। आप आउटपुट बिल्कुल कल्पना नहीं करते हैं; इसका उपयोग x.join(" ").gsub(/Q ?/,"Qu")करने से तीन अतिरिक्त वर्णों की लागत तय होती है।)

— इल्मरी करोनें

(यह joinस्ट्रिंग में एक अतिरिक्त स्थान और रेगेक्स में एक अतिरिक्त स्थान और प्रश्नचिह्न है, एसई सॉफ्टवेयर रिक्त स्थान के मामले में ...)

— इल्मरी करोनन

@IlmariKaronen धन्यवाद, मैंने कॉलम के बीच दो रिक्त स्थान नहीं देखे। यह अब कल्पना करना चाहिए।

— मार्क थॉमस

Answer 5

पॉवरशेल, 234 अक्षर

$d=(0..15|%{@{'AAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZDEILRX'[6*$_+(random)%6]=random}.GetEnumerator()}|sort Value|%{$_.Key})
0..3|%{($d[($_*4)..($_*4+3)])-join"   "-replace'Q ','Qu'}

पठनीयता में सुधार के प्रयास में, अतिरिक्त व्हाट्सएप के साथ यहां एक ही कोड है :-)

#########################################
# roll the 16 dice and shuffle them     #
#########################################

$d=(
        0..15 | % {
                    @{
                       'AAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSHIMNQUEEINSUEEGHNWAFFKPSHLNNRZDEILRX'[6*$_+(random)%6]=random
                     }.GetEnumerator() 
                  } | sort Value | % {
                                        $_.Key
                                     }
    )

############################################
# add the 16 results to the 4 by 4 grid    #
############################################

0..3 | % {
            ($d[($_*4)..($_*4+3)]) -join "   " -replace 'Q ','Qu'
         }

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

Comments

हो सकता है कि आप मौजूदा समय में एमएस के अंतिम अंकों को छँटाई मूल्य के रूप में इस्तेमाल कर सकें?

— ब्लेज़र

@ ब्लेज़र - संभवतः, लेकिन "यादृच्छिक" में केवल छह अक्षर लगते हैं :-)

— एंड्रयू शेफर्ड

Answer 6

पर्ल, 179 वर्ण

@d=(Qu,map"$_ ",HIMNUAAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTYEIOSSTDELRVYACHOPSEEINSUEEGHNWAFFKPSHLNNRZDEILRX
=~/./g);print+(splice@d,6*int rand@d/6,6)[rand 6],@d%24?$":$/while@d

यहाँ कार्यक्रम का एक वर्बोज़ संस्करण है:

my $fullset = "HIMNUAAEEGNELRTTYAOOTTWABBJOOEHRTVWCIMOTUDISTTY"
           . "EIOSSTDELRVYACHOPSEEINSUEEGHNWAFFKPSHLNNRZDEILRX";
my @dice = ("Qu");
push @dice, "$_ " for split //, $fullset;
while (@dice) {
    my @die = splice @dice, 6 * (int rand @dice / 6), 6;
    print $die[rand 6];
    print @dice % 24 ? " " : "\n";
}