ტექნიკურად, ტერმინი "შემთხვევითი რიცხვების გენერატორი" სისულელეა, რადგან თავად რიცხვები შემთხვევითი არ არის. მაგალითად, 100 შემთხვევითი რიცხვია? რაც შეეხება 25-ს? რას ნიშნავს ეს ტერმინი სინამდვილეში არის ის, რომ ის ქმნის რიცხვების თანმიმდევრობას, რომლებიც შემთხვევით ჩნდება. ეს ბადებს უფრო რთულ კითხვას: რა არის შემთხვევითი რიცხვების თანმიმდევრობა? ერთადერთი სწორი პასუხი: შემთხვევითი რიცხვების თანმიმდევრობა არის თანმიმდევრობა, რომელშიც ყველა ელემენტი არ არის დაკავშირებული. ეს განმარტება იწვევს პარადოქსს, რომ ნებისმიერი თანმიმდევრობა შეიძლება იყოს შემთხვევითი ან არა შემთხვევითი, იმისდა მიხედვით, თუ როგორ მიიღება თანმიმდევრობა. მაგალითად, რიცხვების შემდეგი სტრიქონი
1 2 3 4 5 6 7 8 9 0
მიღებული იქნა კლავიატურის ზედა ხაზის თანმიმდევრობით აკრეფით, ამიტომ თანმიმდევრობა არ შეიძლება ჩაითვალოს შემთხვევით გენერირებულად. მაგრამ რა მოხდება, თუ თქვენ მიიღებთ იგივე თანმიმდევრობას, როდესაც აიღებთ დანომრილ ჩოგბურთის ბურთებს ლულიდან. ამ შემთხვევაში, ეს უკვე შემთხვევით გენერირებული თანმიმდევრობაა. ეს მაგალითიგვიჩვენებს, რომ მიმდევრობის შემთხვევითობა დამოკიდებულია იმაზე, თუ როგორ იქნა მიღებული და არა საკუთარ თავზე.

გახსოვდეთ, რომ კომპიუტერის მიერ გენერირებული რიცხვების თანმიმდევრობა დეტერმინისტულია: თითოეული რიცხვი, გარდა პირველისა, დამოკიდებულია მის წინა რიცხვებზე. ტექნიკურად, ეს ნიშნავს, რომ კომპიუტერის მიერ შეიძლება შეიქმნას რიცხვების მხოლოდ კვაზი შემთხვევითი თანმიმდევრობა, ე.ი. სინამდვილეში ისინი ნამდვილად არ არიან შემთხვევითი. თუმცა, ეს საკმარისია ამოცანების უმეტესობისთვის და სიმარტივისთვის ასეთ თანმიმდევრობას შემთხვევითი ეწოდება. ერთი ძალიან საინტერესო მეთოდი შეიმუშავა ჯონ ფონ ნეუმანმა; მას ხშირად უწოდებენ ფესვის საშუალო კვადრატს. ამ მეთოდით, წინა შემთხვევითი რიცხვი იკვრება კვადრატში, შემდეგ კი შუა რიცხვები ამოღებულია შედეგიდან. მაგალითად, თუ თქვენ ქმნით რიცხვებს სამი ციფრით, ხოლო წინა რიცხვი იყო 121, მაშინ მისი კვადრატი იძლევა შედეგს 14641. შუა სამი ციფრის იზოლირება იძლევა შემდეგ შემთხვევით რიცხვს 464. ამ მეთოდის მინუსი ის არის, რომ მას აქვს ძალიან განმეორების მოკლე პერიოდი, რომელსაც ეწოდება ციკლი. ამ მიზეზით ამ მეთოდითდღეს არ გამოიყენება. თანამედროვე მეთოდებიშემთხვევითი რიცხვების გენერირება ბევრად უფრო რთულია.

შემთხვევითი რიცხვები PHP-ში

PHP-ს აქვს ფუნქციების ორი ჯგუფი შემთხვევით რიცხვებთან მუშაობისთვის. მხოლოდ გარეგნულად, ისინი შეიძლება გამოირჩეოდნენ mt_ პრეფიქსით ერთ-ერთი ჯგუფის ყველა ფუნქციისთვის.

მოძველებული ფუნქციები
რანდის ფუნქცია აბრუნებს მთელ რიცხვს ნულსა და RAND_MAX მნიშვნელობას შორის (რაც არის 32767). შეიძლება ჰქონდეს ორი არასავალდებულო მთელი რიცხვი - თუ ისინი მითითებულია, შემთხვევითი რიცხვი წარმოიქმნება პირველი პარამეტრიდან მეორემდე.

Echo rand(); echo rand (1100); // მიეცით შემთხვევითი რიცხვი 1-დან 100-მდე

ფუნქცია srand. განსაზღვრავს შემთხვევითი რიცხვების თანმიმდევრობას, რომლებიც წარმოიქმნება რანდის ფუნქციით. აქვს მთელი პარამეტრი - როდის სხვადასხვა მნიშვნელობაამ პარამეტრით რენდი გამოიმუშავებს რიცხვების სხვადასხვა თანმიმდევრობას. srand ფუნქციის გამოძახება მხოლოდ ერთხელ არის საჭირო რანდის ფუნქციის ყველა გამოძახებამდე. გამოყენების მაგალითი:

სრანდი(1288); // შემთხვევითი რიცხვების გენერატორის ინიციალიზაცია for($i=0; $i ელემენტების რაოდენობა დიაპაზონში = 247 - 78 + 1 = 170; (რადგან ორივე საზღვრები მოიცავს

/*მეთოდი 1:*/ var i = 78, j = 247, k = 170, a = , b = , c, d, e, f, l = 0;< 0) { num3 += 2147483647; } this.SeedArray = num3; this.inext = num; this.inextp = num2; return num3; }; Random.prototype.Sample = function () { return this.InternalSample() * 4.6566128752457969E-10; }; Random.prototype.GetSampleForLargeRange = function () { var num = this.InternalSample(); var flag = this.InternalSample() % 2 == 0; if (flag) { num = -num; } var num2 = num; num2 += 2147483646.0; return num2 / 4294967293.0; }; Random.prototype.Next = function (minValue, maxValue) { if (!minValue && !maxValue) return this.InternalSample(); var num = maxValue - minValue; if (num количество элементов диапазона = 247 - 78 + 1 = 170; (так как обе границы включены.

for(; i = 56) ( num = 1; ) if (++num2 >= 56) ( num2 = 1; ) var num3 = this.SeedArray - this.SeedArray;

თუ (num3 == 2147483647) (num3--; ) თუ (num3

/*მეთოდი 1:*/ var i = 78, j = 247, k = 170, a = , b = , c, d, e, f, l = 0;< how_many_number; i++) { var gen_num = parseInt((Math.random() * (max-min+1)) + min); do { var is_exist = random_number.indexOf(gen_num); if (is_exist >for(; i 20) ( bool = true; ) else ( bool = false; ) ) დაბრუნების ნომერი; )

შემდეგი კოდის გამოყენებით შეგიძლიათ შექმნათ შემთხვევითი რიცხვების მასივი მოცემულ დიაპაზონში გამეორების გარეშე.

ფუნქცია genRandomNumber(how_many_number,min,max) (// პარამეტრები // how_many_number: რამდენი რიცხვის გენერირება გსურთ. მაგალითად, ეს არის 5. // წთ(შეიცავს) : დიაპაზონის მინიმალური/დაბალი მნიშვნელობა. ის უნდა იყოს ნებისმიერი დადებითი მთელი რიცხვი, მაგრამ მაქსიმუმზე ნაკლები, ანუ 4 // max(მაქსიმალური): დიაპაზონის მაქსიმალური მნიშვნელობა უნდა იყოს ნებისმიერი დადებითი, ანუ 50 // დაბრუნების ტიპი: var i = 0; i.

= 0) ( gen_num = parseInt((Math.random() * (max-min+1)) + min); ) else (random_number.push(gen_num); is_exist = -2; ) ) ხოლო (is_არსებობს > -1 );

) document.getElementById("box").innerHTML = შემთხვევითი_ნომერი;

)

შემთხვევითი რიცხვის მისაღებად, თქვით 1-დან 6-მდე, ჯერ გააკეთეთ:

Var მნიშვნელობა = 0.5 + (Math.random() * ((6 - 1) + 1)) var roll = Math.round(მნიშვნელობა);

დაბრუნების როლი;

ზოგადად, ამის კოდი ცვლადების გამოყენებით არის:

Var მნიშვნელობა = (მინ - 0.5) + (მათ.შემთხვევითი() * ((მაქს - მინ.) + 1)) var roll = მათემატიკის რაუნდი(მნიშვნელობა);

დაბრუნების როლი;

მინიმალური მნიშვნელობიდან 0.5-ის გამოკლების მიზეზი არის ის, რომ მხოლოდ მინიმალური მნიშვნელობის გამოყენებით შეგიძლიათ მიიღოთ მთელი რიცხვი, რომელიც იქნება თქვენს მაქსიმალურ მნიშვნელობაზე მეტი. მინიმალური მნიშვნელობიდან 0.5-ის ამოღებით, თქვენ არსებითად თავიდან აიცილებთ მაქსიმალური მნიშვნელობის დამრგვალებას.

იმედია ეს ეხმარება.

შემთხვევითი მთელი რიცხვი ყველაზე დაბალსა და უმაღლეს შორის:

ფუნქცია randomRange(l,h)(var დიაპაზონი = (h-l); var random = Math.floor(Math.random()*range); if (შემთხვევითი === 0)(შემთხვევითი+=1;) დააბრუნებს l+შემთხვევითს; )

არა ყველაზე ელეგანტური გამოსავალი.. მაგრამ რაღაც სწრაფი.

ფუნქცია getRandomInt(ქვედა, ზედა) ( // ლუწი ნიმუშის განაწილების შესაქმნელად დააბრუნებს Math.floor(lower + (Math.random() * (ზედა - ქვედა + 1))); // ნიმუშის არათანაბარი განაწილების შესაქმნელად // დაბრუნება Math.round(ქვედა + (Math.random() * (ზედა - ქვედა)) // მაქსიმალური მნიშვნელობის გამოსარიცხად შესაძლო მნიშვნელობებიდან //return Math.floor(ქვედა + (Math.random() * (ზედა - ქვედა)));< Number.MIN_SAFE_INTEGER) { throw new Error("Arguments must be safe integers."); } else if (range >ამ ფუნქციისა და ამ ფუნქციის ვარიაციების შესამოწმებლად, შეინახეთ ქვემოთ მოცემული HTML/JavaScript ფაილში და გახსენით იგი ბრაუზერში. კოდი აჩვენებს გრაფიკს, რომელიც აჩვენებს მილიონი ფუნქციის ზარის განაწილებას. კოდი ასევე ჩაიწერს კიდეების შემთხვევებს, ასე რომ, თუ ფუნქცია აწარმოებს მაქსიმუმზე მეტ მნიშვნელობას ან min-ზე ნაკლებს, თქვენ.will.know.about.it.< min) { throw new Error("max (${max}) must be >= წთ ($(წთ)"); ) სხვა შემთხვევაში, თუ (მინ === მაქსიმუმ) (დაბრუნების მინ; ) ნება გენერირდეს; გააკეთე (გენერირებული = crypto.getRandomValues(ახალი Uint32Array(1)); ) ხოლო (გენერირებული > maxUnbiased აბრუნებს min + (გენერირდება % possibleResultValues.log(randomInteger(-8, 8)); 944450079 console.log(randomInteger(-1, 0xFFFFFFFF) // შეცდომა: 4294967296-ის დიაპაზონი, რომელიც მოიცავს -1-დან 4294967295-მდე არის > 4294967295. console.log(new Array(12). (8, 12)));

"ალგორითმი" მასივიდან მნიშვნელობების შემთხვევით არჩევისთვის მათი განმეორების გარეშე. უფრო კონკრეტულად, როგორც ჩემი JS ტრენინგის ნაწილი, მე გამოვიყენე ის პერსონაჟების კლასიკური RPG ჯგუფის გენერირებისთვის (ბარბაროსი, ჯადოქარი, ქურდი, რაინდი, მღვდელი), კლასების და სახელების გამეორების გარეშე.

პრინციპი ძალიან მარტივია, მაგრამ ის შეიძლება სასარგებლო იყოს JS დამწყებთათვის, როგორც მე. RPG-თან კავშირი წმინდა სიმბოლურია - ახლა აქტიურად ვცდილობ შევცვალო ჩემი პროფილი მარკეტინგიდან IT-ზე (მივხვდი, რომ ჩემი სული დევს), ხოლო თამაშის ფორმაში ვარჯიში ბევრად უფრო საინტერესოა.

1. შექმენით შაბლონი სიმბოლოთა ჯგუფის შექმნამდე, თქვენ უნდა დააყენოთ შაბლონი მათი თაობისთვის. სინამდვილეში, აქ არის:

ფუნქცია GamePlayer(n, r, l, p) ( this.nick = n; this.role = r; this.level = l; this.portrait = p; )
ფაქტობრივად, ეს ფუნქცია შექმნის სიმბოლოებს იმ ცვლადებიდან, რომელთა მეშვეობითაც მოხდება მისი გამოძახება. მაგალითად:

Var player1 = ახალი GamePlayer ("Power Ranger", "barbarian", "64", "img/barbarian.jpg")
ახლა player1 ცვლადი ინახავს 64 დონის Power Ranger ბარბაროსს კონკრეტული პორტრეტით; მისი ნებისმიერი პარამეტრის ჩვენება შეგვიძლია გვერდის სხეულში player1.nick, player1.level და ა.შ.

GamePlayer-ის მნიშვნელობები (n, r, l, p) პასუხისმგებელია ფუნქციის მონაცემების მიღებასა და შეკვეთაზე. თუ მაგალითში გავცვლით n-ს და r-ს, მაშინ მძლავრი რეინჯერი ბარბაროსი დარჩება player1-ში, რაც ბოლომდე არ შეესაბამება დავალებას.

2. განსაზღვრეთ მასივები იმისთვის, რომ ჩვენ თვითონ არ შევქმნათ სიმბოლოები, არამედ თითქმის შემთხვევით გენერიროთ ისინი (როგორც სათაურში გვპირდება), ჩვენ გვჭირდება მასივები, საიდანაც ავიღებთ იმავე სიმბოლოების პარამეტრებს. როგორც უკვე აღვწერეთ, ჩვენ გვაქვს მხოლოდ 4 პარამეტრი: პერსონაჟის სახელი, კლასი, დონე და პორტრეტი.

მასივი სახელისთვის:

Var playerNames = ["კურდღელი უმწეო", "თბილი, საშინელი ქაფი", "სურვილის ნაკრები", "Angel Dusty", "Sweety Frozen", "Silver Heavy Wombat", "Lost Puma", "Vital Panda", "Rolling Sun" , "ფოლადის რბილობი", "ახალგაზრდა მელა", "უაზრო დაუნდობელი მოხალისე", "მომღერალი კულტი", "ინდიგო ლეკვი"];
შესაძლებელი იქნებოდა უფრო შორს წასვლა და სახელების გენერირება 2-3 კომპონენტიდან, მაგრამ ასეთი გაუმჯობესების ალგორითმი არ შეიცავს ახალს (იგივე შემთხვევითობას) და შემდეგ უბრალოდ გაართულებს სასწავლო პროცესს.

მასივი კლასისთვის:

Var playerRoles = ["ბარბაროსი", "მაგი", "თაღლითი", "რაინდი", "მღვდელი"];
ყველაფერი ისეთივე აშკარაა. რამდენიმე სტრიქონი, საიდანაც შემდეგ ჩვენ ვირჩევთ მნიშვნელობებს გვერდზე გამოსატანად.

მასივი დონისთვის:

ამ კონკრეტულ მაგალითში მე მინდოდა, რომ ყველა პარტიის წევრი ყოფილიყო 60-დან 70-მდე დონეებს შორის. მაგრამ, რადგან პირობები შეიძლება შეიცვალოს, საჭირო იყო მასივის შექმნა 0-დან 80-მდე დონემდე, საიდანაც შემდეგ შეარჩიეთ საჭირო მნიშვნელობები. შეიქმნა მარყუჟში:

Var playerLevels = ; ამისთვის (i = 0; i