Ciao.
Questo è che non vogliono.
E bentornato.
Quindi sappiamo come una buona comprensione della prima affermazione e nell'ultima lezione abbiamo esaminato questo particolare esempio
di prima affermazione.
E abbiamo visto come questa prima affermazione potrebbe essere rappresentata in modi diversi.
E diciamo anche che questo è il modo più comune in cui una prima affermazione sarebbe rappresentata.
Cioè avremmo una dichiarazione di inizializzazione e avremmo qualche condizione e
quindi avremo questa espressione dove incrementiamo la variabile.
Destra.
E in questa conferenza andiamo avanti ed esploriamo un po 'di più la prima affermazione e vedremo la
base comune in cui viene tipicamente utilizzata una prima affermazione.
OK.
E questo è davvero molto utile per i principianti assoluti perché vedremo i diversi modi in
cui le dichiarazioni di inizializzazione e le espressioni di condizione qui le condizioni booleane e
le espressioni di espressione possono essere impostate per diversi problemi.
Va bene.
Quindi sarà molto utile per i principianti assoluti e guarderemo in particolare a come attraversare o
iterare attraverso un array monodimensionale.
Abbiamo già un'idea di base a partire dall'ultima lezione e vedremo anche come un
array bidimensionale o multidimensionale può essere iterato usando istruzioni nidificate.
Va bene.
Quindi vedremo anche le prime dichiarazioni annidate e vedremo anche un semplice esempio in cui
useremo una falsa dichiarazione ma non andremo a ripetere un array.
Va bene.
Quindi è un esempio in cui un array non viene utilizzato in una falsa dichiarazione.
Andiamo avanti e guardiamo questo.
La prima cosa è cambiare questo.
Qui stiamo incrementando di 1.
Quindi qui stiamo iterando attraverso questo particolare array.
Cambiamo solo a 2.
OK.
Quindi incrementeremo anche la variabile i bit.
OK.
In ogni iterazione verrà incrementato di 2.
Quindi questo è solo per mostrare che l'espressione incrementale non deve essere solo una.
OK.
Possiamo anche incrementare di più di uno.
Quindi fammi ricompilare questo.
Quindi questo è in classe demo di base.
E qui siamo nella directory di base.
Quindi sto solo facendo le modifiche nel metodo principale okay.
Ecco qua, stampa 0 2 4 6 e 8.
Va bene.
Quindi andrà a saltare 1 3 5 7 sotto verrà stampato solo 0 2 4 6 8.
Quindi sta stampando tutti i valori alternativi e questo può essere qualsiasi valore, puoi anche renderlo tre o quattro
e così via.
Quindi questa è una cosa.
Ora diciamo che vogliamo stampare questo in ordine inverso.
OK.
Quindi partiamo da qui alle nove.
E dobbiamo stampare nell'ordine inverso.
Quindi, dal momento che dobbiamo iniziare dalle nove.
Quindi dobbiamo prendere che leggo o presta meno uno.
OK.
Perché sappiamo che l'ultimo elemento sarebbe il punto zero meno uno.
E qui dichiareremmo che invece di incrementare e questo sviluppo può anche essere di qualsiasi valore può
essere io. e. uguale a A meno due su così via.
E qui dal momento che stiamo andando nella direzione opposta deve essere maggiore o uguale a zero.
Quindi intendiamo dire fino a raggiungere il prossimo numero zero.
Quindi questo
dovrebbe essere stampato in ordine inverso.
Ecco qua.
Quindi, basta stampare tutti i valori nell'ordine inverso.
Ora diciamo che vogliamo invertire gli elementi in questa particolare area.
A volte vorremmo farlo nella libreria Java, fornendo anche un metodo in una delle classi per
invertire gli elementi in soffitta.
Quindi, quando diciamo che vogliamo invertire gli elementi, Nove deve entrare nell'ultimo elemento deve
andare nella prima posizione e l'elemento nella posizione 0 8 dovrebbe andare nell'ultima posizione dove un otto deve andare
qui e uno ha per andare in ottava posizione.
Quindi lo faremo più avanti usando la prima affermazione, ma in ogni iterazione che stiamo facendo stiamo scambiando
gli elementi pagati.
Quindi nella prima iterazione dovremmo scambiare 0 9 e nella seconda iterazione dovremmo scambiarne uno su otto nel terzo, faremo
un passo due e sette e poi tre e sei e poi quattro e cinque sotto e finiremmo
con quello.
Quindi in ogni iterazione abbiamo bisogno di come accedere a due numeri indicizzati.
Destra.
Ad esempio nella prima iterazione sarebbe zero e l'indice corrispondente a questo che
sarebbe nove.
Quindi dovremmo usare due variabili per questo.
Ora vorrei che tu mettessi in pausa il video qui e provassi a scrivere la logica per quello.
Puoi prenderlo in cinque minuti per quello e prenderò cinque secondi di
pausa e poi tornerò e ti mostrerò come scrivere il codice, ma ti suggerirei di fare
il video e provarlo e poi puoi vedere se la tua soluzione corrisponde alla mia o non va bene.
Spero che tu l'abbia fatto.
Quindi andiamo avanti e scriviamo il codice e puoi confrontarlo con il mio.
Quindi la prima cosa è che abbiamo bisogno di due variabili Foster.
Sarei zero, quindi abbiamo bisogno di un'altra variabile, chiamiamola come una J e J mi permetterebbe anche di copiare questo.
Avremmo bisogno di
questo qui J sarebbe irato o alla fine meno uno.
Va bene.
E qui sarei incrementato di uno in ogni iterazione e J sarebbe decrementale in
ogni iterazione che sto ora arrivando a questa espressione della condizione sarebbe minore di J.
Va bene, è così.
E dobbiamo anche scrivere la logica qui, quindi la condizione è inferiore a G.
Quindi inizialmente sarei zero G sarebbe nove qui e nella seconda iterazione sarebbe 1 su 8.
Quindi quegli elementi sarebbero scambiati nella terza iterazione 2 e 7 sarebbero scambiati e 3 e 6 e 4
e 5.
Questo è quando io sono meno di G.
E nella successiva iterazione sarei 5 e J sarebbe 4.
E questo è quando usciremo dalla prima affermazione.
Va bene così è così che anche il numero pari di elementi come in questo caso
ci sono 10 elementi ma se siamo come il numero di elementi di cui tre e cinque verrebbero
eliminati, avremmo incrementato da 1 a 3 su J sarebbe decrementale cinque e dopo I e J sarebbero quattro.
Quindi la condizione è ancora inferiore a J.
Ma noi come io sono uguale a G qui.
E così la prima affermazione sarebbe uscita lì.
Quindi la condizione sta dicendo se noi stessi come il numero di elementi sia il nostro numero di elementi.
Va bene, è così.
E ora arrivando alla logica nel corpo.
Quindi la prima cosa è definire una variabile temporanea e memorizzare l'elemento giusto nella prima iterazione che sarebbe
zero elemento.
Quindi diremmo che io
Va bene così che è memorizzato in temp che
significa che possiamo prendere l'elemento jet e salvarlo in ottava posizione.
Va bene.
E dopo
quello nella posizione del getto dovremo memorizzare il valore in temp che ha il valore aggiuntivo che era in
posizione.
L'ho visto come lo scambio e andiamo avanti e
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
stampare nella stessa riga.
Quindi diciamo plus e whitespace in modo che stampi tutti gli elementi nella stessa riga.
Quindi stiamo stampando da 0 a lunghezza meno 1.
Quindi questo è solo per la stampa degli elementi.
Quindi andiamo avanti e aggiungimi compilatore e ricompilalo ed eseguilo.
Ecco qua.
Quindi gli elementi sono stati invertiti.
Va bene così è.
Quindi quando uso uguale a G è quando siamo usciti dal ciclo.
Ora possiamo anche invece di J.
Possiamo anche vedere che I Ari non presta più di 2.
Quindi possiamo usare questo tipo di condizione perché leggo che cosa è la terra e poi di due come cinque.
Quindi, fino a quando ne uso meno di cinque, siamo buoni, ma non appena ne avrò cinque, usciremo dal ciclo.
Quindi questo è un modo diverso in cui la stessa espressione può essere scritta la stessa prima affermazione.
Quindi questo è solo per darti un'idea.
E come possiamo rappresentare una dichiarazione lontana in modi diversi e ottenere lo stesso risultato, anche tu
ottieni gli stessi valori ora qui.
Quello che sta accadendo è in ogni iterazione che stiamo eseguendo questa operazione di divisione.
Quindi se hai migliaia o un milione di elementi, allora sai che sarebbe intensivo dal punto di vista computazionale.
Sarà molto costoso.
Quindi, perché in ogni iterazione dobbiamo fare questo calcolo in modo che possiamo fare un'ottimizzazione
e l'ottimizzazione è che prenderò questa espressione da qui e definirò un'altra variabile qui nella parte
dell'istruzione di inizializzazione e che è chiamata come media e diciamo così.
E ora vedremo il metallo.
Quindi in questo caso sappiamo che la parte dell'istruzione di inizializzazione viene eseguita solo una volta.
Quindi questa espressione sarebbe anche calcolata una sola volta e ciò sarebbe sufficiente per noi.
Quindi è calcolato una volta su quel valore sarebbe plug qui.
E così con ogni iterazione non ricalcolare questo valore di metallo.
È fatto solo una volta.
Quindi questo viene fatto solo una volta che sappiamo che questo viene valutato solo una volta.
Ma l'espressione di condizione così come l'elenco di espressioni è ciò che viene valutato con ogni iterazione.
Tutto ok.
Andiamo avanti e ricontrolliamo i nostri risultati ancora
una volta invariato.
Quindi otteniamo gli stessi valori.
Quindi questa è un'ottimizzazione.
Ora puoi pensare se c'è un modo per ottimizzarlo ulteriormente.
Quindi qui stiamo dicendo divisione per 2 Ora si può ricordare che il turno di destra senza segno può essere
usato per quello perché è equivalente alla divisione per potenza morbida.
OK, quindi qui lo renderà uno perché abbiamo bisogno di dividere per due.
Quindi questo è come un punto terra diviso per due al potere di uno.
E sappiamo che gli operatori di The Big Shift sono molto più efficienti della moltiplicazione e della divisione.
Quindi possiamo usare un turno a destra senza segno per l'operazione di divisione.
Verifichiamo di nuovo la verifica in modo che l'output sia lo stesso.
OK.
Quindi questo è quello.
Ora voglio anche dire che per lo più utilizziamo le istruzioni per scorrere le strutture di dati come array o altre strutture
di dati che esploreremo in seguito, ma è possibile utilizzare anche la prima istruzione e altri problemi, ad esempio se
si desidera semplicemente eseguire un'iterazione di alcuni logica per un numero di volte che può
essere utilizzato.
Ora un esempio semplice di esempio in cui un array non è usato come un problema di esempio che tu
sei comunemente visto in comune nei corsi di programmazione come contare il numero di consulenti di un particolare valore
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
va bene se il resto è 0.
Quando dividi per Y, allora è una com e poi diciamo che yz è l'advisor per x.
Quindi per un dato numero chiamiamo il numero di dispositivi che ha.
OK, quindi diciamo, colpiscilo, è molto semplice chiamiamo
il numero 24 e dovremmo trovare tutti e B.
Dovremmo scoprire quanti dispositivi ha.
Quindi usiamo una
variabile e concepiamo quindi uno ne includerebbe uno e 24 per ventiquattro uno e ventiquattro
e ci sarebbero altri dispositivi tra 1 e 24.
Quindi deve iniziare con 1 e non 0.
E abbiamo bisogno di scorrere fino a 24.
Quindi questo è minore o uguale a x e I più più e in ogni iterazione che facciamo sotto controllo diciamo F X
più i z uguale a zero di X adviser di quanto usassi il mattiniero.
Ok, quindi ci stiamo ritirando da uno a 24.
Quindi in questo caso abbiamo bisogno di incrementare il conteggio e questo è anche un modello di programmazione comune.
Qui abbiamo una prima dichiarazione su ciascuna in ogni iterazione.
Facciamo un controllo e se il controllo riesce solo allora eseguiremo un po 'di logica.
Questo è un modello di programmazione comune che incontri.
Adesso stampiamo il
conteggio e stampiamo anche il dispositivo vero e proprio.
Quindi attaccare questo ritmo
I.
Quindi sembra
buono quindi questi sono tutti i dispositivi 424.
Uno due tre quattro sei otto e quattro.
OK.
Quindi se fai più di 24 di uno di questi numeri ricevi un promemoria di zero.
E quindi ci sono otto di loro.
Quindi questo è quello.
Ora diciamo per esempio vediamo ora una dichiarazione annidata per istruzioni nidificate.
Arrivano anche molto comunemente quando stiamo programmando specialmente se tu come una struttura di dati come una matrice.
E se ogni elemento è anche un altro array che è simile a una tridimensionale
non a una tridimensionalità oa una qualsiasi struttura di dati i cui elementi sono altre strutture di dati, allora puoi usare
un'istruzione di forza in cui l'istruzione di forza esterna dovrebbe scorrere attraverso la struttura dei dati è una
specie di una schiera e l'enunciazione della forza interiore itereranno attraverso l'esercito attraverso ciascuno degli elementi, perché ognuno di
essi può essere qualcosa come un array.
Quindi diamo un'occhiata a questo.
E una cosa è che ho menzionato in precedenza nell'ultima conferenza poiché lo scopo di queste variabili termina con il
ciclo for.
Quindi qui abbiamo l'occhio è uguale a zero e puoi vedere che ne abbiamo usato un altro e
io uguale a zero qui perché questo occhio è diverso da questo perché lo scopo dell'occhio variabile e
così questo blocco particolare.
E allo stesso modo anche come l'occhio qui sulla variabile della X lo scope sarebbe da qui fino alla
fine del metodo.
Il metodo principale in seguito esaminerà formalmente anche la portata variabile in un paio di conferenze da ora.
Quindi la prima cosa è questa.
Quindi lasciatemi solo copiare un po 'di codice qui
così qui.
Diciamo che questi sono.
Quindi qui abbiamo un bidimensionale oggi e lo definiamo uno studente fantastico.
Quindi rappresenta alcuni gradi dello studente.
Diciamo che questo elemento qui il primo elemento del vero array è un array sotto disceso ha i
gradi di studenti in una particolare sezione su una particolare classe.
E questo è il gruppo di studenti nella seconda sezione della seconda classe e i voti per la
terza classe.
Ora vogliamo ripetere questo particolare array di pulley e mostrare tutti questi elementi.
Quindi prima avremo una prima dichiarazione esterna e all'interno ne avremmo altri quattro.
Così veloce dirò e io sono uguale a zero meno che
terra quindi sarebbe tre perché ci sono tre elementi e quindi ne avremmo due in ogni iterazione come un
elemento che è una matrice B.
Quindi abbiamo bisogno di scorrere questo e per questo usiamo un altro ciclo annidato.
Quindi diamo una nuova variabile chiamata in J uguale a zero e G minore di quanto possa consentire agli
studenti greci di I OK.
Quindi nella prima iterazione questo sarebbe studente in gradi di 0 che non è
altro che questo array che corrisponde alla prima classe e dobbiamo dire non
prestare perché è necessario iterare attraverso questi elementi e G plus più OK e qui dire
la visualizzazione della
sezione e
quelle uve verranno stampate qui.
Quindi fonte.
Tom Dart OK e invece di I.
Questo sarebbe OK.
Quindi stiamo mostrando gli studenti dagli uve degli studenti in ogni sezione e all'interno di ogni sezione che
stiamo visualizzando queste uve.
OK.
Ecco qua.
Quindi stai dicendo alla sottosezione Spangler 0 e stiamo mostrando lo ione dell'uva abbastanza che la
Sezione 1 è mostrata qui e 2 viene mostrata qui.
Ora un'ultima cosa finale è anche trovare il voto più alto in ciascuna delle sezioni e mostriamo
anche quello.
Quindi usiamo una scheda variabile Max, diciamo.
E Max è uguale a zero e dobbiamo trovare il massimo.
Quindi diciamo che nella seconda iterazione diremo F, quindi stiamo procedendo in iterazione in una delle
sezioni qui, quindi nella prima iterazione attuale sarà questa matrice nella seconda iterazione
dell'anello per loop.
Quindi questo sarebbe il secondo Ari della seconda classe.
OK.
E poi io sono uguale a tre.
Stiamo iterando attraverso io uso uguale a due.
Stiamo guidando attraverso questa cosa.
OK, anche se abbastanza per il ciclo attraverso questo particolare essere giusto.
Quindi qui stiamo dicendo se i gruppi di studenti di I arrivano a un g maggiore di Max.
Quindi è inizialmente zero, quindi dobbiamo
riassegnare Max ma uno studente scappa come una magia e finalmente stamperemo il valore massimo qui.
Quindi il ciclo for esterno lo sta stampando.
E in ogni iterazione troviamo anche il massimo e l'uso di Maxwell stampato qui.
Quindi siamo qui per Max è 90.
E quando abbiamo quando siamo nella seconda iterazione stiamo trovando il massimo in questo particolare array.
Quindi nella seconda iterazione il massimo verrebbe re inizializzato di nuovo.
Infatti è dichiarato all'interno di questo ciclo.
Quindi Max viene dichiarato ancora una volta.
Quindi nella seconda iterazione su Prince 71 perché quello è il massimo e quindi il massimo di iterazione finale
sarà 91.
Ecco come puoi trovare il valore massimo qui.
Quindi questo è tutto.
Grazie.
E chiama questo e basta.
Codifica infelice e ci vediamo nella prossima lezione.