1
00:00:01,100 --> 00:00:07,270
Et cette vidéo je vais aller plus de créer les solutions à ce problème de réseau mis à partir de zéro.

2
00:00:07,290 --> 00:00:10,250
Donc, la première que nous avons est référents d'impression.

3
00:00:10,260 --> 00:00:11,100
Alors avant de commencer.

4
00:00:11,100 --> 00:00:15,780
Et quand je reçois mes fichiers mis en place correctement, j'ai déjà un vieux fichier lui.

5
00:00:15,780 --> 00:00:18,020
Je viens d'appeler cette solution que HMO.

6
00:00:18,450 --> 00:00:28,170
Je vais inclure une source de script source égale à la solution que J S et puis je dois créer ce fichier.

7
00:00:28,450 --> 00:00:30,620
Alors économisons cette solution.

8
00:00:30,730 --> 00:00:31,840
Oui.

9
00:00:32,940 --> 00:00:37,860
Et comme toujours, je voudrais commencer par mon conseil, mais je me connecte.

10
00:00:39,090 --> 00:00:39,650
Allons-y.

11
00:00:39,660 --> 00:00:41,490
Ouvrez ce dans le navigateur.

12
00:00:42,450 --> 00:00:45,830
Ouvrez la console et nous voyons sont connectés.

13
00:00:46,110 --> 00:00:46,860
D'accord.

14
00:00:46,860 --> 00:00:49,390
Commençons donc par l'impression inverse.

15
00:00:49,450 --> 00:00:51,180
Ainsi, l'impression inverse est une fonction.

16
00:00:51,540 --> 00:00:57,640
Donc, je vais commencer par définir la fonction d'impression inverse qui prend un seul argument et tableau.

17
00:00:57,690 --> 00:01:03,340
Je vais juste appeler un r r et tout ce que nous devons faire est de boucler le tableau.

18
00:01:03,600 --> 00:01:10,140
Sauf que nous voulons boucler en arrière de la fin du tableau au début et puis nous allons appeler son journal var chaque élément.

19
00:01:10,200 --> 00:01:12,510
Donc, un foreach ne va pas être idéal ici.

20
00:01:12,690 --> 00:01:17,780
Nous allons utiliser une boucle for qui est un peu plus flexible dans l'ordre que nous parcourons la liste.

21
00:01:18,390 --> 00:01:24,570
Donc, pour var I au lieu de commencer à zéro, nous allons le démarrer à la fin du tableau.

22
00:01:24,630 --> 00:01:34,550
So var est égal à array et n'aime pas moins 1 et nous devons ajouter que moins 1 parce que la longueur est toujours un plus grand que le plus grand indice.

23
00:01:34,740 --> 00:01:36,730
Il est donc un peu espacé.

24
00:01:36,750 --> 00:01:38,590
Ensuite, nous allons continuer.

25
00:01:38,670 --> 00:01:42,480
Alors que I est supérieur à égal à zéro.

26
00:01:42,510 --> 00:01:47,400
Et enfin, nous allons à minus moins.

27
00:01:47,640 --> 00:01:49,470
Je vais donc commencer.

28
00:01:49,740 --> 00:02:21,160
Dans le cas de l'impression inverse de ce tableau 3 6 à 5 je vais commencer à cet index qui serait de trois et nous allons imprimer le tableau de log si je donc qui va imprimer 5 et puis vous soustraire 1 de I et d'imprimer Un tableau de I donne 2 et puis 6 puis 3 et le dernier temps est égal à zéro.

29
00:02:21,300 --> 00:02:23,460
Donc nous imprimons trois et puis nous avons terminé.

30
00:02:23,700 --> 00:02:25,120
Alors allons jeter un coup d'oeil.

31
00:02:25,170 --> 00:02:28,070
Je vais appeler cette impression se réfère à ce tableau.

32
00:02:28,080 --> 00:02:36,070
Exécutez-le dans le navigateur et vous pouvez voir que nous obtenons 5 à 6 et 3 qui est ce que nous attendions.

33
00:02:36,150 --> 00:02:38,580
Cinq à six et trois.

34
00:02:38,790 --> 00:02:40,880
Passons au problème suivant.

35
00:02:41,460 --> 00:02:47,160
Donc, le problème suivant est uniforme qui prend un tableau comme argument et retourne true.

36
00:02:47,190 --> 00:02:49,890
Seulement si tous les éléments sont exactement les mêmes.

37
00:02:50,430 --> 00:02:59,930
Donc, je vais commencer par écrire une note que c'est là où commence uniforme, car ce fichier sera assez complet à la fin de cette.

38
00:03:00,150 --> 00:03:01,700
Donc, je tiens simplement à le préciser.

39
00:03:02,220 --> 00:03:08,940
Commençons par définir notre fonction est uniforme et il va prendre un seul tableau.

40
00:03:09,510 --> 00:03:15,120
Donc, la façon dont je vais résoudre ce que je vais faire une variable égale au tout premier élément.

41
00:03:15,660 --> 00:03:28,990
Donc, dans ce cas 1 et puis je vais boucler à travers le tableau et comparer ce premier élément à tous les autres éléments et si à un moment donné, ils ne sont pas les mêmes, nous allons retourner faux et juste terminer la fonction entière .

42
00:03:29,280 --> 00:03:33,060
Mais si nous arrivons à la fin, cela signifie que chaque élément est le même.

43
00:03:33,060 --> 00:03:34,530
Nous pouvons donc retourner vrai.

44
00:03:35,010 --> 00:03:41,890
Donc, je vais commencer par faire ma première variable var premier est égal au premier élément.

45
00:03:43,080 --> 00:03:45,340
Ensuite, je vais faire le tour du tableau.

46
00:03:45,660 --> 00:03:51,390
Donc, je vais utiliser une boucle for ici et il ya une raison que je n'utilise pas un foreach que je vais expliquer après cela.

47
00:03:51,390 --> 00:04:07,810
Donc, je vais commencer à boucler à travers je moins que Array n'aime pas je plus plus et je vais juste vérifier si tableau élevé n'est pas égal à la première.

48
00:04:07,890 --> 00:04:10,410
Cela signifie que notre réseau n'est pas uniforme.

49
00:04:10,590 --> 00:04:12,920
Alors je vais retourner faux.

50
00:04:13,860 --> 00:04:19,820
Et puis à la fin de mon tableau si nous le faisons à travers toute la boucle, je peux retourner vrai.

51
00:04:20,790 --> 00:04:29,120
Il y a une petite optimisation ici qui est que je suis en train de comparer le premier élément arrays de zéro au premier élément.

52
00:04:29,280 --> 00:04:30,680
La toute première fois dans la boucle.

53
00:04:30,690 --> 00:04:35,710
Si je commence par dire 0 et la vérification est d'effacer la ligne égale à la première.

54
00:04:35,790 --> 00:04:36,900
Je ne veux donc pas faire ça.

55
00:04:36,960 --> 00:04:39,090
Je vais commencer à l'index 1.

56
00:04:39,660 --> 00:04:41,280
Testez-le.

57
00:04:41,280 --> 00:04:49,310
Actualiser notre page est uniforme du tableau 1 1 1.

58
00:04:49,500 --> 00:04:50,600
C'est vrai.

59
00:04:50,790 --> 00:04:52,360
Mais comment environ 1 1 2.

60
00:04:52,620 --> 00:04:55,540
C'est faux et deux sont allés.

61
00:04:55,620 --> 00:04:57,250
C'est aussi faux.

62
00:04:57,780 --> 00:04:58,290
D'ACCORD.

63
00:04:58,290 --> 00:05:01,380
Donc, j'ai mentionné que je ne voulais pas utiliser un pour chacun.

64
00:05:01,470 --> 00:05:29,350
Et la raison derrière cela est que si j'ai écrit un commentaire foreach ce out et au lieu d'une boucle for ici si je faisais un point rouge pour chaque fonction et je l'appelle élément et je vais vérifier si l'élément n'est pas égal à First Je reviendrai faux.

65
00:05:29,380 --> 00:05:34,840
C'est exactement la même logique sauf que nous avons ajouté dans un foreach au lieu d'une boucle for.

66
00:05:35,120 --> 00:05:43,860
Nous avons un problème et le problème est que lorsque je retourne faux ici, cela ne retourne que de la première fonction qui est ici.

67
00:05:44,080 --> 00:05:55,040
Donc il ne sort pas de tout son uniforme, il suffit de sortir de la première fonction qui nous amène alors à ce niveau et puis il exécute juste la ligne suivante qui est retourné vrai.

68
00:05:55,900 --> 00:06:03,400
Donc, plutôt que d'avoir à traiter avec le travail ici, je vais juste utiliser une boucle for parce que c'est beaucoup plus simple, mais je veux que vous compreniez quel est le problème.

69
00:06:03,440 --> 00:06:06,910
Donc, pour résumer que de nouveau, je retourne au lieu d'une fonction.

70
00:06:06,940 --> 00:06:16,760
Il ne détache qu'une seule couche de sorte qu'il ne retourne que la fonction exacte et ensuite la fonction suivante qui est à l'intérieur de lui termine toujours son exécution.

71
00:06:16,750 --> 00:06:22,460
Donc, je vais venir avec celui-ci et laissez-nous simplement laisser celui-ci comme notre véritable solution.

72
00:06:23,950 --> 00:06:26,220
Ensuite, nous avons un tableau.

73
00:06:26,620 --> 00:06:31,420
Donc, un certain tableau prend un seul tableau et il somme de chaque élément à l'intérieur de celui-ci.

74
00:06:31,430 --> 00:06:44,280
Donc, nous allons commencer avec mon commentaire un certain tableau et je vais déclarer la fonction de certains tableau prend un seul tableau.

75
00:06:44,890 --> 00:06:48,710
Et dans ce cas nous devons faire une variable pour tenir le total.

76
00:06:48,800 --> 00:06:52,920
Et puis nous devons boucler tout le tableau et ajouter à ce total.

77
00:06:52,940 --> 00:06:57,170
Donc je vais commencer avec ma variable total égale à zéro.

78
00:06:57,880 --> 00:06:59,850
Et puis je vais le faire pour chacun.

79
00:07:00,310 --> 00:07:02,480
Donc tableau pour chacun.

80
00:07:02,500 --> 00:07:15,010
Et je pourrais juste faire une boucle régulière et je vais juste appeler cet élément et je vais juste ajouter au total à chaque fois.

81
00:07:15,010 --> 00:07:18,300
Donc le total plus les éléments égaux.

82
00:07:19,340 --> 00:07:23,340
Et puis le retour final total et c'est tout ce que j'ai à faire.

83
00:07:23,380 --> 00:07:30,960
Démarrez donc la boucle du zéro total dans le tableau, prenez chaque élément et ajoutez-le au total, puis retournez le total à la fin.

84
00:07:31,390 --> 00:07:33,750
Testez-le.

85
00:07:34,060 --> 00:07:37,640
Essayons de faire un tableau sur le tableau.

86
00:07:37,630 --> 00:07:41,500
Un deux trois et j'en ai six.

87
00:07:41,530 --> 00:07:45,300
Et comment environ 10 10 10 et vous obtenez 30.

88
00:07:45,680 --> 00:07:47,710
OK, c'est un tableau.

89
00:07:48,250 --> 00:07:53,220
La dernière ici est de déterminer l'élément max dans un tableau de nombres.

90
00:07:53,530 --> 00:07:57,430
Je vais donc ajouter mes commentaires en premier.

91
00:07:58,180 --> 00:08:03,130
Nous allons travailler sur Max ici et je vais définir cette fonction d'abord.

92
00:08:03,160 --> 00:08:20,270
Ainsi, la fonction Max prend un seul tableau à nouveau et la logique ici est que nous allons avoir une variable pour garder une trace du maximum et nous allons juste commencé comme le premier élément par défaut et alors nous allons boucler à travers chaque Autre élément et comparez-le au maximum actuel.

93
00:08:20,840 --> 00:08:25,390
Et si jamais il est plus grand que le maximum actuel, alors cet élément est notre nouveau maximum.

94
00:08:25,550 --> 00:08:27,670
Et puis nous revenons à la fin.

95
00:08:27,880 --> 00:08:41,220
Donc, je vais démarrer var Max égal array 0 et puis je vais boucler le tableau et juste pour le bien de la variété, je vais utiliser une boucle for.

96
00:08:41,270 --> 00:08:43,950
Donc pour var I est égal à zéro.

97
00:08:44,140 --> 00:08:46,060
Et en fait, vous pouvez commencer à 1.

98
00:08:46,610 --> 00:08:51,660
Parce que nous utilisons déjà un ratio pour la même raison, ils peuvent commencer celui-ci à 1.

99
00:08:52,310 --> 00:08:54,940
J'ai donc commencé à 1 4 égale à zéro.

100
00:08:55,060 --> 00:08:59,080
J'ai moins d'un lien radar plus plus.

101
00:08:59,330 --> 00:09:03,260
Et tout ce que je veux faire est de vérifier si tableau de I.

102
00:09:03,250 --> 00:09:12,450
Donc, si l'élément individuel est supérieur au maximum alors Max est maintenant égal à Array.

103
00:09:13,510 --> 00:09:20,030
Donc, cela va constamment changer sa valeur ou potentiellement changer sa valeur si elle rencontre un nouveau maximum.

104
00:09:20,060 --> 00:09:25,110
Donc dans cet exercice ici un deux trois au tout début.

105
00:09:25,220 --> 00:09:26,990
Un est le max.

106
00:09:26,990 --> 00:09:29,610
Et puis nous passons par la boucle et nous la comparons à deux.

107
00:09:29,920 --> 00:09:31,120
Deux est supérieur à un.

108
00:09:31,220 --> 00:09:32,760
Donc deux est le nouveau maximum.

109
00:09:33,010 --> 00:09:35,830
Et puis qui répète trois est plus grand que deux.

110
00:09:35,840 --> 00:09:43,440
Donc, trois est un nouveau maximum et la dernière ligne que nous manquons est une fois la boucle est fait, nous revenons juste Max.

111
00:09:43,750 --> 00:09:45,040
Et ce qui devrait être bon à aller.

112
00:09:45,430 --> 00:09:54,550
Alors essayons ceci rafraîchir et essayons de courir max sur 1 2 3 et nous obtenons trois.

113
00:09:54,620 --> 00:09:59,840
Maintenant, essayons d'ajouter 20 au milieu et nous obtenons 20.

114
00:10:00,290 --> 00:10:03,790
Et enfin, jouons avec un nombre négatif et assurez-vous que cela fonctionne.

115
00:10:03,800 --> 00:10:05,160
Et nous avons encore 20.

116
00:10:05,480 --> 00:10:06,010
D'ACCORD.

117
00:10:06,110 --> 00:10:08,290
Nous avons donc quatre solutions.

118
00:10:08,380 --> 00:10:11,890
Tous ont besoin d'utiliser une boucle que nous avons utilisé pour chacun et certains d'entre eux.

119
00:10:11,890 --> 00:10:14,550
Nous avons utilisé une boucle for et certains d'entre eux et tous.

120
00:10:14,570 --> 00:10:16,410
Nous pratiquons une course.

121
00:10:16,550 --> 00:10:17,050
Impressionnant.