1
00:00:00,000 --> 00:00:09,250

2
00:00:09,250 --> 00:00:11,070
>> ZAMYLA CHAN: Ας άλμα σε Mario.

3
00:00:11,070 --> 00:00:14,850
Mario είναι ένα πρόγραμμα όπου θα κάνουν την δική μας
δικό του, έστω και πρωτόγονη, έκδοση του

4
00:00:14,850 --> 00:00:17,760
ένα κλασικό Super Mario Brothers
ιστορικό παιχνίδι.

5
00:00:17,760 --> 00:00:21,100
Για αυτό το σύνολο το πρόβλημα, θα πάμε
να αναδημιουργήσει τη μισή πυραμίδα

6
00:00:21,100 --> 00:00:23,000
Mario να πηδήσει.

7
00:00:23,000 --> 00:00:27,330
Το πρόγραμμά μας θα είναι διαδραστικό, έτσι ώστε να
θα ζητήσει από το χρήστη να εισάγει μια ορισμένη

8
00:00:27,330 --> 00:00:28,660
ύψος για την πυραμίδα.

9
00:00:28,660 --> 00:00:32,920
Και το πρόγραμμα θα εκτυπώσει ένα
μισό πυραμίδα αυτό το ύψος, όπου το

10
00:00:32,920 --> 00:00:37,390
κάτω αριστερά hash ευθυγραμμίζεται με τον πυθμένα
αριστερή γωνία του τερματικού

11
00:00:37,390 --> 00:00:39,710
παράθυρο εξόδου.

12
00:00:39,710 --> 00:00:44,870
>> Ας σπάσει αυτό το πρόβλημα σε δύο μέρη,
ένα, πάρτε την παρέμβαση του χρήστη, και τα δύο,

13
00:00:44,870 --> 00:00:47,040
εκτυπώσετε την πυραμίδα.

14
00:00:47,040 --> 00:00:51,150
Να θυμάστε ότι αν και η λειτουργία GetInt
θα ανακτήσει έναν ακέραιο, θα

15
00:00:51,150 --> 00:00:56,260
Πρέπει να βεβαιωθείτε ότι αυτή η είσοδος κάνει
νόημα για το πρόγραμμά σας, ώστε σε

16
00:00:56,260 --> 00:00:59,690
Mario, αυτό δεν θα γίνει μόνο μια
προϊόντος για ένα ακέραιο.

17
00:00:59,690 --> 00:01:03,440
Θα πρέπει να βεβαιωθείτε ότι ο χρήστης
εισόδους ένας ακέραιος που είναι εντός της

18
00:01:03,440 --> 00:01:06,985
κάτω και άνω όρια του
πυραμίδα που μπορείτε να εκτυπώσετε.

19
00:01:06,985 --> 00:01:12,300
Ανά spec αυτό, αυτό είναι
0 και 23 χωρίς αποκλεισμούς.

20
00:01:12,300 --> 00:01:16,410
Εάν ο χρήστης είσοδοι έναν ακέραιο εκτός
των αποδεκτών ορίων μας, τότε θέλουμε

21
00:01:16,410 --> 00:01:20,840
να τους οδηγήσει ξανά και ξανά μέχρι να
μας δίνουν έναν έγκυρο ακέραιο αριθμό.

22
00:01:20,840 --> 00:01:25,990
>> Ένας τρόπος για να εξασφαλιστεί η ορθή εισάγει ο χρήστης είναι
χρησιμοποιώντας ένα do-while loop, η οποία είναι

23
00:01:25,990 --> 00:01:28,100
πολύ παρόμοια με ένα βρόχο while.

24
00:01:28,100 --> 00:01:32,580
Το Do-while loop εκτελεί τον κώδικα
στο εσωτερικό του σώματος μία φορά, και στη συνέχεια ελέγχει

25
00:01:32,580 --> 00:01:35,270
αν η προϋπόθεση αυτή πληρούται ή όχι.

26
00:01:35,270 --> 00:01:38,830
Αυτό είναι χρήσιμο για την απόκτηση εισόδου χρήστη
επειδή ξέρετε ότι χρειάζεστε

27
00:01:38,830 --> 00:01:41,805
να τους προτρέψει τουλάχιστον μία φορά.

28
00:01:41,805 --> 00:01:45,940
Αν ο όρος αυτός δεν πληρούται, το πρόγραμμα
θα εκτελέσει την γραμμή μετά

29
00:01:45,940 --> 00:01:47,270
Do-while loop σας.

30
00:01:47,270 --> 00:01:50,950
Εάν ικανοποιείται η συνθήκη, όμως,
ο βρόχος θα επαναληφθεί.

31
00:01:50,950 --> 00:01:55,560
>> Ένα do-while loop για την επικύρωση των χρηστών
εισόδου θα δούμε κάτι σαν αυτό.

32
00:01:55,560 --> 00:02:02,920
Δηλώνω μια μεταβλητή n, GetInt,
και επαναλάβετε μέχρι n είναι έγκυρο.

33
00:02:02,920 --> 00:02:06,270
Να θυμάστε ότι όταν δηλώνετε σας
μεταβλητή, χρειάζεται την κατάλληλη

34
00:02:06,270 --> 00:02:08,449
πεδίο, όπως ακριβώς και στο Scratch.

35
00:02:08,449 --> 00:02:12,510
Αν δηλώνω n μέσα Do-while loop μου,
το υπόλοιπο του προγράμματος δεν θα είναι

36
00:02:12,510 --> 00:02:13,750
μπορούν να έχουν πρόσβαση.

37
00:02:13,750 --> 00:02:16,100
Είναι περιορίζεται στα όρια
από τα άγκιστρα.

38
00:02:16,100 --> 00:02:19,010

39
00:02:19,010 --> 00:02:23,090
>> Εντάξει, έτσι τώρα που έχουμε επικυρωθεί
την είσοδο του χρήστη, πρέπει πραγματικά να

40
00:02:23,090 --> 00:02:25,020
συντάξει αυτό το μισό-πυραμίδα.

41
00:02:25,020 --> 00:02:29,700
Είναι κατασκευασμένα από ευανάγνωστους χαρακτήρες, ούτως
ας κάνουμε μια μισή πυραμίδα σε ένα απλό

42
00:02:29,700 --> 00:02:31,480
επεξεργαστή κειμένου.

43
00:02:31,480 --> 00:02:35,920
Αν θέλουμε να κάνουμε μια πυραμίδα στυλ Mario
ύψους τριών που είναι ευθυγραμμισμένα

44
00:02:35,920 --> 00:02:41,370
στην αριστερή πλευρά του παραθύρου μας, τότε
θα γράφατε δύο hashes, κάντε κλικ στο κουμπί Enter,

45
00:02:41,370 --> 00:02:47,180
στη συνέχεια, πληκτρολογήστε τρεις hashes, κάντε κλικ στο κουμπί
Enter, στη συνέχεια, πληκτρολογήστε τέσσερις.

46
00:02:47,180 --> 00:02:51,090
>> Αλλά σε αυτό το σύνολο το πρόβλημα, μας
μισή πυραμίδα θα πρέπει να έχουν δεξιά στοίχιση.

47
00:02:51,090 --> 00:02:55,550
Χρησιμοποιώντας ένα τυπικό πληκτρολόγιο, πώς θα μπορούσε να
μπορείτε να τροποποιήσετε αυτό το αρχείο για να μετακινήσετε hashes

48
00:02:55,550 --> 00:02:57,210
πάνω στη δεξιά πλευρά;

49
00:02:57,210 --> 00:03:03,190
Θα μπορούσαν να χρησιμοποιήσουν για να υπογραμμίζει, δύο για το
κορυφαία σειρά και ένα για το δεύτερο.

50
00:03:03,190 --> 00:03:07,690
Αυτό δεν φαίνεται τόσο ωραίο, όμως, έτσι
ας αντικαταστήσει το υπογραμμίζει με

51
00:03:07,690 --> 00:03:12,450
χώρους, και εκεί έχουμε μια μισή πυραμίδα
ύψους τριών.

52
00:03:12,450 --> 00:03:16,330
>> Προσπαθήστε να θυμηθείτε αυτό το πρόγραμμα επεξεργασίας κειμένου
παράδειγμα, όπως θα αρχίσουμε να σκεφτόμαστε πίσω στην

53
00:03:16,330 --> 00:03:20,100
Γ. Ας προσπαθήσουμε και να καταλάβουμε ορισμένες
είδος σχεδίου που μπορούμε

54
00:03:20,100 --> 00:03:22,750
θέσει σε ένα μόρφωμα βρόχο.

55
00:03:22,750 --> 00:03:27,570
Πάρτε ένα ύψος παράδειγμα, ας πούμε οκτώ,
και δείτε αν μπορείτε να αρχίσετε να

56
00:03:27,570 --> 00:03:29,470
καταλήξουμε σε ένα μοτίβο.

57
00:03:29,470 --> 00:03:34,710
Η πρώτη γραμμή θα έχει επτά θέσεις
ακολουθείται από δύο hashes.

58
00:03:34,710 --> 00:03:40,090
Η δεύτερη σειρά θα έχει έξι θέσεις και
τρεις hashes, και ούτω καθεξής μέχρι το

59
00:03:40,090 --> 00:03:41,440
όγδοη σειρά.

60
00:03:41,440 --> 00:03:45,210
>> Αλλά πώς θα εκπροσωπεί
η νιοστή σειρά;

61
00:03:45,210 --> 00:03:48,170
Να θυμάστε ότι η σύμβαση προγραμματισμού
είναι μηδέν ευρετήριο.

62
00:03:48,170 --> 00:03:51,870
Αυτό σημαίνει ότι θα αρχίσουμε να μετράμε σε
μηδέν, έτσι ώστε η πρώτη γραμμή είναι τεχνικά

63
00:03:51,870 --> 00:03:57,110
σειρά αριθμό μηδέν με δύο καταπακτές, σειρά
νούμερο ένα έχει τρεις hashes, σειρά

64
00:03:57,110 --> 00:04:01,860
νούμερο δύο έχει τέσσερα hashes, έτσι ώστε μετά
αυτό το πρότυπο για κάθε γραμμή

65
00:04:01,860 --> 00:04:05,800
αριθμό n, υπάρχουν n συν 2 hashes.

66
00:04:05,800 --> 00:04:09,270
Θα το αφήσει σε σας, όμως, να βρείτε
έξω από το πρότυπο για τους χώρους.

67
00:04:09,270 --> 00:04:12,240
Να θυμάστε ότι το σχέδιό σας θα είναι
ελαφρώς διαφορετική αν επιλέξετε να

68
00:04:12,240 --> 00:04:16,649
ξεκινήσετε σας μετράνε από
ένα και όχι μηδέν.

69
00:04:16,649 --> 00:04:19,560
>> Τώρα, έχετε ένα πρότυπο για
οποιαδήποτε αφηρημένη n σειρά.

70
00:04:19,560 --> 00:04:25,190
Ξέρετε πόσες θέσεις για την εκτύπωση και
πόσες hashes, έτσι ώστε για κάθε γραμμή, δηλαδή

71
00:04:25,190 --> 00:04:26,270
ο αριθμός θα αλλάξει.

72
00:04:26,270 --> 00:04:30,700
Όμως, η ίδια η διαδικασία της εκτύπωσης α
ενιαίο χαρακτήρα, είτε ένας χώρος ή ένα

73
00:04:30,700 --> 00:04:33,200
hash, επαναλαμβάνεται.

74
00:04:33,200 --> 00:04:37,470
Έτσι, το μόνο που έχετε να κάνετε είναι κατ 'επανάληψη
εκτυπώστε αυτό το χαρακτήρα για όσες φορές

75
00:04:37,470 --> 00:04:40,120
ως πρότυπο σας καθορίζει.

76
00:04:40,120 --> 00:04:42,522
>> Επομένως, πώς θα επαναλάβουμε τις διαδικασίες;

77
00:04:42,522 --> 00:04:45,160
Το Scratch, χρησιμοποιήσαμε το μπλοκ επανάληψης.

78
00:04:45,160 --> 00:04:48,580
Στο C, θα χρησιμοποιήσουμε ένα for loop.

79
00:04:48,580 --> 00:04:51,290
Ας δούμε τη σύνταξη
για την κατηγορία βρόχους.

80
00:04:51,290 --> 00:04:57,140
>> Κάθε Για βρόχος αποτελείται από τρία
μέρη, μια προετοιμασία, μια κατάσταση,

81
00:04:57,140 --> 00:04:58,592
και μια ενημέρωση.

82
00:04:58,592 --> 00:05:01,550
Για την μέθοδο loop σας θα προετοιμαστεί
μια μεταβλητή, όταν για πρώτη

83
00:05:01,550 --> 00:05:02,960
Για εισέρχεται στο βρόχο.

84
00:05:02,960 --> 00:05:07,100
Εάν ικανοποιείται η συνθήκη, ο οργανισμός
του βρόχου θα εκτελέσει.

85
00:05:07,100 --> 00:05:10,070
Στη συνέχεια, η ενημέρωση θα εκτελέσει.

86
00:05:10,070 --> 00:05:13,630
>> Εάν η κατάσταση εξακολουθεί να πληρούται, η
βρόχου θα εκτελέσει και να ενημερώσει και να

87
00:05:13,630 --> 00:05:18,580
Επαναλαμβάνω για όσο διάστημα η κατάστασή σας
αποτιμάται σε True.

88
00:05:18,580 --> 00:05:21,450
Είσαι κατάσταση πρέπει τελικά valuate
στην τιμή False, όμως, γιατί

89
00:05:21,450 --> 00:05:24,490
σε αντίθεση με Scratch, δεν το κάνουμε
έχει θηλιές για πάντα.

90
00:05:24,490 --> 00:05:28,270
Το πρόγραμμά σας πρέπει να σταματήσει τελικά.

91
00:05:28,270 --> 00:05:32,330
>> Εδώ είναι ένα παράδειγμα ενός βρόχου for που
ίσως να θέλετε να χρησιμοποιήσετε για Mario.

92
00:05:32,330 --> 00:05:36,790
Η προετοιμασία δηλώνει
ένα i ακέραιος με τιμή 0.

93
00:05:36,790 --> 00:05:40,750
Εφ 'όσον το i είναι μικρότερο από το ύψος,
το σώμα του βρόχου θα εκτελέσει και

94
00:05:40,750 --> 00:05:44,980
αύξηση i κατά ένα και επαναλάβετε
έως ότου το i είναι μεγαλύτερο ή

95
00:05:44,980 --> 00:05:47,220
ίσο με το ύψος.

96
00:05:47,220 --> 00:05:49,140
>> Τώρα, για βρόχο μου είναι μηδενικό δείκτη.

97
00:05:49,140 --> 00:05:52,270
Η Int i ξεκινά από το μηδέν, όχι ένα.

98
00:05:52,270 --> 00:05:55,320
Αν επέλεξα ένα, τότε η κατάστασή μου θα
πρέπει επίσης να είναι διαφορετική για

99
00:05:55,320 --> 00:05:58,740
ο βρόχος να εκτελέσει την
ίδιο αριθμό φορών.

100
00:05:58,740 --> 00:06:03,490
Θυμηθείτε το αυτό προσεκτικά, όταν είστε
επιλογή προετοιμασίας σας και σας

101
00:06:03,490 --> 00:06:08,660
κατάσταση, και συμβουλευτείτε αυτό
διάγραμμα για διπλό έλεγχο.

102
00:06:08,660 --> 00:06:13,430
>> Ένα από τα μεγάλα πράγματα για τον υπολογιστή
η επιστήμη είναι ότι υπάρχει μόνο τόσα πολλά

103
00:06:13,430 --> 00:06:15,490
τρόποι για να εκτελέσει τα πράγματα.

104
00:06:15,490 --> 00:06:19,450
Μπορείτε να επιλέξετε αν θα
ξεκινούν από το μηδέν ή ένα.

105
00:06:19,450 --> 00:06:22,380
Εάν δεν θέλετε να χρησιμοποιήσετε ένα for loop,
μπορείτε επίσης να χρησιμοποιήσετε ένα βρόχο while να

106
00:06:22,380 --> 00:06:26,530
επαναλάβετε δηλώσεις εφ 'όσον
κρατήσει την ουσία ενός βρόχου for,

107
00:06:26,530 --> 00:06:31,430
προετοιμασία, την κατάσταση και την ενημέρωση.

108
00:06:31,430 --> 00:06:36,890
Μόλις καταλάβω την βρόχου for που
είμαστε πιο άνετα, τότε

109
00:06:36,890 --> 00:06:38,450
μπορεί να ολοκληρώσει Mario.

110
00:06:38,450 --> 00:06:41,540
>> Πρέπει πρώτα ελέγχονται για την είσοδο χρήστη
και προσδιόρισε τότε

111
00:06:41,540 --> 00:06:43,580
πρότυπο για κάθε n σειρά.

112
00:06:43,580 --> 00:06:49,990
Έτσι, για κάθε γραμμή από μηδέν έως μείον 1 n
θα εκτυπώσει τον κατάλληλο αριθμό

113
00:06:49,990 --> 00:06:55,340
χώρους, τότε ο κατάλληλος αριθμός
hashes σύμφωνα με τον τρόπο μας, και

114
00:06:55,340 --> 00:06:57,180
τότε μια νέα γραμμή.

115
00:06:57,180 --> 00:06:59,640
Με αυτό, έχετε πυραμίδα σας.

116
00:06:59,640 --> 00:07:02,630
Το όνομά μου είναι Zamyla, και αυτό ήταν Mario.

117
00:07:02,630 --> 00:07:11,765