1
00:00:00,750 --> 00:00:08,390
Vale, entonces, vamos a grabar, por tanto si habláis me autorizáis a grabar vuestra voz, ¿vale?

2
00:00:08,449 --> 00:00:14,410
Entonces vamos a hacer un ejercicio que se basa sobre, o sea, que hace un contador de frecuencia de palabras, ¿vale?

3
00:00:14,470 --> 00:00:23,850
Entonces vamos a crear, no, aquí en map, vamos utilizando un map, entonces creamos un nuevo package, contador,

4
00:00:23,850 --> 00:00:43,369
Palabras. Y aquí dentro ponemos nuestro...

5
00:00:43,369 --> 00:00:57,200
Entonces ponemos, no sé, contador, frecuencia, qué sé yo. Contador, frecuencia. Palabras.

6
00:00:57,200 --> 00:00:59,439
Supongo que hacemos directamente un main aquí, ¿no?

7
00:00:59,600 --> 00:01:00,359
Sí, sí.

8
00:01:00,359 --> 00:01:02,359
Porque tampoco...

9
00:01:03,420 --> 00:01:05,060
Bueno, entonces tenemos este main.

10
00:01:05,560 --> 00:01:09,379
Aquí nos dice que vamos a utilizar un hashMap de stringInteger, ¿vale?

11
00:01:09,780 --> 00:01:12,359
No podemos usar un stringInt porque...

12
00:01:18,730 --> 00:01:19,829
Hola, buenos días.

13
00:01:21,069 --> 00:01:21,230
¿Eh?

14
00:01:22,530 --> 00:01:23,769
Porque no es un objeto.

15
00:01:24,170 --> 00:01:25,829
Entonces usamos integer porque...

16
00:01:33,310 --> 00:01:37,310
Porque es exactamente lo que se llama una clase wrap, ¿eh?

17
00:01:37,310 --> 00:01:51,500
Es una clase que engloba, envuelve el tipo primitivo y lo transforma en un objeto.

18
00:01:51,840 --> 00:01:57,859
Además Java es suficientemente listo para que estos intercambios lo hace en automático, digamos así.

19
00:01:58,040 --> 00:02:01,959
Entonces donde puedo poner un integer, puedo poner un integer, donde puedo poner un integer, puedo poner un integer.

20
00:02:02,340 --> 00:02:05,980
Y él asume, hace la conversión automática entre uno y otro.

21
00:02:05,980 --> 00:02:25,219
¿Vale? Entonces esta de aquí será frecuencia, es igual a new ashmap de string integer para acá, ¿vale?

22
00:02:25,219 --> 00:02:33,699
Entonces vamos a usar un ashmap, podemos usar un map a la izquierda, da igual, y ¿qué vamos a hacer?

23
00:02:33,699 --> 00:02:38,500
Vamos a tener una frase, ¿vale?

24
00:02:38,500 --> 00:02:44,800
Vamos a hacer lo siguiente, si os parece bien.

25
00:02:44,800 --> 00:02:50,080
¿Dónde queremos poner nuestras palabras?

26
00:02:50,080 --> 00:02:54,800
¿En un list, en un array, en un set, en un qué?

27
00:02:54,800 --> 00:02:56,500
En un array.

28
00:02:56,500 --> 00:02:59,599
¿Un array? Never, una lista.

29
00:02:59,599 --> 00:03:01,780
Array ya ha pasado, vamos a una lista.

30
00:03:01,780 --> 00:03:17,919
List, string, palabras, o frase, o frase, es igual a new ArrayList de string, ¿vale?

31
00:03:17,919 --> 00:03:24,259
Y vamos a hacer una cosa un poquito distinta, que es la siguiente.

32
00:03:24,259 --> 00:03:31,849
Frase es igual a

33
00:03:31,849 --> 00:03:34,449
frase split

34
00:03:34,449 --> 00:03:37,210
de...

35
00:03:37,210 --> 00:03:42,729
¿Eh?

36
00:03:43,930 --> 00:03:47,250
No, esto no existe.

37
00:03:48,509 --> 00:03:49,830
Esto es un método mío.

38
00:03:50,689 --> 00:03:55,689
Si quisieras usar los splits sobre una string, pues sí.

39
00:03:55,689 --> 00:03:59,270
Pero no estoy usando eso. Estoy creando un método mío.

40
00:03:59,270 --> 00:04:03,710
sustancialmente lo que quiero hacer es lo siguiente

41
00:04:03,710 --> 00:04:24,910
yo creo una lista

42
00:04:24,910 --> 00:04:27,529
de palabras, que será mi frase

43
00:04:27,529 --> 00:04:30,990
de cómo la hago con este método

44
00:04:30,990 --> 00:04:35,329
¿qué hace este método? pues ahora mismo

45
00:04:35,329 --> 00:04:39,889
nada, me pone cinco palabras que yo conozco

46
00:04:39,889 --> 00:04:44,009
y que funcionen, cuando más adelante ya me funcione el programa

47
00:04:44,009 --> 00:04:46,769
entonces me puedo poner aquí y decir

48
00:04:46,769 --> 00:04:48,629
dame una frase

49
00:04:48,629 --> 00:04:50,009
un poquito más

50
00:04:50,009 --> 00:04:52,889
interesante y a partir de esta

51
00:04:52,889 --> 00:04:54,769
frase interesante hago todo

52
00:04:54,769 --> 00:04:57,050
lo que tengo que hacer para crear esta lista

53
00:04:57,050 --> 00:04:58,889
o sea, sustancialmente

54
00:04:58,889 --> 00:05:00,910
me invento que esta parte ya se ha hecho

55
00:05:00,910 --> 00:05:02,470
y la haré después

56
00:05:02,470 --> 00:05:05,149
porque no es esta la parte interesante

57
00:05:05,149 --> 00:05:06,910
esta parte de aquí son ejercicios

58
00:05:06,910 --> 00:05:08,509
que ya hemos hecho al principio del curso

59
00:05:08,509 --> 00:05:10,970
dame una frase y divídela en palabras

60
00:05:10,970 --> 00:05:12,290
pues ya la hemos hecho

61
00:05:12,290 --> 00:05:13,829
entonces esto lo sé hacer

62
00:05:13,829 --> 00:05:19,629
No me limito ahora a hacer esa parte de allí, porque es la parte menos interesante.

63
00:05:19,629 --> 00:05:26,110
El ejercicio es sobre ashmat, entonces ahora hago como que este de aquí me hace la magia

64
00:05:26,110 --> 00:05:31,670
y ya cuando paso de aquí ya tengo lo que me han dado originalmente, el texto, el artículo

65
00:05:31,670 --> 00:05:38,949
y cosas por el estilo, dividido en frases, en palabras que componen una frase, ¿sí?

66
00:05:38,949 --> 00:05:42,850
Luego cómo se hace, pues después, ahora lo ignoro.

67
00:05:42,850 --> 00:05:57,569
Aquí simplemente lo que hago es frase, punto add, y añado unas cuantas palabras, que son

68
00:05:57,569 --> 00:06:31,649
... hola, hola, ¿sí?, entonces, es más, yo luego cuando haré esto, asumo que esta

69
00:06:31,649 --> 00:06:40,310
cosa de aquí me pilla una frase, un artículo, un lo que sea, me lo divide en palabras y

70
00:06:40,370 --> 00:06:44,490
quita los puntos de arriba y de abajo y me lo pone todo en minúscula.

71
00:06:44,490 --> 00:06:45,490
¿Sí?

72
00:06:45,490 --> 00:06:46,490
¿Cómo se hace?

73
00:06:46,490 --> 00:06:51,009
No lo sé, no me interesa, lo hace esto.

74
00:06:51,009 --> 00:06:52,009
Después lo haré.

75
00:06:52,009 --> 00:06:57,990
Entonces, aquí me estoy haciendo un método mock, un método falso, que me da lo que me

76
00:06:57,990 --> 00:06:59,990
tiene que dar.

77
00:06:59,990 --> 00:07:00,990
¿Vale?

78
00:07:00,990 --> 00:07:06,129
Sin puntos, sin cosas raras, solo la palabra y todo en minúscula.

79
00:07:06,129 --> 00:07:07,129
¿Sí?

80
00:07:07,129 --> 00:07:24,750
paso aquí, yo tengo que recordarme que, como se dice, divide la frase en palabras sin puntuación,

81
00:07:24,750 --> 00:07:32,860
todo en minúsculas regulares. Entonces yo paso esta cosa aquí, ahora esta cosa aquí

82
00:07:32,860 --> 00:07:39,180
no la está haciendo, me está creando una frase. Yo me espero que de esta cosa aquí

83
00:07:39,180 --> 00:07:50,519
me debería decir que es sustancialmente gato aparece tres veces o la aparece dos veces y

84
00:07:50,519 --> 00:08:05,160
luego perro una delfina una y no más esto es lo que yo me espero de esta cosa aquí actualmente

85
00:08:05,160 --> 00:08:10,060
Si me dará este resultado mi programa, pues funciona.

86
00:08:10,439 --> 00:08:11,480
Asumo que funcione.

87
00:08:11,480 --> 00:08:20,680
Luego puedo probar con otros ejemplos aquí para ver que funcione con datos, digamos, controlados.

88
00:08:21,420 --> 00:08:25,379
Y a ese punto ya paso a implementar bien este método de aquí.

89
00:08:26,240 --> 00:08:31,860
Teniendo en cuenta que si yo lo trabajara así, pues este método lo podría dar a un grupo de trabajo y este método a otro.

90
00:08:31,860 --> 00:08:35,940
¿Vale? Entonces estoy paralelizando el desarrollo de mi sistema

91
00:08:35,940 --> 00:08:39,899
¿Vale? Let's go

92
00:08:39,899 --> 00:08:42,659
Entonces, asumamos que esto ha hecho la magia

93
00:08:42,659 --> 00:08:45,679
Ahora tengo una lista con todas las palabras que es necesaria

94
00:08:45,679 --> 00:08:48,980
Tengo que empezar a trabajar con este aquí

95
00:08:48,980 --> 00:08:52,379
Tengo que recorrer esta lista, pillar las palabras

96
00:08:52,379 --> 00:08:54,480
Y por cada palabra preguntarme

97
00:08:54,480 --> 00:08:57,320
¿Está aquí dentro? Si está aquí dentro

98
00:08:57,320 --> 00:09:00,580
Voy a pillar cuál es el valor actual

99
00:09:00,580 --> 00:09:01,919
Y sumarle uno

100
00:09:02,860 --> 00:09:07,139
Si en vez de no estar aquí dentro, es una cosa nueva y la pongo en él.

101
00:09:07,779 --> 00:09:13,379
Entonces, lo hacemos de versión easy, versión básica, versión fea.

102
00:09:13,740 --> 00:09:19,399
Pero requiere el menor conocimiento posible para que funcione.

103
00:09:19,539 --> 00:09:23,759
Luego después, a lo mejor vemos si la hacemos un poquito mejor.

104
00:09:24,460 --> 00:09:25,940
Entonces, pillo la primera frase.

105
00:09:25,940 --> 00:09:29,179
Entonces, perdón, por todas las palabras de la frase.

106
00:09:29,179 --> 00:09:40,179
vale entonces iterator de string palabra es igual a frase punto no perdón es un iterator

107
00:09:40,179 --> 00:10:18,720
frase punto iterator no quiere trabajar importe que es ya va útil vale entonces vile it punto

108
00:10:18,720 --> 00:10:19,759
as next

109
00:10:19,759 --> 00:10:24,799
que hago es pillar una palabra

110
00:10:24,799 --> 00:10:27,779
string palabra es igual

111
00:10:27,779 --> 00:10:29,519
a it.next

112
00:10:29,519 --> 00:10:33,179
y en este punto voy a preguntarme

113
00:10:33,179 --> 00:10:35,179
si esta palabra existe o no

114
00:10:35,179 --> 00:10:36,360
si

115
00:10:36,360 --> 00:10:40,899
how se llama

116
00:10:40,899 --> 00:10:42,740
frecuencia

117
00:10:42,740 --> 00:10:45,379
frecuencia.contains

118
00:10:46,700 --> 00:10:48,340
key

119
00:10:48,340 --> 00:10:51,980
palabra

120
00:10:51,980 --> 00:10:56,450
los dos casos, ¿vale?

121
00:10:56,590 --> 00:10:57,909
la palabra ya existe

122
00:10:57,909 --> 00:11:00,529
la palabra no existe

123
00:11:00,529 --> 00:11:02,230
este es el caso fácil

124
00:11:02,230 --> 00:11:05,169
la palabra no existe, la he buscado entre las claves

125
00:11:05,169 --> 00:11:06,250
y la palabra no está

126
00:11:06,250 --> 00:11:09,409
por lo tanto, frecuencia

127
00:11:09,409 --> 00:11:11,330
punto put

128
00:11:11,330 --> 00:11:12,730
palabra

129
00:11:12,730 --> 00:11:14,889
uno

130
00:11:14,889 --> 00:11:17,509
m1 es un

131
00:11:17,509 --> 00:11:19,070
íntegro, yo quiero un íntegro

132
00:11:19,070 --> 00:11:19,629
¿vale?

133
00:11:20,669 --> 00:11:24,669
new integer de 1.

134
00:11:24,669 --> 00:11:27,669
Y ahora te dice, pero ¿qué estás haciendo?

135
00:11:27,669 --> 00:11:30,669
El constructor integer de int es deprecado.

136
00:11:30,669 --> 00:11:34,669
Pues no lo hay, está adentro.

137
00:11:34,669 --> 00:11:35,669
¿Sí?

138
00:11:35,669 --> 00:11:39,669
Ahora, aquí en vez quiere decir que ya existe.

139
00:11:39,669 --> 00:11:40,669
Entonces, ¿qué hago?

140
00:11:40,669 --> 00:11:54,570
Pues primero le digo int f es igual a frecuencia.getPalabra.

141
00:11:54,710 --> 00:12:02,919
Con esto usa la clave palabra para encontrar su correspondiente valor, que es un integer.

142
00:12:03,220 --> 00:12:04,519
Entonces me lo puede guardar un int.

143
00:12:05,000 --> 00:12:05,639
Ya lo tengo.

144
00:12:06,179 --> 00:12:07,700
Como ya existía, ya lo tengo.

145
00:12:07,700 --> 00:12:10,059
Que ya se había visto tres veces, me habrá dado tres.

146
00:12:10,059 --> 00:12:18,100
que ya se ha visto 57 veces, me ha dado 57. Hago f++, porque ahora se ha visto una vez más,

147
00:12:18,700 --> 00:12:31,059
y lo vuelvo a poner. Frecuencia, punto put, palabra, f. Cuando yo pongo put sobre algo que ya existe,

148
00:12:31,559 --> 00:12:41,159
me sobrescribe el valor anterior. Por lo tanto, en este caso, lo que hace es que si había aquí dentro

149
00:12:41,820 --> 00:12:48,700
que la palabra gato eran tres veces, ha leído un otro gato, ahora lee tres, pone cuatro y le pone

150
00:12:48,700 --> 00:12:55,620
gato cuatro. Entonces ahora dentro de mi sistema está gato asociado con el intercuarto. Y ya está.

151
00:12:55,620 --> 00:13:15,450
Una vez que ha hecho esto, no sé, vamos a ver si se hizo, frecuencia. Una maravilla.

152
00:13:15,450 --> 00:13:45,159
Ahora, que queremos complicarlo un poco, que queremos decir, mira, pero esto pónmela ordenadas alfabéticamente, ordenada por número, se puede hacer.

153
00:13:46,100 --> 00:13:47,659
Puedes hacer todo lo que queráis.

154
00:13:47,659 --> 00:13:51,700
Probamos a completar esto

155
00:13:51,700 --> 00:13:53,720
Yo os he dicho, usad frases

156
00:13:53,720 --> 00:13:55,860
Inglesas, porque así quitamos

157
00:13:55,860 --> 00:13:57,759
Del medio los acentos

158
00:13:57,759 --> 00:13:59,860
Las señas y cosas así que son más complejas

159
00:13:59,860 --> 00:14:01,460
De trabajar

160
00:14:01,460 --> 00:14:05,320
¿Vale? Vamos a ver cómo lo hacemos

161
00:14:05,320 --> 00:14:05,980
¿Vale?

162
00:14:06,340 --> 00:14:09,860
Ahora, asumamos que no es así

163
00:14:09,860 --> 00:14:11,679
Sino que me han dado

164
00:14:11,679 --> 00:14:13,740
Una cadena

165
00:14:13,740 --> 00:14:14,460
¿Vale?

166
00:14:14,879 --> 00:14:16,860
Y mi cadena será

167
00:14:16,860 --> 00:14:24,039
hola, gato, gato, perro, gato.

168
00:14:25,620 --> 00:14:26,600
¿Sí? Fácil.

169
00:14:27,279 --> 00:14:29,279
Por lo tanto, vamos a arreglar esta de aquí.

170
00:14:29,779 --> 00:14:30,779
Entonces, ¿cómo lo hago?

171
00:14:31,200 --> 00:14:34,340
Pues pillo la string que me han dado,

172
00:14:34,340 --> 00:14:40,980
digo que string array splitted

173
00:14:40,980 --> 00:15:02,309
es igual a string.split de espacio. Y luego, había una forma, raise.toList.

174
00:15:02,309 --> 00:15:19,659
lo hago antes. string es igual a string.toLowerCase. Ahí, ya está, todo mismo. Y ahora lo que

175
00:15:19,659 --> 00:15:27,980
quiero hacer es frase punto a doble de a raíz punto

176
00:15:27,980 --> 00:15:38,789
no me acuerdo

177
00:15:38,789 --> 00:15:59,700
había una forma para transformar

178
00:15:59,700 --> 00:16:01,399
esto directamente en una

179
00:16:01,399 --> 00:16:03,559
es una cosa

180
00:16:03,559 --> 00:16:05,539
así no lo pilla

181
00:16:05,539 --> 00:16:10,940
esto no le gusta, hay que transformar esto

182
00:16:10,940 --> 00:16:11,879
en una colección

183
00:16:11,879 --> 00:16:14,120
y no me acuerdo si estaba

184
00:16:14,120 --> 00:16:16,480
collections punto

185
00:16:16,480 --> 00:16:24,509
hay un método que te pilla directamente

186
00:16:24,509 --> 00:16:28,679
un array

187
00:16:28,679 --> 00:16:30,879
y te lo transforma

188
00:16:30,879 --> 00:16:31,299
en una

189
00:16:31,299 --> 00:16:34,080
en una lista

190
00:16:34,080 --> 00:16:35,659
pero no me acuerdo como sea

191
00:16:35,659 --> 00:16:42,330
list enumeration

192
00:16:42,330 --> 00:16:48,450
no me acuerdo

193
00:16:48,450 --> 00:16:50,529
array.list

194
00:16:50,529 --> 00:17:08,160
Entonces, esto me lo transformo en una lista, lo añado aquí, de hecho, podría ser que

195
00:17:08,160 --> 00:17:29,930
devuelve esto, de acuerdo, Arrays.asList, que devuelve, devuelve una, no leo, devuelve

196
00:17:29,930 --> 00:17:45,210
entonces podría hacer directamente esto no

197
00:17:50,599 --> 00:17:54,170
bueno una maravilla

198
00:17:58,779 --> 00:18:07,220
vamos a ver si nuestro programa funciona click maravilla de una fenómena ahora el problema es

199
00:18:07,220 --> 00:18:16,660
es que esta no es una frase real, porque no tiene comas, puntos y cosas por el estilo.

200
00:18:16,660 --> 00:18:28,200
Entonces una frase real sería más como, me gustan mucho los gatos, porque de hecho

201
00:18:28,200 --> 00:18:51,609
Los gatos son maravillosos, maravillosos, viva los gatos, entonces punto, son tres espacios.

202
00:18:51,609 --> 00:19:03,029
Entonces ahora cuando yo hago esto, me salen cosas raras, entonces lo divide, ofreciendo

203
00:19:03,029 --> 00:19:10,289
espacios pero ahora tengo que comprobar si al final de mi palabra están o no estas cosas aquí

204
00:19:10,289 --> 00:19:22,230
vale entonces como lo hago me han separado por espacios entonces por cada palabra tengo que

205
00:19:22,230 --> 00:19:42,339
hacer como un... Limpiarla. Entonces for string s dos puntos cliptender. Entonces pillo ese y lo

206
00:19:42,339 --> 00:19:52,240
que hago es ese punto trim, le quito espacios a la derecha y a la izquierda. Tiene muchos espacios,

207
00:19:52,240 --> 00:19:58,480
pues se lo quito, ¿vale? No creo que sea necesario porque como he utilizado esto, pues a lo mejor no lo hago, ¿vale?

208
00:19:58,480 --> 00:20:08,180
Luego, voy a mirar... En teoría los signos podrían estar delante y detrás. ¿Hay signos delante? Sí,

209
00:20:08,180 --> 00:20:16,779
porque, claro, en español, en inglés no, ¿no? A comillas a lo mejor, sí, a comillas podría ir. Entonces quito

210
00:20:16,779 --> 00:20:20,980
cosas que no sean letras ni a la izquierda ni a la derecha. He puesto todo lo del case, entonces aquí

211
00:20:20,980 --> 00:20:24,299
solo hay letras minúsculas, me interesan solo letras minúsculas, ¿vale?

212
00:20:24,880 --> 00:20:29,380
Entonces, por ejemplo, quito la parte

213
00:20:29,380 --> 00:20:33,220
la primera parte, ¿vale? Entonces digo

214
00:20:33,220 --> 00:20:40,940
char c es igual

215
00:20:40,940 --> 00:20:44,819
a ese punto char

216
00:20:44,819 --> 00:20:54,769
0. Cuile c

217
00:20:54,769 --> 00:20:59,289
mayor que

218
00:20:59,289 --> 00:20:59,829
a

219
00:20:59,829 --> 00:21:02,609
y c

220
00:21:02,609 --> 00:21:04,809
menor que c,

221
00:21:04,950 --> 00:21:06,950
está en minúsculos, ¿eh? Ah, esto lo haría así.

222
00:21:06,950 --> 00:21:09,069
Y que

223
00:21:09,069 --> 00:21:09,529
paga.

224
00:21:12,089 --> 00:21:12,730
Mientras

225
00:21:12,730 --> 00:21:15,130
no sea esta cosa aquí,

226
00:21:17,740 --> 00:21:18,980
mientras no sea

227
00:21:18,980 --> 00:21:20,880
una letra, yo he empezado desde el principio,

228
00:21:21,079 --> 00:21:23,019
¿vale? Y mientras no sea una letra

229
00:21:23,019 --> 00:21:25,279
lo que tengo que hacer es eliminar ese carácter.

230
00:21:25,900 --> 00:21:26,700
¿Vale? Entonces

231
00:21:26,700 --> 00:21:28,640
s es igual

232
00:21:28,640 --> 00:21:30,819
a

233
00:21:30,819 --> 00:21:58,660
ese punto, esto era substring, substring de 1. Esto lo voy a hacer, porque yo leo, no es una letra,

234
00:21:58,660 --> 00:22:07,480
Pues entonces, transformo S en su substring, o sea, en una subcadena que empieza desde la primera posición.

235
00:22:07,859 --> 00:22:09,119
Sostantialmente, quito la primera.

236
00:22:11,500 --> 00:22:11,880
¿Entiendes?

237
00:22:12,299 --> 00:22:13,380
Y lo vuelvo a hacer.

238
00:22:14,480 --> 00:22:16,240
Ahora es una letra, he acabado.

239
00:22:16,359 --> 00:22:17,920
Ahora es otro signo de interpulsión.

240
00:22:19,500 --> 00:22:20,980
Siguiría adelante, adelante, adelante.

241
00:22:22,059 --> 00:22:27,359
Este de aquí iría quitando todos los símbolos raros antes de la primera letra.

242
00:22:28,200 --> 00:22:28,680
¿Sí?

243
00:22:28,680 --> 00:22:34,019
Ok, he limpiado la parte izquierda

244
00:22:34,019 --> 00:22:36,000
Ahora intento limpiar la parte derecha

245
00:22:36,000 --> 00:22:38,259
Lo mismo, pero desde derecha hasta izquierda

246
00:22:38,259 --> 00:22:39,559
O sea, pillo el último

247
00:22:39,559 --> 00:22:42,279
P es igual

248
00:22:42,279 --> 00:22:45,099
A S.charact

249
00:22:45,099 --> 00:22:46,140
De

250
00:22:46,140 --> 00:22:47,819
S.length

251
00:22:47,819 --> 00:22:50,039
Menos uno

252
00:22:50,039 --> 00:22:55,680
El último carácter

253
00:22:55,680 --> 00:22:56,440
¿Vale?

254
00:22:56,920 --> 00:23:00,200
Y digo que mientras este carácter

255
00:23:00,200 --> 00:23:00,960
No sea

256
00:23:00,960 --> 00:23:02,440
Una

257
00:23:02,440 --> 00:23:05,200
una letra

258
00:23:05,200 --> 00:23:07,940
pues lo que hago es

259
00:23:07,940 --> 00:23:10,299
quitar la última

260
00:23:10,299 --> 00:23:12,319
o sea, su string

261
00:23:12,319 --> 00:23:13,680
desde el principio

262
00:23:13,680 --> 00:23:15,079
hasta

263
00:23:15,079 --> 00:23:18,369
esto

264
00:23:18,369 --> 00:23:27,640
ahora, con un poco de suerte

265
00:23:27,640 --> 00:23:28,339
esto funciona

266
00:23:28,339 --> 00:23:31,279
hay que ver por qué string

267
00:23:31,279 --> 00:23:32,539
siempre es especial

268
00:23:32,539 --> 00:23:35,619
si esta cosa de aquí me lo hace bien

269
00:23:35,619 --> 00:23:35,900
o no

270
00:23:35,900 --> 00:23:39,200
porque si con esto lo hago por valor

271
00:23:39,200 --> 00:23:41,299
no funcionará, si esto lo hace por referencia

272
00:23:41,299 --> 00:23:41,940
si funciona

273
00:23:41,940 --> 00:23:45,039
entonces vamos a ver

274
00:23:45,039 --> 00:23:46,319
si lo hace

275
00:23:46,319 --> 00:23:49,420
boom, explose

276
00:23:49,420 --> 00:23:51,480
ancho 0

277
00:23:51,480 --> 00:23:53,059
menos 1, out of bound

278
00:23:53,059 --> 00:23:54,319
for length 0

279
00:23:54,319 --> 00:23:59,680
vale, aquí

280
00:23:59,680 --> 00:24:02,000
he intentado poner un

281
00:24:02,000 --> 00:24:04,140
menos 1 aquí, porque me ha

282
00:24:04,140 --> 00:24:06,319
dado una cadena

283
00:24:06,319 --> 00:24:07,839
que es larga 0

284
00:24:07,839 --> 00:24:09,480
entonces esto lo

285
00:24:09,480 --> 00:24:12,119
hacemos, siempre

286
00:24:12,119 --> 00:24:28,519
de cuando S tiene algo, pero hay algo, vamos a ver por qué lo hace, entonces aquí le

287
00:24:28,519 --> 00:24:41,559
hacemos escribir schizo proceso dos puntos S, y luego después de este while veo que

288
00:24:41,559 --> 00:24:56,440
quedado en S, limpio izquierda y después de esto limpio derecho. Vamos a ver donde explota.

289
00:24:56,440 --> 00:25:15,549
¡Ah! Vale. Me ha ido bien. Gusto ha ido bien. La primera vez que encuentra gatos empieza a

290
00:25:15,549 --> 00:25:21,650
limpiar a la izquierda y lo hace bien, pero cuando limpia a la derecha explota. ¿Por qué?

291
00:25:21,650 --> 00:25:44,509
¿Por qué va de cero a ese punto lento y menos uno?

292
00:25:44,509 --> 00:25:54,140
Porque se enfada porque intenta acceder...

293
00:25:54,140 --> 00:25:59,140
¿Por qué? Porque la S es de lente cero.

294
00:25:59,140 --> 00:26:12,599
Pero S no es de lente cero.

295
00:26:12,599 --> 00:26:15,599
Que cuando lo escribe aquí, S es esto.

296
00:26:15,599 --> 00:26:18,599
Entonces, debería estar bien.

297
00:26:18,599 --> 00:26:27,599
cuando entra de aquí ese punto substring desde cero hasta la última que no pilla.

298
00:26:27,599 --> 00:26:35,599
Este debería ser este, pero como si esta cosa de aquí me estuviera dando cero, en vez no debería ser cero.

299
00:26:35,599 --> 00:26:46,420
y eso es el punto l

300
00:26:47,140 --> 00:27:07,240
porque aquí me da menos 1 y 0

301
00:27:10,000 --> 00:27:15,460
porque no cambio C aquí dentro entonces

302
00:27:15,460 --> 00:27:21,359
y ya el punto empieza a ir a ir y nunca cambia el C. Esto lo tengo que volver a

303
00:27:21,359 --> 00:27:31,890
hacer cada vez que hago esto. Y lo mismo aquí, porque lo quito, pero ahora tengo que actualizar

304
00:27:31,890 --> 00:27:43,640
el carácter, que en este caso sería este. Ahora sí. ¿No entendéis? No. Si yo pillo,

305
00:27:43,640 --> 00:27:49,500
si está así, aquí dentro el carácter no cambia nada, nunca. C no cambia nunca. Entonces,

306
00:27:49,500 --> 00:27:55,619
aquí detectó que el último es un punto me dice aquí está el último pero no es cambiado entonces

307
00:27:55,619 --> 00:28:00,279
sigue siendo un punto entonces me dice también quita el último y vuelve aquí dice es un punto

308
00:28:00,279 --> 00:28:06,220
quita el último es un punto quita el último es exactamente me destruye todo si yo lo hago así

309
00:28:06,220 --> 00:28:16,480
mira se escriba ese no me va a devolver todas las combinaciones de es y ya datos puntos quita

310
00:28:16,480 --> 00:28:21,140
el punto pero como no he actualizado el carácter ahora cree que este es el punto entonces me quita

311
00:28:21,140 --> 00:28:23,359
este es el punto, me lo quita

312
00:28:23,359 --> 00:28:24,420
este es el punto, me lo quita

313
00:28:24,420 --> 00:28:26,720
hasta llegar a vacío

314
00:28:26,720 --> 00:28:28,900
y cuando hace vacío y le quita el punto

315
00:28:28,900 --> 00:28:30,099
al menos uno explota

316
00:28:30,099 --> 00:28:33,539
¿vale? sustancialmente he hecho un bucle infinito

317
00:28:33,539 --> 00:28:35,160
porque

318
00:28:35,160 --> 00:28:36,359
no actualizo

319
00:28:36,359 --> 00:28:38,420
no actualizo

320
00:28:38,420 --> 00:28:40,500
cuánto vale C aquí dentro

321
00:28:40,500 --> 00:28:42,180
y como mi condición es sobre C

322
00:28:42,180 --> 00:28:44,660
si entra allí dentro no saldrá nunca

323
00:28:44,660 --> 00:28:47,039
siempre que yo aquí hago una condición

324
00:28:47,039 --> 00:28:48,579
sobre una cierta

325
00:28:48,579 --> 00:28:50,920
variable

326
00:28:50,920 --> 00:28:53,440
esta variable tiene que cambiar aquí dentro

327
00:28:53,440 --> 00:28:55,240
porque si no cambia nunca

328
00:28:55,240 --> 00:28:57,480
entro en el while, me quedaré en el while

329
00:28:57,480 --> 00:28:59,539
al infinito o no entro

330
00:28:59,539 --> 00:29:00,700
en el while y no entraré nunca

331
00:29:00,700 --> 00:29:03,440
¿Me explico? Entonces aquí hay que

332
00:29:03,440 --> 00:29:05,440
decirle, vale, ok, si lo que

333
00:29:05,440 --> 00:29:07,220
has encontrado no es una letra

334
00:29:07,220 --> 00:29:09,240
quítala y ahora

335
00:29:09,240 --> 00:29:11,480
actualiza de cuál es el último carácter

336
00:29:11,480 --> 00:29:13,700
es decir, vuelve a escribir esto

337
00:29:13,700 --> 00:29:15,339
actualiza

338
00:29:15,339 --> 00:29:17,180
cuál es el último carácter

339
00:29:17,180 --> 00:29:19,259
ahora el último carácter

340
00:29:19,259 --> 00:29:27,240
podría ser otra vez un punto o podría ser una O. Si es una O, has acabado el byte. ¿Se entiende?

341
00:29:27,240 --> 00:29:44,289
Ahora funciona perfectamente. Medianamente funciona perfectamente. Sigue habiendo cosas raras.

342
00:29:45,630 --> 00:29:53,130
En principio lo procesa bien. Pero no lo está actualizando del otro lado.

343
00:29:53,130 --> 00:30:06,130
No, porque es siempre la última. Se actualiza solo por la S.

344
00:30:06,130 --> 00:30:15,130
Básicamente lo que se hace con ese método es coger las palabras y dividirlas de derecha a izquierda.

345
00:30:15,130 --> 00:30:20,130
O sea, primero por la derecha y luego por la izquierda, dejando solo la palabra y dando puntos y tal.

346
00:30:20,130 --> 00:30:29,130
El trim es una cosa que lo hace para quitar espacios a la derecha o a la izquierda.

347
00:30:29,130 --> 00:30:35,130
Si lo que me ha pillado es espacios, espacios, espacios, espacios, gato, espacios, espacios, espacios, me deja gato.

348
00:30:35,130 --> 00:30:43,470
Quita los espacios a la derecha o a la izquierda.

349
00:30:43,470 --> 00:30:47,470
No debería pasar, porque si tengo espacios, espacios, espacios, me debería dar como 3 palabras.

350
00:30:47,470 --> 00:31:00,269
Ahora, aquí está pasando una cosa rarita, que es uno de los problemas de trabajar con string.

351
00:31:00,970 --> 00:31:03,869
Si os fijáis, yo tengo una red de string.

352
00:31:05,509 --> 00:31:14,170
Entonces, con esto estoy accediendo a cada uno de los string, a los objetos string, y lo modifico.

353
00:31:14,170 --> 00:31:17,769
entonces técnicamente debería modificar ese objeto

354
00:31:17,769 --> 00:31:19,269
y en splitted

355
00:31:19,269 --> 00:31:23,130
ahora debería haber todos los objetos modificados

356
00:31:23,130 --> 00:31:27,349
sin embargo si os fijáis al final yo devuelvo splitted

357
00:31:27,349 --> 00:31:29,589
y lo que llega aquí

358
00:31:29,589 --> 00:31:40,089
debería ser el splitted con todas las palabras limpiado

359
00:31:40,089 --> 00:31:43,450
sin embargo no ha limpiado nada

360
00:31:43,450 --> 00:31:53,839
Y esto es porque string es un medio objeto, es entre objeto y no objeto.

361
00:31:54,140 --> 00:31:59,599
Yo creo que hace, si esto fueran alumnos y yo hubiese hecho modificaciones en alumnos, lo habría hecho.

362
00:32:00,720 --> 00:32:06,000
Pero como string, a veces string se pasa como referencia y a veces se pasa por valor.

363
00:32:06,000 --> 00:32:17,829
Y aquí probablemente cuando hace esta cosa de aquí, no está pillando la referencia desde dentro del objeto diciendo es este de aquí.

364
00:32:17,930 --> 00:32:21,930
me ha estado haciendo una copia y entonces cuando yo la modifico aquí,

365
00:32:21,950 --> 00:32:28,960
porque la estoy modificando sobre S, no se modifica en Splitted.

366
00:32:28,980 --> 00:32:31,160
Y cuando devuelvo Splitted, Splitted es igual.

367
00:32:31,180 --> 00:32:34,539
Si yo aquí lo pongo, si hizo

368
00:32:34,579 --> 00:32:44,589
Arrays.DrawString Splitted, veréis que es

369
00:32:44,609 --> 00:32:47,230
como al principio.

370
00:32:47,250 --> 00:32:52,579
Veis, no ha hecho la limpia.

371
00:32:52,579 --> 00:32:56,599
lo ha hecho sobre como una copia que es una cosa extraña es la razón de cuando

372
00:32:56,599 --> 00:33:03,240
hacéis vosotros ejemplos o pruebas sobre objetos no uséis string como prueba de

373
00:33:03,240 --> 00:33:07,339
objeto porque string se porta como le da la gana

374
00:33:07,339 --> 00:33:16,359
string es un objeto es un semi objeto entonces como lo solucionó pues que esto

375
00:33:16,359 --> 00:33:36,769
no me vale, creo otro string limpiado igual a new string de splitted.length, un array

376
00:33:36,769 --> 00:33:52,019
del mismo tamaño, vale, y a este punto me compensa hacerlo como int i es igual a cero

377
00:33:52,019 --> 00:34:05,400
i menor que splitted punto length i más más, es decir que string s es igual a splitted

378
00:34:05,400 --> 00:34:14,619
de ahí y cuando lo he limpiado, taca taca taca taca taca taca, aquí añado al limpiado

379
00:34:15,980 --> 00:34:34,179
d y ss y al final no devuelvo splitter, más devuelvo limpiado. Esto en vez que con arrays

380
00:34:34,179 --> 00:34:37,239
con listas

381
00:34:37,239 --> 00:34:38,039
de alguna forma

382
00:34:38,039 --> 00:34:39,659
entonces ahora

383
00:34:39,659 --> 00:34:45,429
ha encontrado

384
00:34:45,429 --> 00:34:47,190
tres gatos, no obstante

385
00:34:47,190 --> 00:34:48,949
la frase original

386
00:34:48,949 --> 00:34:50,730
tenga gatos raros

387
00:34:50,730 --> 00:34:52,130
tiene gatos punto

388
00:34:52,130 --> 00:34:54,369
tiene gatos

389
00:34:54,369 --> 00:34:56,650
con tres excavaciones

390
00:34:56,650 --> 00:34:59,670
vale

391
00:34:59,670 --> 00:35:02,630
ahora, yo con esto

392
00:35:02,630 --> 00:35:04,469
suficiente para mi

393
00:35:04,469 --> 00:35:06,730
vale, estaba trabajando un poquito

394
00:35:06,730 --> 00:35:13,929
Entonces, seguro que si os ponéis allí, hay algunas combinaciones de cosas raras que no funcionan, ¿vale?

395
00:35:14,150 --> 00:35:20,440
Si yo, por ejemplo, pongo esto, ya no me funciona, ¿sí?

396
00:35:20,860 --> 00:35:24,420
Porque no pilla esto como dos palabras.

397
00:35:24,760 --> 00:35:28,500
Para él, una palabra es esta, una palabra es esta, pues esta es una palabra única.

398
00:35:29,579 --> 00:35:37,340
¿Sí? Entonces, debería meterme letra por letra a encontrar si tiene un espacio o cosa por el estilo,

399
00:35:37,340 --> 00:35:48,199
o hacer una regex, una expresión regular más compleja de esta y decirle si es espacio,

400
00:35:48,199 --> 00:35:57,019
si es punto, si es coma, si es lo que quiera, pues considerarlo como uno nuevo. Pero si quiero hacer

401
00:35:57,019 --> 00:36:02,659
esto, pues busco esto sí, para estas cosas de aquí, una vez que lo he entendido, pues me voy

402
00:36:02,659 --> 00:36:07,719
a la inteligencia artificial y le digo, oye, hazme un programita, que lo que hace es que te doy una

403
00:36:07,719 --> 00:36:14,380
frase y él me separa las palabras, teniendo en cuenta que pueden haber puntos, y eso trabaja

404
00:36:14,380 --> 00:36:25,829
bien. Y más o menos. ¿Más dudas?

405
00:36:25,829 --> 00:36:54,880
Podríamos seguir con, vale, cuando me lo escribe lo quiero ordenado por algún tipo,

406
00:36:54,880 --> 00:37:06,079
Entonces, cuando lo escriba aquí, lo quiero ordenado por palabra.

407
00:37:06,079 --> 00:37:11,480
Si lo quiero por palabra, una opción relativamente fácil podría ser esta, creo.

408
00:37:11,480 --> 00:37:37,369
Me gato, gustan, echo, los maravillosos, me mucho, son, vivan.

409
00:37:37,369 --> 00:37:39,869
Perfecto, ¿vale?

410
00:37:39,869 --> 00:37:41,949
¿Por qué? Porque estoy aprovechando

411
00:37:41,949 --> 00:37:43,909
de que el stream map

412
00:37:43,909 --> 00:37:46,010
ordena las cosas

413
00:37:46,010 --> 00:37:47,570
dentro por su clave.

414
00:37:48,110 --> 00:37:49,289
La clave es un string.

415
00:37:49,550 --> 00:37:52,349
Los strings vienen ordenados alfabéticamente.

416
00:37:52,989 --> 00:37:53,510
Pues, que no da.

417
00:37:57,409 --> 00:37:59,150
Si quisiera por

418
00:37:59,150 --> 00:38:01,170
esto,

419
00:38:01,909 --> 00:38:04,070
a lo mejor la cosa sería un poquito más compleja.

420
00:38:11,900 --> 00:38:12,719
Voy a ver mi hash map

421
00:38:12,719 --> 00:38:13,840
porque es más rápido.

422
00:38:16,449 --> 00:38:18,429
Entonces, una vez que he obtenido

423
00:38:18,429 --> 00:38:36,440
esto, esto sería un ordenado, entonces ahora pillo set, reset, set, vamos a decir, sí,

424
00:38:36,440 --> 00:39:10,659
Preset de integer ord es igual a new preset de frecuencia.get, no, .values, que no es la key, son los valores.

425
00:39:11,239 --> 00:39:12,239
Ah, sí, perdón.

426
00:39:12,239 --> 00:39:14,239
¿Vale?

427
00:39:14,239 --> 00:39:16,239
Que, pero, no me permite.

428
00:39:16,239 --> 00:39:18,239
No es...

429
00:39:18,239 --> 00:39:24,179
Ah, venga.

430
00:39:24,179 --> 00:39:26,179
Reset lo importo...

431
00:39:26,179 --> 00:39:28,179
¡Ay!

432
00:39:28,179 --> 00:39:30,179
Entonces, con esto

433
00:39:30,179 --> 00:39:32,179
me ha creado un

434
00:39:32,179 --> 00:39:34,179
conjunto de valores...

435
00:39:34,179 --> 00:39:36,179
Me he equivocado.

436
00:39:36,179 --> 00:39:39,739
Si lo hago así...

437
00:39:39,739 --> 00:39:43,889
¡Ah! ¡Uf!

438
00:39:43,889 --> 00:39:45,889
Porque...

439
00:39:45,889 --> 00:39:47,889
Sí, no me interesa.

440
00:39:47,889 --> 00:39:50,130
no puede estar

441
00:39:50,130 --> 00:39:52,289
tened en cuenta que el triset

442
00:39:52,289 --> 00:39:55,150
no me permite duplicados

443
00:39:55,150 --> 00:39:57,190
entonces si hay gato que aparece

444
00:39:57,190 --> 00:39:59,110
tres veces y cocodrilo que aparece

445
00:39:59,110 --> 00:40:01,010
tres veces, pongo una sola vez

446
00:40:01,010 --> 00:40:01,489
tres

447
00:40:01,489 --> 00:40:05,150
pero no me vale, porque yo simplemente lo que intentaré

448
00:40:05,150 --> 00:40:06,909
hacer es pillar la frecuencia

449
00:40:06,909 --> 00:40:09,449
menor e ir a recorrerme

450
00:40:09,449 --> 00:40:10,730
todo el map

451
00:40:10,730 --> 00:40:13,150
a la búsqueda de esa frecuencia allí

452
00:40:13,150 --> 00:40:14,789
si aparece tres veces, tres veces

453
00:40:14,789 --> 00:40:16,889
y pondré las palabras

454
00:40:16,889 --> 00:40:23,369
Pones ahí. Luego empezaré otra vez. Vale, ahora pillo la segunda frecuencia. Es nueve. Vale,

455
00:40:23,369 --> 00:40:36,630
voy a buscar toda la que... ¿Entiendes? La frecuencia, si lo hago así, iría de menor a mayor.

456
00:40:38,630 --> 00:40:45,710
Desde menores... desde frecuencia menor a frecuencia mayor. Si lo quiero hacer al revés,

457
00:40:45,710 --> 00:41:08,769
No sé si el org.getlast... Sí, lo tengo. Tengo getlast, por lo tanto puedo trabajar con getlast.

458
00:41:08,769 --> 00:41:42,489
Vale, entonces, will.org.cj mayor que cero, lo que hago es pillar int frecuencia actual es igual a org.getLast, ¿sí?

459
00:41:42,489 --> 00:41:49,849
Y ahora, con esta frecuencia actual, tengo que recorrerme toda la red y preguntar cada una de las keys.

460
00:41:50,309 --> 00:42:00,969
Y si tengo esto como frecuencia, pues entonces la añado a lo que tengo que escribir.

461
00:42:00,969 --> 00:42:02,989
Tengo que escribirse a una lista.

462
00:42:14,650 --> 00:42:21,269
Lista de string ordenados.

463
00:42:23,210 --> 00:42:34,170
por frecuencia es igual a new ArrayList de Spring, tiquetito, ¿vale?

464
00:42:34,429 --> 00:42:36,789
Entonces, tengo la frecuencia actual que estoy buscando.

465
00:42:37,250 --> 00:42:40,250
Voy a recorrerme el array entero.

466
00:42:40,250 --> 00:43:08,489
Entonces, iterator.it de string it es igual a frecuencia.get, no, .kset.iterator.

467
00:43:08,489 --> 00:43:11,409
¿Sí?

468
00:43:13,230 --> 00:43:13,949
Will

469
00:43:13,949 --> 00:43:16,010
it.next

470
00:43:16,010 --> 00:43:26,210
int

471
00:43:26,210 --> 00:43:29,809
comprobar

472
00:43:29,809 --> 00:43:31,730
es igual

473
00:43:31,730 --> 00:43:33,449
a it.

474
00:43:33,449 --> 00:43:33,849
punto

475
00:43:33,849 --> 00:43:36,849
a frecuencia

476
00:43:36,849 --> 00:43:43,420
necesito los string

477
00:43:43,420 --> 00:43:45,039
string

478
00:43:45,039 --> 00:43:47,099
comprobar

479
00:43:47,099 --> 00:43:49,019
es igual a

480
00:43:49,019 --> 00:43:50,460
y t.next

481
00:43:50,460 --> 00:43:52,679
si

482
00:43:52,679 --> 00:44:00,280
frecuencia

483
00:44:00,280 --> 00:44:02,400
.get

484
00:44:02,400 --> 00:44:03,579
comp

485
00:44:03,579 --> 00:44:05,500
es igual

486
00:44:05,500 --> 00:44:07,260
a frecat

487
00:44:07,260 --> 00:44:11,960
entonces la palabra que estoy

488
00:44:11,960 --> 00:44:14,199
mirando ahora tiene como frecuencia

489
00:44:14,199 --> 00:44:15,940
exactamente la que estoy buscando

490
00:44:15,940 --> 00:44:17,900
por lo tanto lo añado a la lista

491
00:44:17,900 --> 00:44:19,960
que mi lista era

492
00:44:19,960 --> 00:44:22,420
ordenados

493
00:44:22,420 --> 00:44:42,630
por freq. Ordenados por freq.add y añado la palabra con dos puntos, con freq.add.

494
00:44:42,630 --> 00:44:47,730
Se puede optimizar, sí, se puede hacer cosas raras. Lo que queda es el parámetro it. Este

495
00:44:47,730 --> 00:44:57,969
es it2. It2, it2, it2. Se podría mejorar la... porque esto está buscando siempre todo

496
00:44:57,969 --> 00:45:02,090
las mapas siempre todo las mapas siempre todas las mapas hasta hasta frecuencias que ya ha

497
00:45:02,090 --> 00:45:08,789
encontrado pero no quiero machacar el quiero destruir el asma si quiero cuando lo encuentro

498
00:45:08,789 --> 00:45:15,369
destruyó de nuevo esa par esa es entrada en toda la siguiente vez eso no lo contará porque estará

499
00:45:15,369 --> 00:45:24,690
más para más pequeño ahora lo que sí voy quitando es desde esto justo porque esos son los valores

500
00:45:24,690 --> 00:45:57,309
Entonces, yo pillo la primera y la elimino. Bueno, no. Sí, porque le he puesto esto. Entonces, lo que hago aquí, ahora será, una vez que he hecho esto de aquí, he pillado todas las frecuencias, elimino la última.

501
00:45:57,309 --> 00:46:29,820
a menos que no me la haya quitado, esperad, y el last lo remuevo, no, no vale, entonces ahora lo remuevo, remove, remove, entonces esto me va destruyendo org, vale, de organizar un ordenador, que es esto,

502
00:46:29,820 --> 00:46:39,880
Son todos los valores, entonces me va pillando siempre el último, me pilla el último, hace

503
00:46:39,880 --> 00:46:43,780
lo que tiene que hacer con el último y lo quita, me pilla el último, hace lo que tiene

504
00:46:43,780 --> 00:46:46,380
que hacer con el último y lo quita, etc.

505
00:46:46,380 --> 00:46:53,849
Hasta que llega un momento en que ya no habrá valores ahí dentro, entonces se ha acabado.

506
00:46:53,849 --> 00:47:06,800
Al cabo, este de aquí, con un poco de suerte, aquí dentro las tengo ordenadas por frecuencia

507
00:47:06,800 --> 00:47:28,840
3, 3, pero esta palabra no está ordenada por, si quisiera ordenarla ahora, antes de

508
00:47:28,840 --> 00:47:47,380
Y este de aquí podría ser list.sort, no, list.sort, no, collection, collections.sort de ordenados por frecuencia.

509
00:47:54,210 --> 00:47:55,010
No, me lo meto.

510
00:47:55,630 --> 00:47:57,469
Sería demasiado, sería demasiado.

511
00:47:58,150 --> 00:48:04,559
Aquí quieres ordenarlo tanto alfabéticamente como por cantidad de...

512
00:48:04,559 --> 00:48:19,900
Sería bastante más complejo. O sea que dentro de la misma frecuencia, me lo debería organizar en una lista de listas y cada frecuencia ponerlo en una lista y luego ordenar eso y luego después combinarla.

513
00:48:20,059 --> 00:48:23,900
Pero ahora no tengo el poder psicológico para hacer esa cosa.

514
00:48:24,639 --> 00:48:25,300
Eso no tienes.

515
00:48:27,000 --> 00:48:28,980
Lo hacéis vosotros para el lunes.

516
00:48:29,780 --> 00:48:30,380
Exacto.

517
00:48:30,380 --> 00:48:37,300
Entonces, esto lo puedo complicar cuantos da la gana, esto es lo que deberíais hacer

518
00:48:37,300 --> 00:48:41,280
vosotros para jugar con estas cosas, es decir, hago el ejercicio, vale, el ejercicio son

519
00:48:41,280 --> 00:48:44,920
cuatro líneas de códigos, lo hemos visto al principio, y luego ponéis a decir, y si

520
00:48:44,920 --> 00:48:55,239
quiero esto, y si quiero esto, y claro, es que a veces una tontería se puede explotar

521
00:48:55,239 --> 00:49:00,679
desde una perspectiva computacional en el sentido de que requiere de todo lo posible

522
00:49:00,679 --> 00:49:06,820
que esta cosa aquí que hemos hecho nosotros haya una forma de hacerla mucho más ligera elegante

523
00:49:08,340 --> 00:49:24,880
porque si nos interesa es en la primera parte que es aquí fija la cosa hay otros contenidos

524
00:49:24,880 --> 00:49:25,420
aquí

525
00:49:25,420 --> 00:49:27,300
esta

526
00:49:27,300 --> 00:49:30,500
a lo mejor se puede hacer

527
00:49:30,500 --> 00:49:32,760
de una forma un poquito mejor

528
00:49:32,760 --> 00:49:36,840
¿vale? porque aquí sostancialmente

529
00:49:36,840 --> 00:49:38,699
es uno de esos casos que te dice

530
00:49:38,699 --> 00:49:40,579
si estás

531
00:49:40,579 --> 00:49:42,380
una cosa, si no estás otra

532
00:49:42,380 --> 00:49:44,320
¿vale? entonces

533
00:49:44,320 --> 00:49:46,639
dentro de frecuencia

534
00:49:46,639 --> 00:49:50,320
tengo un par de

535
00:49:50,320 --> 00:49:52,820
métodos que son el

536
00:49:52,820 --> 00:49:55,860
UTF-ABSENT

537
00:49:55,860 --> 00:49:57,039
y el GET

538
00:49:57,039 --> 00:49:58,980
por default

539
00:49:58,980 --> 00:50:00,840
que puede

540
00:50:00,840 --> 00:50:03,300
que podrían

541
00:50:03,300 --> 00:50:04,079
ayudarme

542
00:50:04,079 --> 00:50:07,239
por ejemplo podría

543
00:50:07,239 --> 00:50:08,420
utilizar esto

544
00:50:08,420 --> 00:50:18,809
entonces decir

545
00:50:18,809 --> 00:50:19,829
int

546
00:50:19,829 --> 00:50:23,889
s es igual a esta

547
00:50:23,889 --> 00:50:24,329
cosa

548
00:50:24,329 --> 00:50:28,199
y luego esto

549
00:50:28,199 --> 00:50:30,559
y luego esto

550
00:50:30,559 --> 00:50:41,239
entonces esto me lo va a

551
00:50:41,239 --> 00:50:44,489
pillar, va a pillar palabra

552
00:50:44,489 --> 00:50:46,650
si lo encuentra me dará

553
00:50:46,650 --> 00:50:52,530
al asociado con cuarta palabra. Me da la 3, yo le pongo 4 y lo vuelvo a poner. Ya está.

554
00:50:52,530 --> 00:50:58,090
Si en vez no lo encuentra, me devuelve un valor por defecto. Este. Entonces me devuelve

555
00:50:58,090 --> 00:51:06,150
0, le sumo 1, 1 y lo pongo. Esto se queda mucho más elegante de nuestro if esta cosa,

556
00:51:06,150 --> 00:51:11,889
if esta cosa. Mucho más legible, mucho más limpio.

557
00:51:11,889 --> 00:51:35,690
A lo mejor la misma cosa se puede hacer con el otro, que sería, el otro es el frecuencia.put y fabsafe.

558
00:51:35,690 --> 00:51:51,289
Para poner una palabra que no existe sí, pero si ya existe no me lo actualizaría, por lo tanto esto no.

559
00:51:51,289 --> 00:51:59,289
Debería preguntarme que si esta cosa aquí es null, pues entonces quiere decir que no la he metido, entonces la meto yo, pero mejor así.

560
00:51:59,289 --> 00:52:04,289
Esto es más bonito.

561
00:52:04,289 --> 00:52:09,289
Sí, fijaos que he cambiado el método. Si os fijáis aquí yo hago tres cosas.

562
00:52:09,289 --> 00:52:15,289
Hago lo splitting, hago el añadir, hago el organizar.

563
00:52:15,289 --> 00:52:37,260
Estos deberían ser tres métodos para que el main me quede con split a la frase o crea el HashMap, organiza el HashMap, organiza un poquito el main y luego los varios programas lo podrías hasta separar a programadores.

564
00:52:37,260 --> 00:52:44,099
Decirle, mira, tienes que hacer un programa que te dan esto y tienes que devolver esto. Ya está. Luego lo integro con una vaga.

565
00:52:44,099 --> 00:52:57,380
¿Sí? Esto debería seguir funcionando. Madrilla de programa. ¿Dudas? ¿Preguntas?

566
00:52:59,179 --> 00:53:14,000
¿Hay alguna forma de poder ordenar los timers? Diciendo, o sea, me ve por la clave, por igual, tenemos que, por ejemplo, decirle tal interior de mejor interior, me puede decir, por ejemplo.

567
00:53:16,019 --> 00:53:28,960
No, porque como está hecho el map, el map depende de la clave. La cosa importante del

568
00:53:28,960 --> 00:53:34,780
map es la clave. Cuando eliges la clave, entonces sí que con el trimap te organiza por clave.

569
00:53:34,780 --> 00:53:42,909
Pero como valor, no porque tendría menos sentido. Es como si tú haces un índice de

570
00:53:42,909 --> 00:53:52,570
un libro y en vez de ordenarlo por las palabras, pues lo ordenas por la página, pues sería

571
00:53:52,570 --> 00:54:02,679
el primer libro. Pero es que entonces, tu índice serían los números. Normalmente los

572
00:54:02,679 --> 00:54:16,070
HashMaps, si lo has hecho con la clave correcta, son una maravilla, siempre te queda la posibilidad

573
00:54:16,070 --> 00:54:26,170
Es decir, cuando insertas gato y su frecuencia, creas también otro ashmap donde hace la revés.

574
00:54:27,510 --> 00:54:34,750
Que será un ashmap de frecuencia, entonces un integer y una lista de string.

575
00:54:35,670 --> 00:54:37,650
Y lo que haces tú es pillar su frecuencia.

576
00:54:37,789 --> 00:54:39,949
Si ya existe esa frecuencia, lo añades así.

577
00:54:40,190 --> 00:54:41,230
Pero es un...

578
00:54:41,230 --> 00:54:43,550
Porque si lo encuentras otra vez, lo tienes que...

579
00:54:43,550 --> 00:54:45,190
Imagínate, tú gato lo tienes tres veces.

580
00:54:45,190 --> 00:54:50,230
Pues lo deberías añadir a la lista de palabras que se han encontrado tres veces.

581
00:54:50,710 --> 00:54:56,449
Ahora, si lo encuentras otra vez, lo tienes que quitar desde la lista de tres y ponerlo en la lista de cuatro.

582
00:54:56,869 --> 00:54:59,090
Por ejemplo, con cierto cuidado.

583
00:55:01,230 --> 00:55:03,570
Pero lo podrías hacer y al final tendrías dos SashMap.

584
00:55:04,250 --> 00:55:13,349
Uno que te permite buscar por palabra su frecuencia y uno que te permite, dada una frecuencia, buscar cuántas palabras tienen esa frecuencia.

585
00:55:16,570 --> 00:55:23,670
El problemilla aquí es que en el caso de palabras, hay muchas palabras con frecuencia

586
00:55:23,670 --> 00:55:28,969
la que sea, pero las palabras son distintas, entonces se diferencian.

587
00:55:28,969 --> 00:55:34,389
En el otro caso, muchas palabras aparecen pocas veces, entonces a lo mejor tendrías

588
00:55:34,389 --> 00:55:43,329
listas muy largas de 1, 2, 3, 4, entonces luego no sé cuánto... te volverías a recorrer

589
00:55:43,329 --> 00:55:45,389
listas grandes, porque sí.