ZAMYLA chan: ეს არის ჩემთვის, Zamyla.
დღეს Mario, ჩვენ ვაპირებთ, რომ იყოს ხატვის ნახევარი პირამიდის Mario
ასვლა.
>> მოდით ვისაუბროთ ჩვენი to-გავაკეთოთ ამ პრობლემას.
ჩვენ ვაპირებთ, რომ გსურთ შეეკითხება და შეამოწმოს
მომხმარებელს მოქმედებს შეყვანის როგორ მაღალი უნდათ Mario პირამიდის უნდა იყოს.
და მაშინ, ჩვენ ვაპირებთ, რომ მოუტანს მას.
მოდით დავიწყოთ კარნახით და წევრები შესახებ მათი შეყვანა.
>> ჩვენ შეგვიძლია გამოყენება CS50 ბიბლიოთეკა ფუნქცია
კიდევ int რომელიც უზრუნველყოფს, რომ მომხმარებლის საშუალებებით რიცხვი.
ნებისმიერი დადებითი რიცხვებით, უარყოფითი რიცხვებით, ნომერი 0 ყველა სამართლიანი თამაში.
წინააღმდეგ შემთხვევაში, მომხმარებელს მოთხოვნილია კვალვ, სანამ ისინი შემავალი სწორი რიცხვი.
ახლა მიუხედავად იმისა, რომ კიდევ int აკეთებს ბევრი ჩვენთვის მუშაობა
იმის უზრუნველსაყოფად, რომ შესახებ გვაძლევს რიცხვი,
ჩვენ მაინც უნდა მიმართოს დამატებითი შეზღუდვების შესახებ, რომ.
ყოველივე ამის შემდეგ, ჩვენ არ შეგვიძლია Mario ასვლა ნახევარი პირამიდის სიმაღლე უარყოფითი 12.
>> გარდა ამისა, რომ პრობლემა დაზუსტება
ამბობს, რომ ჩვენ შეგვიძლია მხოლოდ საშუალებას Mario ასვლა
პირამიდის სიმაღლეებზე 0-დან 23.
OK, ასე რომ, ეს იმას ნიშნავს, რომ ჩვენ უნდა მუდმივად უბიძგონ შესახებ
მოგვცეს ძალაშია ნომერი და მხოლოდ გაგრძელდება
ერთხელ ისინი მოგვცა სწორი სიმაღლე.
როგორ უნდა გავაკეთოთ, რომ?
>> ისე, უწყვეტი პროცესები მოგვცეს იდეა მარყუჟების თავისსავე
განმეორებით.
ერთი loop in C, როგორც მაშინ, როდესაც loop, რომელიც მუდმივად
შეასრულოს ორგანოს მარყუჟის, რადგან მოცემული მდგომარეობა აფასებს ჭეშმარიტი.
როგორც კი მდგომარეობა აფასებს მცდარია,
პროგრამის გაგრძელება რაც შეეხება შემდეგ.
ასე რომ, ხოლო მარყუჟების ერთი გზა უზრუნველსაყოფად, რომ ჩვენ მუდმივად
შეგახსენებთ მომხმარებლის მოქმედებს შეყვანის.
და კიდევ, მათ მოგვცეს სწორი შეყვანის, ჩვენ გაგრძელება, რასაც მოდის მომავალი.
ჩვენ ვიცით, რომ ვაპირებთ, ვთხოვოთ მომხმარებლის ამისთვის შეყვანის ერთხელ მაინც.
ასე რომ, ახლა მივალთ დამ ხოლო loop, რომელიც არის do ხოლო loop.
>> ნუ ხოლო მარყუჟების შეასრულოს ორგანოს მარყუჟის ერთხელ მაინც.
ასე რომ, შემოწმების გარეშე მდგომარეობაში, ეს იქნება შეასრულოს ორგანოს loop.
და შემდეგ შეამოწმოს მდგომარეობა ვხედავ თუ არა მას სჭირდება განმეორებაზე.
ეს მოდის მოსახერხებელია, როდესაც ჩვენ წევრები მომხმარებლის შეყვანის.
ჩვენ ვიცით, რომ ჩვენ ვაპირებთ მათ ვთხოვთ, ერთხელ მაინც.
ასე რომ, ნუ ხოლო მარყუჟის შეიძლება რაღაც ამის მსგავსი.
ჩვენ გვაქვს მთელი რიცხვი n.
და შიგნით do ხოლო მარყუჟის, ჩვენ დაუყოვნებლივ
შეეკითხება მომხმარებელს რიცხვი.
თუ n არასწორია, მაშინ ჩვენ, აიძულებს ისევ და ისევ და ისევ, სანამ ისინი
გვაძლევს, რომ სწორი რიცხვი.
და ბოლოს, ერთხელ n არის სწორი შეყვანის, ჩვენ გაგრძელება დანარჩენი ჩვენი პროგრამა.
>> მოდით დავუბრუნდეთ სპეც და შემოწმება რა პირობებს მოქმედებს შეყვანის
იქნება.
მოქმედი სიმაღლეებზე ვაპირებთ იყოს 0-დან 23-ის ჩათვლით.
ასე რომ, არასწორი სიმაღლეებზე ვაპირებთ იყოს ნაკლები ვიდრე 0 ან მეტი 23.
ასე მახსოვს, რათა შეიმუშავონ თქვენი მდგომარეობა ყურადღებით,
იცის, რომ მდგომარეობა იმ do ხოლო loop
უნდა იყოს, ხოლო n არასწორია.
ახლა ეს არ აპირებს იყოს მარტივი ერთი ლოგიკური გამოხატულებაა.
ჩვენ ვაპირებთ, რომ უნდა დააკავშიროთ ორი სხვადასხვა გამონათქვამები
იმისათვის, რომ ჩვენი მთელი მდგომარეობა.
>> მოდით შევხედოთ სიმართლე მაგიდა მე უკვე მოცემული მინიშნება, რომ ჩვენ
იქნება საქმე ორი Booleans.
ასე რომ, აქ არის სიმართლე მაგიდა, სადაც მე აქვს ორი Booleans-- ლოგიკური 1 და 2.
ასე რომ, ჩვენ გვაქვს შესაძლებლობა შეაფასოს bool1 და bool2 ან bool1 ან bool2.
და მხოლოდ მაშინ იქნება ნამდვილი თუ ორივე Booleans შეაფასოს ჭეშმარიტი, ხოლო ყველა
ან იქნება ჭეშმარიტი, რადგან ერთ-ერთი ორი Booleans აფასებს ჭეშმარიტი.
OK, ასე რომ, ერთი წუთით, შეაჩეროს ეს ვიდეო და მონელება სიმართლე მაგიდა.
მე ვიქნები უფლება აქ გელოდებათ.
როცა დავბრუნდები, ვხედავ თუ შეგიძლიათ ცალი ერთად
ლოგიკური გამოხატვის თქვენი მდგომარეობა n მყოფი არასწორი შეყვანის.
>> ასე რომ, ახლა, რომ ჩვენ გვაქვს მოქმედებს მომხმარებლის შეყვანის, მოდით
წავიდეთ წინ და ვისაუბროთ, თუ როგორ შეიძლება შევაჩერო ნახევარი პირამიდის.
აქ, ამ მარტივი ტექსტური რედაქტორი, მე შედგენილი მარცხენა მიუერთდა პირამიდის.
მაგრამ ჩვენ ვიცით, რომ ჩვენ უნდა ჩვენი პირამიდის იყოს უფლება მიუერთდა.
ასე როგორ შეიძლება ამის გაკეთება?
ისე, მე შეიძლება ცდილობენ დააყენებს იმისათვის, რომ მხარე
მხოლოდ აყენებს პატარა ხასიათი შორის.
და შემდეგ, მომდევნო ხაზი, მე ვაპირებ დააყენა
კიდევ რამდენიმე პერსონაჟი დააყენებს ის გასწვრივ, და further-- და ასე forth--
სანამ მე მაქვს უფლება მიუერთდა პირამიდის.
ასე რომ, ჩვენ გვაქვს უფლება align პირამიდის, მაგრამ ეს არ გამოიყურება ისე დიდი წერტილები.
მაგრამ ჩვენ მაინც მინდა ამტკიცებენ, რომ ლამაზი ინტერვალი.
ამიტომ, მე ვაპირებ, რომ ფაქტიურად ჩადეთ ზოგიერთი ფართები.
>> იმის ნაცვლად, რომ სამი წერტილი, მე ბოლო ერთი, ორი, სამი ფართები.
მეორე ხაზი.
მე ამას ერთი, ორი ფართები.
და ბოლოსწინა ხაზი, უბრალოდ ერთ სივრცეში.
და აქ მე მაქვს უფლება მიუერთდა პირამიდის.
აკეთებს, მაგალითად, ტექსტი რედაქტორი, ჩვენ გვაქვს იდეა ნიმუში
რომ ჩვენ გამოვიყენებთ მიაპყროს ნახევარი პირამიდის.
ყოველ ზედიზედ, რაც ჩვენ გავაკეთეთ არის ჩვენ აკრიფოთ ზოგიერთი ფართები,
და მაშინ აკრეფილი ზოგიერთი ჰეშები და მაშინ აკრეფილი
Enter, რომელიც შექმნა ახალი ხაზი.
ასე რომ, ახლა, რომ ჩვენ გვაქვს, რომ, მოდით წავიდეთ ერთი ნაბიჯია და ნიმუში.
>> ასე რომ, მე ვაპირებ ვთქვა, რომ ინტერესი ამ მაგალითად,
ჩვენ საქმე გვაქვს სიმაღლე 8.
პირველი რიგის აპირებს აქვს ორი ჰეშები რომ შემდეგნაირად შვიდი სივრცეებს.
Second-- სამი ჰეშები, ექვსი ფართები.
მესამე row-- ოთხი ჰეშები, ხუთ spaces-- ასე შემდეგ და ასე შემდეგ
სანამ არ მივიღებთ nth ზედიზედ.
ასე რომ, მე გთხოვთ nth ზედიზედ რამდენი ჰეშები ჩვენ ვაპირებთ აქვს
და რამდენი ფართები?
ასე რომ, ეს თქვენ, რათა გაერკვნენ ფორმულა წარმოადგენს რამდენი ჰეშები
და რამდენი ფართები საჭირო nth ზედიზედ როდესაც თქვენ გაქვთ გარკვეული სიმაღლე.
>> ახლა, როდესაც თქვენ მჭიდროდაა ამ გარეთ, ფრთხილად, თუ თქვენ ინდექსირებას.
რა ნიშნავს ეს ის არის, რომ ყოველდღიურ ცხოვრებაში ყველა ჩვენგანისთვის
დაიწყება დათვლის, როგორც წესი 1.
მაგრამ CS50 და კომპიუტერულ მეცნიერებათა ზოგადად, ჩვენ 0 ინდექსირებული.
ასე რომ, პირველი რიგის იქნება n 0 განსხვავებით 1.
ფრთხილად, როდესაც თქვენ ცდილობენ გაერკვნენ თქვენი ნიმუში.
ასე რომ, ახლა მოდით დავუბრუნდეთ, თუ როგორ ჩვენ ვაპირებთ, რომ მიაპყროს ჩვენი პირამიდის.
ყოველ ზედიზედ, ჩვენ ვაპირებთ, რომ სურს ბეჭდვა ფართები, ბეჭდვა ჰეშები,
და შემდეგ ბეჭდვა ახალი ხაზი.
მინიშნება აქ არის სიტყვა "" ყოველ ზედიზედ.
In C, ჩვენ გვაქვს მშენებლობა მოუწოდა ამისთვის მარყუჟის,
რომელიც შედგება საქართველოს ინიციალიზაციისას, მდგომარეობა, განახლება,
და ორგანოს loop.
>> ამბობენ, რომ ამის თქმა მინდოდა, hello მსოფლიოში, 50 ჯერ, ჩემი ამისთვის loop
გამოიყურება რაღაც მოსწონს ეს.
ინიციალიზაცია ჩემი რიცხვი 0.
მდგომარეობა არის, რომ მე ნაკლებია, ვიდრე 50.
და მაშინ ჩემი განახლება მხოლოდ დამატება I ერთი ყოველ ჯერზე.
ჩვენ ასევე შეგიძლიათ მარყუჟების iterate მეტი რამ.
გაითვალისწინეთ აქ როგორ არ გვაქვს მყარი კოდირებული ნომერი,
არამედ განთავსებული ცვლადი სიმაღლე ნაცვლად შევიდა მდგომარეობაშია.
ასე რომ, რასაც მე ვაკეთებ, აქ მე iterating ყოველ ზედიზედ პირამიდის.
შემიძლია რაღაც თითოეული ზედიზედ შიგნით ორგანო ჩემი loop.
>> რას ვაკეთებთ შიგნით ორგანოს loop?
ისე, როგორც უკვე განაცხადა, ჩვენ დაბეჭდვის ფართები და ჩვენ დაბეჭდვის ჰეშები
და ჩვენ დაბეჭდვის ახალი ხაზი.
ასე რომ, ჩემი გარე მარყუჟის ასე გამოიყურება.
მე iterate მეტი ყოველ ზედიზედ პირამიდის გამოყენებით,
ამ შემთხვევაში, სიმაღლე, როგორც ცვლადი რომ ინახავს სიმაღლე პირამიდის.
შიგნით ორგანოს, რომ loop, მე აპირებს ბეჭდვა ფართები არაერთხელ, ბეჭდვა
ჰეშები არაერთგზის, და შემდეგ ბეჭდვა ახალი ხაზი.
>> ასე რომ, ახლა გამოყენებით ყველა ცნებები, მე ისაუბრა ამ მსვლელობა მეშვეობით,
თქვენ უნდა შეეძლოს შეეკითხება მომხმარებლის შეყვანის, შეამოწმოს, რომ input,
ხოლო შემდეგ მიაპყროს ნახევარი პირამიდის.
>> ჩემი სახელი არის Zamyla, და ეს არის CS50.