जवाबों:
का उपयोग करें $RANDOM। यह अक्सर सरल शेल अंकगणित के साथ संयोजन में उपयोगी होता है। उदाहरण के लिए, 1 और 10 (समावेशी) के बीच एक यादृच्छिक संख्या उत्पन्न करने के लिए:
$ echo $((1 + RANDOM % 10))
3वास्तविक जनरेटर में है variables.c, फ़ंक्शन brand()। पुराने संस्करण एक साधारण रैखिक जनरेटर थे। संस्करण 4.0 1985 के पेपर के उद्धरण के साथbash एक जनरेटर का उपयोग करता है , जिसका अर्थ है कि यह छद्म आयामी संख्याओं का एक अच्छा स्रोत है। मैं इसका उपयोग अनुकार के लिए नहीं करूंगा (और निश्चित रूप से क्रिप्टो के लिए नहीं), लेकिन यह मूल स्क्रिप्टिंग कार्यों के लिए पर्याप्त है।
यदि आप कुछ ऐसा कर रहे हैं जिसके लिए गंभीर रैंडम नंबरों की आवश्यकता होती है, जिनका आप उपयोग कर सकते हैं /dev/randomया /dev/urandomयदि वे उपलब्ध हैं:
$ dd if=/dev/urandom count=4 bs=1 | od -t d$RANDOM % 10, 8 और 9 औसत दर्जे का (हालांकि मामूली) 4-7 की तुलना में कम संभावित हैं, भले ही $RANDOMयादृच्छिक डेटा का एक मजबूत स्रोत है।
$RANDOMकी सीमा है 0-32767संख्या 0- 7करने के लिए नक्शे 3277विभिन्न संभव आदानों, लेकिन 8और 9केवल उत्पादन किया जा सकता 3276अलग अलग तरीकों से (क्योंकि 32768और 32769संभव नहीं हैं)। यह त्वरित हैक के लिए एक मामूली मुद्दा है, लेकिन इसका मतलब यह है कि परिणाम समान रूप से यादृच्छिक नहीं है। जावा की तरह रैंडम लाइब्रेरी, Randomदिए गए रेंज में एक समान यादृच्छिक संख्या को ठीक से वापस करने के लिए फ़ंक्शंस प्रदान करते हैं, न कि केवल एक-विभाज्य संख्या को मॉडरेट करने के बजाय।
कृपया देखें $RANDOM:
$RANDOMएक आंतरिक बैश फ़ंक्शन (स्थिर नहीं) है जो 0 - 32767 श्रेणी में एक छद्म आयामी पूर्णांक देता है। इसका उपयोग एन्क्रिप्शन कुंजी उत्पन्न करने के लिए नहीं किया जाना चाहिए।
32767किसी भी विशेष अर्थ नहीं है?
32767है 2^16 / 2 - 1जो एक हस्ताक्षरित 16 बिट पूर्णांक के लिए ऊपरी सीमा है।
2^15 - 1? यह समतुल्य है, इसलिए मैं कुछ उत्सुक हूं यदि मुझे कोई संदर्भ याद आ रहा है?
आप शूफ (कोरुटिल्स में उपलब्ध) का भी उपयोग कर सकते हैं ।
shuf -i 1-100000 -n 1shuf -i 1-10 -n 1: syntax error in expression (error token is "1-10 -n 1")
$varश्रेणी के अंत के बजाय इस तरह जोड़ें :var=100 && shuf -i 1-${var} -n 1
-n। उदा। 1 और 100 के बीच 5 यादृच्छिक संख्याएँ उत्पन्न करें :shuf -i 1-100 -n 5
shuf -i 1-10 -n 10तो आपको 1 से 10 तक सभी नंबर मिलेंगे। यदि आप निर्दिष्ट करते हैं -n 15तो आपको अभी भी केवल 10 नंबर एक ही बार मिलेंगे। यह वास्तव में केवल फेरबदल है, यादृच्छिक संख्या उत्पन्न नहीं कर रहा है।
इसे अपने शेल से आज़माएं:
$ od -A n -t d -N 1 /dev/urandomयहां, -t dनिर्दिष्ट करता है कि आउटपुट प्रारूप पर हस्ताक्षर किए जाने वाले दशमलव होने चाहिए; -N 1से एक बाइट पढ़ने के लिए कहते हैं /dev/urandom।
od -A n -t d -N 1 /dev/urandom |tr -d ' '
तुम भी awk से यादृच्छिक संख्या प्राप्त कर सकते हैं
awk 'BEGIN {
# seed
srand()
for (i=1;i<=1000;i++){
print int(1 + rand() * 100)
}
}'srand()बीज वर्तमान सीपीयू समय है। यदि आपको एक विशिष्ट बीज निर्दिष्ट करने की आवश्यकता है, तो आरएनजी को डुप्लिकेट किया जा सकता है, srand(x)जहां xबीज है वहां का उपयोग करें । इसके अलावा, GNU awk के संख्यात्मक फ़ंक्शन मैनुअल के हवाले से कहा गया है, "विभिन्न awk कार्यान्वयन आंतरिक रूप से विभिन्न यादृच्छिक-संख्या जनरेटर का उपयोग करते हैं।" उत्थान यह है कि यदि आप सांख्यिकीय वितरण पैदा करने में रुचि रखते हैं, तो आपको अलग-अलग प्लेटफ़ॉर्म पर एक रनटाइम से अगले तक जाने वाले मामूली बदलावों की उम्मीद करनी चाहिए (सभी चल रहे हैं awkया gawk)।
$ रंडोम है। मुझे नहीं पता कि यह कैसे काम करता है। लेकिन यह काम करता है। परीक्षण के लिए, आप कर सकते हैं:
echo $RANDOMमुझे यह चाल पसंद है:
echo ${RANDOM:0:1} # random number between 1 and 9
echo ${RANDOM:0:2} # random number between 1 and 99...
${RANDOM:0:1}पास 1 या 2 देने का 67.8% मौका है, ${RANDOM:0:2}केवल आपके पास एक अंकों की संख्या देने का 0.03% मौका है (1% होना चाहिए), और दोनों में आपको 0 देने का 0.003% मौका है। अभी भी ऐसे मामलों का उपयोग करते हैं जहां यह ठीक है (जैसे गैर-सुसंगत इनपुट)।
यादृच्छिक संख्या 0 और 9 के बीच समावेशी।
echo $((RANDOM%10))$RANDOMकेवल 0 से 32767 तक चला जाता है। यह कहा जाना चाहिए "रैंडम संख्या ज्यादातर 1 और 3 के बीच, कुछ विंगर्स के साथ";)
यदि आप एक Linux सिस्टम का उपयोग कर रहे हैं, तो आप एक यादृच्छिक संख्या / dev / random या / dev / urandom से प्राप्त कर सकते हैं । यदि पर्याप्त रैंडम नंबर उपलब्ध नहीं हैं, तो केयरफुल / देव / रैंडम ब्लॉक करेंगे। यदि आपको रैंडमनेस के उपयोग की गति की आवश्यकता है / dev / urandom।
ये "फाइलें" ऑपरेटिंग सिस्टम द्वारा उत्पन्न यादृच्छिक संख्याओं से भरी होंगी। यदि आप सही या छद्म यादृच्छिक संख्या प्राप्त करते हैं तो यह आपके सिस्टम पर / dev / random के कार्यान्वयन पर निर्भर करता है। माउस, हार्ड ड्राइव, नेटवर्क जैसे डिवाइस ड्राइवरों से एकत्रित किए गए हेल्प फॉर्म शोर से ट्रू रैंडम नंबर उत्पन्न होते हैं।
आप dd के साथ फाइल से रैंडम नंबर प्राप्त कर सकते हैं
मैंने इनमें से कुछ विचारों को लिया है और एक फ़ंक्शन बनाया है जो बहुत सारे यादृच्छिक संख्याओं की आवश्यकता होने पर जल्दी से प्रदर्शन करना चाहिए।
odयदि आपको बहुत सारे रैंडम नंबर चाहिए तो कॉलिंग महंगी है। इसके बजाय मैं इसे एक बार कॉल करता हूं और 1024 यादृच्छिक संख्याओं को / dev / urandom से स्टोर करता हूं। कबrand कहा जाता है, तो अंतिम यादृच्छिक संख्या वापस आ जाती है और स्केल की जाती है। फिर इसे कैश से हटा दिया जाता है। जब कैश खाली होता है, तो एक और 1024 यादृच्छिक संख्या पढ़ी जाती है।
उदाहरण:
rand 10; echo $RET0 और 9 के बीच RET में एक यादृच्छिक संख्या देता है।
declare -ia RANDCACHE
declare -i RET RAWRAND=$(( (1<<32)-1 ))
function rand(){ # pick a random number from 0 to N-1. Max N is 2^32
local -i N=$1
[[ ${#RANDCACHE[*]} -eq 0 ]] && { RANDCACHE=( $(od -An -tu4 -N1024 /dev/urandom) ); } # refill cache
RET=$(( (RANDCACHE[-1]*N+1)/RAWRAND )) # pull last random number and scale
unset RANDCACHE[${#RANDCACHE[*]}-1] # pop read random number
};
# test by generating a lot of random numbers, then effectively place them in bins and count how many are in each bin.
declare -i c; declare -ia BIN
for (( c=0; c<100000; c++ )); do
rand 10
BIN[RET]+=1 # add to bin to check distribution
done
for (( c=0; c<10; c++ )); do
printf "%d %d\n" $c ${BIN[c]}
doneअद्यतन: यह सभी एन के लिए इतनी अच्छी तरह से काम नहीं करता है। यह छोटे एन के साथ उपयोग किए जाने पर यादृच्छिक बिट्स को भी बर्बाद करता है। ध्यान दें कि (इस मामले में) एक 32 बिट यादृच्छिक संख्या 0 और 9 (10 * 9) के बीच 9 यादृच्छिक संख्याओं के लिए पर्याप्त एन्ट्रॉपी है। = 1,000,000,000 <= 2 * 32) हम प्रत्येक 32 यादृच्छिक स्रोत मान से कई यादृच्छिक संख्या निकाल सकते हैं।
#!/bin/bash
declare -ia RCACHE
declare -i RET # return value
declare -i ENT=2 # keep track of unused entropy as 2^(entropy)
declare -i RND=RANDOM%ENT # a store for unused entropy - start with 1 bit
declare -i BYTES=4 # size of unsigned random bytes returned by od
declare -i BITS=8*BYTES # size of random data returned by od in bits
declare -i CACHE=16 # number of random numbers to cache
declare -i MAX=2**BITS # quantum of entropy per cached random number
declare -i c
function rand(){ # pick a random number from 0 to 2^BITS-1
[[ ${#RCACHE[*]} -eq 0 ]] && { RCACHE=( $(od -An -tu$BYTES -N$CACHE /dev/urandom) ); } # refill cache - could use /dev/random if CACHE is small
RET=${RCACHE[-1]} # pull last random number and scale
unset RCACHE[${#RCACHE[*]}-1] # pop read random number
};
function randBetween(){
local -i N=$1
[[ ENT -lt N ]] && { # not enough entropy to supply ln(N)/ln(2) bits
rand; RND=RET # get more random bits
ENT=MAX # reset entropy
}
RET=RND%N # random number to return
RND=RND/N # remaining randomness
ENT=ENT/N # remaining entropy
};
declare -ia BIN
for (( c=0; c<100000; c++ )); do
randBetween 10
BIN[RET]+=1
done
for c in ${BIN[*]}; do
echo $c
doneod -An -tu4 -N40 /dev/urandomव्हॉट्सएप के साथ अलग किए गए 10 यादृच्छिक अहस्ताक्षरित 32 बिट पूर्णांक उत्पन्न करेंगे। आप इसे एक सरणी में संग्रहीत कर सकते हैं और बाद में इसका उपयोग कर सकते हैं। आपका कोड एक ओवरकिल लगता है।
/ Dev / random / / dev / urandom character विशेष फाइलों से पढ़ना जाने का रास्ता है।
ये डिवाइस पढ़े जाने पर सही मायने में रैंडम नंबर देते हैं और एप्लिकेशन सॉफ़्टवेयर को एन्क्रिप्शन के लिए सुरक्षित कुंजी चुनने में मदद करने के लिए डिज़ाइन किए जाते हैं। ऐसे यादृच्छिक संख्याओं को एक एंट्रॉपी पूल से निकाला जाता है जो विभिन्न यादृच्छिक घटनाओं द्वारा योगदान दिया जाता है। {LDD3, जोनाथन कोरबेट, एलेसेंड्रो रुबीनी और ग्रेग क्रोहा-हार्टमैन]
ये दो फाइलें विशेष रूप से कर्नेल रैंडमाइजेशन के लिए इंटरफेस हैं
void get_random_bytes_arch(void* buf, int nbytes)जो हार्डवेयर से सही मायने में यादृच्छिक बाइट्स खींचता है यदि ऐसा फ़ंक्शन हार्डवेयर द्वारा कार्यान्वित किया जाता है (आमतौर पर), या यह एन्ट्रॉपी पूल (माउस और कीबोर्ड के बीच की घटनाओं के बीच का समय शामिल होता है और अन्य बाधाएं जो SA_AMPLE_RANDOM के साथ पंजीकृत होती हैं) से आती हैं।
dd if=/dev/urandom count=4 bs=1 | od -t dयह काम करता है, लेकिन अनावश्यक आउटपुट ddको स्टडआउट से लिखता है । नीचे दी गई कमांड मुझे केवल पूर्णांक की आवश्यकता है। मैं भी यादृच्छिक बिट्स की निर्दिष्ट संख्या प्राप्त कर सकता हूं क्योंकि मुझे अंकगणित के विस्तार के लिए दिए गए बिटमास्क के समायोजन की आवश्यकता है:
me@mymachine:~/$ x=$(head -c 1 /dev/urandom > tmp && hexdump
-d tmp | head -n 1 | cut -c13-15) && echo $(( 10#$x & 127 ))शायद मुझे थोड़ी देर हो गई है, लेकिन jotबैश में एक सीमा के भीतर एक यादृच्छिक संख्या उत्पन्न करने के लिए उपयोग करने के बारे में क्या ?
jot -r -p 3 1 0 1यह -r3 दशमलव स्थानों पर सटीक ( -p) के साथ एक यादृच्छिक ( ) संख्या उत्पन्न करता है । इस विशेष स्थिति में, आपको 0 और 1 ( 1 0 1) के बीच एक नंबर मिलेगा । आप अनुक्रमिक डेटा भी प्रिंट कर सकते हैं। मैनुअल के अनुसार यादृच्छिक संख्या का स्रोत है:
जब कोई बीज निर्दिष्ट नहीं किया जाता है, और यादृच्छिक (3) के माध्यम से रैंडम संख्या (3) के माध्यम से यादृच्छिक संख्या प्राप्त की जाती है।
@ नेल्सन, @ बरुण और @ रोबर्ट के शानदार जवाबों के आधार पर, यहां एक बैश स्क्रिप्ट है जो यादृच्छिक संख्या उत्पन्न करती है।
/dev/urandomजो बैश के बिल्ट-इन से बहुत बेहतर होता है$RANDOM#!/usr/bin/env bash
digits=10
rand=$(od -A n -t d -N 2 /dev/urandom |tr -d ' ')
num=$((rand % 10))
while [ ${#num} -lt $digits ]; do
rand=$(od -A n -t d -N 1 /dev/urandom |tr -d ' ')
num="${num}$((rand % 10))"
done
echo $num0 से n (16-बिट पूर्णांक पर हस्ताक्षर किए) की सीमा में यादृच्छिक संख्या उत्पन्न करें। $ RAND चर में परिणाम सेट। उदाहरण के लिए:
#!/bin/bash
random()
{
local range=${1:-1}
RAND=`od -t uI -N 4 /dev/urandom | awk '{print $2}'`
let "RAND=$RAND%($range+1)"
}
n=10
while [ $(( n -=1 )) -ge "0" ]; do
random 500
echo "$RAND"
doneकिसी प्रोग्राम की रैंडम ब्रांचिंग या हाँ / नहीं; 1/0; सच / गलत आउटपुट:
if [ $RANDOM -gt 16383 ]; then # 16383 = 32767/2
echo var=true/1/yes/go_hither
else
echo var=false/0/no/go_thither
fiयदि आप 16383 को याद करने के लिए आलसी हैं:
if (( RANDOM % 2 )); then
echo "yes"
else
echo "no"
fi