1
00:00:00,000 --> 00:00:00,500

2
00:00:00,500 --> 00:00:02,500
ZAMYLA Chan: Είναι μια μένα, Zamyla.

3
00:00:02,500 --> 00:00:06,910
Σήμερα στο Mario, θα πάμε να είναι
αντλώντας το μισό πυραμίδα για τον Mario

4
00:00:06,910 --> 00:00:08,290
να ανέβει.

5
00:00:08,290 --> 00:00:11,570
>> Έτσι, ας μιλήσουμε για μας
να-κάνουμε για αυτό το πρόβλημα.

6
00:00:11,570 --> 00:00:13,610
Εμείς πάμε να θέλουν
να παρακινήσει και να επικυρώσει

7
00:00:13,610 --> 00:00:18,290
ο χρήστης για μια έγκυρη είσοδο του πώς
υψηλή θέλουν πυραμίδα του Mario να είναι.

8
00:00:18,290 --> 00:00:20,090
Και τότε, θα πάμε να το σχεδιάσετε.

9
00:00:20,090 --> 00:00:24,870
Ας ξεκινήσουμε με την προτροπή και
επικύρωση από το χρήστη για τη συμβολή τους.

10
00:00:24,870 --> 00:00:27,640
>> Μπορούμε να κάνουμε χρήση του
Λειτουργία CS50 Βιβλιοθήκη

11
00:00:27,640 --> 00:00:31,160
πάρετε int που θα εξασφαλίσει ότι
ο χρήστης εισάγει έναν ακέραιο.

12
00:00:31,160 --> 00:00:35,730
Τυχόν θετική ακέραιοι, αρνητικό
ακέραιοι, ο αριθμός 0 είναι όλα δίκαιο παιχνίδι.

13
00:00:35,730 --> 00:00:41,670
Σε αντίθετη περίπτωση, ο χρήστης θα σας ζητηθεί να
επαναλάβετε μέχρι να εισάγετε ένα έγκυρο ακέραιο.

14
00:00:41,670 --> 00:00:44,210
Τώρα αν πάρει int κάνει
πολλή δουλειά για εμάς

15
00:00:44,210 --> 00:00:46,730
στην εξασφάλιση ότι η
χρήστης μας δίνει έναν ακέραιο,

16
00:00:46,730 --> 00:00:50,760
πρέπει ακόμα να εφαρμόσει κάποια
πρόσθετους περιορισμούς σε αυτό.

17
00:00:50,760 --> 00:00:56,420
Μετά από όλα, δεν μπορούμε να έχουμε Mario αναρρίχηση
μισή πυραμίδα ύψους αρνητική 12.

18
00:00:56,420 --> 00:00:59,040
>> Εκτός από αυτό, το
προδιαγραφή πρόβλημα

19
00:00:59,040 --> 00:01:02,490
λέει ότι μπορούμε μόνο να
επιτρέπουν Mario να αναρριχηθεί

20
00:01:02,490 --> 00:01:06,940
μια πυραμίδα ύψη μεταξύ 0 και 23.

21
00:01:06,940 --> 00:01:11,120
Εντάξει, έτσι αυτό σημαίνει ότι χρειαζόμαστε
να ζητήσει συνεχώς το χρήστη

22
00:01:11,120 --> 00:01:14,320
να μας δώσει μια έγκυρη
αριθμό και μόνο να συνεχίσει

23
00:01:14,320 --> 00:01:17,120
από τη στιγμή που μας έχετε δώσει ένα έγκυρο ύψος.

24
00:01:17,120 --> 00:01:18,720
Πώς θα το κάνουμε αυτό;

25
00:01:18,720 --> 00:01:23,760
>> Λοιπόν, συνεχείς διεργασίες μας δώσει
η ιδέα της loops-- κάνουμε κάτι

26
00:01:23,760 --> 00:01:24,720
επανειλημμένα.

27
00:01:24,720 --> 00:01:28,220
Ένας βρόχος σε C ως μια στιγμή
βρόχο που θα συνεχώς

28
00:01:28,220 --> 00:01:33,480
εκτελέσει το σώμα του βρόχου όσο
η δεδομένη κατάσταση είναι αληθής.

29
00:01:33,480 --> 00:01:36,200
Το συντομότερο αυτή την κατάσταση
ψευδής,

30
00:01:36,200 --> 00:01:39,770
το πρόγραμμα θα προχωρήσει σε
ό, τι έρχεται μετά από αυτό.

31
00:01:39,770 --> 00:01:43,180
Έτσι, ενώ βρόχοι είναι ένας τρόπος
διασφαλίζοντας ότι είμαστε συνεχώς

32
00:01:43,180 --> 00:01:45,320
ζητήσει από το χρήστη για μια έγκυρη εισόδου.

33
00:01:45,320 --> 00:01:50,070
Και τη στιγμή που θα μας δώσει μια έγκυρη είσοδο,
θα προχωρήσει σε ό, τι έρχεται το επόμενο.

34
00:01:50,070 --> 00:01:54,380
Ξέρουμε ότι θα πάμε να ζητήσουμε
ο χρήστης για είσοδο τουλάχιστον μία φορά.

35
00:01:54,380 --> 00:01:59,200
Έτσι τώρα έχουμε έρθει σε μια αδελφή της
ενώ βρόχο, το οποίο είναι το do while loop.

36
00:01:59,200 --> 00:02:02,650
>> Κάνουμε, ενώ βρόχους θα εκτελέσει το
σώμα του βρόχου τουλάχιστον μία φορά.

37
00:02:02,650 --> 00:02:06,150
Έτσι, χωρίς να ελέγξει την κατάσταση,
θα εκτελέσει το σώμα του βρόχου.

38
00:02:06,150 --> 00:02:09,750
Και στη συνέχεια, ελέγξτε την κατάσταση για να δείτε
αν πρέπει να επαναληφθεί.

39
00:02:09,750 --> 00:02:13,080
Αυτό έρχεται σε βολικό όταν
είμαστε επικύρωση εισόδου του χρήστη.

40
00:02:13,080 --> 00:02:15,830
Ξέρουμε ότι θα πάμε
να τους ζητήσει τουλάχιστον μία φορά.

41
00:02:15,830 --> 00:02:18,780
Έτσι, ένα do while loop θα μπορούσε
δείτε κάτι σαν αυτό.

42
00:02:18,780 --> 00:02:20,090
Έχουμε έναν ακέραιο n.

43
00:02:20,090 --> 00:02:22,760
Και στο εσωτερικό του do
βρόχο while, εμείς αμέσως

44
00:02:22,760 --> 00:02:24,750
ζητήσει από το χρήστη για ένα ακέραιο.

45
00:02:24,750 --> 00:02:29,740
Αν n είναι άκυρη, τότε θα τους ωθήσει
ξανά και ξανά και ξανά μέχρι να

46
00:02:29,740 --> 00:02:31,820
να μας δώσει αυτό που ισχύει ακέραιος.

47
00:02:31,820 --> 00:02:37,440
Τέλος, από τη στιγμή n είναι μια έγκυρη είσοδο, εμείς θα
να προχωρήσει με το υπόλοιπο του προγράμματός μας.

48
00:02:37,440 --> 00:02:41,830
>> Έτσι, ας πάμε πίσω στο spec και έλεγχος
ποιες είναι οι προϋποθέσεις για την έγκυρη είσοδο

49
00:02:41,830 --> 00:02:43,670
θα είναι.

50
00:02:43,670 --> 00:02:48,090
Οι έγκυρες ύψη πρόκειται να
να είναι μεταξύ 0 και 23, συμπεριλαμβανομένων.

51
00:02:48,090 --> 00:02:53,350
είναι τόσο άκυρο ύψη πρόκειται να
να είναι μικρότερη από 0 ή περισσότερο από 23.

52
00:02:53,350 --> 00:02:56,420
Έτσι θυμηθείτε να σχεδιάσουν
κατάστασή σας με προσοχή,

53
00:02:56,420 --> 00:02:58,660
γνωρίζοντας ότι η κατάσταση
για το do while loop

54
00:02:58,660 --> 00:03:01,470
θα πρέπει να είναι, ενώ n είναι άκυρη.

55
00:03:01,470 --> 00:03:05,080
Τώρα αυτό δεν πρόκειται να είναι μια
απλά και μόνο Boolean έκφραση.

56
00:03:05,080 --> 00:03:07,630
Εμείς πάμε να πρέπει να συνδυάζουν
δύο διαφορετικές εκφράσεις

57
00:03:07,630 --> 00:03:09,900
για να κάνουν όλη την κατάστασή μας.

58
00:03:09,900 --> 00:03:13,290
>> Έτσι, ας δούμε ένα πίνακα αληθείας έχω
ήδη δώσει την υπόδειξη που είμαστε

59
00:03:13,290 --> 00:03:15,200
πρόκειται να ασχολούνται με δύο Booleans.

60
00:03:15,200 --> 00:03:19,620
Έτσι, εδώ είναι ένας πίνακας αλήθειας όπου
έχουν δύο Booleans-- Boolean 1 και 2.

61
00:03:19,620 --> 00:03:27,050
Έτσι, έχουμε τη δυνατότητα να αξιολογήσει
bool1 και bool2 ή bool1 ή bool2.

62
00:03:27,050 --> 00:03:31,980
Και θα είναι μόνο αλήθεια αν τα δύο
Booleans αξιολόγηση στην αληθινή, ενώ όλες

63
00:03:31,980 --> 00:03:37,280
ή θα ισχύει για όσο διάστημα ένα από τα
οι δύο Booleans αληθής.

64
00:03:37,280 --> 00:03:41,450
Εντάξει, έτσι ώστε να λάβει μια στιγμή, παύση αυτή
βίντεο και να χωνέψει αυτό το πίνακα αληθείας.

65
00:03:41,450 --> 00:03:42,930
Θα είμαι εδώ να περιμένει.

66
00:03:42,930 --> 00:03:45,760
Όταν έρθει πίσω, δείτε
αν μπορείτε να συναρμολογήσουν

67
00:03:45,760 --> 00:03:51,910
μια Boolean έκφραση για σας
κατάσταση του n είναι μια άκυρη εισόδου.

68
00:03:51,910 --> 00:03:54,420
>> Έτσι τώρα που έχουμε
έγκυρη είσοδο του χρήστη, ας

69
00:03:54,420 --> 00:03:58,710
να προχωρήσει και να μιλήσουμε για το πώς μπορούμε
μπορεί να επιστήσει την μισή πυραμίδα.

70
00:03:58,710 --> 00:04:03,410
Εδώ σε αυτό το απλό πρόγραμμα επεξεργασίας κειμένου,
Έχω σχεδιάσει ένα με αριστερή στοίχιση πυραμίδα.

71
00:04:03,410 --> 00:04:07,050
Αλλά γνωρίζουμε ότι χρειαζόμαστε μας
πυραμίδα να ευθυγραμμιστεί σωστά.

72
00:04:07,050 --> 00:04:08,650
Λοιπόν, πώς θα μπορούσε να το κάνω αυτό;

73
00:04:08,650 --> 00:04:11,440
Λοιπόν, εγώ θα μπορούσε να προσπαθήσει να πιέσει
πάντα προς την πλευρά

74
00:04:11,440 --> 00:04:14,880
από απλά βάζοντας ένα μικρό
χαρακτήρα στο μεταξύ.

75
00:04:14,880 --> 00:04:16,779
Και στη συνέχεια, για το επόμενο
γραμμή, Πάω να θέσει

76
00:04:16,779 --> 00:04:20,970
μερικοί περισσότερους χαρακτήρες για να ωθήσει κατά μήκος,
και further-- ούτω καθεξής και ούτω forth--

77
00:04:20,970 --> 00:04:23,360
μέχρι να έχω το δικαίωμα να ευθυγραμμίζονται πυραμίδα.

78
00:04:23,360 --> 00:04:27,780
Έτσι, έχουμε το δικαίωμα ευθυγράμμιση της πυραμίδας, αλλά
δεν είναι και τόσο μεγάλη με τις τελείες.

79
00:04:27,780 --> 00:04:30,680
Αλλά ακόμα θέλουμε να
να διατηρούν αυτό το ωραίο απόσταση.

80
00:04:30,680 --> 00:04:35,260
Έτσι, Πάω να κυριολεκτικά
τοποθετήστε μερικά κενά.

81
00:04:35,260 --> 00:04:39,420
>> Αντί για τρεις τελείες, θα
βάλτε ένα, δύο, τρεις θέσεις.

82
00:04:39,420 --> 00:04:40,370
Στη δεύτερη γραμμή.

83
00:04:40,370 --> 00:04:42,640
Θα βάλω ένα, δύο θέσεις.

84
00:04:42,640 --> 00:04:45,370
Και στην προτελευταία
γραμμή, ένα μόνο χώρο.

85
00:04:45,370 --> 00:04:48,290
Και εδώ έχω το δικαίωμα να ευθυγραμμίζονται πυραμίδα.

86
00:04:48,290 --> 00:04:52,170
Από το να κάνουν το παράδειγμα στο κείμενο
συντάκτης, έχουμε μια ιδέα για το σχέδιο

87
00:04:52,170 --> 00:04:54,590
ότι θα χρησιμοποιήσετε για να επιστήσει την μισή πυραμίδα.

88
00:04:54,590 --> 00:04:58,080
Για κάθε σειρά, αυτό που κάναμε
Είναι γράφουμε κάποια κενά,

89
00:04:58,080 --> 00:05:00,170
και στη συνέχεια να πληκτρολογήσει μερικά
hashes, και στη συνέχεια να πληκτρολογήσει

90
00:05:00,170 --> 00:05:03,020
το πλήκτρο Enter, η οποία
είναι η δημιουργία μιας νέας γραμμής.

91
00:05:03,020 --> 00:05:07,770
Έτσι τώρα που έχουμε ότι, ας πάμε
ένα βήμα παραπέρα και να βρούμε ένα μοτίβο.

92
00:05:07,770 --> 00:05:10,170
>> Έτσι, Πάω να πω, για το
ενδιαφέρον αυτού του παραδείγματος,

93
00:05:10,170 --> 00:05:12,480
έχουμε να κάνουμε με ύψος 8.

94
00:05:12,480 --> 00:05:17,100
Η πρώτη σειρά πρόκειται να έχει δύο
hashes που ακολουθεί επτά θέσεις.

95
00:05:17,100 --> 00:05:20,020
Οι second-- τρεις hashes, έξι χώρους.

96
00:05:20,020 --> 00:05:24,260
Τρίτον row-- τέσσερις hashes, πέντε
spaces-- ούτω καθεξής και ούτω καθεξής

97
00:05:24,260 --> 00:05:26,350
μέχρι να φτάσουμε στη σειρά Ν.

98
00:05:26,350 --> 00:05:31,540
Έτσι, λοιπόν, θα σας ρωτήσω για τη σειρά Ν,
πόσα hashes θα πάμε να έχουν

99
00:05:31,540 --> 00:05:33,120
και πόσες θέσεις;

100
00:05:33,120 --> 00:05:37,000
Γι 'αυτό είναι στο χέρι σας να καταλάβω ένα
τύπο για να αντιπροσωπεύουν τον αριθμό των hashes

101
00:05:37,000 --> 00:05:42,020
και πόσες θέσεις χρειάζονται για
νιοστή σειρά όταν έχετε κάποιο ύψος.

102
00:05:42,020 --> 00:05:46,060
>> Τώρα, όταν είστε υπολογίζοντας αυτό έξω,
να είστε προσεκτικοί πώς είστε ευρετηρίαση.

103
00:05:46,060 --> 00:05:49,170
Τι εννοώ με αυτό είναι ότι
στην καθημερινή ζωή όλων μας

104
00:05:49,170 --> 00:05:51,540
αρχίζουν να μετρούν, συνήθως από 1.

105
00:05:51,540 --> 00:05:55,950
Αλλά σε CS50 και στην επιστήμη των υπολογιστών
σε γενικές γραμμές, είμαστε 0 ευρετήριο.

106
00:05:55,950 --> 00:06:00,620
Έτσι, η πρώτη σειρά θα είναι
n από 0, σε αντίθεση προς 1.

107
00:06:00,620 --> 00:06:04,550
Να είστε προσεκτικοί αυτό όταν είσαι
προσπαθώ να καταλάβω το σχέδιό σας.

108
00:06:04,550 --> 00:06:07,570
Έτσι τώρα ας πάμε πίσω στο πώς
θα πάμε να επιστήσω την πυραμίδα μας.

109
00:06:07,570 --> 00:06:12,300
Για κάθε σειρά, θα πάμε να θέλουν να
εκτύπωση των χώρων, την εκτύπωση των hashes,

110
00:06:12,300 --> 00:06:14,050
και στη συνέχεια να εκτυπώσετε μια νέα γραμμή.

111
00:06:14,050 --> 00:06:19,160
Η υπόδειξη εδώ είναι η
λέξη "για" κάθε γραμμή.

112
00:06:19,160 --> 00:06:21,470
Στην C, έχουμε ένα κατασκεύασμα
ονομάζεται για το βρόχο,

113
00:06:21,470 --> 00:06:25,250
το οποίο αποτελείται από ένα
προετοιμασίας, μια κατάσταση, μια ενημερωμένη έκδοση,

114
00:06:25,250 --> 00:06:26,790
και το σώμα του βρόχου.

115
00:06:26,790 --> 00:06:31,360
>> Πείτε Ήθελα να πω, γεια
κόσμο, 50 φορές, μου βρόχο

116
00:06:31,360 --> 00:06:32,880
θα δούμε κάτι σαν αυτό.

117
00:06:32,880 --> 00:06:35,480
Έχω προετοιμαστεί ακέραιος μου 0.

118
00:06:35,480 --> 00:06:38,230
Η προϋπόθεση είναι ότι θα είναι μικρότερο από 50.

119
00:06:38,230 --> 00:06:42,350
Και στη συνέχεια ενημέρωση μου είναι ακριβώς
προσαύξηση Ι με ένα κάθε φορά.

120
00:06:42,350 --> 00:06:45,140
Μπορούμε επίσης να χρησιμοποιήσουμε για βρόχους
να επαναλάβει πάνω από τα πράγματα.

121
00:06:45,140 --> 00:06:47,820
Παρατηρήστε εδώ πως δεν έχουμε
σκληρό κωδικοποιημένο αριθμό,

122
00:06:47,820 --> 00:06:51,820
αλλά μάλλον τοποθετείται η μεταβλητή
ύψος αντί στην κατάσταση.

123
00:06:51,820 --> 00:06:56,420
Έτσι, αυτό που κάνω εδώ είναι ότι είμαι επανάληψη
πάνω από κάθε σειρά της πυραμίδας.

124
00:06:56,420 --> 00:07:00,160
Μπορώ να κάνω κάτι για το καθένα
σειρά μέσα στο σώμα του βρόχου μου.

125
00:07:00,160 --> 00:07:02,350
>> Τι κάνουμε μέσα
το σώμα του βρόχου;

126
00:07:02,350 --> 00:07:07,120
Λοιπόν, όπως έχουμε ήδη πει, είμαστε εκτύπωση
χώρους και είμαστε hashes εκτύπωση

127
00:07:07,120 --> 00:07:09,480
και είμαστε εκτύπωση μια νέα γραμμή.

128
00:07:09,480 --> 00:07:11,950
Έτσι εξωτερική μου για το βρόχο
θα μοιάζει με αυτό.

129
00:07:11,950 --> 00:07:15,070
Έχω επαναλάβει πάνω από κάθε σειρά
της πυραμίδας, με τη χρήση,

130
00:07:15,070 --> 00:07:18,890
σε αυτή την περίπτωση, το ύψος ως μεταβλητή
που αποθηκεύει το ύψος της πυραμίδας.

131
00:07:18,890 --> 00:07:22,870
Μέσα στο σώμα του εν λόγω βρόχου, είμαι
πρόκειται να εκτυπώσετε χώρους επανειλημμένα, εκτύπωση

132
00:07:22,870 --> 00:07:26,730
τα hashes επανειλημμένα,
και στη συνέχεια να εκτυπώσετε μια νέα γραμμή.

133
00:07:26,730 --> 00:07:31,010
>> Έτσι τώρα, χρησιμοποιώντας όλες τις έννοιες που
Έχω μιλήσει για σε αυτό το walk-through,

134
00:07:31,010 --> 00:07:35,210
θα πρέπει να είναι σε θέση να ζητήσει από το
χρήστη για την είσοδο, την επικύρωση ότι η είσοδος,

135
00:07:35,210 --> 00:07:37,370
και στη συνέχεια να επιστήσει την μισή πυραμίδα.

136
00:07:37,370 --> 00:07:41,510
>> Το όνομά μου είναι Zamyla, και αυτό είναι CS50.

137
00:07:41,510 --> 00:07:43,167