1
00:00:00,000 --> 00:00:13,070

2
00:00:13,070 --> 00:00:13,715
>> ROB BOWDEN: Ciao.

3
00:00:13,715 --> 00:00:17,800
Io sono Rob, e spero che il vostro
gioco per il gioco del 15.

4
00:00:17,800 --> 00:00:22,040
Ora, ci sono quattro funzioni che servono
di attuare in questo programma - init,

5
00:00:22,040 --> 00:00:24,650
disegnare, spostare, e ha vinto.

6
00:00:24,650 --> 00:00:27,230
Quindi, diamo un'occhiata a init.

7
00:00:27,230 --> 00:00:32,930
>> Qui, vediamo la prima cosa che siamo
intenzione di fare è dichiarare una variabile

8
00:00:32,930 --> 00:00:34,600
chiamato contatore.

9
00:00:34,600 --> 00:00:37,620
Sta andando essere inizializzato
ai tempi d d meno 1.

10
00:00:37,620 --> 00:00:40,200
Ricorda che d è la dimensione
del nostro consiglio.

11
00:00:40,200 --> 00:00:43,840
Come init è andare a lavorare è che sta andando
per scorrere l'intero consiglio

12
00:00:43,840 --> 00:00:46,050
e stiamo per cominciare
in alto a sinistra.

13
00:00:46,050 --> 00:00:48,570
>> E diciamo solo noi
avere un 4 per 4 a bordo.

14
00:00:48,570 --> 00:00:51,220
Così in alto a sinistra siamo
andare a dire è 15.

15
00:00:51,220 --> 00:00:53,960
E poi stiamo solo andando a contare
attraverso le tavole, dicendo: 15, 14, 13,

16
00:00:53,960 --> 00:00:58,510
12, 11, 10, 9, 8, 7,
6, 5, 4, e così via.

17
00:00:58,510 --> 00:01:03,780
Così in alto a sinistra, ci aspettiamo di essere d volte
d meno 1, che nel 4 da 4

18
00:01:03,780 --> 00:01:08,290
caso sta per essere 16 meno
1, che è correttamente 15.

19
00:01:08,290 --> 00:01:10,885
>> Ed ora ecco dove stiamo andando a
scorrere l'intera scheda.

20
00:01:10,885 --> 00:01:14,720
E abbiamo intenzione di impostare ogni posizione in
la scheda al valore corrente di

21
00:01:14,720 --> 00:01:19,090
il nostro contatore, e poi contatore sta andando
per diminuire, in modo che la prossima

22
00:01:19,090 --> 00:01:22,300
posizione si raggiunge sta per avere
Contatore essere uno in meno

23
00:01:22,300 --> 00:01:23,690
la posizione precedente.

24
00:01:23,690 --> 00:01:26,970
Così inizialmente avevamo 15 e
diminuire contatore.

25
00:01:26,970 --> 00:01:30,065
Allora stiamo andando assegnare 14 alla
posizione successiva, contatore decremento,

26
00:01:30,065 --> 00:01:33,710
e stiamo per assegnare
13, e così via.

27
00:01:33,710 --> 00:01:37,620
>> Infine, abbiamo bisogno di gestire quell'angolo
caso in cui, se la scheda ha un ancora

28
00:01:37,620 --> 00:01:44,450
dimensione, poi basta fare 15, 14, 13,
12, tutta la strada fino a 3, 2, 1, è

29
00:01:44,450 --> 00:01:46,780
intenzione di lasciare noi con
una scheda irrisolvibile.

30
00:01:46,780 --> 00:01:49,390
E dobbiamo scambiare l'1 e il 2.

31
00:01:49,390 --> 00:01:52,930
Quindi, se d mod 2 è uguale a 0, che è
come stiamo andando a controllare

32
00:01:52,930 --> 00:01:54,410
per vedere se è ancora.

33
00:01:54,410 --> 00:01:59,810
Se d mod 2 è uguale a 0, poi in fila d meno
1, che è la riga di fondo, e

34
00:01:59,810 --> 00:02:05,430
posizione d meno 2, o una colonna d meno
2, stiamo andando a impostare che a 2, e

35
00:02:05,430 --> 00:02:07,860
colonna d meno 3 siamo
andando a impostare a 1.

36
00:02:07,860 --> 00:02:12,170
Quindi questo è solo invertendo dove
l'1 e 2 attualmente sono.

37
00:02:12,170 --> 00:02:16,270
>> Infine, stiamo andando a impostare il molto
in basso a destra pari a vuoto, dove

38
00:02:16,270 --> 00:02:20,700
blank è stato definito hash
in alto come 0.

39
00:02:20,700 --> 00:02:26,785
Quindi, che non era strettamente necessario,
poiché questo ciclo for sta per avere

40
00:02:26,785 --> 00:02:30,610
impostare il basso a destra per 0, poiché
contatore sarà naturalmente raggiungere lo 0.

41
00:02:30,610 --> 00:02:34,610
Ma che si basa su di noi sapendo che
blank è stato eseguito l'hashing per trovare un 0.

42
00:02:34,610 --> 00:02:38,280
Se vado in questo programma e poi
modificare vuota nella parte superiore a 100, essa

43
00:02:38,280 --> 00:02:39,770
dovrebbe ancora funzionare.

44
00:02:39,770 --> 00:02:43,180
>> Quindi questo è solo fare in modo che il
in basso a destra è in realtà uguale al nostro

45
00:02:43,180 --> 00:02:44,870
valore del bianco.

46
00:02:44,870 --> 00:02:50,270
Infine, abbiamo due variabili globali,
così blank i e j vuoto, e vediamo

47
00:02:50,270 --> 00:02:53,360
quelli dichiarati in alto.

48
00:02:53,360 --> 00:02:56,270
E abbiamo intenzione di usare quei due globale
variabili per tenere traccia del

49
00:02:56,270 --> 00:02:59,040
posizione del vuoto, in modo che non lo facciamo
bisogno di guardare attraverso l'intero

50
00:02:59,040 --> 00:03:03,890
bordo per trovare il vuoto di ogni singolo
volta cerchiamo di fare una mossa.

51
00:03:03,890 --> 00:03:08,450
Quindi la posizione del fustellato è sempre
sta per iniziare in basso a destra.

52
00:03:08,450 --> 00:03:13,270
Così basso a destra è data da
indici d meno 1, d meno 1.

53
00:03:13,270 --> 00:03:14,880
Quindi, questo è init.

54
00:03:14,880 --> 00:03:17,040
>> Ora passiamo a disegnare.

55
00:03:17,040 --> 00:03:19,370
Quindi, pareggio sta per essere simile
dove stiamo andando a scorrere

56
00:03:19,370 --> 00:03:20,970
su tutta la scheda.

57
00:03:20,970 --> 00:03:25,400
E vogliamo solo stampare il valore
che è in ogni posizione del consiglio di amministrazione.

58
00:03:25,400 --> 00:03:29,580
Così qui, stiamo stampando il valore che è
in ogni posizione del consiglio di amministrazione.

59
00:03:29,580 --> 00:03:32,280
E notiamo che stiamo facendo -.

60
00:03:32,280 --> 00:03:37,410
E questo è solo raccontare printf che
indipendentemente se si tratta di una sola cifra o

61
00:03:37,410 --> 00:03:42,010
numero a due cifre, vogliamo ancora per
prendere due colonne nella stampa fuori,

62
00:03:42,010 --> 00:03:46,290
in modo che se abbiamo due cifre e uno
numeri a due cifre nella stessa scheda, il nostro

63
00:03:46,290 --> 00:03:49,450
bordo sarà ancora un aspetto gradevole e la piazza.

64
00:03:49,450 --> 00:03:54,190
>> Così vogliamo fare che per ogni valore
nella tavola, tranne per il bianco.

65
00:03:54,190 --> 00:03:58,260
Quindi, se la posizione nel consiglio uguale
il vuoto, poi abbiamo specificamente

66
00:03:58,260 --> 00:04:01,730
vuole stampare solo una sottolineatura
per rappresentare il vuoto, anziché

67
00:04:01,730 --> 00:04:05,150
qualunque sia il valore della
vuoto in realtà è.

68
00:04:05,150 --> 00:04:08,500
>> Infine, vogliamo stampare
una nuova linea.

69
00:04:08,500 --> 00:04:11,970
Si noti che questo è ancora dentro
il ciclo for esterno, ma al di fuori

70
00:04:11,970 --> 00:04:13,200
l'interno ciclo for.

71
00:04:13,200 --> 00:04:17,930
Dal momento che questo ciclo for esterno è iterazione
su tutte le righe, e quindi questo è printf

72
00:04:17,930 --> 00:04:22,130
andare in stampa solo una nuova linea, in modo da
passare per stampare la riga successiva.

73
00:04:22,130 --> 00:04:23,910
E questo è tutto per il pareggio.

74
00:04:23,910 --> 00:04:27,770
>> Così, ora passiamo a muoversi.

75
00:04:27,770 --> 00:04:32,590
Ora, passiamo mossa, la tessera che la
l'utente viene inserito nel gioco - che

76
00:04:32,590 --> 00:04:36,360
inserisci la tessera che vogliono muoversi - e
si suppone di restituire un bool, così

77
00:04:36,360 --> 00:04:39,300
true o false, a seconda
se tale mossa era in realtà

78
00:04:39,300 --> 00:04:43,360
valido - se tale tessera può essere
spostato nello spazio vuoto.

79
00:04:43,360 --> 00:04:48,340
>> Così qui, dichiariamo una variabile locale,
tile_1 e tile_j, che stanno andando a

80
00:04:48,340 --> 00:04:52,150
essere simile a blank_i e blank_j,
tranne che sta andando a tenere traccia del

81
00:04:52,150 --> 00:04:54,910
la posizione della tessera.

82
00:04:54,910 --> 00:05:00,370
Ora qui, stiamo andando a utilizzare blank_i
e blank_j e dire va bene, così

83
00:05:00,370 --> 00:05:01,930
ecco il vuoto sulla scheda.

84
00:05:01,930 --> 00:05:04,420
>> Ora, è la piastrella sopra il vuoto?

85
00:05:04,420 --> 00:05:06,210
È la piastrella a fianco del fustellato?

86
00:05:06,210 --> 00:05:07,420
È la tegola a destra dello sbozzato?

87
00:05:07,420 --> 00:05:08,970
È la tegola sotto il vuoto?

88
00:05:08,970 --> 00:05:13,330
Quindi, se la tessera è in una di queste
posizioni, allora sappiamo che la piastrella

89
00:05:13,330 --> 00:05:16,390
può essere spostato nel posto vuoto e
il vuoto può essere spostato in cui la

90
00:05:16,390 --> 00:05:18,240
tegola è attualmente.

91
00:05:18,240 --> 00:05:26,400
>> Ecco, diciamo che se la scheda in posizione
blank_i meno 1 blank_j.

92
00:05:26,400 --> 00:05:31,120
Quindi questo sta dicendo è la piastrella
al di sopra del vuoto attuale?

93
00:05:31,120 --> 00:05:34,350
E se è così, stiamo andando a ricordare
cioè la posizione della tessera.

94
00:05:34,350 --> 00:05:37,870
La tegola è in posizione blank_i
meno 1 e blank_j.

95
00:05:37,870 --> 00:05:40,660
ora prima, abbiamo anche questo controllo
proprio qui, così blank_i è

96
00:05:40,660 --> 00:05:41,760
maggiore di 0.

97
00:05:41,760 --> 00:05:43,410
>> Perché vogliamo farlo?

98
00:05:43,410 --> 00:05:47,290
Beh, se il vuoto è nella riga superiore
del consiglio di amministrazione, quindi noi non vogliamo

99
00:05:47,290 --> 00:05:51,240
guardare al di sopra del vuoto per la piastrella dal
non c'è nulla sopra il top

100
00:05:51,240 --> 00:05:52,430
riga della scheda.

101
00:05:52,430 --> 00:05:55,950
In questo modo si potrebbe finire per ottenere
qualcosa come un errore di segmentazione o

102
00:05:55,950 --> 00:05:59,030
il programma potrebbe funzionare
in modi inaspettati.

103
00:05:59,030 --> 00:06:04,310
Quindi, questo è fare in modo che non lo facciamo
guardare in luoghi che non sono validi.

104
00:06:04,310 --> 00:06:08,470
>> Ora stiamo andando a fare la stessa cosa per
tutte le altre combinazioni possibili.

105
00:06:08,470 --> 00:06:13,250
Così qui, stiamo cercando di sotto del vuoto
per vedere se questa è la piastrella.

106
00:06:13,250 --> 00:06:16,950
E dobbiamo anche fare in modo che siamo
non sulla riga inferiore, oppure noi

107
00:06:16,950 --> 00:06:18,910
non dovrebbe cercare la piastrella.

108
00:06:18,910 --> 00:06:25,040
Qui stiamo andando a guardare a sinistra
il vuoto per vedere se è la piastrella.

109
00:06:25,040 --> 00:06:27,860
E non dobbiamo guardare verso sinistra
se siamo nella colonna più a sinistra.

110
00:06:27,860 --> 00:06:30,100
E qui stiamo andando a guardare al
destra del vuoto, e non dovremmo

111
00:06:30,100 --> 00:06:33,340
andare a destra se siamo
nella colonna di destra.

112
00:06:33,340 --> 00:06:37,820
>> Quindi, se nessuna di queste cose fosse vera,
significa che la tessera non era adiacente

113
00:06:37,820 --> 00:06:39,640
il vuoto e possiamo tornare false.

114
00:06:39,640 --> 00:06:41,230
La mossa non era valida.

115
00:06:41,230 --> 00:06:47,010
Ma, se una di queste fosse vero, allora a
questo punto, sappiamo che tile_i e

116
00:06:47,010 --> 00:06:50,540
tile_j sono uguali al
la posizione della tessera.

117
00:06:50,540 --> 00:06:55,210
E così, possiamo aggiornare il bordo
posizioni tile_i e tile_j.

118
00:06:55,210 --> 00:06:59,820
Sappiamo che il nuovo valore sarà il vuoto
e che la posizione blank_i

119
00:06:59,820 --> 00:07:02,950
blank_j, che era l'originale
blank - sappiamo che la tegola sta per

120
00:07:02,950 --> 00:07:04,030
trasferirsi lì.

121
00:07:04,030 --> 00:07:07,610
>> Si noti che in realtà non dobbiamo fare un
reale di swap qui, dal momento che sappiamo che la

122
00:07:07,610 --> 00:07:09,850
valori che devono essere inseriti
in tali posizioni.

123
00:07:09,850 --> 00:07:13,780
Non abbiamo bisogno di un temporaneo
variabile intorno.

124
00:07:13,780 --> 00:07:16,920
>> Infine, dobbiamo ricordare che siamo
le nostre variabili globali che sono

125
00:07:16,920 --> 00:07:18,980
tenere traccia della posizione
del vuoto.

126
00:07:18,980 --> 00:07:22,780
Quindi vogliamo aggiornare la posizione di
il vuoto per essere dove la piastrella

127
00:07:22,780 --> 00:07:24,190
originariamente era.

128
00:07:24,190 --> 00:07:27,680
Infine, torniamo vero in quanto
la mossa ha avuto successo.

129
00:07:27,680 --> 00:07:31,110
Ci scambiamo con successo il
bianco con la piastrella.

130
00:07:31,110 --> 00:07:34,890
>> Va bene, così finalmente abbiamo
necessario verificare vinto.

131
00:07:34,890 --> 00:07:39,900
Così, ha vinto restituisce allo stesso modo un bool dove
vero sta a indicare che l'

132
00:07:39,900 --> 00:07:41,460
utente ha vinto la partita.

133
00:07:41,460 --> 00:07:43,780
E falso indica che
il gioco è ancora in corso.

134
00:07:43,780 --> 00:07:46,340
L'utente non ha vinto.

135
00:07:46,340 --> 00:07:52,100
Quindi, questo sta per essere praticamente
il contrario di init, dove init,

136
00:07:52,100 --> 00:07:56,920
Ricordiamo, inizializziamo la scheda
a 15, 14, 13, 12, ecc.

137
00:07:56,920 --> 00:08:03,000
Considerando che ha vinto, vogliamo verificare se il
bordo è 1, 2, 3, 4, 5, e così via.

138
00:08:03,000 --> 00:08:06,600
>> Quindi, stiamo andando a inizializzare il
contrastare a 1 dato che è quello che la parte superiore

139
00:08:06,600 --> 00:08:08,400
sinistra della scheda dovrebbe essere.

140
00:08:08,400 --> 00:08:10,860
E poi andremo a ciclo
su tutta la scheda.

141
00:08:10,860 --> 00:08:13,690
Cerchiamo di ignorare questa condizione
per un secondo.

142
00:08:13,690 --> 00:08:18,410
E questa condizione è solo andare a
controllo è la scheda in questa posizione

143
00:08:18,410 --> 00:08:20,790
pari ai conti correnti?

144
00:08:20,790 --> 00:08:27,040
Se è così, incrementare il conteggio in modo che la
successiva posizione guardiamo è una maggiore

145
00:08:27,040 --> 00:08:29,690
rispetto alla posizione siamo in questo momento.

146
00:08:29,690 --> 00:08:32,700
>> Ecco come si ottiene il
in alto a sinistra dovrebbe essere 1.

147
00:08:32,700 --> 00:08:33,950
Incrementare il conteggio a 2.

148
00:08:33,950 --> 00:08:35,010
Guardate la posizione successiva.

149
00:08:35,010 --> 00:08:35,690
È questo 2?

150
00:08:35,690 --> 00:08:37,659
Se è così, incrementare il conteggio a 3.

151
00:08:37,659 --> 00:08:39,179
Posizione successiva, questo 3?

152
00:08:39,179 --> 00:08:42,440
Se è così, incrementare il conteggio
a 4, e così via.

153
00:08:42,440 --> 00:08:49,190
Quindi, se c'è qualche posizione sulla
scheda che non è uguale a nostro conteggio,

154
00:08:49,190 --> 00:08:52,640
poi vogliamo tornare falso in quanto tale
significa che c'è qualche tegola che è

155
00:08:52,640 --> 00:08:55,490
non in posizione corretta.

156
00:08:55,490 --> 00:08:58,810
>> Ecco, che cosa sta facendo questa condizione?

157
00:08:58,810 --> 00:09:02,170
Bene, ricordate che il bianco sia
dovrebbe andare in basso a destra.

158
00:09:02,170 --> 00:09:06,180
E il valore del bianco potrebbe non
necessariamente uguale al valore della

159
00:09:06,180 --> 00:09:11,080
contatore che sta per essere raggiunto
in basso a destra.

160
00:09:11,080 --> 00:09:15,760
Così abbiamo specificamente vogliamo verificare se i
uguale uguale d meno 1 e j uguali

161
00:09:15,760 --> 00:09:19,470
uguale d meno 1 - che è tutto dire se si
stanno guardando in basso a destra della

162
00:09:19,470 --> 00:09:22,050
il consiglio - poi abbiamo appena
voglia di continuare.

163
00:09:22,050 --> 00:09:26,200
Vogliamo ignorare questo particolare
iterazione del ciclo for.

164
00:09:26,200 --> 00:09:31,250
>> E così, se riusciamo a superare questo
nidificato per il ciclo, il che significa che

165
00:09:31,250 --> 00:09:34,690
non c'era tegola che era in
la posizione corretta.

166
00:09:34,690 --> 00:09:38,900
E noi spezziamo fuori dal giro e arriviamo
qui, dove possiamo restituire true.

167
00:09:38,900 --> 00:09:41,800
Tutte le mattonelle erano nelle posizioni corrette
e ciò significa che l'utente ha

168
00:09:41,800 --> 00:09:43,230
vinto la partita.

169
00:09:43,230 --> 00:09:44,460
E questo è tutto.

170
00:09:44,460 --> 00:09:46,550
Il mio nome è Rob Bowden, e questo era 15.

171
00:09:46,550 --> 00:09:52,726