1
00:00:01,139 --> 00:00:08,839
Vale, pues lo dicho, hemos empezado ya la clase y la idea es repasar lo que vimos el otro día.

2
00:00:09,039 --> 00:00:16,719
Utilicé esta presentación que os tengo puesta aquí y en la presentación estuvimos viendo cómo analizar algoritmos.

3
00:00:17,940 --> 00:00:22,420
Estuvimos viendo que teníamos que localizar las variables, las entradas y salidas de los datos,

4
00:00:23,239 --> 00:00:29,320
el análisis del propósito del propio programa, qué procesos y qué decisiones se tomaban

5
00:00:29,320 --> 00:00:33,280
y al final, después de haber analizado todos esos pasos, veíamos ya en la conclusión

6
00:00:33,280 --> 00:00:37,920
qué era lo que hacía el programa. Teníamos que analizar exactamente cuál era el propósito del programa.

7
00:00:38,740 --> 00:00:44,780
Cuando yo, a ver, quiero que entendáis una cosa, porque muchos al analizar los ejercicios que os he puesto

8
00:00:44,780 --> 00:00:48,960
me habéis ido indicando la descripción de cada una de las cajitas.

9
00:00:49,259 --> 00:00:53,179
Entonces, fijaros en una cosa. Cuando yo voy a abrir una puerta,

10
00:00:53,820 --> 00:00:56,399
si quiero construir un algoritmo para abrir una puerta, ¿vale?

11
00:00:56,399 --> 00:01:00,820
Yo diría algo así como, primero, comprobar si la puerta está cerrada.

12
00:01:01,359 --> 00:01:03,640
Si está cerrada, entonces tengo que abrirla.

13
00:01:03,799 --> 00:01:07,019
Y si no está cerrada, simplemente la atravieso y paso, ¿vale?

14
00:01:07,019 --> 00:01:07,680
Porque está abierta.

15
00:01:08,340 --> 00:01:11,340
Entonces, si está cerrada, ¿qué tengo que hacer?

16
00:01:12,060 --> 00:01:15,459
Tengo que buscar en mi bolsillo unas llaves.

17
00:01:15,859 --> 00:01:21,040
Por lo tanto, tengo que meter la mano en el bolsillo, buscar las llaves y sacarlas.

18
00:01:21,680 --> 00:01:23,579
Después, seleccionar la llave correcta.

19
00:01:23,579 --> 00:01:35,420
introducir la llave en la cerradura, girar la llave de forma que la puerta quede abierta, abrir la puerta y comprobar que la puerta ha quedado abierta.

20
00:01:36,180 --> 00:01:40,560
Si no ha quedado abierta, pues a lo mejor es que me he equivocado de llave. Prueba con otra llave.

21
00:01:41,180 --> 00:01:44,900
Y así hacemos un algoritmo para que podamos pasar la puerta.

22
00:01:45,040 --> 00:01:48,659
Entonces, si os fijáis, yo puedo deciros, ¿cuál es el propósito de este algoritmo?

23
00:01:48,659 --> 00:01:55,260
pues cruzar una puerta entrar a una casa o entrar a una habitación el propósito es una puerta

24
00:01:55,260 --> 00:02:00,959
comprobar si está cerrada o no y pasar vale y abrirla ese es el propósito del algoritmo abrir

25
00:02:00,959 --> 00:02:05,040
la puerta pero yo no puedo deciros cuál es el propósito del algoritmo pues el propósito del

26
00:02:05,040 --> 00:02:11,520
algoritmo es comprobar si la puerta está cerrada y si no está cerrada lo comprobar si tenemos las

27
00:02:11,520 --> 00:02:16,560
llaves en el bolsillo y si tenemos llaves en el bolsillo sacar la llave meter la llave girar la

28
00:02:16,560 --> 00:02:21,919
llave, comprobar si la puerta está abierta, si no, repetir el proceso. Eso no es un propósito en sí.

29
00:02:22,560 --> 00:02:27,280
Tenemos que entender que cuando hablo del propósito tengo que intentar ir un paso de abstracción más

30
00:02:27,280 --> 00:02:35,340
grande, más anterior, y coger la idea general. ¿Qué es lo que ese algoritmo propone resolver?

31
00:02:35,580 --> 00:02:40,159
¿Cuál es el problema con el que yo me encuentro que a través del uso del algoritmo lo resuelvo?

32
00:02:40,500 --> 00:02:45,759
¿Entendéis? Esa es la clave del propósito. Por lo tanto, hasta que no hemos analizado bien qué es lo que

33
00:02:45,759 --> 00:02:52,719
hace el algoritmo, yo no puedo entender cuál es el propósito. Si yo os digo, os voy a decir una secuencia de acciones y me decís cuál es el

34
00:02:52,719 --> 00:02:59,919
propósito. Yo os digo, mirad, llego al umbral de una puerta, comprobo si está abierta. Si no está abierta, saco una llave del bolsillo, la meto en la

35
00:02:59,919 --> 00:03:07,620
cerradura, la giro, abro la puerta y paso. ¿Cuál es el propósito? Vosotros entendéis en ese lenguaje, que es lenguaje natural, que el propósito es

36
00:03:07,620 --> 00:03:15,680
entrar en una casa o entrar en una habitación. Pero no es, el propósito no es buscar unas llaves en el bolsillo, ni el propósito es meter la

37
00:03:15,680 --> 00:03:22,580
llave en la cerradura y girar la llave eso no son los propósitos esas son las acciones entonces

38
00:03:22,580 --> 00:03:29,120
cuando yo describo primero tampoco tengo que describir cada una de las acciones yo si quisiera

39
00:03:29,120 --> 00:03:33,259
describir el algoritmo el algoritmo a nivel general yo lo describiría diciendo llegó a la

40
00:03:33,259 --> 00:03:39,379
puerta compruebo si está abierta si no está abierta la abro y para abrirla tengo que buscar las llaves

41
00:03:39,379 --> 00:03:45,139
introducirlas en la cerradura en la llave correcta y girarla esa sería la descripción de ese algoritmo

42
00:03:45,139 --> 00:03:56,479
Y luego están esos pasos que son los que se desgranan y cada caja, cada acción individual, de hecho cada acción podríamos seguramente subdividirla en acciones.

43
00:03:56,939 --> 00:04:07,039
El buscar las llaves en el bolsillo la puedo subdividir en, meto la mano en el bolsillo, busco entre las cosas que hay en el bolsillo unas llaves y extraigo el manojo de llaves.

44
00:04:07,979 --> 00:04:14,039
Pero no solo eso, sino que es que el meter la mano en el bolsillo supone mover el brazo en dirección al bolsillo,

45
00:04:14,240 --> 00:04:20,180
buscar la abertura del bolsillo, meter la mano dentro del bolsillo de forma que quede la mano dentro del bolsillo.

46
00:04:20,180 --> 00:04:23,000
Todo eso son acciones. Y puedo seguir desgranándolo.

47
00:04:23,360 --> 00:04:24,759
¿Muevo el hombro? ¿Muevo el músculo?

48
00:04:24,920 --> 00:04:33,639
Es decir, muchas veces cada caja en sí mismo sigue siendo un pequeño problema que tendría que resolver a través de un algoritmo.

49
00:04:33,639 --> 00:04:46,879
¿Hasta qué punto tenemos que hacer esto? Hasta el punto en el que lleguemos al nivel del lenguaje de programación que vayamos a utilizar, que yo pueda utilizar órdenes directas en ese lenguaje de programación para cada una de las acciones que estoy realizando.

50
00:04:46,879 --> 00:04:56,100
Si yo tengo una orden en el lenguaje de programación que esté utilizando, que sea, introduce la mano en el bolsillo, yo ya no tengo que desgranar más ese problema.

51
00:04:56,740 --> 00:05:07,660
Pero si yo esa orden no la tengo, el introducir la mano en el bolsillo en sí mismo, tengo que resolverlo y construir un algoritmo que me haga una serie de subprocesos

52
00:05:07,660 --> 00:05:14,180
y que lleven a la resolución de ese problema, que es meter la mano en el bolsillo, que es un subproblema de los que yo me he encontrado.

53
00:05:14,180 --> 00:05:28,040
Entonces, esto supongo que se entiende y simplemente estábamos viendo luego cómo a través de unas plantillas

54
00:05:28,040 --> 00:05:36,079
podíamos analizar los algoritmos. Decíamos que teníamos un algoritmo y vamos a buscarle estas cosas que habíamos dicho,

55
00:05:36,319 --> 00:05:41,220
las variables, entradas y salidas de datos, intentar ver un poco el propósito general con esa información

56
00:05:41,220 --> 00:05:44,300
si lo conocíamos ya, ver qué procesos y decisiones se toman.

57
00:05:44,399 --> 00:05:48,139
Entonces aquí vemos que leemos un número que en principio no sabemos cuál es,

58
00:05:48,220 --> 00:05:52,339
pero sabemos aquí que es un límite, por lo tanto, porque es el que me marca la salida del bucle.

59
00:05:53,000 --> 00:05:56,980
Por lo tanto, nos está preguntando, esto es una pregunta que nos hace al usuario

60
00:05:56,980 --> 00:05:59,060
y es una variable, un dato.

61
00:05:59,779 --> 00:06:02,259
Nos pregunta un dato que luego es el límite de este bucle.

62
00:06:02,759 --> 00:06:07,339
Y en el bucle lo que está haciendo es llevar un contador que está en n,

63
00:06:07,699 --> 00:06:11,180
cada vuelta n se incrementa en 1, con lo cual es un contador de vuelta,

64
00:06:11,839 --> 00:06:16,980
Si empezamos en 0, cuando entramos, entra en 1, cuando entramos en la siguiente vuelta serían 2,

65
00:06:17,139 --> 00:06:21,939
cuando entramos en la siguiente vuelta serían 3, porque cada vuelta se le suma 1, con lo cual esto es un contador, contador de vueltas.

66
00:06:22,459 --> 00:06:29,779
Y lo que hago es, en una variable suma, voy acumulando, es un acumulador, por lo tanto, voy acumulando ese contador,

67
00:06:30,160 --> 00:06:38,060
cada vez que entra va sumando el valor del contador, con lo cual en la primera vuelta sumo 1, en la segunda vuelta sumo 1 más 2,

68
00:06:38,060 --> 00:06:51,360
En la siguiente, 1 más 2 más 3. En la siguiente, 1 más 2 más 3 más 4. Con lo cual, al final, ¿qué estoy haciendo? En este bucle estoy sumando todos los números consecutivos desde 1 hasta el límite que es k.

69
00:06:52,139 --> 00:06:59,300
Y ese es el propósito del programa. El propósito del programa es sumar todos los números naturales de 1 al número que introduce el usuario.

70
00:06:59,300 --> 00:07:04,800
al final evidentemente me tiene que devolver el resultado por lo tanto me dice cuál es el límite

71
00:07:04,800 --> 00:07:11,540
y cuál es la suma cuál es esa suma y ya tengo el propósito resuelto vale bueno lo mismo hacíamos

72
00:07:11,540 --> 00:07:16,379
con el segundo algoritmo que era calcular el factorial de un número y este factorial pues

73
00:07:16,379 --> 00:07:21,220
teníamos que hacer una comprobación inicial para saber si el factorial de cero es un número especial

74
00:07:21,220 --> 00:07:26,319
con lo cual había que filtrarlo y luego teníamos que si es mayor que cero hacer el algoritmo pero

75
00:07:26,319 --> 00:07:34,459
Fijaros que además este algoritmo tenía un problema y es que para n igual a 1, el factorial de 1 es 1, pero yo si meto ahí un 1 en el rn de arriba,

76
00:07:35,180 --> 00:07:41,779
lo que me va a hacer es que va a quedarme en un bucle infinito porque no va a parar nunca, con lo cual tiene un pequeño fallo para 1, ¿de acuerdo?

77
00:07:42,139 --> 00:07:47,759
Filtra el valor de 0, pero no filtra el valor de 1, con lo cual, pues bueno, este tenía algunos problemas que también resolvimos.

78
00:07:47,759 --> 00:08:14,720
Y vimos también cómo utilizábamos PSINT, que es un programa que me permite escribir en pseudocódigo, es decir, escribir no en un lenguaje de programación con comandos, sino a través de casi lenguaje natural, prácticamente un lenguaje natural que nos permite ir diciéndole qué queremos hacer, pues escribir, leer, hacer, asignar, hacer una serie de cosas, repetir mientras, repetir hasta, un sí condicional, todo eso lo podemos hacer en pseudocódigo.

79
00:08:14,720 --> 00:08:19,180
y además nos permitía ejecutarlo y estuvimos viendo esos ejemplos. Eso es lo que estuvimos haciendo el otro día.

80
00:08:19,279 --> 00:08:26,120
Básicamente analizar los diagramas de flujo y ver cuál era su propósito. Hoy vamos a hacer lo contrario.

81
00:08:26,680 --> 00:08:31,720
Hoy vamos a plantear un problema y vamos a construir nosotros el diagrama de flujo para resolverlo.

82
00:08:32,500 --> 00:08:38,139
Parece más fácil, pero cuando lo quiero construir de la forma correcta para luego llevarlo a un lenguaje de programación

83
00:08:38,139 --> 00:08:45,019
puede no ser tan obvio y por eso es lo que vamos a hacer ahí vale entonces preguntas hasta ahora

84
00:08:45,019 --> 00:08:59,309
preguntas por el chat vale si no hay preguntas compruebo las manos no hay manos levantadas

85
00:08:59,309 --> 00:09:09,570
perfecto pues entonces continuamos qué vamos a ver hoy pues vamos a ver cómo construir

86
00:09:09,570 --> 00:09:17,929
un algoritmo. Y este algoritmo, yo os voy a proponer un algoritmo y lo vamos a construir, ¿vale?

87
00:09:22,690 --> 00:09:28,029
¿Cómo construimos un algoritmo de cero? Entonces, vamos a ver cómo construir este algoritmo.

88
00:09:28,029 --> 00:09:38,389
Vamos a darle, así lo veis en grande, y la idea es, a ver un segundito, supongo que seguís viendo

89
00:09:38,389 --> 00:09:47,350
la presentación. Perfecto. Pues la idea es proponer un algoritmo de cero. Yo quiero hacer algo, os voy a proponer el ejemplo de antes,

90
00:09:47,450 --> 00:09:55,190
utilizando el ejemplo de antes, voy a proponeros atravesar una puerta o pasar a una habitación o entrar a una casa y vosotros me tenéis que hacer

91
00:09:55,190 --> 00:10:03,210
el algoritmo para hacerlo. No va a ser ese ejemplo, va a ser otro un poco diferente. Entonces, vamos a verlo.

92
00:10:03,210 --> 00:10:11,070
Bueno, definición del algoritmo que quiero construir, ¿vale? Esto es un ejemplo, pero es un ejemplo que me va a servir para ilustrar los pasos que vamos a tener que utilizar.

93
00:10:11,629 --> 00:10:20,830
Primero, queremos construir un algoritmo que pida al usuario que introduzca una cantidad de dinero, ¿vale? Por lo tanto, la entrada del algoritmo va a ser una cantidad de dinero que me van a preguntar.

94
00:10:20,830 --> 00:10:28,070
y vamos a comprobar si esa cantidad de dinero introducida se puede entregar en billetes de 50, 20 y 10 euros.

95
00:10:28,070 --> 00:10:33,750
Es decir, lo que quiero es cambiar una cantidad de dinero en billetes.

96
00:10:34,990 --> 00:10:39,690
Y ahí tenemos la condición sin necesidad de usar monedas.

97
00:10:40,389 --> 00:10:45,129
Es decir, solamente tiene que ser una cantidad que yo pueda dar en billetes de 50, de 20 o de 10.

98
00:10:45,769 --> 00:10:55,129
Si no es una cantidad que se pueda entregar en billetes de 50, 20 y 10, vamos a volver la pregunta al usuario para que introduzca una cantidad válida.

99
00:10:55,850 --> 00:10:58,389
¿De acuerdo? Esa es la primera parte del algoritmo.

100
00:10:58,549 --> 00:11:06,129
Y después, la salida del algoritmo será la cantidad de billetes de 50 euros, de 20 euros y de 10 euros que usaremos para entregar la cantidad solicitada.

101
00:11:07,409 --> 00:11:10,309
Y usando el mínimo número de billetes, porque si no sería muy fácil.

102
00:11:10,309 --> 00:11:17,289
Si yo lo puedo hacer con billetes de 50, 20 y 10, pues nada, cojo el de 10 que es el más pequeño y ya está divido y se acabó el problema.

103
00:11:17,590 --> 00:11:19,830
No, utilizando el mínimo número de billetes.

104
00:11:20,330 --> 00:11:20,610
¿De acuerdo?

105
00:11:21,629 --> 00:11:25,629
Vale, entonces, ¿qué subproblemas tenemos que resolver?

106
00:11:26,889 --> 00:11:37,830
Entonces, quiero que penséis, cuando hay que resolver este problema, quiero pedir una cantidad de dinero y debo devolverle al usuario, ¿cuántos billetes de 50, de 20 y de 10?

107
00:11:37,830 --> 00:11:47,549
voy a darle qué subproblemas hay que resolver. Quiero volver a enseñaros el enunciado para que lo penséis, ¿vale?

108
00:11:47,610 --> 00:11:52,570
Y me contestáis por el chat o si levantáis la mano os activo el micro y me lo decís, ¿vale?

109
00:11:52,570 --> 00:11:56,049
Entonces quiero que penséis qué subproblemas hay que resolver. Este es el enunciado.

110
00:11:56,669 --> 00:12:03,649
¿Qué cosas son las que yo tengo que prestar atención para resolver porque suponen un problema para mí a la hora de ejecutar un programa?

111
00:12:03,649 --> 00:12:12,629
entonces voy a cogerme el chat y los participantes

112
00:12:12,629 --> 00:12:17,639
y si alguno quiere preguntar, este es el momento

113
00:12:17,639 --> 00:12:20,879
quiero que lo penséis, un minuto, os dejo un minuto

114
00:12:20,879 --> 00:12:26,799
quiero que reviséis ese enunciado y me digáis

115
00:12:26,799 --> 00:12:31,299
por aquí me dicen números negativos, efectivamente

116
00:12:31,299 --> 00:12:35,759
un número negativo no es válido, por lo tanto es algo que tengo que filtrar

117
00:12:35,759 --> 00:12:39,399
entonces hay que apuntar en un papel

118
00:12:39,399 --> 00:12:42,940
tenemos que tener en cuenta los números negativos

119
00:12:42,940 --> 00:12:45,519
con lo cual es algo que

120
00:12:45,519 --> 00:12:48,679
si nos lo introduce el usuario tendremos que decirle

121
00:12:48,679 --> 00:12:50,960
no es válido, perfecto, el 0 también

122
00:12:50,960 --> 00:12:54,399
el 0, números negativos

123
00:12:54,399 --> 00:12:56,399
el 0, ¿qué más?

124
00:12:57,519 --> 00:13:00,259
si es un número inferior a 10

125
00:13:00,259 --> 00:13:03,399
o superiores a 10 que no sean

126
00:13:03,399 --> 00:13:11,440
múltiplos de 10, ¿no? Es decir, si yo meto un 32, un 32 euros, no lo podría devolver en billetes de 50, 20 y 10.

127
00:13:12,820 --> 00:13:20,580
Como mínimo tiene que ser, claro, números que acaben en 0, es decir, la solución sería múltiplos de 10, ¿vale?

128
00:13:21,360 --> 00:13:25,159
Múltiplos de 10, que es al final números que acaben en 0, ¿vale? Múltiplos de 10.

129
00:13:25,159 --> 00:13:44,220
Entonces ya tengo la primera parte del problema, múltiplos de 10. El primer subproblema que es comprobar que la cantidad de dinero introducida se puede entregar en billetes de 50, 20 y 10 me supone tres cosas que debo tener en cuenta.

130
00:13:44,220 --> 00:13:47,340
son que no haya números negativos

131
00:13:47,340 --> 00:13:49,559
que no sea un 0 y que además

132
00:13:49,559 --> 00:13:51,840
el número introducido sea múltiplo de 10

133
00:13:51,840 --> 00:13:53,559
si esas condiciones se cumplen

134
00:13:53,559 --> 00:13:55,799
ya tengo la primera parte resuelta

135
00:13:55,799 --> 00:13:56,860
el número es válido

136
00:13:56,860 --> 00:14:00,100
y lo puedo desgranar en billetes de 50, 20 y 10

137
00:14:00,100 --> 00:14:01,799
¿vale? perfecto

138
00:14:01,799 --> 00:14:03,379
¿qué más problemas

139
00:14:03,379 --> 00:14:04,860
tengo que resolver?

140
00:14:06,299 --> 00:14:07,519
ahora ya tengo resuelto

141
00:14:07,519 --> 00:14:09,440
la entrada, la entrada ya es válida

142
00:14:09,440 --> 00:14:11,519
ya me ha asegurado de que en la cantidad

143
00:14:11,519 --> 00:14:13,679
que ha introducido el usuario es una cantidad válida

144
00:14:13,679 --> 00:14:30,700
Ahora, ¿qué más tengo que resolver? Tengo otro problema. Fijaros, tengo que usar el mínimo número de billetes. Esto es un problema. ¿Y cómo resuelvo ese problema?

145
00:14:32,539 --> 00:14:46,139
¿Cómo haríamos que a la hora de hacer la división usemos el mínimo número de billetes? Porque ya os digo, si no, yo cojo, divido por 10 y a chutar y doy billetes de 10. Fíjate, hay una pila de billetes de 10 y siempre me va a salir.

146
00:14:46,139 --> 00:14:55,799
pero eso no me usa el mínimo número de billetes entonces que números no más grandes que 5 no

147
00:14:55,799 --> 00:15:06,179
entiendo maría más grandes que 50 querías decir no pero sí que pueden ser más si es más grandes

148
00:15:06,179 --> 00:15:10,679
que 50 si pueden ser más grandes que 50 si yo tengo 200 euros te doy cuatro billetes de 50

149
00:15:10,679 --> 00:15:18,779
vale o sea que eso no es pero la idea es que al hacer el reparto usemos el mínimo número de

150
00:15:18,779 --> 00:15:25,080
billetes. Bueno, la solución para esto, probamos a dividir entre el número más grande primero y

151
00:15:25,080 --> 00:15:31,539
yendo a menos, eso sí, ¿vale? David, la cuestión es coger y hacer el reparto desde los billetes más

152
00:15:31,539 --> 00:15:39,080
grandes hacia los billetes más pequeños. Yo voy dando billetes grandes hasta que ya no me cabe,

153
00:15:40,000 --> 00:15:45,840
es decir, hasta que tengo menos de 50 euros y cuando tenga menos de 50 euros paso a dar billetes

154
00:15:45,840 --> 00:15:52,259
de 20 y doy billetes de 20 hasta que tenga menos de 20 euros y cuando tenga menos de 20 euros

155
00:15:52,259 --> 00:16:01,240
entonces doy billetes de 10, ¿de acuerdo? Esa sería la idea. Entonces repartimos de más a menos, por lo

156
00:16:01,240 --> 00:16:09,340
tanto, fijaros, el reparto de más a menos lo que me resuelve ya es el problema, ya he desgranado mi

157
00:16:09,340 --> 00:16:18,960
problema que era dividir una cantidad en billetes lo más grandes posibles y dárselo al usuario, pues ya le he desgranado en los problemas

158
00:16:18,960 --> 00:16:28,740
que yo puedo resolver de una forma más sencilla. He subdividido este algoritmo en sus subproblemas. Por lo tanto, tenemos dos subproblemas

159
00:16:28,740 --> 00:16:36,639
que hay que resolver. Comprobación de que la cantidad introducida es correcta y usar el mínimo número de billetes. La comprobación de la cantidad

160
00:16:36,639 --> 00:16:42,240
se nos ocurre, ¿vale? Haciendo lo que hemos dicho. Pues viendo que no hay números negativos,

161
00:16:42,379 --> 00:16:50,320
viendo que la cantidad no es cero y luego, ¿vale? Usando las matemáticas, tiene que ser múltiplo de 10.

162
00:16:50,399 --> 00:16:56,039
Pero ¿cómo hacemos usando matemáticas? ¿Cómo comprobamos usando las matemáticas que un número es múltiplo de 10?

163
00:16:57,279 --> 00:17:02,200
Vuelvo a preguntaros. Venga, vamos a darle una pequeña vuelta a ver si conseguimos encontrar la clave.

164
00:17:02,200 --> 00:17:06,359
Alguien que me conteste por el chat o que me levante la mano

165
00:17:06,359 --> 00:17:13,049
Fijaros que lo que estamos haciendo simplemente es analizar el problema

166
00:17:13,049 --> 00:17:15,430
Estoy analizando el problema

167
00:17:15,430 --> 00:17:19,589
Estoy viendo simplemente qué problema tengo y cómo lo puedo resolver

168
00:17:19,589 --> 00:17:22,450
Pero lo estoy analizando de una forma muy analítica

169
00:17:22,450 --> 00:17:24,450
Muy desgranando el problema

170
00:17:24,450 --> 00:17:27,430
¿Vale? Venga, cómo a través de las matemáticas

171
00:17:27,430 --> 00:17:28,869
Que es lo que usan los ordenadores

172
00:17:28,869 --> 00:17:30,849
Un ordenador solamente hace cuentas matemáticas

173
00:17:30,849 --> 00:17:32,890
Solo hace comprobaciones matemáticas

174
00:17:32,890 --> 00:17:38,670
Entonces, ¿cómo haríamos? ¿Cómo comprobaríamos que un número es múltiplo de 10?

175
00:17:41,750 --> 00:17:47,509
¿Se os ocurre algo? Bueno, veo que no se os ocurre nada, os lo resuelvo.

176
00:17:47,950 --> 00:17:56,329
La idea sería dividir el número por 10 y comprobar, claro, que sea un número entero, efectivamente.

177
00:17:57,670 --> 00:18:01,450
Entonces, ¿cómo lo haríamos? Dividir entre 10 y comprobar que no tiene decimales.

178
00:18:01,769 --> 00:18:03,650
Comprobar que el número es un número entero.

179
00:18:03,650 --> 00:18:15,569
Entonces, hay formas, hay comandos, órdenes matemáticas que podemos utilizar en los lenguajes de programación que podemos utilizar, ¿vale?

180
00:18:15,569 --> 00:18:23,990
Por ejemplo, suele haber una orden que se llama int, que me da la parte entera de una división, ¿de acuerdo?

181
00:18:24,589 --> 00:18:28,769
También en otros lenguajes de programación ese mismo orden se llama trunk, ¿vale?

182
00:18:28,769 --> 00:18:35,549
de truncar. Lo que haces es cogerte la división y te quedas con el trozo de la parte entera y quito

183
00:18:35,549 --> 00:18:43,630
los decimales. ¿Cómo hacemos entonces la comprobación? Pues simplemente cojo la división entre 10, su parte

184
00:18:43,630 --> 00:18:51,910
entera y compruebo si eso es igual a la división sin calcular su parte entera. Si cogiendo la parte

185
00:18:51,910 --> 00:19:04,170
entera de la división es igual que la división sin tocar, es porque la división es entera. Pero si yo me quedo con la parte entera y me queda un número

186
00:19:04,170 --> 00:19:14,329
diferente que la división sin tocar, eso quiere decir que la división sin tocar tiene decimales, por eso no son iguales. Por lo tanto, en matemáticas,

187
00:19:14,329 --> 00:19:23,390
vale la solución utilizando los comandos que yo puedo utilizar es o round o trunk o in round lo

188
00:19:23,390 --> 00:19:29,509
que hace es redondear al entero más cercano vale entonces hay órdenes en los lenguajes de

189
00:19:29,509 --> 00:19:34,730
programación que eso lo cuando estudiéis programación en algún lenguaje ya los irán

190
00:19:34,730 --> 00:19:40,430
diciendo las órdenes que existen pero todos los lenguajes de programación tienen una forma una

191
00:19:40,430 --> 00:19:46,230
función que me permite redondear al entero más cercano o truncar el número de decimales que no

192
00:19:46,230 --> 00:19:53,109
es lo mismo vale 6 con 7 si yo lo trunco me quedaría 6 si yo lo redondeo al entero más

193
00:19:53,109 --> 00:20:00,430
cercano me quedaría 7 vale pero en cualquier caso 6 con 7 que sería 67 entre 10 no me va a quedar

194
00:20:00,430 --> 00:20:06,069
nunca igual ni a trunk ni a round ni a int vale ni a ninguna de las órdenes que me quita los

195
00:20:06,069 --> 00:20:11,849
decimales, tanto sea redondeando como truncando, ¿de acuerdo? En este caso yo he utilizado round, ¿vale?

196
00:20:11,890 --> 00:20:18,329
Pero podríamos utilizar también trunco. Bien, entonces, si la cantidad entre 10 no nos da decimales es correcta, esa es la clave

197
00:20:18,329 --> 00:20:25,210
para programar, ¿vale? Encontrar de qué forma yo puedo resolver mi problema dándole una pequeña vuelta.

198
00:20:26,390 --> 00:20:32,549
Entonces, ¿qué vamos a hacer? Pues vamos a construir un bucle, ya empezamos a pensar en nuestro programa, en nuestro

199
00:20:32,549 --> 00:20:46,049
algoritmo, vamos a construir un bucle en el cual voy a preguntarle al usuario cuál es la cantidad que quiere repartir en billetes y ese bucle se va a repetir hasta que la cantidad

200
00:20:46,049 --> 00:20:57,910
que me haya introducido dividida por 10 sea igual a la cantidad dividida por 10 redondeada, que quiere decir que me ha metido una cantidad válida. Además de eso, tendré que comprobar

201
00:20:57,910 --> 00:21:27,849
que no sea cero y además de eso tendré que comprobar que no haya números negativos como hemos visto vale es decir ni números negativos ni cero ni por lo tanto tengo que decirle que ese bucle se tiene que repetir hasta cuando hasta que se cumplan dos condiciones una que el número sea estrictamente mayor que cero para que no sea ni cero ni negativo estrictamente mayor que cero y además que round de la cantidad dividido por 10

202
00:21:27,910 --> 00:21:31,730
sea igual a la cantidad por 10. Esas dos son las condiciones que hay que cumplir

203
00:21:31,730 --> 00:21:36,150
y hay que cumplirlas a la vez con un i. ¿Vale? Luego veremos cómo lo hacemos.

204
00:21:36,650 --> 00:21:40,869
Entonces, esta es la primera parte y ya tenemos prácticamente nuestro algoritmo

205
00:21:40,869 --> 00:21:45,829
construido para esa parte. ¿Vale? Vamos a continuar.

206
00:21:47,569 --> 00:21:51,450
Vamos al segundo problema. ¿Cómo usarías el mínimo número de billetes

207
00:21:51,450 --> 00:21:55,069
sabiendo que se pueden usar los de 50? Bueno, pues en este caso ya lo hemos visto.

208
00:21:55,069 --> 00:22:04,750
Vamos a repartir de mayor a menor. Entonces, el truco está empezar a repartir por el billete más grande, que es el de 50, hasta que no se puedan repartir más y luego seguir con el resto del dinero.

209
00:22:06,769 --> 00:22:20,390
Aquí vamos a construir, por cierto, en el anterior necesito una variable, tengo que utilizar una variable que también me la apunto en un papelito, voy a necesitar una variable donde almacenar la cantidad que me ha dicho el usuario que quiere repartir,

210
00:22:20,390 --> 00:22:25,470
para luego poder hacer las comprobaciones, eso es una variable donde yo almaceno ese valor, ¿de acuerdo? Esto está claro.

211
00:22:26,089 --> 00:22:35,630
Y luego, ¿vale? En este caso yo voy a necesitar cuatro variables, yo las he llamado B50, B20, B10, que quiere decir billetes de 50, billetes de 20, billetes de 10

212
00:22:35,630 --> 00:22:46,809
y luego necesito una variable que me vaya almacenando el resto de dinero que me queda por repartir, puesto que yo voy a ir repartiendo dinero en un bucle

213
00:22:46,809 --> 00:22:53,089
de otra forma, yo necesito saber cuánto dinero ya tengo repartido en billetes de 50 para repartir el resto en billetes de 20.

214
00:22:53,269 --> 00:23:00,970
Entonces necesito una variable que me almacene lo que me va quedando de dinero. Una variable, la anterior cantidad, es la que me almacena

215
00:23:00,970 --> 00:23:10,009
la cantidad inicial que yo tenía que repartir y resto, que al principio van a ser iguales, porque al principio tengo todo para repartir,

216
00:23:10,009 --> 00:23:19,250
Por lo tanto, resto al principio va a ser igual a cantidad, poco a poco va a ir avanzando el programa y resto me va a quedar con menos dinero hasta que quede con cero.

217
00:23:19,349 --> 00:23:24,130
Cuando resto quede con cero, quiere decir que he repartido todo el dinero, no me queda nada por repartir, ¿vale?

218
00:23:24,630 --> 00:23:33,049
Con lo cual necesito cuatro variables aquí, b50, b20, b10 y resto, que es lo que me va a almacenar lo que me queda por repartir pendiente.

219
00:23:34,150 --> 00:23:37,490
¿Y cómo resolveríamos esto? Usando las matemáticas, ¿vale?

220
00:23:37,490 --> 00:23:59,990
De nuevo, vuelvo a preguntar, os dejo un minutito, intentar pensar cómo haríamos el reparto en billetes de 50, en billetes de 20, en billetes de 10, ¿vale? Utilizando esas variables y utilizando las matemáticas, utilizando algún proceso, algún bucle, algún algoritmo así sencillo, ¿vale?

221
00:23:59,990 --> 00:24:15,990
Que me podáis decir si os ocurre algo, alguien tiene alguna idea. Ya casi con lo que os he explicado antes tenéis una pista de una de las posibles soluciones.

222
00:24:16,250 --> 00:24:22,509
No hay una solución única. Muchas veces en programación hay soluciones múltiples para un mismo problema.

223
00:24:23,150 --> 00:24:28,130
Es decir, no necesariamente todos los programadores van a programar exactamente lo mismo.

224
00:24:28,130 --> 00:24:33,950
y yo de hecho aquí os voy a dar dos opciones, una mejor, otra peor, pero os voy a dar dos opciones

225
00:24:33,950 --> 00:24:39,930
y las dos funcionan perfectamente, veo que no hay ideas con lo cual avanzamos y os las cuento yo

226
00:24:39,930 --> 00:24:50,430
la opción 1 sería haciendo un bucle, un bucle en el que cada vuelta sumemos 1 a la cantidad de billetes correspondiente

227
00:24:50,430 --> 00:24:54,730
y quitemos el valor de ese billete del resto que me queda, es decir, yo hago un bucle

228
00:24:54,730 --> 00:25:01,430
A ver, dividiendo la cantidad entre 50, solo tener los números enteros, quitando los decimales, luego los de 20 y los de 10.

229
00:25:01,789 --> 00:25:06,529
Vale, Daniel, efectivamente, esa es una de las posibles opciones, esa es lo que yo he llamado la opción 2, ¿vale?

230
00:25:06,589 --> 00:25:11,250
Entonces, hay otra opción, que es la opción 1, ¿vale? Con los comandos que os he dicho, esa sería una opción.

231
00:25:11,930 --> 00:25:18,390
Y ahora, os digo otra, ¿vale? Una opción sería, yo hago un bucle, tengo resto, que tiene toda la cantidad, y digo, ¿vale?

232
00:25:18,390 --> 00:25:27,950
un billete de 50, sumo 1 a los billetes de 50 y le resto 50 al resto que me queda y repito ese bucle.

233
00:25:27,950 --> 00:25:32,789
¿Hasta cuándo repito el bucle? Hasta que la cantidad que yo tenga en resto sea menor que 50.

234
00:25:33,769 --> 00:25:39,950
Cuando la cantidad sea menor que 50 paso a repartirlos de 20, con lo cual sumo 1 a los billetes de 20

235
00:25:39,950 --> 00:25:46,430
y resto 20 de la cantidad que me queda. Y a ese bucle de los billetes de 20 lo voy a repetir

236
00:25:46,430 --> 00:25:50,809
hasta que en el resto me queden menos de 20 euros, porque si me quedan más,

237
00:25:50,930 --> 00:25:54,750
podré dar otro billete de 20, entonces hasta que el resto me queden por debajo de 20 euros.

238
00:25:55,329 --> 00:26:00,150
Y el último, es el de 10, pues será lo mismo, sumo 1 a los billetes de 10

239
00:26:00,150 --> 00:26:04,690
y cada vez que sume 1 a los billetes de 10, tengo que restarle 10 euros al resto

240
00:26:04,690 --> 00:26:10,250
hasta que me quede 0, ¿vale? Entonces, ¿veis que esto es una solución posible

241
00:26:10,250 --> 00:26:14,809
a través de bucles? Yo hago un proceso repetitivo, es como el cuento de la vieja,

242
00:26:14,809 --> 00:26:16,910
¿no? el cuento de la vieja es

243
00:26:16,910 --> 00:26:19,190
cada oveja que saco del corral

244
00:26:19,190 --> 00:26:21,109
pongo la mano y me das el dinero

245
00:26:21,109 --> 00:26:22,910
que vale, y saco otra oveja

246
00:26:22,910 --> 00:26:24,950
y me das el dinero que vale, y saco otra oveja

247
00:26:24,950 --> 00:26:27,089
y me das el dinero que vale, cada vez que saco

248
00:26:27,089 --> 00:26:29,069
una oveja tú me das el dinero, así no me equivoco

249
00:26:29,069 --> 00:26:30,910
ese era el cuento de la vieja

250
00:26:30,910 --> 00:26:32,829
¿vale? pues hacemos lo mismo, yo

251
00:26:32,829 --> 00:26:35,210
te doy un billete de 50 y te quito 50 del resto

252
00:26:35,210 --> 00:26:36,910
te doy otro de 50 y te

253
00:26:36,910 --> 00:26:38,930
quito 50 del resto, ¿hasta cuándo? hasta que

254
00:26:38,930 --> 00:26:40,890
no te pueda dar más billetes de 50 porque

255
00:26:40,890 --> 00:26:43,069
en el resto no me quedan 50 euros, me quedan menos

256
00:26:43,970 --> 00:26:52,289
Esta es una solución y otra es la que proponía Daniel, que es usar la división y quedarme con la parte entera,

257
00:26:52,690 --> 00:26:58,390
no el redondeo que utilicé antes, que antes podía utilizar el redondeo, ahora no, ahora utilizamos solo la parte entera,

258
00:26:58,390 --> 00:27:06,309
es decir, utilizamos el trunk o el int. Para eso usamos la función trunk. La función trunk lo que hace es coger una cantidad concreta

259
00:27:06,309 --> 00:27:15,109
y quedarme con esa parte decimal. La cantidad, evidentemente, va a ser una división. La división de el dinero que me ha introducido el usuario

260
00:27:15,109 --> 00:27:20,710
dividido entre el valor del billete que estoy repartiendo. Tendré que hacer esto tres veces con los billetes de mayor a menor.

261
00:27:21,529 --> 00:27:30,650
Por lo tanto, billetes de 50 será trunk de la cantidad dividida por 50. Aquí es un poco más complicado calcular el resto.

262
00:27:30,650 --> 00:27:37,250
vale no es tan complicado si lo pensamos si yo tengo una cantidad y ya he dado todos los billetes

263
00:27:37,250 --> 00:27:44,869
de 50 que puedo a través de esta orden entonces que tengo que hacer restarle a la cantidad los

264
00:27:44,869 --> 00:27:49,789
billetes de 50 multiplicados por 50 euros si cada billete que yo he entregado son 50 euros

265
00:27:49,789 --> 00:27:56,750
yo al restarle si por ejemplo me salen cuatro billetes de 50 pues le tengo que restar 50 por

266
00:27:56,750 --> 00:28:02,210
4 que son 200 euros a la cantidad del resto de los 200 euros que ha repartido en billetes de 50

267
00:28:02,210 --> 00:28:08,390
y me queda en el resto siempre me va a quedar una cantidad menor que 50 porque si os fijáis lo que

268
00:28:08,390 --> 00:28:14,809
me va a quedar va a ser la cantidad correspondiente a los decimales de esta división siempre va a ser

269
00:28:14,809 --> 00:28:20,509
menor que un billete de 50 vale entendéis hasta aquí las dos opciones de cómo hacemos el reparto

270
00:28:20,509 --> 00:28:35,849
de billetes respuestas por el chat por favor hay alguna duda o se entiende hola hola queda

271
00:28:35,849 --> 00:28:42,569
alguien en clase se entiende vale gracias también vale cuando pregunto si se entiende

272
00:28:42,569 --> 00:28:55,650
despertaros y decir que sí por lo menos ahora bien entonces resumiendo vale resumiendo tenemos

273
00:28:55,650 --> 00:29:02,650
que usar cinco variables, cantidad para la cantidad que nos introduce el usuario, resto para la que me

274
00:29:02,650 --> 00:29:07,910
queda después de mitad del proceso según voy repartiendo y luego b50 que son billetes de 50,

275
00:29:08,049 --> 00:29:13,910
b20 que son billetes de 20 y b10 que son billetes de 10. Vamos a comprobar que la cantidad introducida

276
00:29:13,910 --> 00:29:19,170
es correcta usando el comando round de cantidad entre 10 igual a cantidad entre 10, además de

277
00:29:19,170 --> 00:29:24,309
decir que sea estrictamente mayor que 0 para eliminar los dos casos que hemos visto que me

278
00:29:24,309 --> 00:29:32,710
producirían un error. Números negativos y por otro lado el cero. Y después vamos a asignar el número de billetes

279
00:29:32,710 --> 00:29:38,170
en sus respectivas variables usando una de dos opciones o un bucle que vaya repartiendo cada billete

280
00:29:38,170 --> 00:29:45,630
o el comando trunk de la cantidad que me queda dividida por el valor del billete para cada uno de los tres billetes.

281
00:29:46,230 --> 00:29:53,750
Tres bucles o tres trunk. Eso es el resumen. Pues en este punto ya puedo construir mi algoritmo.

282
00:29:53,750 --> 00:29:58,569
fijaros todo lo que he tenido que pensar previamente para poder construir un algoritmo

283
00:29:58,569 --> 00:30:04,990
yo tengo un problema y tengo que desgranar el problema en problemas más sencillos

284
00:30:04,990 --> 00:30:10,769
problemas tan sencillos que sea capaz de programarlos con un lenguaje que tiene cosas

285
00:30:10,769 --> 00:30:15,450
que son simplemente sumas, restas, multiplicaciones, divisiones, parte entera de algo

286
00:30:15,450 --> 00:30:18,009
el AND, el OR, el NOT

287
00:30:18,009 --> 00:30:20,769
lógico y cuatro comandos

288
00:30:20,769 --> 00:30:22,849
de un SI, un MIENTRAS

289
00:30:22,849 --> 00:30:23,750
un ASTA

290
00:30:23,750 --> 00:30:26,230
bucles y condiciones

291
00:30:26,230 --> 00:30:28,329
y eso es todo lo que tienen los lenguajes de programación

292
00:30:28,329 --> 00:30:29,730
al final un lenguaje de programación

293
00:30:29,730 --> 00:30:32,569
no tiene más que unas decenas

294
00:30:32,569 --> 00:30:33,269
de órdenes

295
00:30:33,269 --> 00:30:35,910
podemos hablar, es como un idioma

296
00:30:35,910 --> 00:30:37,970
que yo necesito hablarlo

297
00:30:37,970 --> 00:30:39,730
con 10 o 15 palabras

298
00:30:39,730 --> 00:30:42,630
¿vale? pues eso es un lenguaje

299
00:30:42,630 --> 00:30:44,430
de programación, son más pero bueno

300
00:30:44,430 --> 00:31:01,789
Realmente las importantes pueden ser unas decenas, a lo mejor 20 o 30 comandos ya me permiten hacer programas en cualquier lenguaje de programación, ya sea Java, sea C, sea Python, sea yo que sé, Processing, que es el que utilizamos en robótica, cualquiera, cualquiera.

301
00:31:01,789 --> 00:31:12,690
Y eso es la gracia que tiene esto. ¿Cómo tiene que pensar un programador? Tiene que desgranar el problema hasta el punto de que queden órdenes tan sencillas

302
00:31:12,690 --> 00:31:17,910
que yo las pueda meter con esas pocas opciones que me dan los lenguajes de programación.

303
00:31:18,589 --> 00:31:26,490
Y el buen programador lo que hace es desgranar los problemas de forma correcta y el mal programador lo que hace es programar a lo bestia.

304
00:31:26,490 --> 00:31:36,670
Por ejemplo, un buen programador tiraría por la solución de dividir con el comando trunk la cantidad entre el valor del billete para hacer el reparto de billetes.

305
00:31:37,150 --> 00:31:43,529
Un mal programador, ¿qué haría? Bucles, bucles y bucles y bucles que están consumiendo un montón de CPU para hacer lo mismo.

306
00:31:43,710 --> 00:31:51,710
En vez de hacer una división, quedarme con la parte entera y tirar para adelante con el resto, lo que está haciendo es un bucle que va pum pum pum pum.

307
00:31:51,710 --> 00:31:57,390
Si las cantidades de billetes son muy grandes, la diferencia en tiempo de proceso y en ejecución es enorme.

308
00:31:57,950 --> 00:32:00,589
Entonces, eso es lo que diferencia a un buen programador de un mal programador.

309
00:32:00,690 --> 00:32:04,869
Un tío que piensa de la forma correcta de un tipo que no piensa de la forma correcta.

310
00:32:04,869 --> 00:32:08,009
Bueno, pues hasta aquí está el ejemplo.

311
00:32:09,930 --> 00:32:12,950
Y entonces, ¿ahora qué vamos a hacer?

312
00:32:12,950 --> 00:32:31,410
Bueno, pues ahora lo que vamos a hacer es intentar ver ese ejemplo que he puesto con PSINT, ¿vale? Entonces voy a ir al programa de PSINT y voy a intentar programar un algoritmo que con esas condiciones que hemos dicho me resuelva el problema.

313
00:32:31,410 --> 00:32:56,990
Bien, pues vamos a ello. Voy a arrancar el programa y os lo comparto. Aquí tenemos el programita PSINT y vamos a resolver el problema que hemos visto.

314
00:32:56,990 --> 00:33:25,920
Ya muy rapidito vamos a coger y vamos a poner aquí reparto de monedas o billetes, le vamos a llamar billetes al algoritmo y lo primero que tenemos que hacer es hacer un bucle que me pida la cantidad de dinero y ese bucle termine cuando la cantidad de dinero sea mayor que 0 estrictamente

315
00:33:25,920 --> 00:33:31,720
Y además, cuando la orden trunc de la cantidad entre 10 sea igual a la cantidad entre 10.

316
00:33:32,460 --> 00:33:37,019
Bien, pues entonces vamos al bucle mientras, que es el bucle que se va a ejecutar,

317
00:33:37,019 --> 00:33:44,079
no, perdón, el bucle repetir hasta, que es el bucle que se va a ejecutar hasta que suceda una expresión.

318
00:33:44,279 --> 00:33:49,299
Este repetir hasta que, si os fijáis, la comprobación, que es el rombito, se hace al final,

319
00:33:49,440 --> 00:33:52,619
con lo cual se va a ejecutar al menos una vez, y esto es la gracia que tiene,

320
00:33:53,039 --> 00:33:55,799
porque yo al menos le tengo que preguntar una vez al usuario la cantidad.

321
00:33:55,920 --> 00:34:11,460
Vamos a escribir por pantalla, ya sabéis que las expresiones que yo pongo para escribir textos literales son entre comillas y le pongo introduce la cantidad de dinero a repartir, ¿de acuerdo?

322
00:34:11,460 --> 00:34:30,670
Dos puntos. Y ahora, ¿qué voy a hacer? Pues después de pedirle al usuario algo concreto, vamos a leer por pantalla el dato que me meta el usuario y ese dato lo que voy a hacer es meterlo en la variable, habíamos dicho que le llamábamos cantidad, ¿de acuerdo?

323
00:34:30,670 --> 00:34:37,289
entonces cantidad me representa la cantidad total de dinero que tengo que repartir perfecto hasta

324
00:34:37,289 --> 00:34:41,989
cuando vamos a repetir esto bueno aquí viene la gracia hasta que sucedan dos cosas que tenemos

325
00:34:41,989 --> 00:34:47,429
que hacer una cosa y la otra por lo tanto primero vamos a ponerle una y un operador lógico aquí a la

326
00:34:47,429 --> 00:34:53,909
izquierda si no nos aparece lo tenéis en operadores y funciones tenéis una columna con la y lógica

327
00:34:53,909 --> 00:35:11,239
Entonces, tenemos que hacer, perdón, ¿hasta cuándo? Hasta que, primero habíamos dicho que cantidad sea estrictamente mayor que cero.

328
00:35:11,239 --> 00:35:35,099
Por lo tanto, hasta que, voy a abrir paréntesis, cantidad sea mayor que cero, cierro paréntesis, y lo segundo que tiene que suceder que es, me voy a las funciones matemáticas y aquí veis que tengo el redondear y el truncar.

329
00:35:35,099 --> 00:35:55,340
Pues cojo el truncar, no, era el redondear el que iba a utilizar, vale, pues utilizamos el redondear. Redondear cantidad entre 10 sea exactamente igual a cantidad entre 10 y cierro los dos paréntesis.

330
00:35:55,340 --> 00:36:15,849
Fijaros que estoy diciendo hasta que cantidad sea mayor que cero y donde está aquí el i que se me ha perdido, no se me ha puesto con él, i, vale, i, ah, vale, no, no, perdonad, es que esto es, es que el i funciona de otra forma.

331
00:36:15,849 --> 00:36:25,110
fijaros aquí me dice que y lleva entre paréntesis una lista de variables vale entonces esto funciona así

332
00:36:26,849 --> 00:36:36,090
y d eso y eso vale entonces yo creo que así es cómo va a funcionar faltan operando antes de él

333
00:36:36,090 --> 00:36:42,550
y no estaba bien así vale bien entonces bueno hasta cuando hasta que la cantidad le vamos a

334
00:36:42,550 --> 00:36:46,929
comprobar si esto funciona para comprobar si esto funciona me hago un subprograma simplemente

335
00:36:46,929 --> 00:36:56,909
le voy a poner aquí escribir cantidad correcta vale y aquí ya puedo comprobar si la primera

336
00:36:56,909 --> 00:37:03,269
parte del bucle es correcto vale voy a ejecutarlo ejecutamos y me dice e introduce la cantidad de

337
00:37:03,269 --> 00:37:10,409
dinero a repartir le voy a poner 67 que no es divisible por 10 me vuelve a preguntar 32 me

338
00:37:10,409 --> 00:37:17,670
vuelve a preguntar 89 ahora le voy a poner un múltiplo de 10 130 cantidad correcta perfecto

339
00:37:17,670 --> 00:37:26,349
vamos a volver a ponerle cosas que no valen menos 13 me lo que re pregunta y cero me lo pregunta

340
00:37:26,349 --> 00:37:31,369
con lo cual funciona perfectamente números negativos no los admite no me admite un cero

341
00:37:31,369 --> 00:37:37,730
y simplemente números positivos los admite pero no cuando son múltiplo cuando no son múltiplos

342
00:37:37,730 --> 00:37:45,190
Si pongo 1300, que es múltiplo de 10, pues cantidad correcta. Perfecto. El filtro funciona perfectamente, puedo seguir programando.

343
00:37:45,389 --> 00:37:54,030
Me quito esto y continuamos. Por lo tanto, fijaros, ¿qué es lo que he hecho? Pues primero, hacer el bucle que habíamos dicho

344
00:37:54,030 --> 00:38:01,489
hasta que sucedan las condiciones que yo le pedía que se cumplieran, que era que la cantidad sea estrictamente mayor que 0,

345
00:38:01,489 --> 00:38:07,590
con lo cual incluyo con una sola orden las dos condiciones que habíamos dicho, que sea distinto de 0 y que no sea negativo,

346
00:38:07,730 --> 00:38:13,389
y además lo que habíamos utilizado para ver si la cantidad era divisible por 10,

347
00:38:13,690 --> 00:38:17,630
que el redondeo de la división sea igual a la división sin redondear,

348
00:38:17,730 --> 00:38:19,289
con lo cual eso quiere decir que no hay decimales.

349
00:38:19,650 --> 00:38:22,230
Perfecto. Ahora, ¿qué tengo?

350
00:38:22,369 --> 00:38:26,010
Tengo tres variables, tengo cuatro variables que aún no he utilizado.

351
00:38:26,369 --> 00:38:28,829
Esas cuatro variables tengo que darles un valor inicial.

352
00:38:29,610 --> 00:38:32,650
Los billetes de 50 que tengo al principio son cero,

353
00:38:32,650 --> 00:38:36,650
para que cuando yo les vaya sumando, sumen desde el número correcto.

354
00:38:36,650 --> 00:38:50,070
Vamos a asignar, que se hace con la asignación, a B50 le voy a asignar 0 euros.

355
00:38:51,130 --> 00:38:59,489
Vamos a asignar, que lo tenemos aquí a la derecha, a los billetes de 20, 0 euros.

356
00:38:59,489 --> 00:39:26,030
A los billetes de 10 les voy a asignar 0 euros y me queda una variable que es la variable que yo voy a utilizar para ir almacenando el resto, que inicialmente el resto habíamos visto que era toda la cantidad, no he repartido nada, por lo tanto, resto es cantidad, es lo mismo que cantidad.

357
00:39:26,030 --> 00:39:37,269
Y a partir de ahora empezamos a hacer el reparto. Vale, pues voy a hacer el reparto por bucles, ¿vale? Mal programado por mi parte, pero lo voy a hacer. Me quedan tres minutos, así que lo voy a hacer muy rápido.

358
00:39:37,750 --> 00:39:51,969
Entonces, ¿qué voy a hacer? Mientras que la cantidad que me queda dentro del resto sea mayor o igual que 50 euros, ¿vale? ¿Qué tengo que hacer?

359
00:39:52,369 --> 00:39:57,849
Fijaros que ahora utilizo un bucle mientras. ¿Por qué? Porque este bucle mientras, si la cantidad inicial es menor que 50, no va a entrar.

360
00:39:58,550 --> 00:40:06,429
Esto ejecuta al menos una vez los órdenes que están dentro, porque la condición se comprueba al final, pero aquí se comprueba al principio.

361
00:40:06,429 --> 00:40:11,590
Por lo tanto, no entrará si no se cumple. Entonces, ¿qué es lo que tengo que hacer? Pues tengo que hacer dos cosas.

362
00:40:11,590 --> 00:40:27,710
incrementar los billetes de 50 en uno y quitarle 50 euros al resto. Por lo tanto, los billetes de 50 serán lo mismo que tuviera antes, más uno, ¿vale?

363
00:40:27,710 --> 00:40:41,300
En cada vuelta le voy a incrementar uno el número de billetes y al resto de cantidad de dinero le voy a quitar 50 euros. Es decir, por cada billete

364
00:40:41,300 --> 00:40:46,579
que yo incremento quito 50 euros del resto y eso lo voy a repetir hasta que en el resto me queden

365
00:40:46,579 --> 00:40:52,679
menos de 50 por eso mientras que el resto sea mayor que sea igual que 50 hacer esto vale y

366
00:40:52,679 --> 00:40:58,480
ahora cojo esto y es exactamente lo mismo para los billetes de 20 lo voy a copiar y lo voy a

367
00:40:58,480 --> 00:41:08,000
pegar y para los billetes de 10 entonces los billetes de 20 sería billetes de 20 y le quitó

368
00:41:08,000 --> 00:41:18,920
20 y para los de 10 sería la variable de billetes de 10, la que tengo que incrementar y le voy quitando ya de 10 en 10, ¿vale?

369
00:41:19,940 --> 00:41:26,239
Cuando he terminado con estos bucles ya he repartido todo el dinero, como ya he comprobado que era un múltiplo de 10, sé seguro que cuando termine

370
00:41:26,239 --> 00:41:34,340
con este último bucle me quedan 0, no voy a comprobarlo, entonces ahora ¿qué voy a hacer? Simplemente voy a escribir por pantalla, ¿vale?

371
00:41:34,340 --> 00:41:45,440
voy a escribir por pantalla la solución. ¿Qué voy a poner? Voy a poner cantidad, que son el número que me había metido el usuario inicialmente

372
00:41:45,440 --> 00:42:04,579
y luego en texto, euros repartidos en billetes, son dos puntos y pongo la cantidad de billetes de 50, de 50 euros, estoy poniendo el texto,

373
00:42:04,579 --> 00:42:30,679
coma, la cantidad de billetes de 20, de 20 euros, coma, y la cantidad de billetes de 10, estoy concatenando textos, simplemente voy a poner un texto con valores de variables entre medios,

374
00:42:30,679 --> 00:42:43,579
Por eso lo pongo todo seguido. De 10 euros. Perfecto. Vale, pues ya estaría. Mi programa está completo. Vamos a ejecutarlo. Bien, introduce la cantidad de dinero a repartir.

375
00:42:43,739 --> 00:42:53,360
Vamos a meterle 35. Introduce la cantidad de dinero a repartir. Menos 10. Introduce la cantidad de dinero a repartir. Cero. Perfecto. Ninguno vale. Ahora le voy a poner uno válido.

376
00:42:53,360 --> 00:43:07,659
130, hace el proceso y me dice que 130 euros repartidos en billetes son 2 de 50, 1 de 20 y 1 de 10, perfecto, pues oye, ha funcionado, me lo ha repartido bien, ha hecho el reparto

377
00:43:07,659 --> 00:43:21,639
y ha utilizado bucles para hacer el reparto, ¿vale? Bien, tengo hecho, para que no, ¿vale? Vamos a abrirlo aquí, tengo hecho la opción mejorada que simplemente lo que hace es

378
00:43:21,639 --> 00:43:34,909
es repetir esto, bueno, hasta que, a ver, número negativo, no, perdonad, perdonad, perdonad, abrir, a ver, billetes, opción 2, este, perdonadme, ¿vale?

379
00:43:35,110 --> 00:43:42,010
Esto es lo mismo, el algoritmo billetes, inicializo las variables, ¿vale? Repito hasta que la cantidad, bueno, aquí no comprobo ni que sea cero

380
00:43:42,010 --> 00:43:49,829
ni que sean números negativos, pero sería igual, poniéndole el i, y luego fijaros que las órdenes me quedan en lugar de bucles, me queda lo que hemos dicho,

381
00:43:49,829 --> 00:44:00,110
dividimos y me quedo con la parte entera, le quitamos al resto la cantidad correspondiente y seguimos, dividimos entre 20, quitamos la cantidad correspondiente

382
00:44:00,110 --> 00:44:09,449
y dividimos entre 10 y me queda lo mismo y funciona perfectamente. Os dejo en el blog los dos ejemplos para que los veáis y los podáis ejecutar y podáis verlos.

383
00:44:09,449 --> 00:44:29,489
Y lo que voy a hacer es plantearos un pequeño reto para que vosotros resolváis. Entonces, en el blog, seguramente esta tarde, os voy a dejar tanto estos dos ejemplos para que los podáis ver, el vídeo lo tenéis, y os voy a colgar unos ejemplos, o sea, un reto para que vosotros lo hagáis.

384
00:44:29,489 --> 00:44:44,389
¿Vale? Preguntas. Venga, que me estoy casi ya pasando de la hora. Preguntas que tengáis. ¿Alguna pregunta? ¿Alguna duda? ¿Alguna cuestión? Manos arriba si queréis que os ponga el micro o por el chat.

385
00:44:44,389 --> 00:44:47,809
me decís si está todo más o menos entendido

386
00:44:47,809 --> 00:44:49,469
os vuelvo a repetir

387
00:44:49,469 --> 00:44:50,090
también os voy

388
00:44:50,090 --> 00:44:52,010
¿obligatorio hacer el algoritmo?

389
00:44:52,090 --> 00:44:54,170
sí, claro, es obligatorio

390
00:44:54,170 --> 00:44:56,090
os voy a poner un reto

391
00:44:56,090 --> 00:44:58,750
me tenéis que mandar por ahí

392
00:44:58,750 --> 00:45:00,090
por

393
00:45:00,090 --> 00:45:02,710
preguntas y respuestas

394
00:45:02,710 --> 00:45:03,670
dice

395
00:45:03,670 --> 00:45:06,090
se entiende, vale

396
00:45:06,090 --> 00:45:08,909
lo que digo, que el reto

397
00:45:08,909 --> 00:45:10,829
lo tenéis que intentar

398
00:45:10,829 --> 00:45:12,789
por lo menos, y los que lo consigáis

399
00:45:12,789 --> 00:45:14,309
va a ser un reto muy sencillito, vale

400
00:45:14,309 --> 00:45:25,869
Va a ser un reto muy sencillito. Voy a intentar inventarme algo. Probablemente sea algo muy parecido a esto que estoy haciendo, pero con monedas o, ¿sabes? O con monedas de otro país. Ya veré.

401
00:45:26,489 --> 00:45:37,130
Pero la cuestión es que intentemos pensar cómo resolver los problemas y analizar un poquito el problema. No os va a llevar mucho tiempo, pero sí quiero que lo intentéis, ¿vale?

402
00:45:37,130 --> 00:45:43,909
entonces os lo voy a dejar en el blog y quiero que me lo respondáis vale por correo de acuerdo

403
00:45:43,909 --> 00:45:52,889
bueno pues nada más os dejo libres para que vayáis a vuestra clase de geografía si queréis cualquier

404
00:45:52,889 --> 00:46:00,889
cosa me tenéis disponible en el correo vale pues nada chicos muchas gracias por estar y nada nos

405
00:46:00,889 --> 00:46:07,789
vemos en la próxima clase que por cierto la próxima clase probablemente no sea este jueves

406
00:46:07,789 --> 00:46:09,710
sino que sea el lunes de la semana que viene, ¿vale?

407
00:46:10,349 --> 00:46:11,409
Pues venga, chao.