1
00:00:00,000 --> 00:00:02,670
[Powered by Google Translate] Πρόβλημα Τμήμα Set 2: Έκδοση Hacker

2
00:00:02,670 --> 00:00:04,910
Rob Bowden, Πανεπιστήμιο του Χάρβαρντ

3
00:00:04,910 --> 00:00:07,410
Αυτό είναι CS50. CS50.TV

4
00:00:07,410 --> 00:00:15,770
Έτσι, είμαι Rob. Είμαι ένας ανώτερος σε 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
Ω, έτσι η ιδέα είναι να πάει σε αυτό το link που σου έστειλα και στη συνέχεια θα είστε σε διάστημα μου.

9
00:00:37,410 --> 00:00:42,410
Δεν έχει κανείς ένα φορητό υπολογιστή; Εντάξει.

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
και θα μπορούσα να σηκώσει κάποια από κωδικό σας, και εγώ θα συζητήσουμε τις ιδέες σας.

13
00:00:56,390 --> 00:01:02,140
Έτσι έχει κάποιος είχε δυσκολία;

14
00:01:02,140 --> 00:01:07,000
Μπορείτε να κάνετε chat στο πλάι? Δεν ξέρω αν θα έχουμε λόγος γι 'αυτό.

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-1 ήδη σετ.

18
00:01:22,550 --> 00:01:27,400
Αλλά μπορούμε να δούμε στο σύνολο P-2 για το τι θα πάμε να πηγαίνει πέρα ​​σήμερα.

19
00:01:27,400 --> 00:01:29,460
Και θα δείτε ένα τμήμα των ερωτήσεων.

20
00:01:29,460 --> 00:01:37,530
Έτσι, αυτό θα είναι σε όλες τις Ρ-σύνολα? Θα υπάρχει ένα τμήμα των ερωτήσεων.

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
Υποθέτω ότι για την έκδοση 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
Αχ. Επίσης, κάτω από αυτές τις ενότητες των ερωτήσεων που επίσης έχετε ερωτήσεις σχετικά με τα σορτς.

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
Έτσι, μπορούμε να αρχίσουμε με αυτά: "Πώς ένα βρόχο, ενώ διαφέρουν από ένα do-while 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-while loop θα είναι πάντα εκτελέσει τουλάχιστον μία φορά.

38
00:02:52,730 --> 00:03:02,950
Ναι. Έτσι, αυτή είναι η διαφορά. Ένας βρόχος ενώ - I'll το κάνει μόνο για εδώ - ενώ βρόχο, έχουμε την κατάσταση

39
00:03:02,950 --> 00:03:19,760
δεξιά εδώ, ενώ ένα do-ενώ, δεν έχετε μια κατάσταση μέχρι να φτάσουμε εδώ κάτω.

40
00:03:19,760 --> 00:03:24,130
Και έτσι, όταν το πρόγραμμά σας είναι εκτέλεση, και αυτό γίνεται με το βρόχο while,

41
00:03:24,130 --> 00:03:26,380
ελέγχει αμέσως εάν αυτή η συνθήκη είναι αληθής.

42
00:03:26,380 --> 00:03:30,710
Αν αυτή η κατάσταση δεν είναι αλήθεια, απλά θα παρακάμψουν εντελώς το βρόχο.

43
00:03:30,710 --> 00:03:34,390
Do-while loop, όπως το πρόγραμμα εκτελεί, να παίρνει το "κάνει".

44
00:03:34,390 --> 00:03:37,920
Τίποτα δεν θα συμβεί σε αυτό το σημείο, απλά συνεχίζει την εκτέλεση.

45
00:03:37,920 --> 00:03:42,690
Στη συνέχεια, όταν χτυπά το «λίγο», αν η συνθήκη είναι αληθής, αυτό θα στραφεί προς τα πίσω και να το κάνουμε ξανά

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
Έτσι, ενώ ο βρόχος θα το κάνει μόνο μια φορά, ή - το βρόχο, ενώ - δεν μπορεί να χρειαστεί να το κάνουμε καθόλου,

50
00:04:03,720 --> 00:04:07,900
από τη στιγμή που θα πάρει σε αυτό, αν η κατάσταση είναι ψευδής, απλά θα προχωρήσετε κατευθείαν πάνω του.

51
00:04:07,900 --> 00:04:11,770
Ότι η do-while loop, εμείς θα το εκτελέσει μία φορά, κατ 'ανάγκην.

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-while.

58
00:04:43,140 --> 00:04:47,510
Έτσι, όταν δεν έχετε χρησιμοποιήσει do-while loops;

59
00:04:47,510 --> 00:04:49,510
Πότε είναι η - ναι;

60
00:04:49,510 --> 00:04:53,180
[Φοιτητικό] Όταν προσπαθείτε να πάρετε είσοδο του χρήστη, ή κάτι που θέλετε να ελέγξετε -

61
00:04:53,180 --> 00:04:59,700
Ναι. Έτσι, do-while loops, εισάγετε το όνομα χρήστη είναι το μεγάλο.

62
00:04:59,700 --> 00:05:03,160
Αυτός είναι ο λόγος για τις πρώτες σειρές πρόβλημα ζευγάρι, όταν θέλετε να ζητήσει από το χρήστη, όπως,

63
00:05:03,160 --> 00:05:08,520
"Δώσε μου ένα string," δεν μπορείτε να συνεχίσετε μέχρι να πάρετε αυτό το string.

64
00:05:08,520 --> 00:05:12,980
Και έτσι, αναγκαστικά, πρέπει να ζητήσει τη σειρά, τουλάχιστον μία φορά.

65
00:05:12,980 --> 00:05:16,950
Στη συνέχεια, όμως, αν απαντήσει κάτι κακό, τότε θα πρέπει να βρόχο πίσω και να ζητήσει και πάλι.

66
00:05:16,950 --> 00:05:20,810
Αλλά εκτός από παρέμβαση του χρήστη, είναι πολύ σπάνιο ότι έχω συναντήσει μια υπόθεση

67
00:05:20,810 --> 00:05:27,170
όπου θέλω να βρόχο »τουλάχιστον μία φορά", αλλά ενδεχομένως περισσότερο.

68
00:05:27,170 --> 00:05:33,370
Ερωτήσεις ή -; Έχει κανείς χρησιμοποιείται ένα do-while loop οπουδήποτε αλλού;

69
00:05:33,370 --> 00:05:36,780
Εντάξει. Έτσι, η επόμενη θα είναι, "Τι σημαίνει αδήλωτη αναγνωριστικό

70
00:05:36,780 --> 00:05:43,310
συνήθως δείχνουν αν εξάγεται από την κλαγγή; "

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
Θα τρέξει αυτό - ω, εγώ δεν το κλικ. Έτσι, εδώ έχουμε - όλα τα δικαιώματα.

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
Έτσι, γιατί είναι αδήλωτη; Ναι.

81
00:06:26,060 --> 00:06:32,190
Έτσι, για να είναι σαφής σχετικά με την ορολογία, η δήλωση μιας μεταβλητής

82
00:06:32,190 --> 00:06:37,360
είναι όταν λέτε "int x," ή "string y," Ό, τι.

83
00:06:37,360 --> 00:06:41,910
Η αρχικοποίηση της μεταβλητής, ή η εκχώρηση της μεταβλητής,

84
00:06:41,910 --> 00:06:44,510
είναι κάθε φορά που λέτε "x = 2."

85
00:06:44,510 --> 00:06:52,950
Έτσι, μπορούμε να κάνουμε αυτά σε ξεχωριστά βήματα, int x, x = 2, και έως ότου - μπορούμε να έχουμε ένα σωρό πράγματα εδώ -

86
00:06:52,950 --> 00:07:00,350
αλλά μέχρι να συμβεί αυτή η γραμμή, x εξακολουθεί να έχει προετοιμαστεί, αλλά δεν έχει δηλωθεί.

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
Και τέλος, "Γιατί είναι το Cipher Caesar δεν είναι πολύ ασφαλής;"

90
00:07:18,390 --> 00:07:23,830
Έτσι, η πρώτη, δεν θέλει κανείς να πει ποιο είναι το Cipher Caesar είναι;

91
00:07:23,830 --> 00:07:28,100
[Φοιτητικό] Caesar Cipher είναι ακριβώς ότι θα χαρτογραφήσει, θα μετατοπιστεί κάθε γράμμα,

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
Αχ. Έτσι, θα πρέπει να επαναλάβουμε;

95
00:07:45,470 --> 00:07:51,600
Το Caesar Cipher, 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» στο Γεια σας, θα γίνει h-i-j-k-l-m-n.

101
00:08:16,560 --> 00:08:19,600
Έτσι, το πρώτο γράμμα θα είναι n. Εμείς κάνουμε το ίδιο πράγμα με το ηλεκτρονικό.

102
00:08:19,600 --> 00:08:23,530
Αν έχουμε ένα, όπως, z ή κάτι τέτοιο, τότε θα γυρίσει πίσω περίπου σε «ένα».

103
00:08:23,530 --> 00:08:29,280
Όμως, κάθε χαρακτήρας παίρνει εναλλάσσονται 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 πράγματα πρόκειται να είναι ευανάγνωστες,

107
00:08:46,860 --> 00:08:50,300
και το ευανάγνωστο κανείς δεν πρόκειται να είναι το αρχικό μήνυμα.

108
00:08:50,300 --> 00:08:56,240
Έτσι δεν είναι ένας πολύ καλός τρόπος για την κρυπτογράφηση οτιδήποτε.

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
Ναι. Γι 'αυτό θα απαντήσω επίσης με την επόμενη απάντηση - ή επανάληψη απαντώντας επίσης με μόνο το επόμενο.

113
00:09:18,160 --> 00:09:22,410
Μπορείτε να χρησιμοποιήσετε τις λειτουργίες και όχι μόνο αντιγραφή και επικόλληση του κώδικα ξανά και ξανά.

114
00:09:22,410 --> 00:09:27,200
Απλώς πάρτε αυτόν τον κώδικα, να το βάλετε σε ένα fuction, και τότε θα μπορούσαμε να ονομάσουμε μόνο τη λειτουργία

115
00:09:27,200 --> 00:09:29,870
όπου κι αν έχουν αντιγραφή και επικόλληση.

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
Το πρώτο. Έτσι, η ιδέα του πρώτου είναι, θα περάσει ένα string, και ανεξάρτητα από το -

119
00:09:46,490 --> 00:09:52,060
ή μήπως να πω όλα τα πεζά; Δεν λέει όλα πεζά.

120
00:09:52,060 --> 00:09:57,730
Έτσι, το μήνυμα μπορεί να είναι οτιδήποτε, και - Ω, όχι. Το κάνει.

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
μεταξύ κεφαλαίων και πεζών - αλλάζουμε το string να είναι κεφαλαία και πεζά, εναλλάξ.

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
Ω, τι έκανα απλά κάντε κλικ πάνω; Ω, απλά κάνετε κλικ σε ένα e-mail εδώ.

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
Εντάξει, ακόμα εδώ.

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, εντάξει.

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
Εντάξει. Μέχρι τότε δεν έχω να πάω πάνω από τα βασικά από αυτά, αλλά θα εξηγήσω

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
Τώρα, η δυαδική αναπαράσταση του χαρακτήρα πεζά γράμματα «a»

147
00:12:19,440 --> 00:12:33,350
πρόκειται να είναι το ίδιο πράγμα, σχεδόν. Είναι ότι - 6, ναι. Αυτό είναι σωστό.

148
00:12:33,350 --> 00:12:37,670
Έτσι δυαδικό κεφάλαιο Α, δυαδική πεζό «ένα».

149
00:12:37,670 --> 00:12:43,940
Έτσι, παρατηρούμε ότι η διαφορά μεταξύ Α και «a» είναι το ενιαίο κομμάτι.

150
00:12:43,940 --> 00:12:49,440
Και αυτό συμβαίνει να είναι η 32 bit, το bit που αντιπροσωπεύει τον αριθμό 32.

151
00:12:49,440 --> 00:12:53,910
Και αυτό είναι λογικό δεδομένου ότι είναι 65 A? «Α» είναι 97.

152
00:12:53,910 --> 00:12:56,610
Η διαφορά μεταξύ τους είναι 32.

153
00:12:56,610 --> 00:13:03,770
Έτσι τώρα ξέρουμε ότι μπορεί να μετατρέψει από Α σε «Α» από τη λήψη

154
00:13:03,770 --> 00:13:09,710
Oring και το bitwise, με - αυτό μοιάζει με ένα 1.

155
00:13:09,710 --> 00:13:20,900
Αυτό είναι ένα bitwise OR, με 00100000, και ότι θα μας δώσει «ένα».

156
00:13:20,900 --> 00:13:26,850
Και μπορούμε να πάρουμε από το «Α» σε Α από bitwise Anding

157
00:13:26,850 --> 00:13:33,700
με 11, 0 σε αυτή τη θέση, 11111.

158
00:13:33,700 --> 00:13:43,840
Έτσι, αυτό θα μας δώσει τότε ακριβώς τι «α» ήταν? Αλλά ακυρώσει την ατομική λίγο,

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
Όλα τα γράμματα, Κ vs k, Ζ vs z,

163
00:14:06,510 --> 00:14:10,080
όλοι τους είναι ακριβώς πρόκειται να διαφέρει από αυτό το μοναδικό κομμάτι.

164
00:14:10,080 --> 00:14:16,290
Και έτσι μπορείτε να χρησιμοποιήσετε αυτό για να αλλάξετε οποιαδήποτε από πεζό σε κάθε κεφαλαίο γράμμα και το αντίστροφο.

165
00:14:16,290 --> 00:14:26,670
Εντάξει. Έτσι, ένας εύκολος τρόπος για να πάρει από αυτό - έτσι, αντί να χρειάζεται να

166
00:14:26,670 --> 00:14:32,170
γράψτε ό, τι είναι 1011111 - ένας εύκολος τρόπος για να αντιπροσωπεύει τον αριθμό αυτό, και αυτό δεν είναι ένα

167
00:14:32,170 --> 00:14:39,710
ότι πήγα πάνω στο supersection, αλλά περισπωμένη (~) είναι μια άλλη 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
Αυτό είναι μόνο μερικά δυαδικό αριθμό, και τι ~ δεν είναι απλώς αντιστρέφει όλα τα bits.

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
ή θέλουμε τα πάντα, κάθε ενιαίο σύνολο λίγο εκτός για 1

178
00:15:44,710 --> 00:15:47,910
έχετε την τάση να κάνετε ~ από το κομμάτι που δεν θέλετε να ρυθμίσετε.

179
00:15:47,910 --> 00:15:53,090
Έτσι, δεν θέλουμε σύνολο των 32 bit, έτσι ώστε να μην ~ του 32.

180
00:15:53,090 --> 00:15:57,790
Εντάξει. Έτσι, μπορούμε να χρησιμοποιήσουμε όλα αυτά εδώ.

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
Πώς, λοιπόν, εμείς βρόχο πάνω από ένα string; Τι πρέπει να χρησιμοποιήσω;

185
00:16:26,710 --> 00:16:30,980
Είμαι δεν πρόκειται να το κάνει για εδώ. Ναι.

186
00:16:30,980 --> 00:16:42,940
Έτσι έχω iterator μου, και το είπε, αλλά πώς μπορώ να ξέρω πόσοι χαρακτήρες είναι στη σειρά;

187
00:16:42,940 --> 00:16:47,030
Strlen (-ες), τότε θ + +.

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
Επειδή είστε έλεγχο της γλώσσας του string κάθε φορά.

191
00:16:55,290 --> 00:17:06,859
Γι 'αυτό και πρόκειται να θέλουν να μετακινηθούν strlen, θα μπορούσα να πω εδώ, int length = 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
του μεταβλητού μήκους ακριβώς αυτό "για" βρόχο, αντί γι 'αυτό πριν από την κήρυξη

196
00:17:29,150 --> 00:17:34,990
και ότι υπάρχει πάντα, και σε περίπτωση που δεν πιάσει γιατί αυτό είναι κακό,

197
00:17:34,990 --> 00:17:39,410
ή γιατί η αρχική ήταν κακή, it's - ξεκινούν από το βρόχο for.

198
00:17:39,410 --> 00:17:43,380
Έλεγξα την κατάσταση. Είναι i <το μήκος του s;

199
00:17:43,380 --> 00:17:46,790
Έτσι, το μήκος του s, ας εργαστούμε με "γεια" ολόκληρο το χρόνο.

200
00:17:46,790 --> 00:17:49,670
Έτσι μήκος των s, h-ε-λ-λ-o. Μήκος είναι 5.

201
00:17:49,670 --> 00:17:57,580
Έτσι, i = 0, το μήκος είναι 5, γι 'αυτό δεν είναι <5, έτσι ώστε ο βρόχος συνεχίζει.

202
00:17:57,580 --> 00:18:02,750
Στη συνέχεια, πάμε πάλι. Ελέγχουμε την κατάσταση. Είναι i <το μήκος του γεια;

203
00:18:02,750 --> 00:18:08,390
Έτσι, ας ελέγξει το μήκος του γεια. H-e-l-l-o. Αυτό είναι 5? I δεν είναι <5, οπότε συνεχίζουμε και πάλι.

204
00:18:08,390 --> 00:18:13,330
Γι 'αυτό και τον υπολογισμό, υπολογίζουμε γειά σου, για κάθε επανάληψη του βρόχου,

205
00:18:13,330 --> 00:18:17,380
παρ 'όλο που ποτέ δεν πρόκειται να αλλάξει? είναι πάντα πρόκειται να είναι 5.

206
00:18:17,380 --> 00:18:22,530
Έτσι θυμόμαστε μόλις 5 μπροστά, και τώρα όλα είναι καλύτερα.

207
00:18:22,530 --> 00:18:24,990
Έτσι επανάληψη καθ 'όλη τη σειρά.

208
00:18:24,990 --> 00:18:31,470
Τι θέλουμε να κάνουμε για κάθε χαρακτήρα του string;

209
00:18:31,470 --> 00:18:38,510
[Μιλώντας Φοιτητών, ακατάληπτο]

210
00:18:38,510 --> 00:18:47,000
Ναι. Έτσι, αν ο χαρακτήρας είναι μη-αλφαβητικό, τότε απλά θέλετε να παρακάμψετε αυτό.

211
00:18:47,000 --> 00:18:52,300
Επειδή μόνο νοιάζονται για αλφαβητική γράμματα? Δεν μπορούμε να επωφεληθούμε από έναν αριθμό.

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
[Φοιτητικό] Μπορείτε να χρησιμοποιήσετε μόνο τη λειτουργία είναι άλφα.

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, να θυμάστε ότι ένα string είναι μια σειρά χαρακτήρων,

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
Ναι. Έτσι, αν s [i] είναι ≥ 65, και s [i] είναι ≤ 90, τι πρέπει να κάνω αντ 'αυτού;

222
00:20:07,860 --> 00:20:18,470
Ναι. Έτσι θα πρέπει να είναι απολύτως δεν χρειάζεται καν να γνωρίζουν τις τιμές 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
Και αυτό είναι πολύ καλύτερα - δεν ξέρω από την κορυφή του κεφαλιού μου ότι το Ζ είναι 90.

227
00:20:47,930 --> 00:20:52,690
Ξέρω από την κορυφή του κεφαλιού μου ότι «Ζ», είναι η πρωτεύουσα της Ζ.

228
00:20:52,690 --> 00:21:02,100
Έτσι, εφ 'όσον αυτό είναι της τάξεως του κεφαλαίου Α έως Ζ του κεφαλαίου, ή μπορούμε να ελέγξουμε για πεζούς,

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
Εκτός από ειδοποίηση ότι, όπως - είναι αυτή η περίπτωση; Ναι.

241
00:22:11,780 --> 00:22:18,270
Είναι κάθε άλλο, αλλά δεν μπορούμε να ενότητα 2 του i, ή i mod 2, αφού

242
00:22:18,270 --> 00:22:22,950
παρατηρήσετε ότι η Ε είναι η πρωτεύουσα και «a» είναι πεζό; Αλλά υπάρχει ένας χώρος που τους χωρίζει;

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
Ναι. Έτσι, είμαστε ακριβώς πρόκειται να κρατήσει μια καταμέτρηση.

246
00:22:34,690 --> 00:22:38,730
Θα μπορούσαμε να κάνουμε, επίσης, ότι εδώ αν θέλαμε? Αυτό ίσως πάρει λίγο δυσκίνητο

247
00:22:38,730 --> 00:22:41,300
στο βρόχο για τις δηλώσεις? Θα το βάλω εδώ.

248
00:22:41,300 --> 00:22:48,840
Έτσι, int count = ξεκινά από το 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; Αχ. Θα κάνω == 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 περιπτώσεις? Κεφαλαία και πεζά γράμματα είναι οι 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 έχουν γυρίσει -

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
Μήπως κεφαλαία Μια αλλαγή, ή αλλάζει η τιμή;

264
00:24:11,900 --> 00:24:23,100
Ναι. Έτσι, κάθε κεφαλαίο γράμμα bitwise ANDed με ~ 32 θα είναι το ίδιο κεφαλαίο χαρακτήρα

265
00:24:23,100 --> 00:24:29,220
επειδή για κάθε κεφαλαίο χαρακτήρα η 32η κομμάτι δεν έχει οριστεί.

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 bit, θα μπορούσε να είναι η 64 bit, θα μπορούσε να είναι το 128 bit.

273
00:25:09,110 --> 00:25:13,990
Οποιαδήποτε από αυτές τις bits θα μπορούσε να είναι το κομμάτι που κάνει διάκριση μεταξύ πεζών και κεφαλαίων.

274
00:25:13,990 --> 00:25:18,350
Δεν πρέπει να πρέπει να ξέρετε ότι είναι το 32 bit.

275
00:25:18,350 --> 00:25:27,130
Μπορώ να χρησιμοποιήσω αυτό το «α» - Μια για να πάρει το κομμάτι που διαφέρει μεταξύ των δύο

276
00:25:27,130 --> 00:25:33,000
χωρίς να χρειάζεται να επικαλεστεί το μαγικό αριθμό που είναι 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
[Φοιτητικό] Θα ότι η στρατηγική της αφαιρώντας τα κεφαλαία από τα πεζά έργο αν δεν ήταν 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, εφ 'όσον όλα τα bits κάτω από αυτή τη θέση είναι το ίδιο.

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
Η διαφορά μεταξύ του Α και «a» πρέπει να είναι τουλάχιστον 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 bits, να εκπροσωπεί τα πάντα μέσω Z.

299
00:27:23,900 --> 00:27:32,170
Γι 'αυτό το επόμενο κομμάτι, ή αυτό το κομμάτι, το επόμενο κομμάτι είναι το ένα που είναι επιλέχθηκε να γίνει διάκριση μεταξύ Α και «ένα».

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 - η διαφορά θα μπορούσε επίσης να είναι και τα δύο από αυτά τα bits.

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
Είναι μόλις τώρα η διαφορά μεταξύ Α και «a» εξακολουθεί να είναι αυτά τα 2 bits.

307
00:28:22,650 --> 00:28:32,240
Νομίζω ότι είναι γραμμένο 48. Είναι 32 + 64; Νομίζω ότι είναι;

308
00:28:32,240 --> 00:28:40,160
Θα εξακολουθεί να είναι 2 bits? Κάθε χαρακτήρα, όπως, Ζ και z, K και k,

309
00:28:40,160 --> 00:28:45,160
θα εξακολουθούν να έχουν τα ίδια ακριβώς κομμάτια που εκτός από τα 2 bits.

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
μπορείτε να απαλλαγείτε από τα άγκιστρα? γι 'αυτό τείνουν να προτιμούν να γίνει αυτό.

316
00:29:24,280 --> 00:29:34,010
Επίσης, ξέρετε πώς μπορούμε να κάνουμε τα πράγματα όπως s [i] + = 1;

317
00:29:34,010 --> 00:29:41,090
Μπορείτε επίσης να κάνετε s [i] bitwise AND = 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
Θα μπορούσατε να τα συνδυάσετε με τριμερή αν θέλετε, αλλά τότε αυτό θα κάνει τα πράγματα απλά Μεσιέ

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
Είναι ότι όλοι το πρόβλημα ζήτησε; Ω ναι.

330
00:30:41,580 --> 00:30:51,070
Έτσι, να απαλλαγούμε από αυτές τις κενές γραμμές, τώρα θα εκτυπώσετε f,% 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
Εντάξει. Τώρα θα το τρέξει. Είναι κατά πάσα πιθανότητα θα μου φωνάζεις.

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
αντί του ΣΣΚ που απλά λέει, "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
Αλλά εμείς θα κάνουμε το παράδειγμά τους, "Thanks 4 the add".

341
00:31:42,540 --> 00:31:47,880
Αυτό φαίνεται σωστό. Ζήτω.

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
Εντάξει. Έτσι τώρα το δεύτερο πρόβλημα.

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 μεταβλητές, A, η οποία είναι απλώς ένας ακέραιος

358
00:33:12,130 --> 00:33:17,800
ότι θα μου δώσει, και ποσό μεταβλητή Β, το οποίο είναι ένα άλλο ακέραιο ότι είμαι δεδομένη.

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
Θα μπορούσαμε να ανταλλάξουν κάνοντας κάτι σαν α = α + β, και β = α - β, α = α - β.

364
00:33:52,980 --> 00:34:04,260
Έτσι, λογική ελέγχου, και στη συνέχεια, θα δούμε ότι τα έργα γιατί.

365
00:34:04,260 --> 00:34:13,320
Ας πούμε ότι α = 7, β = 3, τότε α + β πρόκειται να είναι 10.

366
00:34:13,320 --> 00:34:18,820
Έτσι, είμαστε πλέον μια ρύθμιση = 10, και στη συνέχεια να κάνουμε β = α - β.

367
00:34:18,820 --> 00:34:30,250
Έτσι κάνουμε β = α - β, το οποίο θα είναι 7 και β = α - β και πάλι,

368
00:34:30,250 --> 00:34:38,650
ή α = α - β. Η οποία θα είναι 10 με 7 που είναι 3.

369
00:34:38,650 --> 00:34:44,850
Έτσι τώρα, σωστά, «α» ήταν 7, β ήταν 3, και β τώρα είναι 7 και «a» είναι 3.

370
00:34:44,850 --> 00:34:48,679
Έτσι, αυτό το είδος της νόημα? «Α» είναι ο συνδυασμός των 2 αριθμών.

371
00:34:48,679 --> 00:34:53,000
Σε αυτό το σημείο, «α» είναι ο συνδυασμός, και στη συνέχεια να είμαστε αφαιρώντας από το αρχικό β,

372
00:34:53,000 --> 00:34:56,860
και στη συνέχεια να είμαστε αφαιρώντας από αυτό που ήταν η αρχική «ένα».

373
00:34:56,860 --> 00:35:01,150
Αλλά αυτό δεν λειτουργεί για όλους τους αριθμούς.

374
00:35:01,150 --> 00:35:08,880
Για να το δούμε αυτό, ας θεωρήσουμε ένα σύστημα? Έτσι σκεφτόμαστε συνήθως ακέραιοι ως 32 bit.

375
00:35:08,880 --> 00:35:13,050
Ας εργαστούμε για κάτι που είναι μόνο σαν 4 bits.

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
Στην πραγματικότητα δεκαδικά ψηφία, αν θέλετε να σκεφτώ με αυτόν τον τρόπο, α = 15 και β = 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
Έτσι, το πρώτο μας βήμα είναι a = a + b.

386
00:36:01,780 --> 00:36:08,770
Αριθμοί μας είναι μόνο 4 bits ευρύ, έτσι «ένα», η οποία είναι 1111, β +, το οποίο είναι 0001,

387
00:36:08,770 --> 00:36:16,780
πρόκειται να καταλήγουν να είναι 10000, αλλά έχουμε μόνο 4 bits.

388
00:36:16,780 --> 00:36:22,540
Έτσι τώρα ένα = 0.

389
00:36:22,540 --> 00:36:34,080
Και τώρα θέλουμε να θέσουμε β = α - β - στην πραγματικότητα, αυτό εξακολουθεί να λειτουργεί τέλεια.

390
00:36:34,080 --> 00:36:39,630
α = α - β - ας δούμε αν αυτό λειτουργεί τέλεια.

391
00:36:39,630 --> 00:36:53,720
Έτσι, τότε β = 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
Εντάξει, έτσι εργάζεται με βάση την υπόθεση ότι δεν λειτουργεί με τακτικές δυαδικές πράξεις,

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 έτσι ώστε να δρα σιγά-σιγά, και it's -

399
00:37:34,610 --> 00:37:39,910
Εάν έχετε τα bits 0 και 1, τότε αυτό θα είναι 1.

400
00:37:39,910 --> 00:37:45,230
Εάν έχετε τα bits 1 και 0, θα είναι 1, θα έχουν τα bits 0 και 0 αυτό θα είναι 0,

401
00:37:45,230 --> 00:37:47,640
και αν έχετε τα bits 1 και 1 που θα είναι 0.

402
00:37:47,640 --> 00:37:56,180
Έτσι είναι σαν OR. Εάν οποιοδήποτε από τα bits είναι αλήθεια, είναι 1, αλλά σε αντίθεση με OR, δεν μπορεί να είναι αμφότερα τα bits που είναι αληθείς.

403
00:37:56,180 --> 00:37:59,320
Ή αυτό θα είναι 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.

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 bits, έτσι και τώρα «α» είναι 0,

411
00:38:44,940 --> 00:38:48,730
ότι είναι αυτό που ονομάζεται «υπερχείλιση ακεραίου."

412
00:38:48,730 --> 00:38:54,370
Σύμφωνα με τη Wikipedia, "Σε αντίθεση με τη συμφωνία ανταλλαγής XOR, η τροποποίηση απαιτεί ότι χρησιμοποιεί ορισμένες μεθόδους

413
00:38:54,370 --> 00:38:59,780
να εγγυηθεί ότι x + y δεν προκαλεί έναν ακέραιο υπερχείλιση ".

414
00:38:59,780 --> 00:39:08,350
Έτσι, αυτό δεν έχει προβλήματα? Αυτό ήταν υπερχείλιση ακεραίου, αλλά έκανα κάτι λάθος.

415
00:39:08,350 --> 00:39:10,520
Δεν είμαι σίγουρος. Θα προσπαθήσω να καταλήξουμε με ένα άλλο.

416
00:39:10,520 --> 00:39:13,640
[Φοιτητικό] Λοιπόν, δεν είναι ακέραιος υπερχείλιση όταν προσπαθείτε να βάλετε μια σειρά εκεί

417
00:39:13,640 --> 00:39:16,640
μεγαλύτερο από το ποσό των bits που έχουν διαθέσει;

418
00:39:16,640 --> 00:39:23,730
Ναι. Έχουμε 4 bits. That's - είχαμε 4 bits, που στη συνέχεια, δοκιμάστε να προσθέσετε 1 σε αυτό, έτσι ώστε να καταλήξουμε με 5 bits.

419
00:39:23,730 --> 00:39:26,690
Αλλά το πέμπτο κομμάτι μόνο αποκόπτεται, ναι.

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
Όχι λοιπόν δεν υπάρχει σφάλμα. Όταν φτάσετε στο επίπεδο συναρμολόγησης, ένα ειδικό κομμάτι

423
00:39:40,720 --> 00:39:47,020
κάπου έχει οριστεί ότι είπε ότι υπάρχει μια υπερχείλιση, αλλά σε C κατά κάποιο τρόπο απλά δεν ασχολούνται με αυτό.

424
00:39:47,020 --> 00:39:55,160
Μπορείτε πραγματικά δεν μπορεί να ασχοληθεί με το θέμα εκτός και αν χρησιμοποιείτε ειδικές οδηγίες συναρμολόγησης σε C.

425
00:39:55,160 --> 00:39:58,110
Ας σκεφτούμε ανταλλαγής XOR.

426
00:39:58,110 --> 00:40:02,220
Και νομίζω ότι το άρθρο της Wikipedia μπορεί να έχουν επίσης λέγοντας ότι -

427
00:40:02,220 --> 00:40:07,310
Γι 'αυτό και μεγάλωσε modular αριθμητική, οπότε υποθέτω ότι ήταν, θεωρητικά, να κάνει modular αριθμητική

428
00:40:07,310 --> 00:40:11,160
όταν είπα ότι 0 - 1 είναι 15 και πάλι.

429
00:40:11,160 --> 00:40:15,410
Έτσι που θα μπορούσε στην πραγματικότητα - σε τακτική επεξεργαστή που κάνει 0 - 1 = 15.

430
00:40:15,410 --> 00:40:20,430
Από τη στιγμή που καταλήγουν σε 0, αφαιρούμε 1, έτσι ώστε στη συνέχεια να τυλίγει ακριβώς πίσω γύρω στο 1111.

431
00:40:20,430 --> 00:40:28,930
Έτσι, ο αλγόριθμος αυτός μπορεί πραγματικά να λειτουργήσει, η α + β, το α - β, β - α? Που θα μπορούσε να είναι μια χαρά.

432
00:40:28,930 --> 00:40:34,030
Αλλά υπάρχουν μερικοί επεξεργαστές που δεν το κάνουμε αυτό, και γι 'αυτό δεν θα ήταν μια χαρά σε αυτές τις συγκεκριμένες αυτές.

433
00:40:34,030 --> 00:40:39,880
Ανταλλαγής XOR θα λειτουργήσει σε οποιοδήποτε επεξεργαστή. Εντάξει.

434
00:40:39,880 --> 00:40:42,280
Η ιδέα είναι ότι υποτίθεται ότι είναι το ίδιο, όμως.

435
00:40:42,280 --> 00:40:50,120
Όταν χρησιμοποιούμε XOR για να πάρει με κάποιον τρόπο τα στοιχεία και των δύο σε 1 από τις μεταβλητές,

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 είναι αντιμεταθετική.

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
Έτσι, ένα ^ β ^ β είναι ένα.

443
00:41:35,800 --> 00:41:51,860
Μπορείτε επίσης να δείτε αυτό γραμμένο ως ^ = β, β ^ = α, α = β ^ ξανά.

444
00:41:51,860 --> 00:42:00,200
Έτσι, αυτό είναι σωστό, και να δείτε γιατί αυτό λειτουργεί, σκεφτείτε τα κομμάτια.

445
00:42:00,200 --> 00:42:10,400
Χρησιμοποιώντας ένα μικρούλης αριθμό, ας πούμε 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
Εμείς πάμε για να τον καθορισμό = 'Α' στην 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
δεν πρόκειται να δούμε πολλά από μια σχέση μεταξύ του αρχικού «Α» και το νέο «a»,

452
00:42:41,160 --> 00:42:45,600
αλλά κοιτάζοντας τα bits, «a» είναι τώρα σαν ένα πλέγμα των πληροφοριών

453
00:42:45,600 --> 00:42:49,970
τόσο της αρχικής «Α» και το αρχικό β.

454
00:42:49,970 --> 00:42:57,930
Έτσι, αν λάβουμε ^ α β, βλέπουμε ότι θα καταλήξετε στο αρχικό «a».

455
00:42:57,930 --> 00:43:08,910
Και αν πάρουμε το αρχικό «α» ^ το νέο «α,« βλέπουμε καταλήγουμε στο αρχικό β.

456
00:43:08,910 --> 00:43:18,380
Έτσι (α ^ β) ^ β = του αρχικού «α».

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, όλα τα bits που πρόκειται να είναι το ίδιο.

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
Το ίδιο με αυτό. (Α ^ β) ^ β είναι σαν ^ (β ^ β).

463
00:43:57,240 --> 00:44:03,680
(Β ^ β) θα είναι 0? A ^ 0 είναι ακριβώς πρόκειται να είναι «ένα», αφού όλα τα κομμάτια είναι 0.

464
00:44:03,680 --> 00:44:08,050
Έτσι, οι μόνοι που πρόκειται να είναι όπου «α» ήταν αρχικά ένα 1 - είχαν αυτά.

465
00:44:08,050 --> 00:44:12,070
Και η ίδια η ιδέα εδώ? Είμαι απόλυτα βέβαιος ότι είναι επίσης αντιμεταθετική.

466
00:44:12,070 --> 00:44:17,590
Ναι. Είχα πει πριν ότι ήταν ευμετάβλητη.

467
00:44:17,590 --> 00:44:24,680
Το ^ 'α, και είναι συνειρμική, έτσι και τώρα (β ^ α) ^ α.

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
Έτσι, «a» είναι τώρα ο συνδυασμός του «ενός» και β μαζί.

471
00:44:37,120 --> 00:44:49,660
Χρησιμοποιώντας το νέο combo μας «α» λέμε β = combo 'α' ^ η αρχική β, παίρνουμε το αρχικό «a».

472
00:44:49,660 --> 00:45:05,170
Και τώρα ένα σύνθετο = 'α' ^ το νέο b, που ήταν η αρχική - ή που είναι πλέον αυτό που ήταν «α» ή β.

473
00:45:05,170 --> 00:45:13,620
Αυτό είναι η υπόθεση αυτή εδώ κάτω. Αυτό είναι = b, b παλιά.

474
00:45:13,620 --> 00:45:16,550
Μέχρι τώρα όλα είναι πίσω στο αντάλλαξαν σειρά.

475
00:45:16,550 --> 00:45:22,960
Αν θέλουμε πραγματικά κοίταξε τα κομμάτια, b = a ^ b, πρόκειται να XOR αυτά τα 2,

476
00:45:22,960 --> 00:45:33,920
και η απάντηση θα είναι αυτό, και τότε a = a ^ b είναι XORing αυτά τα 2 και η απάντηση είναι αυτή.

477
00:45:33,920 --> 00:45:41,090
Ερωτήσεις; Εντάξει. Έτσι, η τελευταία είναι κάπως πολύ πιο δύσκολη.

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
Και αυτό οφείλεται στο γεγονός ότι τη στιγμή που θα καταρτίζονται κάτω - τόσο σε επίπεδο συναρμολόγησης,

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
Και να σας φέρει τα πράγματα από τη μνήμη σε μητρώα για να προσθέσει στη συνέχεια,

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
Και μετά από αυτό το σημείο και μετά, αφού έχετε τους αντάλλαξαν,

492
00:46:46,570 --> 00:46:51,540
αυτό ακριβώς θα αρχίσουν να χρησιμοποιούν το άλλο καταχωρητή.

493
00:46:51,540 --> 00:46:56,510
Οπουδήποτε και αν είχε τη χρήση β, αυτό θα χρησιμοποιήσετε μόνο το μητρώο που έχει ήδη την αποθήκευση «ένα».

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
Όπως και αν χρησιμοποιείτε αργότερα ότι η προσωρινή μεταβλητή και πάλι κάπου,

498
00:47:14,830 --> 00:47:18,920
τότε - ή να εκχωρήσετε κάτι σε αυτό προσωρινή μεταβλητή.

499
00:47:18,920 --> 00:47:24,630
Έτσι, αν σε οποιαδήποτε χρονική στιγμή «α, β 'στη θερμοκρασία έχουν διαφορετικές τιμές ή κάτι,

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
Εντάξει. Τελευταία ερώτηση είναι λίγο περισσότερο.

504
00:47:58,620 --> 00:48:04,850
Έτσι, εδώ, σε αυτή τη συσκευή CS50, υπάρχει ένα λεξικό.

505
00:48:04,850 --> 00:48:12,390
Και ο λόγος για αυτό είναι επειδή [? Β66] είναι ένα ορθογραφικό έλεγχο, όπου θα σας γραπτώς

506
00:48:12,390 --> 00:48:15,780
χρησιμοποιώντας πίνακες κατακερματισμού ή χώρες ή κάποια δομή δεδομένων.

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
και στη συνέχεια να αναζητούν πάνω από ένα ολόκληρο έγγραφο για να δούμε αν κάτι είναι ορθογραφικά λάθη,

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
Εδώ λέει ότι θέλουμε να αρχίσετε να ψάχνετε σε αρχείο χειρισμού λειτουργίας Γ,

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
Έτσι, τα κυριότερα από τα οποία θα θελήσετε να εξετάσετε είναι στ ανοικτά και τότε, αναπόφευκτα, στ κλειστό,

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 σάρωση f είναι τι πρόκειται να χρησιμοποιείτε για να σαρώσετε πάνω από το λεξικό.

523
00:49:41,880 --> 00:49:46,370
Και έτσι δεν χρειάζεται να κωδικοποιήσει τη λύση, απλώς προσπαθήστε και όπως ψευδο-κώδικα τον τρόπο σας

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
αλλά ο άνθρωπος, έτσι ώστε οι σελίδες man, είναι αρκετά χρήσιμο για την εξέταση σχεδόν κάθε λειτουργία.

528
00:50:23,490 --> 00:50:27,330
Έτσι, μπορώ να κάνω, όπως, στ άνθρωπος, σάρωση στ.

529
00:50:27,330 --> 00:50:32,300
Αυτό είναι τώρα οι πληροφορίες για την οικογένεια στ σάρωση των λειτουργιών.

530
00:50:32,300 --> 00:50:37,070
Θα μπορούσα να κάνω και στ άνθρωπος, ανοιχτή, και ότι θα μου δώσει τις λεπτομέρειες για αυτό.

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
[Φοιτητικό] Έτσι είμαι διαβάζοντας την σελίδα man για ανοιχτό, αλλά είμαι εξακολουθούν να έχουν συγκεχυμένη για το πώς να το χρησιμοποιήσετε και το πρόγραμμα.

538
00:51:03,010 --> 00:51:06,170
Εντάξει. Πολλές από τις σελίδες άνθρωπος είναι λιγότερο από ό, τι χρήσιμο.

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 f σάρωσης, επίσης. Σας δίνει τις πληροφορίες για όλες αυτές τις λειτουργίες,

543
00:51:22,220 --> 00:51:28,120
και 1 γραμμή προς τα κάτω εδώ συμβαίνει να πει, "F σάρωση στ διαβάζει από το σημείο string ή ρεύμα."

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 είναι τώρα η μεταβλητή που πρόκειται να χρησιμοποιήσετε για να αναπαραστήσει το αρχείο.

559
00:52:46,470 --> 00:52:49,850
Έτσι, εάν θέλετε να διαβάσετε από το αρχείο, μπορείτε να διαβάσετε από f.

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
Κοιτάζοντας τη σελίδα man εδώ, βλέπουμε int f 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
Θα σας δώσω ένα string format αυτή τη στιγμή.

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
Έτσι, στ εκτύπωσης, στ εκτύπωσης που χρησιμοποιούν επίσης αυτό το είδος της παραμέτρου μορφής,

573
00:54:17,160 --> 00:54:25,000
αλλά στην εκτύπωση στ αυτό που κάνουμε είναι - ας ρίξουμε μια ματιά σε ένα ισοδύναμο.

574
00:54:25,000 --> 00:54:32,550
Έτσι εκτύπωση στ, και δεν υπάρχει στην πραγματικότητα και στ στ εκτύπωσης, όπου το πρώτο όρισμα θα είναι στ.

575
00:54:32,550 --> 00:54:40,980
Όταν εκτυπώνετε στ, θα μπορούσαμε να πούμε κάτι σαν, "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 »στο στ εκτύπωσης,

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
Ας χρησιμοποιήσουμε πραγματικά στ σάρωση σε ένα διαφορετικό παράδειγμα.

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
Έτσι, αυτό θα μπορούσε να είναι ένα πρόγραμμα όπου θα έχετε μετρητή ποσό,

591
00:55:51,870 --> 00:55:56,420
Συνοψίζοντας την αντιμετώπιση i, και θέλετε να αποθηκεύσετε μια δέσμη των εικόνων.

592
00:55:56,420 --> 00:56:02,430
Έτσι θέλετε να αποθηκεύσετε i.jpg, όπου θ είναι κάποια επανάληψη του βρόχου σας.

593
00:56:02,430 --> 00:56:05,500
Επομένως, πώς θα κάνουν αυτή τη σειρά για το JPEG;

594
00:56:05,500 --> 00:56:11,720
Αν θέλετε να εκτυπώσετε 4.jpg, θα μπορούσαμε να πούμε ακριβώς στ εκτύπωσης, 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
Θέλουμε να αποθηκεύσετε - "οικογένεια στ σάρωσης των λειτουργιών σάρωσης και στα δύο ανάλογα με τη μορφή, όπως προσπάθησε παρακάτω.

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
Έτσι σάρωση f δεν - τι στο καλό είναι η λειτουργία που το κάνει αυτό;

614
00:58:26,350 --> 00:58:31,650
Έτσι σάρωση f δεν πρόκειται να λάβει έναν ακέραιο και να κάνει dot jpg.

615
00:58:31,650 --> 00:58:43,490
Είναι πρόκειται να [μουρμουρίζει].

616
00:58:43,490 --> 00:58:49,360
Αποθήκευση int μεταβλητή int σε σειρά C.

617
00:58:49,360 --> 00:58:55,940
Τι είναι αυτή η μεταβλητή, ή τι είναι αυτό που ονομάζεται λειτουργία;

618
00:58:55,940 --> 00:59:04,950
Ναι. That's - ναι. Έτσι, αυτό που καθορίζει σε σας πριν ήταν s εκτύπωση στ,

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
Έτσι, αγνοούν ότι εντελώς. Μπορείτε να εξακολουθούν να πιστεύουν του προσδιοριστή μορφή που, όπως εκείνη του στ εκτύπωσης.

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
Έτσι, αυτό ήταν - είναι λιγότερο Σχετική να σάρωση στ στ τώρα? Ελπίζουμε, θα συνδέσει πίσω σε κάποιο είδος της τρόπο.

629
00:59:52,710 --> 01:00:02,240
Αλλά ό, τι αρχικά είχε την πρόθεση να δείξει ήταν - αυτό είναι πραγματικά άμεση σχέση με αυτά τα [; F5]

630
01:00:02,240 --> 01:00:08,520
Θα πάμε να χρησιμοποιούν s στ εκτύπωσης, όπου, για παράδειγμα έχουμε 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
Έτσι, προκειμένου να το κάνουμε αυτό, θα πρέπει να στ ανοικτά, και στη συνέχεια θα πρέπει να περάσει στη σειρά που θέλετε να ανοίξετε.

633
01:00:21,520 --> 01:00:30,020
Γι 'αυτό και θα θέλετε να ανοίξετε 1.jpg? Προκειμένου να δημιουργηθεί το string που είναι 1.jpg,

634
01:00:30,020 --> 01:00:37,660
στ εκτύπωσης κάνουμε s% του D.jpg--εμείς δεν κάνουμε για int i = 0.

635
01:00:37,660 --> 01:00:46,580
θ <40, i + +.

636
01:00:46,580 --> 01:00:51,130
Έτσι% s στ εκτύπωσης D.jpg του i.

637
01:00:51,130 --> 01:00:56,320
Έτσι, μετά από αυτή τη γραμμή, τώρα η μεταβλητή ή η σειρά s πρόκειται να 1.jpg.

638
01:00:56,320 --> 01:01:10,610
Ή, 0.jpg, 1.jpg, 2.jpg. Και έτσι μπορούμε να ανοίξουμε, με τη σειρά του, κάθε εικόνα για ανάγνωση.

639
01:01:10,610 --> 01:01:19,550
Έτσι, αυτό είναι ό, τι s εκτύπωση στ κάνει. Βλέπετε τι s εκτύπωση στ κάνει τώρα;

640
01:01:19,550 --> 01:01:25,720
[Φοιτητικό] Εντάξει, έτσι αυτό είναι που - δημιουργεί ένα string, something.jpg, και στη συνέχεια το αποθηκεύει.

641
01:01:25,720 --> 01:01:30,360
Ναι. Δημιουργεί - αυτό είναι μια άλλη συμβολοσειρά μορφής, όπως ακριβώς και στ σάρωσης και εκτύπωσης στ,

642
01:01:30,360 --> 01:01:37,530
όταν εισάγει όλα από τις μεταβλητές στο δεύτερο όρισμα, θα μπορούσε να είναι s σε αντίθεση με i.

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
και στη συνέχεια να αποθηκεύσετε σε ρυθμιστικό μας? λέμε ότι ένα ρυθμιστικό, είναι όπου είμαστε αποθήκευση του string.

646
01:01:52,250 --> 01:02:00,750
Γι 'αυτό και αποθήκευση μέσα από το s-σωστά μορφοποιημένο string,% d έχει αντικατασταθεί με 4.

647
01:02:00,750 --> 01:02:08,080
[Φοιτητικό] Έτσι, αν το κάναμε αυτό, είναι η μεταβλητή f ακριβώς πρόκειται να ανατεθεί εκ νέου;

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
Ναι. Αλλά θα ανοίξει εκατό διαφορετικά αρχεία.

651
01:02:29,280 --> 01:02:37,360
[Φοιτητών], όμως, δεν θα είναι σε θέση να έχουν πρόσβαση ή - εντάξει.

652
01:02:37,360 --> 01:02:44,230
Εντάξει. Έτσι σάρωση στ, στ στ σάρωσης, είναι το είδος της ίδιας ιδέας,

653
01:02:44,230 --> 01:02:53,610
αλλά αντί, αντί για την αποθήκευση του σε μια σειρά, είναι περισσότερο σαν να είναι τώρα

654
01:02:53,610 --> 01:03:02,420
πηγαίνει πέρα ​​από ένα τσίμπημα και μοτίβο που ταιριάζουν κατά της εν λόγω σειράς και την αποθήκευση των αποτελεσμάτων σε μεταβλητές.

655
01:03:02,420 --> 01:03:11,290
Μπορείτε να χρησιμοποιήσετε σάρωση f για να αναλύσει πάνω από κάτι σαν 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
Έτσι, όταν λέτε, "να πάρει int," είναι σάρωση f-σης πάνω - scan f είναι ο τρόπος για να πάρετε είσοδο του χρήστη.

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
και, επίσης, στ στ σάρωση, νομίζω, θα σταματήσει στη νέα γραμμή δεν έχει σημασία τι.

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
Τι κάναμε με σάρωση f παίρνει κάθε λέξη στο λεξικό,

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
Έτσι, αναπόφευκτα, θα πάμε να καταλήξετε να κάνει ένα μάτσο σάρωσης 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, τότε μπορούμε να τυπώσουμε στ, σε συνδυασμό,

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
Γι 'αυτό θα ταιριάζει με αυτή τη λέξη, αλλά αυτό το υποσύνολο της λέξης δεν είναι ίδια η λέξη.

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
Μπορώ να στείλετε τις λύσεις οριστικοποιηθεί αργότερα.

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
Αχ, δεν μπορώ να απαλλαγούμε από ότι πριν; Char s, υποθέτω είπαμε 127 - ξεχάσω τι είναι η μεγαλύτερη.

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