यादृच्छिक मूल्यों के साथ एक सरणी बनाएं

Question 1

मैं 0 से 39 तक यादृच्छिक मूल्यों के साथ, 40 तत्वों के साथ एक सरणी कैसे बना सकता हूं? पसंद

[4, 23, 7, 39, 19, 0, 9, 14, ...]

मैंने यहाँ से समाधान का उपयोग करने की कोशिश की:

http://freewebdesigntutorials.com/javaScriptTutorials/jsArrayObject/randomizeArrayElements.htm

लेकिन मुझे जो सरणी मिली है वह बहुत कम यादृच्छिक है। यह क्रमिक संख्या के कई ब्लॉक उत्पन्न करता है ...

Question 2

यहां एक समाधान है जो अद्वितीय संख्याओं की एक सूची को बदल देता है (कोई दोहराता नहीं है, कभी भी)।

for (var a=[],i=0;i<40;++i) a[i]=i;

// http://stackoverflow.com/questions/962802#962890
function shuffle(array) {
  var tmp, current, top = array.length;
  if(top) while(--top) {
    current = Math.floor(Math.random() * (top + 1));
    tmp = array[current];
    array[current] = array[top];
    array[top] = tmp;
  }
  return array;
}

a = shuffle(a);

यदि आप दोहराया मूल्यों (जो ओपी चाहते थे वह नहीं है) को अनुमति देना चाहते हैं तो कहीं और देखें। :)

Question 3

सबसे छोटा तरीका (ES6)

// randomly generated N = 40 length array 0 <= A[N] <= 39
Array.from({length: 40}, () => Math.floor(Math.random() * 40));

का आनंद लें!

Question 4

ES5:

function randomArray(length, max) {
    return Array.apply(null, Array(length)).map(function() {
        return Math.round(Math.random() * max);
    });
}

ES6:

randomArray = (length, max) => [...new Array(length)]
    .map(() => Math.round(Math.random() * max));

Question 5

यहां तक कि छोटे ES6 दृष्टिकोण:

Array(40).fill().map(() => Math.round(Math.random() * 40))

इसके अलावा, आपके पास तर्कों के साथ एक फ़ंक्शन हो सकता है:

const randomArray = (length, max) => 
  Array(length).fill().map(() => Math.round(Math.random() * max))

Question 6

सबसे छोटा :-)

[...Array(40)].map(e=>~~(Math.random()*40))

Question 7

Math.random()0 और 1 (अनन्य) के बीच एक नंबर लौटाएगा। इसलिए, यदि आप 0-40 चाहते हैं, तो आप इसे 40 से गुणा कर सकते हैं, उच्चतम परिणाम कभी भी वही हो सकता है जिसे आप गुणा कर रहे हैं।

var arr = [];
for (var i=0, t=40; i<t; i++) {
    arr.push(Math.round(Math.random() * t))
}
document.write(arr);

http://jsfiddle.net/robert/tUW89/

Question 8

.. मुझे जो सरणी मिली है वह बहुत कम यादृच्छिक है। यह क्रमिक संख्या के कई ब्लॉक उत्पन्न करता है ...

यादृच्छिक वस्तुओं के दृश्यों में अक्सर क्रमिक संख्याओं के ब्लॉक होते हैं, जुआरी की पतनशीलता देखें । उदाहरण के लिए:

.. हमने एक पंक्ति में सिर्फ चार सिर ही फैंके हैं .. चूँकि पाँच क्रमिक सिर के एक रन की संभावना केवल 1 person32 है .. जुआरी की पराजय के अधीन एक व्यक्ति यह मान सकता है कि इस अगले फ्लिप के प्रमुख होने की संभावना कम थी पूंछ होना। http://en.wikipedia.org/wiki/Gamblers_fallacy

Question 9

let randomNumber = Array.from({length: 6}, () => Math.floor(Math.random() * 39));

यह देखने के लिए आसान बनाने के लिए सरणी को 6 मानों तक सीमित करता है।

Question 10

चूंकि संख्याओं की सीमा विवश है, मैं कहूंगा कि सबसे अच्छी बात यह है कि सरणी उत्पन्न करना है, इसे 39 के माध्यम से संख्याओं के साथ भरें (क्रम में), फिर इसे फेरबदल करें।

Question 11

var myArray = [];
var arrayMax = 40;
var limit = arrayMax + 1;
for (var i = 0; i < arrayMax; i++) {
  myArray.push(Math.floor(Math.random()*limit));
}

यह ऊपर करने का पारंपरिक तरीका है, लेकिन मैं दूसरी @Pointy और @Phrogz का उपयोग करता हूं, यदि आप महंगी गणना करने के बिना अपने सरणी में डुप्लिकेट से बचना चाहते हैं

Question 12

हर दिन क्वर्की सिंगल-लाइन समाधान।

सरणियों में मान कुल यादृच्छिक है, इसलिए जब आप इस स्निपेट्स का उपयोग करेंगे, तो यह अलग होगा।

लोअरकेस में यादृच्छिक वर्णों के साथ एक सरणी (लंबाई 10)

Array.apply(null, Array(10)).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); })

[[के ’, 'ए’,' एक्स ’,, वाई’,, एन ’, 'डब्ल्यू’,' एम ’, b क्यू’, q बी ’, 'जे’]

0 से 99 तक यादृच्छिक पूर्णांक संख्याओं के साथ एक सरणी (लंबाई 10)

Array.apply(null, Array(10)).map(function() { return Math.floor(Math.random() * 100 % 100); })

[86, 77, 83, 27, 79, 96, 67, 75, 52, 21]

एक यादृच्छिक रैंडम तारीखें (10 साल पहले से लेकर अब तक)

Array.apply(null, Array(10)).map(function() { return new Date((new Date()).getFullYear() - Math.floor(Math.random() * 10), Math.floor(Math.random() * 12), Math.floor(Math.random() * 29) )})

[2008-08-22T21: 00: 00.000Z, 2007-07-17T21: 00: 00.000Z,
2015-05-05T21: 00: 00.000Z, 2011-06-14T21: 00: 00.000Z,
2009-07-23T21 : 00: 00.000Z, 2009-11-13T22: 00: 00.000Z,
2010-05-09T21: 00: 00.000Z, 2008-01-05T22: 00: 00.000Z,
2016-05-06T21: 00: 00.000Z, 00 2014-08-06T21: 00: 00.000Z]

एक सरणी (लंबाई 10) यादृच्छिक तार

Array.apply(null, Array(10)).map(function() { return Array.apply(null, Array(Math.floor(Math.random() * 10  + 3))).map(function() { return String.fromCharCode(Math.floor(Math.random() * (123 - 97) + 97)); }).join('') });

]

अन्य उपयोगी चीजें जो आप यहां पा सकते हैं https://github.com/setivolkylany/nodejs-utils/blob/master/utils/faker.js

Question 13

कुछ नई ES6 विशेषताओं का उपयोग करके, इसे अब उपयोग करके प्राप्त किया जा सकता है:

function getRandomInt(min, max) {
    "use strict";
    if (max < min) {
        // Swap min and max
        [min, max] = [min, max];
    }

    // Generate random number n, where min <= n <= max
    let range = max - min + 1;
    return Math.floor(Math.random() * range) + min;
}

let values = Array.from({length: 40}, () => getRandomInt(0, 40));

console.log(values);

ध्यान दें कि यह समाधान केवल उन आधुनिक ब्राउज़रों में काम करेगा जो इन ES6 सुविधाओं का समर्थन करते हैं: तीर फ़ंक्शन और Array.from ()।

Question 14

नीचे देखें: -

let arr = Array.apply(null, {length: 1000}).map(Function.call, Math.random)
/* will create array with 1000 elements */

Question 15

@Phrogz द्वारा सुझाए गए पृष्ठ से

for (var i=0,nums=[];i<49;i++) nums[i]={ n:i, rand:Math.random() };
nums.sort( function(a,b){ a=a.rand; b=b.rand; return a<b?-1:a>b?1:0 } );

Question 16

मुझे इन समाधानों की तुलना में कुछ अलग की आवश्यकता थी, इसमें मुझे एक निर्दिष्ट श्रेणी के लिए कई विशिष्ट यादृच्छिक संख्याओं के साथ एक सरणी बनाने की आवश्यकता थी। नीचे मेरा समाधान है।

function getDistinctRandomIntForArray(array, range){
   var n = Math.floor((Math.random() * range));
   if(array.indexOf(n) == -1){        
    return n; 
   } else {
    return getDistinctRandomIntForArray(array, range); 
   }
}

function generateArrayOfRandomInts(count, range) {
   var array = []; 
   for (i=0; i<count; ++i){
    array[i] = getDistinctRandomIntForArray(array, range);
   };
   return array; 
}

मैं एक लूप नहीं बनाना पसंद करूंगा जिसमें बहुत सारी अनावश्यक कॉल के साथ समाप्त होने की संभावना हो (यदि आपकी गिनती, और रेंज अधिक है और एक ही नंबर के करीब हैं) लेकिन यह सबसे अच्छा है जिसके साथ मैं आ सकता हूं।

Question 17

function shuffle(maxElements) {
    //create ordered array : 0,1,2,3..maxElements
    for (var temArr = [], i = 0; i < maxElements; i++) {
        temArr[i] = i;
    }

    for (var finalArr = [maxElements], i = 0; i < maxElements; i++) {
        //remove rundom element form the temArr and push it into finalArrr
        finalArr[i] = temArr.splice(Math.floor(Math.random() * (maxElements - i)), 1)[0];
    }

    return finalArr
}

मुझे लगता है कि यह विधि समस्या का समाधान संभावनाओं के साथ करेगी, केवल यादृच्छिक संख्या जनरेटर द्वारा सीमित।

Question 18

यदि आपको 0 से यादृच्छिक विशिष्ट मानों की आवश्यकता है ... लंबाई सीमा:

const randomRange = length => {
  const results = []
  const possibleValues = Array.from({ length }, (value, i) => i)

  for (let i = 0; i < length; i += 1) {
    const possibleValuesRange = length - (length - possibleValues.length)
    const randomNumber = Math.floor(Math.random() * possibleValuesRange)
    const normalizedRandomNumber = randomNumber !== possibleValuesRange ? randomNumber : possibleValuesRange

    const [nextNumber] = possibleValues.splice(normalizedRandomNumber, 1)

    results.push(nextNumber)
  }

  return results
}

randomRange(5) // [3, 0, 1, 4, 2]

Question 19

मुझे पूरा यकीन है कि यह बिना किसी दोहराव के आपके यादृच्छिक सरणी बनाने का सबसे छोटा तरीका है

var random_array = new Array(40).fill().map((a, i) => a = i).sort(() => Math.random() - 0.5);

Question 20

पार्टी के लिए थोड़ा देर से, लेकिन मैं यादृच्छिकता के लिए randojs.com का उपयोग करता हूं क्योंकि यह इस सुपर आसान की तरह सामान बनाता है। आप इस तरह से 39 के माध्यम से 0 से संख्याओं का बेतरतीब ढंग से फेरबदल कर सकते हैं:

console.log(randoSequence(40));

<script src="https://randojs.com/1.0.0.js"></script>

स्निपेट का विस्तार करें

यह सब के रसद के साथ कोई उपद्रव नहीं-प्लस यह सुपर पठनीय और समझने में आसान है :)

Question 21

जेनरेटर

मूल्यों को दोहराए बिना 40 से 40 यादृच्छिक संभावित मूल्यों (0 - 39) की लंबाई की एक सरणी @Phrogz और @Jared बेक के रूप में इसे फेरबदल करना बेहतर है। एक और दृष्टिकोण, सिर्फ रिकॉर्ड के लिए, जनरेटर का उपयोग किया जा सकता है। लेकिन इस दृष्टिकोण में अन्य प्रस्तावित समाधानों की तुलना में प्रदर्शन की कमी है ।

function* generateRandomIterable(n, range) {
  for (let i = 0; i < n; i++) {
    yield ~~(Math.random() * range);
  }
}
const randomArr = [...generateRandomIterable(40,40)];