Ciao e Benvenuto.
Vorrei fornire una dimostrazione soluzione alla nostra
sfida precedente che stava implementando un gioco di ipotesi e numeri.
Quindi portiamo in primo piano il codice blocchi,
chiudi il mio progetto attuale e creane uno nuovo.
Questo nuovo progetto sto solo andando per chiamare il gioco del numero di indovinare.
Sarà un file applicazione console.
Quindi sto solo andando chiamalo indovina il numero.
E cosa intendo fare questo per iniziare questo progetto dichiarerò le
mie variabili.
Mi piace sempre dichiarare e sono le mie variabili in alto.
Ma userò anche il generatore di numeri casuali.
Quindi voglio assicurarmene Ho un paio di include.
Stdlib è già presente per impostazione predefinita.
Quindi tutto ciò che devo fare è aggiungere il mio file tempo. h perché ancora una volta questo è per un
generatore di numeri casuali.
Questo è fondamentalmente per il sedile generatore di numeri casuali.
Le altre variabili che sono ciò che serve in questo programma è che
voglio memorizzare i miei numeri casuali.
Quindi sto solo per dire numero casuale, lo inizializzo a 0 fino
a quando non ho ottenerlo dalla libreria attuale.
Quindi dichiara inizializzare.
Creerò una variabile per memorizzare l'ipotesi dell'utente e
la inizializzerò con 0.
Creerò un'altra variabile che sarà il numero di
ipotesi, il numero corrente di ipotesi o in realtà
dovrei dire numero massimo di ipotesi, massimo numero di tentativi e lo inizializzo a 5
perché possono indovinare solo 5 volte.
Devo anche creare un tempo variabile in modo da poterlo utilizzare per il mio
generatore di numeri casuali.
Quindi dirò solo tempo t t.
La prima cosa che voglio fare prima di me chiedere all'utente l'input è
voglio generare il numero casuale.
Immagino di poterlo fare dopo aver chiesto l'utente per l'input, ma è solo facile fare
la prima cosa che fai.
Quindi ho intenzione di inizializzare il mio generatore di numeri casuali, ci
metto un piccolo commento.
Assicurati di usare un buon significato nomi e assicurati di indentare.
Userà quella funzione srand di cui ho parlato a lezione.
Puoi solo passarlo in un seme essenzialmente.
Quindi dirò non firmato e lo sono passerò solo la mia variabile t.
Questo sta per ottenere il tempo è un funzione che ottiene l'ora corrente.
Ho intenzione di passare in t in modo che lo semina e poi lo finisco.
Ora ho effettivamente bisogno di ottenere il mio file generatore di numeri casuali, quindi
dirò di ottenere il numero casuale.
E tutto questo farà è assegnare una variabile a ciò che
viene restituito dalla funzione rand.
Quindi diciamo un numero casuale quale è la mia variabile locale
uguale a e usa l'operatore di assegnazione diciamo rand che sta chiamando una funzione.
Non hai bisogno di sapere niente di tutto questo, ma ho intenzione di iniziarlo con 21.
Ciò garantirà che il mio errore casuale numero è solo compreso tra 0 e 20.
Ora produrrò solo un file accoppiare i messaggi sullo schermo in modo che l'utente
sappia cosa sta facendo.
Quindi ho intenzione di creare un'app di stampa e lo sono dirò che questo è un gioco d'ipotesi.
E poi lo farò anche io dì loro che
ho scelto di nuovo un numero compreso tra 0 e 20, solo così sono informati.
E poi 0 e 20 che devi indovina e terminalo con l'avanzamento riga.
Ora che ho detto loro quello che ho voglio nel gioco, inizierò effettivamente a
riprodurre in loop.
E continuerò fino a quando il mio il numero di tentativi è pari a 5.
Quindi cosa preferirei in realtà fare è che volevo cancellare il mio
numero di ipotesi qui, ma Non voglio inizializzare.
Voglio inizializzare nel mio ciclo solo per dimostrarti che posso farlo.
Se l'ho inizializzato lì, prima del primo punto e virgola nel ciclo for,
potrei tenerlo vuoto.
Quindi per esempio potrei fare qualcosa in questo modo, inizializzalo qui.
E poi nel mio ciclo for, lo farei metti solo un punto e virgola perché
non ho bisogno di fare un'inizializzazione.
Perché ricorda, nel nostro ciclo for, la prima
cosa che hai prima del punto e virgola è l'inizializzazione della variabile di controllo del ciclo.
L'ho già inizializzato quindi non ho bisogno di
farlo, ma non voglio farlo.
Mi limiterò a dichiarare quassù, e lo
inizializzerò quaggiù.
Sto per dire il massimo il numero di ipotesi è uguale a 5.
Questa è la mia variabile di controllo del ciclo, Lo sto inizializzando.
Salterò fuori dal loop se viene raggiunto il mio numero
massimo di tentativi.
Quindi qui direi che in realtà sono lo scriverò in un modo diverso.
Lo scriverò così il ciclo va da 5 a 0.
Quindi il mio numero massimo è 5.
Sarebbe meglio rinomina questa variabile.
Rinominiamolo e dire il numero di ipotesi.
E il numero di ipotesi inizierà come 5.
E lo farò questo va all'indietro.
E quando il numero di ipotesi è 0, voglio saltare fuori dal giro.
Quindi la mia condizione di uscita dal loop, Dirò che il numero di
ipotesi è maggiore di 0.
Guarda cosa sto facendo qui.
Salterò solo fuori dal loop se non ho più supposizioni.
Quindi, se sono maggiore di 0, lo sono rimarrà all'interno del ciclo.
E poi l'ultima cosa che voglio fornire nel ciclo for dopo che il secondo
colon climatico è stato modificato di quella variabile di controllo del ciclo.
Quindi farò solo un meno meno numero di ipotesi.
E cosa dovresti notare in questo ciclo for è
che sto iniziando ... Sto quasi andando indietro.
Inizio a 5 e vado a 0.
Per tutti gli esempi che forniamo in lezione, iniziamo da 0 e saliamo.
Ma puoi fare entrambe le cose non importa.
Stai ancora iterando qui 5 volte.
Ora voglio visualizzare un file messaggio che dice
loro quanti tentativi hanno lasciato.
Quindi dirò printf, e attualmente incorporerò l'operatore ternario qui
poiché non l'abbiamo usato.
Non ho bisogno di farlo in questo modo, ma lo farò in
questo modo solo per mostrarti come stai può usare l'operatore ternario.
Quindi eccomi qui per stamparti avere percent d tentativi rimanenti percent s.
La percentuale d sarà uguale numero di ipotesi e
tr percento s, cambierà.
O ci saranno tentativi o ci proverà.
E quindi cambierò cosa viene visualizzato in base a quante
ipotesi mi sono rimaste.
Se il numero di ipotesi è uguale a 1.
Non voglio pianificare dei tentativi, uno provare è rimasto, non ha senso.
Voglio stampare una prova.
Quindi qui userò il operatore termitario o più
precisamente operatore condizionale.
Dirò se il numero di ipotesi uguale a 1, quindi imposta il numero di ipotesi uguale
a y altrimenti impostalo su IES.
E lo stamperò così cosa sta facendo la percentuale s, qualunque cosa
venga restituita qui.
Quindi questo tornerà o su IES e visualizzare le informazioni
corrette.
Quindi l'ho fatto solo per essere un po 'di
fantasia ti mostra come puoi usare il terminale, stampa le giuste informazioni.
Dopo aver stampato il numero di tentativi durano, poi voglio dire
loro di inserire un'ipotesi.
Quindi ho intenzione di sopportare alcune
informazioni e dì solo printf inserisci solo una supposizione e questo avrà un avanzamento riga.
Quindi inserisci un'ipotesi e poi vado per leggere questa ipotesi usando scanf, sappiamo come leggere
dalla tastiera.
Sarà un numero intero, quindi lo sono farò la percentuale d e
la inserirò nella variabile ipotesi.
Quindi devo usare la e commerciale.
Adesso devo fare il mio controllo.
Devo controllare se lo indovino Sono quello che mi preoccupa.
Quindi eccoci qui un'altra condizione di uscita.
Userò un'istruzione if.
Dirò se il mio immagino sia uguale al mio numero casuale, cosa
voglio fare?
Bene, prima voglio stampare e dì loro che
hanno indovinato correttamente.
Quindi stamperò complimenti, hai indovinato.
Cos'altro voglio fare se indovinano correttamente?
Voglio uscire dal ciclo.
Allora come posso uscire dal ciclo?
Potrei mettere una pausa.
Potrei fare una pausa, quello salterà fuori dal mio ciclo.
Ora, se non era uguale, allora Voglio aggiungere un altro se.
Se non è uguale, voglio controllare assicurati che abbiano convalidato il numero.
Quindi prima ho detto che avresti potuto un ciclo annidato per la convalida in modo
che entrino di nuovo, tu non è necessario farlo, puoi semplicemente
avere un'istruzione f.
Quindi qui voglio convalidare il numero.
Se non è uguale a numero casuale,
voglio assicurarmi che sia compreso tra 0 e 20.
Quindi, se l'ipotesi è inferiore a 0 o stiamo usando
un operatore logico o 2 barre parallele o l'ipotesi è maggiore di 20, che
fondamentalmente sta verificando un'ipotesi non valida.
Se è così e io no userò una parentesi perché ho
solo una dichiarazione qui, le parentesi sono facoltative se hai
solo un'istruzione.
Quindi, se hanno inserito un'ipotesi non valida, tutto quello che farò è printf.
Ho intenzione di stampare ho detto il numero è compreso tra 0 e 20.
E quello che succederà qui non è niente.
Sta solo per stampare quello fuori
e andrà alla prossima iterazione.
Dirà loro come molti tentativi sono rimasti e sta per
entrare a indovinare.
Ora se non lo volevi valido numeri se hanno inserito
numeri validi da non contare come ipotesi, allora puoi avere un ciclo annidato.
Ma se entrano in qualcosa di 25, conterà ancora come un'ipotesi.
Quindi dico solo che ho impostato un file numero compreso tra 0 e 20.
Se hanno inserito un numero valido ma non era corretto, sarebbe
stata la clausola else.
Ecco, sto solo per dire, scusa, numero sbagliato e dirò loro
se lo è maggiore o minore di.
E potrei usare il ternario operatore qui, ma non ho intenzione di farlo.
Quindi aggiungiamo un se anche qui.
Altrimenti se casuale è maggiore di indovina, allora cosa voglio stampare?
Voglio stampare scusa percento d è sbagliato, la percentuale d sarà la loro ipotesi.
Il mio numero è percento s è la prima parola.
Se il casuale è maggiore, il mio numero è maggiore.
Il mio numero è maggiore di quello,
e non uso percentili e ho solo un avanzamento riga.
Altrimenti se il numero casuale è meno che indovinare, quindi voglio dire loro che è più
basso.
Quindi posso fare la copia e incolla la stessa cosa.
Potrei chiedere scusa, il numero è sbagliato il mio numero è inferiore a quello.
E ancora, potresti davvero metti questi 2 altri se.
Potresti averne un altro se
e potresti effettivamente fare una dichiarazione condizionale qui.
Potresti avere l'operatore ternario, ma userò 2 altri se e dirò che è
inferiore a quello.
E poi sarà tutto questo finirà il ciclo.
E se usciamo dal giro e non abbiamo indovinato correttamente e
abbiamo superato il nostro numero di tentativi, poi dirò loro che
avevano 5 tentativi e loro non ho indovinato il numero e dirò
loro il numero.
Quindi un ultimo output per l'utente da raccontare loro che non hanno vinto la partita e dite
loro qual era il numero.
Quindi hai avuto 5 tentativi e hai fallito, il numero era un numero casuale.
Ok, quindi ha senso?
Stiamo facendo molte cose qui.
Usiamo istruzioni if, else istruzioni in un ciclo e stiamo implementando il
gioco dei numeri.
E poi l'ultima cosa siamo noi ritorno dalla funzione principale.
Quindi andiamo avanti e compiliamo e cosa avresti dovuto
fare durante l'intero esercizio?
Avresti dovuto testare e lavorando in piccoli pezzi.
Probabilmente avresti dovuto ha iniziato a lavorare prima,
basta far funzionare il numero casuale testare e compilare e testare.
Quindi inizia il tuo ciclo.
Assicurati che il tuo ciclo venga eseguito solo per il numero di ipotesi, 5 volte al massimo e
poi farlo funzionare e testare.
Quindi chiedi la risposta dell'utente alcune informazioni, fatele funzionare
e testate.
Quindi confronta con quando uscire se indovinano correttamente, testano e poi scrivono le tue
istruzioni if test, è così che lo implementerei.
Quindi costruiamolo e vedi se si compila.
Si spera di non aver commesso errori.
Sto per dire build.
Ho un errore, io avere un numero non valido.
Deve essere un numero casuale, non casuale perché questo è il
nome della mia variabile.
E questa volta l'ho fatto 0 errori 2 avvisi.
Ho una percentuale d aspettati un po 'di corrispondenza int.
Ho dimenticato di spegnere il file numero casuale o l'ipotesi.
L'ipotesi qui e il file indovina e l'altro.
Voglio dire loro che la loro ipotesi scusa immagino fosse sbagliato, non devi farlo,
ma solo una piccola cosa carina.
Ora costruiamolo perché tu voglio sempre correggere i tuoi avvisi.
Vuoi avere 0 avvisi 0 errori.
Ora, quando eseguiamo questo, dobbiamo testare.
E ci sono molti test diversi casi che desideri eseguire qui.
Ti consigliamo di eseguire più test casi perché ricorda che non è mai bene
provare solo una cosa.
Quindi qui si dice che questa è una supposizione gioco,
ho scelto un numero compreso tra 0 e 20, che devi indovina, hai 5 tentativi rimasti.
Quindi ne metterò 16.
Spiacenti, il 16 è sbagliato, il file numero è inferiore a quello.
Proverò ad averlo 8.
8 è sbagliato, meno di quello.
Ne farò 4.
4 è sbagliato, il mio numero è maggiore di quello.
Oh, ho fatto un errore, io non l'ho letto prima.
Quindi è maggiore di 8.
Proviamo 12.
Mi rimangono solo 2 tentativi.
Immagino sia giusto con 12.
Quindi dice congratulazioni.
Ma vuoi anche testare un fallimento.
Vuoi provare alcune cose qui, ma qui fammi provare e
dirò la mia ipotesi e Metterò solo 0.
0 è sbagliato.
Continuerò a inserire 0 e lì credo di aver sbagliato 5 volte.
Dice che hai avuto 5 tentativi e falliti.
Il numero che tu voleva indovinare era 3.
Quindi funziona.
Ora proviamo per assicurarci cosa succede se inseriamo numeri non validi.
se inserisco 45.
Ho detto che il numero è 0 e 20.
Quindi questo è un altro caso di prova e contava come una prova.
Se non volevo quell'account come file provare, potrebbe avere un ciclo annidato.
Penso che questo sia tutto.
Abbiamo testato tutti i casi.
Abbiamo testato i casi in cui hai indovinato con successo.
Abbiamo testato il caso in cui non hai indovinato con successo.
E abbiamo testato il caso in cui hai inserito un numero non valido.
Forse l'unico altro test lo farebbe assicurati che stesse dicendo maggiore di e minore di, che penso che abbiamo testato
nel primo ci avrebbe effettivamente detto per inserire
un valore minore o maggiore di.
Quindi proviamolo.
Quindi questa volta quando inserisco 20, dice meno di quello che è buono.
Adesso sto per entrare 10 e l'ho indovinato.
Quindi immagino che siano veloci.
Ma dovremmo vedere meno di e maggiore che nella stessa uscita.
Prova di nuovo e casuale numero funziona perché sto generando numeri diversi
ogni volta che eseguo il programma.
20 è sbagliato.
Ora proviamo 19.
Proviamo 1 ed è maggiore di quello.
Quindi vedo maggiore e minore di.
Quindi sono abbastanza sicuro che funzioni.
Mi sembra abbastanza buono.
Una cosa che avresti dovuto notare c'era un piccolo bug nel
programma che ti stavo testando.
Quindi quando l'hai eseguito perché lo abbiamo fatto questa interruzione qui, verrà ancora stampato
che ho fallito anche se quando ci sono riuscito.
Quindi avresti dovuto accorgertene che nell'output precedente, immagino
il numero giusto.
È stampato congratulazioni.
Ma poi ha anche stampato I fallito, non sembra giusto.
Quindi il modo per risolverlo sei tu non hai una svolta,
vuoi avere un ritorno.
E così ora quando ritorna
se vinci, non verrà stampato sulla riga 39.
Non verrà stampato fuori che hai fallito.
Quindi un ultimo test e dovresti lo abbiamo rilevato
prima, ma quando costruiamo e indoviniamo correttamente, non visualizzerà un errore.
Quindi possiamo salvare run e quando noi esegui questo, hai 5 ipotesi.
Dirò 10, meno di quello.
Stiamo per dire 6, e l'ho indovinato.
E noterai lì dice congratulazioni.
Non vediamo quell'output extra questo dice che ho anche fallito.
Quindi vuoi essere sicuro di te aggiungi quel ritorno alla riga 30 in
modo che il programma funzioni correttamente.
Potresti aggiungere un'altra istruzione if se volevi in modo
che non stampasse il printf, avrebbe potuto avere una pausa qui e
poi a printf avresti potuto controllare quante ipotesi di conteggio dovevi anche stabilire se era
inferiore a 5 quindi complimenti.
Ma un piccolo bug lì, e spero che tu l'abbia
notato durante il test, il ritorno lo risolverà.
Quindi un piccolo programma accurato.
Spero che questo ti abbia aiutato a imparare a molto sul looping e su
tutte le tue dichiarazioni di decisione e davvero problem solving.
Si spera che tu l'abbia tirato fuori e lo ha progettato
prima di iniziare a scrivere codice, è sempre importante.
Spero che sia di aiuto.
Fornirò il codice sorgente così tu può confrontarlo, vederlo e analizzarlo.
Grazie.