Iterated पासा रोलिंग

12

एक इनपुट को देखते हुए , nजहां 3 <= n <= 25एक एकल- nमरने (सीमा में चेहरे [1, n], समावेशी) के साथ शुरू करते हुए, निम्न चरणों का पालन करें :

  1. वर्तमान- nचालित पासे को रोल करने के परिणाम के रूप में प्रिंट करें , फॉर्म में kdn: X(जहां Xपरिणाम है और kनाटक में पासा की संख्या है)।
  2. यदि खेल में पासा की संख्या Xसे अधिक या उससे अधिक है n/2, तो एक डाई जोड़ें। एल्स, एक डाई को हटा दें।
  3. यदि खेल में पासा की संख्या 0या के बराबर है n, तो रोकें। एल्स, चरण 1 पर जाएं।

उदाहरण चलता है (ध्यान दें कि कोष्ठक में आउटपुट स्पष्टीकरण के लिए है और इसकी आवश्यकता नहीं है):

6 पक्षीय:

1d6: 4 (avg: 3.0, add)
2d6: 6 (avg: 6.0, add)
3d6: 9 (avg: 9.0, add)
4d6: 16 (avg: 12.0, add)
5d6: 13 (avg: 15.0, remove)
4d6: 9 (avg: 12.0, remove)
3d6: 5 (avg: 9.0, remove)
2d6: 7 (avg: 6.0, add)
3d6: 11 (avg: 9.0, add)
4d6: 14 (avg: 12.0, add)
5d6: 17 (avg: 15.0, add)

9 पक्षीय:

1d9: 7 (avg: 4.5, add)
2d9: 14 (avg: 9.0, add)
3d9: 18 (avg: 13.5, add)
4d9: 18 (avg: 18.0, add)
5d9: 28 (avg: 22.5, add)
6d9: 26 (avg: 27.0, remove)
5d9: 28 (avg: 22.5, add)
6d9: 34 (avg: 27.0, add)
7d9: 33 (avg: 31.5, add)
8d9: 30 (avg: 36.0, remove)
7d9: 29 (avg: 31.5, remove)
6d9: 35 (avg: 27.0, add)
7d9: 32 (avg: 31.5, add)
8d9: 42 (avg: 36.0, add)

नियम

  • आउटपुट बिल्कुल प्रारूप में होना चाहिए kdn: X, जिसमें प्रत्येक रोल को अलग करने के लिए नई सुर्खियाँ हों
  • आप वास्तव में कई पासा रोलिंग अनुकरण करना चाहिए; [1, n]वर्तमान में खेलने में पासा की संख्या से गुणा (समावेशी) श्रेणी में एक यादृच्छिक पूर्णांक को वापस करने की अनुमति नहीं है, क्योंकि यह कई पासा को रोल करने का सही अनुकरण नहीं करता है।
  • मानक खामियों को मना किया जाता है
  • यह कोड-गोल्फ है , इसलिए बाइट्स में सबसे कम उत्तर जीतता है

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से लीडरबोर्ड उत्पन्न करता है) a) प्रति भाषा सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिखाई दे रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक स्कोर अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

कोड स्निपेट दिखाएं

code-golf  random 
— मै जाऊं
स्रोत
मुझे यह भ्रामक लगता है। उदाहरण उत्तर, कृपया?
— Hipe99
उदाहरण उत्तर , जैसा कि उदाहरण हैं।
— Hipe99
आपके संपादन को स्पष्ट किया गया। धन्यवाद!
— Hipe99
16
क्या आप अपने अंकगणित के बारे में निश्चित हैं? एक पारंपरिक d6 में औसतन 3.5 का रोल होता है।
— पीटर टेलर
11
आपके उदाहरण में सभी गलत प्रतीत होते हैं
— edc65

जवाबों:

3

मेथेमेटिका, 95 89 80 अक्षर

For[k=1,0<k<#,If[Print[k,d,#,": ",x=Tr[{1,#}~RandomInteger~k]];x<k/2#,k--,k++]]&

Ungolfed

For[
  k = 1,
  0 < k < #,
  If[
    Print[k, d, #, ": ", x = Tr[{1, #}~RandomInteger~k]];
    x < k/2 #,
    k--,
    k++
  ]
] &
— shrx
स्रोत
1
@ MartinBüttner आपके सुझाव के लिए धन्यवाद। Echoदुर्भाग्य से इनपुट्स का एक क्रम नहीं ले सकता Printहै।
— डे्रक्स
ओह, अच्छी बात है।
— मार्टिन एंडर
3

PHP, 164 121 112 113 109 बाइट्स

अंतिम संस्करण, मैं वादा करता हूँ। टाइटस के सुझाव का उपयोग कर सुधार:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x: $r\n";$y+=$r/$y>$x/2?:-1;$y<$x&&$y?d($x,$y):0;}

संपादित करें: स्वरूपण के लिए एक अतिरिक्त बाइट जोड़ा गया। वहां एक IF भूल गया है कि, "ऐड / सब" टेक्स्ट को छोड़ने के लिए धन्यवाद, एक टर्नरी ऑपरेटर हो सकता है:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x: $r\n";$r/$y>$x/2?$y++:$y--;if($y<$x&&$y)d($x,$y);}

आउटपुट अब जैसा दिखता है:

1d6: 5
2d6: 11
3d6: 8
2d6: 11
3d6: 7
2d6: 4
1d6: 5

संपादित करें: @ मैनटवर्क के लिए धन्यवाद, मुझे बहुत बचाया! नया और पुराना संस्करण:

function d($x,$y){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x=$r\n";if($r/$y>$x/2)$y++;else$y--;if($y<$x&&$y){d($x,$y);}}

पिछली प्रविष्टि:

function d($x,$y){for($i=0;$i<$y;$i++)($r+=rand(1,$x));$s=$y."d$x=$r, ";if($r/$y>$x/2){$y++;$s.="add";}else{$y--;$s.="sub";}echo $s."\n";if($y<$x&&$y>0){d($x,$y);}}`

रोल अलग मर जाता है, यह आउटपुट:

1d6=6, add
2d6=7, add
3d6=11, add
4d6=14, add
5d6=15, sub
4d6=15, add
5d6=18, add

और यह कहा जाता है: d(6, 1);

क्या प्रदर्शन Addऔर Subप्रत्यय अनिवार्य है? यह आपके प्रश्न से स्पष्ट नहीं है।

— steenbergh
स्रोत
आवश्यकता कहती है "ध्यान दें कि कोष्ठक में आउटपुट स्पष्टीकरण के लिए है और इसकी आवश्यकता नहीं है"। इस तरह से छोटा लगता है:function d($x,$y=1){for($i=$y;$i--;)$r+=rand(1,$x);echo$y."d$x, $r↵";$r/$y>$x/2?$y++:$y--;if($y<$x&&$y)d($x,$y);}
— manatwork
@manatwork धन्यवाद, आपने वास्तव में बहुत मदद की!
— स्टाइनबर्ग डे
अगर अभी भी एक बाइट हो सकती है, तो एक बाइट की बचत होगी। और वृद्धि / कमी को $y-=$r/$y>$x/2?:-1
— टाइटस
2

अजगर 3, 125

डीएसएम के लिए 3 बाइट्स को सहेजा गया।

def x(d):
 import random;c=1
 while 0<c<d:r=sum(map(random.randint,[1]*c,[d]*c));print('%id%i: %i'%(c,d,r));c+=2*(r>=d*c/2)-1

बहुत सरल, पासा का एक गुच्छा रोल करता है और औसत की जांच करता है। अभी तक यहां कुछ भी नहीं फैंसी।
इसे इंट के साथ बुलाया जाना चाहिए। तो, x(6)कुछ इस तरह का उत्पादन होगा:

1d6: 5
2d6: 10
3d6: 8
2d6: 7
3d6: 11
4d6: 8
3d6: 13
4d6: 19
5d6: 13
4d6: 15
5d6: 22

।

— मॉर्गन थ्रैप
स्रोत
2

जावास्क्रिप्ट (ईएस 6), 97 102 106 112 बाइट्स

धन्यवाद @ user81655 और मुझे कुछ बाइट्स बचाने के लिए @Jupotter।

f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=k;i--;)x+=Math.random()*n|0}

// 102 bytes:
f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=0;++i<=k;)x+=1+Math.random()*n|0}

// Previous attempt, 112 bytes
f=n=>{k=1;while(k&&k!=n){for(x=i=0;i++<=k;)x+=1+~~(Math.random()*n);console.log(k+`d${n}: `+x);k+=x<k*n/2?-1:1}}

डेमो

यह केवल ES6 अनुरूप ब्राउज़रों में काम करता है (फिलहाल फ़ायरफ़ॉक्स और एज शामिल है, संभवतः क्रोम और ओपेरा के साथ प्रयोगात्मक जावास्क्रिप्ट सुविधाओं के साथ सक्षम हैं):

f=n=>{for(k=1;k%n;console.log(k+`d${n}: `+x),k+=x<k*n/2?-1:1)for(x=i=k;i--;)x+=Math.random()*n|0}

// Snippet stuff
console.log = x => {
  document.getElementById('O').innerHTML += x + `<br>`;
}

document.getElementById('F').addEventListener('submit', e => {
  document.getElementById('O').innerHTML = ``
  f(document.getElementById('I').valueAsNumber)
})
<form id=F action=# method=get>
  <label>
    Number of faces: 
    <input type=number min=3 max=25 value=9 required id=I>
  </label>
  <button>Play</button>
  
  <div>
    <output id=O></output>
  </div>
</form>
स्निपेट का विस्तार करें

— rink.attendant.6
स्रोत
आप whileएक forलूप को बदल सकते हैं , |0इसके बजाय नीचे राउंड ~~()कर सकते हैं और कुछ स्टेटमेंट ले सकते हैं ताकि आप कुछ बाइट्स को बचाने के लिए कोष्ठक को हटा सकें। इसके अलावा, आपको इसे एक अनाम फ़ंक्शन (नहीं f=) बनाने की अनुमति है । 103 बाइट्स:n=>{for(k=1;k&&k!=n;k+=x<k*n/2?-1:1)for(x=i=0;i++<=k;console.log(k+`d${n}: `+x))x+=1+Math.random()*n|0}
— user81655
@ user81655 धन्यवाद। किसी कारण से आपके संस्करण ने बहुत अधिक बाहरी उत्पादन किया, इसलिए मैं console.logदूसरे forलूप में चला गया (लागत मुझे आपकी तुलना में 1 चार्ट अधिक)। फिर भी इसे
— घटाकर
मैंने अभी इसे बिना जांचे-परखे लिखा है, इसलिए मुझे खुशी है कि यह ज्यादातर काम आया। :)
— user81655
आप k&&k!=nतुलना द्वारा स्थिति को बदलकर एक पात्र प्राप्त कर सकते हैंk%n!=0
— जुपिटर
@Jupotter धन्यवाद, और k%nभी बेहतर काम करता है;)
— rink.attenders.6 14
1

सीजेएम, 45 बाइट्स

ri:M;{X__{Mmr+}*[X'dM':S5$N]o_+XM*<_+(-:XM%}g

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

युक्ति का शाब्दिक रूप से क्रियान्वयन (गणितीय रूप से गलत "माध्य रोल" सूत्र सहित)। बिल्ट-इन कमांड के नाम (कम की वजह से उम्मीद थी, CJam लिए नीचे दिए गए मूल GolfScript कार्यक्रम पोर्टिंग बाइट्स की एक गुच्छा बचाया mr, oऔर gके बजाय rand, putsऔर do)।

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

~:&;{1..{&rand+}*[1"d"&": "4$]puts.+1&*<.+(-:1&%}do

यहाँ मेरी मूल गोल्फस्क्रिप्ट प्रविष्टि है। उल्लेखनीय गोल्फ ट्रिक्स में नंबर का उपयोग करने के लिए 1आसानी से पूर्व-प्रारंभिक चर के रूप में नंबर का उपयोग करके रोल की जाने वाली पासा की वर्तमान संख्या को संग्रहीत करना शामिल है। (CJam संस्करण इसके बजाय उपयोग करता है X, जिसे CJam मान 1 से प्रारंभ करता है )

Ps। शीर्षक देखकर, मैं मूल रूप से AnyDice में इसका जवाब देना चाहता था । लेकिन यह इस चुनौती के लिए एक भयानक विकल्प है, और मुझे नहीं लगता कि यह तकनीकी रूप से इस युक्ति को लागू करने के लिए उपयोग करना संभव है।

समस्या यह है कि AnyDice डाइस रोलिंग आँकड़ों की गणना के लिए नियतात्मक कार्यक्रम लिखने के लिए एक डोमेन-विशिष्ट भाषा है । जबकि एक रोल के संभावित परिणामों का निरीक्षण और उन पर आधारित सशर्त रोल कर रही है प्रत्यावर्तन के माध्यम से संभव है, वहाँ कोई रास्ता नहीं है किसी भी वास्तविक अनियमितता उत्पन्न करने के लिए है। इसलिए जब तक आप AnyDice में पासा रोल के इस क्रम का अनुकरण कर सकते हैं, आप सभी प्राप्त कर सकते हैं क्योंकि आउटपुट चीजों पर आंकड़े हैं, जैसे कि, प्रक्रिया समाप्त होने तक रोल की संख्या, या किसी दिए गए कदम पर परिणामों का वितरण।

सभी ने कहा कि, मैं यहां AnyDice में निकटतम हो सकता हूं :

N: 6
K: 1
function: clip X:n { result: X * (X < N) }
function: adjust X:n { result: [clip X + ((XdN)*2 >= X*N)*2-1] * (X > 0) }
loop I over {1..20} {
  output K named "dice in roll [I]"
  output KdN named "outcome of roll [I]"
  K: [adjust K]
}

यह विशेष रूप से गोल्फ कोड नहीं है, क्योंकि यह निरर्थकता में एक व्यायाम की तरह लग रहा था। मानक ब्रेस भाषा गोल्फिंग ट्रिक्स, फ़ंक्शन नामों को छोटा करने और अनावश्यक व्हाट्सएप को खत्म करने की तरह, वैसे भी अधिकांश गोल्फिंग क्षमता को समाप्त करना चाहिए।

यहां उपयोग की जाने वाली प्रमुख ट्रिक यह है कि जब आप किसी फ़ंक्शन को किसी भी नंबर (जैसे कि :nफंक्शन डेफिनेशन में संकेतित परिभाषा के अनुसार) को AnyDice में कॉल करते हैं, और इसे एक डाई (यानी एक प्रायिकता वितरण) के बजाय पास करते हैं, तो AnyDice स्वचालित रूप से सभी संभावित फ़ंक्शन का मूल्यांकन करता है। मरने के मूल्य , और परिणामों को एक नई मौत में जोड़ती है।

यहां पहले तीन रोल के लिए आउटपुट (बार चार्ट फॉर्मेट में) का स्क्रीनशॉट दिया गया है:

AnyDice स्क्रीनशॉट

(ध्यान दें कि प्रत्येक ग्राफ़ में "0" कॉलम संभावना को इंगित करता है कि चालू रोल से पहले या तो 0 या N, पासा मारने की संख्या के कारण पुनरावृति बंद हो गई । यह रोक स्थिति का प्रतिनिधित्व करने के लिए एक सुविधाजनक तरीका है, क्योंकि यह तब से है। निश्चित रूप से रोलिंग 0dN हमेशा उपज 0.)

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

आर, 103 बाइट्स

एक काफी सीधे आगे कार्यान्वयन। डाइस रोल द्वारा किया जाता है sum(sample(n,i))।

i=1;n=scan();while(i&i<=n){cat(i,'d',n,': ',s<-sum(sample(n,i)),'\n',sep='');i=ifelse(s<i*n/2,i-1,i+1)}

परीक्षण चालन

> i=1;n=scan();while(i&i<=n){cat(i,'d',n,': ',s<-sum(sample(n,i)),'\n',sep='');i=ifelse(s<i*n/2,i-1,i+1)}
1: 9
2: 
Read 1 item
1d9: 9
2d9: 14
3d9: 10
2d9: 14
3d9: 9
2d9: 9
3d9: 12
2d9: 7
1d9: 9
2d9: 11
3d9: 17
4d9: 18
5d9: 25
6d9: 29
7d9: 33
8d9: 43
9d9: 45
>
— MickyT
स्रोत
1

कॉफ़ीस्क्रिप्ट, 106 99 बाइट्स

f=(n,k=1)->(x=k;x+=Math.random()*n|0for[k..0];console.log k+"d#{n}: "+x;k+=x<k*n/2&&-1||1)while k%n

# Previous attempt, 106 bytes
f=(n,k=1)->(x=i=0;x+=1+Math.random()*n//1while++i<=k;console.log k+"d#{n}: "+x;k+=x<k*n/2&&-1||1)while k%n

Ungolfed

f = (n, k = 1) ->
 (x = k
 x += 1 + Math.random() * n | 0 for [k..0]
 console.log k + "d#{n}: " + x
 k += x < k * n / 2 && -1 || 1
 ) while k % n
— rink.attendant.6
स्रोत
1

जूलिया, 77 बाइट्स

n->(N=1;while 0<N<n k=sum(rand(1:n,N));print(N,"d$n: $k
");N+=1-2(2k<N*n)end)

इसमें से अधिकांश स्व-व्याख्यात्मक होना चाहिए - एक वास्तविक न्यूलाइन का printउपयोग printlnबाइट को बचाने के लिए उपयोग करने के बजाय स्ट्रिंग में किया जा रहा है । 1 और के बीच यादृच्छिक पूर्णांक rand(1:n,N)बनाता है ।Nn

— ग्लेन हे
स्रोत
1

रूबी, 93 90 82 वर्ण

->n{d=s=2
puts"#{d}d#{n}: #{s=eval'+rand(n)+1'*d}"while(d+=s<d*n/2.0?-1:1)>0&&d<n}

नमूना रन:

2.1.5 :001 > -->n{d=s=2;puts"#{d}d#{n}: #{s=eval'+rand(n)+1'*d}"while(d+=s<d*n/2.0?-1:1)>0&&d<n}[6]
1d6: 5
2d6: 10
3d6: 6
2d6: 5
1d6: 5
2d6: 8
3d6: 15
4d6: 18
5d6: 22
— आदमी काम पर है
स्रोत
0

QBIC , 83 बाइट्स (गैर-प्रतिस्पर्धात्मक)

:c=a{e=0[1,q|e=e+_rq,a|]?!q$+@d|!+a$+@:|+!e$~e<c/2|q=q-1\q=q+1]c=q*a~q=a|_X]~q=0|_X

स्पष्टीकरण:

q                    Tracks the number of dice (is implicitly 1 at the start)
:                    Takes input from a CMD line parameter
[1,q|e=e+_rq,a|]     Rolls the dice separately
?!q$+@d|!+a$+@:|+!e$ Prints the roll result (requires an unfortunate amount of casting...)
~e<c/2|q=q-1\q=q+1]  Checks whether to increase or decrease
~q=a|_X]~q=0|_X      Tests the amount of dice and quits on either boundary.
— steenbergh
स्रोत
0

PHP, 104 बाइट्स

for($n=$argv[$k=1];$k&&$k<$n;print$k."d$n: $x\n",$k-=$x<$n*$k/2?:-1)for($x=$i=0;$i++<$k;)$x+=rand(1,$n);

साथ दौड़ो php -r '<code>' <N>

टूट - फूट

for($n=$argv[$k=1];     // import input, init number of dice
    $k&&$k<$n;          // while 0<$k<$n
    print$k."d$n: $x\n",    // 2. print results
    $k-=$x<$n*$k/2?:-1      // 3. remove or add a die
)
    for($x=$i=0;$i++<$k;)   // 1. roll dice separately
        $x+=rand(1,$n);         // sum up results
— टाइटस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.