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

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

3
00:00:13,715 --> 00:00:17,800
Estou Rob, e eu espero que o seu
jogo para jogo da 15.

4
00:00:17,800 --> 00:00:22,040
Agora, há quatro funções que você precisa
a implementar neste programa - init,

5
00:00:22,040 --> 00:00:24,650
desenhar, mover-se, e ganhou.

6
00:00:24,650 --> 00:00:27,230
Então, vamos olhar para o init.

7
00:00:27,230 --> 00:00:32,930
>> Aqui, vemos a primeira coisa que nós estamos
vai fazer é declarar uma variável

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

9
00:00:34,600 --> 00:00:37,620
Vai ser inicializado
para d vezes d menos 1.

10
00:00:37,620 --> 00:00:40,200
Lembre-se que d é a dimensão
do nosso conselho.

11
00:00:40,200 --> 00:00:43,840
Como o init vai funcionar é que vai
para repetir em todos os fóruns

12
00:00:43,840 --> 00:00:46,050
e nós vamos começar
no canto superior esquerdo.

13
00:00:46,050 --> 00:00:48,570
>> E vamos apenas dizer que
tenho uma placa de 4 por 4.

14
00:00:48,570 --> 00:00:51,220
Assim, a parte superior esquerda estamos
vai dizer é 15.

15
00:00:51,220 --> 00:00:53,960
E então nós apenas estamos indo para contar
através das placas, dizendo 15, 14, 13,

16
00:00:53,960 --> 00:00:58,510
12, 11, 10, 9, 8, 7,
6, 5, 4, e assim por diante.

17
00:00:58,510 --> 00:01:03,780
Assim, o canto superior esquerdo, esperamos estar d vezes
d menos 1, que na posição 4 por 4

18
00:01:03,780 --> 00:01:08,290
caso vai ser 16 menos
1, que é correctamente 15.

19
00:01:08,290 --> 00:01:10,885
>> E agora aqui é onde nós vamos
repetidas em toda a linha.

20
00:01:10,885 --> 00:01:14,720
E nós estamos indo para definir cada posição
a placa com o valor atual de

21
00:01:14,720 --> 00:01:19,090
nosso balcão, e, em seguida, contador vai
para diminuir, para que o próximo

22
00:01:19,090 --> 00:01:22,300
posição chegarmos vai ter
contador de ser um a menos que

23
00:01:22,300 --> 00:01:23,690
a posição anterior.

24
00:01:23,690 --> 00:01:26,970
Assim, inicialmente tinha 15 e
diminuir balcão.

25
00:01:26,970 --> 00:01:30,065
Então vamos atribuir 14 à
posição seguinte, contra decréscimo,

26
00:01:30,065 --> 00:01:33,710
e vamos atribuído
13, e assim por diante.

27
00:01:33,710 --> 00:01:37,620
>> Finalmente, é preciso lidar com esse canto
caso em que, se a placa tem um mesmo

28
00:01:37,620 --> 00:01:44,450
dimensão, então é só fazer 15, 14, 13,
12, todo o caminho até a 3, 2, 1, é

29
00:01:44,450 --> 00:01:46,780
vai nos deixar com
uma placa insolúvel.

30
00:01:46,780 --> 00:01:49,390
E nós temos que trocar o 1 eo 2.

31
00:01:49,390 --> 00:01:52,930
Assim, se d mod 2 é igual a 0, isso é
como vamos verificar

32
00:01:52,930 --> 00:01:54,410
para ver se é mesmo.

33
00:01:54,410 --> 00:01:59,810
Se d mod 2 é igual a 0, então na linha d menos
1, que é a linha de fundo, e

34
00:01:59,810 --> 00:02:05,430
posição d menos 2, ou coluna d menos
2, nós vamos definir que a 2, e

35
00:02:05,430 --> 00:02:07,860
coluna d menos 3 que estamos
vai definir a 1.

36
00:02:07,860 --> 00:02:12,170
Então, isso é só inverter onde
o 1 e 2, atualmente.

37
00:02:12,170 --> 00:02:16,270
>> Finalmente, vamos definir o muito
inferior direito igual em branco, onde

38
00:02:16,270 --> 00:02:20,700
em branco foi de hash definido
no topo, como 0.

39
00:02:20,700 --> 00:02:26,785
Então, isso não era estritamente necessário,
uma vez que este ciclo for vai ter

40
00:02:26,785 --> 00:02:30,610
definir o canto inferior direito para 0, uma vez que
contador naturalmente atingir 0.

41
00:02:30,610 --> 00:02:34,610
Mas isso depende de nós, sabendo que
branco foi hash para encontrar um 0.

42
00:02:34,610 --> 00:02:38,280
Se eu for para este programa e mais tarde
mudar branco na parte superior a 100, que

43
00:02:38,280 --> 00:02:39,770
ainda deve funcionar.

44
00:02:39,770 --> 00:02:43,180
>> Portanto, esta é apenas ter certeza de que o
canto inferior direito é realmente igual ao nosso

45
00:02:43,180 --> 00:02:44,870
valor em branco.

46
00:02:44,870 --> 00:02:50,270
Finalmente, temos duas variáveis ​​globais,
tão em branco i e j em branco, e vemos

47
00:02:50,270 --> 00:02:53,360
os declarados no topo.

48
00:02:53,360 --> 00:02:56,270
E nós vamos usar os dois mundial
variáveis ​​para acompanhar o

49
00:02:56,270 --> 00:02:59,040
posição do branco, para que não
precisa olhar através de todo o

50
00:02:59,040 --> 00:03:03,890
conselho para encontrar o espaço em branco a cada
vez que tentamos fazer uma jogada.

51
00:03:03,890 --> 00:03:08,450
Assim, a posição da peça em bruto é sempre
vai começar no canto inferior direito.

52
00:03:08,450 --> 00:03:13,270
Assim, a parte inferior direita é dada por
índices d menos 1, d menos 1.

53
00:03:13,270 --> 00:03:14,880
Então, isso é o init.

54
00:03:14,880 --> 00:03:17,040
>> Agora vamos passar para desenhar.

55
00:03:17,040 --> 00:03:19,370
Então, sorteio vai ser semelhante
onde vamos fazer uma iteração

56
00:03:19,370 --> 00:03:20,970
ao longo de todo o tabuleiro.

57
00:03:20,970 --> 00:03:25,400
E nós só queremos imprimir o valor
que está em cada posição do tabuleiro.

58
00:03:25,400 --> 00:03:29,580
Então, aqui, estamos a imprimir o valor que é
em cada posição do tabuleiro.

59
00:03:29,580 --> 00:03:32,280
E note que estamos fazendo -.

60
00:03:32,280 --> 00:03:37,410
E isso é apenas a dizer que printf
independentemente de se é um um dígito ou

61
00:03:37,410 --> 00:03:42,010
número de dois dígitos, ainda quer que ele
ocupar duas colunas na impressão,

62
00:03:42,010 --> 00:03:46,290
de modo que, se tivermos dois dígitos e um
algarismos na mesma placa, o nosso

63
00:03:46,290 --> 00:03:49,450
conselho ainda vai ficar bom e quadrado.

64
00:03:49,450 --> 00:03:54,190
>> Por isso, queremos fazer isso para cada valor
na placa, exceto para o branco.

65
00:03:54,190 --> 00:03:58,260
Assim, se a posição na placa é igual a
o espaço em branco, então nós especificamente

66
00:03:58,260 --> 00:04:01,730
pretende imprimir apenas um sublinhado
para representar a placa, em vez de

67
00:04:01,730 --> 00:04:05,150
qualquer que seja o valor do
em branco realmente é.

68
00:04:05,150 --> 00:04:08,500
>> Finalmente, queremos imprimir
uma nova linha.

69
00:04:08,500 --> 00:04:11,970
Note-se que este ainda está dentro
o loop for externo, mas fora

70
00:04:11,970 --> 00:04:13,200
o interior de loop.

71
00:04:13,200 --> 00:04:17,930
Uma vez que este loop for externo é iteração
sobre todas as linhas, e por isso este é printf

72
00:04:17,930 --> 00:04:22,130
vai apenas imprimir uma nova linha, de modo que
passar a imprimir a próxima linha.

73
00:04:22,130 --> 00:04:23,910
E é isso por sorteio.

74
00:04:23,910 --> 00:04:27,770
>> Então, agora vamos passar a se mover.

75
00:04:27,770 --> 00:04:32,590
Agora, passamos movimento, a telha que a
usuário é inserido no jogo - eles

76
00:04:32,590 --> 00:04:36,360
entrar na telha eles querem passar - e
você deveria retornar um booleano, então

77
00:04:36,360 --> 00:04:39,300
verdadeira ou falsa, dependendo
se esse movimento era realmente

78
00:04:39,300 --> 00:04:43,360
válido - se que a telha pode ser
mudou-se para o espaço em branco.

79
00:04:43,360 --> 00:04:48,340
>> Então, aqui, nós declaramos uma variável local,
tile_1 e tile_j, que vão

80
00:04:48,340 --> 00:04:52,150
ser semelhante ao blank_i e blank_j,
exceto que vai acompanhar o

81
00:04:52,150 --> 00:04:54,910
posição do azulejo.

82
00:04:54,910 --> 00:05:00,370
Agora aqui, vamos usar blank_i
e blank_j e dizer tudo bem, então

83
00:05:00,370 --> 00:05:01,930
aqui é o espaço em branco no tabuleiro.

84
00:05:01,930 --> 00:05:04,420
>> Agora, é a telha acima do branco?

85
00:05:04,420 --> 00:05:06,210
É a telha para a esquerda da barra de papelão?

86
00:05:06,210 --> 00:05:07,420
É a telha para a direita da barra de papelão?

87
00:05:07,420 --> 00:05:08,970
É o azulejo abaixo do branco?

88
00:05:08,970 --> 00:05:13,330
Assim, se a telha é em qualquer dos
posições, então sabemos que a telha

89
00:05:13,330 --> 00:05:16,390
pode ser movido para o espaço vazio e
a placa pode ser movida para onde o

90
00:05:16,390 --> 00:05:18,240
telha atualmente.

91
00:05:18,240 --> 00:05:26,400
>> Então, aqui, nós dizemos que se a placa na posição
blank_i menos 1 blank_j.

92
00:05:26,400 --> 00:05:31,120
Então, isso está dizendo é a telha
acima da corrente em branco?

93
00:05:31,120 --> 00:05:34,350
E se assim for, vamos lembrar
que é a posição do azulejo.

94
00:05:34,350 --> 00:05:37,870
O azulejo está na posição blank_i
menos 1 e blank_j.

95
00:05:37,870 --> 00:05:40,660
agora pela primeira vez, também temos essa verificação
aqui, por isso é blank_i

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

97
00:05:41,760 --> 00:05:43,410
>> Por que quer fazer isso?

98
00:05:43,410 --> 00:05:47,290
Bem, se o branco é na linha superior
do conselho de administração, então nós não queremos

99
00:05:47,290 --> 00:05:51,240
olhar por cima do branco para o azulejo desde
não há nada acima do topo

100
00:05:51,240 --> 00:05:52,430
fileira do tabuleiro.

101
00:05:52,430 --> 00:05:55,950
Isto é como você pode acabar recebendo
algo como uma falha de segmentação ou

102
00:05:55,950 --> 00:05:59,030
o programa só poderia trabalhar
de formas inesperadas.

103
00:05:59,030 --> 00:06:04,310
Então, isso é ter certeza de que nós não
procurar em lugares que não são válidos.

104
00:06:04,310 --> 00:06:08,470
>> Agora vamos fazer a mesma coisa para
todas as outras possíveis combinações.

105
00:06:08,470 --> 00:06:13,250
Então, aqui, nós estamos olhando abaixo o espaço em branco
para ver se esse é o azulejo.

106
00:06:13,250 --> 00:06:16,950
E nós também temos que ter certeza que estamos
não na linha de baixo, ou então nós

107
00:06:16,950 --> 00:06:18,910
não deve olhar para o azulejo.

108
00:06:18,910 --> 00:06:25,040
Aqui, vamos olhar para a esquerda de
o espaço em branco para ver se é o azulejo.

109
00:06:25,040 --> 00:06:27,860
E não devemos olhar para a esquerda
se estamos na coluna mais à esquerda.

110
00:06:27,860 --> 00:06:30,100
E aqui nós vamos olhar para o
direito de o espaço em branco, e não devemos

111
00:06:30,100 --> 00:06:33,340
olhar para a direita, se estamos
na coluna da direita.

112
00:06:33,340 --> 00:06:37,820
>> Então, se nenhuma dessas coisas fosse verdade,
isso significa que o azulejo não é adjacente

113
00:06:37,820 --> 00:06:39,640
para o espaço em branco e podemos retornar false.

114
00:06:39,640 --> 00:06:41,230
O movimento não era válido.

115
00:06:41,230 --> 00:06:47,010
Mas, se um desses fosse verdade, então a
Neste ponto, sabemos que tile_i e

116
00:06:47,010 --> 00:06:50,540
tile_j são iguais aos
posição do azulejo.

117
00:06:50,540 --> 00:06:55,210
E assim, podemos atualizar a placa de
posições tile_i e tile_j.

118
00:06:55,210 --> 00:06:59,820
Sabemos que o novo valor será o branco
e que a posição blank_i

119
00:06:59,820 --> 00:07:02,950
blank_j, que era o original
em branco - nós sabemos o azulejo vai

120
00:07:02,950 --> 00:07:04,030
mudar para lá.

121
00:07:04,030 --> 00:07:07,610
>> Observe que na verdade, não tem que fazer um
troca real aqui, uma vez que sabemos que o

122
00:07:07,610 --> 00:07:09,850
os valores que precisam de ser inserido
naquelas posições.

123
00:07:09,850 --> 00:07:13,780
Nós não precisamos de um temporário
variável ao redor.

124
00:07:13,780 --> 00:07:16,920
>> Finalmente, precisamos lembrar que nós
temos nossas variáveis ​​globais que são

125
00:07:16,920 --> 00:07:18,980
manter o controle da situação
do branco.

126
00:07:18,980 --> 00:07:22,780
Por isso, queremos atualizar a posição de
o espaço em branco para estar onde a telha

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

128
00:07:24,190 --> 00:07:27,680
Finalmente, voltamos verdade, pois
o movimento foi bem sucedido.

129
00:07:27,680 --> 00:07:31,110
Nós trocar com sucesso o
em branco com a telha.

130
00:07:31,110 --> 00:07:34,890
>> Tudo bem, então passada nós
precisa verificar won.

131
00:07:34,890 --> 00:07:39,900
Assim, ganhou retorna da mesma forma um bool onde
verdade que vai indicar que o

132
00:07:39,900 --> 00:07:41,460
usuário ganhou o jogo.

133
00:07:41,460 --> 00:07:43,780
E falso está indicando que
o jogo ainda está em curso.

134
00:07:43,780 --> 00:07:46,340
O usuário ainda não ganhou.

135
00:07:46,340 --> 00:07:52,100
Então, isso vai ser muito bonito
o oposto de inicialização, onde init

136
00:07:52,100 --> 00:07:56,920
lembre-se, nós inicializar a bordo
a 15, 14, 13, 12, etc.

137
00:07:56,920 --> 00:08:03,000
Considerando ganhou, queremos verificar se o
placa é 1, 2, 3, 4, 5, e assim por diante.

138
00:08:03,000 --> 00:08:06,600
>> Então, vamos iniciar o nosso
contrariar a 1, uma vez que é o que o topo

139
00:08:06,600 --> 00:08:08,400
esquerdo da placa deve ser.

140
00:08:08,400 --> 00:08:10,860
E então nós vamos fazer um loop
ao longo de todo o tabuleiro.

141
00:08:10,860 --> 00:08:13,690
Vamos ignorar essa condição
por um segundo.

142
00:08:13,690 --> 00:08:18,410
E essa condição só vai
verificação é a placa nesta posição

143
00:08:18,410 --> 00:08:20,790
igual as contagens atuais?

144
00:08:20,790 --> 00:08:27,040
Se assim for, incrementa a contagem de modo a que o
próxima posição que é olhar para um maior

145
00:08:27,040 --> 00:08:29,690
que a posição estamos no agora.

146
00:08:29,690 --> 00:08:32,700
>> Então é assim que nós temos a
superior esquerdo deve ser 1.

147
00:08:32,700 --> 00:08:33,950
Incrementar a contagem de 2.

148
00:08:33,950 --> 00:08:35,010
Olhe para a próxima posição.

149
00:08:35,010 --> 00:08:35,690
É este o 2?

150
00:08:35,690 --> 00:08:37,659
Se for assim, incrementar a contagem de 3.

151
00:08:37,659 --> 00:08:39,179
Próxima posição, isto é 3?

152
00:08:39,179 --> 00:08:42,440
Se for assim, incrementar a contagem
a 4, e assim por diante.

153
00:08:42,440 --> 00:08:49,190
Assim, se houver qualquer posição sobre o
placa que não é igual a nossa contagem,

154
00:08:49,190 --> 00:08:52,640
então queremos voltar falsa, já que
significa que há alguma peça que é

155
00:08:52,640 --> 00:08:55,490
não na posição correta.

156
00:08:55,490 --> 00:08:58,810
>> Então, aqui, o que é essa condição está fazendo?

157
00:08:58,810 --> 00:09:02,170
Bem, lembre-se que o espaço em branco é
deveria ir no canto inferior direito.

158
00:09:02,170 --> 00:09:06,180
E o valor do branco não pode
necessariamente igual ao valor do

159
00:09:06,180 --> 00:09:11,080
contador que vai ser alcançado
na parte inferior direita.

160
00:09:11,080 --> 00:09:15,760
Por isso, quer especificamente para verificar se i
é igual é igual a menos d 1 e j iguais

161
00:09:15,760 --> 00:09:19,470
d é igual a menos 1 - o que está dizendo, se
estão olhando para o canto inferior direito da

162
00:09:19,470 --> 00:09:22,050
a bordo - então nós apenas
deseja continuar.

163
00:09:22,050 --> 00:09:26,200
Queremos pular este particular
iteração do loop para.

164
00:09:26,200 --> 00:09:31,250
>> E assim, se conseguirmos passar por isso
aninhados em loop, o que significa que

165
00:09:31,250 --> 00:09:34,690
não houve telha que foi em
a posição incorreta.

166
00:09:34,690 --> 00:09:38,900
E nós sair do loop e vir
aqui, onde podemos voltar verdade.

167
00:09:38,900 --> 00:09:41,800
Todos os azulejos estavam nas posições corretas
e isso significa que o usuário tem

168
00:09:41,800 --> 00:09:43,230
ganhou o jogo.

169
00:09:43,230 --> 00:09:44,460
E é isso.

170
00:09:44,460 --> 00:09:46,550
Meu nome é Rob Bowden, e este tinha 15 anos.

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