किसी सरणी से यादृच्छिक रूप से चुनें

19

यह चुनौती बल्कि सरल है:
आपको पूर्णांक में सकारात्मक (नहीं सहित) पूर्णांक दिया जाता है, और इस सरणी से एक यादृच्छिक तत्व का चयन करना होता है।

लेकिन यहाँ एक मोड़ है:
एक तत्व के चयन की संभावना पूर्णांक के मूल्य पर निर्भर करती है, जिसका अर्थ है कि पूर्णांक बड़ा हो जाता है, इसके चयनित होने की संभावना भी बढ़ जाती है!

उदाहरण

आपको सरणी दी जाती है [4, 1, 5]।

4 के चयन की संभावना इस मामले में, सभी तत्वों के योग से विभाजित 4 के बराबर है 4 / ( 4 + 1 + 5 ) = 4 / 10 =40%।
1 का चयन करने की संभावना है 1 / 10या 10%।

इनपुट

सकारात्मक पूर्णांक की एक सरणी।

उत्पादन

किसी विधि का उपयोग करते समय चयनित पूर्णांक लौटाएं, या सीधे इसे प्रिंट करें stdout।

नियम

  • यह किसी भी भाषा की जीत में बाइट्स में कोड-गोल्फ इतना छोटा कोड है।
  • मानक खामियों को मना किया जाता है।
code-golf  array-manipulation  random 
— इयान एच।
स्रोत

जवाबों:

20

जेली , 3 बाइट्स

x`X

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

देखो 'मा, नो यूनिकोड!

स्पष्टीकरण:

x`X
 `  Make monad from dyad and use same left and right arguments
x   Repeat each element of the left argument (implicit) list its respective number of times in the right argument list
  X Random element
— आउटग्रॉफर को एरिक करें
स्रोत
1
क्या आप बता सकते हैं कि आपका कोड क्या करता है? :)
— इयान एच।
1
@IanH। यह वास्तव में एक सरल एल्गोरिथ्म है जो प्रत्येक तत्व को स्वयं बार-बार दोहराता है फिर बेतरतीब ढंग से चुनता है।
— आउटगॉल्फ
16

आर , 25 बाइट्स

function(s)sample(s,1,,s)

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

स्पष्टीकरण:

function(s){
 sample(x = s, size = 1, replace = FALSE, prob = s)
}

वजन के साथ, प्रतिस्थापन के बिना sआकार से एक नमूना लेता है ; ये संभाव्यता होने के लिए rescaled हैं।1s

वितरण को सत्यापित करने के लिए, इस लिंक का उपयोग करें ।

— ग्यूसेप
स्रोत
आपने मुझे 9 महीने तक हरा दिया! : D
— JayCe
@ जय हे, तुम पर मेरा एकमात्र लाभ "पहले जा रहा है" लगता है जैसे आप काफी गोल्फर हो! :-)
— Giuseppe
13

अजगर , 4 बाइट्स

OsmR

इसे यहाँ आज़माएँ।

एक बाइट को बचाया, @ जकुबे के लिए धन्यवाद, बल्कि एक असामान्य दृष्टिकोण के साथ।

अजगर , 5 बाइट्स

Osm*]

यहाँ कोशिश करो!

कैसे?

# 1

OsmR - पूर्ण कार्यक्रम।

   आर - सही नक्शा ...
  m - ... मानचित्र का उपयोग करना। यह अनिवार्य रूप से सूची [[4,4,4,4], [1], [5,5,5,5,5]] बनाता है।
       - ... क्रेडिट इसके लिए जकुबे को जाता है!
 s - चपटा।
हे - ^ का यादृच्छिक तत्व। स्पष्ट रूप से प्रदर्शित करें।

# 2

ऑसम *] - पूर्ण कार्यक्रम।

  मी - इनपुट पर नक्शा।
    ] - वर्तमान तत्व, डी, लिपटे; [घ]।
   * - बार-बार डी।
 s - चपटा।
ओ - यादृच्छिक तत्व। परिणाम को स्पष्ट रूप से प्रिंट करें।
— श्री Xcoder
स्रोत
1
मैं इसे 4 में कर सकता हूं। क्या मुझे इसे खराब करना चाहिए, या क्या आप इसे खुद से ढूंढना चाहते हैं?
— याकूब
2
@ जाकुब एक छोटी सी प्रतीक्षा करें। अगर मैं यह कर सकता हूँ देखना चाहते हैं। यह है कि स्पष्ट?
— श्री एक्सकोडर
1
@ जकुब ओके, जब मैं हार मानूंगा तो पिंग करूंगा।
— मिस्टर एक्सकोडर
1
OsmLयाOsmR
— जकुबे
1
@ जाकुब ऊह जो बहुत चालाक है! निहित तर्क d, फिर dएक सीमा से अधिक नक्शे ... प्रतिभा!
— एरिक आउटग्राफर
8

CJam (9 बाइट्स)

q~_]ze~mR

ऑनलाइन डेमो । यह एक पूर्ण कार्यक्रम है जो स्टड पर CJam सरणी प्रारूप में इनपुट लेता है और चयनित तत्व को stdout में प्रिंट करता है।

विच्छेदन

q~   e# Read and parse input
_]z  e# Copy and transpose
e~   e# Run-length decode
mR   e# Select random element uniformly
— पीटर टेलर
स्रोत
1
इतने आसान काम के लिए इतना शक्तिशाली गोल्फ।
— को आउटगॉल्फ
7

पर्ल 6 , 20 बाइट्स

@ ब्रेड गिल्बर्ट b2gills के लिए 1 बाइट धन्यवाद। 

{bag(@_ Zxx@_).pick}

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

यह 1 सूची तर्क लेता है। हम xxऑपरेटर का उपयोग करके इस सूची की 2 प्रतियों को ज़िप करते हैं । तो @_ Zxx@_, हम एक सूची प्राप्त करते हैं जिसमें तत्व xको xबार प्रस्तुत किया जाता है। इसके बाद इसका उपयोग किया जाता है Bag, जो एक संग्रह है जो संग्रह में कितनी बार दिखाई देने के साथ वस्तुओं को संग्रहीत करता है। अंत में, हम इस संग्रह से एक यादृच्छिक तत्व चुनते हैं pick, जो कि गणना को ध्यान में रखता है और द राइट थिंग ™ करता है।

— Ramillies
स्रोत
इसे छोटा किया जा सकता है{bag(@_ Z=>@_).pick}
— ब्रैड गिल्बर्ट b2gills
@ ब्रैडगिल्बर्ब 2 जील्स, दुख की बात है कि काम नहीं करता है। यह जोड़े से एक बैग बनाता है (इसलिए एक बार "1" नहीं होगा, "2" दो बार आदि, लेकिन "1 => 1" एक बार, "2 => 2" एक बार भी - आदि) जो मैं चाहता हूं नहीं। । ऐसा इसलिए है क्योंकि संगीतकार इस एडवेंचर कैलेंडर में बताए गए अनुसार जबरदस्त नहीं हैं ।
— रामलीज
@ ब्रैडगिल्बर्ब २गिल्स, लेकिन फिर भी धन्यवाद, आपने मुझे कुछ स्थानों पर और अन्य चुनौतियों में भी गोल्फ में मदद की!
— रामलीज
मेरा मतलब था{bag(@_ Zxx@_).pick}
— ब्रैड गिल्बर्ट b2gills
आह, मैं देख रहा हूं। यह मेरे लिए क्यों नहीं हुआ ...: -) धन्यवाद।
— रामलीज
4

जावा (ओपनजेडके 8) , 88 87 86 83 बाइट्स

a->{int r=0,x=-1;for(int i:a)r-=i;for(r*=Math.random();r<1;)r+=a[++x];return a[x];}

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

— Nevay
स्रोत
क्या आप एक स्पष्टीकरण जोड़ सकते हैं? मैं यह समझने की कोशिश कर रहा हूं कि for(r*=Math.random();;)आवश्यकता क्यों है, या यदि आप सभी की आवश्यकता है r*=Math.random()।
— 19b पर Ayb4btu
@ Ayb4btu for(;;)लूप के बिना for(int i:a)...कंपाइलर को संतुष्ट करने के लिए एक दूसरे (कभी नहीं पहुंचे) रिटर्न स्टेटमेंट की आवश्यकता होगी - जो 3 बाइट्स लंबा होगा।
— नेवई
आह, बेशक, आपका सी # में for(int i:a)एक जैसा है foreach। मैं एक ही समस्या थी, लेकिन सिर्फ एक है forकि लगातार छोरों का इस्तेमाल किया । आपका नया उत्तर मुझे साज़िश करता है, मैं आपके कुछ विचारों की कोशिश कर सकता हूँ।
— Ayb4btu
3

जे, 8 7 8 बाइट्स

7 बायटर अमान्य है; जब मैं एक या दो दिन में अपने कंप्यूटर पर वापस आऊंगा तो मैं इसे पिछले संपादन में वापस लाऊंगा।

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

?@+/{#~

:( एक सरणी से यादृच्छिक तत्वों का चयन करना महंगा है।

8 बाइट्स

#~{~1?+/

9 बाइट्स

(1?+/){#~

व्याख्या

?@+/{#~
?        Choose random number in range
  +/     Sum of the array
    {    Select that element from
     #~  The elements duplicated as many times as their value
— गोभी
स्रोत
?@+/है (?@+)/; मुझे डर है कि आपको 8 तक फिर से टक्कर लेनी पड़ेगी ...
— FireFly
@ पूरी तरह से मैं इसे और अधिक, अच्छी पकड़ का परीक्षण करना चाहिए था।
— कोल
3

जावास्क्रिप्ट (ईएस 6), 50 बाइट्स

a=>a.sort((a,b)=>b-a)[Math.random()**2*a.length|0]

उम्मीद है कि यह स्पष्ट है कि यह कैसे काम करता है, लेकिन मैं इसे यहाँ वैसे भी समझाता हूँ। यह पूर्णांक में अवरोही क्रम में सॉर्ट करता है, फिर बीटा डिस्टर्ब्यूशन (1 / 2,1) के साथ यादृच्छिक पर एक को चुनता है ।

— kamoroso94
स्रोत
मुझे नहीं लगता कि इसका सही वितरण होगा। मेरे परीक्षणों से पता चलता है कि a=[4,1,5], आपको लगभग 18% 1, 24% 4और 58% 5मिलेंगे, जो बताता है कि आप उस वितरण को लंबाई के किसी भी इनपुट के साथ प्राप्त करेंगे 3.
— Giuseppe
यह मुझे सही लगता है। उच्च पूर्णांक, उच्च संभावना।
— kamoroso94
ओह मैं समझा। मैंने सवाल को गलत बताया। उत्कृष्ट समाधान, +1!
— ग्यूसेप
2

पॉवरशेल , 27 बाइट्स

($args[0]|%{,$_*$_})|Random

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

इनपुट $args[0]को शाब्दिक सरणी के रूप में लेता है । प्रत्येक तत्व |%{...}और प्रत्येक पुनरावृत्ति के माध्यम से लूप तत्वों ,$_की एक नई सरणी का निर्माण करते $_हैं - जैसे, इसके लिए 4एक सरणी बनाएंगे @(4,4,4,4)। उन सरणी तत्वों को तब पाइप किया जाता है Get-Randomजिसमें समान संभावना वाले तत्वों (छद्म) में से एक को बाहर निकाल दिया जाएगा। चूंकि, उदाहरण के लिए, @(4,1,5)यह हमें @(4,4,4,4,1,5,5,5,5,5)संभावना आवश्यकताओं को संतुष्ट करता है।

— AdmBorkBork
स्रोत
2

सी # (.NET कोर) , 93 89 87 76 + 18 = 94 बाइट्स

a=>{int i=-1,r=new Random().Next(a.Sum());while(r>=0)r-=a[++i];return a[i];}

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

के लिए एक अतिरिक्त 18 बाइट्स using System.Linq;

स्वीकृतियाँ

11 बाइट्स नेवी के लिए धन्यवाद को बचाया, जिसका यादृच्छिक संख्या कार्यान्वयन बहुत अधिक संक्षिप्त था (साथ ही साथ एक के intबजाय double)।

Degolfed

a=>{
    int i=-1,
    r=new Random().Next(a.Sum());
    while(r>=0)
        r-=a[++i];
    return a[i];
}

व्याख्या

rतत्वों के 0 और योग के बीच , एक यादृच्छिक संख्या प्राप्त करें । फिर प्रत्येक पुनरावृत्ति पर वर्तमान तत्व को घटाना r। अगर rतुलना में कम है 0, तो यह तत्व लौट आते हैं। विचार यह है कि सरणी में बड़ी संख्या के लिए यादृच्छिक संख्या के बड़े हिस्से हैं।

— Ayb4btu
स्रोत
94 बाइट्स:a=>{int i=-1,r=new Random().Next(a.Sum());for(;r>=0;)r-=a[++i];return a[i];}
— नेवई
2

जाप , 7 बाइट्स

ËÆD
c ö

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

व्याख्या

सरणी का निहित इनपुट U।

Ë

प्रत्येक तत्व को फ़ंक्शन के माध्यम से पास करने वाले सरणी पर मैप करें जहां Dवर्तमान तत्व है।

ÆD

लंबाई की एक सरणी उत्पन्न करें Dऔर इसे भरें D।

c

समतल।

ö

एक यादृच्छिक तत्व प्राप्त करें।

— झबरा
स्रोत
1

पर्ल, 31 बाइट्स

@a=map{($_)x$_}@ARGV;$a[rand@a]

यह इनपुट को कमांड लाइन आर्ग्युमेंट्स मानता है। ध्यान दें कि यदि संख्या बड़ी है, तो यह मेमोरी से बाहर हो सकती है।

1

चारकोल , 12 बाइट्स

Ｆ⪪θ;ＦＩι⊞υι‽υ

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

  θ             Input variable as string
 ⪪ ;            Split on semicolons
Ｆ               Loop i over each string
     Ｉι         Cast i to integer
    Ｆ           Repeat that many times
       ⊞υι      Push i to (originally empty) list
          ‽υ    Random selection from list
                Implicitly print
— नील
स्रोत
1

जावास्क्रिप्ट (ईएस 6), 61 54 बाइट्स

-7 बाइट्स @Justin मेरिनर को धन्यवाद

a=>a.find(m=>(n-=m)<0,n=Math.random()*eval(a.join`+`))

उदाहरण कोड स्निपेट

f=
a=>a.find(m=>(n-=m)<0,n=Math.random()*eval(a.join`+`))
console.log(f([4,1,5]))
स्निपेट का विस्तार करें

— हरमन एल
स्रोत
के eval(a.join`+`)बजाय का उपयोग करके आप योग कर सकते हैं reduce।
— जस्टिन
यदि आप ES7 + के साथ ठीक हैं, तो आप का उपयोग कर सकते हैं: [].find(m=>(n-=m)<0,n=Math.random()*eval(a.join+ ))और साथ कॉल करेंinput::[].find(...)
— डाउनगेट
1

हास्केल , 78 77 बाइट्स

import System.Random
f l=randomRIO(0,sum l-1)>>=pure.((l>>= \n->n<$[1..n])!!)

इसे ऑनलाइन आज़माएं! उपयोग उदाहरण: f [1,99]शायद पैदावार 99।

स्पष्टीकरण:

  • fपूर्णांकों की सूची लेता है lऔर यादृच्छिक रूप से चयनित पूर्णांक देता है IO Int।
  • l>>= \n->n<$[1..n]nबार- nबार प्रत्येक तत्व के साथ एक सूची बनाता है।
  • randomRIO(0,sum l-1) दोहराया तत्वों की सूची की लंबाई से 0 से सीमा में एक पूर्णांक उत्पन्न करता है, जो कि सभी अपवादों का योग है, एक अपवाद को बाहर करने से बचने के लिए शून्य से एक।

बोनस: 85 बाइट बिंदु-मुक्त संस्करण

import System.Random
(>>=).randomRIO.(,)0.pred.sum<*>(pure.).(!!).(>>= \n->n<$[1..n])

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

— Laikoni
स्रोत
1

बैश , 51 बाइट्स

for n in $@;{ printf $n\\n%.s `seq $n`;}|shuf|sed q

एक तर्क या एक से अधिक तर्कों में स्थान-पृथक या न्यूलाइन-पृथक इनपुट लेता है।

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

अधिक जटिल परीक्षण मामले के साथ यादृच्छिक आवृत्तियों को मान्य करें ।

— जस्टिन मेरिनर
स्रोत
1

जावा 8, 127 122 121 बाइट्स

import java.util.*;a->{List l=new Stack();for(int i:a)for(int j=i;j-->0;Collections.shuffle(l))l.add(i);return l.get(0);}

-1 बाइट @Nevay को धन्यवाद ।

सूची में आइटम को कई बार जोड़कर @ErikTheOutgolfer के जेली उत्तर के रूप में एक समान दृष्टिकोण का उपयोग करता है , और फिर उस सूची में से किसी एक का चयन करें।nn

स्पष्टीकरण:

इसे यहाँ आज़माएँ।

import java.util.*;        // Required import for List, Stack and Collections
a->{                       // Method with integer-array parameter and integer return-type
  List l=new Stack();      //  Create a List
  for(int i:a)             //  Loop (1) over the input array
    for(int j=i;j-->0;     //   Inner loop (2) from `i` down to 0
        Collections.shuffle(l))
                           //   and shuffle the List randomly after every iteration
      l.add(i);            //    Add `i` that many times to List `l`
                           //   End of inner loop (2) (implicit / single-line body)
                           //  End of loop (1) (implicit / single-line body)
  return l.get(0);         //  And then return the first item of the list
}                          // End of method
— केविन क्रूज़सेन
स्रोत
1
आप #shuffle1 बाइट को बचाने के लिए कॉल को लूप में स्थानांतरित कर सकते हैं for(int j=i;j-->0;Collections.shuffle(l))l.add(i);।
— नेवे
@ नवीन धन्यवाद! प्रत्येक पुनरावृत्ति के बाद सूची को फेरबदल करना काफी अक्षम है, लेकिन हम दक्षता, चेतावनियों और इस तरह की परवाह करते हैं जब हम एक अतिरिक्त pesky बाइट से छुटकारा पा सकते हैं। ; पी
— केविन क्रूज़सेन 15'17
1

जीएनयू एपीएल 1.2, 26 23 बाइट्स; 1.7 21 19 बाइट्स

एग्री द आउटगॉल्फ के जेली उत्तर से प्रेरित दृष्टिकोण । ⎕IO1 के बजाय 0 होने पर निर्भर करता है , जो जीएनयू एपीएल के लिए डिफ़ॉल्ट है (इसके लिए +5 बाइट्स की तरह ⎕IO←0)।

-3, -2 बाइट्स @ ज़ाचरी को धन्यवाद

∇ समारोह का रूप

∇f R
S[?⍴S←∊0 0⍉R∘.⍴R]∇

अनाम लंबोदर रूप

{S[?⍴S←∊0 0⍉⍵∘.⍴⍵]}

स्पष्टीकरण के लिए, मैं ⍵फ़ंक्शन को दिए गए तर्क का प्रतिनिधित्व करने के लिए उपयोग करूंगा , लेकिन यह फ़ॉर्म Rमें बराबर है ∇।

⍵∘.⍴⍵सूची पर बाहरी उत्पाद को रेज़ैप ( ⍴) ऑपरेटर का उपयोग करके गणना करता है । प्रभावी रूप से, यह एक तालिका बनाता है (गुणा तालिका की तरह) लेकिन गुणा करने के बजाय, यह पंक्ति में तत्व के बराबर कई बार कॉलम में तत्व को दोहराता है। प्रश्न में दिए गए उदाहरण के लिए, यह है:

4 4 4 4    1 1 1 1    5 5 5 5   
4          1          5         
4 4 4 4 4  1 1 1 1 1  5 5 5 5 5

0 0⍉⍵∘.⍴⍵मैट्रिक्स को स्थानांतरित करता है और सिर्फ मुख्य विकर्ण देता है। यह हमें केवल उन भागों को देता है जहां पंक्ति और स्तंभ ⍵∘.⍴⍵समान थे यानी हमने कई बार इसके मूल्य के बराबर संख्या दोहराई थी। उदाहरण के लिए, यह है:

4 4 4 4  1  5 5 5 5 5

∊अपने तर्क को सूची में बदल देता है। ट्रांसपोज़ ( ⍉) ऑपरेटर का उपयोग करके , हमें एक वेक्टर मिला जिसमें 3 वैक्टर थे। एनलिस्ट ( ∊) सभी तत्वों वाले एकल वेक्टर में बदल जाता है।

S←...इस नए वेक्टर को वेक्टर को सौंपता है S। ⍴Sहमें उस सूची की लंबाई देता है। ?यादृच्छिक ऑपरेटर है, इसलिए ?⍴Sहमें 0 और सूची की लंबाई (अनन्य) के बीच एक यादृच्छिक संख्या देता है (यही कारण है कि यह ⎕IO0 पर निर्भर करता है ; अन्यथा यह 1 और लंबाई, समावेशी के बीच है)। S[...]दिए गए इंडेक्स में तत्व देता है।

— Arc676
स्रोत
आपको इसकी आवश्यकता नहीं है Q, क्योंकि आप इसका उपयोग कभी नहीं करते हैं। और IIRC आप डेल (छोटी त्रिभुज-चीज़ को फंक्शन के अंत को चिन्हित करते हुए) से पहले न्यूलाइन को हटा सकते हैं।)
— Zacharý
वाह, मैं <IO> <IO>⍉मुख्य विकर्ण पाने के लिए कभी भी नया नहीं था यहां तक ​​कि एक चीज भी थी!
— ज़ाचारि
@ Zacharý अधिकार, धन्यवाद। सच कहूँ तो, मैं भी ट्रांसपोज़ चीज़ के बारे में नहीं जानता था जब तक कि मैंने इस कार्य की कोशिश नहीं की। इसे यहां
— 2:67 पर Arc676
ओह, GNU की तुलना में बहुत बेहतर मुक्त APL मौजूद है, इसे ngn APL कहा जाता है। यह वास्तव में बहुत अच्छा है! ( ngn.github.io/apl/web , लेकिन इसमें ट्रेडफ़न नहीं है)
— ज़ाचारि
@ Zacharý मेरे पास वह भी एक है :) दुर्भाग्य से ट्रांसपोज़ फंक्शन काम नहीं करता (या मुझे कुछ याद नहीं है)। मैं अब फिर से इसका परीक्षण करूंगा कि मुझे इस बात की बेहतर समझ है कि यह कैसे काम करता है।
— Arc676
1

MATLAB, 30 बाइट्स

@(a)datasample(repelem(n,n),1)

यह MATLAB R2015A या नए और सांख्यिकी और मशीन लर्निंग टूलबॉक्स स्थापित के साथ मानता है।

repelemउपयोग कैसे किया जाता है, इसके लिए नीचे दिया गया विवरण देखें । इस छोटे से एक के बीच का अंतर यह है कि एस एंड एमएल टूलबॉक्स में फ़ंक्शन शामिल होता है datasampleजिसका उपयोग यादृच्छिक पर एक समान या एक से अधिक तत्वों को लेने के लिए किया जा सकता है (एक समान संभावना के साथ) जो एक अनाम फ़ंक्शन का उपयोग करने की अनुमति देता है, जिससे अलग हो जाता है। input/dispकहता है।

MATLAB, 49 बाइट्स

n=input('');a=repelem(n,n);disp(a(randi(nnz(a))))

यह कोड मानता है कि MATLAB R2015a या नए का उपयोग तब किया जाता है जब repelemफ़ंक्शन शुरू किया गया था। repelemएक ऐसा फंक्शन है जो दो मापदंडों को लेता है, पहला है रिप्ले किए जाने वाले नंबरों की एक सरणी, और दूसरा एक एरे का एक सरणी है जो संबंधित एलिमेंट को कितनी बार दोहराया जाना चाहिए। अनिवार्य रूप से फ़ंक्शन संख्या और रन-लंबाई प्रदान करके रन-लंबाई डिकोडिंग करता है।

repelemहम दोनों इनपुटों को एक ही इनपुट प्रदान करके एक एरे के साथ समाप्त होते हैं, जो कि तत्व n की तुलना में n गुणा अधिक होता है। यदि आप प्रदान [1 2 3]करते हैं तो आपको मिलेगा [1 2 2 3 3 3]। यदि आप प्रदान [1 2 4 2]करते हैं तो आपको मिलेगा [1 2 2 4 4 4 4 2 2]। ऐसा करने का अर्थ है कि यदि हम एक समान संभावना वाले तत्व का चयन करते हैं (समान संभावना के साथ randi(m)1 से m तक एक यादृच्छिक पूर्णांक देता है), तो प्रत्येक तत्व n में चयनित होने की n उच्च संभावना है। के पहले उदाहरण में [1 2 3], 11/6 मौका 2होगा , 2/6 मौका 3होगा और 3/6 मौका होगा।

साइड नोट के रूप में, क्योंकि repelemअभी तक ओक्टेव के लिए उपलब्ध नहीं है, मैं एक टीआईओ लिंक नहीं दे सकता। इसके अतिरिक्त, क्योंकि ऑक्टेव का उपयोग नहीं किया जा सकता है क्योंकि इसमें एक बड़ा चरित्र दंड है input()और disp()अनाम फ़ंक्शन के रूप में उपयोग किए जाने की आवश्यकता नहीं है। यदि ओक्टेव समर्थित है repelem, तो निम्नलिखित का उपयोग किया जा सकता है:

@(n)a(randi(nnz(a=repelem(n,n))))

इससे 16 बाइट बच गई होंगी, लेकिन ऐसा नहीं होना था।

— टॉम बढ़ई
स्रोत
वास्तव में स्पष्टीकरण की सराहना करते हैं, धन्यवाद!
— इयान एच।
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.