మీరు బాష్ ప్రాంప్ట్ వద్ద యాదృచ్ఛిక సంఖ్యను సులభంగా ఉత్పత్తి చేయవచ్చు, ఆ తర్వాత మీరు చెప్పిన సంఖ్యను వేరియబుల్గా సెట్ చేయడానికి ఉపయోగించవచ్చు. కొన్ని రకాల స్క్రిప్ట్లను రాయడం నుండి టేబుల్టాప్ రోల్ప్లేయింగ్ అడ్వెంచర్లను అమలు చేయడం వరకు ప్రతిదానికీ ఇది ఉపయోగపడుతుంది. మీరు D & D ప్రచారాన్ని వ్రాస్తున్నా లేదా శక్తివంతమైన బాష్ భాషలో యుటిలిటీని వ్రాసినా, మీరు సాధారణంగా ఒకే పంక్తి కోడ్తో బయటపడవచ్చు. కొన్ని భద్రతా తనిఖీలను ముందుగా రూపొందించడానికి ప్రయత్నించినప్పుడు ఇది చాలా ఉపయోగకరమైన సాధనం, అయితే మంచి క్రాకర్లు ఈ సాధారణ సంఖ్య జనరేటర్లను తప్పించుకోగలరని మీరు గుర్తుంచుకోవాలి. కొన్ని రకాల పాస్వర్డ్లు మరియు కోడ్లను రూపొందించడానికి అవి ఇప్పటికీ ఉపయోగపడతాయి, ఏమైనప్పటికీ వాటిని సురక్షితంగా ఉంచడానికి సహాయపడతాయి.
దీన్ని నెరవేర్చడానికి కొన్ని విభిన్న మార్గాలు ఉన్నాయి, మరియు ప్రతి టెక్నిక్ ప్రతి పరిస్థితికి సరైనది కాదు, కాబట్టి మేము ప్రతి మార్గాన్ని పరిశీలించడానికి మా వంతు కృషి చేసాము మరియు అది పని చేస్తుందని నిర్ధారించడానికి పరీక్షించాము. దీని కోసం మీరు టెర్మినల్ నుండి పని చేయవలసి ఉంటుంది, కాబట్టి గ్రాఫికల్ టెర్మినల్ తెరవడానికి Ctrl + Alt + T లేదా సూపర్ (విండోస్) + T ని ఉపయోగించండి, డాష్లో టెర్మినల్ టైప్ చేయడం ద్వారా ఒకదాన్ని ప్రారంభించండి, అప్లికేషన్ లేదా విస్కర్ నుండి ఎంచుకోండి మరియు సిస్టమ్ టూల్స్ మెనూలు లేదా Ctrl, Alt మరియు F1 మరియు F6 మధ్య కీని ఉపయోగించడం ద్వారా వర్చువల్ టెర్మినల్కు వెళ్ళండి.
విధానం 1: పూర్తి రాండమ్ బైట్ ఎంచుకోవడం
బాష్ ప్రాంప్ట్ నుండి కింది ఆదేశాన్ని నేరుగా అమలు చేయడం ద్వారా మీరు 1 మరియు 256 మధ్య నుండి యాదృచ్ఛిక సంఖ్యను సృష్టించవచ్చు:
of -An -N1 -tu1 / dev / urandom
/ Dev / urandom కు బదులుగా / dev / random కు సూచించబడిన ఈ ఆదేశాన్ని మీరు కొన్నిసార్లు చూడవచ్చు, మీరు బహుశా ఈ విధంగా నడపడానికి ఇష్టపడరు. ఇది యాదృచ్ఛిక విత్తన జనరేటర్ను మీరు ఉపయోగించినప్పుడు ఉపయోగించకుండా ఇతర ప్రోగ్రామ్లను అనుకోకుండా దోచుకుంటుంది. మీరు ప్రోగ్రామ్ను అమలు చేసి, సంఖ్యను సంపాదించిన తర్వాత, ఇది కూడా ఈ విధంగా పనిచేస్తుందని మీరు అనుకోవచ్చు:
ranNum = $ ((od (od -An -N1 -tu1 / dev / urandom)))
ఇది వేరియబుల్ రన్నమ్ను 1 మరియు 256 మధ్య సంఖ్యకు సెట్ చేస్తుంది, మీరు దీన్ని అమలు చేసే సమయంలో ఎంపిక చేస్తారు. మీరు దీన్ని కమాండ్ లైన్ నుండి లేదా స్క్రిప్ట్ లోపలి నుండి అమలు చేయవచ్చు మరియు అది ఏ విధంగానైనా పనిచేయాలి. మీరు ఏదైనా చెల్లుబాటు అయ్యే వేరియబుల్ పేరుతో ranNum ని భర్తీ చేయవచ్చని గుర్తుంచుకోండి.
విధానం 2: 1 మరియు ఏమైనా మధ్య రాండమ్ సంఖ్యకు వేరియబుల్ సెట్ చేయడం
1 మరియు 40 మధ్య యాదృచ్ఛిక సంఖ్యను నేరుగా ప్రామాణిక అవుట్పుట్కు పంపడానికి మీరు కమాండ్ లైన్ నుండి ఎకో $ [RANDOM% 40 + 1] ను అమలు చేయవచ్చు, కానీ మీరు కమాండ్లోని 40 ని వాస్తవంగా ఏ సంఖ్యతోనైనా భర్తీ చేయవచ్చు. చివరికి మీ హోస్ట్ మెషీన్ యొక్క నిర్మాణం అంకెలు అయిపోతుంది లేదా బహుశా బాష్ అవుతుంది, అయితే మీకు ఇంత ఎక్కువ సంఖ్య అవసరమేనా అనేది సందేహమే.
మీ వేరియబుల్ కాన్ఫిగరేషన్ కోసం మీరు 1 మరియు 10 మధ్య యాదృచ్ఛిక సంఖ్యను సృష్టించాలనుకుంటున్నారని అనుకుందాం. మీరు అమలు చేయవచ్చు:
ranNum = $ [రాండమ్% 10 + 1]
మీరు 10 ను మీకు కావలసిన ఎగువ విలువతో భర్తీ చేయవచ్చని గుర్తుంచుకోండి. ఈ విలువ కలుపుకొని ఉంది, అంటే 10 చెల్లుబాటు అయ్యే తిరిగి వచ్చిన వ్యక్తి. మీరు దానిని ఒక్కొక్కటిగా తగ్గించాలనుకుంటే, సి లేదా సి ++ స్టైల్ -1 గణితాన్ని ఉపయోగించకుండా బదులుగా విలువ 9 ను చేయండి. ఈ పద్ధతిని ఉపయోగించి వేరియబుల్ను సెట్ చేసేటప్పుడు ఇవి అనవసరం, మరియు అవి వాస్తవానికి అంకెలను జోడించడం లేదా తీసివేయడం ద్వారా unexpected హించని ఫలితాలను ఇస్తాయి.
విధానం 3: సింగిల్ రాండమ్ బిట్ను ఎంచుకోవడం
మీరు వేరియబుల్ను యాదృచ్ఛిక బిట్కు సున్నా లేదా ఒకటిగా సెట్ చేయవలసి వస్తే, మీరు మునుపటి కోడ్ను ఈ క్రింది విధంగా సవరించాలనుకోవచ్చు:
ranNum = $ ((od (od -An -N1 -i / dev / urandom)% 2))
ఈ కోడ్ రన్ నమ్ ను 1 లేదా 0 గా సెట్ చేస్తుంది / dev / urandom ఫైల్ సరి లేదా బేసి. మీరు ఒకటి లేదా మరొక రాష్ట్రానికి సరళమైన అవును లేదా సమీకరణాన్ని సెట్ చేయాల్సిన అవసరం ఉంటే ఇది ఉపయోగపడుతుంది.
మీరు పని చేస్తున్నదానికి ఇది తగినంత యాదృచ్ఛికం కాకపోతే, / proc / sys / kernel / random డైరెక్టరీకి కాల్ చేయడం ద్వారా మీరు కొంచెం ఎక్కువ యాదృచ్ఛిక సంఖ్యను పొందవచ్చు:
ranNum = $ ((0x $ (cut -c1-1 / proc / sys / kernel / random / uuid)% 2))
మరోసారి, అయితే, ఇది వేరియబుల్ను 1 లేదా 0 కి మాత్రమే సెట్ చేస్తుంది, ఇది బైనరీ లాజిక్కు ఖచ్చితంగా సరిపోతుంది కాని మీకు ఎక్కువ సంఖ్య అవసరమయ్యే సమయాల్లో ఉపయోగపడదు. మీకు ఏమైనా అవసరమైతే మీరు ఈ పంక్తులలో దేనినైనా బాష్ స్క్రిప్ట్లో ఉపయోగించవచ్చు. మొదటిది విఫలమైన పరిస్థితులకు ఈ రెండవ ఎంపిక వాస్తవానికి మంచిది
విధానం 4: యాదృచ్ఛిక సంఖ్యలను తిరిగి ఇవ్వడానికి బాష్ స్క్రిప్ట్లను రచించడం
మీరు ఎప్పుడైనా యాదృచ్ఛిక సంఖ్యను రూపొందించడానికి సులభ సాధనాన్ని కలిగి ఉండాలనుకుంటే, అలా చేయడానికి మీరు కమాండ్ లైన్ స్క్రిప్ట్ను సృష్టించవచ్చు. ఇది చాలా ఆధునిక లైనక్స్ ప్రాంప్ట్లు కలిగి ఉన్న ప్రామాణిక బాష్ భాష కంటే మరేమీ ఉపయోగించదు, కాబట్టి చాలా చక్కని ఏదైనా ఆధునిక లైనక్స్ పంపిణీ మరియు బిఎస్డి ఆధారిత ఆపరేటింగ్ సిస్టమ్లలో కొన్ని దీనిని చక్కగా నిర్వహించాలి. మీరు ఎక్కడి నుండైనా అమలు చేయగల స్థలంలో మీ స్క్రిప్ట్ ఉందని నిర్ధారించుకోవడానికి ఇంకేముందు వెళ్ళే ముందు మీరు సిడి ~ / .లోకల్ / బిన్ను ఉపయోగించాలనుకోవచ్చు.
ప్రారంభించడానికి నానో రాండమ్ లేదా vi రాండమ్ అని టైప్ చేయండి, అయితే మీరు కావాలనుకుంటే మీ స్క్రిప్ట్కు వేరే పేరును ఉపయోగించవచ్చు. మీరు కావాలనుకుంటే మీరు మరొక టెక్స్ట్ ఎడిటర్ను కూడా ఉపయోగించవచ్చు. మీరు కమాండ్ లైన్ వద్ద టైప్ చేసినప్పుడు 1 లేదా 0 తిరిగి వచ్చే ఒకదాన్ని సృష్టించాలనుకుంటున్నారని చెప్పండి. కింది వాటిని ఎంటర్ చేసి, ఆపై మీరు నానో ఉపయోగిస్తుంటే దాన్ని సేవ్ చేయడానికి Ctrl + O ని నొక్కండి:
#! / bin / bash ranNum = $ (($ RANDOM% 2)) echo $ ranNum
టెక్స్ట్ ఎడిటర్ నుండి నిష్క్రమించడానికి Ctrl + X అని టైప్ చేయండి మరియు కమాండ్ లైన్ వద్ద ఒకసారి మీ స్క్రిప్ట్ ఉపయోగపడేలా చేయడానికి chmod + x యాదృచ్ఛికంగా ఉపయోగించండి. మీరు కోర్సులో ranNum = $ [RANDOM% 10 + 1], ranNum = $ ((od (od -An -N1 -tu1 / dev / urandom))) లేదా ranNum = $ (($ రాండమ్% 2)) కాబట్టి మీరు ఏ విధమైన సంఖ్యను తిరిగి పొందాలనుకుంటున్నారో ఖచ్చితంగా నియంత్రించవచ్చు. మీరు క్రమం తప్పకుండా 1 మరియు 50 మధ్య సంఖ్యను ఎంచుకోవాలనుకుందాం. బాష్ స్క్రిప్ట్ యొక్క వచనాన్ని దీనికి మార్చండి:
#! / bin / bash ranNum = $ [RANDOM% 50 + 1] echo $ ranNum
మీరు యాదృచ్ఛిక సంఖ్యను ఉత్పత్తి చేయాలనుకున్నప్పుడు యాదృచ్ఛికంగా టైప్ చేయడం ద్వారా మీరు దీన్ని కమాండ్ లైన్ నుండి సులభంగా అమలు చేయవచ్చు.
4 నిమిషాలు చదవండి