சீரற்ற எண்களுக்கு பாஷ் மாறிகள் அமைப்பது எப்படி

பாஷ் வரியில் நீங்கள் ஒரு சீரற்ற எண்ணை எளிதாக உருவாக்கலாம், பின்னர் நீங்கள் சொன்ன எண்ணை ஒரு மாறியாக அமைக்க பயன்படுத்தலாம். சில வகையான ஸ்கிரிப்ட்களை எழுதுவது முதல் இயங்கும் டேப்லெட் ரோல் பிளேயிங் சாகசங்கள் வரை அனைத்திற்கும் இது பயனுள்ளதாக இருக்கும். நீங்கள் ஒரு டி & டி பிரச்சாரத்தை எழுதுகிறீர்களோ அல்லது சக்திவாய்ந்த பாஷ் மொழியில் ஒரு பயன்பாட்டை எழுதுகிறீர்களோ, நீங்கள் வழக்கமாக ஒரு வரியின் குறியீட்டைப் பெறலாம். சில பாதுகாப்பு சோதனைகளை முன்கூட்டியே முயற்சிக்கும்போது இது மிகவும் பயனுள்ள கருவியாகும், ஆனால் நல்ல பட்டாசுகளால் இந்த எளிய எண் ஜெனரேட்டர்களைத் தவிர்க்க முடியும் என்பதை நீங்கள் நினைவில் கொள்ள வேண்டும். சில வகையான கடவுச்சொற்கள் மற்றும் குறியீட்டை உருவாக்குவதற்கு அவை இன்னும் பயனுள்ளதாக இருக்கும், அவை எப்படியும் பாதுகாப்பாக வைக்க உதவும்.

இதை நிறைவேற்ற சில வேறுபட்ட வழிகள் உள்ளன, மேலும் ஒவ்வொரு நுட்பத்திற்கும் ஒவ்வொரு நுட்பமும் சரியானதல்ல, எனவே ஒவ்வொரு வழியையும் கவனித்து, அது செயல்படுவதை உறுதிசெய்ய அதைச் சோதித்தோம். இதற்காக நீங்கள் ஒரு முனையத்திலிருந்து வேலை செய்ய வேண்டும், எனவே ஒரு வரைகலை முனையத்தைத் திறக்க Ctrl + Alt + T அல்லது Super (Windows) + 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 ஐ உருவாக்கவும். இந்த முறையைப் பயன்படுத்தி ஒரு மாறியை அமைக்கும் போது இவை தேவையற்றவை, மேலும் அவை உண்மையில் இலக்கங்களைச் சேர்ப்பதன் மூலம் அல்லது கழிப்பதன் மூலம் எதிர்பாராத முடிவுகளை உருவாக்கும்.

முறை 3: ஒற்றை ரேண்டம் பிட்டைத் தேர்ந்தெடுப்பது

சீரற்ற பிட் பூஜ்ஜியம் அல்லது ஒன்றுக்கு நீங்கள் ஒரு மாறியை அமைக்க வேண்டும் என்றால், முந்தைய குறியீட்டை பின்வருமாறு மாற்ற விரும்பலாம்:

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

இந்த குறியீடு ரன்நூமை 1 அல்லது 0 ஆக அமைக்கும் / dev / urandom கோப்பு சமமாக அல்லது ஒற்றைப்படை. ஒன்று அல்லது வேறு மாநிலத்திற்கு எளிய ஆம் அல்லது சமன்பாட்டை அமைக்க வேண்டியிருந்தால் இது பயனுள்ளதாக இருக்கும்.

நீங்கள் பணிபுரியும் அளவுக்கு இது சீரற்றதாக இல்லாவிட்டால், / proc / sys / kernel / சீரற்ற கோப்பகத்திற்கு அழைப்பதன் மூலம் சற்று அதிகமான சீரற்ற எண்ணைப் பெறலாம்:

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

மீண்டும், இருப்பினும், இது மாறியை 1 அல்லது 0 க்கு மட்டுமே அமைக்கும், இது பைனரி தர்க்கத்திற்கு ஏற்றது, ஆனால் உங்களுக்கு நீண்ட எண் தேவைப்படும் நேரங்களுக்கு இது பயனுள்ளதாக இருக்காது. எவ்வாறாயினும், இந்த வரிகளில் ஏதேனும் ஒன்றை நீங்கள் பாஷ் ஸ்கிரிப்டில் பயன்படுத்தலாம். முதல் விருப்பம் தோல்வியுற்ற சூழ்நிலைகளுக்கு இந்த இரண்டாவது விருப்பம் உண்மையில் சிறப்பாக இருக்கும்

முறை 4: சீரற்ற எண்களைத் திரும்ப பாஷ் ஸ்கிரிப்ட்களை எழுதுதல்

எந்த நேரத்திலும் சீரற்ற எண்ணை உருவாக்குவதற்கான எளிதான கருவியை நீங்கள் வைத்திருக்க விரும்பினால், அவ்வாறு செய்ய கட்டளை வரி ஸ்கிரிப்டை உருவாக்கலாம். இது நவீன லினக்ஸ் கேட்கும் நிலையான பாஷ் மொழியைத் தவிர வேறொன்றையும் பயன்படுத்தாது, எனவே எந்த நவீன லினக்ஸ் விநியோகமும் பி.எஸ்.டி-அடிப்படையிலான இயக்க முறைமைகளில் சிலவும் இதை நன்றாகக் கையாள வேண்டும். உங்கள் ஸ்கிரிப்டை நீங்கள் எங்கிருந்தும் இயக்கக்கூடிய இடத்தில் வைத்திருப்பதை உறுதிசெய்ய, மேலும் செல்வதற்கு முன் நீங்கள் சிடி ~ / .லோகல் / பின் பயன்படுத்த விரும்பலாம்.

தொடங்குவதற்கு நானோ சீரற்ற அல்லது vi சீரற்றதைத் தட்டச்சு செய்க, நீங்கள் விரும்பினால் உங்கள் ஸ்கிரிப்டுக்கு வேறு பெயரைப் பயன்படுத்தலாம். நீங்கள் விரும்பினால் மற்றொரு உரை எடிட்டரையும் பயன்படுத்தலாம். கட்டளை வரியில் தட்டச்சு செய்யும் போது 1 அல்லது 0 ஐத் தரும் ஒன்றை உருவாக்க விரும்பினீர்கள் என்று சொல்லுங்கள். பின்வருவனவற்றை உள்ளிட்டு, நீங்கள் நானோவைப் பயன்படுத்தினால் அதைச் சேமிக்க Ctrl + O ஐ அழுத்தவும்:

#! / bin / bash ranNum = $ (($ RANDOM% 2)) எதிரொலி $ 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] எதிரொலி $ ranNum

நீங்கள் ஒரு சீரற்ற எண்ணை உருவாக்க விரும்பும் போதெல்லாம் சீரற்ற தட்டச்சு செய்வதன் மூலம் கட்டளை வரியிலிருந்து எளிதாக இயக்கலாம்.