1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] სექცია პრობლემა უცნობია 2: Hacker Edition

2
00:00:02,670 --> 00:00:04,910
რობ Bowden, ჰარვარდის უნივერსიტეტი

3
00:00:04,910 --> 00:00:07,410
ეს არის CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
ასე რომ, მე რობ. მე უფროსი in KIRKLAND. ეს ჩემი მესამე წელი TFing CS50.

5
00:00:15,770 --> 00:00:22,220
ეს პირველი შემთხვევაა, როდესაც ჩვენ იცვლება ტრადიციული-ლექცია სტილის განყოფილებაში

6
00:00:22,220 --> 00:00:25,610
სადაც ჩვენ უბრალოდ სახის მიმოხილვას თუ რა მოხდა ლექცია და მერე ბიჭებს კითხვის დასმის,

7
00:00:25,610 --> 00:00:32,250
ახლა მიმდინარეობს გაცილებით მეტი პრობლემა დაფუძნებული, სადაც ჩვენ გამოტოვოთ, და -

8
00:00:32,250 --> 00:00:37,410
ოჰ, ისე იდეა წასვლა ბმული მე გაგზავნილი თქვენ და შემდეგ თქვენ გექნებათ ჩემი ფართი.

9
00:00:37,410 --> 00:00:42,410
ვინმეს არ აქვს ლეპტოპი? Okay.

10
00:00:42,410 --> 00:00:47,050
ამიტომ, ჩვენ ვაპირებთ იყოს გამოყენებისას, და ჩვენ ვაპირებთ იყოს აკეთებს პრობლემების ცხოვრობენ ნაწილში

11
00:00:47,050 --> 00:00:50,740
განხილვა მათ და მჭიდროდაა რა არის არასწორი

12
00:00:50,740 --> 00:00:56,390
და ალბათ დახევის up ზოგიერთი თქვენი კოდი და ალბათ განიხილოს თქვენი იდეები.

13
00:00:56,390 --> 00:01:02,140
ასე რომ უკვე ვინმე უჭირდათ?

14
00:01:02,140 --> 00:01:07,000
შეგიძლიათ სტატისტიკა მხარეს, მე არ ვიცი, თუ ჩვენ გვექნება მიზეზი.

15
00:01:07,000 --> 00:01:12,270
ახლა, ისევე როგორც წინა supersection, თუ იყო, რომ კლასი, იცით რა, რომ დაახლოებით.

16
00:01:12,270 --> 00:01:19,200
ყველა P კომპლექტი იქ იქნება ამ მონაკვეთების.

17
00:01:19,200 --> 00:01:22,550
ასე რომ P-set 2, სპეციფიკაციები, ვფიქრობ თქვენ ნახეთ ეს P-set 1 უკვე.

18
00:01:22,550 --> 00:01:27,400
მაგრამ ჩვენ შეგვიძლია შევხედოთ P-set 2 რისთვისაც ჩვენ ვაპირებთ იყოს ვაპირებთ დღეს სრულდება.

19
00:01:27,400 --> 00:01:29,460
და დაინახავთ მონაკვეთზე კითხვები.

20
00:01:29,460 --> 00:01:37,530
ასე რომ, ეს იქნება ყველა P-კომპლექტი; იქ ვიქნები მონაკვეთზე კითხვები.

21
00:01:37,530 --> 00:01:41,340
აქამდე ჩვენ განაცხადა, "ჩათვალეთ ეს საშუალებას."

22
00:01:41,340 --> 00:01:44,940
თქვენ არ იქნება სთხოვა წარუდგინოს ამ პროგრამის.

23
00:01:44,940 --> 00:01:48,480
იდეა არის, რომ ეს უნდა სახის დაგეხმარებათ დაიწყო პრობლემა კომპლექტი.

24
00:01:48,480 --> 00:01:53,220
ვფიქრობ on Hacker გამოცემა, ბევრი მათგანი უნდა იყოს მხოლოდ ახალი, საინტერესო რამ უნდა ვისწავლოთ.

25
00:01:53,220 --> 00:01:58,590
ისინი არ შეიძლება იყოს პირდაპირ გამოიყენება პრობლემა კომპლექტი.

26
00:01:58,590 --> 00:02:01,810
და სწორედ ახლა ჩვენ არ მქონე თქვენ წარუდგინოს ისინი, მაგრამ თეორიულად,

27
00:02:01,810 --> 00:02:07,480
მოგვიანებით პრობლემა კომპლექტი, თქვენ შეიძლება წარუდგინოს ისინი, და ამით თქვენ შეგიძლიათ მოსვლა სექციაში

28
00:02:07,480 --> 00:02:10,380
ან საყურადღებო მონაკვეთზე მიიღოს პასუხი, ან შეგიძლიათ უბრალოდ მათ საკუთარ

29
00:02:10,380 --> 00:02:16,350
თუ არ იგრძნონ მოსარგებლე ჩემი თანდასწრებით.

30
00:02:16,350 --> 00:02:21,010
ამიტომ - ვფიქრობ, ეს არის პირველი.

31
00:02:21,010 --> 00:02:29,280
Oh. ასევე, ამ მონაკვეთზე კითხვები ჩვენ ასევე თქვენ კითხვის დასმის შესახებ შორტები.

32
00:02:29,280 --> 00:02:33,440
ამიტომ ვფიქრობ, თეორიულად, თქვენ უნდა უყუროთ ამ მისვლამდე მონაკვეთზე,

33
00:02:33,440 --> 00:02:38,550
მაგრამ ჯარიმა თუ არ; ჩვენ წავიდეთ მათზე მაინც.

34
00:02:38,550 --> 00:02:42,590
ასე რომ ჩვენ შეგვიძლია დავიწყოთ ამ: "როგორ ამჯამად ხოლო loop განსხვავდება do-ხოლო loop?

35
00:02:42,590 --> 00:02:46,210
როდესაც არის ეს უკანასკნელი განსაკუთრებით სასარგებლოა? "

36
00:02:46,210 --> 00:02:49,390
ასე რომ ვინმეს აქვს რაიმე -?

37
00:02:49,390 --> 00:02:52,730
[სტუდენტური] do-ხოლო loop ყოველთვის შეასრულოს ერთხელ მაინც.

38
00:02:52,730 --> 00:03:02,950
დიახ. ასე რომ არის განსხვავება. ხოლო loop - I'll მხოლოდ ამის შესახებ აქ - ხოლო მარყუჟის, ჩვენ გვაქვს მდგომარეობა

39
00:03:02,950 --> 00:03:19,760
სწორედ აქ, ხოლო do-ხოლო, თქვენ არ მდგომარეობა სანამ არ მივიღებთ ქვემოთ აქ.

40
00:03:19,760 --> 00:03:24,130
ასე რომ, როდესაც თქვენი პროგრამის შესრულებაში, და იგი იღებს, რათა ხოლო მარყუჟის,

41
00:03:24,130 --> 00:03:26,380
იგი მაშინვე ამოწმებს თუ ეს მდგომარეობა არის ჭეშმარიტი.

42
00:03:26,380 --> 00:03:30,710
თუ ეს მდგომარეობა არ არის სიმართლე, ეს იქნება უბრალოდ გამოტოვოთ მეტი loop მთლიანად.

43
00:03:30,710 --> 00:03:34,390
Do-loop ხოლო, როგორც პროგრამის შესრულებაში, იგი იღებს, რათა "გავაკეთოთ."

44
00:03:34,390 --> 00:03:37,920
არაფერი ხდება ამ ეტაპზე, უბრალოდ აგრძელებს შესრულებაში.

45
00:03:37,920 --> 00:03:42,690
მაშინ, როდესაც ის იგებს "ხოლო," თუ მდგომარეობა არის ნამდვილი, ის ყველაფერს loop უკან და ამის გაკეთება კიდევ ერთხელ

46
00:03:42,690 --> 00:03:46,730
და ისევ და ისევ სანამ მდგომარეობა არ არის სიმართლე და შემდეგ უბრალოდ მოდის მეშვეობით.

47
00:03:46,730 --> 00:03:50,600
ასე რომ, განსხვავებით,,, რომ ეს შეიძლება გამოტოვოთ უფლება თავიდანვე.

48
00:03:50,600 --> 00:03:56,770
ეს აუცილებლად ახორციელებს ერთხელ და მერე შეიძლება შესრულდეს უფრო თუ მდგომარეობა კვლავ ჭეშმარიტი.

49
00:03:56,770 --> 00:04:03,720
ასე რომ სანამ loop იქნება მხოლოდ ამის გაკეთება კიდევ ერთხელ, ან - ხოლო loop - ჩვენ შეიძლება არ გვჭირდება საერთოდ,

50
00:04:03,720 --> 00:04:07,900
რადგან როგორც კი მივიღებთ, თუ ეს პირობა არის ყალბი, ჩვენ უბრალოდ გამოტოვოთ უფლება მას.

51
00:04:07,900 --> 00:04:11,770
ვინაიდან do-ხოლო მარყუჟის, ჩვენ შეასრულოს ის ერთხელ, აუცილებლად.

52
00:04:11,770 --> 00:04:14,560
მაშინ, როცა ჩვენ ვიღებთ, რათა მდგომარეობა, ჩვენ შეამოწმოთ, თუ ეს სიმართლეა ან ცრუ.

53
00:04:14,560 --> 00:04:19,790
თუ ეს სიმართლეა, ჩვენ გავაკეთებთ ერთხელ, თუ ეს ცრუ, ჩვენ უბრალოდ გავაგრძელებთ აპირებს.

54
00:04:19,790 --> 00:04:24,680
ასე რომ, როდესაც არის ეს უკანასკნელი განსაკუთრებით სასარგებლოა?

55
00:04:24,680 --> 00:04:31,190
ასე, რომ შეიძლება ითქვას, რომ მთლიანად საქართველოს 4 წლის, 3 წლის განმავლობაში, რაც,

56
00:04:31,190 --> 00:04:38,780
რომ მე უკვე პროგრამირების, მე არ გამოიყენება ამ, ისევე, ქვეშ 10 ჯერ.

57
00:04:38,780 --> 00:04:43,140
და ალბათ 5 მათგანი CS50 როდესაც ჩვენ შემოღების do-ხოლო მარყუჟების.

58
00:04:43,140 --> 00:04:47,510
ასე რომ, როდესაც თქვენ როგორ გამოიყენა do-ხოლო მარყუჟების?

59
00:04:47,510 --> 00:04:49,510
როდესაც არის - Yeah?

60
00:04:49,510 --> 00:04:53,180
[სტუდენტური] როცა თქვენ ცდილობს მომხმარებლის input, ან რაღაც გსურთ შეამოწმოთ -

61
00:04:53,180 --> 00:04:59,700
Yeah. ასე რომ, ხოლო მარყუჟების, მომხმარებლის შეყვანის არის დიდი ერთი.

62
00:04:59,700 --> 00:05:03,160
ამიტომ პირველ რამდენიმე პრობლემა კომპლექტი, როდესაც თქვენ მინდა ვკითხო მომხმარებლის, ისევე,

63
00:05:03,160 --> 00:05:08,520
"მომეცი სიმებიანი," ვერ გაგრძელდება სანამ არ მიიღებთ, რომ სიმებიანი.

64
00:05:08,520 --> 00:05:12,980
და ასე რომ თქვენ, აუცილებლად, უნდა მოითხოვოთ სიმებიანი ერთხელ მაინც.

65
00:05:12,980 --> 00:05:16,950
მაგრამ შემდეგ, თუ ისინი უპასუხოს რაღაც ცუდი, მაშინ უნდა loop თავში და ვთხოვ კიდევ ერთხელ.

66
00:05:16,950 --> 00:05:20,810
მაგრამ, გარდა მომხმარებლის input, ძალიან იშვიათი რომ მე ექმნებათ შემთხვევაში

67
00:05:20,810 --> 00:05:27,170
აქ მინდა მარყუჟის "ერთხელ მაინც" მაგრამ შესაძლოა უფრო.

68
00:05:27,170 --> 00:05:33,370
კითხვები ან -? აქვს ვინმეს გამოყენებული do-loop ხოლო სხვაგან?

69
00:05:33,370 --> 00:05:36,780
Okay. ასე რომ შემდეგი ერთი, "რას გამოუცხადებელ იდენტიფიკატორი

70
00:05:36,780 --> 00:05:43,310
ჩვეულებრივ მიუთითებს თუ outputted მიერ clang? "

71
00:05:43,310 --> 00:05:47,380
ასე რომ, თუ რა სახის კოდი შეიძლება ვწერ მისაღებად 'გამოუცხადებელ იდენტიფიკატორი?'

72
00:05:47,380 --> 00:05:49,550
[სტუდენტური], რომ x = 2?

73
00:05:49,550 --> 00:05:52,650
ასე რომ ჩვენ შეგვიძლია სცადეთ იგი აქ, X = 2.

74
00:05:52,650 --> 00:06:04,830
ჩვენ აწარმოებს ამ - Oh, მე არ დაწკაპეთ იგი. ასე რომ აქ კიდევ - ყველა უფლება.

75
00:06:04,830 --> 00:06:07,100
"გამოიყენე გამოუცხადებელი იდენტიფიკატორი x".

76
00:06:07,100 --> 00:06:11,610
ასე რომ გამოუცხადებელ იდენტიფიკატორი, ცვლადი.

77
00:06:11,610 --> 00:06:13,910
ეს იქნება ხშირად მოვუწოდებთ ცვლადი იდენტიფიკატორი.

78
00:06:13,910 --> 00:06:17,300
ასე რომ, შესაძლოა, არ იციან, რეალურად ცვლადი, არ ვიცი რა არის.

79
00:06:17,300 --> 00:06:19,380
ასე რომ იდენტიფიკატორი.

80
00:06:19,380 --> 00:06:26,060
ასე რატომ არის გამოუცხადებელი? Yeah.

81
00:06:26,060 --> 00:06:32,190
ასე უნდა იყოს მკაფიო on ტერმინოლოგიას, დეკლარაცია ცვლადი

82
00:06:32,190 --> 00:06:37,360
როდესაც ამბობთ "int x," ან "string Y", რასაც.

83
00:06:37,360 --> 00:06:41,910
ინიციალიზაციისას of ცვლადი, ან დავალებით ცვლადი,

84
00:06:41,910 --> 00:06:44,510
არის როცა ამბობენ, რომ "X = 2."

85
00:06:44,510 --> 00:06:52,950
ასე რომ ჩვენ შეგვიძლია გავაკეთოთ ეს ცალკე ნაბიჯები, int x, x = 2 და სანამ - ჩვენ შეგვიძლია აქვს bunch პერსონალის აქ -

86
00:06:52,950 --> 00:07:00,350
მაგრამ სანამ ამ ხაზის მოხდება, x კვლავ uninitialized, მაგრამ ეს გამოცხადდა.

87
00:07:00,350 --> 00:07:06,760
და ასე შეგვიძლია აშკარად ამას 1 ხაზი, და ახლა ჩვენ ვაცხადებთ და ინიციალიზაციისას.

88
00:07:06,760 --> 00:07:10,730
კითხვები?

89
00:07:10,730 --> 00:07:18,390
და ბოლოს, "რატომ არის კეისრის კოდი არ არის ძალიან უსაფრთხო?"

90
00:07:18,390 --> 00:07:23,830
ასე რომ, პირველი, ჯერ არავის მინდა ვთქვა, რა კეისრის კოდი არის?

91
00:07:23,830 --> 00:07:28,100
[სტუდენტური] კეისრის კოდი მხოლოდ ის არის, რომ თქვენ რუკა, თქვენ გადაეტანა ყველა წერილი,

92
00:07:28,100 --> 00:07:34,420
გარკვეული რაოდენობის ასოები წასვლა დასრულდა და გადაადგილდება მეტი, და ეს არ არის ძალიან უსაფრთხო, რადგან

93
00:07:34,420 --> 00:07:42,260
იქ მხოლოდ 26 შესაძლო ვარიანტები და უბრალოდ უნდა ვეცადოთ ყოველ 1 იმ სანამ ამას არ გაიგებთ.

94
00:07:42,260 --> 00:07:45,470
Oh. ასე რომ, მე უნდა გავიმეორო?

95
00:07:45,470 --> 00:07:51,600
კეისრის კოდი, it's - ვგულისხმობ, თქვენ უნდა საქმე ის პრობლემები, რომელიც თქვენ -

96
00:07:51,600 --> 00:07:56,110
ან ვფიქრობ სტანდარტული გამოცემა პრობლემა კომპლექტი რომ არა ჰაკერი გამოცემა.

97
00:07:56,110 --> 00:08:01,550
ასე სტანდარტული გამოცემა პრობლემა კომპლექტი, თქვენ გაგზავნა მოსწონს, "Hello, World,"

98
00:08:01,550 --> 00:08:08,410
და თქვენ ასევე აქვს ხმების მოსწონს 6, და შენ რომ გაგზავნა, და თითოეული ინდივიდუალური ხასიათი,

99
00:08:08,410 --> 00:08:11,310
თქვენ როტაცია იგი 6 თანამდებობებზე ანბანი.

100
00:08:11,310 --> 00:08:16,560
ასე რომ "თ" წელს მიესალმები გახდება H-I-j-K-L-მ n.

101
00:08:16,560 --> 00:08:19,600
ასე რომ პირველი ასო იქნება n. ჩვენ ამას ვაკეთებთ იგივე ერთად ე.

102
00:08:19,600 --> 00:08:23,530
თუ ჩვენ გვაქვს, ისევე, z ან რამე, მაშინ ჩვენ საერთო უკან გარშემო to '.'

103
00:08:23,530 --> 00:08:29,280
მაგრამ ყოველ ხასიათი იღებს cycled 6 სიმბოლო მოგვიანებით ანბანი, და ეს არ არის ძალიან უსაფრთხო

104
00:08:29,280 --> 00:08:35,440
რადგან არსებობს მხოლოდ 26 შესაძლებლობები რამდენი გზები შეგიძლიათ გადაიტანოთ ერთი წერილი.

105
00:08:35,440 --> 00:08:42,919
ასე რომ თქვენ შეგიძლიათ სცადეთ ყველა 26 მათგანი და, სავარაუდოდ, ამისთვის ხანგრძლივი საკმარისი გაგზავნა,

106
00:08:42,919 --> 00:08:46,860
მხოლოდ 1 იმ შესაძლო 26 რამ იქნება legible,

107
00:08:46,860 --> 00:08:50,300
და legible ერთი იქნება ორიგინალური გაგზავნა.

108
00:08:50,300 --> 00:08:56,240
ასე რომ არ არის ძალიან კარგი გზა encrypting არაფერი ყოფილა.

109
00:08:56,240 --> 00:08:59,070
უკავშირდება იმ შორტები, "რა არის ფუნქცია?"

110
00:08:59,070 --> 00:09:03,370
რა არის ფუნქცია? დიახ.

111
00:09:03,370 --> 00:09:11,640
[სტუდენტური] ეს მოსწონს ცალკე ნაჭერი კოდი, რომელიც შეგიძლიათ დარეკოთ გავლა და შემდეგ მიიღოს დაბრუნების ღირებულება რასაც.

112
00:09:11,640 --> 00:09:18,160
Yeah. ასე რომ მე ვუპასუხო მას ასევე პასუხობდა შემდეგი - ან განმეორებითი მიერ ასევე უბრალოდ პასუხობდა შემდეგი ერთი.

113
00:09:18,160 --> 00:09:22,410
თქვენ შეგიძლიათ გამოიყენოთ ფუნქციები ნაცვლად მხოლოდ გადაწერა და pasting კოდი უსასრულოდ.

114
00:09:22,410 --> 00:09:27,200
უბრალოდ, რომ კოდი, დაუსვან მას ფუნქციის გამოსართავად, და მაშინ შეიძლება მხოლოდ მოვუწოდებთ ფუნქცია

115
00:09:27,200 --> 00:09:29,870
სადაც არ უნდა იყოთ უკვე გადაწერა და pasting.

116
00:09:29,870 --> 00:09:33,350
ამიტომ ფუნქციებია სასარგებლო.

117
00:09:33,350 --> 00:09:35,860
ახლა ჩვენ გავაკეთებთ აქტუალურ პრობლემებზე.

118
00:09:35,860 --> 00:09:46,490
პირველი. ასე რომ იდეა პირველი ის არის, თქვენ უნდა გაიაროს ეს ტექსტი, და მიუხედავად -

119
00:09:46,490 --> 00:09:52,060
ან გვეუბნება ყველა ამას? ეს არ ვთქვა, ყველა ამას.

120
00:09:52,060 --> 00:09:57,730
ამიტომ გაგზავნა შეიძლება იყოს არაფერი, და - Oh no. ის ჯერ.

121
00:09:57,730 --> 00:10:01,610
"რამეთუ სიმარტივის, თქვენ შეიძლება ვივარაუდოთ, რომ მომხმარებელი მიიღებს მხოლოდ შეყვანის ამას წერილსა და სივრცეებს."

122
00:10:01,610 --> 00:10:08,180
ამიტომ, ჩვენ უნდა გაიაროს ეს გაგზავნა მხოლოდ ამას წერილებს და შემდეგ ჩვენ ალტერნატიულ

123
00:10:08,180 --> 00:10:15,450
შორის კაპიტალი და ამას - შევცვლით სიმებიანი უნდა იყოს დედაქალაქში და ამას, მონაცვლეობით.

124
00:10:15,450 --> 00:10:22,920
ასე რომ სანამ ჩვენ მოგცემთ მეორე კი ჩაყვინთვის შევიდა პრობლემა,

125
00:10:22,920 --> 00:10:32,420
რა არის პირველი რაც უნდა გავაკეთოთ?

126
00:10:32,420 --> 00:10:36,900
ოჰ, რა მე უბრალოდ დააწკაპუნეთ? ოჰ, მე უბრალოდ დაწკაპავთ ელ აქ.

127
00:10:36,900 --> 00:10:42,870
ასე რომ პირველი რაც უნდა გავაკეთოთ - მე ეძებს არასწორი ერთი?

128
00:10:42,870 --> 00:10:49,320
ეს ნაწილი ამ ერთი?

129
00:10:49,320 --> 00:10:51,320
არა, იმ დღემდე, არადა.

130
00:10:51,320 --> 00:10:55,160
Okay, ჯერ კიდევ აქ.

131
00:10:55,160 --> 00:11:03,160
ახლა ჩვენ არ შეგვიძლია ვივარაუდოთ, -? დიახ. აქ ჩვენ არ შეგვიძლია ვივარაუდოთ, რომ ეს მხოლოდ ამას და სივრცეებს.

132
00:11:03,160 --> 00:11:07,770
ახლა გვაქვს საქმე იმით, რომ ასოები შეიძლება იყოს რასაც ჩვენ გვინდა, რომ იყოს.

133
00:11:07,770 --> 00:11:11,910
და ა.შ. პირველი რაც ჩვენ გვსურს რომ არის უბრალოდ გაგზავნა.

134
00:11:11,910 --> 00:11:19,790
ჩვენ უბრალოდ უნდა მიიღოს სიმებიანი, სიმებიანი s = GetString, okay.

135
00:11:19,790 --> 00:11:24,890
ახლა ეს პრობლემა, არის რამდენიმე გზა არსებობს ამის გაკეთება.

136
00:11:24,890 --> 00:11:29,840
მაგრამ ჩვენ ვაპირებთ გინდათ გამოიყენოთ bitwise ოპერატორები აქ.

137
00:11:29,840 --> 00:11:35,280
არსებობს ხალხი, რომელიც არც არ იმყოფებოდნენ supersection,

138
00:11:35,280 --> 00:11:37,480
ან რაღაც, და არ ვიცი რა bitwise ოპერატორები არიან?

139
00:11:37,480 --> 00:11:41,710
ან როგორ ისინი ეხება ASCII არანაირად?

140
00:11:41,710 --> 00:11:45,650
[სტუდენტური] მე არ იყო supersection, მაგრამ მე ვიცი რა bitwise ოპერატორები არიან.

141
00:11:45,650 --> 00:11:49,560
Okay. ასეა, მაშინ მე არ მაქვს წასვლა მეტი საფუძვლებს, მაგრამ მე ახსნას

142
00:11:49,560 --> 00:11:51,830
რაც ჩვენ ვაპირებთ გინდათ გამოიყენოთ აქ.

143
00:11:51,830 --> 00:11:59,680
ასე რომ '': ორობითი წარმომადგენლობა დედაქალაქში, ნომერი 65.

144
00:11:59,680 --> 00:12:07,560
მე უბრალოდ აპირებს შევხედოთ - 41 იქნება 01000001.

145
00:12:07,560 --> 00:12:14,170
ასე რომ უნდა იყოს 65 წელს ათობითი, ამიტომ ეს არის ორობითი წარმომადგენლობა ხასიათი კაპიტალური ა

146
00:12:14,170 --> 00:12:19,440
ახლა, ორობითი წარმომადგენლობა ხასიათი მხედრულ ''

147
00:12:19,440 --> 00:12:33,350
იქნება იგივე, თითქმის. არის, რომ - 6, yeah. ეს არის სწორი.

148
00:12:33,350 --> 00:12:37,670
ასე რომ ორობითი დედაქალაქში, ორობითი ამას ". '

149
00:12:37,670 --> 00:12:43,940
ასე რომ განსხვავება და '' ეს ერთჯერადი bit.

150
00:12:43,940 --> 00:12:49,440
ეს მაშინ იქნება 32 ბიტიანი, ცოტა წარმოადგენს ნომერი 32.

151
00:12:49,440 --> 00:12:53,910
და რომ აზრი წლიდან არის 65; '' არის 97.

152
00:12:53,910 --> 00:12:56,610
განსხვავება მათ შორის არის 32.

153
00:12:56,610 --> 00:13:03,770
ახლა ჩვენ ვიცით, ჩვენ შეგვიძლია კონვერტირება საწყისი to '"მიერ აღების

154
00:13:03,770 --> 00:13:09,710
და bitwise ORing იგი, - რომ ჰგავს 1.

155
00:13:09,710 --> 00:13:20,900
ეს არის bitwise ან, ერთად 00100000, და რომ მივცემ us '.'

156
00:13:20,900 --> 00:13:26,850
ჩვენ შეუძლიათ მიიღონ '' to მიერ bitwise ANDing

157
00:13:26,850 --> 00:13:33,700
11, 0 რომ ადგილი, 11111.

158
00:13:33,700 --> 00:13:43,840
ასე რომ, ეს იქნება მაშინ მოგვცეს ზუსტად რა '' იყო, მაგრამ გააუქმოს ეს ინდივიდუალური bit,

159
00:13:43,840 --> 00:13:50,070
ამიტომ ჩვენ გვექნება 01000001, მე არ ვიცი, თუ მე დათვლილი უფლება.

160
00:13:50,070 --> 00:13:56,750
მაგრამ ამ ტექნიკას bitwise ORing მიიღოს საწყისი კაპიტალის მხედრულ,

161
00:13:56,750 --> 00:14:02,080
და bitwise ANDing მისაღებად საწყისი ამას კაპიტალის არ არის ექსკლუზიური ა

162
00:14:02,080 --> 00:14:06,510
ყველა წერილებს, K vs K, Z vs z,

163
00:14:06,510 --> 00:14:10,080
ყველა მათგანი მხოლოდ აპირებს განსხვავდება ამ ერთჯერადი bit.

164
00:14:10,080 --> 00:14:16,290
და ასე რომ თქვენ შეგიძლიათ გამოიყენოთ ეს შეცვალოს ნებისმიერი ამას წერილში ნებისმიერ დედაქალაქში წერილში და პირიქით.

165
00:14:16,290 --> 00:14:26,670
Okay. ასე მარტივად მიღების ამ - ასე ნაცვლად, რომელმაც უნდა

166
00:14:26,670 --> 00:14:32,170
წერენ გარეთ რასაც 1011111 არის - მარტივი გზა წარმოადგენს ეს რიცხვი, და ეს არ არის ერთი

167
00:14:32,170 --> 00:14:39,710
რომ მივედი დასრულდა supersection, მაგრამ tilde (~) არის კიდევ ერთი bitwise ოპერატორს.

168
00:14:39,710 --> 00:14:42,520
რა ~ არ არის ის უყურებს ცოტა წარმომადგენლობა.

169
00:14:42,520 --> 00:14:45,630
ავიღოთ ნებისმიერი რაოდენობის.

170
00:14:45,630 --> 00:14:53,130
ეს არის რამოდენიმე ორობითი ნომერი, და რა ~ ამჯამად არის უბრალოდ შეიჭრება ყველა ბიტი.

171
00:14:53,130 --> 00:15:00,630
ასე რომ, ეს იყო 1, არის 0, ეს 0, ახლა 1, 010100.

172
00:15:00,630 --> 00:15:08,320
ასე რომ ყველა ~ აკეთებს. ასე 32 იქნება ნომერი - მოვაშოროთ, რომ -

173
00:15:08,320 --> 00:15:23,320
ასე 32 იქნება ნომერი 00100000, და ასე ~ ამ იქნება

174
00:15:23,320 --> 00:15:29,980
ეს რიცხვი აქ, რომ მე ANDed '' ერთად.

175
00:15:29,980 --> 00:15:35,600
ამჯამად ყველას ვხედავ, რომ? ეს არის საკმაოდ გავრცელებული, ასე, როდესაც გსურთ გაერკვნენ

176
00:15:35,600 --> 00:15:40,740
მოგვიანებით რამ, რომ ჩვენ შეიძლება ვხედავთ, როდესაც ჩვენ გვინდა, რომ თუ -

177
00:15:40,740 --> 00:15:44,710
ან ჩვენ გვინდა ყველაფერი, თითოეული bit კომპლექტი გარდა 1

178
00:15:44,710 --> 00:15:47,910
თქვენ ტენდენცია არ ~ საქართველოს bit, რომ ჩვენ არ გვინდა მითითებული.

179
00:15:47,910 --> 00:15:53,090
ასე რომ არ გვინდა 32 bit კომპლექტი, ასე რომ ჩვენ ~ 32.

180
00:15:53,090 --> 00:15:57,790
Okay. ასე რომ ჩვენ შეგვიძლია გამოვიყენოთ ყველა იმ აქ.

181
00:15:57,790 --> 00:16:03,000
ყველა უფლება, ამიტომ ჯარიმის თუ თქვენ არ კეთდება, უნდა ნელა სიარული მეტი ერთად,

182
00:16:03,000 --> 00:16:11,870
ფეხით ან მეტი ამ, ასე - მისი მეშვეობით. გავლა ამ.

183
00:16:11,870 --> 00:16:20,790
ამიტომ, ჩვენ გვაქვს ჩვენი სიმებიანი, და გვინდა, რომ მარყუჟი აღემატება თითოეული პერსონაჟი, რომ სიმებიანი და რაღაც მას.

184
00:16:20,790 --> 00:16:26,710
ასე როგორ უნდა loop მეტი სიმებიანი? რა უნდა გამოიყენოს?

185
00:16:26,710 --> 00:16:30,980
მე არ ვაპირებ ამის შესახებ აქ. Yeah.

186
00:16:30,980 --> 00:16:42,940
ასე რომ მე მაქვს ჩემი iterator და თქვა, მაგრამ რა ვიცი, რამდენი გმირები არიან სიმებიანი?

187
00:16:42,940 --> 00:16:47,030
Strlen (s), მერე + +.

188
00:16:47,030 --> 00:16:49,860
მერე რა მე ვაკეთებ აქ არ არის საუკეთესო გზა კეთების რამ.

189
00:16:49,860 --> 00:16:51,860
ვინმეს თუ რატომ?

190
00:16:51,860 --> 00:16:55,290
იმიტომ, რომ თქვენ შემოწმების ენა სიმებიანი თითოეული დრო.

191
00:16:55,290 --> 00:17:06,859
ამიტომ, ჩვენ ვაპირებთ, რომ გვინდა ვიაროთ strlen, მე შეიძლება ითქვას, აქ, int სიგრძე = strlen (s),

192
00:17:06,859 --> 00:17:11,900
და მერე მე <სიგრძე, და იმ შემთხვევაში თუ თქვენ არ მინახავს ეს ადრე,

193
00:17:11,900 --> 00:17:20,410
მე შეიძლება გავაკეთოთ int i = 0, სიგრძე = strlen (s).

194
00:17:20,410 --> 00:17:25,010
და ა.შ. ეს გარკვეულწილად სასურველია, რადგან ახლა მე შეზღუდული არეალი

195
00:17:25,010 --> 00:17:29,150
საქართველოს ცვლადი სიგრძის მხოლოდ ამ 'for' loop, ნაცვლად გამოცხადების ეს ადრე

196
00:17:29,150 --> 00:17:34,990
და რომ ყოველთვის არსებობს და იმ შემთხვევაში თუ თქვენ არ დაიჭიროთ რატომ რომ ცუდი,

197
00:17:34,990 --> 00:17:39,410
ან რატომ ორიგინალური იყო ცუდი, it's - იწყება ამისთვის loop.

198
00:17:39,410 --> 00:17:43,380
მე შევამოწმე მდგომარეობა. მე ვარ <სიგრძით s?

199
00:17:43,380 --> 00:17:46,790
ამიტომ სიგრძით s, მოდით ვიმუშაოთ "Hello" მთელი ამ დროის.

200
00:17:46,790 --> 00:17:49,670
ამიტომ სიგრძით s, H-E-L-მ-o. სიგრძე არის 5.

201
00:17:49,670 --> 00:17:57,580
ასე რომ = 0, სიგრძე არის 5, ამიტომ არ არის <5, ასე loop გრძელდება.

202
00:17:57,580 --> 00:18:02,750
მაშინ ჩვენ წავიდეთ ერთხელ. ჩვენ შეამოწმოს მდგომარეობა. მე ვარ <სიგრძეზე მიესალმები?

203
00:18:02,750 --> 00:18:08,390
მოდით შევამოწმოთ სიგრძეზე hello. H-e-L-მ-o. სწორედ 5, მე არ არის <5, ამიტომ ჩვენ ვაგრძელებთ ერთხელ.

204
00:18:08,390 --> 00:18:13,330
ჩვენ გაანგარიშების, ჩვენ მათი იმედი გვაქვს hello, თითოეული iteration of მარყუჟის,

205
00:18:13,330 --> 00:18:17,380
კი ეგონა, არასდროს შეიცვლება, ის ყოველთვის იქნება 5.

206
00:18:17,380 --> 00:18:22,530
ამიტომ, ჩვენ უბრალოდ გვახსოვდეს 5 up წინა და ახლა ყველაფერი სჯობს.

207
00:18:22,530 --> 00:18:24,990
ამიტომ iterating მთელ string.

208
00:18:24,990 --> 00:18:31,470
რას გსურთ თითოეული ხასიათი სიმებიანი?

209
00:18:31,470 --> 00:18:38,510
[სტუდენტური მოლაპარაკე, გაუგებარია]

210
00:18:38,510 --> 00:18:47,000
Yeah. ასე რომ, თუ ხასიათი არის არასამთავრობო ანბანურ, მაშინ ჩვენ გვსურს მხოლოდ გამოტოვოთ მას.

211
00:18:47,000 --> 00:18:52,300
იმიტომ, რომ ჩვენ მხოლოდ აინტერესებს ანბანურ წერილებს, ჩვენ ვერ capitalize ნომერი.

212
00:18:52,300 --> 00:19:10,850
ასე რომ როგორ შეგვიძლია ამის გაკეთება? ასე რომ ჩვენი მდგომარეობა, ასე რომ, თუ ჩვენ გვინდა რაღაც - შეამოწმეთ თუ ანბანურ.

213
00:19:10,850 --> 00:19:14,060
ასე როგორ უნდა შეამოწმოთ ამ?

214
00:19:14,060 --> 00:19:18,720
[სტუდენტური] შეგიძლიათ უბრალოდ გამოიყენოთ ფუნქცია alpha.

215
00:19:18,720 --> 00:19:23,160
ის არის, რომ შედის არც ერთ ამ, ან ნებისმიერ მოიცავს, როგორიცაა, char.h ან რაღაც?

216
00:19:23,160 --> 00:19:32,710
მოდით არ გამოიყენოთ არის ალფა ფუნქცია და გამოიყენონ გამოკვეთილ - ასე გვაქვს s [i],

217
00:19:32,710 --> 00:19:40,460
რომ არის მერვე ხასიათი s, გვახსოვდეს, რომ სტრიქონს მასივი გმირები,

218
00:19:40,460 --> 00:19:43,180
ასე მერვე ხასიათი s.

219
00:19:43,180 --> 00:19:49,280
ახლა, თუ ეს კაპიტალი წერილში, ჩვენ ვიცით უნდა იყოს კონკრეტული დიაპაზონი.

220
00:19:49,280 --> 00:19:54,370
და რა არის ის, რომ სპექტრი?

221
00:19:54,370 --> 00:20:07,860
Yeah. ასე რომ, თუ s [i] არის ≥ 65, და s [i] არის ≤ 90, რა უნდა გავაკეთო ნაცვლად?

222
00:20:07,860 --> 00:20:18,470
Yeah. ასე, რომ თქვენ უნდა აბსოლუტურად არასოდეს კი უნდა იცოდეთ ASCII ღირებულებებს არაფერი ოდესმე.

223
00:20:18,470 --> 00:20:25,640
არასოდეს ვფიქრობ ნომრები 65, 90, 97 და 102, ან რასაც იგი.

224
00:20:25,640 --> 00:20:32,470
თქვენ არ გჭირდებათ - 112? - თქვენ არ უნდა იცოდეთ ის ყველა. სწორედ არასწორი ძალიან.

225
00:20:32,470 --> 00:20:41,940
მხოლოდ ერთ ციტირებით გმირები, მარტოხელა ციტირებით მუდმივები. ასე რომ "ა" და ნაკლები 90 არის 'ზ'

226
00:20:41,940 --> 00:20:47,930
და ეს არის მნიშვნელოვნად უკეთესი - მე არ ვიცი Off ზევით ჩემი უფროსი, რომ Z არის 90.

227
00:20:47,930 --> 00:20:52,690
მე ვიცი Off ზევით ჩემი უფროსი, რომ "Z" არის კაპიტალური ზ

228
00:20:52,690 --> 00:21:02,100
ასე რომ, სანამ ეს სპექტრი კაპიტალი კაპიტალის Z, ან ჩვენ შეგვიძლია შევამოწმოთ ამას,

229
00:21:02,100 --> 00:21:17,010
ან თუ იმ დიაპაზონში ≥ "ა" და ≤ z.

230
00:21:17,010 --> 00:21:19,010
ასე რომ ჩვენი მდგომარეობა.

231
00:21:19,010 --> 00:21:22,520
სტილი სად დააყენა ეს ყველაფერი მერყეობს.

232
00:21:22,520 --> 00:21:29,520
მე გავაკეთებთ მოსწონს ეს.

233
00:21:29,520 --> 00:21:31,520
ახლა, რა გვჭირდება ჩვენ უნდა გავაკეთოთ?

234
00:21:31,520 --> 00:21:39,530
ჩვენ ვიცით, ეს წერილი არის ხასიათი, ანბანური ხასიათი.

235
00:21:39,530 --> 00:21:46,270
ამიტომ, ჩვენ უნდა ჰყავდეს შორის თუ არა ეს უნდა იყოს კაპიტალის წერილით ან ამას წერილში.

236
00:21:46,270 --> 00:21:48,820
როგორ უნდა ტრეკზე რომელიც ერთი ჩვენ გვინდა, რომ იყოს?

237
00:21:48,820 --> 00:21:55,520
[სტუდენტური ხმები, გაუგებარია]

238
00:21:55,520 --> 00:21:59,150
ასე რომ დიახ, მაგრამ ნება მიბოძეთ შეამოწმოს.

239
00:21:59,150 --> 00:22:04,910
მოდული 0-2 ითქვა, იყო წინადადება გადმოაგდეს, და ვეთანხმები, რომ.

240
00:22:04,910 --> 00:22:11,780
გარდა ცნობა, როგორიცაა - არის ამ შემთხვევაში? Yeah.

241
00:22:11,780 --> 00:22:18,270
ეს ყოველ მეორე, მაგრამ ჩვენ არ შეგვიძლია მოდული 2 I, ან მე mod 2, ვინაიდან

242
00:22:18,270 --> 00:22:22,950
შეამჩნევთ, რომ E არის კაპიტალური და '' არის ამას? მაგრამ სივრცე ჰყოფს მათ?

243
00:22:22,950 --> 00:22:27,150
ამიტომ ისინი უნდა იყოს იგივე mod 2, მაგრამ ისინი სხვადასხვა შემთხვევებში.

244
00:22:27,150 --> 00:22:29,150
[სტუდენტური კითხვაზე, გაუგებარია]

245
00:22:29,150 --> 00:22:34,690
Yeah. ასე რომ ჩვენ უბრალოდ აპირებს შეინარჩუნოს რაოდენობა.

246
00:22:34,690 --> 00:22:38,730
ჩვენ შეგვიძლია აგრეთვე გავაკეთოთ, რომ აქ, თუ გვინდოდა, რომ შესაძლოა პატარა unwieldy

247
00:22:38,730 --> 00:22:41,300
in for loop დეკლარაციების; მე ამას აქ.

248
00:22:41,300 --> 00:22:48,840
ასე int რაოდენობა = იწყება 0.

249
00:22:48,840 --> 00:22:54,070
და ახლა, მე ვაპირებ ითვლიან რამდენი ანბანის სიმბოლოების ჩვენ გვქონდა.

250
00:22:54,070 --> 00:22:59,550
ამიტომ ჩვენ აუცილებლად ვაპირებთ ითვლიან + + წლიდან აღმოვაჩინეთ კიდევ ერთი ანბანური ხასიათი.

251
00:22:59,550 --> 00:23:09,130
მაგრამ, ასე ახლა თქვენ ამბობდა, თუ რაოდენობა mod 2.

252
00:23:09,130 --> 00:23:12,590
მერე რა, რომ რაოდენობა mod 2? Oh. მე გავაკეთებ == 0 ახლა.

253
00:23:12,590 --> 00:23:21,740
ჩვენ ასევე წასვლა მეტი რომ. ასე რომ, თუ რაოდენობა mod 2 == 0, მერე რა?

254
00:23:21,740 --> 00:23:27,830
[სტუდენტები პასუხი, გაუგებარია]

255
00:23:27,830 --> 00:23:32,750
ამიტომ ჩვენ გვსურს დასრულდება მდე ზედა.

256
00:23:32,750 --> 00:23:37,520
არის 2 შემთხვევა; ზედა და ამას are 2 შემთხვევა.

257
00:23:37,520 --> 00:23:40,990
ასე რომ, თუ ჩვენ ამას ჩვენ გვჭირდება, რათა ის ზედა.

258
00:23:40,990 --> 00:23:43,710
თუ ეს ზედა ჩვენ არ გვჭირდება არაფრის.

259
00:23:43,710 --> 00:23:50,760
მაგრამ, არსებობს გზა - shouldn't არ flipped -

260
00:23:50,760 --> 00:23:54,800
რომ ჩვენ არც კი უნდა შეამოწმოთ, რამდენად მიზანშეწონილია ზედა ან ამას?

261
00:23:54,800 --> 00:24:02,240
რა გავაკეთოთ, რომ ყოველთვის დარწმუნდით, რომ ჩვენ ყოველთვის დასრულდება მდე საათზე ზედა?

262
00:24:02,240 --> 00:24:07,830
ასე რომ შეამჩნია, რასაც ჩვენ გააკეთა ამას ''; რა, თუ ეს გავაკეთეთ იგივე ზუსტი რამ ზედა?

263
00:24:07,830 --> 00:24:11,900
Does ზედა ცვლილება, ან ჯერ ფასი ცვლილება?

264
00:24:11,900 --> 00:24:23,100
Yeah. ასე რომ ნებისმიერი კაპიტალის წერილში bitwise ANDed ერთად ~ 32 იქნება, რომ იგივე ზედა ხასიათი

265
00:24:23,100 --> 00:24:29,220
რადგან ნებისმიერი ზედა ხასიათი 32ND ცოტა არ არის მითითებული.

266
00:24:29,220 --> 00:24:40,920
ასე რომ, თუ ჩვენ გვინდა, რათა ხასიათი s [i], ჩვენ გვსურს, რომ გახდეს ამას ან ზედა.

267
00:24:40,920 --> 00:24:46,890
ასე რომ, თუ ეს იყო ამას, ეს არის ზედა, თუ ეს იყო ზედა, მაინც ზედა, და ამით ყველაფერი მთავრდება.

268
00:24:46,890 --> 00:24:54,290
მე ვთქვი ეს supersection: თქვენ შეგიძლიათ გამოიყენოთ 32 თუ გინდათ, მაგრამ მე როგორც წესი, ამჯობინებენ აკეთებს '' -,

269
00:24:54,290 --> 00:25:01,150
ნაცვლად მხოლოდ ბარის 32, იმიტომ რომ ეს შეიძლება იყოს ნებისმიერი სხვა bit.

270
00:25:01,150 --> 00:25:03,610
შემდეგ 32 bit, ეს შეიძლება იყოს რომელიმე ამ, ან ჩვენ არ გვაქვს საკმარისი

271
00:25:03,610 --> 00:25:05,840
ნომრები წარმოადგინოს ყველა სიმბოლო.

272
00:25:05,840 --> 00:25:09,110
ასე რომ თუ თქვენ გაქვთ 32 ბიტიანი, შეიძლება იყოს 64 bit, ეს შეიძლება იყოს 128 ბიტიანი.

273
00:25:09,110 --> 00:25:13,990
ნებისმიერი იმ ბიტი შეიძლება ცოტა რომ განასხვავებს ზედა და ამას.

274
00:25:13,990 --> 00:25:18,350
მე არ უნდა უნდა იცოდეთ, რომ ეს 32 ბიტიანი.

275
00:25:18,350 --> 00:25:27,130
შემიძლია ამ ნაწილის "ა" - მიიღოს ცოტა რომ განსხვავდება შორის ორი

276
00:25:27,130 --> 00:25:33,000
გარეშე სჭირდება უნდა დაეყრდნოს Magic ნომერი, რომელიც 32.

277
00:25:33,000 --> 00:25:38,770
და ა.შ. ახლა, სხვას დათვლა უცნაური, და ასე რა გსურთ?

278
00:25:38,770 --> 00:25:43,920
[სტუდენტური პასუხები, გაუგებარია]

279
00:25:43,920 --> 00:25:45,920
[სტუდენტური] რა არის რომ?

280
00:25:45,920 --> 00:25:49,850
მე ამას 1 წამში.

281
00:25:49,850 --> 00:25:55,690
ახლა თუ მინდა - მინდა დარწმუნდით ხასიათი არის ამას,

282
00:25:55,690 --> 00:26:04,140
და ასე, რომ შეიძლება ან 32 და 32 მნიშვნელობა '' - ა

283
00:26:04,140 --> 00:26:06,510
მაგრამ ცნობა, იმავე მიზეზის როგორც ადრე, რომ თუ

284
00:26:06,510 --> 00:26:11,670
წერილში უკვე ამას, მაშინ ORing მიერ 32 მხოლოდ ინახავს მხედრულ.

285
00:26:11,670 --> 00:26:16,220
ეს არ შეცვლილა ორიგინალური ხასიათი.

286
00:26:16,220 --> 00:26:19,910
მაგრამ ახლა არ მაქვს, რათა თავიდან ავიცილოთ განაცხადა, "თუ ეს ამას, უბრალოდ დაივიწყოს ის,

287
00:26:19,910 --> 00:26:23,650
თუ ზედა, მაშინ შეცვლის. "

288
00:26:23,650 --> 00:26:26,900
ეს ბევრად უფრო მოსახერხებელია ამის გაკეთება.

289
00:26:26,900 --> 00:26:33,190
[სტუდენტური] Would რომ სტრატეგია subtracting ზედა მხრიდან ამას მუშაობა თუ იგი არ იყო 32?

290
00:26:33,190 --> 00:26:35,330
თუ ეს იყო, ისევე, 34 ან რამე?

291
00:26:35,330 --> 00:26:41,840
ასე რომ, თქვენ უნდა იცოდეთ, რომ განსხვავება არის 2 -? >> 1 bit.

292
00:26:41,840 --> 00:26:49,840
ეს შეიძლება იყოს მეტი, ვიდრე 1 bit, რადგან ყველა ბიტი ქვემოთ ამ თანამდებობაზე ერთი და იგივე.

293
00:26:49,840 --> 00:26:58,500
ამიტომ ჩვენ გვჭირდება მინიმუმ 26 ჩარი - ან, არის 26 სიმბოლო.

294
00:26:58,500 --> 00:27:04,590
ამიტომ ჩვენ გვჭირდება მინიმუმ 26 ნომრის წარმოადგენს სხვაობა -

295
00:27:04,590 --> 00:27:07,650
განსხვავება და '' უნდა იყოს მინიმუმ 26,

296
00:27:07,650 --> 00:27:10,760
ანდა ჩვენ არ წარმოდგენილია ყველა დედაქალაქში ნომრები.

297
00:27:10,760 --> 00:27:18,630
ეს იმას ნიშნავს, რომ, თუ ჩვენ იწყება 1, ის აპირებს გამოიყენოს ყველა ამ ბიტი,

298
00:27:18,630 --> 00:27:23,900
ყველა ამ პირველი 5 ბიტი, წარმოადგინოს ყველაფერი მეშვეობით ზ

299
00:27:23,900 --> 00:27:32,170
ამიტომ შემდეგი bit, ან ამ bit, შემდეგი bit არის ერთი, რომ მიერ არჩეული გამოირჩეოდნენ შორის და '.'

300
00:27:32,170 --> 00:27:40,930
სწორედ ასევე, თუ რატომ, ამ ASCII მაგიდა, არის 5 სიმბოლიკა ჰყოფს ასოებით საწყისი ამას წერილებს.

301
00:27:40,930 --> 00:27:49,050
მას შემდეგ, რაც ეს ის სიმბოლიკა, დამატებით 5, რომ გამოიტანს 32 მყოფი განსხვავება მათ შორის.

302
00:27:49,050 --> 00:27:51,840
[სტუდენტური], ამიტომ ვერ გავაკეთებთ, რადგან ASCII ის შექმნილია, რომ გზა.

303
00:27:51,840 --> 00:27:57,280
დიახ. მაგრამ ASCII - განსხვავება შეიძლება ორივე ბიტი.

304
00:27:57,280 --> 00:28:12,040
მსგავსად, თუ იყო 10000001, და '' იყო 11100001 - მე დაგვავიწყდეს, რასაც.

305
00:28:12,040 --> 00:28:18,100
მაგრამ თუ ეს იყო, მაშინ ჩვენ შეგვიძლია კვლავ გამოიყენოს "ა" - ა

306
00:28:18,100 --> 00:28:22,650
უბრალოდ ახლა სხვაობა და '' ჯერ კიდევ ამ 2 ბიტი.

307
00:28:22,650 --> 00:28:32,240
ვფიქრობ, ეს დაწერილი 48. არის თუ არა 32 + 64? მე ვფიქრობ, ეს არის?

308
00:28:32,240 --> 00:28:40,160
ეს მაინც იყოს 2 ბიტი, თითოეული ხასიათი, ისევე, Z და z, K და K,

309
00:28:40,160 --> 00:28:45,160
ისინი ჯერ კიდევ აქვს იგივე ზუსტი ბიტი მითითებული გარდა იმ 2 ბიტი.

310
00:28:45,160 --> 00:28:48,870
ასე რომ სანამ რომ ყოველთვის ასეა, მიუხედავად თუ ჩვენ გამოყენებით ASCII ან სხვა სისტემა,

311
00:28:48,870 --> 00:28:53,050
რადგან არსებობს მხოლოდ კომპლექტი რაოდენობის ბიტი, რომლებიც სხვადასხვა თითოეული ხასიათი,

312
00:28:53,050 --> 00:28:55,050
მაშინ რომ მუშაობს ჯარიმა.

313
00:28:55,050 --> 00:29:06,110
უბრალოდ, 32 შეიქმნა იმიტომ რომ პირველი ჩვენ შეიძლება გამოვიყენოთ. >> Cool.

314
00:29:06,110 --> 00:29:14,520
მე როგორც წესი, ერჩივნა, იმ შემთხვევაში თუ თქვენ არ მინახავს, ​​თუ ბლოკი მხოლოდ ერთი ხაზი,

315
00:29:14,520 --> 00:29:24,280
შეგიძლიათ დავაღწიოთ Curly braces, ამიტომ მე ტენდენცია ურჩევნია აკეთებენ.

316
00:29:24,280 --> 00:29:34,010
ასევე, თქვენ იცით, თუ როგორ შეგვიძლია გავაკეთოთ რამ, როგორიცაა s [i] + = 1?

317
00:29:34,010 --> 00:29:41,090
თქვენ ასევე შეგიძლიათ გავაკეთოთ s [i] bitwise და = 32.

318
00:29:41,090 --> 00:29:46,400
და bitwise OR = 32.

319
00:29:46,400 --> 00:29:51,490
ასევე, ითვლიან mod 2 == 0.

320
00:29:51,490 --> 00:30:00,900
ასე რომ გვახსოვდეს, რომ - მე არ დავწერ აქ - ნებისმიერი არასამთავრობო ნულოვანი ღირებულება არის ჭეშმარიტი და 0 სიცრუეა.

321
00:30:00,900 --> 00:30:07,880
ასე რომ "თუ რაოდენობა mod 2 == 0" იგივეა, რაც რომ "თუ არ ითვლიან mod 2."

322
00:30:07,880 --> 00:30:11,580
მე ალბათ ახლახანს შეცვალა ხაზები და განაცხადა, რომ "თუ რაოდენობა mod 2,

323
00:30:11,580 --> 00:30:15,350
ნუ ან 1, სხვას რას და 1 ", ასე, რომ არ გვჭირდება" არა ".

324
00:30:15,350 --> 00:30:18,650
მაგრამ ეს მუშაობს მხოლოდ ასევე.

325
00:30:18,650 --> 00:30:25,660
და რა გავაკეთო აქ?

326
00:30:25,660 --> 00:30:29,060
თქვენ შეიძლება დააკავშიროთ მათ ternary თუ უნდოდა, მაგრამ მაშინ ეს უბრალოდ მიიღოს რამ messier

327
00:30:29,060 --> 00:30:33,770
და ალბათ უფრო რთული წასაკითხი, ამიტომ ჩვენ არ გაგვაჩნია.

328
00:30:33,770 --> 00:30:37,330
ვინმეს აქვს რაიმე სხვა წინადადებები?

329
00:30:37,330 --> 00:30:41,580
არის, რომ ყველა პრობლემა სთხოვა? Oh Yeah.

330
00:30:41,580 --> 00:30:51,070
ასე რომ დავაღწიოთ ამ ცარიელი ხაზები, ახლა ჩვენ ბეჭდვა ვ% s მყოფი ერთ სიმებისათვის,

331
00:30:51,070 --> 00:30:56,620
ჩვენ ბეჭდვა F, s.

332
00:30:56,620 --> 00:30:59,330
ახლა მოდით გაუშვით. არ ვამბობ არაფერს არასწორი?

333
00:30:59,330 --> 00:31:03,200
სწორედ \ "; მინდა n.

334
00:31:03,200 --> 00:31:07,840
Okay. ახლა ჩვენ გაუშვით. ეს ალბათ დაწეროთ at me.

335
00:31:07,840 --> 00:31:11,250
Strlen არის string.h.

336
00:31:11,250 --> 00:31:14,290
ასე რომ, ეს არის კარგი რამ შესახებ Clang არის ის გიჩვენებთ რასაც ის წელს,

337
00:31:14,290 --> 00:31:19,140
ნაცვლად gcc რომელიც მხოლოდ ამბობს: "Hey, თქვენ დაგავიწყდათ რაღაც, არ ვიცი, რაც იყო."

338
00:31:19,140 --> 00:31:29,220
მაგრამ ეს იქნება მითხრათ, "თქვენ ნიშნავდა მოიცავს string.h."

339
00:31:29,220 --> 00:31:32,130
ასე რომ მე არ შეეკითხება რაიმეს, ამიტომ არ ვამბობ არაფერს.

340
00:31:32,130 --> 00:31:42,540
მაგრამ ჩვენ ყველაფერს გავაკეთებთ მათ მაგალითზე, "გმადლობთ 4 დამატება".

341
00:31:42,540 --> 00:31:47,880
რომელიც გამოიყურება უფლება. Hooray.

342
00:31:47,880 --> 00:31:52,370
ამიტომ დაბრუნების თქვენი მთავარი, მე თითქმის არასდროს გავაკეთებთ.

343
00:31:52,370 --> 00:31:57,110
ეს პირობითი. და მთავარი არის ერთადერთი ფუნქცია, რომლის მიმართაც ის სურვილისამებრ.

344
00:31:57,110 --> 00:32:07,140
თუ არ დაბრუნდნენ არაფერს მთავარ, ეს ვარაუდი, რომ თქვენ ნიშნავდა დაბრუნებას 0.

345
00:32:07,140 --> 00:32:13,070
კითხვები?

346
00:32:13,070 --> 00:32:20,980
Okay. ახლა მეორე პრობლემა.

347
00:32:20,980 --> 00:32:24,810
"შეგახსენებთ, საწყისი კვირაში 2 მეორე ლექცია, რომ შევცვალე 2 ცვლადები 'ღირებულებების გავლით

348
00:32:24,810 --> 00:32:30,780
იმ 2 ცვლადები ფუნქციის (თუნდაც მოუწოდა swap) არ ზუსტად იმუშავებს, მაინც არ გარეშე "პოინტერები".

349
00:32:30,780 --> 00:32:37,020
და იგნორირება პოინტერები სანამ არ მივიღებთ მათ.

350
00:32:37,020 --> 00:32:40,070
ჩვენ გვინდა, რომ სვოპ 2 ცვლადები; ჩვენ არ იყენებს ფუნქციას ამის გაკეთება.

351
00:32:40,070 --> 00:32:43,410
ჩვენ კვლავ აპირებს ის ძირითადი მოსწონს ნათქვამია მოხსენებაში.

352
00:32:43,410 --> 00:32:48,360
მაგრამ გამოიყენოს იმ 2 ცვლადები, არ გვინდა გამოვიყენოთ დროებითი ცვლადი.

353
00:32:48,360 --> 00:32:50,770
2 გზა არსებოსბს ამის გაკეთება.

354
00:32:50,770 --> 00:32:56,310
თქვენ შეგიძლიათ ეს გააკეთოთ გამოყენებით თქვენი ტრადიციული ბინარული ოპერატორები.

355
00:32:56,310 --> 00:33:00,180
ასე რომ ვინმეს ვიცი სწრაფი და ბინძური გზა აკეთებს, რომ?

356
00:33:00,180 --> 00:33:07,650
ეს შეიძლება პრაქტიკულად წუთი აზროვნების. თუ მე -

357
00:33:07,650 --> 00:33:12,130
მე მითითებული პრობლემა მოსწონს ისინი კითხულობენ. ასე რომ, თუ მაქვს 2 ცვლადები,, რაც არის მთელი რიცხვი

358
00:33:12,130 --> 00:33:17,800
რომ მომცეს, და თანხა ცვლადი B, რაც კიდევ ერთი რიცხვი, რომ მე მოცემული.

359
00:33:17,800 --> 00:33:22,700
ასე რომ, თუ მაქვს ამ 2 ცვლადები, ახლა მინდა სვოპ მათ.

360
00:33:22,700 --> 00:33:31,550
ტრადიციული, თქვენი რეგულარული ბინარული ოპერატორები, ვგულისხმობ, როგორიც +, -, ÷.

361
00:33:31,550 --> 00:33:36,630
არ bitwise ოპერატორების რომელიც მოქმედებს ორობითი.

362
00:33:36,630 --> 00:33:39,600
ასე გამოყენებით -, +, î, და ყველა იმ.

363
00:33:39,600 --> 00:33:52,980
ჩვენ შეგვეძლო სვოპ ამით რაღაც = + B და B = - ბ, = - ბ.

364
00:33:52,980 --> 00:34:04,260
ასე რომ, საღი აზრის შეამოწმეთ და შემდეგ ვნახავთ, თუ რატომ, რომ სამუშაოები.

365
00:34:04,260 --> 00:34:13,320
ვთქვათ = 7, ბ = 3, მაშინ a + b იქნება 10.

366
00:34:13,320 --> 00:34:18,820
ამიტომ ჩვენ ახლა შექმნის = 10, და შემდეგ ვაკეთებთ B = - ბ.

367
00:34:18,820 --> 00:34:30,250
ასე ვაკეთებთ B = - ბ, რომელიც იქნება 7, ბ = - ბ ერთხელ,

368
00:34:30,250 --> 00:34:38,650
ან = - ბ. რომელიც იქნება 10 - 7 რომელიც არის 3.

369
00:34:38,650 --> 00:34:44,850
ახლა, სწორად, '' იყო 7, ბ იყო 3 და ახლა B არის 7 და '' არის 3.

370
00:34:44,850 --> 00:34:48,679
ასე რომ ასეთი სახის აზრი; '' არის კომბინაცია 2 ნომრები.

371
00:34:48,679 --> 00:34:53,000
ამ ეტაპზე, "ა" არის კომბინაცია, და შემდეგ ჩვენ subtracting გარეთ ორიგინალური ბ,

372
00:34:53,000 --> 00:34:56,860
და მაშინ ჩვენ subtracting რა იყო ორიგინალური '.'

373
00:34:56,860 --> 00:35:01,150
მაგრამ ეს არ მუშაობს ყველა ნომრები.

374
00:35:01,150 --> 00:35:08,880
, რომ ეს, განვიხილოთ სისტემა, ამიტომ როგორც წესი, ჩვენ ვიფიქროთ, მთელი რიცხვები, როგორც 32 ბიტი.

375
00:35:08,880 --> 00:35:13,050
მოდით მუშაობა რაღაც რომ მხოლოდ მოსწონს 4 ბიტი.

376
00:35:13,050 --> 00:35:15,450
იმედია მე ამუშავება კარგი მაგალითი ახლავე.

377
00:35:15,450 --> 00:35:18,680
ასე რომ, მე ვიცი, ეს იქნება ადვილი.

378
00:35:18,680 --> 00:35:26,720
ვთქვათ ჩვენი 2 ნომრები არიან 1111 და 1111, ამიტომ ჩვენ წელს ორობითი ახლავე.

379
00:35:26,720 --> 00:35:34,630
რეალურ decimals, თუ თქვენ გინდათ რომ ვფიქრობ ის, რომ გზა, = 15 და B = 15.

380
00:35:34,630 --> 00:35:37,630
ამიტომ ჩვენ ველით, რომ მას შემდეგ, რაც ჩვენ სვოპ მათ - მათ არც კი უნდა იყოს იგივე ნომრები,

381
00:35:37,630 --> 00:35:41,140
მაგრამ ეს ამ გზით.

382
00:35:41,140 --> 00:35:47,100
მოდით მათ არ იგივე ნომრები. მოდით 1111 და 0001.

383
00:35:47,100 --> 00:35:51,860
ასე = 15 და B = 1.

384
00:35:51,860 --> 00:35:57,670
მას შემდეგ რაც სვოპ მათ, ჩვენ ველით, რომ "ა" უნდა იყოს 1 და B უნდა იყოს 15.

385
00:35:57,670 --> 00:36:01,780
ამიტომ ჩვენი პირველი ნაბიჯი არის = + ბ.

386
00:36:01,780 --> 00:36:08,770
ჩვენი ნომრები მხოლოდ 4 ბიტი ფართო, ასე ',' რომელიც 1111, + B, რომელიც 0001,

387
00:36:08,770 --> 00:36:16,780
აპირებს დასრულდება მდე მიმდინარეობს 10000, მაგრამ ჩვენ მხოლოდ 4 ბიტი.

388
00:36:16,780 --> 00:36:22,540
ახლა = 0.

389
00:36:22,540 --> 00:36:34,080
და ახლა ჩვენ გვინდა მითითებული B = - ბ - ფაქტობრივად, ეს მაინც შეიმუშავებს შესანიშნავად.

390
00:36:34,080 --> 00:36:39,630
= - ბ - ვნახოთ, თუ ამ შეიმუშავებს შესანიშნავად.

391
00:36:39,630 --> 00:36:53,720
ასეა, მაშინ B = 0 - 1, რომელიც კვლავ იყოს 15, ხოლო შემდეგ = - ბ, რომელიც იქნება 1.

392
00:36:53,720 --> 00:36:56,210
იქნებ ეს სულაც მუშაობა.

393
00:36:56,210 --> 00:36:59,020
ვგრძნობ, როგორიცაა არსებობს მიზეზი ის არ მუშაობს გამოყენებით რეგულარული.

394
00:36:59,020 --> 00:37:06,400
Okay, ასე მუშაობს ვარაუდი, რომ იგი არ მუშაობს რეგულარული ბინარული ოპერაციები,

395
00:37:06,400 --> 00:37:15,040
და მე ვეძებთ - მე Google თუ რომ მართლაც ასეა.

396
00:37:15,040 --> 00:37:23,490
ასე რომ ჩვენ გვინდა ამის გაკეთება გამოყენებით bitwise ოპერატორები, და ნახავ აქ XOR.

397
00:37:23,490 --> 00:37:28,780
ასე რომ, შემოღების XOR (^) თუ არ მინახავს ეს არავის გაუკეთებია.

398
00:37:28,780 --> 00:37:34,610
ეს, კიდევ ერთხელ, bitwise ოპერატორი ასე მოქმედებს ნელ bit, და it's -

399
00:37:34,610 --> 00:37:39,910
თუ თქვენ გაქვთ ბიტი 0 და 1, მაშინ ეს იქნება 1.

400
00:37:39,910 --> 00:37:45,230
თუ თქვენ გაქვთ ბიტი 1 და 0, ეს იქნება 1, თქვენ გაქვთ ბიტი 0 და 0 ეს იქნება 0,

401
00:37:45,230 --> 00:37:47,640
და თუ თქვენ გაქვთ ბიტი 1 და 1 ეს იქნება 0.

402
00:37:47,640 --> 00:37:56,180
ასე რომ მოსწონს ან. თუ არც ბიტი არის ჭეშმარიტი, ეს 1, მაგრამ განსხვავებით, ან მას არ შეუძლია იყოს როგორც ბიტი, რომ არის ჭეშმარიტი.

403
00:37:56,180 --> 00:37:59,320
OR იქნებოდა ეს იყოს 1, XOR იქნებოდა ეს იყოს 0.

404
00:37:59,320 --> 00:38:02,250
ამიტომ, ჩვენ ვაპირებთ, რომ გსურთ გამოიყენოთ XOR აქ.

405
00:38:02,250 --> 00:38:09,960
დაფიქრდით ერთი წუთით, მე ვაპირებ Google.

406
00:38:09,960 --> 00:38:16,230
ისე, თქვენ ვერ ხედავთ, რომ მე ვარ ამჟამად XOR swap ალგორითმი გვერდზე.

407
00:38:16,230 --> 00:38:21,340
იმედია ამ აგიხსნით რატომ can't -

408
00:38:21,340 --> 00:38:34,190
სწორედ ეს არის ის ალგორითმი, რომ ჩვენ უბრალოდ გააკეთეს.

409
00:38:34,190 --> 00:38:37,330
მე მაინც ვერ ვხედავ, რატომ - მე უნდა უბრალოდ აღებული ცუდი მაგალითია,

410
00:38:37,330 --> 00:38:44,940
მაგრამ ამ შემთხვევაში '' მოხდა, რომ გახდეს 0, მას შემდეგ, რაც დან 5 ბიტი, ამიტომ ახლა '' არის 0,

411
00:38:44,940 --> 00:38:48,730
რომ არის რა ჰქვია "Integer overflow".

412
00:38:48,730 --> 00:38:54,370
მიხედვით ვიკიპედია, "განსხვავებით XOR swap, ამ ვარიაციის მოითხოვს, რომ იგი იყენებს ზოგიერთი მეთოდები

413
00:38:54,370 --> 00:38:59,780
უნდა უზრუნველყოს, რომ x + y არ იწვევს მთელი overflow ".

414
00:38:59,780 --> 00:39:08,350
ასე რომ, ეს არ აქვს პრობლემები, რაც მთელი რიცხვი overflow, მაგრამ რაღაც არასწორია.

415
00:39:08,350 --> 00:39:10,520
მე არ ვარ დარწმუნებული. ვეცდები რომ ამუშავება კიდევ ერთი.

416
00:39:10,520 --> 00:39:13,640
[სტუდენტური] ისე, არ არის მთელი რიცხვი overflow როდესაც თქვენ ცდილობთ დააყენა ნომერი არსებობს

417
00:39:13,640 --> 00:39:16,640
დიდია, ვიდრე თანხის ბიტი თქვენ არ გამოყო?

418
00:39:16,640 --> 00:39:23,730
Yeah. ჩვენ გვყავს 4 ბიტი. That's - გვქონდა 4 ბიტი, ჩვენ მაშინ ცდილობენ დაამატოთ 1 მას, ასე რომ ჩვენ დასრულდება მდე, 5 ბიტი.

419
00:39:23,730 --> 00:39:26,690
მაგრამ მეხუთე bit უბრალოდ იღებს შეწყვიტა, yeah.

420
00:39:26,690 --> 00:39:28,970
ეს შესაძლოა რეალურად -

421
00:39:28,970 --> 00:39:33,010
[სტუდენტური] არა, რომ ჩააგდოს თქვენ შეცდომა, ან არ, რომ - რომ რომ ჩააგდოს შეცდომა?

422
00:39:33,010 --> 00:39:40,720
პოსტები ასე არ შეცდომა. როდესაც თქვენ მიიღებთ ასამბლეის დონეზე, სპეციალური bit

423
00:39:40,720 --> 00:39:47,020
სადღაც არის მითითებული, რომ განაცხადა, რომ overflow, მაგრამ C თქვენ სახის უბრალოდ არ გაუმკლავდეთ რომ.

424
00:39:47,020 --> 00:39:55,160
თქვენ ნამდვილად ვერ გაუმკლავდეთ მას თუ არ გამოიყენოს სპეციალური ასამბლეის ინსტრუქცია C.

425
00:39:55,160 --> 00:39:58,110
მოდით ვიფიქროთ XOR swap.

426
00:39:58,110 --> 00:40:02,220
და ვფიქრობ ვიკიპედიის სტატიიდან შეიძლება ასევე ამბობდა, რომ -

427
00:40:02,220 --> 00:40:07,310
ასე რომ, ეს ასევე აღიზარდნენ მოდულარული არითმეტიკა, ასე ვფიქრობ მე ვიყავი, თეორიულად, აკეთებს მოდულარული არითმეტიკა

428
00:40:07,310 --> 00:40:11,160
როდესაც ვთქვი, რომ 1 - 0 არის 15 ერთხელ.

429
00:40:11,160 --> 00:40:15,410
ასე, რომ ეს შეიძლება რეალურად - რეგულარულ პროცესორი რომ არ 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
ვინაიდან ჩვენ დასრულდება მდე at 0, ჩვენ სხვაობა 1, ასე რომ მაშინ მხოლოდ დასრულდება უკან გარშემო ნომერზე 1111.

431
00:40:20,430 --> 00:40:28,930
ასე რომ, ეს ალგორითმი შეიძლება რეალურად მუშაობა, + B, - ბ, ბ -, რომ შესაძლოა, ჯარიმა.

432
00:40:28,930 --> 00:40:34,030
მაგრამ ზოგიერთი პროცესორები რომლებიც არ გავაკეთოთ, და ა.შ. ეს არ იქნება ჯარიმა იმ კონკრეტულ მიიჩნიეს.

433
00:40:34,030 --> 00:40:39,880
XOR swap იმუშავებს ნებისმიერი პროცესორი. Okay.

434
00:40:39,880 --> 00:40:42,280
იდეა არის ის, რომ ეს უნდა იყოს იგივე, თუმცა.

435
00:40:42,280 --> 00:40:50,120
სადაც ჩვენ ვართ გამოყენებით XOR რათა როგორმე მიიღოს ინფორმაცია ორივე შევიდა 1 of ცვლადები,

436
00:40:50,120 --> 00:40:54,120
და შემდეგ გაიყვანოს ინფორმაციით ინდივიდუალური ცვლადები ერთხელ.

437
00:40:54,120 --> 00:41:04,330
ასე რომ ვინმეს აქვს იდეები / პასუხი?

438
00:41:04,330 --> 00:41:14,540
[სტუდენტური პასუხი, გაუგებარია]

439
00:41:14,540 --> 00:41:22,220
ასე რომ, ეს უნდა იმუშაოს, და ასევე, XOR არის commutative.

440
00:41:22,220 --> 00:41:27,620
მიუხედავად რომელიც წესრიგის ამ 2 ნომრები მოხდეს იყოს აქ,

441
00:41:27,620 --> 00:41:30,100
ეს შედეგი იქნება იგივე.

442
00:41:30,100 --> 00:41:35,800
ასე ^ B არის ბ ^.

443
00:41:35,800 --> 00:41:51,860
თქვენ შესაძლოა, ასევე ხედავენ ამ წერილობითი როგორც ^ = B, B ^ =, ^ = B ერთხელ.

444
00:41:51,860 --> 00:42:00,200
ასე რომ, ეს უფლება, და თუ რატომ ეს სამუშაოები, ვფიქრობ ბიტი.

445
00:42:00,200 --> 00:42:10,400
გამოყენება smallish ნომერი, ვთქვათ 11001, 01100 და.

446
00:42:10,400 --> 00:42:12,790
ასე რომ, ეს ''; ეს ბ.

447
00:42:12,790 --> 00:42:15,540
ასე ^ = B.

448
00:42:15,540 --> 00:42:22,380
ჩვენ ვაპირებთ უნდა დააყენოთ '' = to XOR ამ 2 რამ.

449
00:42:22,380 --> 00:42:32,920
ამგვარად 1 ^ 0 არის 1; 1 ^ 1 არის 0; 0 ^ 1 არის 1 და 0 ^ 0 არის 0; 1 ^ 0 არის 1.

450
00:42:32,920 --> 00:42:37,380
ასე რომ ',' თუ შევხედოთ ათობითი რიცხვი, ეს იქნება -

451
00:42:37,380 --> 00:42:41,160
თქვენ არ აპირებენ ვხედავ დიდი შორის ურთიერთობის ორიგინალური "ა" და ახალი ", '

452
00:42:41,160 --> 00:42:45,600
მაგრამ თუ ჩვენ შევხედავთ ბიტი, '' არის მოსწონს mesh ინფორმაციის

453
00:42:45,600 --> 00:42:49,970
ორივე ორიგინალური "ა" და ორიგინალური ბ.

454
00:42:49,970 --> 00:42:57,930
ასე რომ, თუ ჩვენ ვიღებთ ბ ^, ჩვენ ვხედავთ, რომ ჩვენ დასრულდება მდე საათზე ორიგინალური '.'

455
00:42:57,930 --> 00:43:08,910
და თუ ავიღებთ ორიგინალური '' ^ ახალი ',' ჩვენ ვხედავთ ჩვენ დასრულდება მდე საათზე ორიგინალური ბ.

456
00:43:08,910 --> 00:43:18,380
ასე რომ (^ ბ) ^ B = ორიგინალური '.'

457
00:43:18,380 --> 00:43:27,910
და (^ ბ) ^ = ორიგინალური ბ.

458
00:43:27,910 --> 00:43:37,010
არსებობს - სხვა გზა ხედავს ეს არაფერი XOR თავისთავად ყოველთვის 0.

459
00:43:37,010 --> 00:43:45,020
ასე რომ 1101 ^ 1101, ყველა ბიტი ვაპირებთ იყოს იგივე.

460
00:43:45,020 --> 00:43:47,920
ასე რომ ის არასდროს იქნება შემთხვევაში სადაც 1 არის 0, ხოლო მეორე 1.

461
00:43:47,920 --> 00:43:51,080
ასე რომ, ეს არის 0000.

462
00:43:51,080 --> 00:43:57,240
იგივე ამ. (^ ბ) ^ ბ ჰგავს ^ (B ^ ბ).

463
00:43:57,240 --> 00:44:03,680
(ბ ^ ბ) იქნება 0; ^ 0 მხოლოდ იქნება ", 'რადგან ყველა ბიტი არის 0.

464
00:44:03,680 --> 00:44:08,050
ასე რომ ერთადერთი პირობა, რომ ვაპირებთ იყოს სადაც "'თავდაპირველად 1 - ჰქონდა მიიჩნიეს.

465
00:44:08,050 --> 00:44:12,070
და იგივე იდეა აქ ვარ საკმაოდ დარწმუნებული ასევე commutative.

466
00:44:12,070 --> 00:44:17,590
Yeah. მე ვთქვა ადრე, რომ ეს იყო commutative.

467
00:44:17,590 --> 00:44:24,680
^ ',' და ეს ასოციაციური, ამიტომ ახლა (B ^) ^.

468
00:44:24,680 --> 00:44:28,970
და ჩვენ შეგვიძლია გავაკეთოთ ბ ^ (^).

469
00:44:28,970 --> 00:44:31,540
და ა.შ. ერთხელ, მივიღებთ ორიგინალური ბ.

470
00:44:31,540 --> 00:44:37,120
ასე რომ '' არის კომბინაცია "ა" და ბ ერთად.

471
00:44:37,120 --> 00:44:49,660
ჩვენი ახალი Combo '' ვამბობთ B = Combo '' ^ ორიგინალური ბ, მივიღებთ ორიგინალური '.'

472
00:44:49,660 --> 00:45:05,170
და ახლა = Combo '' ^ ახალი ბ, რომელიც იყო ორიგინალურ - ან რომელიც არის, რა იყო '"ან ბ.

473
00:45:05,170 --> 00:45:13,620
სწორედ ამ შემთხვევაში ქვემოთ აქ. ეს არის = B, ძველი ბ.

474
00:45:13,620 --> 00:45:16,550
ასე რომ ახლა ყველაფერი უკან swapped მიზნით.

475
00:45:16,550 --> 00:45:22,960
თუ ჩვენ რეალურად შევხედე ბიტი, ბ = ^ B, აპირებს XOR ამ 2,

476
00:45:22,960 --> 00:45:33,920
და პასუხი იქნება ამ და შემდეგ = ^ B არის XORing ამ 2 და პასუხი არის ამ.

477
00:45:33,920 --> 00:45:41,090
კითხვები? Okay. ასე რომ ბოლო ერთი გარკვეულწილად მნიშვნელოვნად უფრო რთულია.

478
00:45:41,090 --> 00:45:43,180
[სტუდენტური] ვფიქრობ მას კითხვას ამის შესახებ. >> ოჰ, უკაცრავად.

479
00:45:43,180 --> 00:45:49,380
[სტუდენტური] რა არის რეალურად უფრო სწრაფად? თუ იყენებთ ამ XOR, ან არის, თუ გამოაცხადოს ახალი ცვლადი?

480
00:45:49,380 --> 00:45:55,190
რა არის რეალურად უფრო სწრაფად, გამოცხადების ახალი ცვლადი ან გამოყენებით XOR რომ სვოპ?

481
00:45:55,190 --> 00:45:59,600
პასუხი არის, ყველა ალბათობა, დროებითი ცვლადი.

482
00:45:59,600 --> 00:46:05,780
და ეს იმიტომ, რომ ერთხელ ის შედგენილი Down - ისე ასამბლეის დონეზე,

483
00:46:05,780 --> 00:46:12,320
არსებობს ასეთი რამ, როგორც ადგილობრივი ცვლადები ან ნებისმიერ დროებითი ცვლადები ან ამ პერსონალის.

484
00:46:12,320 --> 00:46:16,060
ისინი ისევე როგორც - იქ მეხსიერება, და არსებობს რეგისტრების.

485
00:46:16,060 --> 00:46:20,920
რეგისტის, რა აქტიურად ხდება.

486
00:46:20,920 --> 00:46:24,750
თქვენ არ დაამატოთ 2 რამ მეხსიერება; თქვენ დაამატოთ 2 რამ რეგისტრების.

487
00:46:24,750 --> 00:46:28,160
და თქვენ მოუტანს ნივთები მეხსიერების რეგისტრების შევიდა, რათა შემდეგ add მათ,

488
00:46:28,160 --> 00:46:33,180
და მაშინ შეიძლება განათავსოთ მათ უკან მეხსიერებაში, მაგრამ ყველა მოქმედება ხდება რეგისტრების.

489
00:46:33,180 --> 00:46:38,750
ასე რომ, როდესაც თქვენ იყენებთ დროებითი ცვლადი მიდგომა, ჩვეულებრივ, რა ხდება

490
00:46:38,750 --> 00:46:42,810
ამ 2 ნომრები უკვე რეგისტრების.

491
00:46:42,810 --> 00:46:46,570
და შემდეგ რომ წერტილი, შემდეგ თქვენ swapped მათ,

492
00:46:46,570 --> 00:46:51,540
ეს კიდე დავიწყო გამოყენებით სხვა რეესტრში.

493
00:46:51,540 --> 00:46:56,510
ერთგან თქვენ უკვე გამოყენებით B, იგი ყველაფერს უბრალოდ გამოიყენოთ რეგისტრაცია რომ უკვე შენახვა ". '

494
00:46:56,510 --> 00:47:02,180
ასე რომ, ეს არ უნდა გავაკეთოთ არაფერი მართლაც swap. ჰო?

495
00:47:02,180 --> 00:47:05,690
[სტუდენტური] არამედ იღებს მეტი მეხსიერების, არა?

496
00:47:05,690 --> 00:47:10,280
იგი მხოლოდ მიიღოს მეტი მეხსიერების თუ მას სჭირდება შესანახად, რომ დროებითი ცვლადი.

497
00:47:10,280 --> 00:47:14,830
Like თუ მოგვიანებით გამოყენება, რომ დროებითი ცვლადი ერთხელ სადღაც,

498
00:47:14,830 --> 00:47:18,920
მაშინ - ან თქვენ დაავალოს რაღაც რომ დროებითი ცვლადი.

499
00:47:18,920 --> 00:47:24,630
ასე რომ, თუ ნებისმიერ მომენტში "," ბ temp აქვს მკაფიო ღირებულებები ან რაღაც,

500
00:47:24,630 --> 00:47:30,680
მაშინ აპირებს აქვს მკაფიო ადგილებში მეხსიერება, მაგრამ ეს სიმართლეა, რომ

501
00:47:30,680 --> 00:47:34,800
არსებობს მრავალი ადგილობრივი ცვლადები რომელიც მხოლოდ არსებობს რეგისტრების.

502
00:47:34,800 --> 00:47:44,370
რა შემთხვევაში, არასდროს ექსპლუატაციაში შევიდა მეხსიერება და ა.შ. თქვენ არასოდეს გაყვანაა მეხსიერება.

503
00:47:44,370 --> 00:47:58,620
Okay. ბოლო კითხვაზე ოდნავ მეტი.

504
00:47:58,620 --> 00:48:04,850
ასე რომ აქ, ამ CS50 ელექტრო მოწყობილობების, არსებობს ლექსიკონი.

505
00:48:04,850 --> 00:48:12,390
და მიზეზი არის ის, რადგან [? B66] არის მართლწერის შემოწმება, სადაც თქვენ უნდა წერა

506
00:48:12,390 --> 00:48:15,780
გამოყენებით hash მაგიდები ან ლელო ან მონაცემები სტრუქტურა.

507
00:48:15,780 --> 00:48:22,660
თქვენ უნდა წერა მართლწერის შემოწმება, და თქვენ უნდა გამოყენებისას ლექსიკონი გავაკეთოთ, რომ.

508
00:48:22,660 --> 00:48:28,280
მაგრამ ამ პრობლემას, ჩვენ უბრალოდ აპირებს ეძებოთ თუ ერთი სიტყვა არის ლექსიკონში.

509
00:48:28,280 --> 00:48:31,250
ასე რომ ნაცვლად შენახვა მთელი ლექსიკონი ზოგიერთ მონაცემები სტრუქტურა

510
00:48:31,250 --> 00:48:35,180
და შემდეგ ეძებს მეტი დოკუმენტის სრულად თუ არაფერი ის misspelled,

511
00:48:35,180 --> 00:48:38,490
ჩვენ გვსურს მხოლოდ მოძიების 1 სიტყვა. ასე რომ ჩვენ შეგვიძლია მხოლოდ სკანირების მთელ ლექსიკონი

512
00:48:38,490 --> 00:48:44,300
და თუ ჩვენ არასოდეს მოვძებნოთ სიტყვა მთელი ლექსიკონი, მაშინ მას არ არსებობს.

513
00:48:44,300 --> 00:48:52,150
თუ ჩვენ სკანირების მთელ ლექსიკონი და ნუ ვხედავ სიტყვას, მაშინ ჩვენ კარგი, ჩვენ ვერ.

514
00:48:52,150 --> 00:48:56,580
იგი ამბობს, რომ ჩვენ გვინდა, რომ დაიწყოს ეძებს C-ს ფაილის დამუშავება ფუნქცია,

515
00:48:56,580 --> 00:48:59,930
მას შემდეგ, რაც ჩვენ გვინდა წაიკითხოთ ლექსიკონი,

516
00:48:59,930 --> 00:49:07,680
მაგრამ მისცემს მინიშნება აქ როგორც რომლის ფუნქციები უნდა იფიქრონ.

517
00:49:07,680 --> 00:49:11,510
მე წერენ მათ სივრცეებს.

518
00:49:11,510 --> 00:49:20,490
ასე რომ მთავარი პირობა თქვენ გსურთ შევხედოთ მათ F ღია და შემდეგ, აუცილებლად, ვ დახურულია,

519
00:49:20,490 --> 00:49:26,540
რომელიც წავა დასასრულს თქვენი პროგრამა, და ვ სკანირების ვ.

520
00:49:26,540 --> 00:49:31,060
თქვენ შეიძლება ასევე გამოიყენოს ვ წავიკითხე, მაგრამ როგორც ჩანს არ მინდა

521
00:49:31,060 --> 00:49:34,200
იმიტომ, რომ - თქვენ არ დასრულდება მდე სჭირდება, რომ.

522
00:49:34,200 --> 00:49:41,880
F სკანირების ვ არის თუ რას აპირებენ გამოყენებით სკანირებას მეტი ლექსიკონი.

523
00:49:41,880 --> 00:49:46,370
და ასე რომ თქვენ არ გჭირდებათ კოდი up გადაწყვეტა, სცადეთ და როგორც ფსევდო კოდი თქვენი გზა

524
00:49:46,370 --> 00:50:05,200
უნდა გადაწყვეტა, და შემდეგ ჩვენ განვიხილავთ მას.

525
00:50:05,200 --> 00:50:14,110
და ფაქტობრივად, რადგან მე უკვე მისცა თქვენ ამ, თუ ნებისმიერ ტერმინალში ან თქვენი ელექტრო ს შელი,

526
00:50:14,110 --> 00:50:18,250
მინდა - მე როგორც წესი - თუ არ მინახავს ჯერ, არ ვიცი, თუ რა გააკეთეთ კლასში,

527
00:50:18,250 --> 00:50:23,490
მაგრამ კაცი, ასე რომ მამაკაცს გვერდებზე, საკმაოდ სასარგებლოა ეძებს საკმაოდ ბევრი ნებისმიერი ფუნქცია.

528
00:50:23,490 --> 00:50:27,330
ასე რომ შემიძლია, ისევე, ადამიანი F, სკანირების ვ.

529
00:50:27,330 --> 00:50:32,300
ეს არის ინფორმაცია იმის შესახებ, სკანირების ვ ოჯახის ფუნქციები.

530
00:50:32,300 --> 00:50:37,070
მე შეიძლება გააკეთოს მამაკაცმა F, ღია, და რომ მივცემ ჩემს დეტალებს რომ.

531
00:50:37,070 --> 00:50:40,750
ასე რომ, თუ თქვენ იცით რა ფუნქცია თქვენ იყენებთ, ან თქვენ კითხულობს კოდი

532
00:50:40,750 --> 00:50:43,000
და ხედავთ ზოგიერთი ფუნქცია და თქვენ, როგორიცაა, "რას აკეთებთ?"

533
00:50:43,000 --> 00:50:45,280
უბრალოდ კაცი, რომ ფუნქციის სახელი.

534
00:50:45,280 --> 00:50:47,340
არსებობს რამდენიმე უცნაური მაგალითიც მოიყვანა, სადაც თქვენ შეიძლება უნდა ვთქვა

535
00:50:47,340 --> 00:50:51,620
მინდა. კაცი 2, რომ ფუნქციის სახელი, ან ადამიანის 3 რომ ფუნქციის სახელი,

536
00:50:51,620 --> 00:50:58,230
მაგრამ თქვენ მხოლოდ უნდა გავაკეთოთ, რომ თუ კაცი ფუნქციის სახელი არ ხდება მუშაობა პირველად.

537
00:50:58,230 --> 00:51:03,010
[სტუდენტური] ასე მე კითხულობს კაცი გვერდზე ღია, მაგრამ მე ჯერ კიდევ დაბნეული, თუ როგორ გამოიყენოთ იგი და პროგრამა.

538
00:51:03,010 --> 00:51:06,170
Okay. ბევრი ადამიანი, გვერდებზე ნაკლები გამოსადეგი.

539
00:51:06,170 --> 00:51:08,470
ისინი უფრო გამოსადეგი თუ იცით რას აკეთებს

540
00:51:08,470 --> 00:51:12,670
და მაშინ თქვენ უბრალოდ უნდა გვახსოვდეს ბრძანებით არგუმენტები ან რამე.

541
00:51:12,670 --> 00:51:17,640
ან მათ მოგცემთ ზოგად მიმოხილვას, მაგრამ ზოგი მათგანი ძალიან დიდი.

542
00:51:17,640 --> 00:51:22,220
მომწონს F სკანირების ვ, ასევე. ეს გაძლევთ ინფორმაციას ყველა ამ ფუნქციების

543
00:51:22,220 --> 00:51:28,120
და 1 ხაზი ქვემოთ აქ ხდება ვთქვა, "F სკანირების ვ კითხულობს სიმებიანი წერტილი ან სტრიმის ჩართვა."

544
00:51:28,120 --> 00:51:32,360
მაგრამ ვ გახსნა. ასე რომ, როგორ ვიყენებთ ვ ღია?

545
00:51:32,360 --> 00:51:38,470
იდეა პროგრამა, რომელიც სჭირდება გავაკეთოთ ფაილის I / O ის არის, რომ

546
00:51:38,470 --> 00:51:45,070
თქვენ ჯერ უნდა გახსნა ფაილი გსურთ რამ, და აუცილებლად,

547
00:51:45,070 --> 00:51:51,220
წაკითხვის ნივთები რომ ფაილი და გააკეთოს პერსონალის მათთან.

548
00:51:51,220 --> 00:51:55,350
F ღია არის ის, რაც ჩვენ ვიყენებთ გახსნას ფაილი.

549
00:51:55,350 --> 00:52:04,190
რამ მივიღებთ უკან, ასე რომ ფაილი გვინდა გახსნას, ეს გვაძლევს -

550
00:52:04,190 --> 00:52:11,970
აქ ნათქვამია "/ user / share / dict / სიტყვა."

551
00:52:11,970 --> 00:52:16,740
ეს არის ფაილი, რომ ჩვენ გვინდა გავხსნათ, და გვინდა, რომ იგი უნდა გახსნას -

552
00:52:16,740 --> 00:52:21,440
ჩვენ უნდა მიუთითოთ თუ არა ჩვენ გვინდა გავხსნათ ეს წაიკითხოს ან თუ გვინდა გასახსნელად დაწერა.

553
00:52:21,440 --> 00:52:26,490
არსებობს რამდენიმე კომბინაციები და პერსონალი, მაგრამ ჩვენ გვინდა, რომ გახსნას ამ წასაკითხად.

554
00:52:26,490 --> 00:52:29,380
ჩვენ გვინდა, რომ წაკითხვის ფაილი.

555
00:52:29,380 --> 00:52:34,290
რას გვეუბნება ამ დაბრუნების? ის დააბრუნებს ფაილი ვარსკვლავი (*),

556
00:52:34,290 --> 00:52:37,260
და მე უბრალოდ ნახოთ ყველაფერი ცვლადი F, ასე *,

557
00:52:37,260 --> 00:52:40,840
ერთხელ, ეს მაჩვენებელი, მაგრამ ჩვენ არ გვინდა, რომ გაუმკლავდეთ პოინტერები.

558
00:52:40,840 --> 00:52:46,470
შეგიძლიათ წარმოიდგინოთ, რომ F როგორც, F არის ცვლადი თქვენ აპირებს გამოიყენოს წარმოადგინოს ფაილი.

559
00:52:46,470 --> 00:52:49,850
ასე რომ, თუ გსურთ წაკითხვა ფაილი, თქვენ წაკითხვის ვ.

560
00:52:49,850 --> 00:52:54,820
თუ გსურთ დახურეთ ფაილი, თქვენ დახურვა ვ.

561
00:52:54,820 --> 00:53:00,350
ამიტომ დასასრულს პროგრამის როდესაც ჩვენ აუცილებლად გვინდა დახურვა ფაილი, რა უნდა გავაკეთოთ?

562
00:53:00,350 --> 00:53:06,750
ჩვენ გვინდა, რომ დახუროს ვ.

563
00:53:06,750 --> 00:53:12,600
ახლა ბოლო ფაილი ფუნქცია, რომ ჩვენ ვაპირებთ გინდათ გამოიყენოთ არის სკანირების ვ, ვ სკანირების ვ.

564
00:53:12,600 --> 00:53:20,930
და რა რომ არ არის ეს დაასკანირებს მეტი ფაილი ეძებს ნიმუში ემთხვევა.

565
00:53:20,930 --> 00:53:39,100
ეძებს კაცს გვერდზე აქ, ჩვენ ვხედავთ int F სკანირების ვ, იგნორირება დაბრუნების მნიშვნელობა არის.

566
00:53:39,100 --> 00:53:45,230
პირველი არგუმენტი ფაილი * ნაკადი, ასე პირველი არგუმენტი ჩვენ ვაპირებთ გვინდა უღელტეხილი ვ.

567
00:53:45,230 --> 00:53:47,900
ჩვენ სკანირების მეტი ვ.

568
00:53:47,900 --> 00:53:53,680
მეორე არგუმენტი არის სტრიქონში.

569
00:53:53,680 --> 00:53:58,310
მე მოგცემთ სტრიქონში ახლავე.

570
00:53:58,310 --> 00:54:05,180
ვფიქრობ, არ უნდა ვთქვათ, 127s \ n, ბევრი რომ ზედმეტი.

571
00:54:05,180 --> 00:54:12,490
იდეა რა, რომ სტრიქონში არის, არის შეგიძლიათ წარმოიდგინოთ, რომ სკანირების ვ როგორც საპირისპირო ბეჭდვითი ვ.

572
00:54:12,490 --> 00:54:17,160
ამიტომ ბეჭდვითი F, ბეჭდვითი F ჩვენ ასევე ვიყენებთ ამ ტიპის ფორმატი პარამეტრი,

573
00:54:17,160 --> 00:54:25,000
მაგრამ ბეჭდვით F იმას თუ რას ვაკეთებთ არის - მოდით შევხედოთ ექვივალენტს.

574
00:54:25,000 --> 00:54:32,550
ამიტომ ბეჭდვა F, და იქ ფაქტიურად ასევე F ბეჭდვითი F, სადაც პირველი არგუმენტი იქნება ვ.

575
00:54:32,550 --> 00:54:40,980
როდესაც თქვენ ბეჭდვა F, შეიძლება ითქვას, მსგავსი რამ, "ბეჭდვის 127s \ n" და შემდეგ, თუ ჩვენ გაიაროს ეს რამდენიმე სტრიქონი,

576
00:54:40,980 --> 00:54:44,050
ის აპირებს ბეჭდვა ეს კონტექსტი და შემდეგ ახალი ხაზი.

577
00:54:44,050 --> 00:54:49,690
რა 127 საშუალებებით, მე საკმაოდ დარწმუნებული, მაგრამ მე არასდროს შეზღუდული თავს მას,

578
00:54:49,690 --> 00:54:52,470
თქვენ არც უნდა ითქვას, '127 'in ბეჭდვითი F,

579
00:54:52,470 --> 00:54:57,090
მაგრამ რას ნიშნავს არის ბეჭდვის პირველი 127 სიმბოლო.

580
00:54:57,090 --> 00:54:59,350
ამიტომ მე საკმაოდ დარწმუნებული ვარ, რომ არის საქმე. შეგიძლიათ Google-ის რომ.

581
00:54:59,350 --> 00:55:03,000
მაგრამ მომდევნო ერთი მე თითქმის პოზიტიური ეს ნიშნავს, რომ.

582
00:55:03,000 --> 00:55:08,880
ასე რომ, ეს არის ბეჭდვის პირველი 127 სიმბოლოს, რასაც მოჰყვა ახალი ხაზი.

583
00:55:08,880 --> 00:55:14,680
F სკანირების ვ ახლა, ნაცვლად ეძებს ცვლადი და ბეჭდვა ეს,

584
00:55:14,680 --> 00:55:22,620
ის აპირებს შევხედოთ ზოგიერთი სიმებიანი, და შესანახად ნიმუში შევიდა ცვლადი.

585
00:55:22,620 --> 00:55:26,360
მოდით რეალურად გამოიყენოთ სკანირების ვ in სხვადასხვა მაგალითი.

586
00:55:26,360 --> 00:55:31,670
ასე ვთქვათ ჩვენ გვქონდა int, x = 4,

587
00:55:31,670 --> 00:55:41,110
და გვინდოდა სტრინგის შექმნის დამზადებული - სურდა შექმნა string

588
00:55:41,110 --> 00:55:44,250
რომ იყო, ეს იქნება ამუშავება გაცილებით გვიან,

589
00:55:44,250 --> 00:55:49,020
რაღაც რომ ისევე 4.jpg.

590
00:55:49,020 --> 00:55:51,870
ასე რომ, ეს შეიძლება იყოს პროგრამის სადაც თქვენ გექნებათ თანხა counter,

591
00:55:51,870 --> 00:55:56,420
მთლიანობაში დავუპირისპირდეთ მე, და გსურთ შეინახოთ bunch of images.

592
00:55:56,420 --> 00:56:02,430
ასე რომ გსურთ შეინახოთ i.jpg, სადაც მე რაღაც iteration თქვენი loop.

593
00:56:02,430 --> 00:56:05,500
ასე როგორ უნდა გააკეთოს ეს კონტექსტი რომ JPEG?

594
00:56:05,500 --> 00:56:11,720
თუ უნდოდა ბეჭდვა 4.jpg, შეიძლება უბრალოდ, ვამბობთ ბეჭდური F,% d.jpg,

595
00:56:11,720 --> 00:56:14,410
და მაშინ ბეჭდვა რომ JPEG.

596
00:56:14,410 --> 00:56:20,050
მაგრამ თუ გვინდა, რომ გადავარჩინოთ სიმებიანი 4.jpg, ჩვენ ვიყენებთ სკანირების ვ.

597
00:56:20,050 --> 00:56:30,860
ამიტომ string s - რეალურად ჩვენ can't - ხასიათი, char s, მოდით წავიდეთ 100.

598
00:56:30,860 --> 00:56:35,400
ასე რომ მე უბრალოდ გამოაცხადა გარკვეული მასივი 100 სიმბოლო,

599
00:56:35,400 --> 00:56:39,830
და რომ სწორედ ეს ჩვენ აუცილებლად უნდა შენახვის, რომ JPEG სისტემაში

600
00:56:39,830 --> 00:56:47,920
ამიტომ, ჩვენ ვაპირებთ, გამოვიყენოთ სკანირების ვ, და ფორმატი, თუ როგორ ვიტყოდი% d.jpg

601
00:56:47,920 --> 00:56:54,980
რათა ბეჭდვა 4.jpg, ფორმატი ამ იქნება% d.jpg.

602
00:56:54,980 --> 00:57:04,020
ასე ფორმატი% d.jpg, რაც გვინდა, შევცვალოთ% d არის x,

603
00:57:04,020 --> 00:57:06,590
და ახლა გვჭირდება შესანახად რომ სიმებიანი სადღაც.

604
00:57:06,590 --> 00:57:12,500
და სადაც ჩვენ ვაპირებთ შესანახად ეს კონტექსტი არის მასივი s.

605
00:57:12,500 --> 00:57:21,640
ასე რომ ამის შემდეგ ხაზი კოდი, s, თუ ჩვენ ბეჭდვა F,% s ცვლადი s,

606
00:57:21,640 --> 00:57:26,280
ის აპირებს ბეჭდვა 4.jpg.

607
00:57:26,280 --> 00:57:38,930
ასე ვ F სკანირების არის იგივე როგორც სკანირების ვ, გარდა ახლა კი ეძებს ამ ფაილის

608
00:57:38,930 --> 00:57:43,600
ამისთვის, რა მაღაზიის s.

609
00:57:43,600 --> 00:57:46,160
სწორედ ბოლო არგუმენტი იქნება.

610
00:57:46,160 --> 00:57:54,170
ჩვენ გვინდა შესანახად - "Scan ვ ოჯახის ფუნქციების Scans ორივე მიხედვით ფორმატი, როგორც შევეცადეთ ქვემოთ.

611
00:57:54,170 --> 00:58:02,450
თუ რომელიმე ინახება წერტილები შეიძლება დაბრუნდეს - "

612
00:58:02,450 --> 00:58:12,910
არა, ჩვენ შეიძლება იყოს კარგი. ნება მომეცით ვფიქრობ, მეორე.

613
00:58:12,910 --> 00:58:26,350
ამიტომ სკანირების ვ არ - რა heck არის ფუნქცია, რომელიც აკეთებს, რომ?

614
00:58:26,350 --> 00:58:31,650
ამიტომ სკანირების ვ არ აპირებს მიიღოს მთელი რიცხვი და ნუ dot jpg.

615
00:58:31,650 --> 00:58:43,490
იგი აპირებს [mumbles].

616
00:58:43,490 --> 00:58:49,360
შენახვა int ცვლადი in string int C.

617
00:58:49,360 --> 00:58:55,940
რა არის ეს ცვლადი, ან რა არის ეს ფუნქცია, რომელსაც ჰქვია?

618
00:58:55,940 --> 00:59:04,950
დიახ. That's - დიახ. მერე რა მე განსაზღვრის თქვენ ადრე იყო და ბეჭდვითი F,

619
00:59:04,950 --> 00:59:09,820
რაც - ხდის ბევრად უფრო გრძნობა, რატომ განაცხადა, რომ ეს იყო ბევრად უფრო მოსწონს ბეჭდვითი ვ.

620
00:59:09,820 --> 00:59:14,700
სკანირების ვ კვლავ სახის მოსწონს ბეჭდვითი F, მაგრამ s ბეჭდვითი ვ აპირებს სკანირების მას მეტი

621
00:59:14,700 --> 00:59:17,510
და შეცვლის ცვლადები და ახლა ჩაწერს მას სიმებიანი.

622
00:59:17,510 --> 00:59:19,620
იმის ნაცვლად, რომ დაბეჭდვის, ეს ინახავს მას სიმებიანი.

623
00:59:19,620 --> 00:59:25,070
ასე იგნორირება, რომ მთლიანად. თქვენ შეგიძლიათ კვლავ ვფიქრობ ფორმატში specifier როგორც მოსწონს, რომ ბეჭდური ვ.

624
00:59:25,070 --> 00:59:34,510
ახლა, თუ ჩვენ გვინდოდა ჯანმრთელობის სფეროში გაგვეკეთებინა 4.jpg რამ, ჩვენ ყველაფერს გააკეთებს s ბეჭდვითი F, X ამ.

625
00:59:34,510 --> 00:59:38,520
მერე რა სკანირების ვ აკეთებს - როგორი იყო თქვენი კითხვა იქნება?

626
00:59:38,520 --> 00:59:40,820
[სტუდენტური] მე უბრალოდ დაბნეული რა ჩვენ ვცდილობთ გავაკეთოთ უფლება აქ

627
00:59:40,820 --> 00:59:43,450
რომ JPEG. შეგიძლიათ განმარტავენ, რომ 1 უფრო მეტი დრო?

628
00:59:43,450 --> 00:59:52,710
ასე რომ, ეს იყო - ეს ნაკლებად relevent to F სკანირების ვ ახლა, იმედია, ეს იქნება უსიამოვნოა უკან რაღაც გზა.

629
00:59:52,710 --> 01:00:02,240
მაგრამ, რაც მე თავდაპირველად აპირებს შოუ - ეს არის რეალურად პირდაპირ შესაბამის ამ [? F5]

630
01:00:02,240 --> 01:00:08,520
თქვენ უნდა გამოყენებით s ბეჭდვითი F, სადაც, ვთქვათ გვაქვს 100, სურათებით,

631
01:00:08,520 --> 01:00:13,630
და თქვენ გინდათ წაიკითხოთ გამოსახულება 1.jpg, 2.jpg, 3.jpg.

632
01:00:13,630 --> 01:00:21,520
რათა მოხდეს ასე, თქვენ უნდა ვ ღია და შემდეგ თქვენ უნდა გაიაროს in string რომ გსურთ გახსნა.

633
01:00:21,520 --> 01:00:30,020
ასე რომ ჩვენ გვინდა გავხსნათ 1.jpg; შესაქმნელად string რომ არის 1.jpg,

634
01:00:30,020 --> 01:00:37,660
ვაკეთებთ s ბეჭდვითი F of% d.jpg--ჩვენ არ გააკეთოს int i = 0.

635
01:00:37,660 --> 01:00:46,580
I <40 მე + +.

636
01:00:46,580 --> 01:00:51,130
რათა ბეჭდვითი ვ% d.jpg, I.

637
01:00:51,130 --> 01:00:56,320
ასე რომ ამის შემდეგ ხაზი, ახლა ცვალებად და array s აპირებს 1.jpg.

638
01:00:56,320 --> 01:01:10,610
ან, 0.jpg, 1.jpg, 2.jpg. ასე რომ, ჩვენ შეიძლება გახსნა, თავის მხრივ, თითოეული image წასაკითხად.

639
01:01:10,610 --> 01:01:19,550
ასე რომ არის რა ბეჭდვა F აკეთებს. ხედავთ რა ბეჭდვა F არის აკეთებთ?

640
01:01:19,550 --> 01:01:25,720
[სტუდენტური] Okay, ამიტომ აღების - იგი ქმნის სტრინგს, something.jpg და შემდეგ ინახავს მას.

641
01:01:25,720 --> 01:01:30,360
დიახ. იგი ქმნის - ეს არის კიდევ ერთი სტრიქონში, ისევე, როგორც სკანირების ვ და ბეჭდვითი F,

642
01:01:30,360 --> 01:01:37,530
სადაც ეს ჩანართები ყველა ცვლადები შევიდა მეორე არგუმენტი, შესაძლოა, ჯერ როგორც ეწინააღმდეგებოდა მე.

643
01:01:37,530 --> 01:01:42,280
ალბათ - ვგულისხმობ, რომ საქმე. მაგრამ რაც ბრძანებით არგუმენტები არის.

644
01:01:42,280 --> 01:01:45,440
იგი აპირებს ჩადეთ ყველა ცვლადები შევიდა სტრიქონში

645
01:01:45,440 --> 01:01:52,250
და შემდეგ ვინახავთ ჩვენს ბუფერული, ჩვენ მოვუწოდებთ, რომ ბუფერული, ეს სადაც ჩვენ შენახვის სიმებიანი.

646
01:01:52,250 --> 01:02:00,750
ჩვენ შენახვის შიგნით s სწორად ფორმატირებული ტექსტი,% d გამო შეცვალა 4.

647
01:02:00,750 --> 01:02:08,080
[სტუდენტური] ასე რომ, თუ ეს გავაკეთეთ, არის ცვლადი ვ უბრალოდ უნდა გადაიყვანა?

648
01:02:08,080 --> 01:02:18,110
დიახ. ამიტომ, ჩვენ უნდა დახუროს ორიგინალური ვ ადრე აკეთებენ.

649
01:02:18,110 --> 01:02:22,810
მაგრამ - და შემდეგ ასევე, თუ არ იყო ვ გახსენით აქ, მაშინ ჩვენ უნდა ვთქვა -

650
01:02:22,810 --> 01:02:29,280
Yeah. მაგრამ ეს არ გახსნა ასი სხვადასხვა ფაილები.

651
01:02:29,280 --> 01:02:37,360
[სტუდენტური] მაგრამ ჩვენ ვერ წვდომისათვის ან - okay.

652
01:02:37,360 --> 01:02:44,230
Okay. ამიტომ სკანირების ვ, ვ სკანირების F, არის ერთგვარი იგივე იდეა,

653
01:02:44,230 --> 01:02:53,610
მაგრამ ნაცვლად, ნაცვლად შენახვის ის ტექსტი, ეს უფრო მოსწონს თქვენ ახლა

654
01:02:53,610 --> 01:03:02,420
აპირებს მეტი Sting და ნიმუში შესატყვისი წინააღმდეგ რომ სიმებიანი და შენახვის იწვევს ცვლადები.

655
01:03:02,420 --> 01:03:11,290
თქვენ შეგიძლიათ გამოიყენოთ სკანირების ვ გარჩევის გამო რაღაც 4.jpg, და შესანახად რიცხვი 4 შევიდა თანხა int x.

656
01:03:11,290 --> 01:03:13,430
რაც ჩვენ შეგვიძლია გამოვიყენოთ სკანირების ვ ამისთვის.

657
01:03:13,430 --> 01:03:16,300
F სკანირების ვ გაკეთებას აპირებს, რომ ბრძანებათა ზოლს.

658
01:03:16,300 --> 01:03:19,200
მე რეალურად საკმაოდ დარწმუნებული ეს რა CS50 ბიბლიოთეკა აკეთებს.

659
01:03:19,200 --> 01:03:29,050
ასე რომ, როდესაც თქვენ ამბობთ, "Get int," ეს სკანირების F-ing მეტი - სკანირების ვ არის გზა თქვენ მომხმარებლის შეყვანის.

660
01:03:29,050 --> 01:03:34,670
F სკანირების ვ აპირებს იგივე მაგრამ გამოყენებით ფაილის სკანირებას დასრულდა.

661
01:03:34,670 --> 01:03:41,090
ასე რომ აქ, ჩვენ სკანირების ამ ფაილის.

662
01:03:41,090 --> 01:03:45,460
ნიმუში ვცდილობთ ემთხვევა არის ზოგიერთი სიმებიანი რომ არის 127 სიმბოლომდე

663
01:03:45,460 --> 01:03:48,100
მოჰყვა ახალი ხაზი

664
01:03:48,100 --> 01:03:54,770
ამიტომ მე საკმაოდ დარწმუნებული შეგვეძლო კი უბრალოდ, ვამბობთ "ემთხვევა s," რადგან ლექსიკონი

665
01:03:54,770 --> 01:03:57,770
ჩვენ არ უნდა ჰქონდეს, რომ ჩვენ გარანტირებული სიტყვას არ არის, რომ ხანგრძლივი,

666
01:03:57,770 --> 01:04:03,310
და ასევე F სკანირების ვ, ვფიქრობ, იქნება შეჩერება ახალი ხაზი არა აქვს მნიშვნელობა რა.

667
01:04:03,310 --> 01:04:06,970
მაგრამ ამას მოიცავს ახალი ხაზი მატჩი, და -

668
01:04:06,970 --> 01:04:13,960
[სტუდენტური] თუ ჩვენ არ შედის ახალი ხაზი, რომ არა იგი იპოვის ნაწილების სიტყვა?

669
01:04:13,960 --> 01:04:22,900
იგი - ყოველ - ეძებს ლექსიკონი -

670
01:04:22,900 --> 01:04:26,200
ასე რომ ლექსიკონი, ეს არის ყველა ჩვენი სიტყვა.

671
01:04:26,200 --> 01:04:30,500
თითოეული არის ახალი ხაზი.

672
01:04:30,500 --> 01:04:32,510
სკანირების ვ აპირებს შეარჩიო ამ სიტყვის.

673
01:04:32,510 --> 01:04:38,750
თუ ჩვენ არ შეიცავს ახალი ხაზი, მაშინ შესაძლებელია, რომ მომდევნო სკანირების ვ მხოლოდ წაიკითხა ახალი ხაზი.

674
01:04:38,750 --> 01:04:44,180
მაგრამ მათ შორის ახალი ხაზი მაშინ იქნება უბრალოდ იგნორირება ახალი ხაზი.

675
01:04:44,180 --> 01:04:49,440
მაგრამ ჩვენ არასდროს მიიღოთ ნაწილი სიტყვას, რადგან ჩვენ ყოველთვის კითხულობს მდე ახალი ხაზი, არ აქვს მნიშვნელობა რა.

676
01:04:49,440 --> 01:04:54,530
[სტუდენტური] მაგრამ რა, თუ თქვენ მოძებნოთ სიტყვა "cissa," მოსწონს cissa.

677
01:04:54,530 --> 01:04:57,380
იქნება ეს იპოვოს, რომ, და აცხადებენ, რომ ეს მატჩი?

678
01:04:57,380 --> 01:05:05,110
ასე რომ აქ ჩვენ - ის იკითხება - ეს არის რეალურად კარგი წერტილი.

679
01:05:05,110 --> 01:05:10,660
ჩვენ არასოდეს გამოყენებით მიმდინარე - სიტყვა ჩვენ ვეძებთ არის პირველი ბრძანება ხაზი არგუმენტი.

680
01:05:10,660 --> 01:05:16,460
ამიტომ სტრიქონს, სიტყვა = argv 1.

681
01:05:16,460 --> 01:05:20,020
ამიტომ სიმებიანი ჩვენ ვეძებთ არის argv 1.

682
01:05:20,020 --> 01:05:23,290
ჩვენ არ ვეძებთ სიტყვა ყველა ჩვენს სკანირების ვ.

683
01:05:23,290 --> 01:05:28,030
რას ვაკეთებდით ერთად სკანირების ვ დღითიდღე ყოველ სიტყვას ლექსიკონი,

684
01:05:28,030 --> 01:05:34,320
და შემდეგ კიდევ გვაქვს, რომ სიტყვა ჩვენ ვაპირებთ გამოვიყენოთ strcmp შედარების მათ.

685
01:05:34,320 --> 01:05:39,210
ჩვენ ვაპირებთ შეადაროთ ჩვენი სიტყვა და რასაც ჩვენ უბრალოდ წაიკითხა შემოსული

686
01:05:39,210 --> 01:05:45,110
ასე რომ აუცილებლად, ჩვენ ვაპირებთ დასრულდება მდე აკეთებს bunch of სკანირების FS

687
01:05:45,110 --> 01:05:52,130
სანამ ასე მოხდება, რომ სკანირების ვ დაბრუნდება -

688
01:05:52,130 --> 01:05:54,800
იგი დაბრუნდება ერთი, რადგან მას შესაბამისი ახალი სიტყვა,

689
01:05:54,800 --> 01:06:01,360
და ეს დაბრუნდება რაღაც, როგორც კი ვერ ემთხვევა სიტყვა.

690
01:06:01,360 --> 01:06:08,440
ჩვენ მათ შორის მთელ ლექსიკონი, შენახვა ხაზს თითოეულ სიტყვას შევიდა ცვლადი s.

691
01:06:08,440 --> 01:06:17,240
მაშინ ჩვენ შედარებით სიტყვაზე s, და თუ შედარებით == 0,

692
01:06:17,240 --> 01:06:21,650
strcmp ხდება, რათა 0 თუ მატჩი გაკეთდა.

693
01:06:21,650 --> 01:06:31,510
ასე რომ, თუ ეს იყო 0, მაშინ ჩვენ შეგვიძლია ბეჭდვა F, შესაბამისი,

694
01:06:31,510 --> 01:06:35,370
ან სიტყვა არის ლექსიკონის, ან რასაც თქვენ გსურთ ბეჭდვა ვ.

695
01:06:35,370 --> 01:06:41,450
და მაშინ - ჩვენ არ გვინდა, რომ ვ დახურვა უსასრულოდ.

696
01:06:41,450 --> 01:06:50,410
ეს არის სახის რამ გვინდა გავაკეთოთ, და ჩვენ არა მხოლოდ ეძებს სიტყვას ლექსიკონი.

697
01:06:50,410 --> 01:06:56,660
ამიტომ ვერ გავაკეთებთ, თუ გვინდოდა ვეძებოთ მათი ნიმუში, cissa, თქვენნაირი დაწყებამდე განაცხადა,

698
01:06:56,660 --> 01:07:00,260
თუ გვინდოდა ვეძებოთ, რომ ნიმუში, მაშინ ვერ შემთხვევაში

699
01:07:00,260 --> 01:07:08,010
რადგან ეს არ არის რეალურად სიტყვა, მაგრამ ერთი სიტყვა ლექსიკონი მოსდის აქვს, რომ მასში.

700
01:07:08,010 --> 01:07:13,560
ასე, რომ ეს დაემთხვა ამ სიტყვის, მაგრამ ეს subset of სიტყვა არ არის სიტყვა თავად.

701
01:07:13,560 --> 01:07:17,250
მაგრამ ეს არ არის, თუ როგორ იყენებთ მას; ჩვენ კითხულობს თითოეულ სიტყვას

702
01:07:17,250 --> 01:07:19,740
და მაშინ შედარებით სიტყვა გვაქვს, რომ სიტყვა.

703
01:07:19,740 --> 01:07:25,780
ამიტომ ჩვენ ყოველთვის შედარებით სრული სიტყვა.

704
01:07:25,780 --> 01:07:29,620
მე შეგიძლიათ გააგზავნოთ out დასრულდა გადაწყვეტილებები მოგვიანებით.

705
01:07:29,620 --> 01:07:32,050
ეს არის სახის თითქმის სწორად უნდა უპასუხოს, ვფიქრობ.

706
01:07:32,050 --> 01:07:34,720
[სტუდენტური კომენტარი, გაუგებარია]

707
01:07:34,720 --> 01:07:40,870
ოჰ, არც მე მოშორება, რომ ადრე? ჩარ s, ვფიქრობ ჩვენ განაცხადა 127 - I დაგვავიწყდეს, თუ რა არის ყველაზე დიდი.

708
01:07:40,870 --> 01:07:44,100
ჩვენ უბრალოდ 128, ამიტომ ახლა s არის ხანგრძლივი საკმარისი.

709
01:07:44,100 --> 01:07:46,570
ჩვენ არ გვჭირდება ბეჭდვა არაფერი.

710
01:07:46,570 --> 01:07:56,440
ჩვენ ასევე ვაპირებთ სურს დახუროს ჩვენი ფაილი, და რომ უნდა იყოს დაახლოებით უფლება პასუხი.

711
01:07:56,440 --> 01:07:59,440
CS50.TV