1
00:00:02,190 --> 00:00:03,160
Ciao.

2
00:00:03,270 --> 00:00:04,340
Questo è che non vogliono.

3
00:00:04,340 --> 00:00:05,280
E bentornato.

4
00:00:05,550 --> 00:00:12,570
Quindi sappiamo come una buona comprensione della prima affermazione e nell'ultima lezione abbiamo esaminato questo particolare esempio

5
00:00:12,690 --> 00:00:14,220
di prima affermazione.

6
00:00:14,530 --> 00:00:19,000
E abbiamo visto come questa prima affermazione potrebbe essere rappresentata in modi diversi.

7
00:00:19,090 --> 00:00:24,450
E diciamo anche che questo è il modo più comune in cui una prima affermazione sarebbe rappresentata.

8
00:00:24,450 --> 00:00:29,580
Cioè avremmo una dichiarazione di inizializzazione e avremmo qualche condizione e

9
00:00:29,580 --> 00:00:33,410
quindi avremo questa espressione dove incrementiamo la variabile.

10
00:00:33,680 --> 00:00:33,960
Destra.

11
00:00:34,690 --> 00:00:41,640
E in questa conferenza andiamo avanti ed esploriamo un po 'di più la prima affermazione e vedremo la

12
00:00:41,640 --> 00:00:45,780
base comune in cui viene tipicamente utilizzata una prima affermazione.

13
00:00:46,180 --> 00:00:46,980
OK.

14
00:00:47,070 --> 00:00:54,420
E questo è davvero molto utile per i principianti assoluti perché vedremo i diversi modi in

15
00:00:54,540 --> 00:01:01,470
cui le dichiarazioni di inizializzazione e le espressioni di condizione qui le condizioni booleane e

16
00:01:01,470 --> 00:01:06,180
le espressioni di espressione possono essere impostate per diversi problemi.

17
00:01:06,180 --> 00:01:06,630
Va bene.

18
00:01:06,690 --> 00:01:13,620
Quindi sarà molto utile per i principianti assoluti e guarderemo in particolare a come attraversare o

19
00:01:13,650 --> 00:01:16,150
iterare attraverso un array monodimensionale.

20
00:01:16,170 --> 00:01:23,040
Abbiamo già un'idea di base a partire dall'ultima lezione e vedremo anche come un

21
00:01:23,040 --> 00:01:28,170
array bidimensionale o multidimensionale può essere iterato usando istruzioni nidificate.

22
00:01:28,400 --> 00:01:28,610
Va bene.

23
00:01:28,620 --> 00:01:33,690
Quindi vedremo anche le prime dichiarazioni annidate e vedremo anche un semplice esempio in cui

24
00:01:33,690 --> 00:01:37,440
useremo una falsa dichiarazione ma non andremo a ripetere un array.

25
00:01:37,830 --> 00:01:38,330
Va bene.

26
00:01:38,430 --> 00:01:42,960
Quindi è un esempio in cui un array non viene utilizzato in una falsa dichiarazione.

27
00:01:43,590 --> 00:01:45,760
Andiamo avanti e guardiamo questo.

28
00:01:45,780 --> 00:01:48,000
La prima cosa è cambiare questo.

29
00:01:48,000 --> 00:01:49,940
Qui stiamo incrementando di 1.

30
00:01:49,950 --> 00:01:52,920
Quindi qui stiamo iterando attraverso questo particolare array.

31
00:01:53,130 --> 00:01:56,330
Cambiamo solo a 2.

32
00:01:56,530 --> 00:01:56,820
OK.

33
00:01:56,880 --> 00:02:01,570
Quindi incrementeremo anche la variabile i bit.

34
00:02:01,680 --> 00:02:01,950
OK.

35
00:02:01,950 --> 00:02:04,850
In ogni iterazione verrà incrementato di 2.

36
00:02:04,860 --> 00:02:10,350
Quindi questo è solo per mostrare che l'espressione incrementale non deve essere solo una.

37
00:02:10,580 --> 00:02:10,830
OK.

38
00:02:10,830 --> 00:02:13,370
Possiamo anche incrementare di più di uno.

39
00:02:13,380 --> 00:02:16,140
Quindi fammi ricompilare questo.

40
00:02:16,140 --> 00:02:19,290
Quindi questo è in classe demo di base.

41
00:02:19,290 --> 00:02:21,600
E qui siamo nella directory di base.

42
00:02:21,600 --> 00:02:27,640
Quindi sto solo facendo le modifiche nel metodo principale okay.

43
00:02:27,680 --> 00:02:31,940
Ecco qua, stampa 0 2 4 6 e 8.

44
00:02:31,970 --> 00:02:32,200
Va bene.

45
00:02:32,210 --> 00:02:39,850
Quindi andrà a saltare 1 3 5 7 sotto verrà stampato solo 0 2 4 6 8.

46
00:02:39,890 --> 00:02:46,070
Quindi sta stampando tutti i valori alternativi e questo può essere qualsiasi valore, puoi anche renderlo tre o quattro

47
00:02:46,160 --> 00:02:47,510
e così via.

48
00:02:47,510 --> 00:02:48,610
Quindi questa è una cosa.

49
00:02:48,650 --> 00:02:53,190
Ora diciamo che vogliamo stampare questo in ordine inverso.

50
00:02:53,230 --> 00:02:53,570
OK.

51
00:02:53,600 --> 00:02:55,500
Quindi partiamo da qui alle nove.

52
00:02:55,550 --> 00:02:57,770
E dobbiamo stampare nell'ordine inverso.

53
00:02:57,770 --> 00:03:00,360
Quindi, dal momento che dobbiamo iniziare dalle nove.

54
00:03:00,560 --> 00:03:07,770
Quindi dobbiamo prendere che leggo o presta meno uno.

55
00:03:07,790 --> 00:03:07,990
OK.

56
00:03:08,030 --> 00:03:13,490
Perché sappiamo che l'ultimo elemento sarebbe il punto zero meno uno.

57
00:03:13,550 --> 00:03:20,990
E qui dichiareremmo che invece di incrementare e questo sviluppo può anche essere di qualsiasi valore può

58
00:03:20,990 --> 00:03:23,920
essere io. e. uguale a A meno due su così via.

59
00:03:24,140 --> 00:03:32,240
E qui dal momento che stiamo andando nella direzione opposta deve essere maggiore o uguale a zero.

60
00:03:32,330 --> 00:03:37,090
Quindi intendiamo dire fino a raggiungere il prossimo numero zero.

61
00:03:38,060 --> 00:03:39,020
Quindi questo

62
00:03:42,810 --> 00:03:45,180
dovrebbe essere stampato in ordine inverso.

63
00:03:45,200 --> 00:03:45,770
Ecco qua.

64
00:03:45,770 --> 00:03:50,230
Quindi, basta stampare tutti i valori nell'ordine inverso.

65
00:03:50,240 --> 00:03:54,980
Ora diciamo che vogliamo invertire gli elementi in questa particolare area.

66
00:03:55,370 --> 00:04:02,450
A volte vorremmo farlo nella libreria Java, fornendo anche un metodo in una delle classi per

67
00:04:02,450 --> 00:04:05,030
invertire gli elementi in soffitta.

68
00:04:05,090 --> 00:04:11,020
Quindi, quando diciamo che vogliamo invertire gli elementi, Nove deve entrare nell'ultimo elemento deve

69
00:04:11,030 --> 00:04:19,010
andare nella prima posizione e l'elemento nella posizione 0 8 dovrebbe andare nell'ultima posizione dove un otto deve andare

70
00:04:19,010 --> 00:04:23,440
qui e uno ha per andare in ottava posizione.

71
00:04:23,750 --> 00:04:30,590
Quindi lo faremo più avanti usando la prima affermazione, ma in ogni iterazione che stiamo facendo stiamo scambiando

72
00:04:31,080 --> 00:04:32,520
gli elementi pagati.

73
00:04:32,690 --> 00:04:39,260
Quindi nella prima iterazione dovremmo scambiare 0 9 e nella seconda iterazione dovremmo scambiarne uno su otto nel terzo, faremo

74
00:04:39,260 --> 00:04:45,110
un passo due e sette e poi tre e sei e poi quattro e cinque sotto e finiremmo

75
00:04:45,110 --> 00:04:45,830
con quello.

76
00:04:46,790 --> 00:04:51,980
Quindi in ogni iterazione abbiamo bisogno di come accedere a due numeri indicizzati.

77
00:04:51,980 --> 00:04:52,310
Destra.

78
00:04:52,340 --> 00:04:57,980
Ad esempio nella prima iterazione sarebbe zero e l'indice corrispondente a questo che

79
00:04:57,980 --> 00:04:59,030
sarebbe nove.

80
00:04:59,030 --> 00:05:01,840
Quindi dovremmo usare due variabili per questo.

81
00:05:01,940 --> 00:05:08,330
Ora vorrei che tu mettessi in pausa il video qui e provassi a scrivere la logica per quello.

82
00:05:08,450 --> 00:05:14,090
Puoi prenderlo in cinque minuti per quello e prenderò cinque secondi di

83
00:05:14,090 --> 00:05:20,720
pausa e poi tornerò e ti mostrerò come scrivere il codice, ma ti suggerirei di fare

84
00:05:20,720 --> 00:05:28,460
il video e provarlo e poi puoi vedere se la tua soluzione corrisponde alla mia o non va bene.

85
00:05:28,490 --> 00:05:29,910
Spero che tu l'abbia fatto.

86
00:05:29,960 --> 00:05:33,510
Quindi andiamo avanti e scriviamo il codice e puoi confrontarlo con il mio.

87
00:05:34,220 --> 00:05:37,260
Quindi la prima cosa è che abbiamo bisogno di due variabili Foster.

88
00:05:37,910 --> 00:05:48,500
Sarei zero, quindi abbiamo bisogno di un'altra variabile, chiamiamola come una J e J mi permetterebbe anche di copiare questo.

89
00:05:48,510 --> 00:05:49,800
Avremmo bisogno di

90
00:05:52,820 --> 00:05:56,450
questo qui J sarebbe irato o alla fine meno uno.

91
00:05:56,750 --> 00:05:57,460
Va bene.

92
00:05:57,620 --> 00:06:06,050
E qui sarei incrementato di uno in ogni iterazione e J sarebbe decrementale in

93
00:06:06,860 --> 00:06:15,350
ogni iterazione che sto ora arrivando a questa espressione della condizione sarebbe minore di J.

94
00:06:15,910 --> 00:06:19,030
Va bene, è così.

95
00:06:19,310 --> 00:06:24,650
E dobbiamo anche scrivere la logica qui, quindi la condizione è inferiore a G.

96
00:06:24,850 --> 00:06:32,100
Quindi inizialmente sarei zero G sarebbe nove qui e nella seconda iterazione sarebbe 1 su 8.

97
00:06:32,140 --> 00:06:40,690
Quindi quegli elementi sarebbero scambiati nella terza iterazione 2 e 7 sarebbero scambiati e 3 e 6 e 4

98
00:06:40,750 --> 00:06:42,050
e 5.

99
00:06:42,100 --> 00:06:44,100
Questo è quando io sono meno di G.

100
00:06:44,380 --> 00:06:49,120
E nella successiva iterazione sarei 5 e J sarebbe 4.

101
00:06:49,300 --> 00:06:52,150
E questo è quando usciremo dalla prima affermazione.

102
00:06:52,810 --> 00:06:58,900
Va bene così è così che anche il numero pari di elementi come in questo caso

103
00:06:58,900 --> 00:07:05,500
ci sono 10 elementi ma se siamo come il numero di elementi di cui tre e cinque verrebbero

104
00:07:05,930 --> 00:07:12,750
eliminati, avremmo incrementato da 1 a 3 su J sarebbe decrementale cinque e dopo I e J sarebbero quattro.

105
00:07:12,790 --> 00:07:15,130
Quindi la condizione è ancora inferiore a J.

106
00:07:15,280 --> 00:07:18,080
Ma noi come io sono uguale a G qui.

107
00:07:18,130 --> 00:07:20,630
E così la prima affermazione sarebbe uscita lì.

108
00:07:20,950 --> 00:07:26,720
Quindi la condizione sta dicendo se noi stessi come il numero di elementi sia il nostro numero di elementi.

109
00:07:26,710 --> 00:07:27,970
Va bene, è così.

110
00:07:27,970 --> 00:07:31,390
E ora arrivando alla logica nel corpo.

111
00:07:31,390 --> 00:07:40,830
Quindi la prima cosa è definire una variabile temporanea e memorizzare l'elemento giusto nella prima iterazione che sarebbe

112
00:07:40,830 --> 00:07:42,080
zero elemento.

113
00:07:42,090 --> 00:07:43,980
Quindi diremmo che io

114
00:07:44,580 --> 00:07:48,510
Va bene così che è memorizzato in temp che

115
00:07:53,730 --> 00:07:58,070
significa che possiamo prendere l'elemento jet e salvarlo in ottava posizione.

116
00:07:58,170 --> 00:07:59,050
Va bene.

117
00:07:59,270 --> 00:08:00,290
E dopo

118
00:08:03,210 --> 00:08:11,640
quello nella posizione del getto dovremo memorizzare il valore in temp che ha il valore aggiuntivo che era in

119
00:08:11,640 --> 00:08:12,400
posizione.

120
00:08:12,400 --> 00:08:17,280
L'ho visto come lo scambio e andiamo avanti e

121
00:08:21,650 --> 00:08:36,580
stampo questo in modo che le condizioni qui come io sono meno uguali a questo o si può solo quanto meno di un occhio più positivo e basta

122
00:08:36,580 --> 00:08:39,040
stampare nella stessa riga.

123
00:08:39,310 --> 00:08:44,950
Quindi diciamo plus e whitespace in modo che stampi tutti gli elementi nella stessa riga.

124
00:08:45,430 --> 00:08:49,320
Quindi stiamo stampando da 0 a lunghezza meno 1.

125
00:08:49,360 --> 00:08:52,150
Quindi questo è solo per la stampa degli elementi.

126
00:08:52,300 --> 00:09:00,630
Quindi andiamo avanti e aggiungimi compilatore e ricompilalo ed eseguilo.

127
00:09:00,650 --> 00:09:01,170
Ecco qua.

128
00:09:01,170 --> 00:09:03,770
Quindi gli elementi sono stati invertiti.

129
00:09:03,780 --> 00:09:05,220
Va bene così è.

130
00:09:06,310 --> 00:09:10,540
Quindi quando uso uguale a G è quando siamo usciti dal ciclo.

131
00:09:10,570 --> 00:09:12,460
Ora possiamo anche invece di J.

132
00:09:12,460 --> 00:09:18,740
Possiamo anche vedere che I Ari non presta più di 2.

133
00:09:19,010 --> 00:09:26,960
Quindi possiamo usare questo tipo di condizione perché leggo che cosa è la terra e poi di due come cinque.

134
00:09:27,010 --> 00:09:35,780
Quindi, fino a quando ne uso meno di cinque, siamo buoni, ma non appena ne avrò cinque, usciremo dal ciclo.

135
00:09:35,810 --> 00:09:41,700
Quindi questo è un modo diverso in cui la stessa espressione può essere scritta la stessa prima affermazione.

136
00:09:41,720 --> 00:09:43,610
Quindi questo è solo per darti un'idea.

137
00:09:43,640 --> 00:09:51,950
E come possiamo rappresentare una dichiarazione lontana in modi diversi e ottenere lo stesso risultato, anche tu

138
00:09:51,950 --> 00:09:55,490
ottieni gli stessi valori ora qui.

139
00:09:55,520 --> 00:10:00,320
Quello che sta accadendo è in ogni iterazione che stiamo eseguendo questa operazione di divisione.

140
00:10:00,440 --> 00:10:07,790
Quindi se hai migliaia o un milione di elementi, allora sai che sarebbe intensivo dal punto di vista computazionale.

141
00:10:07,820 --> 00:10:09,440
Sarà molto costoso.

142
00:10:10,040 --> 00:10:16,460
Quindi, perché in ogni iterazione dobbiamo fare questo calcolo in modo che possiamo fare un'ottimizzazione

143
00:10:16,460 --> 00:10:23,240
e l'ottimizzazione è che prenderò questa espressione da qui e definirò un'altra variabile qui nella parte

144
00:10:23,240 --> 00:10:28,550
dell'istruzione di inizializzazione e che è chiamata come media e diciamo così.

145
00:10:28,820 --> 00:10:33,420
E ora vedremo il metallo.

146
00:10:33,630 --> 00:10:39,720
Quindi in questo caso sappiamo che la parte dell'istruzione di inizializzazione viene eseguita solo una volta.

147
00:10:40,290 --> 00:10:46,360
Quindi questa espressione sarebbe anche calcolata una sola volta e ciò sarebbe sufficiente per noi.

148
00:10:46,380 --> 00:10:50,440
Quindi è calcolato una volta su quel valore sarebbe plug qui.

149
00:10:50,580 --> 00:10:56,010
E così con ogni iterazione non ricalcolare questo valore di metallo.

150
00:10:56,220 --> 00:10:57,230
È fatto solo una volta.

151
00:10:57,480 --> 00:11:01,830
Quindi questo viene fatto solo una volta che sappiamo che questo viene valutato solo una volta.

152
00:11:02,310 --> 00:11:10,480
Ma l'espressione di condizione così come l'elenco di espressioni è ciò che viene valutato con ogni iterazione.

153
00:11:10,480 --> 00:11:10,820
Tutto ok.

154
00:11:11,340 --> 00:11:14,940
Andiamo avanti e ricontrolliamo i nostri risultati ancora

155
00:11:17,910 --> 00:11:19,370
una volta invariato.

156
00:11:20,220 --> 00:11:22,070
Quindi otteniamo gli stessi valori.

157
00:11:22,170 --> 00:11:23,860
Quindi questa è un'ottimizzazione.

158
00:11:23,880 --> 00:11:27,520
Ora puoi pensare se c'è un modo per ottimizzarlo ulteriormente.

159
00:11:28,290 --> 00:11:37,860
Quindi qui stiamo dicendo divisione per 2 Ora si può ricordare che il turno di destra senza segno può essere

160
00:11:37,860 --> 00:11:43,380
usato per quello perché è equivalente alla divisione per potenza morbida.

161
00:11:44,070 --> 00:11:48,270
OK, quindi qui lo renderà uno perché abbiamo bisogno di dividere per due.

162
00:11:48,270 --> 00:11:53,140
Quindi questo è come un punto terra diviso per due al potere di uno.

163
00:11:53,280 --> 00:12:01,020
E sappiamo che gli operatori di The Big Shift sono molto più efficienti della moltiplicazione e della divisione.

164
00:12:01,020 --> 00:12:04,650
Quindi possiamo usare un turno a destra senza segno per l'operazione di divisione.

165
00:12:04,860 --> 00:12:13,550
Verifichiamo di nuovo la verifica in modo che l'output sia lo stesso.

166
00:12:13,560 --> 00:12:13,790
OK.

167
00:12:13,830 --> 00:12:15,460
Quindi questo è quello.

168
00:12:15,540 --> 00:12:22,380
Ora voglio anche dire che per lo più utilizziamo le istruzioni per scorrere le strutture di dati come array o altre strutture

169
00:12:22,560 --> 00:12:29,040
di dati che esploreremo in seguito, ma è possibile utilizzare anche la prima istruzione e altri problemi, ad esempio se

170
00:12:29,040 --> 00:12:34,020
si desidera semplicemente eseguire un'iterazione di alcuni logica per un numero di volte che può

171
00:12:34,020 --> 00:12:34,800
essere utilizzato.

172
00:12:35,160 --> 00:12:42,870
Ora un esempio semplice di esempio in cui un array non è usato come un problema di esempio che tu

173
00:12:42,870 --> 00:12:50,340
sei comunemente visto in comune nei corsi di programmazione come contare il numero di consulenti di un particolare valore

174
00:12:51,000 --> 00:13:00,960
per esempio per esempio se c'è un valore X e un valore Y sarebbe un divisore di X se X è segnato dai risultati e 0

175
00:13:01,020 --> 00:13:04,070
va bene se il resto è 0.

176
00:13:04,080 --> 00:13:10,360
Quando dividi per Y, allora è una com e poi diciamo che yz è l'advisor per x.

177
00:13:10,500 --> 00:13:15,390
Quindi per un dato numero chiamiamo il numero di dispositivi che ha.

178
00:13:15,930 --> 00:13:21,450
OK, quindi diciamo, colpiscilo, è molto semplice chiamiamo

179
00:13:26,690 --> 00:13:32,710
il numero 24 e dovremmo trovare tutti e B.

180
00:13:32,740 --> 00:13:36,050
Dovremmo scoprire quanti dispositivi ha.

181
00:13:36,050 --> 00:13:37,790
Quindi usiamo una

182
00:13:41,020 --> 00:13:48,490
variabile e concepiamo quindi uno ne includerebbe uno e 24 per ventiquattro uno e ventiquattro

183
00:13:48,490 --> 00:13:53,300
e ci sarebbero altri dispositivi tra 1 e 24.

184
00:13:53,590 --> 00:13:57,800
Quindi deve iniziare con 1 e non 0.

185
00:13:58,450 --> 00:14:01,530
E abbiamo bisogno di scorrere fino a 24.

186
00:14:01,570 --> 00:14:13,670
Quindi questo è minore o uguale a x e I più più e in ogni iterazione che facciamo sotto controllo diciamo F X

187
00:14:14,060 --> 00:14:22,230
più i z uguale a zero di X adviser di quanto usassi il mattiniero.

188
00:14:22,320 --> 00:14:25,970
Ok, quindi ci stiamo ritirando da uno a 24.

189
00:14:26,450 --> 00:14:32,670
Quindi in questo caso abbiamo bisogno di incrementare il conteggio e questo è anche un modello di programmazione comune.

190
00:14:32,670 --> 00:14:36,470
Qui abbiamo una prima dichiarazione su ciascuna in ogni iterazione.

191
00:14:36,480 --> 00:14:41,370
Facciamo un controllo e se il controllo riesce solo allora eseguiremo un po 'di logica.

192
00:14:41,370 --> 00:14:45,170
Questo è un modello di programmazione comune che incontri.

193
00:14:45,180 --> 00:14:46,800
Adesso stampiamo il

194
00:14:57,270 --> 00:15:01,030
conteggio e stampiamo anche il dispositivo vero e proprio.

195
00:15:01,110 --> 00:15:03,270
Quindi attaccare questo ritmo

196
00:15:08,040 --> 00:15:08,770
I.

197
00:15:09,080 --> 00:15:09,840
Quindi sembra

198
00:15:14,660 --> 00:15:17,410
buono quindi questi sono tutti i dispositivi 424.

199
00:15:17,690 --> 00:15:21,530
Uno due tre quattro sei otto e quattro.

200
00:15:22,170 --> 00:15:22,640
OK.

201
00:15:22,670 --> 00:15:28,020
Quindi se fai più di 24 di uno di questi numeri ricevi un promemoria di zero.

202
00:15:28,030 --> 00:15:29,270
E quindi ci sono otto di loro.

203
00:15:29,990 --> 00:15:31,300
Quindi questo è quello.

204
00:15:31,340 --> 00:15:38,010
Ora diciamo per esempio vediamo ora una dichiarazione annidata per istruzioni nidificate.

205
00:15:38,020 --> 00:15:45,430
Arrivano anche molto comunemente quando stiamo programmando specialmente se tu come una struttura di dati come una matrice.

206
00:15:45,640 --> 00:15:51,100
E se ogni elemento è anche un altro array che è simile a una tridimensionale

207
00:15:51,400 --> 00:15:58,630
non a una tridimensionalità oa una qualsiasi struttura di dati i cui elementi sono altre strutture di dati, allora puoi usare

208
00:15:58,630 --> 00:16:04,900
un'istruzione di forza in cui l'istruzione di forza esterna dovrebbe scorrere attraverso la struttura dei dati è una

209
00:16:04,900 --> 00:16:11,380
specie di una schiera e l'enunciazione della forza interiore itereranno attraverso l'esercito attraverso ciascuno degli elementi, perché ognuno di

210
00:16:11,380 --> 00:16:14,030
essi può essere qualcosa come un array.

211
00:16:14,710 --> 00:16:16,060
Quindi diamo un'occhiata a questo.

212
00:16:16,380 --> 00:16:22,960
E una cosa è che ho menzionato in precedenza nell'ultima conferenza poiché lo scopo di queste variabili termina con il

213
00:16:22,960 --> 00:16:23,740
ciclo for.

214
00:16:23,740 --> 00:16:29,200
Quindi qui abbiamo l'occhio è uguale a zero e puoi vedere che ne abbiamo usato un altro e

215
00:16:29,200 --> 00:16:34,660
io uguale a zero qui perché questo occhio è diverso da questo perché lo scopo dell'occhio variabile e

216
00:16:34,660 --> 00:16:35,950
così questo blocco particolare.

217
00:16:35,950 --> 00:16:43,450
E allo stesso modo anche come l'occhio qui sulla variabile della X lo scope sarebbe da qui fino alla

218
00:16:43,540 --> 00:16:45,030
fine del metodo.

219
00:16:45,040 --> 00:16:52,210
Il metodo principale in seguito esaminerà formalmente anche la portata variabile in un paio di conferenze da ora.

220
00:16:52,240 --> 00:16:53,530
Quindi la prima cosa è questa.

221
00:16:53,530 --> 00:16:55,900
Quindi lasciatemi solo copiare un po 'di codice qui

222
00:17:01,980 --> 00:17:02,550
così qui.

223
00:17:02,580 --> 00:17:04,170
Diciamo che questi sono.

224
00:17:04,680 --> 00:17:08,480
Quindi qui abbiamo un bidimensionale oggi e lo definiamo uno studente fantastico.

225
00:17:08,670 --> 00:17:11,040
Quindi rappresenta alcuni gradi dello studente.

226
00:17:11,220 --> 00:17:18,570
Diciamo che questo elemento qui il primo elemento del vero array è un array sotto disceso ha i

227
00:17:18,570 --> 00:17:23,160
gradi di studenti in una particolare sezione su una particolare classe.

228
00:17:23,160 --> 00:17:28,650
E questo è il gruppo di studenti nella seconda sezione della seconda classe e i voti per la

229
00:17:28,650 --> 00:17:29,430
terza classe.

230
00:17:29,430 --> 00:17:37,580
Ora vogliamo ripetere questo particolare array di pulley e mostrare tutti questi elementi.

231
00:17:37,710 --> 00:17:45,260
Quindi prima avremo una prima dichiarazione esterna e all'interno ne avremmo altri quattro.

232
00:17:45,280 --> 00:17:50,290
Così veloce dirò e io sono uguale a zero meno che

233
00:17:53,410 --> 00:18:02,170
terra quindi sarebbe tre perché ci sono tre elementi e quindi ne avremmo due in ogni iterazione come un

234
00:18:02,170 --> 00:18:05,630
elemento che è una matrice B.

235
00:18:05,680 --> 00:18:09,980
Quindi abbiamo bisogno di scorrere questo e per questo usiamo un altro ciclo annidato.

236
00:18:10,060 --> 00:18:21,480
Quindi diamo una nuova variabile chiamata in J uguale a zero e G minore di quanto possa consentire agli

237
00:18:21,630 --> 00:18:24,710
studenti greci di I OK.

238
00:18:24,760 --> 00:18:31,120
Quindi nella prima iterazione questo sarebbe studente in gradi di 0 che non è

239
00:18:31,120 --> 00:18:37,000
altro che questo array che corrisponde alla prima classe e dobbiamo dire non

240
00:18:37,510 --> 00:18:44,810
prestare perché è necessario iterare attraverso questi elementi e G plus più OK e qui dire

241
00:18:48,280 --> 00:18:49,690
la visualizzazione della

242
00:18:52,570 --> 00:18:53,710
sezione e

243
00:18:56,680 --> 00:18:59,020
quelle uve verranno stampate qui.

244
00:18:59,020 --> 00:19:00,670
Quindi fonte.

245
00:19:01,140 --> 00:19:04,770
Tom Dart OK e invece di I.

246
00:19:04,770 --> 00:19:08,610
Questo sarebbe OK.

247
00:19:08,640 --> 00:19:17,100
Quindi stiamo mostrando gli studenti dagli uve degli studenti in ogni sezione e all'interno di ogni sezione che

248
00:19:17,100 --> 00:19:19,320
stiamo visualizzando queste uve.

249
00:19:30,260 --> 00:19:30,500
OK.

250
00:19:30,510 --> 00:19:30,930
Ecco qua.

251
00:19:30,930 --> 00:19:35,700
Quindi stai dicendo alla sottosezione Spangler 0 e stiamo mostrando lo ione dell'uva abbastanza che la

252
00:19:35,700 --> 00:19:38,740
Sezione 1 è mostrata qui e 2 viene mostrata qui.

253
00:19:38,760 --> 00:19:44,910
Ora un'ultima cosa finale è anche trovare il voto più alto in ciascuna delle sezioni e mostriamo

254
00:19:44,910 --> 00:19:45,940
anche quello.

255
00:19:46,020 --> 00:19:49,410
Quindi usiamo una scheda variabile Max, diciamo.

256
00:19:49,410 --> 00:19:58,610
E Max è uguale a zero e dobbiamo trovare il massimo.

257
00:19:58,660 --> 00:20:06,090
Quindi diciamo che nella seconda iterazione diremo F, quindi stiamo procedendo in iterazione in una delle

258
00:20:06,090 --> 00:20:12,440
sezioni qui, quindi nella prima iterazione attuale sarà questa matrice nella seconda iterazione

259
00:20:13,130 --> 00:20:14,930
dell'anello per loop.

260
00:20:14,930 --> 00:20:19,060
Quindi questo sarebbe il secondo Ari della seconda classe.

261
00:20:19,130 --> 00:20:19,800
OK.

262
00:20:19,910 --> 00:20:22,170
E poi io sono uguale a tre.

263
00:20:22,190 --> 00:20:24,190
Stiamo iterando attraverso io uso uguale a due.

264
00:20:24,200 --> 00:20:25,930
Stiamo guidando attraverso questa cosa.

265
00:20:25,960 --> 00:20:30,270
OK, anche se abbastanza per il ciclo attraverso questo particolare essere giusto.

266
00:20:30,350 --> 00:20:37,200
Quindi qui stiamo dicendo se i gruppi di studenti di I arrivano a un g maggiore di Max.

267
00:20:37,490 --> 00:20:44,750
Quindi è inizialmente zero, quindi dobbiamo

268
00:20:48,350 --> 00:21:04,450
riassegnare Max ma uno studente scappa come una magia e finalmente stamperemo il valore massimo qui.

269
00:21:05,120 --> 00:21:08,170
Quindi il ciclo for esterno lo sta stampando.

270
00:21:08,300 --> 00:21:13,430
E in ogni iterazione troviamo anche il massimo e l'uso di Maxwell stampato qui.

271
00:21:13,430 --> 00:21:15,040
Quindi siamo qui per Max è 90.

272
00:21:15,500 --> 00:21:22,220
E quando abbiamo quando siamo nella seconda iterazione stiamo trovando il massimo in questo particolare array.

273
00:21:22,250 --> 00:21:26,230
Quindi nella seconda iterazione il massimo verrebbe re inizializzato di nuovo.

274
00:21:26,330 --> 00:21:29,330
Infatti è dichiarato all'interno di questo ciclo.

275
00:21:29,450 --> 00:21:31,750
Quindi Max viene dichiarato ancora una volta.

276
00:21:32,330 --> 00:21:40,010
Quindi nella seconda iterazione su Prince 71 perché quello è il massimo e quindi il massimo di iterazione finale

277
00:21:40,010 --> 00:21:41,090
sarà 91.

278
00:21:41,870 --> 00:21:45,500
Ecco come puoi trovare il valore massimo qui.

279
00:21:46,100 --> 00:21:47,720
Quindi questo è tutto.

280
00:21:47,720 --> 00:21:48,260
Grazie.

281
00:21:48,270 --> 00:21:51,030
E chiama questo e basta.

282
00:21:51,030 --> 00:21:53,390
Codifica infelice e ci vediamo nella prossima lezione.