কিভাবে একটি অ্যারের থেকে এলোমেলো উপাদান সংখ্যা পেতে?

Question 1

আমি 'জাভাস্ক্রিপ্টের একটি অ্যারে থেকে এলোমেলোভাবে কীভাবে উপাদানগুলি অ্যাক্সেস করব' এ নিয়ে কাজ করছি। আমি এ সম্পর্কিত অনেক লিঙ্ক খুঁজে পেয়েছি। পছন্দ: জাভাস্ক্রিপ্ট অ্যারে থেকে এলোমেলো আইটেম পান

var item = items[Math.floor(Math.random()*items.length)];

তবে এটিতে আমরা অ্যারে থেকে কেবল একটি আইটেম বেছে নিতে পারি। আমরা যদি একাধিক উপাদান চাই তবে আমরা কীভাবে এটি অর্জন করতে পারি? অ্যারে থেকে আমরা কীভাবে একাধিক উপাদান পেতে পারি?

Question 2

এই অ-ধ্বংসাত্মক চেষ্টা করুন (এবং দ্রুত ) ফাংশনটি ব্যবহার করে দেখুন:

function getRandom(arr, n) {
    var result = new Array(n),
        len = arr.length,
        taken = new Array(len);
    if (n > len)
        throw new RangeError("getRandom: more elements taken than available");
    while (n--) {
        var x = Math.floor(Math.random() * len);
        result[n] = arr[x in taken ? taken[x] : x];
        taken[x] = --len in taken ? taken[len] : len;
    }
    return result;
}

Question 3

মাত্র দুটি লাইন:

// Shuffle array
const shuffled = array.sort(() => 0.5 - Math.random());

// Get sub-array of first n elements after shuffled
let selected = shuffled.slice(0, n);

ডেমো :

Question 4

এখানে একটি-লাইনার অনন্য সমাধান রয়েছে

 array.sort(() => Math.random() - Math.random()).slice(0, n)

Question 5

.sampleপাইথন স্ট্যান্ডার্ড লাইব্রেরি থেকে পোর্টিং :

function sample(population, k){
    /*
        Chooses k unique random elements from a population sequence or set.

        Returns a new list containing elements from the population while
        leaving the original population unchanged.  The resulting list is
        in selection order so that all sub-slices will also be valid random
        samples.  This allows raffle winners (the sample) to be partitioned
        into grand prize and second place winners (the subslices).

        Members of the population need not be hashable or unique.  If the
        population contains repeats, then each occurrence is a possible
        selection in the sample.

        To choose a sample in a range of integers, use range as an argument.
        This is especially fast and space efficient for sampling from a
        large population:   sample(range(10000000), 60)

        Sampling without replacement entails tracking either potential
        selections (the pool) in a list or previous selections in a set.

        When the number of selections is small compared to the
        population, then tracking selections is efficient, requiring
        only a small set and an occasional reselection.  For
        a larger number of selections, the pool tracking method is
        preferred since the list takes less space than the
        set and it doesn't suffer from frequent reselections.
    */

    if(!Array.isArray(population))
        throw new TypeError("Population must be an array.");
    var n = population.length;
    if(k < 0 || k > n)
        throw new RangeError("Sample larger than population or is negative");

    var result = new Array(k);
    var setsize = 21;   // size of a small set minus size of an empty list

    if(k > 5)
        setsize += Math.pow(4, Math.ceil(Math.log(k * 3, 4)))

    if(n <= setsize){
        // An n-length list is smaller than a k-length set
        var pool = population.slice();
        for(var i = 0; i < k; i++){          // invariant:  non-selected at [0,n-i)
            var j = Math.random() * (n - i) | 0;
            result[i] = pool[j];
            pool[j] = pool[n - i - 1];       // move non-selected item into vacancy
        }
    }else{
        var selected = new Set();
        for(var i = 0; i < k; i++){
            var j = Math.random() * n | 0;
            while(selected.has(j)){
                j = Math.random() * n | 0;
            }
            selected.add(j);
            result[i] = population[j];
        }
    }

    return result;
}

বাস্তবায়ন Lib / random.py থেকে পোর্ট করা হয়েছে ।

মন্তব্য:

setsizeদক্ষতার জন্য পাইথনের বৈশিষ্ট্যের ভিত্তিতে সেট করা হয়েছে। যদিও এটি জাভাস্ক্রিপ্টের জন্য সামঞ্জস্য করা হয়নি, তবে অ্যালগরিদম এখনও প্রত্যাশা অনুযায়ী কাজ করবে।
এই পৃষ্ঠায় বর্ণিত আরও কিছু উত্তর অপব্যবহারের কারণে ইসমাস্ক্রিপ্টের স্পেসিফিকেশন অনুযায়ী নিরাপদ নয় Array.prototype.sort। এই অ্যালগরিদম অবশ্য সীমাবদ্ধ সময়ে শেষ করার গ্যারান্টিযুক্ত।
Setপ্রয়োগ করা হয়নি এমন পুরানো ব্রাউজারগুলির জন্য , সেটটি একটি দ্বারা প্রতিস্থাপন Arrayএবং .has(j)প্রতিস্থাপন করা যেতে পারে .indexOf(j) > -1।

গৃহীত উত্তরের বিরুদ্ধে অভিনয়:

https://jsperf.com/pick-random-elements-from-an-array
পারফরম্যান্স পার্থক্য সাফারি উপর বৃহত্তম।

Question 6

মূল অ্যারে পরিবর্তন না করে 5 টি এলোমেলো আইটেম পাওয়া:

const n = 5;
const sample = items
  .map(x => ({ x, r: Math.random() }))
  .sort((a, b) => a.r - b.r)
  .map(a => a.x)
  .slice(0, n);

(এটি বড় তালিকার জন্য ব্যবহার করবেন না)

Question 7

একটি ফানসিওন তৈরি করুন যা এটি করে:

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
        result.push(sourceArray[Math.floor(Math.random()*sourceArray.length)]);
    }
    return result;
}

সোর্স অ্যারেতে ফিরে আসার মতো পর্যাপ্ত উপাদান রয়েছে কিনা তাও আপনার পরীক্ষা করা উচিত। এবং যদি আপনি চান অনন্য উপাদানগুলি ফিরে আসে, আপনার উত্সআরে থেকে নির্বাচিত উপাদানটি সরিয়ে নেওয়া উচিত।

Question 8

ES6 সিনট্যাক্স

const pickRandom = (arr,count) => {
  let _arr = [...arr];
  return[...Array(count)].map( ()=> _arr.splice(Math.floor(Math.random() * _arr.length), 1)[0] ); 
}

Question 9

যদি আপনি পুনরাবৃত্তি ছাড়াই এলোমেলোভাবে অ্যারে থেকে আইটেমগুলি পেতে চান তবে আপনি নির্বাচিত আইটেমটি অ্যারে থেকে এটিকে সরাতে পারেন splice:

var items = [1, 2, 3, 4, 5];
var newItems = [];

for (var i = 0; i < 3; i++) {
  var idx = Math.floor(Math.random() * items.length);
  newItems.push(items[idx]);
  items.splice(idx, 1);
}

console.log(newItems);

স্নিপেট প্রসারিত করুন

Question 10

Array.prototype.getnkill = function() {
    var a = Math.floor(Math.random()*this.length);
    var dead = this[a];
    this.splice(a,1);
    return dead;
}

//.getnkill() removes element in the array 
//so if you like you can keep a copy of the array first:

//var original= items.slice(0); 


var item = items.getnkill();

var anotheritem = items.getnkill();

Question 11

এখানে একটি সুন্দর টাইপিত সংস্করণ। এটি ব্যর্থ হয় না। যদি নমুনার আকার মূল অ্যারের দৈর্ঘ্যের চেয়ে বড় হয় তবে একটি বদলানো অ্যারে ফেরত দেয়।

function sampleArr<T>(arr: T[], size: number): T[] {
  const setOfIndexes = new Set<number>();
  while (setOfIndexes.size < size && setOfIndexes.size < arr.length) {
    setOfIndexes.add(randomIntFromInterval(0, arr.length - 1));
  }
  return Array.from(setOfIndexes.values()).map(i => arr[i]);
}

const randomIntFromInterval = (min: number, max: number): number =>
  Math.floor(Math.random() * (max - min + 1) + min);

Question 12

লোডাশ ( https://lodash.com/ ) _.sampleএবং_.sampleSize ।

সংগ্রহ থেকে আকারের অবধি অনন্য কীগুলিতে এক বা এন এলোমেলো উপাদান পান।

_.sample([1, 2, 3, 4]);
// => 2

_.sampleSize([1, 2, 3], 2);
// => [3, 1]
 
_.sampleSize([1, 2, 3], 4);
// => [2, 3, 1]

Question 13

সম্পাদনা : আপনি কেবল কয়েকটি উপাদান পেতে চাইলে এই সমাধানটি এখানে উপস্থাপিত অন্যদের তুলনায় ধীরে ধীরে (যা উত্স অ্যারেটি বিভক্ত করে তোলে)। এই দ্রষ্টব্যটির গতি কেবলমাত্র মূল অ্যারেতে থাকা উপাদানের সংখ্যার উপর নির্ভর করে, তবে বিভক্ত দ্রবণটির গতি আউটপুট অ্যারেতে প্রয়োজনীয় উপাদানের সংখ্যার উপর নির্ভর করে।

আপনি যদি অ-পুনরাবৃত্তি এলোমেলো উপাদান চান, আপনি আপনার অ্যারে পরিবর্তন করতে পারেন তারপর আপনি চান হিসাবে কেবল পেতে:

function shuffle(array) {
    var counter = array.length, temp, index;

    // While there are elements in the array
    while (counter--) {
        // Pick a random index
        index = (Math.random() * counter) | 0;

        // And swap the last element with it
        temp = array[counter];
        array[counter] = array[index];
        array[index] = temp;
    }

    return array;
}

var arr = [0,1,2,3,4,5,7,8,9];

var randoms = shuffle(arr.slice(0)); // array is cloned so it won't be destroyed
randoms.length = 4; // get 4 random elements

ডেমো: http://jsbin.com/UHUHuqi/1/edit

এখান থেকে তোলা ফাংশনটি: https://stackoverflow.com/a/6274398/1669279 9

Question 14

এই ধরণের সমস্যা সমাধানের জন্য আমার একটি ফাংশন প্রয়োজন তাই আমি এটি এখানে ভাগ করছি।

    const getRandomItem = function(arr) {
        return arr[Math.floor(Math.random() * arr.length)];
    }

    // original array
    let arr = [4, 3, 1, 6, 9, 8, 5];

    // number of random elements to get from arr
    let n = 4;

    let count = 0;
    // new array to push random item in
    let randomItems = []
    do {
        let item = getRandomItem(arr);
        randomItems.push(item);
        // update the original array and remove the recently pushed item
        arr.splice(arr.indexOf(item), 1);
        count++;
    } while(count < n);

    console.log(randomItems);
    console.log(arr);

দ্রষ্টব্য: তবে যদি n = arr.lengthআপনি মূলত অ্যারে পরিবর্তন করে থাকেন arrএবং randomItemsফেরত দেওয়া সেই অ্যারেটি ফিরিয়ে দেন।

ডেমো

Question 15

এই উত্তরে আমি আপনার সাথে এই পরীক্ষাটি ভাগ করতে চাই যে আমাকে সেরা পদ্ধতিটি জানতে হবে যা সমস্ত উপাদানকে এলোমেলোভাবে সাববারে করার সমান সুযোগ দেয়।

পদ্ধতি 01

array.sort(() => Math.random() - Math.random()).slice(0, n)

এই পদ্ধতিটি ব্যবহার করে কিছু উপাদানগুলির অন্যদের সাথে তুলনা করার সম্ভাবনা বেশি থাকে।

calculateProbability = function(number=0 ,iterations=10000,arraySize=100) { 
let occ = 0 
for (let index = 0; index < iterations; index++) {
   const myArray= Array.from(Array(arraySize).keys()) //=> [0, 1, 2, 3, 4, ... arraySize]
   
  /** Wrong Method */
    const arr = myArray.sort(function() {
     return val= .5 - Math.random();
      });
     
  if(arr[0]===number) {
    occ ++
    }

    
}

console.log("Probability of ",number, " = ",occ*100 /iterations,"%")

}

calculateProbability(0)
calculateProbability(0)
calculateProbability(0)
calculateProbability(50)
calculateProbability(50)
calculateProbability(50)
calculateProbability(25)
calculateProbability(25)
calculateProbability(25)

স্নিপেট প্রসারিত করুন

পদ্ধতি 2

এই পদ্ধতিটি ব্যবহার করে উপাদানগুলির একই সম্ভাবনা রয়েছে:

 const arr = myArray
      .map((a) => ({sort: Math.random(), value: a}))
      .sort((a, b) => a.sort - b.sort)
      .map((a) => a.value)

calculateProbability = function(number=0 ,iterations=10000,arraySize=100) { 
let occ = 0 
for (let index = 0; index < iterations; index++) {
   const myArray= Array.from(Array(arraySize).keys()) //=> [0, 1, 2, 3, 4, ... arraySize]
   

  /** Correct Method */
  const arr = myArray
  .map((a) => ({sort: Math.random(), value: a}))
  .sort((a, b) => a.sort - b.sort)
  .map((a) => a.value)
    
  if(arr[0]===number) {
    occ ++
    }

    
}

console.log("Probability of ",number, " = ",occ*100 /iterations,"%")

}

calculateProbability(0)
calculateProbability(0)
calculateProbability(0)
calculateProbability(50)
calculateProbability(50)
calculateProbability(50)
calculateProbability(25)
calculateProbability(25)
calculateProbability(25)

স্নিপেট প্রসারিত করুন

সঠিক উত্তরটি নিম্নলিখিত লিঙ্কটিতে পোস্ট করা হয়েছে: https://stackoverflow.com/a/46545530/3811640

Question 16

এখানে একজন অপ্টিমাইজ সংস্করণ কোড @Derek দ্বারা পাইথন থেকে বৈশিষ্ট্যসমূহ নিয়ে আসা, এটা দ্রুততম সম্ভব অ্যালগরিদম যদি আপনি এটি দিয়ে যেতে পারেন যে যোগ ধ্বংসাত্মক (ইন-স্থান) বিকল্প। অন্যথায় এটি হয় একটি সম্পূর্ণ অনুলিপি তৈরি করে বা, একটি বড় অ্যারে থেকে অনুরোধ করা আইটেমের সংখ্যক সংখ্যার জন্য, একটি নির্বাচন-ভিত্তিক অ্যালগরিদমে স্যুইচ করে।

// Chooses k unique random elements from pool.
function sample(pool, k, destructive) {
    var n = pool.length;

    if (k < 0 || k > n)
        throw new RangeError("Sample larger than population or is negative");

    if (destructive || n <= (k <= 5 ? 21 : 21 + Math.pow(4, Math.ceil(Math.log(k*3, 4))))) {
        if (!destructive)
            pool = Array.prototype.slice.call(pool);
        for (var i = 0; i < k; i++) { // invariant: non-selected at [i,n)
            var j = i + Math.random() * (n - i) | 0;
            var x = pool[i];
            pool[i] = pool[j];
            pool[j] = x;
        }
        pool.length = k; // truncate
        return pool;
    } else {
        var selected = new Set();
        while (selected.add(Math.random() * n | 0).size < k) {}
        return Array.prototype.map.call(selected, i => population[i]);
    }
}

ডেরেকের বাস্তবায়নের তুলনায়, ক্রোমটিতে কিছুটা ধীর হয়ে যাওয়ার পরে প্রথম অ্যালগরিদম ফায়ারফক্সে আরও দ্রুততর হয়, যদিও এখন এটির ধ্বংসাত্মক বিকল্প রয়েছে - সর্বাধিক পারফরম্যান্ট। দ্বিতীয় অ্যালগরিদম কেবল 5-15% দ্রুত। আমি কোনও কংক্রিট নম্বর না দেওয়ার চেষ্টা করি যেহেতু এগুলি কে এবং এন এর উপর নির্ভর করে পরিবর্তিত হয় এবং ভবিষ্যতে নতুন ব্রাউজার সংস্করণগুলির সাথে কিছু বোঝায় না।

আলগোরিদিমগুলির মধ্যে যে শব্দটি তৈরি হয় তা পাইথন কোড থেকে উদ্ভূত। আমি এটি যেমনটি রেখেছি তেমনি এটি কখনও কখনও ধীরে ধীরে নির্বাচন করে। এটি জেএসের জন্য অনুকূলিত করা উচিত, তবে কর্নার কেসগুলির পারফরম্যান্স ব্রাউজার- এবং তাদের সংস্করণ নির্ভর- উদাহরণস্বরূপ, আপনি যখন 1000 বা 1050 এর মধ্যে 20 টি নির্বাচন করার চেষ্টা করবেন, সে অনুযায়ী এটি প্রথম বা দ্বিতীয় অ্যালগরিদমে স্যুইচ করবে। এক্ষেত্রে প্রথমটি ক্রোম ৮০ এ দ্বিতীয়টির চেয়ে ২x দ্রুত এবং ফায়ারফক্স 74৪ এ 3x ধীর গতিতে চলে।

Question 17

2020
অ ধ্বংসাত্মক কার্যকরী প্রোগ্রামিং শৈলী, একটি পরিবর্তনীয় প্রসঙ্গে কাজ করা।

const _randomslice = (ar, size) => {
  let new_ar = [...ar];
  new_ar.splice(Math.floor(Math.random()*ar.length),1);
  return ar.length <= (size+1) ? new_ar : _randomslice(new_ar, size);
}


console.log(_randomslice([1,2,3,4,5],2));

স্নিপেট প্রসারিত করুন

Question 18

এটি যথেষ্ট পরিমাণে পাওয়ার পরে একে একে এসআরসিআরএর থেকে এলোমেলো উপাদানগুলি বের করে বা এসক্রিআরিতে আর কোনও উপাদান বের করার জন্য অবশিষ্ট নেই। দ্রুত এবং নির্ভরযোগ্য।

function getNRandomValuesFromArray(srcArr, n) {
    // making copy to do not affect original srcArray
    srcArr = srcArr.slice();
    resultArr = [];
    // while srcArray isn't empty AND we didn't enough random elements
    while (srcArr.length && resultArr.length < n) {
        // remove one element from random position and add this element to the result array
        resultArr = resultArr.concat( // merge arrays
            srcArr.splice( // extract one random element
                Math.floor(Math.random() * srcArr.length),
                1
            )
        );
    }

    return resultArr;
}

স্নিপেট প্রসারিত করুন

Question 19

2019

এটি Laurynas Mališauskas জবাব হিসাবে একই , উপাদানগুলি অনন্য (কোনও নকল নেই)।

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
    var index = Math.floor(Math.random() * sourceArray.length);
        result.push(sourceArray[index]);
        sourceArray.splice(index, 1);
    }
    return result;
}

এখন আসল প্রশ্নের উত্তর দিতে "jQuery দ্বারা একাধিক এলোমেলো উপাদান কীভাবে পাবেন", আপনি এখানে যান:

var getMeRandomElements = function(sourceArray, neededElements) {
    var result = [];
    for (var i = 0; i < neededElements; i++) {
    var index = Math.floor(Math.random() * sourceArray.length);
        result.push(sourceArray[index]);
        sourceArray.splice(index, 1);
    }
    return result;
}

var $set = $('.someClass');// <<<<< change this please

var allIndexes = [];
for(var i = 0; i < $set.length; ++i) {
    allIndexes.push(i);
}

var totalRandom = 4;// <<<<< change this please
var randomIndexes = getMeRandomElements(allIndexes, totalRandom);

var $randomElements = null;
for(var i = 0; i < randomIndexes.length; ++i) {
    var randomIndex = randomIndexes[i];
    if($randomElements === null) {
        $randomElements = $set.eq(randomIndex);
    } else {
        $randomElements.add($set.eq(randomIndex));
    }
}

// $randomElements is ready
$randomElements.css('backgroundColor', 'red');

Question 20

আমি এখানে একটি ফাংশন ব্যবহার করছি যা আপনাকে সহজেই প্রতিস্থাপনের সাথে বা ছাড়াই কোনও অ্যারে নমুনা করতে দেয়:

  // Returns a random sample (either with or without replacement) from an array
  const randomSample = (arr, k, withReplacement = false) => {
    let sample;
    if (withReplacement === true) {  // sample with replacement
      sample = Array.from({length: k}, () => arr[Math.floor(Math.random() *  arr.length)]);
    } else { // sample without replacement
      if (k > arr.length) {
        throw new RangeError('Sample size must be less than or equal to array length         when sampling without replacement.')
      }
      sample = arr.map(a => [a, Math.random()]).sort((a, b) => {
        return a[1] < b[1] ? -1 : 1;}).slice(0, k).map(a => a[0]); 
      };
    return sample;
  };

এটি ব্যবহার করা সহজ:

প্রতিস্থাপন ছাড়াই (ডিফল্ট আচরণ)

randomSample([1, 2, 3], 2) ফিরে আসতে পারে [2, 1]

প্রতিস্থাপন সহ

randomSample([1, 2, 3, 4, 5, 6], 4) ফিরে আসতে পারে [2, 3, 3, 2]

Question 21

var getRandomElements = function(sourceArray, requiredLength) {
    var result = [];
    while(result.length<requiredLength){
        random = Math.floor(Math.random()*sourceArray.length);
        if(result.indexOf(sourceArray[random])==-1){
            result.push(sourceArray[random]);
        }
    }
    return result;
}

Question 22

আমি বিশ্বাস করতে পারি না যে কেউ এই পদ্ধতিটি উল্লেখ করেনি, বেশ পরিষ্কার এবং সরাসরি এগিয়ে।

const getRnd = (a, n) => new Array(n).fill(null).map(() => a[Math.floor(Math.random() * a.length)]);

Question 23

এখানে সর্বাধিক সঠিক উত্তর এবং এটি আপনাকে এলোমেলো + অনন্য উপাদান দেয়।

function randomize(array, n)
{
    var final = [];
    array = array.filter(function(elem, index, self) {
        return index == self.indexOf(elem);
    }).sort(function() { return 0.5 - Math.random() });

    var len = array.length,
    n = n > len ? len : n;

    for(var i = 0; i < n; i ++)
    {
        final[i] = array[i];
    }

    return final;
}

// randomize([1,2,3,4,5,3,2], 4);
// Result: [1, 2, 3, 5] // Something like this

Question 24

আইটেম.সোর্ট (() => (ম্যাথআর্যান্ডম ()> 0.5? 1: -1)) স্লাইস (0, গণনা);