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

2
00:00:09,386 --> 00:00:11,332
>> ZAMYLA CHAN: La oss ha
moro med Fifteen.

3
00:00:11,332 --> 00:00:15,680
Femten er det første spillet som du får
å gjennomføre, og det er interaktive.

4
00:00:15,680 --> 00:00:16,410
Nå, for ikke å bekymre deg.

5
00:00:16,410 --> 00:00:18,830
Du trenger ikke å skrive den
hele greia selv.

6
00:00:18,830 --> 00:00:22,320
Se på fordelingen kode fordi en
Mange av spillet struktur er allerede

7
00:00:22,320 --> 00:00:23,880
satt opp for deg.

8
00:00:23,880 --> 00:00:28,160
Det aksepterer og analyserer en kommandolinje
argument fra brukeren og skaper en

9
00:00:28,160 --> 00:00:31,230
styret basert på at innspill.

10
00:00:31,230 --> 00:00:35,570
Den sjekker om spillet er vunnet og utganger
når brukerens vunnet spillet.

11
00:00:35,570 --> 00:00:38,340
Og for å vinne kampen, det blir
input fra brukeren og

12
00:00:38,340 --> 00:00:40,610
kaller Move-funksjonen.

13
00:00:40,610 --> 00:00:44,600
>> Så vi kommer til å gjennomføre fire
funksjoner for spillet av femten,

14
00:00:44,600 --> 00:00:48,110
init, tegne, flytte, og vant.

15
00:00:48,110 --> 00:00:50,340
Først, la oss takle init.

16
00:00:50,340 --> 00:00:55,150
I init, for initialisere, vi representerer
styret i et 2D heltall array.

17
00:00:55,150 --> 00:01:01,070
Og dette er en global variabel kalt
bord med dimensjoner MAX, og MAX,

18
00:01:01,070 --> 00:01:03,880
maksimale dimensjoner av styret.

19
00:01:03,880 --> 00:01:07,310
Nå er den faktiske dimensjon av brettet
er gitt av brukeren, representert

20
00:01:07,310 --> 00:01:10,620
heltallet d, noe som kunne
være mindre enn MAX.

21
00:01:10,620 --> 00:01:14,660
Men, i C, du kan ikke endre størrelsen på arrays,
så du sitter fast med

22
00:01:14,660 --> 00:01:16,730
at maksimal dimensjon.

23
00:01:16,730 --> 00:01:19,870
>> Din jobb i init er å fylle
verdiene av styre

24
00:01:19,870 --> 00:01:21,860
med den riktige verdien.

25
00:01:21,860 --> 00:01:26,910
Nå, vi har sett 1D arrays, men
hvordan 2D-matriser fungerer?

26
00:01:26,910 --> 00:01:30,985
Det er en indeks for raden, null
indeksert som alltid, og da også av

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

28
00:01:32,100 --> 00:01:36,120
Og du vil fylle din rutenett i inn
synkende verdier, akkurat som dette.

29
00:01:36,120 --> 00:01:43,260
Grid, 0, 0, rad 0, kolonne
0, er åtte, grid 0, 1 er syv.

30
00:01:43,260 --> 00:01:48,500
Dette er et eksempel hvor
d, d lite, er 3..

31
00:01:48,500 --> 00:01:52,690
>> Nå har styret i Fifteen må også
inneholde en blank flis, hvis du noen gang

32
00:01:52,690 --> 00:01:54,280
spilt med det fysiske spillet.

33
00:01:54,280 --> 00:01:59,210
Men, er styret et heltall array, så
alle verdier må være heltall.

34
00:01:59,210 --> 00:02:06,950
Så det er opp til deg å bestemme et heltall
verdi for å representere en tom flis.

35
00:02:06,950 --> 00:02:10,460
For å initialisere ditt bord, kan du bruke
loop strukturer for å inneholde

36
00:02:10,460 --> 00:02:16,440
starter tilstand av styret, hvor styret
jeg j representerer elementet på

37
00:02:16,440 --> 00:02:19,380
rad i og kolonne j.

38
00:02:19,380 --> 00:02:23,035
De begynner i synkende rekkefølge, og
Husk, at hvis antallet av fliser

39
00:02:23,035 --> 00:02:29,590
er et oddetall, så er du nødt til å
bytte plasseringen av to og en.

40
00:02:29,590 --> 00:02:33,790
Så der har vi vår
initialisert bord.

41
00:02:33,790 --> 00:02:37,440
>> Nå som vi har initialisert vår
bord, er det på tide å trekke den.

42
00:02:37,440 --> 00:02:41,260
Trekningen vil skrive ut den nåværende tilstanden i
bord, men du må sørge for at

43
00:02:41,260 --> 00:02:44,260
å skrive ut fliser i samme rekkefølge
at du har initialisert dem.

44
00:02:44,260 --> 00:02:47,300
Og du trenger også å formatere
tallene dine riktig.

45
00:02:47,300 --> 00:02:51,700
Fordi vi kan ha enkelttall og
doble sifre, så du vil

46
00:02:51,700 --> 00:02:54,540
skrive ut en tom plass før
noen ensifret tall.

47
00:02:54,540 --> 00:03:00,150
Du bruker det ved hjelp
plassholderen -.

48
00:03:00,150 --> 00:03:02,550
>> Men husk vår tomrom.

49
00:03:02,550 --> 00:03:05,970
Vi ønsker ikke å skrive det faktiske antallet
at vi har valgt til å representere

50
00:03:05,970 --> 00:03:10,410
at tomrom i styret, men vi har også
ikke ønsker å skrive ut noe i det hele tatt.

51
00:03:10,410 --> 00:03:15,310
Så hva du kan gjøre er å definere et symbol
eller tegn for å representere

52
00:03:15,310 --> 00:03:17,050
blank flis.

53
00:03:17,050 --> 00:03:21,030
I eksemplene ovenfor har jeg valgt en
strek, og så du bare skrive ut

54
00:03:21,030 --> 00:03:26,970
at når du kommer til blank
plass i trekningen funksjon.

55
00:03:26,970 --> 00:03:29,850
>> Så trekke vil ha nestet for løkker.

56
00:03:29,850 --> 00:03:31,150
Noe sånt som dette.

57
00:03:31,150 --> 00:03:35,660
For hver rad, og deretter for hver verdi i
raden, du kommer til å skrive ut

58
00:03:35,660 --> 00:03:36,940
verdi i dette rommet.

59
00:03:36,940 --> 00:03:39,470
Når du har skrevet ut alle verdier
i raden, så du

60
00:03:39,470 --> 00:03:41,180
kan skrive ut en ny linje.

61
00:03:41,180 --> 00:03:47,730
Husk at den rekkefølgen for uavgjort
Funksjonen må ekko eller speile den rekkefølgen

62
00:03:47,730 --> 00:03:48,980
i din initialisert funksjon.

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

64
00:03:51,290 --> 00:03:55,160
>> Nå som du initialisert styret og
at du har tegnet det, er det på tide å la

65
00:03:55,160 --> 00:03:58,500
brukeren redigere det og gjøre sine trekk.

66
00:03:58,500 --> 00:04:03,840
Så i Fifteen.c funksjon, den
Programmet tar input fra brukeren og

67
00:04:03,840 --> 00:04:07,690
Da kaller flyttingen funksjon, passerer
i antall flis som

68
00:04:07,690 --> 00:04:09,270
brukeren ønsker å flytte.

69
00:04:09,270 --> 00:04:10,380
Nå, vær forsiktig.

70
00:04:10,380 --> 00:04:14,200
Dette er det faktiske antall av flis
og ikke den faktiske plasseringen.

71
00:04:14,200 --> 00:04:19,010
Så, må du søke etter flis
posisjon til å vite hvor det er.

72
00:04:19,010 --> 00:04:23,440
>> Nå bør du bare la brukeren
å gjøre et trekk hvis det er lovlig.

73
00:04:23,440 --> 00:04:27,910
Et lovlig trekk er noe flis som er
som grenser til den tomme flis.

74
00:04:27,910 --> 00:04:32,020
Det betyr, over og under, for å
venstre og til høyre.

75
00:04:32,020 --> 00:04:34,680
Så du trenger å vite hvor
den blanke fliser er like godt.

76
00:04:34,680 --> 00:04:39,720
Nå, for hver bevegelse du søker etter
brukerne flis, men det er nok

77
00:04:39,720 --> 00:04:43,030
ikke best å søke etter den blanke fliser
hver gang fordi du gjør det

78
00:04:43,030 --> 00:04:45,270
hver eneste gang
brukeren ønsker å flytte.

79
00:04:45,270 --> 00:04:50,300
Så, i stedet, er det best å huske hvor
den blanke fliser er ved hjelp av noen

80
00:04:50,300 --> 00:04:52,650
godt kalt variabler.

81
00:04:52,650 --> 00:04:55,970
Så når du tillater brukeren å gjøre sine
trekk, de er vel på sin

82
00:04:55,970 --> 00:04:59,700
måten å vinne spillet av femten.

83
00:04:59,700 --> 00:05:03,940
>> For å vinne spillet Femten, flisene
må være i en bestemt rekkefølge, og

84
00:05:03,940 --> 00:05:06,970
den vant funksjonen sjekker om
spillet er vunnet.

85
00:05:06,970 --> 00:05:10,290
Den returnerer True hvis spillet er vunnet og
flisene er i riktig rekkefølge,

86
00:05:10,290 --> 00:05:12,210
og False ellers.

87
00:05:12,210 --> 00:05:15,830
Så for å vinne spillet av femten, fliser
nødt til å være økende rekkefølge, med

88
00:05:15,830 --> 00:05:19,230
blank flis nederst i høyre hjørne.

89
00:05:19,230 --> 00:05:23,630
Så hvordan gjør du sjekke om brukeren
har flyttet styret inn i høyre

90
00:05:23,630 --> 00:05:25,010
orientering?

91
00:05:25,010 --> 00:05:29,200
>> Vel, vil du iterere over styret og
kontrollere verdiene for å sørge for at

92
00:05:29,200 --> 00:05:30,550
de er på rett sted.

93
00:05:30,550 --> 00:05:33,910
For å gjøre dette, kan du bruke nestet
for looper, akkurat som du gjorde

94
00:05:33,910 --> 00:05:36,520
i trekningen og i init.

95
00:05:36,520 --> 00:05:40,430
Det er et par måter å sjekke
og validere om styret er

96
00:05:40,430 --> 00:05:42,860
korrekte og et vinnende
formasjon, skjønt.

97
00:05:42,860 --> 00:05:47,330
Hvis du går fra venstre til høyre, og begynner
fra den øverste raden ned, deretter hver

98
00:05:47,330 --> 00:05:50,590
Tallet må være større enn
det foregående.

99
00:05:50,590 --> 00:05:54,530
Vær forsiktig med hvilken verdi du har
valgt for blank flis skjønt.

100
00:05:54,530 --> 00:05:59,250
>> Eller du kan bruke en teller variabel til
sørge for at hver verdi er på plass, dersom

101
00:05:59,250 --> 00:06:03,660
du kommer opp med en slags
formel for å representere dette.

102
00:06:03,660 --> 00:06:06,250
Så ha det gøy å eksperimentere
med regnestykket.

103
00:06:06,250 --> 00:06:10,930
Når du har kommet opp med en måte, retur
Sant når brukeren har vunnet spillet.

104
00:06:10,930 --> 00:06:15,950
Men hvis noen verdi er feil, retur
Falsk, har brukeren å fortsette å flytte

105
00:06:15,950 --> 00:06:18,440
fordi de ikke har vunnet spillet.

106
00:06:18,440 --> 00:06:23,030
Når du implementerer denne sjekken, og sammen
med initialisere, tegne, og bevege seg,

107
00:06:23,030 --> 00:06:25,110
du er ferdig med spillet av femten.

108
00:06:25,110 --> 00:06:27,620
Gratulerer og ha det gøy å spille.

109
00:06:27,620 --> 00:06:30,600
Mitt navn er Zamyla og dette er CS50.

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