> pick | shuffle | pair <

// Liste einfügen, Gewinner ziehen, die Reihenfolge mischen oder Personen zu Gruppen zusammenstellen - alles in deinem Browser

EINGABELISTE:

MODUS:

N AUSWÄHLEN MISCHEN PAARE BILDEN

ANZAHL:

SEED (optional):

Duplikate erlauben (mit Zurücklegen) Eingabezeilen kürzen & Duplikate entfernen

ERGEBNIS:

[PICK_N]

N zufällige Einträge auswählen

Ziehe eine beliebige Anzahl von Gewinnern aus deiner Liste. Ohne Zurücklegen für eindeutige Gewinner oder mit Zurücklegen für gewichtungsähnliche Ziehungen.

[SHUFFLE]

Unverzerrter Fisher-Yates-Shuffle

Ordnet die gesamte Liste mit dem klassischen Knuth-Shuffle neu an. Jede Permutation ist gleich wahrscheinlich - keine naiven Sortier-Tricks hier.

[PAIRS]

Zu Gruppen zusammenstellen

Teile eine Teilnehmerliste in Paare, Dreiergruppen oder eine beliebige Gruppengröße. Perfekt für Partnerarbeit, Code-Review-Rotationen oder Wichtel-Paarungen.

[SEEDED]

Seed-basierte Reproduzierbarkeit

Gib eine Seed-Zeichenkette an, um eine deterministische Ziehung zu erhalten. Derselbe Seed plus dieselbe Liste ergibt immer dasselbe Ergebnis - teilbar und überprüfbar.

// ÜBER DIE ZUFALLSAUSWAHL

So funktioniert es:

Dieses Tool verwendet den Fisher-Yates- (auch Knuth-) Shuffle: gehe das Array vom letzten Index zum ersten durch und tausche bei jedem Schritt das aktuelle Element mit einem an einem gleichverteilt zufälligen früheren Index. Das erzeugt in O(n)-Zeit eine unverzerrte, gleichmäßige Permutation. Der naive Trick array.sort(() => Math.random() - 0.5) ist verzerrt, weil JavaScript-Sortiervergleiche transitiv sein müssen - zufällige Vergleiche verletzen das und verzerren die Verteilung. Für Ziehungen ohne Seed beziehen wir Entropie aus window.crypto.getRandomValues. Wenn du eine Seed-Zeichenkette angibst, hashen wir sie mit cyrb53 zu einer 53-Bit-Ganzzahl und treiben damit einen mulberry32-PRNG an, sodass identische Seeds identische, reproduzierbare Ergebnisse erzeugen.

Algorithmus:

for i = n-1 down to 1: j = randInt(0, i); swap(a[i], a[j]) - unbiased Fisher-Yates

Standards & Referenzen:

>Web Crypto API (W3C) - crypto.getRandomValues für kryptografisch starke Zufälligkeit
>Fisher-Yates-Shuffle (1938), bekannt gemacht von Donald Knuth in The Art of Computer Programming Bd. 2
>mulberry32 - kleiner, schneller, gut verteilter Seed-PRNG von Tommy Ettinger
>cyrb53 - 53-Bit-String-Hash von bryc, um eine Seed-Zeichenkette in einen numerischen PRNG-Zustand zu verwandeln

Häufige Anwendungsfälle:

>Gewinnspiele, Verlosungen und das Bestimmen eines zufälligen Gewinners aus Einsendungen
>Namensziehungen im Klassenzimmer und Auswahl für spontane Wortmeldungen
>Sportteam-Paarungen, Partner-Workouts und Turnierbäume
>Zuweisung von Code-Review-Prüfern in einem Entwicklungsteam
>Stichprobenauswahl für A/B-Tests und randomisierte Umfragegruppen
>Wichtel-Paare, Geschenketausch und Mittagessen-Buddys im Team
>Zufällige Testeingaben und Fuzzing-Seeds für die QA
>Gruppenbasierte Entscheidungsfindung und Stichentscheide
>Schein-Geschworenenauswahl und randomisierte Interviewpanels
>Lotterieartige Ziehungen für Gemeindeveranstaltungen und Preise

// BEISPIELZIEHUNGEN

Gewinnspiel — 3 Gewinner aus 50 Einsendungen ziehen

> input:

alice@x.com
bob@x.com
carlos@x.com
…(50 Zeilen insgesamt)

> config:

Modus=Pick N, Anzahl=3, Duplikate erlauben=aus, Seed=(leer)

> output:

1. carlos@x.com
2. priya@x.com
3. wei@x.com

Eine Liste mit 10 Namen für eine Präsentationsreihenfolge mischen

> input:

Alice
Bob
Charlie
Dana
Evelyn
Farouk
Gabriela
Hiroshi
Isabella
Jamal

> config:

Modus=Shuffle, Seed=(leer)

> output:

1. Hiroshi
2. Alice
3. Farouk
4. Jamal
5. Dana
6. Evelyn
7. Bob
8. Isabella
9. Gabriela
10. Charlie

Eine Klasse mit 12 Schülern in Zweiergruppen einteilen

> input:

S01
S02
S03
S04
S05
S06
S07
S08
S09
S10
S11
S12

> config:

Modus=Pair Up, Gruppengröße=2, Seed=class-2026-05-02

> output:

Gruppe 1: S07, S02
Gruppe 2: S11, S04
Gruppe 3: S09, S12
Gruppe 4: S01, S06
Gruppe 5: S03, S10
Gruppe 6: S08, S05

Reproduzierbare Seed-Ziehung — zweimal mit demselben Seed ausführen, dieselben Gewinner erhalten

> input:

alpha
bravo
charlie
delta
echo
foxtrot
golf
hotel

> config:

Modus=Pick N, Anzahl=2, Seed=launch-day, Duplikate erlauben=aus

> output:

Lauf 1: 1. echo
        2. bravo
Lauf 2: 1. echo
        2. bravo  (identisch — seed-basiert)

// WARUM NAIVES .SORT() VERZERRT IST

Ein verbreiteter Einzeiler-Shuffle ist arr.sort(() => Math.random() - 0.5). Er sieht elegant aus, läuft in einer Zeile und fühlt sich zufällig an — aber die resultierende Permutationsverteilung ist alles andere als gleichmäßig. Die ECMAScript-Spezifikation verlangt, dass Vergleichsfunktionen deterministisch und transitiv sind: wenn a < b und b < c, dann a < c. Ein Münzwurf-Vergleich verletzt diesen Vertrag, und die Sortier-Implementierung der Engine besucht Vergleichspaare in einem ungleichmäßigen Muster.

V8 (Chrome, Node) verwendet Timsort; ältere Engines nutzten Quicksort oder Mergesort. Jede Implementierung besucht eine andere Teilmenge von Vergleichspaaren und verwendet zwischengespeicherte Vergleiche auf unterschiedliche Weise wieder. Wie Mike Bostock empirisch gezeigt hat (bost.ocks.org/mike/shuffle/compare.html), erzeugt die naive Sortierung stark verzerrte Ausgaben, bei denen einige Permutationen mehrfach häufiger erscheinen als andere — inakzeptabel für ein Gewinnspiel, einen A/B-Eimer oder jede Ziehung, die fair sein muss.

Der korrekte Algorithmus ist Fisher-Yates (Knuth-Shuffle): gehe das Array vom letzten Index bis zum ersten durch und tausche bei jedem Schritt das aktuelle Element mit einem gleichverteilt zufällig aus den Indizes 0..i gewählten. Er läuft in O(n), benötigt O(1) zusätzlichen Speicher und erzeugt nachweislich jede Permutation mit gleicher Wahrscheinlichkeit.

// BAD: NOT uniformly random
const shuffled = arr.sort(() => Math.random() - 0.5);

// GOOD: Fisher-Yates (Knuth) shuffle
function shuffle(arr) {
  const a = arr.slice();
  for (let i = a.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}

// SELBST IMPLEMENTIEREN

Möchtest du deine eigene Auswahl bauen oder unsere prüfen? Das sind genau die Primitiven, die diese Seite verwendet — klein, ohne Abhängigkeiten und identisch mit dem, was in deinem Browser läuft, wenn du auf PICK klickst. Kopiere sie direkt in ein Node-Skript oder eine andere Web-App.

// Fisher-Yates shuffle (uniform, O(n))

function shuffle(arr, rng = Math.random) {
  const a = arr.slice();
  for (let i = a.length - 1; i > 0; i--) {
    const j = Math.floor(rng() * (i + 1));
    [a[i], a[j]] = [a[j], a[i]];
  }
  return a;
}

// Pick N without replacement (shuffle then slice)

function pickN(arr, n, rng = Math.random) {
  if (n > arr.length) {
    throw new Error('n exceeds list size');
  }
  return shuffle(arr, rng).slice(0, n);
}

// mulberry32 seeded PRNG + cyrb53 string hash

// cyrb53: turn a seed string into a 53-bit integer
function cyrb53(str, seed = 0) {
  let h1 = 0xdeadbeef ^ seed;
  let h2 = 0x41c6ce57 ^ seed;
  for (let i = 0, ch; i < str.length; i++) {
    ch = str.charCodeAt(i);
    h1 = Math.imul(h1 ^ ch, 2654435761);
    h2 = Math.imul(h2 ^ ch, 1597334677);
  }
  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^
       Math.imul(h2 ^ (h2 >>> 13), 3266489909);
  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^
       Math.imul(h1 ^ (h1 >>> 13), 3266489909);
  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
}

// mulberry32: tiny seeded PRNG -> [0, 1)
function mulberry32(a) {
  return function () {
    a |= 0; a = (a + 0x6D2B79F5) | 0;
    let t = a;
    t = Math.imul(t ^ (t >>> 15), t | 1);
    t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
    return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
  };
}

// Build a seeded picker:
const h = cyrb53('my-seed', 1);
const state = (h ^ Math.floor(h / 4294967296)) >>> 0;
const rng = mulberry32(state);
const winners = pickN(['alice', 'bob', 'carlos'], 2, rng);

>> häufig gestellte fragen

F: Wie wird die Zufälligkeit erzeugt?

A: Wenn kein Seed angegeben wird, verwenden wir window.crypto.getRandomValues, den kryptografisch sicheren Zufallszahlengenerator des Browsers auf Basis der Web Crypto API. Es ist dieselbe Entropiequelle, die für kryptografische Schlüssel und Tokens genutzt wird, also mehr als stark genug für Verlosungen und Mischungen. Wenn du einen Seed angibst, leiten wir deterministisch einen 53-Bit-Zustand über den cyrb53-String-Hash ab und speisen ihn in einen mulberry32-PRNG, sodass die Ziehung reproduzierbar ist.

F: Kann ich mit einem Seed dasselbe Ergebnis zweimal erhalten?

A: Ja. Gib eine beliebige Zeichenkette in das SEED-Feld ein - ein Datum, einen Wettbewerbsnamen, einen Hash, irgendetwas. Derselbe Seed in Kombination mit derselben Eingabeliste und demselben Modus erzeugt immer exakt dieselbe Ausgabe. Das ist von unschätzbarem Wert für transparente Gewinnspiele, bei denen du den Seed im Voraus veröffentlichen und Teilnehmer die Ziehung überprüfen lassen möchtest, oder für Entwicklungsrotationen, die maschinenübergreifend reproduzierbar sein müssen.

F: Was ist der Unterschied zwischen Pick N und Shuffle?

A: Pick N wählt eine Teilmenge der Größe N aus deiner Liste, optional mit Zurücklegen (Duplikate erlaubt). Shuffle gibt die gesamte Liste neu geordnet zurück - keine Einträge werden entfernt oder wiederholt, nur umgeordnet. Verwende Pick N, wenn du nur wenige Gewinner aus vielen Einsendungen möchtest; verwende Shuffle, wenn jeder Eintrag weiterhin teilnehmen soll, aber in einer neuen zufälligen Reihenfolge, etwa eine Präsentationswarteschlange oder Playlist.

F: Ist array.sort(() => Math.random() - 0.5) tatsächlich zufällig?

A: Nein, es ist verzerrt. Die ECMAScript-Spezifikation verlangt, dass Sortiervergleiche deterministisch und transitiv sind (wenn a < b und b < c, dann a < c). Ein zufälliger Vergleich verletzt diesen Vertrag, und verschiedene JavaScript-Engines führen unterschiedliche zugrunde liegende Sortieralgorithmen aus (TimSort, Mergesort, Quicksort), die auf unterschiedliche Weise mit dem zufälligen Vergleich interagieren. Das Ergebnis ist eine ungleichmäßige Verteilung, bei der einige Permutationen weit häufiger erscheinen als andere. Fisher-Yates ist der korrekte Algorithmus.

F: Kann ich eine Liste mit ungerader Anzahl paaren?

A: Ja. Der Modus Pair Up mischt deine Liste mit Fisher-Yates und teilt sie dann nach deiner gewählten Gruppengröße auf. Wenn die Gesamtzahl nicht gleichmäßig aufgeht, ist die letzte Gruppe kleiner und wird in der Ausgabe deutlich als Restgruppe gekennzeichnet. Bei einer ungeraden Liste kannst du entweder einen Einzeleintrag akzeptieren, die Gruppengröße erhöhen oder vor der Ziehung einen Platzhalternamen wie "frei" hinzufügen.

F: Wird meine Liste irgendwohin hochgeladen?

A: Nein. Dieses Tool läuft zu 100 % clientseitig - deine Liste, dein Seed und die Ausgabe verlassen niemals deinen Browser. Es gibt keinen Serveraufruf, kein Logging und keine Analyse der Eingabe. Du kannst dich nach dem Laden der Seite vom Internet trennen, und jede Schaltfläche funktioniert weiterhin. Lade die Seite neu und die Daten sind endgültig weg.

F: Gibt es eine visuelle Glücksrad-Version dieses Tools?

A: Für ein interaktives Namensrad-Erlebnis mit Animation, Soundeffekten und einer großen visuellen Enthüllung siehe randompickerwheel.app. Es ist ein ergänzendes Produkt mit Fokus auf Live-Publikumsziehungen und Bildschirmfreigabe. Diese Seite ist eine textorientierte Auswahl mit Fokus auf Massenlisten, reproduzierbare Seed-Ziehungen, CSV-Export und Paarbildung - nützlich, wenn du eine schnelle deterministische Antwort statt einer Präsentation brauchst.

// OTHER LANGUAGES

🇺🇸 English 🇫🇷 Français 🇩🇪 Deutsch 🇪🇸 Español 🇵🇹 Português 🇮🇹 Italiano 🇳🇱 Nederlands 🇷🇺 Русский 🇯🇵 日本語 🇰🇷 한국어 🇹🇼 繁體中文 🇸🇦 العربية 🇵🇱 Polski 🇸🇪 Svenska 🇩🇰 Dansk

> pick | shuffle | pair <

N zufällige Einträge auswählen

Unverzerrter Fisher-Yates-Shuffle

Zu Gruppen zusammenstellen

Seed-basierte Reproduzierbarkeit

// ÜBER DIE ZUFALLSAUSWAHL

So funktioniert es:

Standards & Referenzen:

Häufige Anwendungsfälle:

Verwandte Tools:

// BEISPIELZIEHUNGEN

Gewinnspiel — 3 Gewinner aus 50 Einsendungen ziehen

Eine Liste mit 10 Namen für eine Präsentationsreihenfolge mischen

Eine Klasse mit 12 Schülern in Zweiergruppen einteilen

Reproduzierbare Seed-Ziehung — zweimal mit demselben Seed ausführen, dieselben Gewinner erhalten

// WARUM NAIVES .SORT() VERZERRT IST

// SELBST IMPLEMENTIEREN

>> häufig gestellte fragen

// OTHER LANGUAGES