Ciao e Benvenuto.
Vorrei fornire una soluzione per la sfida del tic tac toe.
Ora ricorda, ce ne sono molti soluzioni a un dato problema.
Questa sarà solo la mia soluzione.
Se la tua soluzione è diversa fintanto che segui una
buona pratica di programmazione e usi il linguaggio di programmazione c nel
modo corretto, allora va bene.
Sto solo fornendo la mia soluzione.
Sono sicuro che può essere migliorato.
Quindi iniziamo.
Creerò un nuovo file il progetto si chiama ovviamente tris,
e lo faremo inizia a provare a modulare.
Ho provato a scomporlo come ho fatto nella descrizione della lezione.
Creerò un file solo pochi moduli o dovrei
dire poche funzioni.
Si spera che sia così va bene e lavora bene per te.
Sto usando la custodia del cammello per tutti i miei nomi convenzioni proprio quello a cui sono abituato.
Potremmo addirittura separarci questo anche in più file sorgente, se
lo volessimo.
Quindi abbiamo il nostro principale.
Liberiamoci di questo printf.
Sto per includere un ulteriore include.
Questo mi permetterà fondamentalmente fai un po 'di pulizia del nostro sistema e un
paio di cose carine, permetti anche a me penso di rimuovere un carattere.
Quindi oltre a questi 2 librerie, includiamo conio. h.
E quello che voglio fare e io voglio affrontare questo problema.
Voglio provare a modulo più che posso.
Ho detto che sto andando utilizzare un
array monodimensionale, un array bidimensionale potrebbe anche funzionare meglio.
Ma ho intenzione di implementare questo utilizzando un
array monodimensionale che rappresenta il nostro gioco board, la nostra tavola da tris.
Lo creerò come variabile globale.
Sto usando una variabile globale qui perché
non ho dimostrato il concetto di passaggio di dati per riferimento in c.
Non voglio confonderti.
Non dovrei usare globale dati qui e potrei
passare i dati alle funzioni, ma lo farei è necessario utilizzare il passaggio per riferimento.
Dovrei passare in giro suggerimenti, e non abbiamo ancora discusso
nulla di tutto ciò.
Quindi userò i dati globali.
Perdonami, ricorda che i dati globali sono di solito non è una
buona cosa da fare ma perché, ancora una volta, ci stiamo provando dimostrare l'apprendimento, la divisione, la conquista e
stiamo cercando di dimostrare come utilizzare le funzioni, ho bisogno di utilizzare i dati globali
perché noi non ho ancora parlato di indicatori.
Quindi i miei dati globali qui che sto andando da usare è il mio quadrato che
rappresenta la mia griglia, il mio tris.
Questo sarà un singolo area dimensionale di
10 elementi principalmente perché I. non voglio usare l'elemento 0.
Userò questo array per scegli i numeri per giocare.
Consentirà anche io per avere le mie coordinate.
Lo inizializzerò con solo valori da 1 a 9.
E questo sarà un file array di caratteri perché ho bisogno
di inserire x e o.
Non abbiamo parlato di carattere array ancora, ma questo mi permetterà di
inserire singoli caratteri.
È proprio come il concetto di matrice di int tranne che contiene caratteri.
I personaggi, ricorda, l'hanno fatto virgolette singole intorno a loro.
Quindi uno 2 3 9 il, 0 lì la o sto solo
per saltare, non userò nemmeno, perché voglio usare quelli.
Rende la programmazione un po 'più semplice.
Posso usare il valore che l'utente entra come indice, come indice valido.
Anch'io dovrò farlo creare 2 variabili globali per la scelta
nel turno del giocatore.
Quindi la scelta sarà quello che loro inserito tramite la tastiera, da uno a
9 a seconda di dove vogliono mettere la loro xo o.
Il giocatore sta per solo rappresenta il
turno del giocatore, giocatore uno o giocatore 2.
Non ho bisogno di altri dati globali.
Ho solo bisogno della mia funzione dichiarazioni qui.
Sto per iniziare con la creazione di 3 funzioni.
Quindi ne avrò 3 dichiarazioni di funzione.
Ne avrò uno per verificare la vittoria.
Non prenderà dati.
Restituirà un int.
Ne avrò uno che non lo fa restituire tutti i dati
che, visualizza solo la scheda con i caratteri corretti.
Inoltre non richiede dati.
E avrò anche un file funzione che segna solo il tabellone.
Questo richiederà l'input dell'utente.
E a seconda di cosa sono entrati, posizionerà una xo o nel punto
corretto dell'array e quindi verrà visualizzato quell'array usando il tabellone.
Quindi qui stiamo solo per dire mark board e questo prenderà effettivamente
un segno con una xo o.
Quindi posso riutilizzarlo.
Posso riutilizzarlo per giocatore uno o giocatore 2.
3 dichiarazioni di funzione in modo che io possa posizionare le mie funzioni ovunque
nel programma, le ho dichiarate in alto.
E noterai che il 2 di questi le funzioni non restituiscono alcun dato
e solo una sta prendendo un parametro.
Implementiamo queste funzioni prima di implementare il gioco.
Quindi prima, andiamo implementare il controllo per vincere.
Questa funzione sta fondamentalmente lavoro dove controllerà il tabellone per vedere
se c'è qualche vincita.
Quindi conterrà molte istruzioni if.
Probabilmente potrei migliorare questo codice un bel po '.
Ma metterò alcuni commenti qui perché dovremmo sempre avere commenti
nella parte superiore della nostra funzione.
Questi sono piuttosto semplificati.
Dovremmo avere il nome della funzione.
Questo fondamentalmente sta dicendo quello la funzione restituirà
uno stato di gioco di uno se il gioco è finita, ti dico se hai
vinto, risultato negativo se il la partita è in corso e 0 se la partita è
finita ed era un pareggio.
Quindi questa funzione controlla si sta restituendo un int.
Quindi vado avanti e definire questo.
E tutto ciò che farà è guarderà l'array
e vedrà se ci sono punti lì, se 3x è abbinato.
Quindi ce ne sono molti istruzioni if diverse.
Allora come facciamo a sapere se un giocatore lo è.
Bene, sappiamo se un giocatore lo è uno se corrispondono in una riga diagonale
o in una colonna.
Quindi dobbiamo controllare ciascuno una di quelle situazioni.
E conosciamo le righe nel file colonne basate sull'array.
Quindi se il mio quadrato è uguale al quadrato 2 e
il quadrato 2 è uguale al quadrato 3, ciò significa che noi avere una corrispondenza nella nostra prima fila.
Quindi lo farò anche io creare un valore di ritorno qui.
In alto, dirò solo valore di ritorno, inizializzalo a 0.
Lo inizializzeremo a 0 per la fine del gioco.
E se abbiamo una corrispondenza in la prima riga, ne
torno una, il gioco è finito.
Dobbiamo quindi avere una serie di altri se per abbinare e in realtà non
voglio tornare uno voglio impostare il mio valore di ritorno.
Perché potremmo tornare, ma è così rende il programma più difficile da seguire.
Altrimenti, lo faremo controlla tutte le nostre altre righe.
Quindi copierò e incollerò un po 'di codice qui perché
è un sacco di codice ridondante.
L'unica cosa che è interessante è se abbiamo un pareggio.
Quindi fammi inserire tutti i file altrimenti se per i vincitori.
E poi lo farò anche io restituisce valori diversi.
Invece di avere un mucchio di altro se, potrei avere la e commerciale, ma
è ancora più difficile da leggere.
Quindi se abbiamo una corrispondenza in prima fila.
E assicuriamoci che il nostro il rientro è corretto.
Se abbiamo una corrispondenza nella nostra seconda riga, questo è quello che sta facendo il secondo.
Se abbiamo una corrispondenza nella nostra terza riga, restituisci uno aggiungi alcune nuove righe per
la leggibilità, non servono parentesi perché sono dichiarazioni singole.
Sulla linea 37, sembra stiamo abbinando uno, 4 e 7.
Quindi questo sembra un file corrispondenza diagonale, restituisci uno.
Quaranta, abbiniamo 2 5 e 8.
Sembra una partita del centro scendendo, quindi la seconda colonna.
3 6, puoi vedere il file anche altre partite.
Fondamentalmente dobbiamo prendere tutte le partite per righe, colonne e diagonali.
Ed è quello che abbiamo fatto con tutto queste dichiarazioni cercano nell'array.
Ora l'unica cosa che ci dice se noi non abbiamo una partita o abbiamo un pareggio è
dobbiamo confrontarli tutti e fondamentalmente assicurati solo che non siano i numeri
che sono stati inizializzati.
Quindi, se abbiamo il nostro array quadrato e non contiene 1 2 3 1 2 3 4
5 6 8 o 9 per nessuno dei valori, significa che abbiamo un pareggio perché contengono
uno 0 o una x.
Quindi possiamo scrivere un altro altro se questo
in pratica dice che è un pareggio e possiamo impostare il valore di ritorno a 0, restituisce un valore uguale a 0.
E di nuovo questo è solo fondamentalmente controllando quest'ultimo altrimenti se, se i
numeri sono gli stessi come sono stati inizializzati.
Se sono tutti diversi, allora ciò significa che possiamo restituire 0.
Mettiamolo uno.
Altrimenti, se non abbiamo un file pareggio e non abbiamo un vincitore,
significa che non abbiamo finito.
Quindi un'ultima dichiarazione di altro può solo dire il valore restituito è uguale a uno negativo.
Perché ricorda, la funzione è restituendo uno negativo per
partita in corso, uno per partita terminata e 0 per il gioco senza risultato.
E poi l'ultima cosa che voglio fare è Voglio restituire il valore di ritorno.
Quindi qui sto solo andando dì ritorno, valore di ritorno.
E questo completerà la funzione.
E cosa noti quando stiamo facendo questo, stiamo
dividendo e conquistando.
Tutti ci stiamo concentrando sul giusto ora sta controllando il tabellone per vedere se
c'è una vittoria.
Lavoreremmo in piccolo blocchi proprio come questo e
li testeremmo costantemente.
Questo ci permette di concentrarci sul nostro design e ci permette anche di ridurre o isolare
i nostri errori più facilmente.
Ora che abbiamo finito con il file tabellone, vogliamo andare
avanti e implementare il tabellone.
Il tabellone è giusto andando a mostrare il tabellone.
Quindi tutto ciò che serve davvero è disegna l'array in un formato specifico.
Quindi scriveremo un file funzione denominata tabellone.
Non restituirà alcun dato, non prenderà alcun parametro.
Il motivo è un numero di funzione uno
è perché dovremo disegnare il tabellone molte volte ed è anche solo meglio perché
sta facendo un compito specifico.
Ora questo avrà un sacco di funzioni printf in esso.
E avrà un sacco di formattazione.
Quindi lo copierò e incollerò.
La cosa unica qui è Pulisco lo schermo ogni volta.
Ma se dici system e Windows e dici cls, questo cancellerà
lo schermo.
Lo rende solo più pulito.
Allora andremo a solo fare un sacco di printfs.
Stamperemo il titolo del gioco. Stamperemo i player 1 e 0.
E poi andiamo per stampare la lavagna.
Il consiglio andrà bene formattato con alcune barre parallele
e poi stamperemo il file valori di tutti i valori nell'array.
E se il valore è x o 0, verrà visualizzato.
In caso contrario, verrà visualizzato un file numero in modo che possiamo usare quel numero
per selezionare la nostra opzione per disegnare e questo è è tutto ciò che fa questa funzione.
Ora che abbiamo finito visualizzando la scheda,
ora vogliamo creare la nostra ultima funzione che segna il tabellone.
Quindi mark board sta per impostare l'array con un valore particolare
e verrà digitato un segno in una x o in una o.
Quindi ci vorrà un personaggio.
Quello che sta per fare è avrà
un sacco di altre istruzioni if.
Quindi qui nel nostro tabellone, siamo
voglio fondamentalmente dare alcuni commenti e dire che questo sta per
impostare la scacchiera con il carattere corretto xo o nel punto corretto dell'array.
Quindi spero che abbia senso.
Come vedi il codice I devo terminare i miei commenti.
Voglio formattarlo bene quindi sono 2 righe qui.
E tutto questo farà controllerà
per vedere cosa ha inserito l'utente.
Quindi ricorda, abbiamo 2 dati globali valori per ciò che l'utente ha inserito.
Abbiamo anche un valore per il giocatore corrente.
Quindi la scelta sarà fondamentalmente ciò che viene inserito tramite la tastiera.
Non l'abbiamo ancora implementato perché lo implementeremo
nella funzione principale.
Il giocatore lo sarà il giocatore corrente.
Avremo bisogno di entrambi di questi per lasciare il segno.
Quindi quello che faremo è lo siamo avrà un
sacco di dichiarazioni else, if else.
Stiamo andando a verificare la scelta, quale è l'input dell'utente.
E se la scelta è uguale a 1, noi voglio disegnare qualcosa in quel quadrato.
Vogliamo anche essere sicuri che quel quadrato sia disponibile.
Quindi se è uguale a 1 e non lo è attualmente uguale a 1, significa
che in pratica qualcuno ha già messo una x o un o là e non possiamo usarlo.
Se è uguale a uno e loro inserito uno, ciò significa che possiamo
impostare l'array su un valore specifico.
Stiamo per impostare l'array su cosa è stato passato sia nella o nella x.
E lo ripeteremo per fare questo per ogni scelta.
Se sono scelte 2 3 4 5 6 8 o 9.
Quindi un sacco di altri se che fanno la stessa cosa.
Se l'utente ha inserito la scelta 2, siamo assicurandoti che il rientro
sia buono e che il quadrato 2 sia disponibile, contrassegneremo il quadrato 2 con tutto ciò che
abbiamo passato qui.
E a seconda di quale giocatore è il turno è, passeremo in an o x.
Ora l'ultima cosa che dobbiamo fare questa funzione è che dobbiamo convalidare.
Se hanno passato qualcosa diverso da uno a 9, allora è
una mossa non valida.
Quindi la nostra ultima dichiarazione qui stamperà un messaggio che dice mossa non valida, lo farà segna il giocatore in
basso di uno.
Perché ricorda i giocatori sono uno o due.
E contrassegneremo il giocatore indietro e poi lo incrementeremo nel nostro
ciclo sulla nostra funzione principale.
E poi quest'ultima cosa ottiene char sta solo mettendo in pausa il programma in
modo che l'utente debba premere ritorno dopo una mossa non valida.
Altrimenti, la mossa non valida lo farebbe essere visualizzato e quindi
verrebbe immediatamente cancellato perché ridisegneremo di nuovo il tabellone.
Quindi prendi char lo mette in pausa.
Ti costringe a premere il pulsante Invio per passare ad inserire un altro valore.
E queste sono le nostre 3 funzioni.
Ricorda, questa funzione non restituisce nulla.
Quindi possiamo tenerlo in fondo.
Ora dobbiamo effettivamente implementare il gioco.
Il gioco va nella funzione principale.
Quindi per il gioco, ecco dove chiederemo all'utente di inserire un numero,
disegneremo il bordo, stiamo andando a controllare per vincere.
Quindi creeremo 2 variabili locali qui e inizializzeremo
il nostro lettore.
Qui stiamo andando crea il nostro numero intero I.
Questo verrà utilizzato per il nostro ciclo.
E il nostro segno sarà x oppure o, a seconda di chi è il turno.
Mark sarà x o o credo.
Mark sarà xo o.
E la scelta sarà cosa l'utente accede tramite la tastiera.
Quindi 2 variabili locali.
Stiamo anche impostando il nostro player, che è una variabile globale.
Inizialmente, succederà essere il primo giocatore per iniziare il gioco.
Quindi avremo un ciclo.
Fondamentalmente avremo un un loop fino a quando non abbiamo finito di suonare.
Userò un po 'di tempo loop qui perché voglio che
venga eseguito almeno una volta.
Voglio visualizzare il file bordo almeno una volta.
Quindi visualizzerò il file board e giocare
finché non ottengo un pareggio o una vittoria.
Quindi lo farò finché come io è uguale a negativo 1.
Cosa rappresenta un 1 negativo, esso rappresenta che il gioco è in corso.
Sarò il ritorno valore per verificare la vittoria.
E lo vedrai in un secondo ma fondamentalmente quando
ho un ciclo che continua a fare la stessa cosa e fino a quando il gioco è finito.
E il gioco sarà finita se non è negativa.
Allora cosa dobbiamo fare prima.
La prima cosa che dobbiamo fare è dobbiamo mostrare il tabellone.
Quindi posso semplicemente chiamare il tabellone delle funzioni.
Quindi dobbiamo calcolare il giocatore.
E il giocatore inizia con il giocatore uno.
Quello che faremo qui
è useremo un operatore ternario e diremo se il giocatore mod 2, allora il
giocatore è uguale a 1 altrimenti è uguale a 2.
Questo è un modo per determinare il giocatore giusto.
Ogni iterazione del ciclo sta andando per passare da uno a 2 o da 2 a uno.
Quando inizia come giocatore uno, dirà giocatore mod 2,
uno diviso per 2 o il resto di uno diviso 2 è cosa, uno.
Quindi se è uno, lo sei sarà il primo giocatore.
E quando torni per il alla prossima
iterazione, player sarà uguale a 2 perché lo incrementeremo.
2 mod 2 è 0.
Quindi se non è uguale a uno, allora il giocatore sarà
uguale al giocatore 2.
Lo imposterà solo su giocatore uno se il giocatore mod 2 è uno.
Ricorda, quel tornitore si spera l'operatore.
La prossima cosa che devo fare è io è necessario ottenere l'input dall'utente.
Quindi qui sto per dire, sto andando per chiedere all'utente di inserire un numero.
Dirò giocatore percentuale d o il giocatore 1 o 2, inserisci un numero e poi metto il giocatore
per stampare, giocatore uno o 2.
Poi leggerò il file input dall'utente utilizzando scanf.
E sarà un numero intero, rappresenterà un punto
sul tabellone da uno a 9.
E vado a immagazzinare quello nella mia scelta variabile.
La scelta è un pollice, quindi io devo passare l'indirizzo e
devo dire la scelta.
Solo se è una stringa lo farei non passare l'indirizzo.
Quindi posso fondamentalmente determinare indipendentemente dal fatto che sia o meno il marchio.
Devo determinare se il segno è una x o un no in base al giocatore.
Quindi userò il file nuovamente operatore ternario.
E ho intenzione di assegnare per contrassegnare una x o una o.
Se il giocatore è uguale a 1, vado da assegnare a contrassegnare la x, la x maiuscola.
Altrimenti, lo farò assegnagli una o, o maiuscola.
Quindi questo operatore ternario è molto utile quando devi assegnare variabili
in base a una condizione.
Di nuovo quello che sta dicendo è se il giocatore è uguale a
1, il segno sarà uguale a x.
Altrimenti, sarà uguale a o.
Il punto interrogativo rappresenta se la valutazione booleana è vera, i
due punti rappresentano se è falsa.
Ora che ho ricevuto la lettera corretta, Posso chiamare la
mia funzione per marcare il tabellone dicendo semplicemente mark bordo, passando la x o la o.
Dopo aver segnato il tabellone e loro hanno effettuato la
selezione, devo controllare se c'è un vincitore.
Ho la mia variabile io quale davvero dovrebbe
probabilmente dovrebbe essere un nome migliore.
Chiamiamolo controllo dello stato, gioco controlla che ne dici o lo stato del gioco.
E lo stato del gioco sarà uguale a uno negativo o 0.
Lo stato del gioco sta per essere uguale a tutto ciò che
viene restituito dall'assegno per vincere.
Perché ricorda, questa funzione lo farà restituisce uno uno 0 o uno negativo.
Uno se il gioco è finito il risultato, negativo se la partita è in corso, 0 se
è finita senza risultato.
Quindi ora che abbiamo archiviato il gioco status, vorremo anche cambiare
la condizione del loop.
Quindi, se lo stato del gioco è uguale a uno negativo,
salteremo fuori dal ciclo.
Altrimenti, tutto quello che dobbiamo fare è cambiare il turno del giocatore.
Come cambiamo il turno del giocatore, incrementiamo semplicemente il giocatore di uno.
In questo modo la prossima volta salirà e sarà 2, e il giocatore
sarà uguale a 2 e torneremo indietro.
Quando fanno tentativi non validi cosa accade nei modelli non validi,
diminuisce il conteggio dei giocatori.
Quando decrementi il conteggio dei giocatori, torni al giocatore corretto.
Quindi, se è uno, lo decrementi a 0, il prossimo turno sarà uno, essenzialmente è
di nuovo il tuo stesso turno.
Ecco perché lo incrementiamo.
Ora se è il giocatore 2, lo incrementiamo di uno.
E quello che succede è 2 diviso 2 è 0.
Quindi in realtà si imposta il giocatore torna a uno.
È così che funziona.
Ma questa è tutta la logica.
Abbiamo fatto molto qui.
Non dovresti scrivere tutto questo codice e prova subito.
Avresti dovuto lavorare con il divide et impera, testando costantemente
mentre esegui il codice.
Ora vado a provvedere questa soluzione, ma eseguiamola
e testiamola.
Funzionerà proprio come ha fatto in la demo della lezione di sfida.
Ma ancora una volta, studia questo codice e crea sicuro di aver capito cosa sta succedendo.
L'uso di array e la divisione conquista l'approccio, ma guarda quanto è
carino questo metodo principale.
È molto facile sapere cosa in corso nel metodo principale.
Tabellone, cambia giocatore e tu probabilmente voglio inserire commenti qui.
Cambia i turni, e poi anche qui ottieni input.
E poi imposta il corretto lettera, imposta il carattere corretto in
base al turno del giocatore.
Non ne hai nemmeno davvero bisogno questi commenti
perché le funzioni sono così descrittive.
Segna scheda, imposta la scheda in base a la scelta dell'utente o la scelta non valida.
E poi il controllo dello stato del gioco per vincere, abbastanza autoesplicativo.
E poi saltiamo fuori se il gioco è finito.
Costruiamo questo.
Si spera che non vengano visualizzati errori, no avvertimenti, non lo facciamo, il che è carino.
Ora eseguiamolo e lo farai vedi funziona proprio come nella nostra demo.
La prima cosa che fa è andando a visualizzare lo schermo.
E lo permetterà noi per stampare una registrazione.
E ha la nostra griglia, una 2 3 4 5 6 7 8 9 il nostro array.
Quindi mi dice il giocatore uno inserisci qualcosa e io
inserisco qualcosa di valido.
E lo disegna, e cancella lo schermo.
Quindi sembra carino.
E ora c'è una x in 3.
Ora è il turno del giocatore 2.
Lascerò fare qualcosa di non valido.
Dice mosse non valide, si ferma.
Ho premuto Invio, ottengo per andare di nuovo giocatore 2.
Ora ne colpisco uno, ridisegna con la o in un punto.
E continuo così fino a abbiamo un vincitore o un perdente.
Quindi cerchiamo di creare un vincitore per così tanto.
Ora x sarà, 2 o è sarà 5, x sarà 6
e o sarà 9.
Game over perché abbiamo appena pareggiato 3 0.
Quindi l'unica cosa che ho dimenticato è stata dopo il ciclo while per visualizzare
le congratulazioni che hai vinto.
E tutto quello che dobbiamo fare lì è dobbiamo controllare lo stato del gioco.
Se lo stato del gioco è uguale a uno, significa un giocatore uno e sarebbe
l'ultimo giocatore a vincere.
Quindi avremmo stampato vince la percentuale d del giocatore.
Altrimenti, stiamo andando per stampare solo un pareggio.
Perché se uscissimo dal nostro giro e lo stato era
negativo, sappiamo che il gioco era finito e ha avuto un
risultato, potrebbe essere così dobbiamo avere quell'ultimo se dichiarazione per visualizzare i risultati.
Quindi ora eseguiamolo di nuovo come vincitore.
E ora lo faremo effettivamente vedere qualcuno vincere.
Quindi lo metto solo valido numeri qui, causano una
rapida vittoria per x e in realtà devi farlo in questo programma perché quello va via.
Ecco fatto, il giocatore uno vince e suonava un altro bel suono lì.
Quindi questa è stata una lunga conferenza.
Mi scuso per la lunga conferenza.
Studierò questo codice, io forniscilo come file sorgente.
Si spera che impari molto metodi in divide et impera.
Grazie