Comment définir des variables bash avec des nombres aléatoires

Comment définir des variables bash avec des nombres aléatoires
Index

Découvrez comment générer et utiliser des nombres aléatoires dans Bash grâce à des méthodes simples et pratiques pour améliorer vos scripts et applications, qu'il s'agisse de jeux ou de sécurité.

Vous pouvez facilement générer un nombre aléatoire à l'invite bash, que vous pouvez ensuite utiliser pour définir ce nombre comme une variable. Cela est utile pour tout, de l'écriture de certains types de scripts à la gestion d'aventures de jeux de rôle sur table. Que vous souhaitiez rédiger une campagne D&D ou écrire un utilitaire dans le puissant langage bash, vous pouvez généralement vous en sortir avec une seule ligne de code. C'est également un outil très utile lorsque vous essayez d'effectuer certaines vérifications de sécurité, mais n'oubliez pas que de bons crackers peuvent contourner ces générateurs de nombres simples. Ils sont néanmoins utiles pour générer certains types de mots de passe et de codes, ce qui pourrait aider à sécuriser les choses de toute façon.

Il existe plusieurs façons d'accomplir cela, et toutes les techniques ne conviennent pas à toutes les situations, nous avons donc fait de notre mieux pour examiner chaque méthode et l'avons testée pour garantir son bon fonctionnement. Vous devrez travailler depuis un terminal pour cela, donc utilisez soit Ctrl+Alt+T, soit Super (Windows)+T pour ouvrir un terminal graphique, commencez-en un en tapant terminal dans le Dash, sélectionnez-le dans le menu Applications ou Outils système, ou accédez à un terminal virtuel en utilisant Ctrl, Alt et une touche entre F1 et F6.

Méthode 1 : Choisir un Octet Aléatoire Complet

Vous pouvez générer un nombre aléatoire compris entre 1 et 256 en exécutant la commande suivante directement depuis l'invite bash :

od -An -N1 -tu1 /dev/urandom

Bien que vous voyiez parfois cette commande référencée à /dev/random au lieu de /dev/urandom, vous ne voudrez probablement pas procéder de cette façon. Cela peut involontairement priver d'autres programmes de pouvoir utiliser le générateur de graines aléatoires pendant votre utilisation. Une fois que vous avez exécuté le programme et obtenu un nombre, vous pouvez également être sûr qu'il fonctionnera de cette manière :

ranNum=$(($(od -An -N1 -tu1 /dev/urandom)))

Cela définira la variable ranNum à un nombre compris entre 1 et 256, sélectionné au moment où vous l'exécutez. Vous pouvez l'exécuter depuis la ligne de commande ou depuis un script, et cela devrait fonctionner dans les deux cas. Gardez à l'esprit que vous pouvez remplacer ranNum par n'importe quel nom de variable valide.

Méthode 2 : Définir une Variable à un Nombre Aléatoire Entre 1 et Tout Ce Que Vous Voulez

Vous pouvez exécuter echo $[RANDOM%40+1] depuis la ligne de commande pour envoyer un nombre aléatoire entre 1 et 40 directement à la sortie standard, mais vous pourriez également remplacer le 40 dans la commande par pratiquement n'importe quel nombre. En fin de compte, l'architecture de votre machine hôte manquera de chiffres ou peut-être bash, mais il est peu probable que vous ayez besoin d'un nombre aussi élevé de toute façon.

Supposons que vous souhaitiez générer un nombre aléatoire entre 1 et 10 pour votre configuration de variable. Vous pourriez exécuter :

ranNum=$[RANDOM%10+1]

N'oubliez pas que vous pouvez remplacer 10 par n'importe quelle valeur supérieure que vous souhaitez. Cette valeur est inclusive, ce qui signifie que 10 est un chiffre valide retourné. Si vous souhaitez la réduire d'un, il suffit de définir la valeur à 9 au lieu d'utiliser des mathématiques de type C ou C++ avec -1. Celles-ci ne sont pas nécessaires lors de la définition d'une variable en utilisant cette méthode, et elles généreront en fait des résultats inattendus en ajoutant ou en soustrayant des chiffres.

Méthode 3 : Sélectionner un Bit Aléatoire Simple

Si vous devez définir une variable à un bit aléatoire de zéro ou un, vous souhaiterez peut-être modifier le code précédent comme suit :

ranNum=$(($(od -An -N1 -i /dev/urandom) % 2))

Ce code définira ranNum à soit 1 soit 0 selon que les nombres qu'il a échantillonnés dans le fichier /dev/urandom étaient pairs ou impairs. Cela peut être utile si vous devez définir une équation simple oui ou non à l'un ou l'autre état.

Si cela n'est pas suffisamment aléatoire pour votre projet, vous pourriez obtenir un nombre légèrement plus aléatoire en effectuant un appel au répertoire /proc/sys/kernel/random avec :

ranNum=$((0x$(cut -c1-1 /proc/sys/kernel/random/uuid) % 2))

Encore une fois, cela ne définira la variable qu'à 1 ou 0, ce qui est parfait pour la logique binaire, mais pas aussi utile pour les situations où vous pourriez avoir besoin d'un nombre plus long. Vous pourriez cependant utiliser l'une de ces lignes dans un script bash si vous en avez besoin. Cette seconde option pourrait en fait être meilleure pour les situations où la première échoue également.

Méthode 4 : Écrire des Scripts Bash pour Retourner des Nombres Aléatoires

Si vous souhaitez disposer d'un outil pratique pour générer un nombre aléatoire à tout moment, alors vous pouvez créer.

Un script de ligne de commande pour le faire. Cela utilise rien de plus que le langage bash standard que la plupart des invites Linux modernes possèdent, donc presque n'importe quelle distribution Linux moderne et un bon nombre de systèmes d'exploitation basés sur BSD devraient bien gérer cela. Vous pourriez souhaiter utiliser cd ~/.local/bin avant d'aller plus loin pour vous assurer que vous aurez votre script dans un endroit où vous pouvez l'exécuter depuis n'importe où.

Tapez nano random ou vi random pour commencer, bien que vous puissiez utiliser un autre nom pour votre script si vous le souhaitez. Vous pourriez également utiliser un autre éditeur de texte si vous préférez. Supposons que vous vouliez créer un script qui renvoie soit 1 soit 0 lorsque tapé dans la ligne de commande. Entrez ce qui suit et puis appuyez sur Ctrl+O pour l'enregistrer si vous utilisez nano :

#!/bin/bash
ranNum=$(($RANDOM % 2))
echo $ranNum

Tapez Ctrl+X pour quitter l'éditeur de texte et une fois de retour à la ligne de commande, utilisez chmod +x random pour rendre votre script utilisable. Vous pourriez bien sûr utiliser ranNum=$[RANDOM%10+1], ranNum=$(($(od -An -N1 -tu1 /dev/urandom))) ou toute autre ligne à la place de ranNum=$(($RANDOM % 2)) afin de contrôler exactement quel type de nombre vous voudriez obtenir. Disons que vous vouliez sélectionner un nombre entre 1 et 50 régulièrement. Changez le texte du script bash en :

#!/bin/bash
ranNum=$[RANDOM%50+1]
echo $ranNum

Vous pouvez maintenant facilement l'exécuter depuis la ligne de commande en tapant random chaque fois que vous souhaitez générer un nombre aléatoire.

Les questions et réponses indispensables

Comment générer des nombres aléatoires dans bash ?

Pour générer des nombres aléatoires dans Bash, vous pouvez utiliser la variable intégrée $RANDOM. Voici comment cela fonctionne :

    • -

Génération d'un nombre aléatoire

    :

  • En tapant echo $RANDOM, vous obtiendrez un entier aléatoire compris entre 0 et
  • Stocker dans une variable :
  • Vous pouvez assigner ce nombre à une variable pour une utilisation ultérieure : bash RANDOM_NUMBER=$RANDOM
  • Limitation de la plage :
  • Si vous souhaitez générer un nombre aléatoire dans une plage spécifique, vous pouvez utiliser l'opérateur modulo %. Par exemple, pour obtenir un nombre entre 0 et 99 : bash RANDOM_NUMBER=$((RANDOM % 100))
  • Utilisation dans des scripts :
  • Cette fonctionnalité est utile pour divers cas d'utilisation dans les scripts, comme la création de noms de fichiers uniques, le tirage au sort, etc. Cette méthode simple offre un moyen efficace de travailler avec des valeurs aléatoires dans vos scripts Bash.

Comment générer des nombres aléatoires en C++ ?

Pour générer des nombres aléatoires en C++, vous avez plusieurs options. Voici un aperçu rapide :

 

  • Fonction rand() :
      - C'est la méthode la plus basique.
  • Exemple d'utilisation : cpp #include #include int main() { std::srand(std::time(0)); // Initialisation du générateur int randomNumber = std::rand(); // Génère un nombre aléatoire }
  • Notez que rand() produit une séquence déterministe si elle n'est pas initialisée avec une graine variée, ce qui la rend inappropriée pour le chiffrement.
  • Bibliothèque <random> :
  • Pour une génération de nombres aléatoires plus robuste et moderne.
  • Exemple d'utilisation : cpp #include int main() { std::random_device rd; // Générateur de nombres aléatoires non déterministes std::mt19937 gen(rd()); // Mersenne Twister, initialisé avec une graine std::uniform_int_distribution<> distrib(1, 100); // Distribution uniforme int randomNumber = distrib(gen); // Génère un nombre aléatoire entre 1 et 100 }
  • Méthode sécurisée : rand_s() :
  • Utilisé pour des applications nécessitant des nombres générés de manière sécurisée, comme le chiffrement.
  • Exemple d'utilisation : cpp #include int main() { unsigned int randomNumber; rand_s(&randomNumber); // Génération d'un nombre aléatoire sécurisé } En résumé, choisissez rand() pour des besoins simples, std::random pour des applications générales et rand_s() pour des scénarios sécurisés.

 

Comment générer des nombres aléatoires sous Excel ?

Pour générer des nombres aléatoires sous Excel, voici une méthode simple et efficace :

 

  • Utiliser la fonction ALEA() :
      • - Tapez

    =ALEA()

      dans une cellule. Cela génèrera un nombre décimal aléatoire compris entre 0 et
  • 2. Générer des nombres entiers dans une plage spécifique :
  • Si vous souhaitez des nombres aléatoires entiers dans une plage déterminée, utilisez =ENT(ALEA()*(max-min)+min), où max est la valeur maximale et min la valeur minimale que vous souhaitez.
  • Fixer le nombre généré :
  • Pour que le nombre aléatoire ne change pas chaque fois que la feuille se recalculer, après avoir tapé la formule, appuyez sur F9. Cela 'fige' le nombre généré. En appliquant ces étapes, vous pourrez facilement créer des nombres aléatoires selon vos besoins dans Excel.

 

Comment générer des nombres aléatoires sur Python ?

Pour générer des nombres aléatoires en Python, le module random propose plusieurs méthodes pratiques. Voici les principales :

    • -

random()

    : Cette fonction retourne un nombre à virgule flottante aléatoire dans l’intervalle [0.0, 1.0).

  • randint(a, b) : Utilisez cette méthode pour obtenir un nombre entier aléatoire compris entre les valeurs a et b, incluant les deux.
  • uniform(a, b) : Cette méthode génère un nombre à virgule flottante aléatoire entre les valeurs a et b, permettant une plus grande flexibilité dans la plage. Pour utiliser ces fonctions, n'oubliez pas d'importer le module random au début de votre code : python import random # Exemples d'utilisation nombre_flottant = random.random() # Nombre flottant entre 0 et 1 nombre_entier = random.randint(1, 10) # Nombre entier entre 1 et 10 nombre_uniforme = random.uniform(1, 10) # Nombre flottant entre 1 et 10 Ces méthodes vous permettront de générer facilement des nombres aléatoires selon vos besoins spécifiques dans vos programmes Python.

Maintenant que tu as fini de lire Comment définir des variables bash avec des nombres aléatoires, nous t'invitons à explorer davantage la catégorie Linux. Tu y trouveras d'autres articles intéressants qui élargiront tes connaissances et te tiendront informé. Ne cesse pas de lire et de découvrir plus!

Go up