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

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

3
00:00:13,715 --> 00:00:17,800
Estoy Rob, y espero que su
juego para el juego del 15.

4
00:00:17,800 --> 00:00:22,040
Ahora, hay cuatro funciones que necesita
para aplicar en este programa - init,

5
00:00:22,040 --> 00:00:24,650
dibujar, mover, y ganó.

6
00:00:24,650 --> 00:00:27,230
Por lo tanto, echemos un vistazo a init.

7
00:00:27,230 --> 00:00:32,930
>> Aquí, vemos la primera cosa que estamos
vamos a hacer es declarar una variable

8
00:00:32,930 --> 00:00:34,600
llamado contador.

9
00:00:34,600 --> 00:00:37,620
Esto va a ser inicializado
a veces d d menos 1.

10
00:00:37,620 --> 00:00:40,200
Recuerde que d es la dimensión
de nuestro consejo.

11
00:00:40,200 --> 00:00:43,840
Cómo init va a funcionar es que va
iterar sobre el foro entero

12
00:00:43,840 --> 00:00:46,050
y vamos a empezar
en la parte superior izquierda.

13
00:00:46,050 --> 00:00:48,570
>> Y vamos a decir que
tener una placa de 4 por 4.

14
00:00:48,570 --> 00:00:51,220
Así que la parte superior izquierda estamos
va a decir es de 15.

15
00:00:51,220 --> 00:00:53,960
Y entonces sólo vamos a contar
a través de las juntas, diciendo: 15, 14, 13,

16
00:00:53,960 --> 00:00:58,510
12, 11, 10, 9, 8, 7,
6, 5, 4, y así sucesivamente.

17
00:00:58,510 --> 00:01:03,780
Así que la parte superior izquierda, esperamos estar d veces
D menos 1, que en el 4 por 4

18
00:01:03,780 --> 00:01:08,290
caso va a ser 16 menos
1, que es correcta 15.

19
00:01:08,290 --> 00:01:10,885
>> Y ahora aquí es donde vamos a
iterar sobre el foro entero.

20
00:01:10,885 --> 00:01:14,720
Y vamos a ajustar cada posición en
el tablero para el valor actual de

21
00:01:14,720 --> 00:01:19,090
nuestro mostrador, y luego contador se va
para disminuir, de manera que la siguiente

22
00:01:19,090 --> 00:01:22,300
posición que lleguemos va a tener
contador sea uno menos que

23
00:01:22,300 --> 00:01:23,690
la posición anterior.

24
00:01:23,690 --> 00:01:26,970
Así que al principio teníamos 15 y
decrementar contador.

25
00:01:26,970 --> 00:01:30,065
Así que vamos a asignar 14 a la
siguiente posición, contador decreciente,

26
00:01:30,065 --> 00:01:33,710
y que vamos a asignar
13, y así sucesivamente.

27
00:01:33,710 --> 00:01:37,620
>> Por último, tenemos que manejar esa esquina
caso en el que, si el tablero tiene una aún

28
00:01:37,620 --> 00:01:44,450
dimensión, a continuación, sólo hacer 15, 14, 13,
12, hasta el final abajo a 3, 2, 1, es

29
00:01:44,450 --> 00:01:46,780
nos va a dejar con
una junta irresoluble.

30
00:01:46,780 --> 00:01:49,390
Y tenemos que cambiar la 1 y la 2.

31
00:01:49,390 --> 00:01:52,930
Por lo tanto, si d mod 2 es igual a 0, eso es
como vamos a comprobar

32
00:01:52,930 --> 00:01:54,410
para ver si es aún.

33
00:01:54,410 --> 00:01:59,810
Si d mod 2 es igual a 0, entonces en la fila d menos
1, que es la fila inferior, y

34
00:01:59,810 --> 00:02:05,430
posición d menos 2 o columna d menos
2, vamos a establecer que a 2, y

35
00:02:05,430 --> 00:02:07,860
columna d menos 3 estamos
va a establecer en 1.

36
00:02:07,860 --> 00:02:12,170
Así que eso es sólo invertir donde
el 1 y 2 son actualmente.

37
00:02:12,170 --> 00:02:16,270
>> Por último, vamos a configurar el
abajo a la derecha igual al blanco, donde

38
00:02:16,270 --> 00:02:20,700
blanco ha sido definido de hash
en la parte superior como 0.

39
00:02:20,700 --> 00:02:26,785
Por lo tanto, eso no era estrictamente necesario,
ya que este bucle va a tener

40
00:02:26,785 --> 00:02:30,610
fijar la parte inferior derecha de 0, ya que
contador naturalmente llegar a 0.

41
00:02:30,610 --> 00:02:34,610
Pero eso depende de nosotros, sabiendo que
blanco se aplica un algoritmo hash para encontrar un 0.

42
00:02:34,610 --> 00:02:38,280
Si entro en este programa y más tarde
cambiar en blanco en la parte superior a 100, se

43
00:02:38,280 --> 00:02:39,770
debería funcionar.

44
00:02:39,770 --> 00:02:43,180
>> Así que esto es simplemente asegurarse de que el
abajo a la derecha es en realidad igual a nuestra

45
00:02:43,180 --> 00:02:44,870
valor en blanco.

46
00:02:44,870 --> 00:02:50,270
Por último, tenemos dos variables globales,
tan en blanco i y j en blanco, y vemos

47
00:02:50,270 --> 00:02:53,360
las declaradas en la parte superior.

48
00:02:53,360 --> 00:02:56,270
Y vamos a utilizar esos dos mundial
variables para realizar un seguimiento de la

49
00:02:56,270 --> 00:02:59,040
posición del blanco, así que nosotros no
que tenga que mirar a través de la totalidad de

50
00:02:59,040 --> 00:03:03,890
foro para encontrar el blanco cada
vez que tratamos de hacer un movimiento.

51
00:03:03,890 --> 00:03:08,450
Así la posición de la pieza en bruto es siempre
va a comenzar en la parte inferior derecha.

52
00:03:08,450 --> 00:03:13,270
Así que la parte inferior derecha está dada por
Índices 1 d menos 1, d menos.

53
00:03:13,270 --> 00:03:14,880
Entonces, eso es init.

54
00:03:14,880 --> 00:03:17,040
>> Ahora pasamos a dibujar.

55
00:03:17,040 --> 00:03:19,370
Así, sorteo va a ser similar
donde vamos a repetir

56
00:03:19,370 --> 00:03:20,970
sobre el foro entero.

57
00:03:20,970 --> 00:03:25,400
Y sólo queremos imprimir el valor
eso es en cada posición de la junta.

58
00:03:25,400 --> 00:03:29,580
Así que aquí, vamos a imprimir el valor que es
en cada posición de la junta.

59
00:03:29,580 --> 00:03:32,280
Y notamos que estamos haciendo -.

60
00:03:32,280 --> 00:03:37,410
Y eso es simplemente decirle a printf que
independientemente de si es un dígito o

61
00:03:37,410 --> 00:03:42,010
número de dos dígitos, todavía queremos que
ocupan dos columnas en la impresión,

62
00:03:42,010 --> 00:03:46,290
por lo que si tenemos dos dígitos y una
número de dos dígitos en el mismo tablero, nuestro

63
00:03:46,290 --> 00:03:49,450
tablero todavía se vean bien y cuadrado.

64
00:03:49,450 --> 00:03:54,190
>> Así que queremos hacer que por cada valor
en la tabla, excepto para el blanco.

65
00:03:54,190 --> 00:03:58,260
Por lo tanto, si la posición en el tablero es igual
el espacio en blanco, entonces específicamente

66
00:03:58,260 --> 00:04:01,730
desee imprimir sólo un guión bajo
para representar el espacio en blanco, en lugar de

67
00:04:01,730 --> 00:04:05,150
cualquiera que sea el valor de la
en blanco en realidad es.

68
00:04:05,150 --> 00:04:08,500
>> Por último, queremos imprimir
una nueva línea.

69
00:04:08,500 --> 00:04:11,970
Tenga en cuenta que esto es todavía en el interior
el ciclo for exterior, pero fuera

70
00:04:11,970 --> 00:04:13,200
el interior de bucle.

71
00:04:13,200 --> 00:04:17,930
Dado que este ciclo for exterior está iterando
sobre todas las filas, y por lo que este es printf

72
00:04:17,930 --> 00:04:22,130
va a imprimir sólo una nueva línea, por lo que
pasar a imprimir la siguiente fila.

73
00:04:22,130 --> 00:04:23,910
Y eso es todo por sorteo.

74
00:04:23,910 --> 00:04:27,770
>> Así que, ahora vamos a pasar a moverse.

75
00:04:27,770 --> 00:04:32,590
Ahora, pasamos movimiento, el azulejo que el
usuario se introduce en el juego - que

76
00:04:32,590 --> 00:04:36,360
entrar en el azulejo que quieren moverse - y
se supone que debes devolver un bool, por lo

77
00:04:36,360 --> 00:04:39,300
ya sea verdadero o falso, dependiendo de
si esa medida era en realidad

78
00:04:39,300 --> 00:04:43,360
válida - si esa ficha puede ser
movido en el espacio en blanco.

79
00:04:43,360 --> 00:04:48,340
>> Así que aquí, declaramos una variable local,
tile_1 y tile_j, que se va a

80
00:04:48,340 --> 00:04:52,150
ser similar a blank_i y blank_j,
excepto que va a realizar un seguimiento de la

81
00:04:52,150 --> 00:04:54,910
posición de la baldosa.

82
00:04:54,910 --> 00:05:00,370
Ahora aquí, vamos a utilizar blank_i
y blank_j y decir bien, por lo que

83
00:05:00,370 --> 00:05:01,930
aquí está el espacio en blanco en el tablero.

84
00:05:01,930 --> 00:05:04,420
>> Ahora, es el mosaico sobre el blanco?

85
00:05:04,420 --> 00:05:06,210
Es la baldosa a la izquierda de la pieza en bruto?

86
00:05:06,210 --> 00:05:07,420
Es la baldosa a la derecha del blanco?

87
00:05:07,420 --> 00:05:08,970
Es el azulejo debajo del blanco?

88
00:05:08,970 --> 00:05:13,330
Por lo tanto, si la ficha está en ninguno de los
posiciones, entonces sabemos que el azulejo

89
00:05:13,330 --> 00:05:16,390
se puede mover en el espacio en blanco y
la pieza en bruto se puede mover a donde el

90
00:05:16,390 --> 00:05:18,240
baldosas actualmente es.

91
00:05:18,240 --> 00:05:26,400
>> Así que aquí, decimos si la tarjeta en la posición
blank_i menos 1 blank_j.

92
00:05:26,400 --> 00:05:31,120
Así que esto está diciendo es el azulejo
por encima de la pieza en bruto actual?

93
00:05:31,120 --> 00:05:34,350
Y si es así, vamos a recordar
que es la posición de la baldosa.

94
00:05:34,350 --> 00:05:37,870
El azulejo está en posición blank_i
menos 1 y blank_j.

95
00:05:37,870 --> 00:05:40,660
ahora primero, también tenemos esta comprobación
aquí, por lo que es blank_i

96
00:05:40,660 --> 00:05:41,760
mayor que 0.

97
00:05:41,760 --> 00:05:43,410
>> ¿Por qué queremos hacer eso?

98
00:05:43,410 --> 00:05:47,290
Bueno, si el blanco se encuentra en la fila superior
del tablero, entonces no queremos

99
00:05:47,290 --> 00:05:51,240
mirar por encima del blanco para el azulejo ya
no hay nada por encima de la parte superior

100
00:05:51,240 --> 00:05:52,430
fila de la tabla.

101
00:05:52,430 --> 00:05:55,950
Esta es la forma en que podría terminar encima de conseguir
algo así como una violación de segmento o

102
00:05:55,950 --> 00:05:59,030
el programa podría funcionar
de maneras inesperadas.

103
00:05:59,030 --> 00:06:04,310
Por lo tanto, este es asegurarse de que no lo hacemos
buscar en lugares que no son válidos.

104
00:06:04,310 --> 00:06:08,470
>> Ahora vamos a hacer lo mismo para
todas las demás combinaciones posibles.

105
00:06:08,470 --> 00:06:13,250
Así que aquí, estamos buscando por debajo del blanco
para ver si ese es el azulejo.

106
00:06:13,250 --> 00:06:16,950
Y también tenemos que asegurarnos de que estamos
no en la fila inferior, o de lo contrario

107
00:06:16,950 --> 00:06:18,910
no debe buscar el azulejo.

108
00:06:18,910 --> 00:06:25,040
Aquí, vamos a mirar a la izquierda de
el espacio en blanco para ver si se trata de la baldosa.

109
00:06:25,040 --> 00:06:27,860
Y no debemos mirar hacia la izquierda
si estamos en la columna de la izquierda.

110
00:06:27,860 --> 00:06:30,100
Y aquí vamos a mirar hacia el
derecho del espacio en blanco, y no debemos

111
00:06:30,100 --> 00:06:33,340
mirar a la derecha si somos
en la columna más a la derecha.

112
00:06:33,340 --> 00:06:37,820
>> Así que, si ninguna de esas cosas fuera cierto,
eso significa que el azulejo no era adyacente

113
00:06:37,820 --> 00:06:39,640
a la pieza y podemos devolver false.

114
00:06:39,640 --> 00:06:41,230
El movimiento no era válida.

115
00:06:41,230 --> 00:06:47,010
Pero, si uno de ellos fuera cierto, entonces en
este punto, sabemos que tile_i y

116
00:06:47,010 --> 00:06:50,540
tile_j son iguales a la
posición de la baldosa.

117
00:06:50,540 --> 00:06:55,210
Y así, podemos actualizar la pensión en
posiciones tile_i y tile_j.

118
00:06:55,210 --> 00:06:59,820
Sabemos que el nuevo valor será el espacio en blanco
y que la posición blank_i

119
00:06:59,820 --> 00:07:02,950
blank_j, que era el original
blanco - sabemos que el azulejo se va a

120
00:07:02,950 --> 00:07:04,030
mudarse allí.

121
00:07:04,030 --> 00:07:07,610
>> Nótese que en realidad no tenemos que hacer una
intercambio real aquí, ya que sabemos que el

122
00:07:07,610 --> 00:07:09,850
valores que necesitan ser insertado
en esas posiciones.

123
00:07:09,850 --> 00:07:13,780
No necesitamos un temporal
variable de alrededor.

124
00:07:13,780 --> 00:07:16,920
>> Por último, debemos recordar que
Disponemos de variables globales que están

125
00:07:16,920 --> 00:07:18,980
hacer el seguimiento de la posición
de la pieza en bruto.

126
00:07:18,980 --> 00:07:22,780
Así que queremos actualizar la posición de
el espacio en blanco para estar donde el azulejo

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

128
00:07:24,190 --> 00:07:27,680
Por último, volvemos cierto ya
el movimiento fue exitoso.

129
00:07:27,680 --> 00:07:31,110
Intercambiamos con éxito el
en blanco con el azulejo.

130
00:07:31,110 --> 00:07:34,890
>> Muy bien, así que pasado
necesitará comprobar won.

131
00:07:34,890 --> 00:07:39,900
Así, ganó devuelve de manera similar un bool donde
verdad va a indicar que el

132
00:07:39,900 --> 00:07:41,460
usuario ha ganado la partida.

133
00:07:41,460 --> 00:07:43,780
Y falso es lo que indica que
el juego está todavía en curso.

134
00:07:43,780 --> 00:07:46,340
El usuario no ha ganado.

135
00:07:46,340 --> 00:07:52,100
Por lo tanto, esto va a ser más o menos
lo contrario de init, donde init,

136
00:07:52,100 --> 00:07:56,920
Recordemos, inicializamos el tablero
a 15, 14, 13, 12, etc.

137
00:07:56,920 --> 00:08:03,000
Considerando que el ganado, queremos comprobar si el
Junta es 1, 2, 3, 4, 5, y así sucesivamente.

138
00:08:03,000 --> 00:08:06,600
>> Por lo tanto, vamos a inicializar nuestra
contrarrestar a 1 ya que eso es lo que la parte superior

139
00:08:06,600 --> 00:08:08,400
izquierdo de la placa debe ser.

140
00:08:08,400 --> 00:08:10,860
Y luego vamos a bucle
sobre el foro entero.

141
00:08:10,860 --> 00:08:13,690
Vamos a ignorar esta condición
por un segundo.

142
00:08:13,690 --> 00:08:18,410
Y esta condición es sólo va a
cheque es el consejo en esta posición

143
00:08:18,410 --> 00:08:20,790
igual a los recuentos actuales?

144
00:08:20,790 --> 00:08:27,040
Si es así, incrementar el recuento de modo que el
siguiente posición observamos es una mayor

145
00:08:27,040 --> 00:08:29,690
que la posición que estamos en estos momentos.

146
00:08:29,690 --> 00:08:32,700
>> Así es como se obtiene la
arriba a la izquierda debe ser 1.

147
00:08:32,700 --> 00:08:33,950
Incrementa el conteo de 2.

148
00:08:33,950 --> 00:08:35,010
Mira la siguiente posición.

149
00:08:35,010 --> 00:08:35,690
¿Es esto 2?

150
00:08:35,690 --> 00:08:37,659
Si es así, incrementar la cuenta de 3.

151
00:08:37,659 --> 00:08:39,179
Posición siguiente, ¿esto es 3?

152
00:08:39,179 --> 00:08:42,440
Si es así, incrementar el recuento
a 4, y así sucesivamente.

153
00:08:42,440 --> 00:08:49,190
Así, si hay cualquier posición en la
tablero que no es igual a nuestra cuenta,

154
00:08:49,190 --> 00:08:52,640
entonces queremos devolver false ya que
significa que hay alguna pieza que se va

155
00:08:52,640 --> 00:08:55,490
no en la posición correcta.

156
00:08:55,490 --> 00:08:58,810
>> Así que aquí, lo que hace de esta condición?

157
00:08:58,810 --> 00:09:02,170
Bueno, recuerde que el blanco es
supone ir en la parte inferior derecha.

158
00:09:02,170 --> 00:09:06,180
Y el valor del blanco podría no
necesariamente igual al valor de la

159
00:09:06,180 --> 00:09:11,080
responden que va a ser alcanzado
en la parte inferior derecha.

160
00:09:11,080 --> 00:09:15,760
Así que específicamente queremos comprobar si i
es igual a es igual a D menos 1 y j iguales

161
00:09:15,760 --> 00:09:19,470
es igual a D menos 1 - que ya es decir si
están buscando en la parte inferior derecha de

162
00:09:19,470 --> 00:09:22,050
la junta - entonces sólo
desea continuar.

163
00:09:22,050 --> 00:09:26,200
Queremos saltar este particular,
iteración del bucle para.

164
00:09:26,200 --> 00:09:31,250
>> Y así, si logramos salir de esto
anidado bucle, lo que significa que

165
00:09:31,250 --> 00:09:34,690
no había baldosa que estaba en
la posición incorrecta.

166
00:09:34,690 --> 00:09:38,900
Y salimos de bucle y venimos
aquí, donde podemos volver realidad.

167
00:09:38,900 --> 00:09:41,800
Todos los azulejos estaban en las posiciones correctas
y eso significa que el usuario tiene

168
00:09:41,800 --> 00:09:43,230
ganado el juego.

169
00:09:43,230 --> 00:09:44,460
Y eso es todo.

170
00:09:44,460 --> 00:09:46,550
Mi nombre es Rob Bowden, y esto fue el 15.

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