Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

2º BCH - TICO II. Pasos para construir un algoritmo con PseInt - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 27 de abril de 2020 por Juan Ramã‼N G.

81 visualizaciones

Clase Virtual en la que se explican los pasos para construir algoritmos y luego pasarlos a Pseudocódigo usando Pse-Int.

Más información Transcripción

Descargar la transcripción

Vale, pues lo dicho, hemos empezado ya la clase y la idea es repasar lo que vimos el otro día. 00:00:01
Utilicé esta presentación que os tengo puesta aquí y en la presentación estuvimos viendo cómo analizar algoritmos. 00:00:09
Estuvimos viendo que teníamos que localizar las variables, las entradas y salidas de los datos, 00:00:17
el análisis del propósito del propio programa, qué procesos y qué decisiones se tomaban 00:00:23
y al final, después de haber analizado todos esos pasos, veíamos ya en la conclusión 00:00:29
qué era lo que hacía el programa. Teníamos que analizar exactamente cuál era el propósito del programa. 00:00:33
Cuando yo, a ver, quiero que entendáis una cosa, porque muchos al analizar los ejercicios que os he puesto 00:00:38
me habéis ido indicando la descripción de cada una de las cajitas. 00:00:44
Entonces, fijaros en una cosa. Cuando yo voy a abrir una puerta, 00:00:49
si quiero construir un algoritmo para abrir una puerta, ¿vale? 00:00:53
Yo diría algo así como, primero, comprobar si la puerta está cerrada. 00:00:56
Si está cerrada, entonces tengo que abrirla. 00:01:01
Y si no está cerrada, simplemente la atravieso y paso, ¿vale? 00:01:03
Porque está abierta. 00:01:07
Entonces, si está cerrada, ¿qué tengo que hacer? 00:01:08
Tengo que buscar en mi bolsillo unas llaves. 00:01:12
Por lo tanto, tengo que meter la mano en el bolsillo, buscar las llaves y sacarlas. 00:01:15
Después, seleccionar la llave correcta. 00:01:21
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. 00:01:23
Si no ha quedado abierta, pues a lo mejor es que me he equivocado de llave. Prueba con otra llave. 00:01:36
Y así hacemos un algoritmo para que podamos pasar la puerta. 00:01:41
Entonces, si os fijáis, yo puedo deciros, ¿cuál es el propósito de este algoritmo? 00:01:45
pues cruzar una puerta entrar a una casa o entrar a una habitación el propósito es una puerta 00:01:48
comprobar si está cerrada o no y pasar vale y abrirla ese es el propósito del algoritmo abrir 00:01:55
la puerta pero yo no puedo deciros cuál es el propósito del algoritmo pues el propósito del 00:02:00
algoritmo es comprobar si la puerta está cerrada y si no está cerrada lo comprobar si tenemos las 00:02:05
llaves en el bolsillo y si tenemos llaves en el bolsillo sacar la llave meter la llave girar la 00:02:11
llave, comprobar si la puerta está abierta, si no, repetir el proceso. Eso no es un propósito en sí. 00:02:16
Tenemos que entender que cuando hablo del propósito tengo que intentar ir un paso de abstracción más 00:02:22
grande, más anterior, y coger la idea general. ¿Qué es lo que ese algoritmo propone resolver? 00:02:27
¿Cuál es el problema con el que yo me encuentro que a través del uso del algoritmo lo resuelvo? 00:02:35
¿Entendéis? Esa es la clave del propósito. Por lo tanto, hasta que no hemos analizado bien qué es lo que 00:02:40
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 00:02:45
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 00:02:52
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 00:02:59
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 00:03:07
llave en la cerradura y girar la llave eso no son los propósitos esas son las acciones entonces 00:03:15
cuando yo describo primero tampoco tengo que describir cada una de las acciones yo si quisiera 00:03:22
describir el algoritmo el algoritmo a nivel general yo lo describiría diciendo llegó a la 00:03:29
puerta compruebo si está abierta si no está abierta la abro y para abrirla tengo que buscar las llaves 00:03:33
introducirlas en la cerradura en la llave correcta y girarla esa sería la descripción de ese algoritmo 00:03:39
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. 00:03:45
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. 00:03:56
Pero no solo eso, sino que es que el meter la mano en el bolsillo supone mover el brazo en dirección al bolsillo, 00:04:07
buscar la abertura del bolsillo, meter la mano dentro del bolsillo de forma que quede la mano dentro del bolsillo. 00:04:14
Todo eso son acciones. Y puedo seguir desgranándolo. 00:04:20
¿Muevo el hombro? ¿Muevo el músculo? 00:04:23
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. 00:04:24
¿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. 00:04:33
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. 00:04:46
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 00:04:56
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. 00:05:07
Entonces, esto supongo que se entiende y simplemente estábamos viendo luego cómo a través de unas plantillas 00:05:14
podíamos analizar los algoritmos. Decíamos que teníamos un algoritmo y vamos a buscarle estas cosas que habíamos dicho, 00:05:28
las variables, entradas y salidas de datos, intentar ver un poco el propósito general con esa información 00:05:36
si lo conocíamos ya, ver qué procesos y decisiones se toman. 00:05:41
Entonces aquí vemos que leemos un número que en principio no sabemos cuál es, 00:05:44
pero sabemos aquí que es un límite, por lo tanto, porque es el que me marca la salida del bucle. 00:05:48
Por lo tanto, nos está preguntando, esto es una pregunta que nos hace al usuario 00:05:53
y es una variable, un dato. 00:05:56
Nos pregunta un dato que luego es el límite de este bucle. 00:05:59
Y en el bucle lo que está haciendo es llevar un contador que está en n, 00:06:02
cada vuelta n se incrementa en 1, con lo cual es un contador de vuelta, 00:06:07
Si empezamos en 0, cuando entramos, entra en 1, cuando entramos en la siguiente vuelta serían 2, 00:06:11
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. 00:06:17
Y lo que hago es, en una variable suma, voy acumulando, es un acumulador, por lo tanto, voy acumulando ese contador, 00:06:22
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, 00:06:30
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. 00:06:38
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. 00:06:52
al final evidentemente me tiene que devolver el resultado por lo tanto me dice cuál es el límite 00:06:59
y cuál es la suma cuál es esa suma y ya tengo el propósito resuelto vale bueno lo mismo hacíamos 00:07:04
con el segundo algoritmo que era calcular el factorial de un número y este factorial pues 00:07:11
teníamos que hacer una comprobación inicial para saber si el factorial de cero es un número especial 00:07:16
con lo cual había que filtrarlo y luego teníamos que si es mayor que cero hacer el algoritmo pero 00:07:21
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, 00:07:26
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? 00:07:35
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. 00:07:42
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. 00:07:47
y además nos permitía ejecutarlo y estuvimos viendo esos ejemplos. Eso es lo que estuvimos haciendo el otro día. 00:08:14
Básicamente analizar los diagramas de flujo y ver cuál era su propósito. Hoy vamos a hacer lo contrario. 00:08:19
Hoy vamos a plantear un problema y vamos a construir nosotros el diagrama de flujo para resolverlo. 00:08:26
Parece más fácil, pero cuando lo quiero construir de la forma correcta para luego llevarlo a un lenguaje de programación 00:08:32
puede no ser tan obvio y por eso es lo que vamos a hacer ahí vale entonces preguntas hasta ahora 00:08:38
preguntas por el chat vale si no hay preguntas compruebo las manos no hay manos levantadas 00:08:45
perfecto pues entonces continuamos qué vamos a ver hoy pues vamos a ver cómo construir 00:08:59
un algoritmo. Y este algoritmo, yo os voy a proponer un algoritmo y lo vamos a construir, ¿vale? 00:09:09
¿Cómo construimos un algoritmo de cero? Entonces, vamos a ver cómo construir este algoritmo. 00:09:22
Vamos a darle, así lo veis en grande, y la idea es, a ver un segundito, supongo que seguís viendo 00:09:28
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, 00:09:38
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 00:09:47
el algoritmo para hacerlo. No va a ser ese ejemplo, va a ser otro un poco diferente. Entonces, vamos a verlo. 00:09:55
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. 00:10:03
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. 00:10:11
y vamos a comprobar si esa cantidad de dinero introducida se puede entregar en billetes de 50, 20 y 10 euros. 00:10:20
Es decir, lo que quiero es cambiar una cantidad de dinero en billetes. 00:10:28
Y ahí tenemos la condición sin necesidad de usar monedas. 00:10:34
Es decir, solamente tiene que ser una cantidad que yo pueda dar en billetes de 50, de 20 o de 10. 00:10:40
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. 00:10:45
¿De acuerdo? Esa es la primera parte del algoritmo. 00:10:55
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. 00:10:58
Y usando el mínimo número de billetes, porque si no sería muy fácil. 00:11:07
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. 00:11:10
No, utilizando el mínimo número de billetes. 00:11:17
¿De acuerdo? 00:11:20
Vale, entonces, ¿qué subproblemas tenemos que resolver? 00:11:21
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? 00:11:26
voy a darle qué subproblemas hay que resolver. Quiero volver a enseñaros el enunciado para que lo penséis, ¿vale? 00:11:37
Y me contestáis por el chat o si levantáis la mano os activo el micro y me lo decís, ¿vale? 00:11:47
Entonces quiero que penséis qué subproblemas hay que resolver. Este es el enunciado. 00:11:52
¿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? 00:11:56
entonces voy a cogerme el chat y los participantes 00:12:03
y si alguno quiere preguntar, este es el momento 00:12:12
quiero que lo penséis, un minuto, os dejo un minuto 00:12:17
quiero que reviséis ese enunciado y me digáis 00:12:20
por aquí me dicen números negativos, efectivamente 00:12:26
un número negativo no es válido, por lo tanto es algo que tengo que filtrar 00:12:31
entonces hay que apuntar en un papel 00:12:35
tenemos que tener en cuenta los números negativos 00:12:39
con lo cual es algo que 00:12:42
si nos lo introduce el usuario tendremos que decirle 00:12:45
no es válido, perfecto, el 0 también 00:12:48
el 0, números negativos 00:12:50
el 0, ¿qué más? 00:12:54
si es un número inferior a 10 00:12:57
o superiores a 10 que no sean 00:13:00
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. 00:13:03
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? 00:13:12
Múltiplos de 10, que es al final números que acaben en 0, ¿vale? Múltiplos de 10. 00:13:21
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. 00:13:25
son que no haya números negativos 00:13:44
que no sea un 0 y que además 00:13:47
el número introducido sea múltiplo de 10 00:13:49
si esas condiciones se cumplen 00:13:51
ya tengo la primera parte resuelta 00:13:53
el número es válido 00:13:55
y lo puedo desgranar en billetes de 50, 20 y 10 00:13:56
¿vale? perfecto 00:14:00
¿qué más problemas 00:14:01
tengo que resolver? 00:14:03
ahora ya tengo resuelto 00:14:06
la entrada, la entrada ya es válida 00:14:07
ya me ha asegurado de que en la cantidad 00:14:09
que ha introducido el usuario es una cantidad válida 00:14:11
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? 00:14:13
¿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. 00:14:32
pero eso no me usa el mínimo número de billetes entonces que números no más grandes que 5 no 00:14:46
entiendo maría más grandes que 50 querías decir no pero sí que pueden ser más si es más grandes 00:14:55
que 50 si pueden ser más grandes que 50 si yo tengo 200 euros te doy cuatro billetes de 50 00:15:06
vale o sea que eso no es pero la idea es que al hacer el reparto usemos el mínimo número de 00:15:10
billetes. Bueno, la solución para esto, probamos a dividir entre el número más grande primero y 00:15:18
yendo a menos, eso sí, ¿vale? David, la cuestión es coger y hacer el reparto desde los billetes más 00:15:25
grandes hacia los billetes más pequeños. Yo voy dando billetes grandes hasta que ya no me cabe, 00:15:31
es decir, hasta que tengo menos de 50 euros y cuando tenga menos de 50 euros paso a dar billetes 00:15:40
de 20 y doy billetes de 20 hasta que tenga menos de 20 euros y cuando tenga menos de 20 euros 00:15:45
entonces doy billetes de 10, ¿de acuerdo? Esa sería la idea. Entonces repartimos de más a menos, por lo 00:15:52
tanto, fijaros, el reparto de más a menos lo que me resuelve ya es el problema, ya he desgranado mi 00:16:01
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 00:16:09
que yo puedo resolver de una forma más sencilla. He subdividido este algoritmo en sus subproblemas. Por lo tanto, tenemos dos subproblemas 00:16:18
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 00:16:28
se nos ocurre, ¿vale? Haciendo lo que hemos dicho. Pues viendo que no hay números negativos, 00:16:36
viendo que la cantidad no es cero y luego, ¿vale? Usando las matemáticas, tiene que ser múltiplo de 10. 00:16:42
Pero ¿cómo hacemos usando matemáticas? ¿Cómo comprobamos usando las matemáticas que un número es múltiplo de 10? 00:16:50
Vuelvo a preguntaros. Venga, vamos a darle una pequeña vuelta a ver si conseguimos encontrar la clave. 00:16:57
Alguien que me conteste por el chat o que me levante la mano 00:17:02
Fijaros que lo que estamos haciendo simplemente es analizar el problema 00:17:06
Estoy analizando el problema 00:17:13
Estoy viendo simplemente qué problema tengo y cómo lo puedo resolver 00:17:15
Pero lo estoy analizando de una forma muy analítica 00:17:19
Muy desgranando el problema 00:17:22
¿Vale? Venga, cómo a través de las matemáticas 00:17:24
Que es lo que usan los ordenadores 00:17:27
Un ordenador solamente hace cuentas matemáticas 00:17:28
Solo hace comprobaciones matemáticas 00:17:30
Entonces, ¿cómo haríamos? ¿Cómo comprobaríamos que un número es múltiplo de 10? 00:17:32
¿Se os ocurre algo? Bueno, veo que no se os ocurre nada, os lo resuelvo. 00:17:41
La idea sería dividir el número por 10 y comprobar, claro, que sea un número entero, efectivamente. 00:17:47
Entonces, ¿cómo lo haríamos? Dividir entre 10 y comprobar que no tiene decimales. 00:17:57
Comprobar que el número es un número entero. 00:18:01
Entonces, hay formas, hay comandos, órdenes matemáticas que podemos utilizar en los lenguajes de programación que podemos utilizar, ¿vale? 00:18:03
Por ejemplo, suele haber una orden que se llama int, que me da la parte entera de una división, ¿de acuerdo? 00:18:15
También en otros lenguajes de programación ese mismo orden se llama trunk, ¿vale? 00:18:24
de truncar. Lo que haces es cogerte la división y te quedas con el trozo de la parte entera y quito 00:18:28
los decimales. ¿Cómo hacemos entonces la comprobación? Pues simplemente cojo la división entre 10, su parte 00:18:35
entera y compruebo si eso es igual a la división sin calcular su parte entera. Si cogiendo la parte 00:18:43
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 00:18:51
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, 00:19:04
vale la solución utilizando los comandos que yo puedo utilizar es o round o trunk o in round lo 00:19:14
que hace es redondear al entero más cercano vale entonces hay órdenes en los lenguajes de 00:19:23
programación que eso lo cuando estudiéis programación en algún lenguaje ya los irán 00:19:29
diciendo las órdenes que existen pero todos los lenguajes de programación tienen una forma una 00:19:34
función que me permite redondear al entero más cercano o truncar el número de decimales que no 00:19:40
es lo mismo vale 6 con 7 si yo lo trunco me quedaría 6 si yo lo redondeo al entero más 00:19:46
cercano me quedaría 7 vale pero en cualquier caso 6 con 7 que sería 67 entre 10 no me va a quedar 00:19:53
nunca igual ni a trunk ni a round ni a int vale ni a ninguna de las órdenes que me quita los 00:20:00
decimales, tanto sea redondeando como truncando, ¿de acuerdo? En este caso yo he utilizado round, ¿vale? 00:20:06
Pero podríamos utilizar también trunco. Bien, entonces, si la cantidad entre 10 no nos da decimales es correcta, esa es la clave 00:20:11
para programar, ¿vale? Encontrar de qué forma yo puedo resolver mi problema dándole una pequeña vuelta. 00:20:18
Entonces, ¿qué vamos a hacer? Pues vamos a construir un bucle, ya empezamos a pensar en nuestro programa, en nuestro 00:20:26
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 00:20:32
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 00:20:46
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 00:20:57
sea igual a la cantidad por 10. Esas dos son las condiciones que hay que cumplir 00:21:27
y hay que cumplirlas a la vez con un i. ¿Vale? Luego veremos cómo lo hacemos. 00:21:31
Entonces, esta es la primera parte y ya tenemos prácticamente nuestro algoritmo 00:21:36
construido para esa parte. ¿Vale? Vamos a continuar. 00:21:40
Vamos al segundo problema. ¿Cómo usarías el mínimo número de billetes 00:21:47
sabiendo que se pueden usar los de 50? Bueno, pues en este caso ya lo hemos visto. 00:21:51
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. 00:21:55
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, 00:22:06
para luego poder hacer las comprobaciones, eso es una variable donde yo almaceno ese valor, ¿de acuerdo? Esto está claro. 00:22:20
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 00:22:26
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 00:22:35
de otra forma, yo necesito saber cuánto dinero ya tengo repartido en billetes de 50 para repartir el resto en billetes de 20. 00:22:46
Entonces necesito una variable que me almacene lo que me va quedando de dinero. Una variable, la anterior cantidad, es la que me almacena 00:22:53
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, 00:23:00
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. 00:23:10
Cuando resto quede con cero, quiere decir que he repartido todo el dinero, no me queda nada por repartir, ¿vale? 00:23:19
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. 00:23:24
¿Y cómo resolveríamos esto? Usando las matemáticas, ¿vale? 00:23:34
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? 00:23:37
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. 00:23:59
No hay una solución única. Muchas veces en programación hay soluciones múltiples para un mismo problema. 00:24:16
Es decir, no necesariamente todos los programadores van a programar exactamente lo mismo. 00:24:23
y yo de hecho aquí os voy a dar dos opciones, una mejor, otra peor, pero os voy a dar dos opciones 00:24:28
y las dos funcionan perfectamente, veo que no hay ideas con lo cual avanzamos y os las cuento yo 00:24:33
la opción 1 sería haciendo un bucle, un bucle en el que cada vuelta sumemos 1 a la cantidad de billetes correspondiente 00:24:39
y quitemos el valor de ese billete del resto que me queda, es decir, yo hago un bucle 00:24:50
A ver, dividiendo la cantidad entre 50, solo tener los números enteros, quitando los decimales, luego los de 20 y los de 10. 00:24:54
Vale, Daniel, efectivamente, esa es una de las posibles opciones, esa es lo que yo he llamado la opción 2, ¿vale? 00:25:01
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. 00:25:06
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? 00:25:11
un billete de 50, sumo 1 a los billetes de 50 y le resto 50 al resto que me queda y repito ese bucle. 00:25:18
¿Hasta cuándo repito el bucle? Hasta que la cantidad que yo tenga en resto sea menor que 50. 00:25:27
Cuando la cantidad sea menor que 50 paso a repartirlos de 20, con lo cual sumo 1 a los billetes de 20 00:25:33
y resto 20 de la cantidad que me queda. Y a ese bucle de los billetes de 20 lo voy a repetir 00:25:39
hasta que en el resto me queden menos de 20 euros, porque si me quedan más, 00:25:46
podré dar otro billete de 20, entonces hasta que el resto me queden por debajo de 20 euros. 00:25:50
Y el último, es el de 10, pues será lo mismo, sumo 1 a los billetes de 10 00:25:55
y cada vez que sume 1 a los billetes de 10, tengo que restarle 10 euros al resto 00:26:00
hasta que me quede 0, ¿vale? Entonces, ¿veis que esto es una solución posible 00:26:04
a través de bucles? Yo hago un proceso repetitivo, es como el cuento de la vieja, 00:26:10
¿no? el cuento de la vieja es 00:26:14
cada oveja que saco del corral 00:26:16
pongo la mano y me das el dinero 00:26:19
que vale, y saco otra oveja 00:26:21
y me das el dinero que vale, y saco otra oveja 00:26:22
y me das el dinero que vale, cada vez que saco 00:26:24
una oveja tú me das el dinero, así no me equivoco 00:26:27
ese era el cuento de la vieja 00:26:29
¿vale? pues hacemos lo mismo, yo 00:26:30
te doy un billete de 50 y te quito 50 del resto 00:26:32
te doy otro de 50 y te 00:26:35
quito 50 del resto, ¿hasta cuándo? hasta que 00:26:36
no te pueda dar más billetes de 50 porque 00:26:38
en el resto no me quedan 50 euros, me quedan menos 00:26:40
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, 00:26:43
no el redondeo que utilicé antes, que antes podía utilizar el redondeo, ahora no, ahora utilizamos solo la parte entera, 00:26:52
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 00:26:58
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 00:27:06
dividido entre el valor del billete que estoy repartiendo. Tendré que hacer esto tres veces con los billetes de mayor a menor. 00:27:15
Por lo tanto, billetes de 50 será trunk de la cantidad dividida por 50. Aquí es un poco más complicado calcular el resto. 00:27:21
vale no es tan complicado si lo pensamos si yo tengo una cantidad y ya he dado todos los billetes 00:27:30
de 50 que puedo a través de esta orden entonces que tengo que hacer restarle a la cantidad los 00:27:37
billetes de 50 multiplicados por 50 euros si cada billete que yo he entregado son 50 euros 00:27:44
yo al restarle si por ejemplo me salen cuatro billetes de 50 pues le tengo que restar 50 por 00:27:49
4 que son 200 euros a la cantidad del resto de los 200 euros que ha repartido en billetes de 50 00:27:56
y me queda en el resto siempre me va a quedar una cantidad menor que 50 porque si os fijáis lo que 00:28:02
me va a quedar va a ser la cantidad correspondiente a los decimales de esta división siempre va a ser 00:28:08
menor que un billete de 50 vale entendéis hasta aquí las dos opciones de cómo hacemos el reparto 00:28:14
de billetes respuestas por el chat por favor hay alguna duda o se entiende hola hola queda 00:28:20
alguien en clase se entiende vale gracias también vale cuando pregunto si se entiende 00:28:35
despertaros y decir que sí por lo menos ahora bien entonces resumiendo vale resumiendo tenemos 00:28:42
que usar cinco variables, cantidad para la cantidad que nos introduce el usuario, resto para la que me 00:28:55
queda después de mitad del proceso según voy repartiendo y luego b50 que son billetes de 50, 00:29:02
b20 que son billetes de 20 y b10 que son billetes de 10. Vamos a comprobar que la cantidad introducida 00:29:08
es correcta usando el comando round de cantidad entre 10 igual a cantidad entre 10, además de 00:29:13
decir que sea estrictamente mayor que 0 para eliminar los dos casos que hemos visto que me 00:29:19
producirían un error. Números negativos y por otro lado el cero. Y después vamos a asignar el número de billetes 00:29:24
en sus respectivas variables usando una de dos opciones o un bucle que vaya repartiendo cada billete 00:29:32
o el comando trunk de la cantidad que me queda dividida por el valor del billete para cada uno de los tres billetes. 00:29:38
Tres bucles o tres trunk. Eso es el resumen. Pues en este punto ya puedo construir mi algoritmo. 00:29:46
fijaros todo lo que he tenido que pensar previamente para poder construir un algoritmo 00:29:53
yo tengo un problema y tengo que desgranar el problema en problemas más sencillos 00:29:58
problemas tan sencillos que sea capaz de programarlos con un lenguaje que tiene cosas 00:30:04
que son simplemente sumas, restas, multiplicaciones, divisiones, parte entera de algo 00:30:10
el AND, el OR, el NOT 00:30:15
lógico y cuatro comandos 00:30:18
de un SI, un MIENTRAS 00:30:20
un ASTA 00:30:22
bucles y condiciones 00:30:23
y eso es todo lo que tienen los lenguajes de programación 00:30:26
al final un lenguaje de programación 00:30:28
no tiene más que unas decenas 00:30:29
de órdenes 00:30:32
podemos hablar, es como un idioma 00:30:33
que yo necesito hablarlo 00:30:35
con 10 o 15 palabras 00:30:37
¿vale? pues eso es un lenguaje 00:30:39
de programación, son más pero bueno 00:30:42
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. 00:30:44
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 00:31:01
que yo las pueda meter con esas pocas opciones que me dan los lenguajes de programación. 00:31:12
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. 00:31:18
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. 00:31:26
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. 00:31:37
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. 00:31:43
Si las cantidades de billetes son muy grandes, la diferencia en tiempo de proceso y en ejecución es enorme. 00:31:51
Entonces, eso es lo que diferencia a un buen programador de un mal programador. 00:31:57
Un tío que piensa de la forma correcta de un tipo que no piensa de la forma correcta. 00:32:00
Bueno, pues hasta aquí está el ejemplo. 00:32:04
Y entonces, ¿ahora qué vamos a hacer? 00:32:09
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. 00:32:12
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. 00:32:31
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 00:32:56
Y además, cuando la orden trunc de la cantidad entre 10 sea igual a la cantidad entre 10. 00:33:25
Bien, pues entonces vamos al bucle mientras, que es el bucle que se va a ejecutar, 00:33:32
no, perdón, el bucle repetir hasta, que es el bucle que se va a ejecutar hasta que suceda una expresión. 00:33:37
Este repetir hasta que, si os fijáis, la comprobación, que es el rombito, se hace al final, 00:33:44
con lo cual se va a ejecutar al menos una vez, y esto es la gracia que tiene, 00:33:49
porque yo al menos le tengo que preguntar una vez al usuario la cantidad. 00:33:53
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? 00:33:55
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? 00:34:11
entonces cantidad me representa la cantidad total de dinero que tengo que repartir perfecto hasta 00:34:30
cuando vamos a repetir esto bueno aquí viene la gracia hasta que sucedan dos cosas que tenemos 00:34:37
que hacer una cosa y la otra por lo tanto primero vamos a ponerle una y un operador lógico aquí a la 00:34:41
izquierda si no nos aparece lo tenéis en operadores y funciones tenéis una columna con la y lógica 00:34:47
Entonces, tenemos que hacer, perdón, ¿hasta cuándo? Hasta que, primero habíamos dicho que cantidad sea estrictamente mayor que cero. 00:34:53
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. 00:35:11
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. 00:35:35
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. 00:35:55
fijaros aquí me dice que y lleva entre paréntesis una lista de variables vale entonces esto funciona así 00:36:15
y d eso y eso vale entonces yo creo que así es cómo va a funcionar faltan operando antes de él 00:36:26
y no estaba bien así vale bien entonces bueno hasta cuando hasta que la cantidad le vamos a 00:36:36
comprobar si esto funciona para comprobar si esto funciona me hago un subprograma simplemente 00:36:42
le voy a poner aquí escribir cantidad correcta vale y aquí ya puedo comprobar si la primera 00:36:46
parte del bucle es correcto vale voy a ejecutarlo ejecutamos y me dice e introduce la cantidad de 00:36:56
dinero a repartir le voy a poner 67 que no es divisible por 10 me vuelve a preguntar 32 me 00:37:03
vuelve a preguntar 89 ahora le voy a poner un múltiplo de 10 130 cantidad correcta perfecto 00:37:10
vamos a volver a ponerle cosas que no valen menos 13 me lo que re pregunta y cero me lo pregunta 00:37:17
con lo cual funciona perfectamente números negativos no los admite no me admite un cero 00:37:26
y simplemente números positivos los admite pero no cuando son múltiplo cuando no son múltiplos 00:37:31
Si pongo 1300, que es múltiplo de 10, pues cantidad correcta. Perfecto. El filtro funciona perfectamente, puedo seguir programando. 00:37:37
Me quito esto y continuamos. Por lo tanto, fijaros, ¿qué es lo que he hecho? Pues primero, hacer el bucle que habíamos dicho 00:37:45
hasta que sucedan las condiciones que yo le pedía que se cumplieran, que era que la cantidad sea estrictamente mayor que 0, 00:37:54
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, 00:38:01
y además lo que habíamos utilizado para ver si la cantidad era divisible por 10, 00:38:07
que el redondeo de la división sea igual a la división sin redondear, 00:38:13
con lo cual eso quiere decir que no hay decimales. 00:38:17
Perfecto. Ahora, ¿qué tengo? 00:38:19
Tengo tres variables, tengo cuatro variables que aún no he utilizado. 00:38:22
Esas cuatro variables tengo que darles un valor inicial. 00:38:26
Los billetes de 50 que tengo al principio son cero, 00:38:29
para que cuando yo les vaya sumando, sumen desde el número correcto. 00:38:32
Vamos a asignar, que se hace con la asignación, a B50 le voy a asignar 0 euros. 00:38:36
Vamos a asignar, que lo tenemos aquí a la derecha, a los billetes de 20, 0 euros. 00:38:51
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. 00:38:59
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. 00:39:26
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? 00:39:37
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. 00:39:52
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. 00:39:58
Por lo tanto, no entrará si no se cumple. Entonces, ¿qué es lo que tengo que hacer? Pues tengo que hacer dos cosas. 00:40:06
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? 00:40:11
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 00:40:27
que yo incremento quito 50 euros del resto y eso lo voy a repetir hasta que en el resto me queden 00:40:41
menos de 50 por eso mientras que el resto sea mayor que sea igual que 50 hacer esto vale y 00:40:46
ahora cojo esto y es exactamente lo mismo para los billetes de 20 lo voy a copiar y lo voy a 00:40:52
pegar y para los billetes de 10 entonces los billetes de 20 sería billetes de 20 y le quitó 00:40:58
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? 00:41:08
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 00:41:19
con este último bucle me quedan 0, no voy a comprobarlo, entonces ahora ¿qué voy a hacer? Simplemente voy a escribir por pantalla, ¿vale? 00:41:26
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 00:41:34
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, 00:41:45
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, 00:42:04
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. 00:42:30
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. 00:42:43
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 00:42:53
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 00:43:07
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? 00:43:21
Esto es lo mismo, el algoritmo billetes, inicializo las variables, ¿vale? Repito hasta que la cantidad, bueno, aquí no comprobo ni que sea cero 00:43:35
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, 00:43:42
dividimos y me quedo con la parte entera, le quitamos al resto la cantidad correspondiente y seguimos, dividimos entre 20, quitamos la cantidad correspondiente 00:43:49
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. 00:44:00
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. 00:44:09
¿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. 00:44:29
me decís si está todo más o menos entendido 00:44:44
os vuelvo a repetir 00:44:47
también os voy 00:44:49
¿obligatorio hacer el algoritmo? 00:44:50
sí, claro, es obligatorio 00:44:52
os voy a poner un reto 00:44:54
me tenéis que mandar por ahí 00:44:56
por 00:44:58
preguntas y respuestas 00:45:00
dice 00:45:02
se entiende, vale 00:45:03
lo que digo, que el reto 00:45:06
lo tenéis que intentar 00:45:08
por lo menos, y los que lo consigáis 00:45:10
va a ser un reto muy sencillito, vale 00:45:12
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é. 00:45:14
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? 00:45:26
entonces os lo voy a dejar en el blog y quiero que me lo respondáis vale por correo de acuerdo 00:45:37
bueno pues nada más os dejo libres para que vayáis a vuestra clase de geografía si queréis cualquier 00:45:43
cosa me tenéis disponible en el correo vale pues nada chicos muchas gracias por estar y nada nos 00:45:52
vemos en la próxima clase que por cierto la próxima clase probablemente no sea este jueves 00:46:00
sino que sea el lunes de la semana que viene, ¿vale? 00:46:07
Pues venga, chao. 00:46:10
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Materias:
Tecnologías de la Información
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Educación Secundaria Obligatoria
    • Ordinaria
      • Primer Ciclo
        • Primer Curso
        • Segundo Curso
      • Segundo Ciclo
        • Tercer Curso
        • Cuarto Curso
        • Diversificacion Curricular 1
        • Diversificacion Curricular 2
  • Bachillerato
    • Primer Curso
    • Segundo Curso
Autor/es:
JUAN RAMÓN GARCÍA MONTES
Subido por:
Juan Ramã‼N G.
Licencia:
Reconocimiento - No comercial - Sin obra derivada
Visualizaciones:
81
Fecha:
27 de abril de 2020 - 20:49
Visibilidad:
Público
Centro:
IES ANTONIO GAUDI
Duración:
46′ 16″
Relación de aspecto:
1.78:1
Resolución:
1866x1050 píxeles
Tamaño:
183.81 MBytes

Del mismo autor…

Ver más del mismo autor

Comentarios

Para publicar comentarios debes entrar con tu nombre de usuario de EducaMadrid.

Comentarios

Este vídeo todavía no tiene comentarios. Sé el primero en comentar.


EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid