>> რობ Bowden: Hi.
მე რობ, და ვიმედოვნებ, რომ თქვენი თამაში თამაში 15.
ახლა, არსებობს ოთხი ფუნქციები გჭირდებათ განახორციელოს ამ პროგრამაში - init,
მიაპყროს, გადაადგილება, და გაიმარჯვა.
ასე რომ, მოდით შევხედოთ init.
>> აქ ჩვენ ვხედავთ, პირველი, რაც ჩვენ ვაპირებთ გავაკეთოთ არის განაცხადოს ცვლადი
ე.წ. counter.
ეს იქნება ინიციალიზაცია დ ჯერ d მინუს 1.
გახსოვდეთ, რომ d არის განზომილება ჩვენი ფორუმში.
როგორ init იმუშავებს არის ის აპირებს iterate მეტი მთელი საბჭოს
და ჩვენ ვაპირებთ დავიწყოთ ზედა მარცხენა.
>> და მოდით უბრალოდ, ვამბობთ ჩვენ აქვს 4 4 ფორუმში.
ასე რომ ზედა მარცხენა ვართ ვაპირებ ვთქვა, ის არის 15.
და მაშინ ჩვენ უბრალოდ აპირებს ითვლიან მეშვეობით დაფები და განაცხადა, რომ 15, 14, 13,
12, 11, 10, 9, 8, 7, 6, 5, 4, და ასე შემდეგ.
ასე რომ ზედა მარცხენა, ჩვენ მოველით, რომ იყოს დ ჯერ d მინუს 1, რომელიც 4 4
შემთხვევაში იქნება 16 მინუს 1, რომელიც სწორად 15.
>> და ახლა აქ, სადაც ჩვენ ვაპირებთ iterate მთელ ფორუმში.
და ჩვენ ვაპირებთ, რომ მითითებული თითოეული პოზიცია ფორუმში მიმდინარე ღირებულება
ჩვენი counter და შემდეგ counter აპირებს to decrement, რომ მომავალ
პოზიცია მივაღწევთ აპირებს counter იყოს ნაკლები
წინა პოზიცია.
ამიტომ ჩვენ თავდაპირველად ჰქონდა 15 და decrement counter.
ასე რომ მაშინ ჩვენ ვაპირებთ დაავალოს 14 დან შემდეგი პოზიცია, decrement counter,
და ჩვენ ვაპირებთ დაავალა 13, და ასე შემდეგ.
>> და ბოლოს, ჩვენ უნდა გაუმკლავდეს კუთხეში იმ შემთხვევაში, თუ საბჭოს აქვს კიდევ
განზომილება, მაშინ უბრალოდ აკეთებს 15, 14, 13, 12, ყველა გზა ქვემოთ 3, 2, 1, არის
დატოვებს ჩვენს გადაუჭრელ ფორუმში.
და ჩვენ უნდა სვოპ 1 და 2.
ასე რომ, თუ d mod 2 უდრის 0, რომ როგორ ვაპირებთ, რათა შეამოწმოს
თუ ეს კიდევ.
იმ შემთხვევაში, თუ d mod 2 უდრის 0, მაშინ ზედიზედ d მინუს 1, რომელიც ქვედა გრაფაში და
პოზიცია d მინუს 2, ან სვეტი დ minus 2, ჩვენ ვაპირებთ, რომ მითითებული, რომ 2 და
სვეტი დ მინუს 3 ჩვენ აპირებს შექმნას 1.
ასე რომ, უბრალოდ უკუქცევის სადაც 1 და 2 არ არიან.
>> და ბოლოს, ჩვენ ვაპირებთ, რომ მითითებული ძალიან ქვედა მარჯვენა ტოლი ცარიელი, სადაც
ცარიელი უკვე hash განსაზღვრული ზედა, როგორც 0.
ისე, რომ არ იყო მკაცრად აუცილებელია, მას შემდეგ, რაც ამ loop აპირებს
მითითებული ქვედა მარჯვენა 0, მას შემდეგ, counter ბუნებრივია მიაღწიოს 0.
მაგრამ, რომ ეყრდნობა us იცის, რომ ცარიელი იყო hashed მოძიების 0.
თუ მე წასვლას ამ პროგრამის შესახებ და შემდეგ შეცვლა ცარიელი ზედა 100,
მაინც უნდა იმუშაოს.
>> ასე რომ, ეს უბრალოდ მიღების დარწმუნებული ვარ, რომ ქვედა მარჯვენა რეალურად ტოლია ჩვენი
blank ღირებულება.
და ბოლოს, ჩვენ გვაქვს ორი გლობალური ცვლადები, ასე ცარიელი i და ცარიელი j, და ჩვენ ვხედავთ
იმ გამოაცხადა ზედა.
და ჩვენ ვაპირებთ გამოვიყენოთ ეს ორი გლობალურ ცვლადები ტრეკზე
პოზიცია ცარიელი, ისე, რომ ჩვენ არ უნდა გამოიყურებოდეს მთელი
ფორუმში იპოვოს ცარიელი თითოეული დროს ჩვენ ვცდილობთ, რათა ნაბიჯი.
ასე რომ, პოზიცია ცარიელი ყოველთვის არის ვაპირებთ დავიწყოთ ბოლოში უფლება.
ასე რომ ქვედა მარჯვენა მოცემულია მიერ ინდექსების d მინუს 1, d მინუს 1.
ასე რომ, init.
>> ახლა ჩვენ გადაადგილება მიაპყროს.
ასე რომ, გათამაშება იქნება მსგავსი სადაც ჩვენ ვაპირებთ iterate
მთელ ფორუმში.
და ჩვენ უბრალოდ გვინდა ბეჭდვა ღირებულება ეს არის ის, თითოეულ თანამდებობაზე ფორუმში.
ასე რომ აქ, ჩვენ დაბეჭდვის ღირებულება, რომ თითოეულ თანამდებობაზე ფორუმში.
და შენიშნავს, რომ ჩვენ ვაკეთებთ -.
და ეს უბრალოდ ვეუბნებოდი printf რომ მიუხედავად იმისა, თუ ის ერთი ციფრი ან
ორი ციფრი ნომერი, მაინც მინდა, რომ დასჭირდეს ორ ბურჯს ბეჭდვითი out,
ასე რომ, თუ ჩვენ გვაქვს ორი ციფრი და ერთი ციფრიან ნომრებს იმავე საბჭო, ჩვენი
საბჭოს კვლავ გამოიყურება ლამაზი და მოედანზე.
>> ასე რომ ჩვენ გვინდა, რომ ყველა ღირებულება ფორუმში, გარდა ცარიელი.
ასე რომ, თუ პოზიცია board შეადგენს ცარიელი, მაშინ ჩვენ კონკრეტულად
გსურთ ამობეჭდოთ მხოლოდ ტირეთი წარმოადგენს ცარიელი, ნაცვლად
რასაც ღირებულება ცარიელი რეალურად არის.
>> და ბოლოს, ჩვენ გვინდა ბეჭდვა out ახალი ხაზი.
გაითვალისწინეთ, რომ ეს არის კიდევ შიგნით გარე მარყუჟის, არამედ მის ფარგლებს გარეთ
შიდა for loop.
რადგან ეს გარე მარყუჟის არის iterating მთელი რიგები, და ა.შ. ეს printf არის
ვაპირებ უბრალოდ ბეჭდვა ახალი ხაზი, ამიტომ ჩვენ გადაადგილება ამობეჭდოთ მომავალი row.
და რომ ეს გათამაშება.
>> ასე რომ, ახლა მოდით გადაადგილება გადატანა.
ახლა, ჩვენ გაივლის ნაბიჯი, კრამიტი, რომ პროფაილი შევიდა თამაში - მათ
შესვლის ფილა მათ სურთ გადაადგილება - და თქვენ უნდა დაბრუნების bool, ასე რომ,
არც ჭეშმარიტი ან მცდარი, რაც დამოკიდებულია მიუხედავად იმისა, რომ ეს ნაბიჯი იყო, ფაქტობრივად,
ძალაშია - თუ არა, რომ ფილა შეიძლება გადავიდა ცარიელი სივრცე.
>> ასე რომ აქ, ვაცხადებთ ადგილობრივი ცვლადი, tile_1 და tile_j, რომლებიც აპირებენ
იყოს მსგავსი blank_i და blank_j, გარდა ის აპირებს ტრეკზე
პოზიცია ფილა.
ახლა აქ, ჩვენ ვაპირებთ გამოვიყენოთ blank_i და blank_j და ამბობენ, ყველა უფლება, ასე რომ,
აქ არის ცარიელი ფორუმში.
>> ახლა არის კრამიტი ზემოთ ცარიელი?
არის კრამიტი მარცხნივ ცარიელი?
არის კრამიტი მარჯვნივ ცარიელი?
არის ფილა ქვემოთ ცარიელი?
ასე რომ, თუ ფილა ნებისმიერ იმ პოზიციებს, მაშინ ჩვენ ვიცით, რომ ფილა
შეიძლება გადავიდა ცარიელი ადგილზე და ცარიელი შეიძლება გადავიდა, სადაც
ფილა ამჟამად.
>> ასე რომ აქ, ჩვენ ვამბობთ, თუ საბჭოს პოზიცია blank_i მინუს 1 blank_j.
ასე რომ, ეს ნათქვამია, ფილა ზემოთ არსებული ცარიელი?
და თუ ასეა, ჩვენ ვაპირებთ გვახსოვდეს რომ არის პოზიცია ფილა.
კრამიტი არის პოზიცია blank_i მინუს 1 და blank_j.
ახლა პირველ რიგში, ჩვენ ასევე გვაქვს ამ გამშვები სწორედ აქ, ამიტომ blank_i არის
უფრო მეტი, ვიდრე 0.
>> რატომ გვინდა ამის გაკეთება?
ისე, თუ ცარიელი არის ყველაზე row გამგეობის, მაშინ ჩვენ არ გვინდა, რომ
შეხედეთ ზემოთ ცარიელი ფილა წლიდან არაფერია ზემოთ დაბრუნება
row ფორუმში.
ეს არის, თუ როგორ შეიძლება დასრულდება მდე მიღების რაღაც სეგმენტაცია ბრალია ან
თქვენი პროგრამა შეიძლება მხოლოდ მუშაობა მოულოდნელი გზები.
ასე რომ, ეს არის მიღების დარწმუნებული ვარ, რომ ჩვენ არ გამოიყურება ადგილები, რომლებიც არ არის სწორი.
>> ახლა ჩვენ ვაპირებთ იგივე ყველა სხვა შესაძლო კომბინაციები.
ასე რომ აქ, ჩვენ ვეძებთ ქვემოთ ცარიელი თუ რომ ფილა.
და ჩვენ ასევე უნდა დავრწმუნდეთ, რომ ჩვენ არა ქვედა გრაფაში, ანდა ჩვენ
არ უნდა ვეძებოთ ფილა.
აქ ჩვენ ვაპირებთ შევხედოთ მარცხენა ცარიელი თუ ეს ფილა.
და ჩვენ არ უნდა ვუყურებდეთ მარცხენა თუ ჩვენ ამ leftmost სვეტი.
და აქ ჩვენ ვაპირებთ შევხედოთ მარჯვნივ ცარიელი, და ჩვენ არ უნდა
გამოიყურება უფლება, თუ ჩვენ ამ rightmost სვეტი.
>> ასე რომ, თუ არა იმ რამ იყო ნამდვილი, ეს ნიშნავს, რომ ფილა არ იყო მოსაზღვრე
რომ ცარიელი და ჩვენ შეგვიძლია დაბრუნების ცრუ.
ნაბიჯი არ იყო სწორი.
მაგრამ, თუ ერთი იმ ჭეშმარიტ იყო, შემდეგ ამ ეტაპზე, ჩვენ ვიცით, რომ tile_i და
tile_j ტოლია პოზიცია ფილა.
ასე რომ, ჩვენ შეიძლება განახლდეს საბჭოს პოზიციები tile_i და tile_j.
ჩვენ ვიცით, ახალ ღირებულება იქნება ცარიელი და რომ პოზიცია blank_i
blank_j, რომელიც იყო ორიგინალურ ცარიელი - ჩვენ ვიცით, ფილა აპირებს
იქ.
>> გაითვალისწინეთ, რომ ჩვენ არ რეალურად უნდა გავაკეთოთ რეალური swap აქ, რადგან ჩვენ ვიცით,
ფასეულობები, რომელიც უნდა დაემატოს იმ პოზიციებზე.
ჩვენ არ გვჭირდება დროებითი ცვლადი გარშემო.
>> და ბოლოს, ჩვენ უნდა გვახსოვდეს, რომ ჩვენ ჩვენი გლობალური ცვლადები, რომლებიც
შენახვა ტრეკზე პოზიცია ცარიელი.
ასე რომ ჩვენ გვინდა განაახლოთ თანამდებობაზე ცარიელი უნდა იყოს, სადაც ფილა
თავდაპირველად იყო.
და ბოლოს, ჩვენ იქნება TRUE, რადგან ნაბიჯი წარმატებული იყო.
ჩვენ წარმატებით სვოპ ცარიელი და ფილა.
>> ყველა უფლება, ასე უკანასკნელი ჩვენ უნდა შეამოწმოთ მოიგო.
ასე რომ, თეთრებმა ასევე დააბრუნებს bool, სადაც დიახ აპირებს მიუთითებს, რომ
პროფაილი მოიგო თამაში.
და ცრუ არის იმაზე მიუთითებს, რომ თამაში გრძელდება.
მომხმარებელს ჯერ არ მოიგო.
ასე რომ, ეს იქნება საკმაოდ ბევრი საპირისპირო init, სადაც init,
მახსოვს, ჩვენ ინიციალიზაცია ფორუმში 15, 14, 13, 12, ა.შ..
ვინაიდან მოიგო, ჩვენ გვინდა, რომ შეამოწმოთ, თუ board 1, 2, 3, 4, 5, და ასე შემდეგ.
>> ასე რომ, ჩვენ ვაპირებთ ინიციალიზაცია ჩვენი counter 1 რადგან ეს არის ის, რაც ყველაზე
მარცხენა board უნდა იყოს.
და მაშინ ჩვენ ვაპირებთ loop მთელ ფორუმში.
მოდით იგნორირება ამ მდგომარეობაში მეორე.
და ამ მდგომარეობაში მხოლოდ აპირებს ჩეკი არის ფორუმში ამ თანამდებობაზე
თანაბარი მიმდინარე ითვლის?
თუ ასეა, ნამატი რაოდენობა ისე, რომ შემდეგი პოზიცია შევხედავთ ერთი უმაღლესი
ვიდრე პოზიცია ჩვენ ვიმყოფებით ახლა.
>> ასე რომ, თუ მივიღებთ ზედა მარცხენა უნდა იყოს 1.
ნამატი რაოდენობა 2.
შევხედოთ მომავალ თანამდებობაზე.
ეს არის 2?
თუ ასეა, ნამატი რაოდენობა 3.
შემდეგი პოზიცია, ეს 3?
თუ ასეა, ნამატი რაოდენობა 4, და ასე შემდეგ.
ასე რომ, თუ არსებობს რაიმე პოზიცია ფორუმში რომ არ გაუტოლდება ჩვენი რაოდენობა,
მაშინ ჩვენ გვინდა დაბრუნების ცრუ მას შემდეგ იმას ნიშნავს, რომ ზოგიერთი ფილა რომ არის
არ არის სწორი პოზიცია.
>> ასე რომ, აქ, რა არის ამ მდგომარეობის აკეთებს?
ასევე, შეგახსენებთ, რომ ცარიელი არის უნდა წავიდეს მარჯვენა ქვედა.
და ცარიელი ღირებულების შეიძლება არ აუცილებლად თანაბარი ღირებულების
ამტკიცებენ, რომ იქნება მიღწეული ბოლოში უფლება.
ასე რომ, ჩვენ კონკრეტულად გვინდა შევამოწმოთ თუ უდრის უდრის d მინუს 1 და j შეადგენს
შეადგენს d მინუს 1 - რომელიც ამბობს, რომ, თუ ჩვენ ეძებს ბოლოში უფლება
ფორუმში - მაშინ ჩვენ უბრალოდ გსურთ გაგრძელება.
ჩვენ გვინდა, რომ გამოტოვოთ ეს განსაკუთრებით iteration of ამისთვის loop.
>> ასე რომ, თუ ჩვენ შევძელით ამ წყობილი მარყუჟის, ეს იმას ნიშნავს რომ
არ არსებობს ფილა რომ იყო არასწორი პოზიცია.
და ჩვენ შესვენება გარეთ loop და მოდის აქ, სადაც ჩვენ შეგვიძლია იქნება TRUE.
ყველა ფილების იყო სწორი პოზიციები და ეს ნიშნავს, რომ მომხმარებელს აქვს
მოიგო თამაში.
და რომ არის ის.
ჩემი სახელი არის რობ Bowden, და ეს იყო 15.