>> [მუსიკის დაკვრა]
DOUG LLOYD ყველა უფლება.
მუშაობა ერთი ცვლადები არის საკმაოდ სახალისო.
მაგრამ რა, თუ ჩვენ გვინდა მუშაობა ბევრი ცვლადები,
მაგრამ ჩვენ არ გვინდა, რომ აქვს bunch of სხვადასხვა სახელები საფრენი გარშემო ჩვენი კოდი?
ამ შემთხვევაში, კოლექტორები აპირებს მოდის ძალიან მოსახერხებელი.
მასივები მართლაც ფუნდამენტური მონაცემები სტრუქტურა რაიმე პროგრამირების ენის
რომ თქვენ გამოიყენოთ.
და ისინი მართლაც, ნამდვილად სასარგებლოა, კერძოდ, როგორც ჩვენ ვხედავთ, CS 50.
>> ჩვენ ვიყენებთ კოლექტორები გამართავს ღირებულებების იგივე მონაცემები ტიპის
განთავსებულია მიმდებარე მეხსიერების ადგილას.
სწორედ რომ ვთქვათ, ეს არის ისე, რომ ჩვენ შეუძლია ჯგუფი
რამოდენიმე რიცხვებით ერთად მეხსიერების ან bunch of გმირები
ან მოძრავი მეხსიერება ნამდვილად დახურვა ერთად და მუშაობა
მათ გარეშე, რათა თითოეული ერთი საკუთარი უნიკალური სახელი, რომელსაც შეუძლია
მიიღეთ cumbersome ცოტა ხნის შემდეგ.
>> ახლა, ერთი გზა ანალოგიური კოლექტორები ვიფიქროთ თქვენი ადგილობრივი პოსტი
საოფისე მეორე.
ასე ნაბიჯი დაშორებით პროგრამირების და უბრალოდ თვალები დახუჭე
და ვიზუალურად თქვენი გონება ადგილობრივ ფოსტაში.
როგორც წესი, ყველაზე პოსტი ოფისები, არსებობს დიდი ბანკი
ფოსტაში ყუთები კედელზე.
>> მასივი გიგანტური ბლოკი მომიჯნავე მეხსიერება,
ანალოგიურად, რომ ფოსტა საბანკო თქვენს ფოსტაში
დიდი სივრცე კედლის ფოსტაში.
მასივები უკვე დანაწევრებული პატარა, იდენტურად ზომის ბლოკებს სივრცეში,
რომელთაგან თითოეული ეწოდება ელემენტს, ანალოგიურად, რომ კედელზე პოსტი
ოფისი დანაწევრებული პატარა, იდენტურად ზომის ბლოკებს სივრცეში,
რომელიც ჩვენ მოვუწოდებთ PO ყუთის.
თითოეული ელემენტის მასივი შესანახად გარკვეული მონაცემები,
ისევე როგორც თითოეული ყუთის შეუძლია გამართავს გარკვეული mail.
>> რა შეიძლება იყოს შენახული თითოეული ელემენტის მასივი ცვლადები იგივე მონაცემები
ტიპის, როგორიცაა int ან char, უბრალოდ როგორც თქვენი საფოსტო ყუთის,
თქვენ შეგიძლიათ მხოლოდ ჯდება რამ მსგავსი ტიპის,
როგორიცაა წერილები და მცირე პაკეტები.
და ბოლოს, ჩვენ შეუძლია თითოეული ელემენტის მასივი პირდაპირ ინდექსი ნომერი,
ისევე, როგორც ჩვენ შეუძლია ჩვენს ფოსტაში ყუთი იცის მისი ფოსტის ნომერი.
იმედია, რომ ანალოგია გეხმარებათ მიიღოთ თქვენი უფროსი
იდეის გარშემო მასივები მიერ analogizing, რომ რაღაც
რომ თქვენ, ალბათ, უკვე იცნობს.
>> In C, ელემენტები მასივი არიან ინდექსირებული დაწყებული 0, არა 1.
და ეს ძალიან მნიშვნელოვანია.
და სინამდვილეში, სწორედ ამიტომ ჩვენ, CS 50, და ამიტომ კომპიუტერის მეცნიერები ხშირად
დაითვლის 0-დან, არის იმის გამო, რომ C მასივი
ინდექსირებას, რომელიც ყოველთვის იწყება 0.
ასე რომ, თუ მასივი შედგება N ელემენტები, პირველი ელემენტი, რომელიც მასივი
მდებარეობს ინდექსი 0, და ბოლო ელემენტს მასივი
მდებარეობს ინდექსი ო მინუს 1.
ისევ და ისევ, თუ არსებობს n ელემენტები ჩვენს მასივი, ბოლო მაჩვენებელი N მინუს 1.
>> ასე რომ, თუ ჩვენი მასივი 50 ელემენტები, პირველ ელემენტს მდებარეობს ინდექსი 0,
და ბოლო ელემენტს მდებარეობს ინდექსი 49.
სამწუხაროდ, ან საბედნიეროდ, დამოკიდებულია თქვენი პერსპექტივა,
C არის ძალიან რბილი აქ.
ეს არ შეგიშლით აპირებს ფარგლებს გარეთ თქვენი მასივი.
თქვენ შეიძლება თქვათ მინუსის 3 ელემენტს მასივი
ან 59 ელემენტს მასივი, თუ თქვენი მასივი მხოლოდ 50 ელემენტებს.
ეს არ შეწყვეტენ თქვენი პროგრამის შედგენა, მაგრამ პერსპექტივაში დრო,
თქვენ შეიძლება ექმნებათ საშინელი სეგმენტაცია ბრალია
თუ დაიწყება მეხსიერება რომ არის გარეთ ფარგლებში, რაც
თქვენ სთხოვა თქვენი პროგრამა მოგცემთ.
ასე რომ, ფრთხილად.
>> რას მასივი დეკლარაციის ჰგავს?
როგორ შეგვიძლია კოდი მასივი არსებობა როგორც ჩვენ კოდექსში ნებისმიერი სხვა ცვლადი?
არსებობს სამი ნაწილებით მასივი declaration-- ტიპის, სახელი,
და ზომა.
ეს არის ძალიან ჰგავს ცვლადის დეკლარაცია, რომელიც
მხოლოდ ტიპის და სახელი, ზომა ელემენტს მიმდინარეობს
სპეციალური შემთხვევაში მასივი, იმიტომ, რომ ჩვენ ვიღებთ რამოდენიმე მათგანი
ამავე დროს.
>> ასე რომ, ტიპის, თუ რა სახის ცვლადი თქვენ მინდა თითოეული ელემენტის მასივი იყოს.
არ მინდა, რომ ის მასივი რიცხვებით?
ამის შემდეგ, თქვენი მონაცემები ტიპის უნდა იყოს int.
გსურთ, რომ იყოს მასივი ორადგილიანი და მოძრავი?
მონაცემთა ტიპი უნდა იყოს ორმაგი ან float.
სახელი არის ის, რაც თქვენ მინდა მოვუწოდო თქვენი მასივი.
რა გინდათ ასახელებს ამ გიგანტური საბანკო რიცხვებით ან მოძრავი ან სიმბოლო
ან ორჯერ, ან რასაც თქვენ?
რა გინდათ ეძახით?
საკმაოდ თვითმმართველობის განმარტებითი.
>> და ბოლოს, ზომა, რომელიც მიდის შიგნით კვადრატულ ფრჩხილებში,
რამდენი ელემენტები თქვენ ამას როგორც თქვენი მასივი შეიცავს.
რამდენი რიცხვებით გინდათ?
რამდენი მოძრავი გინდათ?
>> ასე მაგალითად, int სტუდენტი შეფასება 40.
ეს აცხადებს მასივი მოუწოდა სტუდენტური შეფასება, რომელიც შედგება 40 რიცხვებით.
საკმაოდ თვითმმართველობის განმარტებითი, იმედი მაქვს.
აი კიდევ ერთი მაგალითი.
ორმაგი მენიუ ფასები 8.
ეს ქმნის მასივი მოუწოდა მენიუ ფასებს, რომელიც შედგება
ოთახი მეხსიერების რვა ორადგილიანი.
>> თუ ფიქრობთ, რომ ყველა ელემენტს მასივი ტიპის მონაცემთა ტიპის,
ასე მაგალითად, ერთ ელემენტს მასივი ტიპის int, იგივე გზა
ვფიქრობ, რომ ნებისმიერი სხვა ცვლადი ტიპის int,
ყველა ნაცნობი ოპერაციების, რომ ჩვენ განიხილეს ადრე ოპერაციების
ვიდეო აზრი.
ასე რომ, ჩვენ შეიძლება განაცხადოს მასივი booleans მოუწოდა Truthtable,
რომელიც შედგება ოთახი 10 Booleans.
>> და შემდეგ, ისევე, როგორც ჩვენ შეგვიძლია მხოლოდ მივანიჭოთ მნიშვნელობა ნებისმიერი სხვა ცვლადი ტიპის
ლოგიკური, შეიძლება ითქვას, რაღაც ისევე როგორც Truthtable კვადრატული ფრჩხილი
2, რომელიც არის როგორ ჩვენ მიუთითოს, რომელიც ელემენტს ჭეშმარიტების მაგიდაზე?
მესამე ელემენტია სიმართლე მაგიდასთან, რადგან მახსოვს,
ჩვენ იმედი 0-დან.
ასე რომ, ის, თუ როგორ მიუთითოს მესამე ელემენტს სიმართლე მაგიდა.
Truthtable 2 უდრის ყალბი, ისევე, როგორც ჩვენ შეიძლება declare--
ან ჩვენ შეგვიძლია მივანიჭოთ, არამედ ნებისმიერი ლოგიკური ტიპის ცვლადი, რომ ტყუილია.
>> ჩვენ ასევე შეგიძლიათ ეს პირობები.
თუ (truthtable 7 == ნამდვილი), რაც უნდა ვთქვა,
იმ შემთხვევაში, თუ მერვე ელემენტს საქართველოს Truthtable არის ნამდვილი,
იქნებ ჩვენ გვინდა ბეჭდვა გაგზავნა საქართველოს შესახებ, printf ("სიმართლე! n") ;.
რომელიც იწვევს გვაძლევს ვთქვათ, Truthtable 10 უდრის მართალია, არა?
ისე, მე არ შემიძლია, მაგრამ ეს საკმაოდ საშიშია, რადგან მახსოვს,
ჩვენ გვაქვს მასივი 10 Booleans.
ასე რომ, ყველაზე მაღალი მაჩვენებელი, რომ შემდგენელი მოგვცა 9.
>> ეს პროგრამა შედგენა, მაგრამ თუ რაღაც მეხსიერება
არსებობს, სადაც ჩვენ გვინდა ველით Truthtable 10 წასვლა,
ჩვენ შეიძლება განიცდიან სეგმენტაცია ბრალია. ჩვენ შეიძლება მიიღოს away, მაგრამ ზოგადად,
საკმაოდ საშიშია.
ასე რომ, რასაც მე ვაკეთებ აქ არის სამართლებრივი C, მაგრამ არ არის აუცილებელი საუკეთესო ნაბიჯი.
ახლა, როდესაც თქვენ გამოაცხადოს და ინიციალიზაცია მასივი ერთდროულად,
არ არის რეალურად საკმაოდ სპეციალური სინტაქსი, რომ თქვენ
შეგიძლიათ გამოიყენოთ შეავსოთ მასივი მისი ამოსავალი ღირებულებები.
მას შეუძლია მიიღოს რთული განაცხადოს მასივი ზომა 100,
და მერე უნდა ვთქვა, ელემენტს 0 უდრის; ელემენტის 1 უდრის;
ელემენტი 2 შეადგენს, რომ.
რა არის წერტილი, არა?
>> თუ ეს პატარა მასივი, თქვენ შეიძლება რაიმე ამის მსგავსი.
რედაქტირება truthtable 3 ტოლია ღია Curly გაუწიოს და შემდეგ მძიმე
გამოყოფა სიის ელემენტების რომ გსურთ დააყენა მასივი.
მაშინ დახურვა Curly გაუწიოს მძიმით.
ეს ქმნის მასივი ზომა სამი მოუწოდა Truthtable,
ელემენტებით ყალბი, მართალია, და ჭეშმარიტი.
და ფაქტობრივად, instantiation სინტაქსი მაქვს აქ
ზუსტად ისევე, როგორც აკეთებს ინდივიდუალური ელემენტს სინტაქსი ქვემოთ.
ეს ორი გზა კოდირების გვინდა აწარმოოს ზუსტი იგივე მასივი.
>> ანალოგიურად, ჩვენ შეგვიძლია iterate მთელ ელემენტები
მასივი გამოყენებით loop, რომელიც, ფაქტობრივად, ეს არის ძალიან მკაცრად რეკომენდირებულია
სახლში განხორციელება.
როგორ შექმნათ მასივი 100 რიცხვებით, სადაც
ყველა ელემენტს მასივი მისი ინდექსი?
ასე მაგალითად, ჩვენ გვაქვს მასივი 100 რიცხვებით და პირველ ელემენტს,
ჩვენ გვინდა, რომ 0.
მეორე ელემენტს, ჩვენ გვინდა, რომ 1.
მესამე ელემენტს, ჩვენ გვინდა იმისათვის, რომ 2; და ასე შემდეგ და ასე შემდეგ.
ეს არის ძალიან კარგი სახლში exercise გაგვაჩნია.
>> აქ, ეს არ გამოიყურება როგორც ძალიან ბევრი რამ შეიცვალა.
მაგრამ შეამჩნია, რომ შორის კვადრატულ ფრჩხილებში, ამ დროს,
მე რეალურად გამოტოვებული ნომერი.
თუ თქვენ იყენებთ ამ სპეციალური instantiation
სინტაქსი შექმნათ მასივი, თქვენ ნამდვილად არა
უნდა მიუთითოს ზომა მასივი წინასწარ.
შემდგენელი არის smart საკმარისი ვიცი, რომ თქვენ რეალურად
გვინდა მასივი ზომა 3, იმიტომ, რომ თქვენ დააყენა სამი ელემენტები
მარჯვნივ თანაბარი ნიშანი.
თუ თქვენ დააყენა ოთხი, ეს იქნებოდა მოცემული სიმართლე მაგიდა ზომა ოთხი
და ასე შემდეგ და ასე შემდეგ.
>> მასივები არ შემოიფარგლება ერთი განზომილება, რომელიც არის საკმაოდ გრილი.
თქვენ შეგიძლიათ რეალურად იმდენი მხარე specifiers, როგორც თქვენ გსურთ.
ასე მაგალითად, თუ გვინდა, რომ შევქმნათ საბჭოს თამაში Battleship, რომელიც,
თუ თქვენ ოდესმე ითამაშა, არის თამაში, რომელიც არის ითამაშა სამაგრები 10 10 ქსელის,
შეგიძლიათ შექმნათ მასივი მოსწონს ეს.
თქვენ შეიძლება ითქვას რედაქტირება საბრძოლო კვადრატული ფრჩხილი 10
დახურული მოედანი bracket მოედანზე bracket 10 დახურულია კვადრატული ფრჩხილი.
>> და შემდეგ, თქვენ შეგიძლიათ ინტერპრეტაცია თქვენი გონება, როგორც 10
10 ქსელის საკნები.
ახლა, ფაქტობრივად, მეხსიერება, ეს მართლაც მხოლოდ
რჩება 100 ელემენტი, ერთ განზომილებიანი მასივი.
ეს, ფაქტობრივად, მიდის თუ აქვს სამი განზომილება ან ოთხი ან ხუთი.
ეს ნამდვილად არ გავამრავლოთ ყველა indices--
ან ყველა ზომა specifiers-- ერთად,
და თქვენ უბრალოდ ერთი განზომილებიანი მასივი, რომ ზომა.
>> მაგრამ იმ თვალსაზრისით, ორგანიზაცია და ვიზუალიზაცია და აღქმა,
ეს შეიძლება იყოს ბევრი ადვილია მუშაობა ქსელის
თუ ვმუშაობთ თამაში როგორიცაა Tic-TAC-toe და Battleship,
ან რამე მაგდაგვარს.
ეს არის დიდი აბსტრაქცია, ნაცვლად, რომელმაც
ვიფიქროთ Tic-TAC-toe მონიშნე როგორც ხაზი ცხრა
მოედნებზე ან Battleship ფორუმში როგორც ხაზი 100 მოედნებზე.
10 10 ქსელის ან სამი სამი ქსელის ალბათ
ბევრი უფრო ადვილად აღიქვამს.
>> ახლა, მართლაც რაღაც მნიშვნელოვანი მასივები.
ჩვენ შეგვიძლია მკურნალობა თითოეული ინდივიდუალური ელემენტს მასივი, როგორც ცვლადი.
ჩვენ ვნახეთ, რომ ადრე როდესაც ჩვენ მინიჭების
ღირებულების True გარკვეული Booleans და ტესტირების მათ პირობით.
მაგრამ ჩვენ არ შეუძლია მთელი კოლექტორები საკუთარ თავს, როგორც ცვლადი.
ჩვენ არ შეგვიძლია, მაგალითად, დაავალოს ერთ მასივი სხვა მასივი გამოყენებით დავალება
ოპერატორი.
ეს არ არის სამართლებრივი C.
>> თუ გვინდა, რომ, მაგალითად, რა ჩვენ უნდა აკეთებდა, რომ მაგალითად
იქნება კოპირება ერთი მასივი მეორეზე.
თუ გვინდა, რომ გავაკეთოთ, რომ ჩვენ რეალურად უნდა გამოვიყენოთ loop კოპირება მეტი
თითოეულ ინდივიდუალური ელემენტს ერთ დროს.
მე ვიცი, რომ ცოტა დროს მოითხოვს.
>> ასე მაგალითად, თუ ჩვენ გვქონდა ამ ორი ხაზი კოდი, რომ ეს მუშაობა?
ისე, არა, ეს არ არის, უფლება?
იმის გამო, რომ ჩვენ ვცდილობთ მივანიჭოთ საკვები ბარი.
ეს არ იმუშავებს, იმიტომ, რომ ეს მასივი,
და ჩვენ უბრალოდ აღწერილი რომ ეს არ არის სამართლებრივი C.
>> სამაგიეროდ, თუ ჩვენ გვინდა, რომ კოპირება შინაარსი საკვები
შევიდა ბარი, რაც ჩვენ ვცდილობთ, რომ აქ,
ჩვენ უნდა სინტაქსი მოსწონს ეს.
ჩვენ გვაქვს ამისთვის loop რომ მიდის საწყისი J უდრის 0-დან 5
და ჩვენ ნამატი J ყოველ iteration მარყუჟის და მივანიჭოთ ელემენტები, როგორიცაა, რომ.
ეს გამოიწვევს იმას, ბარი ასევე ერთ-ერთი, ორი, სამი, ოთხი, ხუთი,
მაგრამ ჩვენ უნდა გავაკეთოთ ეს ძალიან ნელი ელემენტს მიერ ელემენტს გზა,
ნაცვლად მხოლოდ გადაწერა მთელი მასივი.
სხვა პროგრამირების ენებზე, უფრო თანამედროვე პირობა,
თქვენ შეგიძლიათ, ფაქტობრივად, ამის გაკეთება მხოლოდ რომ მარტივი ტოლია სინტაქსი.
მაგრამ C, სამწუხაროდ, ჩვენ არ არის ნებადართული უნდა გავაკეთოთ, რომ.
>> ახლა, იქ ერთი სხვა რამ მინდა აღვნიშნო,
მასივების, რომ შეიძლება ცოტა ცოტა სახიფათო პირველად
მათთან მუშაობა.
ჩვენ განვიხილეთ ვიდეო ცვლადი ფარგლებს,
რომ ყველაზე ცვლადები C, როცა რეკავთ მათ ფუნქციებს, მათ მიერ მიღებულ ღირებულება.
გახსოვთ, რას ნიშნავს გაივლის რაღაც მნიშვნელობა?
ეს იმას ნიშნავს, თქვენ მიღების ასლი ცვლადი, რომელიც მიმდინარეობს გადავიდა.
Callee ფუნქცია, ფუნქცია რომ მიმღები ცვლადი,
არ მიიღოთ ცვლადი თავად.
იგი იღებს თავისი ადგილობრივი ასლი მუშაობა.
>> მასივები, რა თქმა უნდა, ამის გაკეთება არ იცავენ ამ წესს.
პირიქით, რაც ჩვენ მოვუწოდებთ ამ არის ავლით მითითება.
Callee რეალურად ამჯამად მიიღოს მასივი.
ეს არ მიიღოს მისი ადგილობრივი ასლი.
და თუ ფიქრობთ, ის, რომ ეს აზრი.
თუ კოლექტორები ნამდვილად დიდი, იმდენად დიდი დრო და ძალისხმევა,
რათა ასლი მასივი 100 ან 1000 ან 10,000 ელემენტები,
ის, რომ არ ღირს ამისთვის ფუნქციონირებს მიიღოს ასლი,
დაკავდით მუშაობა, და მაშინ უბრალოდ გაკეთდეს ასლი;
ეს არ უნდა ეს ჩამოკიდებული გარშემო აღარ.
>> იმის გამო, რომ კოლექტორები ზოგიერთი bulky და რთული,
ჩვენ უბრალოდ გაივლის მათ მიერ მინიშნება.
ჩვენ უბრალოდ ენდობა, რომ ფუნქცია უნდა, არ დაარღვიოს არაფერი.
ასე რომ, ეს რეალურად მიიღოს მასივი.
იგი არ მიიღებს საკუთარი ადგილობრივი ასლი.
>> ასე რომ, რას ნიშნავს ეს, მაშინ, როდესაც Callee
მანიპულირებს ელემენტების მასივი?
რა ხდება?
ახლა, ჩვენ სიპრიალის მეტი რატომ სწორედ ამ
ხდება, რატომ კოლექტორები გავიდა მითითებით
და ყველაფერი მიერ მიღებულ ღირებულება.
მაგრამ მე გპირდებით, რომ ჩვენ დაბრუნდნენ და მოგაწვდით პასუხი
ამ მოგვიანებით ვიდეო.
>> აი კიდევ ერთი სავარჯიშო თქვენ სანამ ჩვენ გადაიტანოთ up რამ მასივები.
მტევნის კოდი აქ, რომ არ არის განსაკუთრებით კარგი სტილი,
უბრალოდ მე გავაკეთებ, რომ გაფრთხილება.
არ არის კომენტარი აქ, რაც საკმაოდ ცუდი ფორმა.
მაგრამ ეს მხოლოდ იმიტომ, რომ მე მინდოდა, რომ იყოს შეუძლია მოერგოს ყველაფერი ეკრანზე.
>> ზედა, თქვენ ხედავთ, რომ მე მაქვს ორი ფუნქციის დეკლარაციების კომპლექტი მასივი
და მითითებული int.
Set მასივი აშკარად იღებს მასივი ოთხი რიცხვებით როგორც მისი შეყვანის.
და მითითებული int აშკარად იღებს ერთი რიცხვი, როგორც მისი შეყვანა.
მაგრამ ორივე არ აქვს გამომავალი.
გამომავალი, დაბრუნების ტიპი, თითოეული ბათილია.
მთავარი, ჩვენ გვაქვს რამდენიმე ხაზი კოდი.
ჩვენ განაცხადოს რიცხვი ცვლადი მოუწოდა და მივანიჭოთ მას ღირებულება 10.
ჩვენ ვაცხადებთ მასივი ოთხი მთელი რიცხვი მოუწოდა B და მივანიჭოთ ელემენტები 0, 1,
2 და 3, შესაბამისად.
მაშინ, ჩვენ გვაქვს ზარი მითითებული int და ზარის შექმნას მასივი.
განმარტებები კომპლექტი მასივი და კომპლექტი int არის ქვემოთ, ბოლოში.
>> ასე რომ, კიდევ ერთხელ, მე გკითხოთ კითხვაზე.
რა ხდება დაბეჭდილი out აქ ბოლოს მთავარი?
აქ არის ამონაწერი col. მე დაბეჭდვის ორი რიცხვებით.
მე დაბეჭდვისას შინაარსი და შინაარსი B კვადრატული ფრჩხილი 0.
პაუზის ვიდეო აქ და მიიღოს წუთი.
შეგიძლიათ გაერკვნენ, რა არის ეს ფუნქცია ბეჭდვა ბოლოს?
იმედია, თუ გახსოვთ, განსხვავება ავლით მნიშვნელობა
და გავლის მიერ მინიშნება, ამ პრობლემა არ იყო ძალიან სახიფათო თქვენთვის.
და პასუხი თქვენ, იპოვეს ეს.
თუ თქვენ ნამდვილად არ ვიცი, როგორც რატომ, რომ იმ შემთხვევაში, მიიღოს მეორე,
დაბრუნდეს, განიხილავს რა მე უბრალოდ განხილვის შესახებ ავლით კოლექტორები
მინიშნება, წინააღმდეგ გავლის სხვა ცვლადები ღირებულება,
და იმედია, რომ თქვენ, რათა ცოტა მეტი აზრი.
>> მე Doug Lloyd, და ეს არის CS50.