1
00:00:00,000 --> 00:00:09,386

2
00:00:09,386 --> 00:00:11,332
>> ZAMYLA CHAN: Vamos ter
divertir com quinze.

3
00:00:11,332 --> 00:00:15,680
Quinze é o primeiro jogo que você obtenha
para implementar e é interativo.

4
00:00:15,680 --> 00:00:16,410
Agora, não se preocupe.

5
00:00:16,410 --> 00:00:18,830
Você não tem que escrever o
tudo mesmo.

6
00:00:18,830 --> 00:00:22,320
Verifique o código de distribuição, porque um
muito da estrutura do jogo já está

7
00:00:22,320 --> 00:00:23,880
configurado para você.

8
00:00:23,880 --> 00:00:28,160
Ele aceita e analisa uma linha de comando
argumento do usuário e cria uma

9
00:00:28,160 --> 00:00:31,230
placa com base nessa entrada.

10
00:00:31,230 --> 00:00:35,570
Ele verifica se o jogo está ganho e sai
uma vez que o usuário do ganhou o jogo.

11
00:00:35,570 --> 00:00:38,340
E para ganhar o jogo, ele fica
entrada do usuário e

12
00:00:38,340 --> 00:00:40,610
chama a função Move.

13
00:00:40,610 --> 00:00:44,600
>> Então, nós vamos estar implementando quatro
funções para o jogo de quinze anos,

14
00:00:44,600 --> 00:00:48,110
init, desenhar, mover, e ganhou.

15
00:00:48,110 --> 00:00:50,340
Primeiro, vamos resolver o init.

16
00:00:50,340 --> 00:00:55,150
No init, para inicializar, representamos
a placa em um array de inteiros 2D.

17
00:00:55,150 --> 00:01:01,070
E esta é uma variável global chamada
placa com dimensões MAX e MAX,

18
00:01:01,070 --> 00:01:03,880
as dimensões máximas do conselho.

19
00:01:03,880 --> 00:01:07,310
Agora, a dimensão real do conselho
é dada pelo utilizador, representada em

20
00:01:07,310 --> 00:01:10,620
o número inteiro d, o que poderia
ser inferior a MAX.

21
00:01:10,620 --> 00:01:14,660
Mas, em C, você não pode redimensionar matrizes,
então você está preso com

22
00:01:14,660 --> 00:01:16,730
essa dimensão máxima.

23
00:01:16,730 --> 00:01:19,870
>> Seu trabalho em init é preencher
os valores do conselho

24
00:01:19,870 --> 00:01:21,860
com o valor correcto.

25
00:01:21,860 --> 00:01:26,910
Agora, temos visto matrizes 1D, mas
como matrizes 2D funciona?

26
00:01:26,910 --> 00:01:30,985
Há um índice da linha, zerar
indexados, como sempre, e depois também de

27
00:01:30,985 --> 00:01:32,100
a coluna.

28
00:01:32,100 --> 00:01:36,120
E você vai preencher sua grade em em
descendente valores, assim como este.

29
00:01:36,120 --> 00:01:43,260
Grade, 0, 0, linha 0, coluna
0, 8 é, grade 0, 1 a 7.

30
00:01:43,260 --> 00:01:48,500
Isto é para um exemplo onde
d, pouco d, é 3.

31
00:01:48,500 --> 00:01:52,690
>> Agora, o conselho em Quinze devem também
conter uma telha em branco, se você já

32
00:01:52,690 --> 00:01:54,280
jogado com o jogo físico.

33
00:01:54,280 --> 00:01:59,210
Mas, o conselho é um array de inteiros, de modo
todos os valores têm de ser números inteiros.

34
00:01:59,210 --> 00:02:06,950
Portanto, cabe a você decidir um inteiro
valor para representar um azulejo branco.

35
00:02:06,950 --> 00:02:10,460
Para inicializar sua placa, você pode usar
estruturas de loop para conter a

36
00:02:10,460 --> 00:02:16,440
estado inicial da placa, onde bordo
i j representa o elemento em

37
00:02:16,440 --> 00:02:19,380
i linha e coluna j.

38
00:02:19,380 --> 00:02:23,035
Eles começam em ordem decrescente e,
lembrar que, se o número de peças

39
00:02:23,035 --> 00:02:29,590
é estranho, então você vai ter que
trocar a localização de 2 e de 1.

40
00:02:29,590 --> 00:02:33,790
Portanto, há, temos a nossa
placa inicializado.

41
00:02:33,790 --> 00:02:37,440
>> Agora, que temos a nossa inicializado
placa, é hora de desenhá-la.

42
00:02:37,440 --> 00:02:41,260
Sorteio irá imprimir o estado actual da
placa, mas você precisa ter certeza de

43
00:02:41,260 --> 00:02:44,260
para imprimir azulejos na mesma ordem
que você tenha inicializado eles.

44
00:02:44,260 --> 00:02:47,300
E você também precisa formatar
seus números corretamente.

45
00:02:47,300 --> 00:02:51,700
Porque nós pode ter um dígito e
dois dígitos, então você quer

46
00:02:51,700 --> 00:02:54,540
imprimir um espaço em branco antes
todos os números de um dígito.

47
00:02:54,540 --> 00:03:00,150
Você usa isso usando
o espaço reservado -.

48
00:03:00,150 --> 00:03:02,550
>> Mas lembre-se o nosso espaço em branco.

49
00:03:02,550 --> 00:03:05,970
Nós não queremos imprimir o número real
que temos escolhido para representar

50
00:03:05,970 --> 00:03:10,410
que o espaço em branco na placa, mas também
não quer imprimir nada.

51
00:03:10,410 --> 00:03:15,310
Então o que você pode fazer é definir um símbolo
ou caracteres para representar o

52
00:03:15,310 --> 00:03:17,050
azulejo branco.

53
00:03:17,050 --> 00:03:21,030
Nos exemplos anteriores, eu escolhi um
sublinhado, e então você apenas imprimir

54
00:03:21,030 --> 00:03:26,970
que sempre que você chegar ao branco
espaço em sua função de empate.

55
00:03:26,970 --> 00:03:29,850
>> Então desenhar terá aninhados para loops.

56
00:03:29,850 --> 00:03:31,150
Algo parecido com isto.

57
00:03:31,150 --> 00:03:35,660
Para cada linha, em seguida, para cada valor de
a linha, você está indo para imprimir o

58
00:03:35,660 --> 00:03:36,940
valor neste espaço.

59
00:03:36,940 --> 00:03:39,470
Depois de impresso todos os valores
na linha, então você

60
00:03:39,470 --> 00:03:41,180
pode imprimir uma nova linha.

61
00:03:41,180 --> 00:03:47,730
Lembre-se que a ordem para o seu sorteio
função deve ecoar ou espelhar a ordem

62
00:03:47,730 --> 00:03:48,980
na sua função inicializado.

63
00:03:48,980 --> 00:03:51,290

64
00:03:51,290 --> 00:03:55,160
>> Agora que você inicializar a bordo e
que você tenha desenhado isso, é hora de deixar

65
00:03:55,160 --> 00:03:58,500
o usuário editá-lo e fazer os seus movimentos.

66
00:03:58,500 --> 00:04:03,840
Assim, em função Fifteen.c, o
programa leva a entrada do usuário e

67
00:04:03,840 --> 00:04:07,690
em seguida, chama a função de movimento, passando
o número da telha que o

68
00:04:07,690 --> 00:04:09,270
usuário deseja mover.

69
00:04:09,270 --> 00:04:10,380
Agora, tome cuidado.

70
00:04:10,380 --> 00:04:14,200
Este é o número real da telha
e não a sua posição real.

71
00:04:14,200 --> 00:04:19,010
Então, você precisa procurar a telha de
posição de saber onde ele está.

72
00:04:19,010 --> 00:04:23,440
>> Agora, você só deve permitir que o usuário
para fazer um movimento, se é legal.

73
00:04:23,440 --> 00:04:27,910
Um lance legal é qualquer peça que é
adjacente ao azulejo branco.

74
00:04:27,910 --> 00:04:32,020
Isso significa que, acima e abaixo, para
a esquerda e para a direita.

75
00:04:32,020 --> 00:04:34,680
Então, você vai precisar saber onde
o azulejo branco é tão bem.

76
00:04:34,680 --> 00:04:39,720
Agora, para cada movimento que você está procurando
a telha de usuários, mas é provavelmente

77
00:04:39,720 --> 00:04:43,030
não melhor para procurar o azulejo branco
cada vez, porque você está fazendo isso

78
00:04:43,030 --> 00:04:45,270
cada vez que o
usuário deseja mover.

79
00:04:45,270 --> 00:04:50,300
Então, em vez disso, é melhor se lembrar de onde
o azulejo branco está usando algum

80
00:04:50,300 --> 00:04:52,650
bem nomeado variáveis.

81
00:04:52,650 --> 00:04:55,970
Então, quando você permitir que o usuário faça a sua
movimentos, eles estão bem no seu

82
00:04:55,970 --> 00:04:59,700
maneira de ganhar o jogo dos Quinze.

83
00:04:59,700 --> 00:05:03,940
>> Para ganhar o jogo dos Quinze, as telhas
tem que estar em uma ordem específica, e

84
00:05:03,940 --> 00:05:06,970
a função ganhou verifica se
o jogo está ganho.

85
00:05:06,970 --> 00:05:10,290
Ele retorna True se o jogo está ganho e
as telhas são na ordem correta,

86
00:05:10,290 --> 00:05:12,210
e False caso contrário.

87
00:05:12,210 --> 00:05:15,830
Então, para ganhar o jogo de quinze anos, telhas
tem que ser por ordem crescente, com o

88
00:05:15,830 --> 00:05:19,230
azulejo branco no canto inferior direito.

89
00:05:19,230 --> 00:05:23,630
Assim como você verificar se o usuário
mudou-se a placa no direito

90
00:05:23,630 --> 00:05:25,010
orientação?

91
00:05:25,010 --> 00:05:29,200
>> Bem, você vai interagir sobre a placa e
verificar os valores para se certificar de que

92
00:05:29,200 --> 00:05:30,550
eles estão no lugar certo.

93
00:05:30,550 --> 00:05:33,910
Para fazer isso, você pode usar nested
loops, tal como fez

94
00:05:33,910 --> 00:05:36,520
no sorteio e no init.

95
00:05:36,520 --> 00:05:40,430
Há um par de maneiras de verificar
e validar se o conselho é

96
00:05:40,430 --> 00:05:42,860
correta e uma vencedora
formação, no entanto.

97
00:05:42,860 --> 00:05:47,330
Se você vai da esquerda para a direita, começando
a partir da linha de cima para baixo, em seguida, cada

98
00:05:47,330 --> 00:05:50,590
número deve ser maior que
o anterior.

99
00:05:50,590 --> 00:05:54,530
Tenha cuidado com o que você tem valor
escolheu para o seu azulejo branco embora.

100
00:05:54,530 --> 00:05:59,250
>> Ou você pode usar uma variável de contador para
assegurar que cada valor é no lugar, caso

101
00:05:59,250 --> 00:06:03,660
você venha com algum tipo de
fórmula para representar isso.

102
00:06:03,660 --> 00:06:06,250
Então divirta-se experimentando
com a matemática.

103
00:06:06,250 --> 00:06:10,930
Uma vez que você chegar a uma maneira, o retorno
É verdade, uma vez que o usuário ganhou o jogo.

104
00:06:10,930 --> 00:06:15,950
Mas se algum valor estiver incorreto, o retorno
False, o usuário tem que continuar se movendo

105
00:06:15,950 --> 00:06:18,440
porque não ganhou o jogo.

106
00:06:18,440 --> 00:06:23,030
Depois de implementar esta verificação e, junto
com initialize, desenhar e mover-se,

107
00:06:23,030 --> 00:06:25,110
você já terminou o jogo dos Quinze.

108
00:06:25,110 --> 00:06:27,620
Parabéns e se divertir jogando.

109
00:06:27,620 --> 00:06:30,600
Meu nome é Zamyla e este é CS50.

110
00:06:30,600 --> 00:06:37,632