ZAMYLA chan: ეს არის-me, Zamyla.
დღეს, ჩვენ ვაპირებთ განახორციელოს Mario, სადაც ჩვენ მიაპყროს Mario
სრული პირამიდის მას ნახტომი მეტი.
მოდით ჩაიშალოს ქვე-ამოცანები ამ პრობლემას.
>> პირველი, ჩვენ გვინდა უბიძგონ შესახებ სიმაღლე პირამიდის.
და მაშინ ჩვენ გვინდა დავრწმუნდეთ რომ შეყვანის მოქმედებს.
და მაშინ ჩვენ ვაპირებთ მინდა გავამახვილო პირამიდის.
>> ასე რომ, მოდით ვისაუბროთ რითაც და წევრები მომხმარებლის შეყვანის.
ეს შეიძლება რაღაც ამ, do- ხოლო მარყუჟის, რომ
თხოვს მომხმარებელს რიცხვი და შემდეგ მხოლოდ იმეორებს
თუ ეს რიცხვი არასწორია.
რა უნდა ამ მდგომარეობაში უნდა იყოს?
>> ამ, მოდით დავუბრუნდეთ დაზუსტება.
ისე, სპეც გვეუბნება, რომ ნებისმიერი მოქმედი სიმაღლე იქნება 0-დან 23,
ჩათვლით.
ასე რომ, გამოდის, რომ ნებისმიერი არასწორი სიმაღლე იქნება ნაკლები 0
ან მეტი 23.
>> ასე რომ, ახლა რომ ჩვენ გვაქვს ეს ინფორმაცია, მოდით დიზაინი ჩვენი მდგომარეობა.
მაგრამ ჩვენ უნდა ვიყოთ ფრთხილად, რადგან ახლა ჩვენ გვაქვს
ორი Booleans, რომ ჩვენ გვინდა შევაფასოთ.
>> აქ მე იმ პირობით, თქვენ ერთად სიმართლე მაგიდა.
ეს საშუალებას გვაძლევს, რომ ორი Booleans, ლოგიკური ერთი და ორი.
და ჩვენ შეგვიძლია შევაფასოთ ან bool1 და bool2 ან bool1 ან bool2.
>> ასე რომ, რა არის განსხვავება შორის და და ან?
ისე, bool1 და bool2 იქნება შეაფასოს ჭეშმარიტი, თუ და მხოლოდ
თუ ორივე Booleans არის ჭეშმარიტი, იმის გამო, რომ ან ექსპლუატაციის
იქნება ნამდვილი თუ არც ერთი Booleans ან ორივე არის ჭეშმარიტი.
ასე რომ, ამ აზრით, თუ თქვენ შეგიძლიათ გაერკვნენ
რა შესაბამისი პირობა თქვენი do-loop ხოლო არასწორი n
იქნება.
>> ამასთან, ჩვენ აიძულა და დამტკიცდა მომხმარებელი სიმაღლე პირამიდის
რომ მათ სურთ.
ასე რომ, ახლა, ეს ჩვენთვის მიაპყროს პირამიდის.
სრული პირამიდის ამ პრობლემა გამოიყურება ცოტა
მსგავსი, სადაც ჩვენ გვაქვს მარცხენა პირამიდის, გარკვეული შეუსაბამობა, და შემდეგ მარჯვენა პირამიდის.
მოდით დაარღვიოს ეს ქვემოთ ცოტა.
>> თუ მე ჩემი ტექსტური რედაქტორი, აქ მე შედგენილი us მარცხენა სწორებით პირამიდის.
მაგრამ, რომ არ გააკეთებს.
ის, რაც ჩვენ გვსურს რომ არის ჩვენ გვინდა შექმნა მარჯვენა სწორებით პირამიდის პირველი.
ასე რომ ამის გაკეთება, უბრალოდ დააყენებს ჩემი ჰეშები გასწვრივ მხარეს,
მე უბრალოდ აპირებს დააყენოს გარკვეული სიმბოლოები შორის, მხოლოდ ამ წერტილები.
ამის შემდეგ მე ვაპირებ, რომ ბოლო ორი წლის შემდეგი ხაზი, და ერთი, რომ ხაზი.
ასე რომ, აქ მაქვს მარჯვენა სწორებით პირამიდის.
>> ამის შემდეგ, მე ვაპირებ დაბრუნდეს დაბრუნება ზედიზედ
და ამით უფსკრული, რომელიც არის, თითო სპეც, ორი სივრცეებს.
ამის შემდეგ მე ვაპირებ შევსება მეორე მხარეს პირამიდის.
მე ვაპირებ წასვლა მეორე რიგის, წერა ორი ფართების უფსკრული და შემდეგ ორი
ჰეშები.
უკან მესამე რიგის, ორი ფართები ხარვეზის და სამი ჰეშები.
და ბოლოს, ორი ფართები ხარვეზის და ოთხი ჰეშები.
ასე რომ, რაც სრული პირამიდის გამოიყურება.
>> რა თქმა უნდა, ჩვენ არ გვინდა, ეს წერტილები გზა.
ასე რომ, ჩვენ ვაპირებთ, რომ შეცვალოს ეს წერტილები აყენებს ზოგიერთი ფართები.
ერთი, ორი, სამი, პირველი ხაზი.
ერთი, ორი მეორე.
და ერთი მესამე ხაზი.
ასე რომ, ეს არის ის, რაც ჩვენ ყველაფერს გააკეთებს, თუ ჩვენ მინდოდა უბრალოდ მიიღოს სრული პირამიდის,
ამბობენ, ჩვენი ტექსტური რედაქტორი.
>> ასე რომ, მოდით ეს, გაგება იმ ნიმუშების,
და დააკონვერტიროთ ის მეტი ზოგიერთი pseudocode.
თითოეული ზედიზედ პირამიდის, ჩვენ გვინდა ბეჭდვა მარცხენა პირამიდის და შემდეგ
უფსკრული და შემდეგ მარჯვენა პირამიდის.
მარცხენა პირამიდის, ჩვენ ბეჭდვა საჭირო თანხის ფართები,
მოჰყვა ჰეშები.
მაშინ ჩვენ ბეჭდვა უფსკრული, რომელიც მხოლოდ ორი ფართები ყოველ ჯერზე.
და სწორი პირამიდის, ჩვენ ბეჭდვა საჭირო რაოდენობის ჰეშები.
>> მეორე რიგის, ჩავატარეთ ზუსტად იგივე პროცესი.
ჩვენ ბეჭდვა ფართები მარცხენა პირამიდა, საჭირო თანხა
ჰეშები, უფსკრული, ორი ფართების, და მაშინ ჰეშები უფლება პირამიდა.
>> მოდით დაძლევის ნიმუში მარცხენა პირამიდის.
თუ მქონდა, იმ მიზნით, ამ მაგალითად, სიმაღლე
რვა მიერ მოთხოვნილი შესახებ, მაშინ ჩემი პირველი რიგის
ექნება ერთი hash და შვიდი სივრცეებს.
ჩემი მეორე რიგის ექნება ორი ჰეშები, ექვსი ფართები.
მესამე რიგის, სამი ჰეშები, ხუთ ფართები.
თქვენ ალბათ შეუძლია ამის გაკეთება თავის სიმაღლე რვა
და განსაზღვრავს თითოეული ზედიზედ რამდენი ჰეშები და რამდენი ფართები გჭირდებათ.
მაგრამ ის, რაც ჩვენ გვინდა გავაკეთოთ არის ჩვენ გვინდა, რომ აბსტრაქტული იგი.
ასე რომ, გთხოვთ ნებისმიერი nth ზედიზედ რამდენი ჰეშები და რამდენი ფართები გვჭირდება?
>> ახლა, როგორც თქვენ განსაზღვრავს ნიმუში რამდენი ჰეშები
და რამდენი ფართები გჭირდებათ ნებისმიერი nth ზედიზედ მოცემული სიმაღლე,
გვახსოვდეს, რომ ფრთხილად როგორ თქვენ ინდექსირებას.
რა ნიშნავს ეს, რომ ყოველდღიურ ცხოვრებაში ყველაზე მეტად ჩვენს დაიწყება დათვლის ერთი.
ასე რომ, პირველი რიგის იქნება ნომერ.
მეორე რიგში იქნება ზედიზედ ნომერი ორი, და ასე შემდეგ.
>> მაგრამ კომპიუტერულ მეცნიერებათა და CS50, ჩვენ ნულოვანი ინდექსირებული.
ასე რომ, ჩვენ რეალურად დაიწყოს დათვლის დროს ნულოვანი.
ასე რომ, პირველი რიგის გვინდა იყოს რიგის ნომერი ნულოვანი.
და მეორე რიგის იქნება ზედიზედ ნომერ პირველი.
ასე რომ, თუ მე მქონდა სიმაღლე რვა ჩემი პირამიდის, მაშინ ბოლო ღირებულება N
რეალურად იყოს შვიდი და არა რვა.
>> ასე რომ, ფრთხილად შესახებ.
და უნდა იცოდეს, როდესაც თქვენ განსაზღვრის თქვენი ნიმუში თუ არა თქვენი ნულოვანი ინდექსირებული
ან ერთი ინდექსირებული
>> კარგი.
ასე რომ, ახლა, რომ ჩვენ გვაქვს ნიმუში მარცხენა პირამიდის,
ჩვენ გვჭირდება, რათა დადგინდეს ნიმუში უფსკრული.
საბედნიეროდ, ეს მართლაც მარტივია.
ეს უბრალოდ ყოველთვის ორი სივრცეებს.
>> ასე რომ, ახლა ჩვენ გაგრძელება მარჯვნივ ნიმუში.
პირველ რიგში მოგიწევთ ერთ hash.
მეორე რიგის, ორი.
მესამე რიგის, სამი.
და ასე შემდეგ.
ასე რომ კიდევ ერთხელ, განსაზღვრავს ნებისმიერი აბსტრაქტული n და ნებისმიერ სიმაღლეზე რამდენი ჰეშები
და რამდენი ფართები თითოეული ზედიზედ უნდა ჰქონდეს.
>> კარგი.
ჩვენ ვიცით, რომ თითოეული ზედიზედ ჩვენ უნდა ჩაატაროს გარკვეული პროცესი.
როგორ უნდა გავაკეთოთ, რომ?
ასევე, ჩვენ ვიყენებთ იმ მარყუჟის მშენებლობა, შედგება ინიციალიზაციისას,
მდგომარეობა, და განახლება.
მარყუჟების შეიძლება იქნას გამოყენებული გავიმეორო პროცესებში.
>> ასე ვთქვათ, მე მინდა, რომ მიესალმები, მსოფლიოს 50-ჯერ, მაშინ ჩემი ამისთვის loop
გამოიყურება რაღაც მსგავსი, სადაც მე ვრთავ ჩემს ცვლადი ნულოვანი.
მდგომარეობა არის, რომ მე ნაკლებია, ვიდრე 50.
და შემდეგ განახლება არის ის, რომ მდე ერთი ყოველ ჯერზე.
ასე რომ, რა ამ ყველაფერს გააკეთებს იქნება ბეჭდვა hello, world 50-ჯერ ზედიზედ.
>> ახლა ამბობენ, რომ მინდოდა iterate მეტი სიმაღლე პირამიდის.
მაშინ ნაცვლად კოდირების გარკვეული მნიშვნელობა პირობა,
მე უბრალოდ გამოიყენოთ ცვლადი სიმაღლე.
ასე რომ, რა ამ ყველაფერს გააკეთებს iterate მეტი სიმაღლე თითოეული მწკრივი.
და შემიძლია რაღაც შიგნით ორგანოს, რომელიც loop.
>> რა გვინდა ჩვენ უნდა გავაკეთოთ შიგნით ორგანოს მარყუჟის?
ისე, როგორც ჩვენ აღვნიშნეთ, ჩვენ გვინდა ბეჭდვა ფართები და ჰეშები
მარცხენა პირამიდის და შემდეგ ბეჭდვა ორი ფართები და შემდეგ ბეჭდვა ჰეშები.
ასე რომ, ჩვენ უკვე figured, რომ.
ასე რომ ჩვენ შეგვიძლია დავიწყოთ შეავსოთ ჩვენი პროგრამა ბევრი სხვა.
>> აქ მაქვს გარე მარყუჟის რომ iterates მეტი ყოველ ზედიზედ პირამიდის.
და შიგნით რომ სხეულში მე ვაპირებ ბეჭდვა ფართები არაერთგზის,
ჰეშები არაერთხელ, და მაშინ უფსკრული, და მაშინ ჰეშები უფლება პირამიდა,
და მაშინ, საბოლოოდ, ახალი ხაზი უნდა დაიწყოს მომდევნო ზედიზედ.
>> ამასთან, ჩვენ აიძულა მომხმარებლის შეყვანის.
ჩვენ დარწმუნებული ვართ, რომ ეს მოქმედებს.
და მაშინ ჩვენ შედგენილი პირამიდის.
ასე რომ, ბენ შეუძლია წარმატებით ასვლა პირამიდის.
>> ჩემი სახელი არის Zamyla.
და ეს არის CS50.