एक मानक पासा (मरो) में संख्याओं को व्यवस्थित किया जाता है ताकि विपरीत चेहरे सात हो जाएं। अपनी पसंदीदा भाषा में सबसे कम संभव प्रोग्राम लिखें जो एक यादृच्छिक थ्रो का अनुसरण करता है और उसके बाद 9 यादृच्छिक टिपिंग। टिपिंग पासा का एक चौथाई मोड़ है, उदाहरण के लिए यदि पासा 5 का सामना कर रहा है, तो सभी संभावित टिपिंग 1,3,4 और 6 हैं।
वांछित उत्पादन का उदाहरण:
1532131356
जवाबों:
आपको अपने जावास्क्रिप्ट वातावरण के आधार पर, कुछ और के printसाथ alertया कुछ और बदलने की आवश्यकता हो सकती है।
for(C=L=T=0;C++<10;print(L=T))while(!(T-L&&T+L-7))T=Math.random()*6+1|0
0:|;{7,[0|7|-]-.,rand=:|}10*
दे घुमा के
#/!bin/bash
f=`expr $RANDOM % 6`
f=`expr $f + 1`
printf "$f"
for ((i=0; i<9; i++))
do
((bad=7-$f))
next=`expr $RANDOM % 6`
next=`expr $next + 1`
while [ $next -eq $bad ] || [ $next -eq $f ]
do
next=`expr $RANDOM % 6`
next=`expr $next + 1`
done
printf "$next"
f=$next
done
नमूना कोड: http://ideone.com/CCfro
((var=expression))बहुत अच्छा है - मैंने सोचा था कि सबसे छोटा रास्ता था, var=$((expression))लेकिन आप केवल एक बार बैकटिक्स में अक्षर के बेकार टन का उपयोग क्यों करते हैं?
for(i in 0:9)cat(F<-sample(setdiff(1:6,c(F,7-F)),1))
के लिए ((i = 10, च = यादृच्छिक% 6 + 1; मैं -;)) करना प्रिंटफ $ च ((N = यादृच्छिक% 4 + 1, मी = च <4 च: 7-च, च = n <मीटर || ++ n <7 मीटर n: n + 1)) किया हुआ
मुख्य विचार यह है कि [1, x] में एक यादृच्छिक संख्या चुनने के लिए, जो y के बराबर नहीं है, आप [1, x-1] में एक यादृच्छिक संख्या चुन सकते हैं और फिर यह = = y होने पर वेतन वृद्धि कर सकते हैं। इस समस्या के लिए हम [1,6] में एक यादृच्छिक संख्या चाहते हैं जो f या 7-f के बराबर नहीं है। हमें दो टेस्ट ऑर्डर मिन (f, 7-f), मैक्स (f, 7-f) में करने होंगे।
शुरू में खाली वातावरण मानकर मैं इनिशियलाइज़ नहीं कर सकता और लूप की स्थिति को बदलकर 2 चार्ट बचा सकता था i++<10
अमन ZeeK वर्मा के जवाब से भारी गोल्फ
(; मैं (मैं = 10, च = 0 -;)) के लिए करते हैं ((n = f; n == f = n + f == 7; f = RANDOM% 6 + 1)): किया हुआ प्रिंटफ $ च किया हुआ
एनबी यकीनन यह पहली पंक्ति को बदलकर 5 वर्णों से सिकुड़ सकता है, for((;i++<10;))लेकिन यह ऐसी धारणाएं बनाता है जो हमेशा मान्य नहीं होती हैं। यह आइडोन में ठीक काम करेगा, लेकिन इसे शेल से चलाने वाला कोई व्यक्ति गैर-शून्य को निर्यात iया fनिर्यात कर सकता है ।
man bash, हालांकि, मैं इसकी सलाह देता हूं। मैंने एक बार इसे कवर करने के लिए कवर किया था, और बस जो संभव हो और देखने लायक था, का एक अस्पष्ट विचार मुझे अच्छी तरह से परोसा गया है।
-join(0..9|%{($d=1..6-ne(7-$d)-ne$d|random)})
सुंदर तुच्छ, वास्तव में। मैं संभावित पासा रोल की एक सूची तैयार करता हूं 1..6और फिर अंतिम रोल के बराबर नहीं केवल सात शून्य के बराबर का चयन करता हूं । शेष सूची से मैं फिर एक यादृच्छिक आइटम का चयन करता हूं और इसे असाइन करता हूं $d। चूंकि $dशुरू में 0इसका इलाज किया जाता है, क्योंकि यह पहली बार एक सामान्य मर जाता है।
टेस्ट स्क्रिप्ट:
for($i=0;$i-lt20;$i++){
$o=@(./tipping.ps1)
if ($i-gt0-and$o-eq$o2) { throw "Must have random output" }
if ($o.count-ne1) { throw "Must only have one line of output" }
if ($o[0]-match'[^1-6]'){ throw "Invalid characters" }
if($o[0].length-ne10){ throw "Wrong length: $($o[0].length)" }
$r=[char[]]($o[0])|%{$_-48}
for ($x=1;$x-lt$r.count;$x++){
if ($r[$x-1]+$r[$x]-eq7) { throw "Not a tipping: $($r[$x-1]) and $($r[$x])" }
}
$o2=$o
}
इतिहास:
The term 'random' is not recognized as a cmdlet, function, operable program, or script file. Verify the term and try again.
Get-RandomCmdlet v1 में मौजूद नहीं था।
यह काम करना चाहिए लेकिन दुर्भाग्य से J का यादृच्छिक जनरेटर 3 पुनरावृत्ति के बाद फंस गया:
a=:>:i.6
f=:a#~1-(+&(a=])7&-)
((,(?4)&{@f@(_1&{))^:9)>:?6
6 4 5 4 5 4 5 4 5 4
(?4)एक बार लुढ़क जाता है और यदि आप इसके आस-पास सावधान नहीं होते हैं तो इसे बाद के पुनरावृत्तियों के लिए एक स्थिर माना जाता है। मैंने इसके चारों ओर एक समान (?@4:)निर्माण का उपयोग करके काम किया ।
(0..9).reduce([]){|m|m<<((1..6).to_a-[d=m[-1]||0,7-d]).shuffle[0]}
>:(?@4:{(i.6)-.],5&-)^:(<10)?6
6 2 3 5 4 2 4 1 3 6
स्पष्टीकरण (दाईं से बाईं ओर पढ़ें):
?6 0 और 5 के बीच एक यादृच्छिक संख्या देता है^:(<10)एक समारोह को 9 बार लागू करता है, जिस तरह से परिणाम जमा करता है। समारोह है:?@4:{(i.6)-.],5&-
] , 5&- इनपुट नंबर की एक सरणी देता है और इसके पूरक 5 (हम वर्तमान में 0-आधारित संख्या को संभाल रहे हैं, इसलिए विपरीत चेहरों का योग 5 है)(i. 6) -. पूर्णांक 0 से 5 के पूर्ण सेट से उन्हें निकालता है। इनपुट स्थिति से एकल टैपिंग ऑपरेशन के बाद हम सभी वैध पदों से बचे हैं।?@4: { यादृच्छिक में से एक चुनता है।>: 1 से 6 के अंतराल पर आंकड़े वापस लाने के लिए पूरे अनुक्रम को बढ़ाता है।16 2f 25 08 41 20 17 30 16 2f 31 31 25 09 19 32
यहां देखिए यह कैसे काम करता है
16 2f 25 # make range from 1 to 6 and push random element
08 # start block
41 # duplicate top of stack twice
20 17 30 # negate top of stack and add 7
16 2f # push range from 1 to 6
31 31 # do set-wise difference with each of the two previous numbers
25 # push a random element from the list
09 # end block
19 32 # repeat block 9 times
For(I,1,9
Ans→X
Repeat Ans≠X and Ans≠7-X
randInt(1,6
End
Disp Ans
End
बोरिंग समाधान, लेकिन यह पिछले संशोधन से छोटा है। मैं इस तथ्य का लाभ उठाता हूं कि एक ताजा कैलकुलेटर पर, Ansशून्य से आरंभ किया जाता है।
v->{int d=(int)(Math.random()*6+1),i=10,p;String r=""+d;for(;i-->0;r+=d)for(p=d;p==d|p+d==7;d=(int)(Math.random()*6+1));return r;}वर्बोज़ मेन-मेथड के साथ पूर्ण कार्यक्रम के बजाय यह 178 बाइट्स होगा:
interface M{static void main(String[]a){int d=(int)(Math.random()*6+1),i=10,p;String r=""+d;for(;i-->0;r+=d)for(p=d;p==d|p+d==7;d=(int)(Math.random()*6+1));System.out.print(r);}}@AmanZeeKVerma के बैश जवाब का सेमी-पोर्ट ।
स्पष्टीकरण:
v->{ // Method with empty unused parameter and String return-type
int d=(int)(Math.random()*6+1),
// Random dice-roll 1-6
i=10, // Counter-integer, starting at 10
p; // Temp integer to store new side
String r=""+d; // Result-String, starting at the first dice-roll
for(;i-->0; // Loop (1) 10 times:
r+=d) // After every iteration, append the result with a random side
for(p=d; // Set the new side to the current side
p==d // Loop (2) as long as the new side and current side are the same
|p+d==7; // or as long as both combined are exactly 7:
d=(int)(Math.random()*6+1)
// Set the new side to a random side 1-6
); // End of loop (2)
// End of loop (1) (implicit / single-line body)
return r; // Return the result-String
} // End of methoda=randi(6)
for i=1:9;b=1:6;b([a,7-a])=[];a=b(randi(4))
end
मुझे खुशी है कि मैं यह प्रदर्शित कर सकता हूं कि मैं xइसे यहां देखकर याद नहीं करता।
a&0 v
/2v
1x3v
>x< <<
6x4v
\5v ~
:{:/ ^?=}
:{:/ ^?=7+}
:~$<^&;!?:-1&n
आप इसे इस ऑनलाइन दुभाषिया (पेस्ट कोड, सबमिट, स्टार्ट) पर आजमा सकते हैं ।
c(3,5,1,4,2,6)[(sample(1:6,1)+cumsum(sample((-2:2)[-3],9,T)))%%6+1]नहीं है एक golfier आर जवाब लेकिन यह मुझे लगता है कि अब तक प्रस्तुत जवाब से एक अलग दृष्टिकोण है।
c(3,5,1,4,2,6) #A dice and its facets
(sample(1:6,1) #Initial dice roll
+cumsum(sample((-2:2)[-3],9,T))) #9 tippings in c(-2,-1,1,2)
%%6+1 #converts to values in [0,6]
[ ]#6LΩUTFX?6LʒDXÊsX+7Ê*}ΩU
निश्चित रूप से गोल्फ हो सकता है, लेकिन मैं वर्तमान में इसे नहीं देख रहा हूं।
स्पष्टीकरण:
6LΩ # Pick a random value from the range [1,6]
# i.e. [1,2,3,4,5,6] → 3
U # Save this random value in variable `X`
TF # Loop 10 times:
X? # Print `X` without newline to STDOUT
6Lʒ } # Create a range [1,6] again, and filter it by:
DXÊ # Check if the current value is not equal to `X`
# i.e. 1 and 3 → 1 (truthy)
# i.e. 3 and 3 → 0 (falsey)
sX+ # Sum the current value with `X`
# i.e. 1 and 3 → 4
# i.e. 3 and 3 → 6
7Ê # And check if it's not equal to 7
# i.e. 4 and 7 → 1 (truthy)
# i.e. 6 and 7 → 1 (truthy)
* # If both checks are truthy, keep it in the filtered list
# i.e. 1 and 1 → 1 (truthy)
# i.e. 0 and 1 → 0 (falsey)
Ω # Pick a random value from the filtered list
# i.e. [1,2,5,6] → 1
U # And save it in variable `X` for the next iteration of the loop