1 থেকে 100 এর মধ্যে অনন্য এলোমেলো সংখ্যা তৈরি করুন

Question 1

আমি কীভাবে জাভাস্ক্রিপ্ট ব্যবহার করে 1 এবং 100 এর মধ্যে কিছু অনন্য এলোমেলো সংখ্যা তৈরি করতে পারি ?

Question 2

উদাহরণস্বরূপ: 8 টি অনন্য এলোমেলো সংখ্যা তৈরি করতে এবং এটিকে একটি অ্যারেতে সঞ্চয় করতে, আপনি কেবল এটি করতে পারেন:

var arr = [];
while(arr.length < 8){
    var r = Math.floor(Math.random() * 100) + 1;
    if(arr.indexOf(r) === -1) arr.push(r);
}
console.log(arr);

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

Question 3

1 থেকে 100 পর্যন্ত সংখ্যা সহ একটি অ্যারে তৈরি করুন।
এলোমেলো ।
ফলাফল অ্যারের প্রথম 8 উপাদান নিন।

Question 4

জেনারেট করুন বিন্যাস 100 সংখ্যার এবং তারপর ধারাবাহিকভাবে চয়ন।

ব্যবহারের Knuth এলোমেলো (ওরফে ফিশার-ইয়েটস এলোমেলো) অ্যালগরিদম ।

জাভাস্ক্রিপ্ট:

  function fisherYates ( myArray,stop_count ) {
  var i = myArray.length;
  if ( i == 0 ) return false;
  int c = 0;
  while ( --i ) {
     var j = Math.floor( Math.random() * ( i + 1 ) );
     var tempi = myArray[i];
     var tempj = myArray[j];
     myArray[i] = tempj;
     myArray[j] = tempi;

     // Edited thanks to Frerich Raabe
     c++;
     if(c == stop_count)return;

   }
}

লিঙ্ক থেকে কোড কপি করা হয়েছে।

সম্পাদনা :

উন্নত কোড:

function fisherYates(myArray,nb_picks)
{
    for (i = myArray.length-1; i > 1  ; i--)
    {
        var r = Math.floor(Math.random()*i);
        var t = myArray[i];
        myArray[i] = myArray[r];
        myArray[r] = t;
    }

    return myArray.slice(0,nb_picks);
}

সম্ভাব্য সমস্যা:

ধরুন আমাদের কাছে 100 টি সংখ্যার অ্যারে রয়েছে {যেমন [1,2,3 ... 100]} এবং আমরা 8 টি অদলবদলের পরে অদলবদল বন্ধ করি; তারপরে বেশিরভাগ সময় অ্যারে দেখতে হবে {1,2,3,76,5,6,7,8, ... এখানে নম্বরগুলি পরিবর্তন হয়ে যাবে ... 10}}

কারণ প্রতিটি সংখ্যা সম্ভাব্যতা 1/100 তাই প্রোব সঙ্গে অদলবদল করা হবে। প্রথম 8 নম্বর অদলবদল 8/100 হয়, যেখানে প্রোব। অন্যান্য 92 এর অদলবদল হল 92/100।

তবে আমরা যদি পুরো অ্যারের জন্য অ্যালগরিদম চালাই তবে আমরা নিশ্চিত (প্রায়) প্রতিটি প্রবেশই অদলবদল হয়।

অন্যথায় আমরা একটি প্রশ্নের মুখোমুখি: কোন 8 নম্বর চয়ন করতে হবে?

Question 5

আধুনিক জেএস সলিউশন সেট (এবং গড় কেস ও (এন)) ব্যবহার করে

const nums = new Set();
while(nums.size !== 8) {
  nums.add(Math.floor(Math.random() * 100) + 1);
}

console.log([...nums]);

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

Question 6

উপরের কৌশলগুলি যদি আপনি কোনও লাইব্রেরি এড়াতে চান তবে ভাল তবে আপনি যদি লাইব্রেরির সাথে ঠিক থাকেন তবে আমি জাভাস্ক্রিপ্টে এলোমেলো জিনিস উত্পন্ন করার সম্ভাবনা পরীক্ষা করে দেখার পরামর্শ দিচ্ছি ।

বিশেষত আপনার প্রশ্নটি সমাধান করার জন্য, চান্স ব্যবহার করে এটি যতটা সহজ:

// One line!
var uniques = chance.unique(chance.natural, 8, {min: 1, max: 100});

// Print it out to the document for this snippet so we can see it in action
document.write(JSON.stringify(uniques));

<script src="http://chancejs.com/chance.min.js"></script>

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

দাবি অস্বীকার, চান্সের লেখক হিসাবে আমি কিছুটা পক্ষপাতদুষ্ট;)

Question 7

আরেকটি পদ্ধতি হ'ল আরোহী সংখ্যা সহ একটি 100 আইটেম অ্যারে তৈরি করা এবং এলোমেলোভাবে এটিকে সাজান। এটি আসলে একটি সংক্ষিপ্ত এবং (আমার মতে) সাধারণ স্নিপেটের দিকে নিয়ে যায়।

const numbers = Array(100).fill().map((_, index) => index + 1);
numbers.sort(() => Math.random() - 0.5);
console.log(numbers.slice(0, 8));

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

Question 8

দীর্ঘ এবং অবিশ্বাস্য কোনও এলোমেলো এড়াতে, আমি নিম্নলিখিতগুলি করব ...

ক্রমানুসারে 1 এবং 100 এর মধ্যে সংখ্যাযুক্ত একটি অ্যারে তৈরি করুন।
1 এবং 100 এর মধ্যে একটি এলোমেলো সংখ্যা তৈরি করুন
অ্যারেতে এই সূচীতে নম্বরটি দেখুন এবং আপনার ফলাফলগুলিতে সঞ্চয় করুন
অ্যারে থেকে এলেমেন্টটি সরান, এটিকে আরও খাটো করে তোলা
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 99 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 98 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 97 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 96 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 95 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 94 ব্যবহার করুন
পদক্ষেপ 2 থেকে পুনরাবৃত্তি করুন, তবে এলোমেলো সংখ্যার উপরের সীমা হিসাবে 93 ব্যবহার করুন

ভয়েলা - কোনও পুনরাবৃত্তি সংখ্যা নেই।

কারও আগ্রহ থাকলে আমি পরে কিছু প্রকৃত কোড পোস্ট করতে পারি।

সম্পাদনা: এটি সম্ভবত আমার মধ্যে প্রতিযোগিতামূলক ধারা কিন্তু @ অ্যালসিয়ান্ডে পোস্টটি দেখে, আমি যে প্রতিশ্রুতি দিয়েছি কোডটি পোস্ট করা প্রতিহত করতে পারিনি।

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
<html>
<head>
<title>8 unique random number between 1 and 100</title>
<script type="text/javascript" language="Javascript">
    function pick(n, min, max){
        var values = [], i = max;
        while(i >= min) values.push(i--);
        var results = [];
        var maxIndex = max;
        for(i=1; i <= n; i++){
            maxIndex--;
            var index = Math.floor(maxIndex * Math.random());
            results.push(values[index]);
            values[index] = values[maxIndex];
        }
        return results;
    }
    function go(){
        var running = true;
        do{
            if(!confirm(pick(8, 1, 100).sort(function(a,b){return a - b;}))){
                running = false;
            }
        }while(running)
    }
</script>
</head>

<body>
    <h1>8 unique random number between 1 and 100</h1>
    <p><button onclick="go()">Click me</button> to start generating numbers.</p>
    <p>When the numbers appear, click OK to generate another set, or Cancel to stop.</p>
</body>

Question 9

আমি এটি করব:

function randomInt(min, max) {
    return Math.round(min + Math.random()*(max-min));
}
var index = {}, numbers = [];
for (var i=0; i<8; ++i) {
    var number;
    do {
        number = randomInt(1, 100);
    } while (index.hasOwnProperty("_"+number));
    index["_"+number] = true;
    numbers.push(number);
}
delete index;

Question 10

এটি একটি খুব জেনেরিক ফাংশন যা আমি অ্যারের জন্য এলোমেলো অনন্য / অ-অনন্য পূর্ণসংখ্যার উত্পাদন করতে লিখেছি। এই উত্তরের জন্য এই দৃশ্যে সত্য হতে শেষ প্যারামিটারটি ধরে নিন।

/* Creates an array of random integers between the range specified 
     len = length of the array you want to generate
     min = min value you require
     max = max value you require
     unique = whether you want unique or not (assume 'true' for this answer)
*/
    function _arrayRandom(len, min, max, unique) {
        var len = (len) ? len : 10,
                min = (min !== undefined) ? min : 1,
                max = (max !== undefined) ? max : 100,
                unique = (unique) ? unique : false,
                toReturn = [], tempObj = {}, i = 0;

        if(unique === true) {
            for(; i < len; i++) {
                var randomInt = Math.floor(Math.random() * ((max - min) + min));
                if(tempObj['key_'+ randomInt] === undefined) {
                    tempObj['key_'+ randomInt] = randomInt;
                    toReturn.push(randomInt);
                } else {
                    i--;
                }
            }
        } else {
            for(; i < len; i++) {
                toReturn.push(Math.floor(Math.random() * ((max - min) + min)));
            }
        }

        return toReturn;
    }

এখানে 'টেম্পবজ' একটি দরকারী উপকারী যেহেতু উত্পন্ন প্রতিটি এলোমেলো সংখ্যা সরাসরি এই টেম্পবজে চেক করবে যদি সেই কীটি ইতিমধ্যে উপস্থিত থাকে তবে যদি তা না থাকে তবে আমরা এখনই একটিকে কমিয়ে দেই যেহেতু বর্তমান র্যান্ডম সংখ্যাটি ইতিমধ্যে বিদ্যমান রয়েছে বলে আমাদের 1 টি অতিরিক্ত রান প্রয়োজন we ।

আপনার ক্ষেত্রে, নিম্নলিখিত চালান

_arrayRandom(8, 1, 100, true);

এখানেই শেষ.

Question 11

1 থেকে 100 এর মধ্যে নম্বরগুলি পরিবর্তন করা সঠিক মৌলিক কৌশল, তবে আপনার যদি কেবল 8 টি শ্যাফল সংখ্যার প্রয়োজন হয় তবে সমস্ত 100 সংখ্যাটি বদল করার দরকার নেই।

আমি জাভাস্ক্রিপ্ট খুব ভাল জানি না, তবে আমি বিশ্বাস করি দ্রুত 100 নালার একটি অ্যারে তৈরি করা সহজ। তারপরে, 8 রাউন্ডের জন্য, আপনি অ্যারের N'th উপাদানটি অদলবদল করবেন (n 0 থেকে শুরু হবে) এলোমেলোভাবে নির্বাচিত উপাদানটিকে এন + 1 থেকে 99 এর মধ্যে দিয়ে দিন Of মূল সূচক প্লাস 1, যাতে এটি ফ্যাক্টরটির পক্ষে তুচ্ছ।

Question 12

var arr = []
while(arr.length < 8){
  var randomnumber=Math.ceil(Math.random()*100)
  if(arr.indexOf(randomnumber) === -1){arr.push(randomnumber)}  
}
document.write(arr);

আমি দেখেছি অন্যান্য উত্তর চেয়ে ছোট

Question 13

মেশিন চারার হিসাবে একই ক্রমোটেশন অ্যালগরিদম, তবে একটি প্রোটোটাইপ বাস্তবায়নের সাথে। বড় সংখ্যা বাছাই করা ভাল। উপলব্ধ থাকলে জেএস 1.7 ডিস্ট্রাকচারিং অ্যাসাইনমেন্ট ব্যবহার করুন ।

// swaps elements at index i and j in array this
// swapping is easy on js 1.7 (feature detection)
Array.prototype.swap = (function () {
    var i=0, j=1;
    try { [i,j]=[j,i]; }
    catch (e) {}
    if(i) {
        return function(i,j) {
            [this[i],this[j]] = [this[j],this[i]];
            return this;
        }
    } else {
        return function(i,j) {
            var temp = this[i];
            this[i] = this[j];
            this[j] = temp;
            return this;
        }
    }
})();


// shuffles array this
Array.prototype.shuffle = function() {
    for(var i=this.length; i>1; i--) {
        this.swap(i-1, Math.floor(i*Math.random()));
    }
    return this;
}

// returns n unique random numbers between min and max
function pick(n, min, max) {
    var a = [], i = max;
    while(i >= min) a.push(i--);
    return a.shuffle().slice(0,n);
}

pick(8,1,100);

সম্পাদনা করুন: অন্য একটি প্রস্তাব, বেলুগাবোবের উত্তরের ভিত্তিতে অল্প সংখ্যক পিকের পক্ষে ভাল better স্বতন্ত্রতার গ্যারান্টি হিসাবে, আমরা অ্যারে থেকে বাছাই করা নম্বরগুলি সরিয়ে ফেলি।

// removes n random elements from array this
// and returns them
Array.prototype.pick = function(n) {
    if(!n || !this.length) return [];
    var i = Math.floor(this.length*Math.random());
    return this.splice(i,1).concat(this.pick(n-1));
}

// returns n unique random numbers between min and max
function pick(n, min, max) {
    var a = [], i = max;
    while(i >= min) a.push(i--);
    return a.pick(n);
}

pick(8,1,100);

Question 14

এর মতো গর্তযুক্ত অ্যারেগুলির জন্য [,2,,4,,6,7,,] কারণ আমার সমস্যাটি হোলগুলি পূরণ করা ছিল। সুতরাং আমি এটি আমার প্রয়োজন অনুসারে পরিবর্তন করেছি :)

নিম্নলিখিত পরিবর্তিত সমাধানটি আমার জন্য কাজ করেছে :)

var arr = [,2,,4,,6,7,,]; //example
while(arr.length < 9){
  var randomnumber=Math.floor(Math.random()*9+1);
  var found=false;
  for(var i=0;i<arr.length;i++){
    if(arr[i]==randomnumber){found=true;break;}
  }

  if(!found)
    for(k=0;k<9;k++)
    {if(!arr[k]) //if it's empty  !!MODIFICATION
      {arr[k]=randomnumber; break;}}
}

alert(arr); //outputs on the screen

Question 15

পূর্বের সেরা উত্তরটি হল উত্তর sje397 । যত তাড়াতাড়ি সম্ভব আপনি পেতে পারেন হিসাবে ভাল এলোমেলো নম্বর পাবেন।

আমার সমাধান তার সমাধানের সাথে খুব মিল। যাইহোক, কখনও কখনও আপনি এলোমেলো ক্রমে এলোমেলো সংখ্যা চান, এবং সে কারণেই আমি একটি উত্তর পোস্ট করার সিদ্ধান্ত নিয়েছি। এছাড়াও, আমি একটি সাধারণ ফাংশন সরবরাহ করি।

function selectKOutOfN(k, n) {
  if (k>n) throw "k>n";
  var selection = [];
  var sorted = [];
  for (var i = 0; i < k; i++) {
    var rand = Math.floor(Math.random()*(n - i));
    for (var j = 0; j < i; j++) {
      if (sorted[j]<=rand)
        rand++;
      else
        break;
    }
    selection.push(rand);
    sorted.splice(j, 0, rand);
  }
  return selection;
}

alert(selectKOutOfN(8, 100));

Question 16

এখানে আমার ES6 সংস্করণটি আমি একসাথে cobbled করেছি। আমি নিশ্চিত এটি কিছুটা আরও একীভূত হতে পারে।

function randomArray(i, min, max) {
  min = Math.ceil(min);
  max = Math.floor(max);
  
  let arr = Array.from({length: i}, () => Math.floor(Math.random()* (max - min)) + min);
  
  return arr.sort();
 }
 
 let uniqueItems = [...new Set(randomArray(8, 0, 100))]
 console.log(uniqueItems);

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

Question 17

হ্যাশ টেবিল হিসাবে অবজেক্ট বৈশিষ্ট্য ব্যবহার সম্পর্কে কীভাবে ? এইভাবে আপনার সেরা দৃশ্যটি কেবল 8 বার এলোমেলো করা। এটি কেবলমাত্র তখনই কার্যকর হবে যদি আপনি সংখ্যার ব্যাপ্তির একটি ছোট অংশ চান। এটি ফিশার-ইয়েটসের চেয়ে নিবিড় স্মৃতিও কম কারণ আপনাকে কোনও অ্যারের জন্য স্থান বরাদ্দ করতে হবে না।

var ht={}, i=rands=8;
while ( i>0 || keys(ht).length<rands) ht[Math.ceil(Math.random()*100)]=i--;
alert(keys(ht));

আমি তখন জানতে পারি যে অবজেক্ট.কিজ (ওজেক্ট) একটি ইসমাস্ক্রিপ্ট 5 বৈশিষ্ট্য তাই উপরের মুহূর্তে ইন্টারনেটগুলিতে খুব বেশি অকেজো। ভয় পাবেন না, কারণ আমি এটির মতো কীগুলি যুক্ত করে এটি ECMAScript 3 সামঞ্জস্যপূর্ণ করেছি।

if (typeof keys == "undefined") 
{ 
  var keys = function(obj) 
  {
    props=[];
    for (k in ht) if (ht.hasOwnProperty(k)) props.push(k);
    return props;
  }
}

Question 18

var bombout=0;
var checkArr=[];
var arr=[];
while(arr.length < 8 && bombout<100){
  bombout++;
  var randomNumber=Math.ceil(Math.random()*100);
  if(typeof checkArr[randomNumber] == "undefined"){
    checkArr[randomNumber]=1;
    arr.push(randomNumber);
  }
}

// untested - hence bombout

Question 19

আপনার যদি আরও অনন্য প্রয়োজন হয় তবে আপনাকে অবশ্যই একটি অ্যারে তৈরি করতে হবে (1..100)।

var arr=[];
function generateRandoms(){
for(var i=1;i<=100;i++) arr.push(i);
}
function extractUniqueRandom()
{
   if (arr.length==0) generateRandoms();
   var randIndex=Math.floor(arr.length*Math.random());
   var result=arr[randIndex];
   arr.splice(randIndex,1);
   return result;

}
function extractUniqueRandomArray(n)
{
   var resultArr=[];
   for(var i=0;i<n;i++) resultArr.push(extractUniqueRandom());
   return resultArr;
}

উপরের কোডটি দ্রুত:
এক্সট্রাক্টউনিক র্যান্ডমআরাই (50) => [২,, 79, ৩৮, ৫৯, ,৩, ৪২, ৫২, ২২, 78 78, ৫০, ৩৯,, 77, ১, ৮৮, ৪০, ২৩, ৪৮, ,৪, ,১, 49, 4, 54, 93, 36, 100, 82, 62, 41, 89, 12, 24, 31, 86, 92, 64, 75, 70, 61, 67, 98, 76, 80, 56, 90, 90 83, 44, 43, 47, 7, 53]

Question 20

জাভাস্ক্রিপ্ট 1.6 ইনডেক্সের ফাংশন সহ একই কোডের (স্বীকৃত উত্তর) এর আরও ভাল সংস্করণ যুক্ত করা। প্রতিবার নকলটি পরীক্ষা করার সময় পুরো অ্যারে থেকে লুপ নেওয়ার দরকার নেই।

var arr = []
while(arr.length < 8){
  var randomnumber=Math.ceil(Math.random()*100)
  var found=false;
    if(arr.indexOf(randomnumber) > -1){found=true;}
  if(!found)arr[arr.length]=randomnumber;
}

জাভাস্ক্রিপ্টের পুরানো সংস্করণটি এখনও শীর্ষে থাকা সংস্করণটি ব্যবহার করতে পারে

পিএস: উইকিতে আপডেটের পরামর্শ দেওয়ার চেষ্টা করা হয়েছিল কিন্তু তা প্রত্যাখ্যান করা হয়েছিল। আমি এখনও মনে করি এটি অন্যের জন্য কার্যকর হতে পারে।

Question 21

এটি আমার ব্যক্তিগত সমাধান:

<script>

var i, k;
var numbers = new Array();
k = Math.floor((Math.random()*8));
numbers[0]=k;
    for (var j=1;j<8;j++){
        k = Math.floor((Math.random()*8));
i=0;
while (i < numbers.length){
if (numbers[i] == k){
    k = Math.floor((Math.random()*8));
    i=0;
}else {i++;}
}
numbers[j]=k;
    }
    for (var j=0;j<8;j++){
alert (numbers[j]);
    }
</script>

এটি এলোমেলোভাবে 8 টি অনন্য অ্যারে মান উত্পন্ন করে (0 এবং 7 এর মধ্যে), তারপরে একটি সতর্কতা বাক্স ব্যবহার করে তাদের প্রদর্শন করে।

Question 22

function getUniqueRandomNos() {
    var indexedArrayOfRandomNo = [];
    for (var i = 0; i < 100; i++) {
        var randNo = Math.random();
        indexedArrayOfRandomNo.push([i, randNo]);
    }
    indexedArrayOfRandomNo.sort(function (arr1, arr2) {
        return arr1[1] - arr2[1]
    });
    var uniqueRandNoArray = [];
    for (i = 0; i < 8; i++) {
        uniqueRandNoArray.push(indexedArrayOfRandomNo[i][0]);
    }
    return uniqueRandNoArray;
}

আমি মনে করি যে এই পদ্ধতিটি বেশিরভাগ উত্তরে প্রদত্ত পদ্ধতিগুলির চেয়ে পৃথক, তাই আমি ভেবেছিলাম যে আমি এখানে একটি উত্তর যুক্ত করতে পারি (যদিও প্রশ্নটি 4 বছর আগে জিজ্ঞাসা করা হয়েছিল)।

আমরা 100 টি এলোমেলো সংখ্যা উত্পন্ন করি এবং তাদের প্রত্যেককে 1 থেকে 100 পর্যন্ত সংখ্যার সাথে ট্যাগ করি Then তারপরে আমরা এই ট্যাগযুক্ত এলোমেলো সংখ্যাগুলিকে বাছাই করি এবং ট্যাগগুলি এলোমেলোভাবে বদলে যায়। বিকল্প হিসাবে, এই প্রশ্নে যেমন প্রয়োজন তেমন একটি, ট্যাগ করা এলোমেলো সংখ্যাগুলির মধ্যে শীর্ষ 8 খুঁজে বের করতে পারে। শীর্ষ 8 টি আইটেম সন্ধান করা পুরো অ্যারে বাছাই করার চেয়ে সস্তা।

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

Question 23

এটি 20 ডিজিটের ইউনিক্যু এলোমেলো নম্বর পর্যন্ত উত্পাদন পরিচালনা করতে পারে

জেএস

 var generatedNumbers = [];

    function generateRandomNumber(precision) { // input --> number precision in integer 
        if (precision <= 20) {
            var randomNum = Math.round(Math.random().toFixed(precision) * Math.pow(10, precision));
            if (generatedNumbers.indexOf(randomNum) > -1) {
                if (generatedNumbers.length == Math.pow(10, precision))
                    return "Generated all values with this precision";
                    return generateRandomNumber(precision);
            } else {
                generatedNumbers.push(randomNum);
                return randomNum;
            }
        } else
           return "Number Precision shoould not exceed 20";
    }
    generateRandomNumber(1);

jsFizz

Question 24

এই সমাধানটিতে হ্যাশ ব্যবহার করা হয় যা অ্যারেতে থাকে কিনা তা যাচাই করার চেয়ে অনেক বেশি পারফরম্যান্ট হে (1)। এটিতে অতিরিক্ত নিরাপদ চেকও রয়েছে। আশা করি এটা সাহায্য করবে.

function uniqueArray(minRange, maxRange, arrayLength) {
  var arrayLength = (arrayLength) ? arrayLength : 10
  var minRange = (minRange !== undefined) ? minRange : 1
  var maxRange = (maxRange !== undefined) ? maxRange : 100
  var numberOfItemsInArray = 0
  var hash = {}
  var array = []

  if ( arrayLength > (maxRange - minRange) ) throw new Error('Cannot generate unique array: Array length too high')

  while(numberOfItemsInArray < arrayLength){
    // var randomNumber = Math.floor(Math.random() * (maxRange - minRange + 1) + minRange)
    // following line used for performance benefits
    var randomNumber = (Math.random() * (maxRange - minRange + 1) + minRange) << 0

    if (!hash[randomNumber]) {
      hash[randomNumber] = true
      array.push(randomNumber)
      numberOfItemsInArray++
    }
  }
  return array
}
document.write(uniqueArray(1, 100, 8))

Question 25

এটিকে জেনারেটর হিসাবে প্রয়োগ করা কাজ করে খুব সুন্দর করে তোলে। দ্রষ্টব্য, এই বাস্তবায়নটি সম্পূর্ণ ইনপুট অ্যারেটিকে প্রথমে বদলানো দরকার ones

এই sampleফাংশনটি অলসভাবে কাজ করে, আপনার কাছে চাওয়া আইটেমগুলি পর্যন্ত আপনাকে পুনরাবৃত্তির জন্য 1 টি এলোমেলো আইটেম দেয় N। এটি দুর্দান্ত কারণ আপনি যদি 1000 এর তালিকা থেকে 3 টি আইটেম চান তবে আপনাকে প্রথমে সমস্ত 1000 আইটেম স্পর্শ করতে হবে না।

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
  let ys = xs.slice(0);
  let len = xs.length;
  while (n > 0 && len > 0) {
    let i = (Math.random() * len) >> 0;
    yield ys.splice(i,1)[0];
    n--; len--;
  }
}

// example inputs
let items = ['a', 'b', 'c', 'd', 'e', 'f', 'g'];
let numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

// get 3 random items
for (let i of sample(3) (items))
  console.log(i); // f g c

// partial application
const lotto = sample(3);
for (let i of lotto(numbers))
  console.log(i); // 3 8 7

// shuffle an array
const shuffle = xs => Array.from(sample (Infinity) (xs))
console.log(shuffle(items)) // [b c g f d e a]

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

আমি sampleএমনভাবে প্রয়োগ করা বেছে নিয়েছি যাতে ইনপুট অ্যারেটি পরিবর্তন না করে তবে আপনি সহজেই যুক্তি দিতে পারেন যে কোনও মিউটেশন বাস্তবায়ন অনুকূল।

উদাহরণস্বরূপ, shuffleফাংশনটি মূল ইনপুট অ্যারেটি পরিবর্তন করতে পারে। অথবা আপনি একই সময়ে বিভিন্ন সময়ে একই ইনপুট থেকে নমুনা নিতে চান, প্রতিটি সময় ইনপুট আপডেট করে।

// sample :: Integer -> [a] -> [a]
const sample = n => function* (xs) {
  let len = xs.length;
  while (n > 0 && len > 0) {
    let i = (Math.random() * len) >> 0;
    yield xs.splice(i,1)[0];
    n--; len--;
  }
}

// deal :: [Card] -> [Card]
const deal = xs => Array.from(sample (2) (xs));

// setup a deck of cards (13 in this case)
// cards :: [Card]
let cards = 'A234567890JQK'.split('');

// deal 6 players 2 cards each
// players :: [[Card]]
let players = Array.from(Array(6), $=> deal(cards))

console.log(players);
// [K, J], [6, 0], [2, 8], [Q, 7], [5, 4], [9, A]

// `cards` has been mutated. only 1 card remains in the deck
console.log(cards);
// [3]

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

sampleঅ্যারে ইনপুট মিউটেশনের কারণে আর খাঁটি ফাংশন নয়, তবে নির্দিষ্ট পরিস্থিতিতে (উপরে প্রদর্শিত) এটি আরও বোধ করতে পারে।

আমি কেবলমাত্র একটি অ্যারের ফিরিয়ে দেয় এমন ফাংশনের পরিবর্তে একটি জেনারেটর বেছে নিয়েছি কারণ আপনি কিছু নির্দিষ্ট শর্ত না হওয়া পর্যন্ত নমুনা চালিয়ে যেতে চাইতে পারেন।

সম্ভবত আমি 1,000,000 এলোমেলো সংখ্যার তালিকা থেকে প্রথম মৌলিক সংখ্যাটি চাই।

"আমার কতটি নমুনা করা উচিত?" - আপনাকে নির্দিষ্ট করতে হবে না
"আমাকে কি প্রথমে সমস্ত প্রাইম সন্ধান করতে হবে এবং তারপরে একটি এলোমেলো প্রাইম নির্বাচন করতে হবে?" - না

যেহেতু আমরা একটি জেনারেটরের সাথে কাজ করছি, এই কাজটি তুচ্ছ

const randomPrimeNumber = listOfNumbers => {
  for (let x of sample(Infinity) (listOfNumbers)) {
    if (isPrime(x))
      return x;
  }
  return NaN;
}

এটি অবিচ্ছিন্নভাবে একবারে 1 টি এলোমেলো সংখ্যার নমুনা দেবে x, এটি প্রাইম কিনা তা পরীক্ষা করে দেখুন, তা xহলে ফিরে আসুন । যদি কোনও মৌলিক সন্ধানের আগে সংখ্যার তালিকাটি শেষ হয়ে যায় NaNতবে ফিরে আসে।

বিঃদ্রঃ:

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

Question 26

getRandom (min, max) {
  return Math.floor(Math.random() * (max - min)) + min
}

getNRandom (min, max, n) {
  const numbers = []
  if (min > max) {
    return new Error('Max is gt min')
  }

  if (min === max) {
    return [min]
  }

  if ((max - min) >= n) {
    while (numbers.length < n) {
      let rand = this.getRandom(min, max + 1)
      if (numbers.indexOf(rand) === -1) {
        numbers.push(rand)
      }
    }
  }

  if ((max - min) < n) {
    for (let i = min; i <= max; i++) {
      numbers.push(i)
    }
  }
  return numbers
}

Question 27

একটি ব্যবহার Setকরা আপনার দ্রুততম বিকল্প। কলব্যাক জেনারেটর ব্যবহার করে এমন একটি অনন্য র্যান্ডম পাওয়ার জন্য এখানে একটি জেনেরিক ফাংশন। এখন এটি দ্রুত এবং পুনরায় ব্যবহারযোগ্য ।

// Get a unique 'anything'
let unique = new Set()

function getUnique(generator) {
  let number = generator()
  while (!unique.add(number)) {
    number = generator()
  }
  return number;
}

// The generator.  Return anything, not just numbers.
const between_1_100 = () => 1 + Math.floor(Math.random() * 100)

// Test it
for (var i = 0; i < 8; i++) {
  const aNumber = getUnique(between_1_100)
}
// Dump the 'stored numbers'
console.log(Array.from(unique))

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

Question 28

এটি ফিশার ইয়েটস / ডার্সটেনফিল্ড শফলের একটি বাস্তবায়ন , তবে উপলব্ধ অ্যারের সংখ্যার তুলনায় যখন পিকের আকার ছোট হয় তখন প্রয়োজনীয় অ্যারে তৈরি না করে প্রয়োজনীয় স্পেস জটিলতা বা স্মৃতিশক্তি হ্রাস করতে পারে।

100 থেকে 8 নম্বর বাছাই করতে 100 টি উপাদানের একটি অ্যারে তৈরি করা প্রয়োজন হবে না।

ধরে নিলাম একটি অ্যারে তৈরি হয়েছে,

অ্যারের শেষে (100), এলোমেলো নম্বর ( rnd) থেকে 1 থেকে 100 পান
100 এবং এলোমেলো নম্বর অদলবদল করুন rnd
অ্যারের সাথে ধাপ 1 পুনরাবৃত্তি করুন (99)

যদি একটি অ্যারে তৈরি না করা হয় তবে একটি হ্যাশম্যাপ প্রকৃত অদলবদল অবস্থানগুলি মনে রাখতে ব্যবহার করা যেতে পারে। যখন উত্পন্ন দ্বিতীয় এলোমেলো সংখ্যা পূর্বের উত্পন্ন সংখ্যার একের সমান হয় তখন মানচিত্রটি আসল মানের পরিবর্তে সেই অবস্থানে বর্তমান মান সরবরাহ করে।

const getRandom_ = (start, end) => {
  return Math.floor(Math.random() * (end - start + 1)) + start;
};
const getRealValue_ = (map, rnd) => {
  if (map.has(rnd)) {
    return getRealValue_(map, map.get(rnd));
  } else {
    return rnd;
  }
};
const getRandomNumbers = (n, start, end) => {
  const out = new Map();
  while (n--) {
    const rnd = getRandom_(start, end--);
    out.set(getRealValue_(out, rnd), end + 1);
  }
  return [...out.keys()];
};

console.info(getRandomNumbers(8, 1, 100));
console.info(getRandomNumbers(8, 1, Math.pow(10, 12)));
console.info(getRandomNumbers(800000, 1, Math.pow(10, 15)));

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

Question 29

এখানে কোনও নকল ছাড়াই 0 থেকে 100 (0 এবং 100 উভয়ই অন্তর্ভুক্ত) থেকে নেওয়া এলোমেলো 5 টি সংখ্যার উদাহরণ রয়েছে।

let finals = [];
const count = 5; // Considering 5 numbers
const max = 100;

for(let i = 0; i < max; i++){
  const rand = Math.round(Math.random() * max);
  !finals.includes(rand) && finals.push(rand)
}

finals = finals.slice(0, count)

Question 30

আপনি এটির মতো একটি ওলাইনারের সাহায্যে এটি করতে পারেন:

[...((add, set) => add(set, add))((set, add) => set.size < 8 ? add(set.add(Math.floor(Math.random()*100) + 1), add) : set, new Set())]