Wie kann ich ein Array mit 40 Elementen mit zufälligen Werten von 0 bis 39 erstellen? Mögen

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

Ich habe versucht, Lösungen von hier zu verwenden:

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

Aber das Array, das ich bekomme, ist sehr wenig zufällig. Es werden viele Blöcke aufeinanderfolgender Zahlen erzeugt ...

Hier ist eine Lösung, die eine Liste eindeutiger Zahlen mischt (keine Wiederholungen, niemals).

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);

Wenn Sie wiederholte Werte zulassen möchten (was nicht das OP wollte), schauen Sie woanders hin. :) :)

Der kürzeste Ansatz (ES6)

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

Genießen!

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));

Noch kürzerer ES6-Ansatz:

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

Sie könnten auch eine Funktion mit Argumenten haben:

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

Kürzeste :-)

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

Math.random()gibt eine Zahl zwischen 0 und 1 zurück (exklusiv). Wenn Sie also 0-40 möchten, können Sie es mit 40 multiplizieren. Das höchste Ergebnis, das jemals erzielt werden kann, ist das, mit dem Sie multiplizieren.

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/

.. das Array, das ich bekomme, ist sehr wenig zufällig. Es werden viele Blöcke aufeinanderfolgender Zahlen erzeugt ...

Sequenzen von zufälligen Gegenständen enthalten oft Blöcke aufeinanderfolgender Zahlen, siehe den Irrtum des Spielers . Beispielsweise:

.. wir haben gerade vier Köpfe hintereinander geworfen .. Da die Wahrscheinlichkeit eines Laufs von fünf aufeinanderfolgenden Köpfen nur 1⁄32 beträgt .. könnte eine Person, die dem Irrtum des Spielers ausgesetzt ist, glauben, dass dieser nächste Flip weniger wahrscheinlich Köpfe als war Schwänze sein. http://en.wikipedia.org/wiki/Gamblers_fallacy

Da der Zahlenbereich eingeschränkt ist, würde ich sagen, dass das Array am besten generiert, mit den Zahlen Null bis 39 (in der Reihenfolge) gefüllt und dann gemischt wird.

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

Das Array wurde auf 6 Werte begrenzt, um die Anzeige zu vereinfachen.

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

Dies ist die traditionelle Vorgehensweise, aber ich unterstütze @Pointy und @Phrogz, wenn Sie Duplikate in Ihrem Array vermeiden möchten, ohne teure Berechnungen durchführen zu müssen

Quirk Single-Line-Lösungen an jedem Tag.

Die Werte in Arrays sind völlig zufällig. Wenn Sie diese Snippets verwenden, ist dies anders.

Ein Array (Länge 10) mit zufälligen Zeichen in Kleinbuchstaben

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

['k', 'a', 'x', 'y', 'n', 'w', 'm', 'q', 'b', 'j']

Ein Array (Länge 10) mit zufälligen Ganzzahlen von 0 bis 99

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

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

Ein Array zufälliger Daten (von 10 Jahren bis vor heute)

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, 2014-08-06T21: 00: 00.000Z]

Ein Array (Länge 10) zufällige Zeichenfolgen

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('') });

['cubjjhaph', 'bmwy', 'alhobd', 'ceud', 'tnyullyn', 'vpkdflarhnf', 'hvg', 'arazuln', 'jzz', 'cyx']

Weitere nützliche Dinge finden Sie hier https://github.com/setivolkylany/nodejs-utils/blob/master/utils/faker.js

Mit einigen neuen ES6-Funktionen kann dies jetzt erreicht werden mit:

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);

Beachten Sie, dass diese Lösung nur in modernen Browsern funktioniert, die diese ES6-Funktionen unterstützen: Pfeilfunktionen und Array.from ().

Siehe unten: -

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

von der von @Phrogz vorgeschlagenen Seite

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 } );

Ich brauchte etwas anderes als das, was diese Lösungen gaben, da ich ein Array mit einer Reihe unterschiedlicher Zufallszahlen erstellen musste, die in einem bestimmten Bereich gehalten wurden. Unten ist meine Lösung.

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; 
}

Ich hätte es vorgezogen, keine Schleife zu erstellen, die die Möglichkeit hat, viele unnötige Anrufe zu tätigen (wenn Ihre Anzahl und Reichweite hoch sind und nahe an derselben Nummer liegen), aber dies ist das Beste, was ich mir vorstellen kann.

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
}

Ich denke, diese Methode wird das Problem mit den Wahrscheinlichkeiten lösen, die nur durch den Zufallszahlengenerator begrenzt sind.

Wenn Sie es mit zufälligen eindeutigen Werten von 0 benötigen ... Längenbereich:

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]

Ich bin mir ziemlich sicher, dass dies der kürzeste Weg ist, um Ihr zufälliges Array ohne Wiederholungen zu erstellen

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

Ein bisschen spät zur Party, aber ich benutze randojs.com für Zufälligkeit, weil es solche Sachen super einfach macht. Sie können ein zufällig gemischtes Array von Zahlen von 0 bis 39 wie folgt erhalten:

console.log(randoSequence(40));

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

Keine Aufregung mit der Logistik - außerdem ist es super lesbar und leicht zu verstehen :)

Generatoren

Ein Array mit einer Länge von 40 von 40 zufälligen möglichen Werten (0 - 39) ohne Wiederholung von Werten ist besser zu mischen, wie @Phrogz und @Jared Beck erklären. Ein anderer Ansatz, nur für die Aufzeichnungen, könnte die Verwendung von Generatoren sein. Bei diesem Ansatz mangelt es jedoch an Leistung im Vergleich zu anderen vorgeschlagenen Lösungen .

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