If you're seeing this message, it means we're having trouble loading external resources on our website.

Եթե գտնվում ես վեբ զտիչի հետևում, խնդրում ենք համոզվել, որ *.kastatic.org և *.kasandbox.org տիրույթները հանված են արգելափակումից։

Հիմնական նյութ

Պատահական քայլեր

Վեկտորներին ու ֆիզիկական շարժումներին անցնելուց առաջ փորձենք հասկանալ, թե ինչ է նշանակում էկրանի վրա օբյեկտի շարժում։ Դրա համար կարող ենք ամենապարզ ու ամենատարածված նմանակիչներից մեկը քննարկել՝ պատահական քայլը։
Պատկերացրու՝ կանգնած ես ինչ-որ ձողի մեջտեղում ու տասը վայրկյանը մեկ մետաղադրամ ես գցում։ Եթե զինանշան է, մեկ քայլ առաջ ես գնում, եթե թիվ է, մեկ քայլ հետ ես գնում։ Այսինքն՝ պատահական զբոսանք ես կատարում՝ պատահական քայլերի շարք։ Եթե ձողի վրայից իջնես ու կանգնես գետնի վրա, կկարողանաս երկչափ պատահական քայլեր կատարել՝ նույն մետաղադրամը երկու անգամ գցելով։ Այդ դեպքում կարող ես հետևել այս աղյուսակին։
Մետաղադրամի նետում 1Մետաղադրամի նետում 2Արդյունք
ԶինանշանԶինանշանԱռաջ գնա
ԶինանշանԹիվԱջ գնա
ԹիվԶինանշանՁախ գնա
ԹիվԹիվՀետ գնա
Իհարկե, սա առանձնապես բարդ ալգորիթմ չէ։ Այնուամենայնիվ, պատահական քայլերի միջոցով հնարավոր է աշխարհում տեղի ունեցող բազմաթիվ երևույթներ մոդելավորել, օրինակ՝ գազի մեջ մոլեկուլների, կամ խաղատանը մեկ օր անցկացնող խաղամոլի պահվածքը։ Իսկ մենք արդեն կարող ենք սկսել այս թեմայի ուսումնասիրությունը՝ մեր մտքում երեք նպատակ ունենալով։

Պատահական քայլողի (Random Walker) օբյեկտը

Սկզբի համար վերհիշենք օբյեկտային կողմնորոշվածությամբ ծրագրավորումը՝ Walker օբյեկտի ստեղծման միջոցով։ Սա մակերեսային կրկնություն կլինի։ Եթե երբևէ չես զբաղվել օբյեկտային կողմնորոշվածության ծրագրավորմամբ, ավելի լավ կլինի՝ օբյեկտային կողմնորոշվածությամբ JavaScript-ի վերաբերյալ հատվածն ուսումնասիրես։
JavaScript-ում օբյեկտը տվյալի տեսակ է, որին նախատիպի միջոցով կցված են հատկություններ և գործառույթներ։ Մենք ուզում ենք ստեղծել Walker օբյեկտ, որը կպահի իր վերաբերյալ տեղեկություն, օրինակ՝ այդ պահին էկրանի որ հատվածում է գտնվում, և որը կարողանում է որոշ գործողություններ կատարել, օրինակ՝ ինքն իրեն նկարել կամ քայլ կատարել։
Walker օբյեկտի օրինակներ ստեղծելու համար պետք է Walker օբյեկտը սահմանենք։ Եթե փորձենք թխվածքների վրա օրինակը բերել, ապա օբյեկտը կլինի թխվածքի կաղապարը, իսկ Walker-ի յուրաքանչյուր օրինակ կլինի նոր թխվածք։
Սկզբի համար սահմանենք Walker օբյեկտի տեսակը։ Walker-ը պետք է ընդամենը իր x և y կոորդինատները պահի։ Կառուցող ֆունկցիայում կարող ենքնախնական արժեքներ փոխանցել դրանց՝ ստեղծվող օբյեկտը տեղակայելով կտավի կենտրոնում։
var Walker = function() {
    this.x = width/2;
    this.y = height/2;
};
x և y կոորդինատները պահելուց բացի Walker օբյեկտը պետք է ունենա մեթոդներ, որոնք հնարավոր է կանչել։ Առաջին մեթոդը օբյեկտին թույլ կտա ինքն իրեն նկարել որպես սև կետ։ Հիշիր, որ JavaScript-ում օբյեկտին մեթոդներ ավելացնելու համար պետք է դրանք կցենք օբյեկտի prototype-ին (նախատիպ)։
Walker.prototype.display = function() {
    stroke(0, 0, 0);
    point(this.x, this.y);
};
Walker օբյեկտի երկրորդ մեթոդը դրան թույլ կտա քայլ կատարել։ Այս հատվածն արդեն ավելի հետաքրքիր է։ Հիշո՞ւմ ես գետնի վրա քայլեր կատարելու օրինակը։ Այստեղ կտավը մեր գետինն է, և կան հնարավոր չորս քայլեր։ Դեպի աջ քայլը հնարավոր է նմանակել՝ x-ը մեծացնելով x++, դեպի ձախ քայլը՝ x-ը փոքրացնելով x--, դեպի առաջ քայլը՝ y-ը մեծացնելով y++, դեպի հետ քայլը՝ y-ը փոքրացնելով y--։ Ինչպե՞ս ընտրենք քայլի ուղղությունը։ Հոդվածի սկզբում նշեցինք, որ ընտրությունը կատարելու համար հնարավոր է մետաղադրամ գցել։ Այնուամենայնիվ, ProcessingJS-ում հնարավոր տարբերակներից մեկում պատահական ընտրելու համար հնարավոր է random() հրամանի միջոցով պատահական թիվ ընտրել։
Walker.prototype.walk = function() {
    var choice = floor(random(4));
};
Այս կոդը պատահական 0-ից 4 հատվածում ընկած որևէ տասնորդական թիվ է ընտրում և այն floor() հրամանի միջոցով վերածում ամբողջ թվի. արդյունքը 0, 1, 2 կամ 3 է։Տեսականորեն ընտրված թիվը երբեք 4,0 չի լինի, այն միշտ կլինի 3,999999 (հնարավորինս շատ 9-երով), իսկ քանի որ floor() հրամանը վերադարձնում է ամենամոտ ամբողջ թիվը, որը տրված թվից փոքր կամ հավասար է, միշտ արդյունքում ստացված մեծագույն արժեքը 3 կլինի։\ Դրանից հետո արդեն, ելնելով ստացված թվից, կատարում ենք համապատասխան քայլը՝ աջ, ձախ, առաջ կամ հետ։
Walker.prototype.walk = function() {
    var choice = floor(random(4));
    if (choice === 0) {
        this.x++;
    } else if (choice === 1) {
        this.x--;
    } else if (choice === 2) {
        this.y++;
    } else {
        this.y--;
    } 
};
Քանի որ արդեն դասը գրել ենք, կարող ենք ծրագրում իրական Walker օբյեկտ ստեղծել։ Կառուցող ֆունկցիան կանչելով սահմանում և հայտարարում ենք Walker տիպի ընդհանրական մեկ փոփոխական՝ ենթադրելով, որ միայն մեկ պատահական զբոսանք ենք ուզում մոդելավորել։
var w = new Walker();
Որպեսզի քայլողը որևէ գործողություն կատարի, կարող ենք սահմանել draw() ֆունկցիան։ Այդ ֆունկցիայում քայլողը կարող է քայլ կատարել, ինչպես նաև ամեն կանչից հետո ինքն իրեն ևս մեկ անգամ նկարել։
draw = function() {
    w.walk();
    w.display();
};
Քանի որ draw ֆունկցիայում background հրամանը չենք կանչում, հնարավոր է կտավի վրա պատահական քայլերի հետքը տեսնել։

Պատահական քայլողի բարելավում

Պատահական քայլողին կարող ենք մի քանի ձևով բարելավել։ Օրինակ՝ այս քայլողը ընդամենը չորս ուղղությամբ է կարողանում քայլ կատարել՝ վերև, ներքև, աջ և ձախ։ Այնուամենայնիվ, պատուհանի ցանկացած պիքսել ունի հնարավոր ութ հարևան, իսկ շարժման իններորդ տարբերակը տեղում մնալն է։
Կոդի բնույթի նկար
Պատկեր 1,1
Դեպի ցանկացած հարևան պիքսել շարժվող կամ տեղում մնացող Walker օբյեկտ կիրառելու համար կարող ենք 0-ից 8 թիվ ընտրել. այդ դեպքում կունենանք 9 ընտրություն։ Այնուամենայնիվ, ավելի արդյունավետ տարբերակ է x առանցքով հնարավոր երեք շարժումներից մեկը (-1, 0 կամ 1) և y առանցքով հնարավոր երեք շարժումներից մեկն ընտրել։
Walker.prototype.walk = function() {
  var stepx = floor(random(3))-1;
  var stepy = floor(random(3))-1;
  this.x += stepx;
  this.y += stepy;
};
Ավելին՝ կարող ենք x-ի և y-ի համար տասնորդական թվեր կիրառել՝ -1-ի ու 1-ի միջև ցանկացած թվով տեղաշարժվել. այս մոտեցումը հնարավոր է կիրառել, միայն եթե միջավայրը կարողանում է ցուցադրել 2,2-ի և 2,4-ի միջև տարբերությունը։
Walker.prototype.walk = function() {
  var stepx = random(-1, 1);
  var stepy = random(-1, 1);
  this.x += stepx;
  this.y += stepy;
};
Պատահական «դասական» զբոսանքի բոլոր վարիացիաները մեկ ընդհանրություն ունեն. ցանկացած պահի հավանականությունը, որ Walker-ը կորոշի որևէ ուղղությամբ քայլ կատարել կամ չշարժվել, հավասար է ցանկացած այլ որոշում կատարելու հավանականությանը։ Այլ կերպ ասած, եթե Walker-ն ունի հնարավոր 4 քայլ, դրանցից որևէ մեկն ընտրելու հավանականությունը 25% է։ Եթե Walker-ն ունի հնարավոր 9 քայլ, հավանականությունը 9-ից 1 է (մոտավորապես 11,1%)։
random() ֆունկցիան հենց այսպես աշխատում։ Դրա՝ պատահական թվերի գեներացնող հատվածը ստանում է թվերի «համաչափ» բաշխում։ Այս փաստը կարող ենք ստուգել և ցուցադրել մի ծրագրի միջոցով, որը հաշվում է, թե քանի անգամ է որևէ թիվ ընտրվում, և գրաֆիկում այդ քանակը ներկայացնում է որպես ուղղանկյան երկարություն։
Մի քանի րոպե ծրագիրը կատարելուց հետո բոլոր գոտիները նույն երկարությունն ունե՞ն։ Հավանական է, որ ոչ։ Մեր ընտրույթի չափը՝ մեր ընտրած պատահական թվերի քանակը, բավականին փոքր է, և առկա են որոշ անհամապատասխանություններ. ինչ-որ թվեր ավելի հաճախ են ընտրվում։ Սակայն պատահական թվեր լավ գեներացնող ֆունկցիա ունենալու դեպքում այս պատկերի գոտիները ժամանակի ընթացքում կհավասարվեին։
random() ֆունկցիայից ստացված պատահական թվերը այնքան էլ պատահական չեն, այլ «կեղծ պատահական» են։ Դրանք պատահականություն նմանակող մաթեմատիկական ֆունկցիայի արդյունքն են։ Ժամանակի ընթացքում այս ֆունկցիայի արտածած արժեքները կսկսեն հետևել ինչ-որ օրինաչափության, բայց քանի որ ժամանակի այդ հատվածը մեզ համար չափազանց երկար է, արդյունքը մեզ համար իրոք պատահական է։
Հաջորդ հատվածում խոսելու ենք որոշակի ուղղություններ «նախընտրող» քայլողներ ստեղծելու մասին։ Սակայն մինչ այդ քեզ սպասում է մեր մարտահրավերը։

«Բնական նմանակիչներ» դասընթացը ստեղծվել է Դանիել Շիֆմանի «Կոդի բնույթը» գրքի հիման վրա և կիրառվում է ըստ Creative Commons Attribution-NonCommercial 3,0 Unported License-ի։

Ուզո՞ւմ ես միանալ խոսակցությանը։

Առայժմ հրապարակումներ չկան։
Անգլերեն հասկանո՞ւմ ես: Սեղմիր այստեղ և ավելի շատ քննարկումներ կգտնես «Քան» ակադեմիայի անգլերեն կայքում: