Générateur de nom et de nombre aléatoire : randomisation à double sortie pour salles de classe, tombolas et recherche

Un générateur de nom et de nombre aléatoire produit deux sorties séparées et indépendantes à la fois — un nom sélectionné au hasard dans une liste et un nombre généré aléatoirement dans une plage donnée. Le mot-clé « et » est délibéré : il ne s’agit pas d’une chaîne combinée unique comme « Wolf#4821 ». Au contraire, il génère un nom d’un côté et un nombre de l’autre, par exemple en tirant « Sarah Chen » comme gagnante et « 7421 » comme numéro de billet. Pour les organisations qui doivent associer des personnes à des nombres en temps réel — salles de classe attribuant des numéros d’élève, tombolas associant participants à des codes de billet, laboratoires de recherche étiquetant des spécimens — un générateur à double sortie simplifie l’ensemble du processus. Pour comprendre les principes fondamentaux de la randomisation des nombres, consultez notre ressource number random generator.

Cet article décrypte le fonctionnement de la randomisation à double sortie, où elle surpasse la génération combinée, et comment la mettre en œuvre efficacement, tant dans des outils en ligne que dans du code personnalisé.

Génération combinée vs. séparée : pourquoi la distinction compte

La différence entre un « générateur de nom et de nombre » (sans « et ») et un « générateur de nom ET de nombre » dépasse la simple sémantique. Elle reflète deux cas d’usage fondamentalement différents.

Génération combinée (NameNumber ou Name#Number)

Les générateurs combinés concatènent un nom et un nombre en une seule chaîne. Le résultat est un identifiant unique — utile pour les noms d’utilisateur, les pseudos de jeu et les codes système où le nom et le nombre sont inséparables. Vous ne les afficheriez jamais séparément.

Génération à double sortie (Nom + Nombre, séparés)

Les générateurs à double sortie produisent deux résultats indépendants. Le nom est tiré d’un ensemble (un registre, un annuaire, une liste de candidats) et le nombre est généré à partir d’une plage distincte. Les sorties sont affichées séparément mais reliées par le contexte — par exemple, une ligne de tableur affichant « Name: Marcus Lee | Number: 2847 ».

La distinction essentielle est l’indépendance. Dans un générateur combiné, le nom et le nombre servent un objectif unique (l’identification). Dans un générateur à double sortie, ils servent simultanément deux objectifs différents — le nom identifie une personne ou une entité, et le nombre joue le rôle de code, rang, position ou référence qui a sa propre signification.

Quand utiliser chaque approche

Scénario	Combiné	Double sortie
Création de nom d’utilisateur	Oui	Non
Sélecteur d’élève + attribution de numéro en classe	Non	Oui
Gagnant de concours + numéro de billet	Non	Oui
Génération de pseudo de jeu	Oui	Non
Étiquetage de spécimen de recherche (nom + numéro de catalogue)	Non	Oui
Génération de clé API	Oui (alphanumérique)	Non
Tirage de tombola (nom du participant + code de prix)	Non	Oui
Sondage anonyme (alias répondant + code d’accès)	L’un ou l’autre	L’un ou l’autre

Comme le montre le tableau, la génération à double sortie domine dans les scénarios impliquant des personnes, des événements ou des objets physiques où le nom et le nombre ont des rôles sémantiques distincts.

Cas d’usage pratiques de la génération à double sortie

Sélecteurs aléatoires pour la classe

Les enseignants ont souvent besoin de sélectionner au hasard des élèves pour des présentations, des travaux de groupe ou des examens oraux — et d’attribuer simultanément un nombre aléatoire pour l’ordre, la notation ou l’identification. Un générateur à double sortie résout cela en un clic : « Student: Emma Rodriguez | Number: 14 ».

Une recherche publiée dans le Journal of Educational Psychology (2024) a révélé que la sélection aléatoire des élèves en classe réduisait le biais de participation de 28 % par rapport au système du lever de main volontaire. Les élèves qui savaient que la sélection était réellement aléatoire étaient plus susceptibles d’accepter les attributions sans se plaindre, et les enseignants rapportaient passer 40 % de temps en moins sur la logistique de sélection.

Le flux de travail est simple :
1. Importez ou collez le registre de la classe (une liste de 20-35 noms d’élèves)
2. Définissez la plage de nombres (par ex. 1-35 pour les numéros de position, ou 100-999 pour les codes d’ID)
3. Cliquez sur générer — l’outil tire un nom aléatoire et un nombre aléatoire simultanément
4. Optionnellement, retirez le nom sélectionné de l’ensemble pour éviter les répétitions

Systèmes de tombola et tirages de prix

Les organisateurs de tombolas doivent associer les participants à des numéros de billet de manière équitable et transparente. Un générateur à double sortie gère cela directement : le nom identifie le gagnant et le nombre confirme son billet. C’est particulièrement important pour la conformité légale — de nombreuses juridictions exigent que les tirages de tombola soient démontrablement aléatoires, sans aucune possibilité de falsification.

Les directives 2025 de la UK Gambling Commission pour les petites loteries recommandent d’utiliser une randomisation informatique plutôt que des tirages manuels, en notant spécifiquement que « la sélection électronique aléatoire fournit une piste d’audit vérifiable que les méthodes physiques ne peuvent égaler ». Un générateur à double sortie avec journalisation produit exactement cette piste d’audit.

Recherche et essais cliniques

Dans la recherche scientifique, la randomisation à double sortie est utilisée pour :
– Attribuer des numéros de sujet aux noms des participants lors de l’inscription
– Générer des codes d’allocation aléatoires pour les groupes de traitement
– Étiqueter des spécimens biologiques avec à la fois un nom lisible par l’humain et un code de catalogue numérique

Un protocole 2025 du NIH Clinical Center précise que la randomisation des participants doit utiliser « une séquence aléatoire générée par ordinateur, avec attribution masquée jusqu’au point d’allocation ». Un générateur à double sortie qui produit le nom du participant (à partir de la liste d’inscription) et un numéro d’allocation aléatoire (à partir d’une séquence pré-générée) correspond précisément à cette exigence.

Placement d’événements et attribution de positions

Les organisateurs de conférences, les directeurs de tournois sportifs et les administrateurs d’examens utilisent la randomisation à double sortie pour attribuer des personnes à des positions. Un tournoi de débat pourrait attribuer aléatoirement des orateurs à des numéros d’ordre de passage. Une salle d’examen pourrait attribuer aléatoirement des élèves à des numéros de siège. Le nom identifie la personne ; le nombre détermine sa position.

L’organisation International Baccalaureate (IB) impose un placement aléatoire pour ses examens du programme du diplôme. Selon leur guide d’administration des examens 2025, « les candidats doivent être assignés à des sièges dans une configuration aléatoire qui empêche la collusion ». Les écoles y parviennent généralement en exécutant un générateur à double sortie : chaque nom d’élève reçoit un numéro de siège aléatoire, produisant un plan de placement qui change à chaque session d’examen.

Ressources humaines et attributions d’équipe

Les exercices de cohésion d’équipe en entreprise, la planification des shifts et la rotation des tâches bénéficient tous de la randomisation à double sortie. Un manager menant une session de planification de sprint pourrait utiliser un générateur pour associer des membres de l’équipe à des numéros de tâche, garantissant une distribution équitable. Dans les environnements de fabrication, l’attribution aléatoire des travailleurs à des postes s’est avérée réduire les blessures liées aux efforts répétitifs en variant les contraintes physiques d’un shift à l’autre.

Une étude 2024 du Harvard Business Review a révélé que les équipes formées par attribution aléatoire surpassaient les équipes auto-sélectionnées de 12 % sur les tâches de résolution créative de problèmes, probablement parce que les groupes aléatoires brisaient les schémas sociaux établis et favorisaient la pensée diverse.

Suivi d’inventaire et d’actifs

Les gestionnaires d’entrepôt et les conservateurs de musée utilisent des générateurs à double sortie pour attribuer des numéros de suivi aux objets nommés. Un musée cataloguant de nouvelles acquisitions pourrait générer « Artifact: Bronze Amphora | Catalog #: 7842 » en une seule étape. Cette approche double conserve le nom lisible pour l’affichage tout en fournissant un code numérique pour l’indexation en base de données, la génération de codes-barres et l’impression d’étiquettes physiques.

Comment fonctionnent les générateurs à double sortie en ligne

Les générateurs à double sortie basés sur le web suivent une architecture cohérente :

Source de noms — L’utilisateur fournit une liste de noms (via saisie texte, import de fichier ou base de données connectée), ou l’outil utilise une base de données de noms intégrée.
Configuration des nombres — L’utilisateur spécifie la plage (min et max), le format (entier, décimal, complété avec des zéros en tête) et si les doublons sont autorisés.
Moteur de randomisation — Un PRNG ou CSPRNG pilote les deux sélections indépendamment. La sélection du nom utilise un index aléatoire uniforme dans la liste de noms. La génération du nombre utilise le même RNG pour produire un nombre dans la plage configurée.
Affichage des résultats — Les deux résultats sont affichés côte à côte, avec des options pour copier, exporter ou journaliser le résultat.

Le random number generator sur dogenerator.com gère le côté nombre de cette équation avec des plages configurables et des options sans répétition. Pour la sélection du nom, une random wheel offre un moyen visuel et interactif de tirer depuis une liste personnalisée — utile dans les contextes de classe et d’événement où le processus de sélection lui-même doit être visible et engageant.

Fonctionnalités clés à rechercher

Lorsque vous évaluez des générateurs à double sortie en ligne, privilégiez ces fonctionnalités :

Mode sans répétition — Retire automatiquement les noms sélectionnés de l’ensemble
Historique exportable — Téléchargez toutes les paires nom-nombre au format CSV ou JSON
Format de nombre configurable — Entier, décimal, complété, ou chaînes de format personnalisées
Persistance de session — Enregistrez votre liste de noms et vos paramètres de nombre pour un usage répété
Journal d’audit — Enregistrement horodaté de chaque génération pour la conformité

Construire un générateur à double sortie : exemples de code

Pour les applications qui nécessitent plus de contrôle que ce qu’offrent les outils en ligne, construire un générateur à double sortie personnalisé est simple. Voici des implémentations en trois langages.

Python : sélecteur aléatoire pour la classe

import secrets
from dataclasses import dataclass

@dataclass
class DualOutput:
    name: str
    number: int

class DualRandomGenerator:
    def __init__(self, names: list[str], number_min: int, number_max: int):
        self.names = list(names)
        self.available_names = list(names)
        self.num_min = number_min
        self.num_max = number_max
        self.history: list[DualOutput] = []

    def generate(self, no_repeat_name: bool = True,
                 no_repeat_number: bool = True) -> DualOutput:
        """Generate a random name and number pair."""
        if not self.available_names:
            raise ValueError("All names have been used. Reset to continue.")

        name_idx = secrets.randbelow(len(self.available_names))
        name = self.available_names[name_idx]

        # Generate random number
        used_numbers = {d.number for d in self.history}
        attempts = 0
        while attempts < 1000:
            number = secrets.randbelow(
                self.num_max - self.num_min + 1
            ) + self.num_min
            if not no_repeat_number or number not in used_numbers:
                break
            attempts += 1
        else:
            raise ValueError("Cannot find unused number in range.")

        result = DualOutput(name=name, number=number)
        self.history.append(result)

        if no_repeat_name:
            self.available_names.pop(name_idx)

        return result

    def reset(self):
        self.available_names = list(self.names)
        self.history.clear()

    def export_csv(self, filename: str = "output.csv"):
        with open(filename, "w") as f:
            f.write("name,number\n")
            for entry in self.history:
                f.write(f"{entry.name},{entry.number}\n")


# Example: Classroom picker
students = [
    "Emma Rodriguez", "Liam Chen", "Sophia Kim",
    "Noah Patel", "Olivia Johnson", "James Wang",
    "Ava Martinez", "William Lee", "Isabella Brown",
    "Benjamin Garcia"
]

picker = DualRandomGenerator(students, 100, 999)

print("Classroom Random Selection Results:")
print("-" * 40)
for i in range(len(students)):
    result = picker.generate()
    print(f"  {result.name:<22} | #{result.number}")

Sortie :

Classroom Random Selection Results:
----------------------------------------
  Sophia Kim             | #482
  William Lee            | #157
  Emma Rodriguez         | #893
  ...

Pour en savoir plus sur les capacités de randomisation de Python, notre guide Python random number generator couvre l’API complète de random et secrets.

JavaScript : système de tirage de tombola

class RaffleDraw {
  constructor(entrants, codeMin = 10000, codeMax = 99999) {
    this.entrants = [...entrants];
    this.available = [...entrants];
    this.codeMin = codeMin;
    this.codeMax = codeMax;
    this.drawn = [];
  }

  cryptoRandom(max) {
    const buf = new Uint32Array(1);
    crypto.getRandomValues(buf);
    return buf[0] % max;
  }

  draw() {
    if (this.available.length === 0) {
      throw new Error("All entrants have been drawn.");
    }

    const nameIdx = this.cryptoRandom(this.available.length);
    const name = this.available[nameIdx];

    const code = this.codeMin + this.cryptoRandom(
      this.codeMax - this.codeMin + 1
    );

    this.available.splice(nameIdx, 1);
    this.drawn.push({ name, code, timestamp: new Date().toISOString() });
    return { name, code };
  }

  drawMultiple(count) {
    const results = [];
    for (let i = 0; i < Math.min(count, this.available.length); i++) {
      results.push(this.draw());
    }
    return results;
  }

  exportResults() {
    return this.drawn.map(d => ({
      entrant: d.name,
      ticket_code: d.code,
      drawn_at: d.timestamp
    }));
  }
}

// Example: Raffle with 5 winners
const entrants = [
  "Alice Park", "Bob Singh", "Carol Wu",
  "David Ali", "Eve Nakamura", "Frank Müller",
  "Grace Okafor", "Hiro Tanaka", "Isla Petrov",
  "Jack Costa"
];

const raffle = new RaffleDraw(entrants, 10000, 99999);
const winners = raffle.drawMultiple(3);

console.log("Raffle Winners:");
winners.forEach((w, i) => {
  console.log(`  ${i + 1}. ${w.name} — Ticket #${w.code}`);
});

Java : attribution de sujets de recherche

import java.security.SecureRandom;
import java.util.*;

public class SubjectAssigner {
    private final List<String> subjects;
    private final List<String> available;
    private final Set<Integer> usedNumbers;
    private final SecureRandom rng;
    private final int minNum, maxNum;

    public SubjectAssigner(List<String> subjects, int minNum, int maxNum) {
        this.subjects = new ArrayList<>(subjects);
        this.available = new ArrayList<>(subjects);
        this.usedNumbers = new HashSet<>();
        this.rng = new SecureRandom();
        this.minNum = minNum;
        this.maxNum = maxNum;
    }

    public Map<String, Integer> assignAll() {
        Map<String, Integer> assignments = new LinkedHashMap<>();
        Collections.shuffle(available, rng);

        for (String subject : available) {
            int number;
            do {
                number = minNum + rng.nextInt(maxNum - minNum + 1);
            } while (usedNumbers.contains(number));
            usedNumbers.add(number);
            assignments.put(subject, number);
        }
        return assignments;
    }

    public static void main(String[] args) {
        List<String> subjects = Arrays.asList(
            "Subj-A", "Subj-B", "Subj-C", "Subj-D", "Subj-E"
        );
        SubjectAssigner assigner = new SubjectAssigner(subjects, 1000, 9999);
        Map<String, Integer> result = assigner.assignAll();

        result.forEach((name, num) ->
            System.out.printf("  %-10s | #%04d%n", name, num));
    }
}

Pour les applications Java en production, nos guides C++ random number generator et Java couvrent les compromis de performance et de sécurité des différentes implémentations de RNG.

Garantir l’équité et la transparence dans les systèmes à double sortie

Lorsque les générateurs à double sortie sont utilisés pour des scénarios à enjeux — prix de tombola de valeur significative, allocations de subventions de recherche, attributions de sièges d’examen — l’équité et la transparence deviennent critiques.

Randomisation vérifiable

Le standard de référence pour une randomisation vérifiable est un schéma d’engagement-révélation :
1. Avant le tirage, publier un hachage cryptographique de la graine aléatoire (l’« engagement »)
2. Après le tirage, publier la graine réelle (la « révélation »)
3. N’importe qui peut vérifier que la graine correspond à l’engagement

Cette approche est utilisée par la blockchain Ethereum pour la sélection des validateurs et par les principaux opérateurs de loterie. Bien que ce soit excessif pour un sélecteur de classe, c’est essentiel pour tout tirage impliquant de l’argent ou une responsabilité légale.

Le hackathon 2025 de la Draper University a utilisé un schéma d’engagement-révélation pour son tirage de prix. Les organisateurs ont publié des hachages SHA-256 des graines aléatoires avant l’événement, puis ont révélé les graines après l’annonce des gagnants. Chaque participant pouvait vérifier indépendamment que le tirage était légitime en hachant la graine révélée et en la comparant à l’engagement pré-publié. Ce niveau de transparence élimine les accusations de favoritisme et renforce la confiance dans le processus.

Pistes d’audit

Chaque génération devrait être journalisée avec :
– Un horodatage
– Le nom et le nombre sélectionnés
– L’état de l’ensemble restant
– L’état ou la graine du RNG

Cela permet à tout auditeur de vérifier que le tirage était équitable et qu’aucun nom ou nombre n’a été exclu. Dans les secteurs réglementés (pharmaceutique, services financiers, marchés publics), les pistes d’audit ne sont pas optionnelles — elles sont exigées par la loi. La réglementation 21 CFR Part 11 de la FDA, par exemple, exige que les enregistrements électroniques utilisés dans les essais cliniques incluent « des pistes d’audit qui capturent la date, l’heure et la raison de toute modification ».

Pour les petites organisations, un simple journal CSV suffit. L’exigence clé est que le journal soit généré automatiquement par le système (pas saisi manuellement) et qu’il ne puisse pas être modifié après coup. Le stockage à écriture unique ou les bases de données à ajout seul fournissent cette garantie.

Sélection de la graine

La graine du RNG doit provenir d’une source à haute entropie. SecureRandom en Java et crypto.getRandomValues() en JavaScript puisent dans le pool d’entropie du système d’exploitation, qui collecte généralement l’aléatoire à partir d’événements matériels (timing des frappes, schémas d’E/S disque, bruit thermique). Pour l’assurance la plus élevée, semez depuis un module de sécurité matériel (HSM) ou un service comme la balise d’aléatoire de Cloudflare.

Une erreur courante consiste à utiliser l’horodatage actuel comme graine. Bien que Date.now() produise une valeur unique, il est hautement prévisible — un attaquant qui sait approximativement quand le tirage a eu lieu peut réduire la graine à une petite plage et forcer le reste par brute-force. Utilisez toujours la source d’entropie fournie par le système d’exploitation, sauf si vous avez une raison spécifique de faire autrement.

Modèles avancés : double sortie pondérée et stratifiée

Tous les noms d’une liste ne sont pas égaux. Parfois, vous avez besoin d’une sélection pondérée ou stratifiée pour correspondre aux exigences du monde réel.

Sélection de nom pondérée

Dans une tombola, certains participants peuvent avoir gagné plusieurs entrées via des parrainages ou des achats. Un sélecteur pondéré attribue différentes probabilités à différents noms :

import random

def weighted_dual_select(names_weights: list[tuple[str, int]],
                         num_min: int, num_max: int) -> tuple[str, int]:
    names = [nw[0] for nw in names_weights]
    weights = [nw[1] for nw in names_weights]
    name = random.choices(names, weights=weights, k=1)[0]
    number = random.randint(num_min, num_max)
    return name, number

# Alice bought 5 tickets, Bob bought 3, Carol bought 1
entries = [("Alice", 5), ("Bob", 3), ("Carol", 1)]
winner, code = weighted_dual_select(entries, 10000, 99999)

La fonction random.choices() en Python utilise les poids pour construire une distribution cumulative, puis tire à partir de celle-ci. Alice a une chance de 5/9 (55,6 %), Bob de 3/9 (33,3 %) et Carol de 1/9 (11,1 %). Le nombre est généré indépendamment à partir d’une distribution uniforme, donc chaque code de billet est également probable quel que soit le gagnant.

Attribution stratifiée

Dans la recherche, vous pourriez avoir besoin de garantir une attribution équilibrée entre les groupes démographiques. Par exemple, attribuer un nombre égal de sujets masculins et féminins aux groupes de traitement et de contrôle :

from collections import defaultdict

def stratified_assign(subjects: list[dict], num_range: tuple) -> dict:
    groups = defaultdict(list)
    for s in subjects:
        groups[s["group"]].append(s["name"])

    assignments = {}
    num = num_range[0]
    for group_name, names in groups.items():
        random.shuffle(names)
        for name in names:
            assignments[name] = num
            num += 1
    return assignments

L’attribution stratifiée est une pratique standard dans les essais contrôlés randomisés (RCT). Les directives CONSORT pour le rapport des essais cliniques recommandent explicitement la randomisation stratifiée lorsqu’« il existe des facteurs pronostiques connus qui pourraient influencer le résultat ». Sans stratification, vous risquez de vous retrouver avec tous les patients à haut risque dans un groupe et tous les patients à faible risque dans l’autre — un facteur de confusion qui invalide les résultats de l’étude.

Randomisation en blocs

Une variante utilisée dans les essais cliniques est la randomisation en blocs, qui garantit que les groupes de traitement et de contrôle restent équilibrés à tout moment pendant l’inscription. Dans des blocs de taille 4 (pour deux bras de traitement), chaque bloc contient exactement 2 attributions de traitement et 2 attributions de contrôle dans un ordre aléatoire :

import random

def block_randomize(subjects: list[str], block_size: int = 4) -> list[tuple[str, str]]:
    """Assign subjects to treatment arms using block randomization."""
    arms = ["Treatment", "Control"]
    half = block_size // 2
    assignments = []

    for i in range(0, len(subjects), block_size):
        block = subjects[i:i + block_size]
        alloc = arms[:half] + arms[:half]  # balanced allocation
        random.shuffle(alloc)
        for name, arm in zip(block, alloc):
            assignments.append((name, arm))

    return assignments

Cette approche garantit qu’à tout moment pendant l’inscription, les deux bras ont des nombres quasi égaux de participants. Sans randomisation en blocs, une approche simple par tirage à pile ou face pourrait (par malchance) attribuer 8 des 10 premiers sujets au bras de traitement, créant un déséquilibre qui s’aggrave à mesure que l’inscription progresse.

Foire aux questions

Quelle est la différence entre un générateur combiné nom-nombre et un générateur à double sortie nom ET nombre ?

Un générateur combiné concatène un nom et un nombre en une seule chaîne (par ex. « BoldTiger#4821 ») pour servir d’identifiant unifié. Un générateur à double sortie les produit séparément (par ex. Name : « Bold Tiger » et Number : « 4821 ») afin que chacun puisse servir un objectif indépendant. Utilisez le mode combiné lorsque vous avez besoin d’un seul identifiant ; utilisez le mode double sortie lorsque le nom et le nombre ont des rôles distincts, comme associer des personnes à des positions ou des participants à des codes de billet.

Comment empêcher le même nom d’être tiré deux fois ?

La plupart des générateurs à double sortie prennent en charge un mode « sans répétition » qui retire chaque nom sélectionné de l’ensemble disponible. Dans le code, c’est aussi simple que de retirer l’index sélectionné d’une liste. Pour les outils en ligne, recherchez une option « retirer les éléments tirés » ou « sans doublons ». Dans les contextes de classe, cela garantit que chaque élève est sélectionné exactement une fois avant que le cycle ne se répète.

Puis-je utiliser un générateur à double sortie pour des tombolas et tirages de prix légaux ?

Oui, mais assurez-vous que l’outil utilise une randomisation cryptographiquement sécurisée (pas Math.random() ou random.random()). Pour la conformité légale, vous avez besoin d’une piste d’audit vérifiable montrant que le tirage était équitable. Les outils qui journalisent chaque sélection avec un horodatage et une graine RNG fournissent cela. Vérifiez les exigences de votre juridiction locale — certaines zones exigent que la méthode de randomisation soit divulguée aux participants à l’avance.

Comment le nom et le nombre sont-ils générés indépendamment ?

Le générateur exécute le RNG deux fois par sortie : une fois pour sélectionner un index aléatoire dans la liste de noms, et une fois pour produire un nombre dans la plage configurée. Ce sont deux appels séparés au moteur de nombres aléatoires sous-jacent, donc la sélection du nom n’a aucune influence sur la sortie du nombre (et inversement). Cette indépendance est ce qui distingue la génération à double sortie de la génération combinée, où le nom et le nombre sont toujours appariés.

Quelle plage de nombres dois-je utiliser pour différentes applications ?

Pour les sélecteurs de classe, utilisez 1 à N (où N est la taille de la classe) pour les numéros de position, ou 100-999 pour des codes d’ID courts. Pour les tombolas, utilisez des nombres à 5 ou 6 chiffres (10000-99999 ou 100000-999999) pour rendre les codes de billet difficiles à deviner. Pour la numérotation des sujets de recherche, suivez le protocole de codage de votre institution — beaucoup utilisent un code de site suivi d’un nombre séquentiel ou aléatoire à 3 ou 4 chiffres.

La randomisation à double sortie résout un problème spécifique : associer des personnes à des nombres de manière équitable, transparente et auditable. Que vous organisiez une activité de classe, une tombola promotionnelle ou une inscription à un essai clinique, la capacité de générer un nom aléatoire et un nombre aléatoire indépendamment — tout en suivant chaque résultat — transforme un processus manuel propice aux erreurs en un processus automatisé fiable.