Saltar navegación

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

2º BCH - TICO II. Análisis y ejecución de organigramas. - 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 14 de abril de 2020 por Juan Ramã‼N G.

127 visualizaciones

Clase Virtual impartida a los alumnos de 2º de Bachillerato explicando cómo se deben analizar los organigramas y cómo usar PseInt para poder escribir un algoritmo en pseudocódigo, ver su diagrama de flujo e incluso poder ejecutarlo.

Más información Capítulos Transcripción

Análisis de Organigramas o Diagramas de Flujo. 00:00:00
Organigramas para Robótica 00:26:53
Pseudocode Interpreter (PseInt) 00:33:37
Canal de YouTube de Juanra Garcia (@tecnojuanra777) 00:56:36

Descargar la transcripción

Muy bien, vale, pues ya está grabando. Pues nada, vamos a empezar un poquito con la clase. 00:00:00
En principio voy a compartiros mi escritorio, me veréis en una esquinita y veréis también mi pantalla o a lo mejor dejáis de verme a mí, no estoy muy seguro. 00:00:08
A ver, comparto aquí, vale, ahí estamos. 00:00:17
Entonces, ahora me veis ahí en una esquina seguramente 00:00:21
Yo voy a abrirme por aquí el chat para asegurarme y los participantes 00:00:25
Para asegurarme que os veo y que... lo que pasa es que me ocupa pantalla 00:00:31
Entonces no... no... vale, no me gusta tenerlo mucho 00:00:34
Bien, y quiero empezar un poquito viendo esto, los organigramas 00:00:39
¿Vale? Hemos empezado viendo los organigramas 00:00:47
Bueno, un organigrama, para poderlo analizar y poderlo analizar de una forma conveniente, lo mejor es hacer una... 00:00:49
Vale, perfecto. Pues nada, en principio, los organigramas, los tengo aquí, ¿vale? Estos son los organigramas, el B y el A. 00:01:00
se han de analizar primero cuando nos enfrentamos a un organigrama 00:01:13
que no sabemos qué es lo que nos está haciendo 00:01:19
tenemos que intentar ver qué cosas entran y qué cosas salen 00:01:22
yo para analizar los organigramas os recomiendo que sobre todo al principio 00:01:26
yo estas cosas pues como las he hecho muchas veces las hago ya casi mentalmente 00:01:30
las hago sobre la marcha un poco 00:01:34
pero lo que os recomiendo es que utilicéis una plantilla 00:01:36
una plantilla como esta que os enseño aquí a la derecha 00:01:39
Voy a cerrarme aquí estas cositas. 00:01:43
Voy a cerrar el chat, ¿vale? 00:01:45
Luego, si me levantáis la mano, no os voy a ver. 00:01:46
Entonces, luego, cuando termine de hablar, 00:01:49
yo miro a ver quién quiere decir algo. 00:01:51
Pero vosotros, si tenéis alguna pregunta, 00:01:53
poned la mano arriba, ¿vale? 00:01:54
Bien. 00:01:56
Entonces, hay unas plantillas que yo me gusta utilizar, ¿vale? 00:01:57
Esta es una plantillita que me he hecho en un segundín, ¿vale? 00:02:01
Pero podéis hacerlas como más os guste. 00:02:04
Entonces, en las plantillas tenemos las entradas, 00:02:06
las salidas y las variables, ¿de acuerdo? 00:02:08
Entonces, vamos a analizar, por ejemplo, este algoritmo y vamos a ver un poco cómo vemos que hace. 00:02:11
Lo primero es ver las entradas y las salidas, que son las lecturas y las escrituras, 00:02:17
y también dónde empieza y dónde acaba el algoritmo, porque tengo que ver el flujo. 00:02:24
Este es un algoritmo muy sencillo que tiene prácticamente lineal, excepto un pequeño bucle en esta parte. 00:02:27
Entonces, empezamos arrancando con un terminal de inicio y terminamos siempre con un terminal de fin. 00:02:32
suelen ser redondos o redondeados como este. Primero las entradas, ¿vale? Aquí vamos a leer k, 00:02:39
entonces me apunto aquí leer k o pongo k simplemente y luego cuando identifique qué significa ya lo 00:02:47
pondré ahí, ¿vale? Y las salidas en este caso son k y suma, ¿vale? Esas son las salidas que son las 00:02:53
cosas que voy a escribir. Y después ¿qué variables utilizo? Bueno, pues tengo una variable que es k, 00:03:03
que es donde voy a almacenar lo que meco, ¿vale? 00:03:08
Tengo una variable n y una variable suma, que las voy a poner aquí. 00:03:12
n y suma. 00:03:15
Perfecto. 00:03:17
Esto lo podéis hacer con una plantilla o con un papel. 00:03:18
O sea, esto lo hacéis en un momento, ¿vale? 00:03:21
No hace falta que tengáis todo bien estructurado. 00:03:22
Yo lo que pasa es que quiero que lo veáis bien. 00:03:24
Entonces, empezamos leyendo k, ¿perfecto? 00:03:26
Con lo cual k es un número que introduce el usuario. 00:03:30
Vamos a poner un ejemplo. 00:03:33
Vamos a hacer una ejecución simulada, 00:03:34
una ejecución donde nosotros vamos a ir paso a paso viendo qué cosas 00:03:36
va haciendo cada parte del algoritmo. Entonces yo le voy a poner un ejemplo 00:03:40
voy a poner aquí un 4, ¿vale? Yo introduzco 4 00:03:44
entonces aquí en K yo le voy a poner valor 00:03:48
de momento yo sé que esto es un valor introducido por el 00:03:52
usuario. Esto puede ser un sensor de otro bot o puede ser 00:03:56
una toma de datos de algún sitio 00:04:01
o puedo estar leyendo algún archivo, no lo sé. 00:04:04
El caso es que la entrada al algoritmo se hace a través de esa variable k. 00:04:07
Y en la k, en el valor de la variable, voy a almacenar ese valor. 00:04:12
¿Vale? En el contenido de esta caja llamada k voy a meter un 4, 00:04:17
que es el número que yo he metido. 00:04:22
Recordar que en este ejemplo, voy a poner aquí ejemplo 4, ¿vale? 00:04:23
Quiere decirse que yo he metido un 4 en ese valor k. 00:04:29
Perfecto, me ha pedido un número, yo he metido k. 00:04:34
Ahora, siguiente paso, un proceso. 00:04:37
¿Qué hace? 00:04:40
Asigna el valor 0 a n y el valor 0 a suma. 00:04:41
Pues asigna 0 a n y 0 a suma. 00:04:44
Esos son los valores que tienen ahora mismo mis tres variables. 00:04:47
k tiene 4, n tiene 0 y suma tiene. 00:04:49
Seguimos. 00:04:54
Entramos en este bucle, que es un bucle repetir hasta. 00:04:55
Repetir hasta que n sea igual a k. 00:05:00
Entonces, entramos en este bucle y lo siguiente que hacemos es un proceso, ¿qué es lo que hacemos? 00:05:02
Pues bien, la variable n va a tomar el valor de su propio valor más 1, con lo cual en el valor de n, en esta primera vuelta del bucle, n se va a actualizar su valor y se va a poner a 1. 00:05:07
Y la variable suma va a coger su contenido, lo que vale la variable suma, y le va a sumar lo que valga n. 00:05:20
Pues voy a coger suma que es 0 y le voy a sumar 1, con lo cual 0 más 1, 1, y lo voy a almacenar dentro de suma, ¿entendéis esto? 00:05:26
Es decir, el valor de la variable suma es su propio valor anterior más lo que valga n en este momento, 0 más 1, 1, y lo almaceno dentro de suma. 00:05:37
Eso es lo que quiere decir esta orden de aquí. 00:05:51
Y ahora hago la comprobación. 00:05:54
¿Es n igual a k? 00:05:55
n vale 1 en este momento y k vale 4. 00:05:57
No son iguales. 00:05:59
Como no son iguales, repito el bucle. 00:06:00
¿Qué hago? 00:06:03
A la variable n le sumo 1. 00:06:03
¿Veis? 00:06:06
Entonces, este valor n, si os fijáis, va creciendo de 1 en 1. 00:06:07
A cada vuelta del bucle va creciendo de 1 en 1. 00:06:11
Y suma, lo que va a hacer es almacenar ahora su propio valor, 00:06:14
que es 1, que es lo que vale ahora, más lo que vale n en este momento, que es 2, 2 y 1, 3. 00:06:18
Fijaros, lo voy a poner aquí debajo, que en este caso el valor de suma era 0 más 1, ¿vale? 00:06:24
Esto es 0 más 1, que era el valor anterior, más el valor de n, 0 más 1. 00:06:32
Ahora, el valor de suma es el valor anterior, que era 0 más 1, más 2, ¿vale? 0 más 1 más 2, ¿de acuerdo? 00:06:36
Bien, y ahora volvemos a hacer la comprobación, estamos en este punto del programa y volvemos a hacer la comprobación. 00:06:45
¿Es n igual a k? ¿2 es igual a 4? No. 00:06:50
Por lo tanto, volvemos a entrar al núcleo. 00:06:53
Se vuelve a actualizar n, n es igual a n más 1, por lo tanto, 2 más 1, 3. 00:06:56
Suma es igual a su propio valor más lo que valga n, 3 más 3, 6. 00:07:00
Que ahora, si os fijáis, lo que he hecho es 0 más 1 más 2 más 3, le añado el 3. 00:07:05
Y continuamos, ¿vale? 00:07:12
¿3 es igual a 4? No. 00:07:15
Volvemos al bucle. 00:07:17
Estamos saliendo por la salida del no. 00:07:18
Y entonces cojo y digo, 3, le añado 1, 4. 00:07:20
Y a suma le sumo el valor, estoy haciendo este proceso, n igual a n más 1, 00:07:24
y ahora suma, le pongo suma más n, 6 más 4, 10. 00:07:28
Entonces aquí he hecho 0 más 1 más 2 más 3 más 4. 00:07:33
Y ahora compruebo, ¿es n igual a k? 00:07:37
¿4 es igual a 4? Sí. 00:07:39
Por lo tanto, me voy por la salida del sí, 00:07:41
Y en las salidas pongo K, que no ha cambiado en toda la ejecución del programa, vale 4 y sigue valiendo 4 y siempre ha valido 4. 00:07:43
Y la suma, que lo que me devuelve en este caso es 10. 00:07:51
Pero que yo ya he visto que es la suma de todos los números desde 1 hasta... ¿Vale? 00:07:55
Entonces fijaros que yo introduzco un valor, que eso es un valor que pedimos al usuario. 00:08:07
y luego lo que hago es un bucle en el cual voy sumándole 1 acá a n, perdón, en cada vuelta 00:08:13
y voy acumulando dentro de la suma, por lo tanto n es un contador, es el contador de vuelta, 00:08:21
la vuelta 0, la vuelta 1, la vuelta 2, la vuelta 3, la vuelta 4 y suma es un acumulador 00:08:27
que va acumulando ese valor de n. En la primera vuelta acumula 1, en la segunda vuelta acumula 1 más 2, 00:08:32
o sea, va sumando a su propio valor, por eso se llama un acumulador, ¿vale? 00:08:40
Y ya está, entonces ya hemos visto cuál es el algoritmo y cuál es lo que está haciendo, 00:08:45
cuál es su propósito, su propósito es sumarme todos los números desde 0 o desde 1 00:08:51
hasta el número que le meta el usuario, ya está, es una serie, ¿vale? 00:08:56
Si habéis estudiado matemática en las series, las series son sumas de sucesivos elementos. 00:09:01
Bueno, pues ya está, esto sería el análisis de este primer algoritmo 00:09:05
Y es muy fácil con una plantilla de este tipo. 00:09:09
Bueno, voy a abrirlo de la... a ver, por aquí, participantes... 00:09:12
Vale, ¿alguien tiene alguna pregunta sobre esto de momento? 00:09:17
En el chat. 00:09:20
Vale, no veo que nadie haya levantado la mano, no veo que nadie haga preguntas. 00:09:22
Si no, paso al segundo ejemplo. 00:09:25
¿De acuerdo? 00:09:28
Perfecto. 00:09:29
Pues seguimos. 00:09:30
Lo mismo que antes, si tenéis alguna duda en cualquier momento, por favor, levantad la mano. 00:09:31
Segundo ejemplo de algoritmo. 00:09:35
voy a vaciar mi plantilla 00:09:37
¿vale? vaciamos mi plantilla 00:09:39
de datos y volvemos 00:09:42
ahora, bueno en las conclusiones evidentemente 00:09:44
yo aquí abajo tengo una de estas conclusiones 00:09:46
donde escribiría un poco pues ya el resumen 00:09:48
lo que entra, lo que sale, cuál es el propósito 00:09:50
del programa y un poco el funcionamiento 00:09:52
si os fijáis cuando yo quiero 00:09:54
describir el funcionamiento de este algoritmo no me 00:09:56
pongo a describir lo que hace cada caja, eso ya lo veo 00:09:58
¿vale? yo no digo 00:10:00
primero leemos K, luego hacemos n igual a 0 00:10:02
luego suma igual a 0, luego n igual a 00:10:04
Eso ya lo veo. Lo que quiero que me digáis es que este proceso lo que va a hacer es repetir en bucle la suma de estos elementos 00:10:06
y el incremento de la n hasta cuando se haga igual al valor introducido por el usuario. 00:10:15
Entonces primero se lee, luego se inicializan las variables con el valor 0 y después se va incrementando el valor de n 00:10:23
y acumulando ese valor dentro de suma hasta que n es igual a k. 00:10:32
Y cuando n se hace igual a k, salimos y escribimos el número de vueltas que hemos dado, 00:10:38
el número límite o el límite de nuestro bucle y la suma total de esos valores. 00:10:44
Entonces, bueno, pues esto, luego vamos a ver un programita que es súper guay, 00:10:51
que nos permite ver esto de una forma muy visual, ¿vale? 00:10:55
También nos va a ayudar a entenderlo. 00:10:58
Bueno, vamos al segundo. 00:10:59
Entonces, segundo ejemplo, bien, ¿qué entradas tenemos aquí? 00:11:01
Pues tenemos n, solamente metemos n y ya veremos lo que es. 00:11:07
Antes era el límite o el número hasta donde queríamos ir sumando. 00:11:11
¿Vale? ¿Qué variables tenemos en este caso? 00:11:16
Pues tenemos la variable n, nuevamente, y tenemos la variable p y no hay más. 00:11:17
¿Vale? Tenemos la variable p y ya no hay más. 00:11:25
Perfecto. Vamos a ver qué es lo que estamos haciendo. 00:11:27
Pues lo primero que hacemos es leemos n, con lo cual a n le damos el valor del usuario. 00:11:31
Este es un valor introducido por el usuario. 00:11:35
Valor, ya lo he dicho antes, valor, valor introducido por el usuario, ¿vale? 00:11:38
Valor introducido por el usuario. 00:11:46
Y yo le voy a poner un ejemplo, por ejemplo, tres, ¿vale? 00:11:48
Un número cualquiera. 00:11:51
¿Vale? O bueno, voy a poner, para ir cogiendo los valores, voy a ponerle un valor cero, ¿de acuerdo? 00:11:53
empezamos a ejecutar, leemos n y le introducimos el valor 0, el usuario pone el valor 0. 00:11:58
¿Es n igual a 0? Sí. 00:12:06
Bueno, pues entonces escribimos que el factorial de 0 es igual a 1. 00:12:08
Por lo tanto, la salida, si n es igual a 0, la salida es factorial de 0 es 1. 00:12:11
Y ya esto nos da una pista de cuál es el propósito de este programa. 00:12:22
El factorial de 0 es 1. 00:12:26
Lo mismo estamos calculando el factorial de un número. 00:12:28
Hemos estudiado en matemáticas lo que vale el factorial, ¿vale? 00:12:31
Recordamos, os lo escribo aquí, que 5 factorial, que se escribe así con una unidación, 00:12:34
es igual a 5 por 4 por 3 por 2 y por 1, ¿vale? 00:12:39
Es decir, vamos a ir multiplicando desde el número que me dan hasta el 1. 00:12:46
Y esta multiplicación es lo que llamamos 5 factorial. 00:12:54
Pues entonces, ¿qué vamos a hacer nosotros? 00:12:58
Vamos a ver si este programa lo que me calcula son números factoriales. 00:13:01
Pues bueno, si es 0, el factorial de 0 es 1, con lo cual la salida es correcta. 00:13:04
¿Qué pasa si el usuario, cuando empezamos y ya se termina el programa? 00:13:09
Vamos a hacer otra ejecución donde n le voy a poner el valor menos 3, un número negativo. 00:13:12
Bueno, pues si le pongo el valor menos 3, entonces n es igual a 0, no, salgo hacia abajo. 00:13:18
n es mayor que 0, no, aquí esto es un error de la gráfica, esto es una flecha que tendría que tener esta dirección 00:13:23
no esta, no es una vuelta, sino que es una ida, entonces este es uno de los dos errores que tenía este programa 00:13:30
ahora veremos el otro, esta salida es hacia abajo, la flecha tendría que estar indicándome la dirección hacia abajo 00:13:37
escribimos el número negativo y escribimos prueba con positivos, por lo tanto en mis salidas pongo si n es menor que 0 00:13:43
la salida es 00:13:53
número negativo 00:13:57
prueba con positivo. 00:13:59
¿Vale? Ya lo tengo. 00:14:04
Y ahora vamos a ver qué pasa si el número es positivo. 00:14:06
Vamos a probar con el 3. 00:14:09
Entonces, ¿qué pasa si n es igual a 3? 00:14:11
Bueno, primero, ¿n es igual a 0? 00:14:12
Seguimos ejecutando desde el principio siempre. 00:14:14
Leemos n, 3. 00:14:16
¿n es igual a 0? 00:14:18
No, para abajo. 00:14:19
¿n es mayor que 0? 00:14:20
Sí, para abajo. 00:14:21
Inicializamos p y le ponemos el valor 1. 00:14:23
Esto es un valor inicial que yo le meto a p a saco. 00:14:26
p igual a 1. 00:14:30
Inicializo esa variable con su valor. 00:14:31
Y ahora empiezo al bucle, que es un bucle repetirá esta. 00:14:33
Igual que el anterior. 00:14:35
p es igual a p por n. 00:14:37
Bueno, ¿cuánto vale en la primera vuelta? 00:14:38
¿Cuánto vale p? 00:14:41
¿Cuánto vale n? 00:14:42
3 por 1, 3. 00:14:43
Por lo tanto aquí voy a poner un 3. 00:14:44
n es igual a n menos 1. 00:14:47
Con lo cual en la primera vuelta esto será un 2. 00:14:49
Y una vez que hemos terminado de hacer el proceso, 00:14:53
preguntamos, ¿qué es n igual a 1? 00:14:55
Si n es igual a 1, me saldría. 00:14:58
Pero como no lo es, repito el bucle. 00:15:01
Vuelvo a hacer p es igual a p por n. 00:15:04
3 por 2, vale, fijaros que aquí he hecho 00:15:07
1 por 3 00:15:10
para alcanzar el valor de p. 00:15:14
¿Lo veis? 1 por 3, p por n. 00:15:18
En esta segunda vuelta he dicho que voy a hacer p es igual a p por n, 00:15:21
que es 3 por 2, ¿vale? Que es 6. Por lo cual aquí habré hecho 1 por 3 por 2, ¿vale? Y después hago n igual a n menos 1. 00:15:24
Y pregunto, ¿es n igual a 1? Sí. Salgo hacia abajo y escribo, si n es mayor que 0, entonces me pone factorial igual 00:15:37
y me devuelve el valor de p, que en este caso sería 6, ¿vale? 00:15:52
En el caso del ejemplo sería 6. 00:15:56
Entonces, si os fijáis, lo que he hecho aquí es 3 por 2 por 1, 00:15:59
que es calcular el factorial, ¿vale? 00:16:05
Si hubiéramos metido aquí un 4, pues vamos a hacerlo rápido, 00:16:08
todo esto lo voy a borrar, esto lo voy a borrar, 00:16:13
si hubiera metido el valor de 4, pues me hubiera dado, 00:16:16
primero p vale 1, bueno pasamos las dos primeras, no es 0, no es mayor que 0, ¿vale? 00:16:18
y aquí p igual a 1, entonces tenemos estos valores iniciales 00:16:26
en el bucle hacemos 4 por 1 es 4 y a este restamos 1, 3 00:16:30
4 por 3 es 12 y a este le restamos 1, 2 00:16:36
12 por 2 es 24 y a este le restamos 1, 1 00:16:39
Y como ya es igual a 1, salgo del bucle, con lo cual 4 factorial será 24. 00:16:44
Si hacemos 4 por 3 por 2 por 1, 4 por 3, 12, por 2, 24, por 1, 24. 00:16:49
¿Vale? Me quedaría perfectamente el factorial. 00:16:55
Por lo tanto, ¿cuál es el propósito de este algoritmo? 00:16:57
Sacarme el factorial de un número. 00:17:02
Pero claro, el factorial de 0 no cumple la regla. 00:17:04
Por lo tanto, por lo tanto, el factorial de 0 tengo que darle un caso especial. 00:17:07
que es factorial de 0 igual a 1 00:17:12
por eso tengo que hacer esta primera comprobación 00:17:14
y además 00:17:16
no existen factoriales de números negativos 00:17:18
¿vale? porque en el momento en el que sea 00:17:20
negativo, como tengo que ir restando 1 00:17:22
dejar el menos 1 menos 2 menos 3 menos 4 00:17:24
me iría al infinito, con lo cual no puede ser 00:17:26
un factorial de un número negativo 00:17:28
por lo tanto, como el número tiene que ser positivo 00:17:29
y distinto de 0, esta primera condición 00:17:32
y esta segunda condición lo que hacen es protegerme 00:17:34
toda la ejecución 00:17:36
de los valores que no son válidos 00:17:39
y después una vez que sabemos que el valor es válido 00:17:40
entramos en el bucle y ejecutamos 00:17:43
esa multiplicación recursiva 00:17:45
hasta que tengo el factorial y cuando 00:17:47
tengo el factorial lo saco 00:17:49
sin ningún problema, ¿vale? 00:17:51
más o menos, ¿eh? entonces 00:17:53
quiero que me digáis si tenéis 00:17:55
alguna duda, de momento vuelvo a 00:17:57
sacar aquí las pantallitas de 00:17:59
cuando lo veáis, las estoy sacando 00:18:00
¿vale? decirme si me seguís 00:18:03
escuchando, si estáis ahí, si os habéis dormido ya 00:18:05
o si, ¿vale? a través del chat 00:18:07
Que alguien conteste, por favor. Que alguien dé señales de vida. A ver... Hola. 00:18:09
Sí se oye, sí. 00:18:19
Ah, vale. Ah, sí me gusta, sí me gusta. Vale. 00:18:21
Veo que Antonio Casado por aquí está aplaudiendo. Eso está bien. 00:18:24
Bueno, ¿podrías decir otra vez lo de factorial cero? Sí, claro. 00:18:29
La norma, la regla, la regla para el factorial es cogerme desde el número, lo voy a poner aquí abajo, ¿vale? 00:18:35
Si tengo factorial de un número, 7, ¿vale? 00:18:43
Lo que hago es ir haciendo la multiplicación hacia atrás hasta el 0, o hasta el 1, perdón. 00:18:46
Entonces, 7 por 6, por 5, por 4, por 3, por 2, por 2 y por 1. 00:18:55
Ahí va, aquí, por 2 y por 1, ¿vale? 00:19:03
Entonces, esa es la norma. 00:19:08
Pero, ¿qué pasa con el 0 factorial? 00:19:10
Que el 0 factorial es un caso especial. 00:19:11
El cero factorial no lo podemos calcular según la norma. 00:19:13
Simplemente los matemáticos han llegado a un convenio. 00:19:21
Un convenio que es cero factorial es igual a uno, siempre. 00:19:24
¿Por qué? Porque nos da la gana. 00:19:26
Porque nosotros lo valemos y lo decidimos. 00:19:28
Como somos los que decidimos las cosas que se hacen en matemáticas, 00:19:31
pues vamos a tomar la decisión de que cero factorial es igual a uno. 00:19:34
Y se acabó. Es una norma. 00:19:36
Entonces, yo no puedo hacer 0 por números menores que 0, 00:19:39
restando de 1 en 1 hasta llegar a 0, porque si os fijáis, nunca llegaría. 00:19:45
Entonces, 0 factorial por convenio es 1. 00:19:50
7 factorial es multiplicar 7 por 6, restándole 1 al 7 hasta que llegue al 1. 00:19:52
Y si es un número negativo, no existe factorial. 00:19:58
Entonces, aquí lo que hago es protegerme al principio de esos valores que no son válidos. 00:20:01
Primero, compruebo si n es igual a 0. 00:20:05
Si n es igual a 0, me salgo y digo, vale, el factorial de 0 es igual a 1, 00:20:07
porque es un caso especial, no puedo aplicarle el bucle, no puedo aplicarle la norma. 00:20:12
Entonces, el caso especial del 0 lo trato aquí, n igual a 0, un caso especial, 00:20:17
y lo saco, factorial de 0 es igual a 1. 00:20:23
Si no es 0, todavía tengo una opción de que esto no sea válido, 00:20:25
y es cuando los números son negativos, por eso hago esta comprobación. 00:20:29
Si n es mayor que 0, ¿vale? Hago el bucle, pero si no es mayor que 0, como ya he comprobado que no era 0 y no es mayor que 0, la única opción que quedaría para esta salida del no es que sea menor estrictamente que 0. 00:20:32
Es un número por debajo de 0. Por lo tanto, escribo número negativo y escribo prueba con positivos, metiendo números positivos, porque con ese no me vale. Y se acabó. 00:20:48
Entonces, lo que hago es protegerme aquí de los valores que no son válidos para el algoritmo. 00:20:59
Y aquí está realmente el cuerpo del algoritmo, que es el cálculo del factorial, 00:21:05
que es el bucle que me va multiplicando el número por uno menos, por uno menos, por uno menos, hasta llegar al uno. 00:21:09
Y cuando llega al uno se sale y me escribe el valor resultante y se acabó. 00:21:14
¿Vale? 00:21:18
¿Contesta eso la pregunta, Liz? 00:21:20
¿Vale? 00:21:24
¿Mario? 00:21:26
que va a ser el que preguntabas 00:21:26
¿contesta eso tu pregunta? 00:21:29
vale, perfecto 00:21:33
entonces 00:21:34
¿qué ocurre? yo os decía 00:21:34
vale, esto está guay 00:21:37
pero también hay que ver 00:21:39
una vez que nos podemos 00:21:41
hacer esto, si esto falla en algún sitio 00:21:44
yo nada más verlo 00:21:45
ya os digo, yo he hecho muchos algoritmos 00:21:47
me doy cuenta de que 00:21:49
este algoritmo tiene un error 00:21:51
tiene un error en la ejecución, por la forma 00:21:52
en la que hace las cosas. Fijaros, vamos a poner un ejemplo, ¿de acuerdo? Y voy a hacer 00:21:55
el ejemplo en el caso de que el usuario introduzca el valor 1. Todo el mundo sabe, ¿verdad?, 00:22:00
que factorial de 1 es 1. Y se acabó. Factorial de 1 es 1. Factorial de 0 es 1 por convenio, 00:22:09
pero factorial de 1 es 1. Es 1 por sí mismo y se acabó. Entonces, si yo le pongo el valor 00:22:15
1, ¿qué va a ocurrir? Fijaros, el filtro para los valores válidos me lo paso, porque 00:22:22
n no es 0, por lo tanto salgo hacia abajo, y n es positivo, por lo tanto salgo hacia 00:22:30
abajo. Ya estoy dentro del bucle. Inicializo p a 1. Y ahora fijaros el error. p es p por 00:22:35
n. 1 por 1, 1. Hasta aquí todo bien. n igual a n menos 1. Cuidadito, que ahora lo pongo 00:22:43
a 0. Y ahora hago la comprobación. ¿Es n 00:22:50
igual a 1? No. No es 00:22:51
n igual a 1. Por lo tanto, me meto 00:22:54
en el bucle. 00:22:55
p es igual a p por n. 1 por 0. 0. 00:22:57
Y n es igual a n menos 1. 00:23:01
Ahora ya estamos en n igual a menos 1. Fijaros 00:23:03
que me he pasado y ahora ya estoy haciendo un disparate. 00:23:05
¿Vale? ¿Es n igual a 00:23:08
1? Para nada. Y vuelvo a entrar 00:23:10
en el bucle. Y ahora hago 00:23:11
0 por menos 1. 0. 00:23:13
n igual a n menos 1. 00:23:16
N igual a n menos 2. 00:23:17
y pregunto, ¿es n igual a 1? No, y vuelvo a entrar en el bucle 00:23:18
y veo que p es 0 por 0 por menos 2, 0, y menos 2 se convierte en menos 3 00:23:23
y así puedo seguir, menos 3 es menos 4, menos 5 es menos 6 00:23:29
y no va a acabar nunca este proceso, se ha saltado el límite del bucle 00:23:33
y por la forma en la que está escrito no terminaría en la vida 00:23:38
Entonces, para el caso de n igual a 1, este programa tiene un fallo, tiene un error y habría que corregirlo, habría que hacer las cosas de otra forma para permitir que eso no pasara. 00:23:43
O ponemos un caso especial para n igual a 1 aquí arriba, con lo cual también, si aquí le pongo, por ejemplo, simplemente, si n es igual a 0 o n es igual a 1, escribo factorial igual a 1. 00:23:55
y me he quedado tan ancho 00:24:07
porque tanto el factorial de 0 como el factorial de 1 vale 1 00:24:09
y después ya he protegido 00:24:12
contra el valor que me hacía que esto cascara 00:24:14
¿N es negativo? No 00:24:16
por lo tanto cuando entro aquí 00:24:17
ni es 0, ni es 1, ni es negativo 00:24:19
con lo cual ya estoy seguro de que esto va a funcionar 00:24:22
y ya estaría protegiendo 00:24:24
correctamente este programa 00:24:26
y el algoritmo funcione 00:24:27
¿entendéis cuál es el error? 00:24:29
¿vale? ¿entendéis un poco 00:24:32
cuál es el problema de este algoritmo? 00:24:34
contestarme por el chat 00:24:36
aún si, o si queréis activaros 00:24:38
el micro y me decís 00:24:40
que sí, y ya está 00:24:42
¿vale? 00:24:44
es un error muy tonto, pero es un error que muchas 00:24:46
veces lo cometemos cuando 00:24:48
cuando estamos 00:24:50
calculando variables, fijaros que en este caso 00:24:52
también tenemos, por ponerle el nombre que voy a 00:24:54
darles ahora, tenemos una 00:24:56
variable que es la variable de entrada que 00:24:58
nos sirve de contador, voy a poner un ejemplo 00:25:00
que se vea bien, el del 4 por ejemplo 00:25:02
4, p se inicializaría a 1, 4 por 1 es 4, resto 1, 3, 4 por 3, 12, resto 1, 2, 12 por 2, 24, resto 1, 1, y aquí ya me saldría. 00:25:04
Vale, entonces, fijaros que esta es la forma de ejecutar un algoritmo rápido, pero tenemos que ver muy claro cuáles son las variables y cuál es el valor que en cada momento tiene esta variable. 00:25:19
Eso me ayuda muchísimo para entender cómo funciona un algoritmo. 00:25:28
¿Vale? Bien, entonces, ahí tenemos un ejemplo, el valor de n igual a 4, ¿vale? Y cómo ha ido evolucionando. En este caso el factorial sería 24 y la salida sería esta. 00:25:31
Y aquí en las conclusiones yo escribiría, ¿vale? Las conclusiones. Pues mis conclusiones serían que el propósito de este programa es calcular el factorial de un número, 00:25:44
que para ello primero elimina los valores que no son válidos para la norma general 00:25:53
que serían el valor de n igual a 0 que su función es 1 y el valor que sea un número negativo que no se puede hacer 00:26:00
y una vez que hemos hecho esa comprobación pasamos a escribir el algoritmo de multiplicación 00:26:05
con un bucle repetir hasta que n sea igual a 1, ¿de acuerdo? 00:26:10
Y en las conclusiones yo pondría y además el programa tiene un fallo y es que para el valor de n igual a 1 no funciona 00:26:15
y además el organigrama tiene un fallo y es que esta flecha está al revés. 00:26:22
Y con eso estamos de acuerdo, ¿vale? 00:26:26
Bueno, más o menos espero que os haya quedado claro que una plantilla de estas 00:26:30
o escribiendo en un folio simplemente poniendo cuáles son las entradas, 00:26:33
cuáles son las salidas y cuáles son los valores de las variables, 00:26:38
se entiende muy bien cómo funcionan los algoritmos y es una forma muy útil para identificar esto. 00:26:40
¿De acuerdo? Ya os digo, no me describáis cuando queréis describir un algoritmo que hace cada caja. 00:26:46
Bien, bueno, pues voy a cerrar esto y voy a enseñaros entonces un pequeño resumen que os he preparado, un pequeño resumen de cómo nosotros vamos a analizar los ejemplos de los diagramas de acu, ¿de acuerdo? 00:26:50
Esto luego os lo pasaré, todo este material os lo dejaré colgado en el blog, ¿de acuerdo? Bien, pues lo primero, vamos a ver el análisis de los algoritmos, ¿vale? Y cómo resolverlos y vamos a tener que cubrir una serie de fases. 00:27:10
Primero, ¿cuál es el problema? 00:27:24
Bueno, pues el problema es que tenemos que localizar las variables. 00:27:27
Nosotros tenemos que localizar las variables y al localizar las variables, 00:27:32
para eso es importante localizar los elementos que van a ir cambiando de valor 00:27:35
o aquellos que yo introduzco a través del teclado. 00:27:40
Entonces, eso es importante. 00:27:43
Hay contadores, hay acumuladores, hay variables que me cogen un límite, 00:27:45
que me cojan el límite de un bucle, entonces tenemos que ver qué variables son las importantes 00:27:50
y sobre todo apuntármelas en un papel e ir actualizando sus valores para ver qué afectan. 00:27:58
Tenemos, evidentemente, es crucial detectar cuáles son las entradas de los datos y cuáles son las salidas. 00:28:03
La salida del algoritmo es lo que me va a dar el propósito, lo que devuelve el algoritmo al final es lo que quiera o que haga, 00:28:07
entonces eso me va a dar el propósito. 00:28:14
¿Vale? Y entonces, una vez que hemos visto qué variables tengo, cuáles son las entradas y cuál es la salida, es donde ya vamos a saber qué problema trata de resolver el algoritmo, ¿vale? 00:28:15
Entonces, normalmente nos fijamos en eso, en entradas y salidas para intentar entender. 00:28:28
Luego también hay que analizar qué hacen los procesos internos, ¿vale? Las asignaciones, las actualizaciones de los valores para las variables. 00:28:33
y también tenemos que ver qué cosas se van haciendo en los bucles 00:28:40
o en las bifurcaciones, en las decisiones que se toman, ¿de acuerdo? 00:28:44
Y por último, llegamos a la conclusión, conclusión de lo que hemos analizado. 00:28:48
Normalmente a estas alturas ya sabemos perfectamente qué es lo que hace el algoritmo, 00:28:53
entonces no tenemos problema para poder resolver este tipo de preguntas. 00:28:56
Bueno, vamos a poner el primer ejemplo, ¿vale? Ya lo habéis visto, ¿no? 00:29:02
En este caso, pues el primer algoritmo teníamos tres variables, 00:29:06
que era la k, que era el límite, era lo que yo leía, pero además me sirve, como veis aquí, 00:29:08
a ver un segundito, si como veis aquí, ¿vale? Veis que n es igual a k, entonces el valor n igual a k, 00:29:15
lo que está haciendo es, a ver un segundito, si estoy compartiendo la pantalla correcta, 00:29:23
¿verdad? Estáis viendo la presentación, ¿no? A ver, un segundo, a ver en el chat, 00:29:27
Contestadme por el chat si estáis viendo la presentación bien 00:29:33
Vale, perfecto 00:29:37
Entonces, en este de aquí es el límite 00:29:39
Porque es el que me va a marcar la salida del bucle 00:29:42
La salida del bucle lo tengo en n igual a k 00:29:45
Por lo tanto, k es el límite 00:29:47
Es una variable que tiene un límite 00:29:49
Luego tengo un contador que es n 00:29:50
Que si os fijáis va creciendo de uno en uno 00:29:52
En cada vuelta crece en uno 00:29:54
Con lo cual es un contador 00:29:56
Y luego tengo un acumulador 00:29:57
Que es donde voy metiendo el valor acumulado 00:29:59
De la suma de todos esos 00:30:01
los números que van sucediendo. 00:30:03
Con lo cual ya identifico mis variables. 00:30:05
Después, tenemos que K me marca ese límite, ¿vale? 00:30:08
La salida del bucle, las entradas y las salidas, es K la entrada, 00:30:16
y la salida es la suma, que es el acumulador, lo que tenga el valor del acumulador. 00:30:20
Y el propósito es resolver la suma de los K primeros números consecutivos, ¿vale? 00:30:25
Los naturales. 00:30:28
Bien. 00:30:30
Bien, segundo ejemplo, ya lo hemos analizado, volvemos a él, ¿vale? Las variables n y p, después tenemos que k va a ser, bueno, en este caso n nos sirve tanto de contador como de límite, ¿por qué? Porque va a ser el que va a ir contando en qué vuelta me encuentro, ¿vale? Y también es el que va a hacer el límite de la salida, en este caso es la misma variable, ¿vale? 00:30:30
El hecho de utilizar la misma variable con los dos propósitos hace que aquí no pueda decir el factorial de el número n es p, 00:30:55
porque n siempre va a valer 1, si os fijáis, esta es la condición de salida. 00:31:03
Con lo cual, como me he ido restando de mi variable inicial números, no sé cuál era el número inicial. 00:31:07
A estas alturas del algoritmo he perdido esa información. 00:31:14
o guardo en una variable diferente el valor inicial o aquí al final no podré decir el factorial del número, el que sea, es p, ¿vale? 00:31:17
Entonces, bueno, pues eso son cosillas que son luego mejoras que podemos hacer nosotros en los aburridos. 00:31:28
Y la suma es la salida que es el acumulador, que en este caso no acumula sumando, sino que acumula multiplicando y ahí acumulando en su valor la multiplicación, ¿vale? 00:31:32
Y hemos visto que el propósito es devolver el factorial del número k introducido por el usuario. 00:31:43
Y ya está. ¿De acuerdo? Entonces veis que es todo bastante intuitivo. 00:31:47
Hemos visto que tenía dos problemas, el problema de la flecha y hemos visto que tenía el problema de que si le pongo n igual a 1, 00:31:52
como en la condición previa a la comprobación ya me dice, me pregunta si n es igual, o sea, me resta 1 a la n, 00:31:59
cuando le pongo n igual a 1, aquí peta. ¿Vale? No saldrá nunca de este bucle y se queda de forma infinita g. 00:32:07
¿De acuerdo? Bueno, preguntas hasta aquí. A ver, abrimos un poquito el turno de preguntas, ¿vale? No sé si tenéis alguna cuestión que decirme. ¿Alguien ha levantado la mano? Antonio está aplaudiendo, Sergio está aplaudiendo, pero bueno, ya podéis dejar de aplaudir. 00:32:13
¿Alguien tiene alguna duda? Vale, perfecto. Pues nada, seguimos viaje. 00:32:35
¿Qué tengo para enseñaros? Pues tengo para enseñaros un programita que se llama PSINT, que es un programa gratuito que podéis descargaros de internet. 00:32:47
Tengo un vídeo en mi canal de YouTube donde os explico cómo descargarlo y cómo instalarlo. 00:32:56
instalarlo, de acuerdo, ahora os diré 00:33:01
dónde están los vídeos de mi canal y 00:33:03
dónde están todas estas cosillas que 00:33:05
podéis utilizar, si queréis, entonces 00:33:06
PSINT es un programa que nos sirve para 00:33:08
esto, entonces, bueno, aquí ya termina la 00:33:12
presentación, vale, esto lo pasaré para 00:33:16
que lo tengáis, con lo cual ahí tenéis un 00:33:18
poquito toda la, toda la, perfecto, vuelvo a mi 00:33:20
a mi pantallita, a ver, un segundo, que he 00:33:23
perdido, vuelvo a compartir mi escritorio, perdonad, que ha saltado sin querer, vale. 00:33:29
Y entonces ahora lo que voy a hacer es enseñaros este, el programa PSI, ¿de acuerdo? 00:33:36
Fijaros, voy a volver a coger los algoritmos que teníamos, voy a coger el facilito, 00:33:42
y este programa me sirve para poner algoritmos en formato pseudocódigo. 00:33:48
Entonces, un algoritmo empieza con un inicial algoritmo y un final, fin algoritmo, 00:33:52
que es el inicio y el fin, ¿vale? Estas son las estructuras redondas. 00:33:57
Y luego aquí a la derecha, en los comandos, ¿vale? 00:34:02
Voy a quitar esto de la estorba. 00:34:09
Entonces aquí veis que tenemos una serie de cosas que se pueden hacer. 00:34:11
Un escribir, que son salidas, un leer, que son entradas, 00:34:15
un asignar, que me va a asignar valores a variables, 00:34:18
estos son la variable igual a algo, 00:34:21
y luego aquí bifurcaciones y bucles del tipo repetir hasta o repetir mientras, ¿vale? 00:34:22
O un bucle con un contador que va adquiriendo valores desde un valor hasta el que sea. 00:34:28
Bueno, entonces, fijaros, el algoritmo que yo voy a poner aquí, pues, va a ser algoritmo A, ¿vale? 00:34:34
Este es el algoritmo A que estamos haciendo. 00:34:43
Lo primero que hago es leer K. 00:34:45
Le doy a leer y la variable que quiero leer es la variable K. 00:34:47
Fijaros que estoy copiando prácticamente lo que pone en ese algoritmo. 00:34:51
Ahora le voy a asignar a la variable n el valor 0 y a la variable suma le voy a asignar el valor 0. 00:34:55
Entonces, en un momento voy a ir siguiendo lo que hace el programa. 00:35:13
Lo que hago es leer k, luego le pongo a n el valor 0 y asumo el valor 0. 00:35:16
Y ahora voy a hacer este proceso repetitivo que está dentro de un bucle repetir hasta. 00:35:22
Con lo cual, si os fijáis, tengo aquí la estructura del repetir hasta, ¿vale? 00:35:26
Repetir hasta que suceda algo. 00:35:31
¿Qué secuencia de acciones tengo que hacer? 00:35:34
Bueno, pues tengo que asignarle a la variable n la expresión n más 1 00:35:35
y a la variable suma le voy a poner la suma más n. 00:35:44
Bien, ¿y hasta cuándo voy a repetir esto? 00:35:59
Hasta que n sea igual, ¿vale? 00:36:03
Bien, y cuando salga de este bucle, ¿qué voy a hacer? 00:36:08
Voy a escribir por pantalla k y voy a escribir por pantalla suma, ¿vale? 00:36:11
Ahí va, me he saltado, perdonadme, este fin de algoritmo me lo he zampado, no es aquí, este fin de algoritmo es aquí, ¿vale? Eso es, es que un pequeño error táctico. 00:36:24
Vale, ahora estaría bien, entonces fijaros, ¿qué es lo que estoy haciendo? He puesto el nombre del algoritmo, inicio, sería este inicio del algoritmo, 00:36:41
luego leemos k, ponemos a n el valor 0, sumamos, perdona, al valor de la suma le damos el valor 0 00:36:50
y luego vamos a repetir hasta que n sea igual a k, que es este bucle, 00:36:56
n coge el valor n más 1 y suma, coge el valor suma más n. 00:37:01
Escribimos k cuando terminemos y escribimos suma y terminamos el algoritmo. 00:37:06
¿Qué es lo guapo de este programa? 00:37:10
Que aparte de poderlo escribir aquí de una forma un poquito como si fuera lenguaje natural, 00:37:11
yo puedo ver el diagrama de flujo. 00:37:17
Que si os fijáis, tiene una pinta bastante parecida al diagrama de flujo que teníamos original. 00:37:20
Leemos k, asignamos el valor 0 a n, asignamos el valor 0 a suma, n es n más 1, suma, suma más n, 00:37:28
y aquí preguntamos n es igual a k, y cuando es falso, volvemos para arriba. 00:37:35
Y si es verdadero, escribo suma y escribo k, que si os fijáis son las entradas y salidas, 00:37:39
con la flechita hacia afuera la de escribir y esta es la de leer. 00:37:45
Veis que el diagrama de flujo es prácticamente clavado, pero además lo puedo ejecutar, que esto es la maravilla de este programa, ¿veis? 00:37:48
Yo lo ejecuto, me sale una ventanita y me dice, es aquí en el play este redondo, ejecución iniciada. 00:37:57
¿Qué estamos haciendo? Leer K, entonces aquí le voy a poner un número, 4, ¿vale? 00:38:04
Y entonces me pone, acaba de terminar de ejecutar el bucle y escribe K, que es 4, y escribe la suma, que es 10. 00:38:09
4 y 3, 7 y 2, 9 y 1, 10. 00:38:16
Perfecto, me ha sumado todos los números 00:38:19
entre 1 y 4. 00:38:21
¿Vale? 00:38:24
Y me sale el resultado 3, 10. 00:38:25
¿Veis que es muy críptico? 00:38:27
Esto mola más si yo le pongo 00:38:29
algo de información para que la ejecución 00:38:31
sea más guapa. 00:38:33
Yo le pongo aquí 00:38:34
escribir 00:38:36
introduce, entre comillas, 00:38:37
siempre los textos, introduce 00:38:40
ahí va, introduce 00:38:42
un número 00:38:46
para que sepa que es lo que tiene que meter el usuario, ¿vale? Leemos K, repetimos el bucle y ahora cuando escribo, ¿vale? 00:38:48
Lo que voy a hacer es escribir la suma de los números desde 1 hasta, le pongo este texto y detrás el valor de la variable K, ¿vale? 00:38:56
Y aquí le pongo otro texto, que es, fijaros que estoy concatenando textos, es dos puntos, espacio, coma, sub. 00:39:14
¿Qué he hecho aquí? Voy a quitarme este escribir. 00:39:23
¿Qué he hecho aquí? Muy fácil, lo que he hecho ha sido escribir una cosa detrás de otra, con lo cual me va a escribir este texto, 00:39:29
la suma de los números desde uno hasta, después me va a poner el valor de la variable k, 00:39:36
después otro texto, que es 00:39:40
un espacio, es dos puntos 00:39:43
y después el valor de la variable suma 00:39:45
¿vale? entonces esto, puesto de esta 00:39:47
forma, esto lo tenéis explicado 00:39:50
también en los vídeos y lo que veis 00:39:52
con un poquito más de detalle, ¿vale? introduce 00:39:53
el número, ahora ya sé que me está pidiendo 00:39:55
pues 4, y ahora me dice 00:39:57
la suma de los números desde 1 hasta 00:39:59
4 es 10, ahora tiene sentido 00:40:01
¿veis? ahora me está dando un programa 00:40:03
en condiciones, le he añadido 00:40:05
simplemente pues un poquito de interacción en la 00:40:07
Entraría en la salida para saber qué está haciendo. 00:40:09
Eso no te lo han puesto en este algoritmo, en este organigrama, 00:40:11
porque entonces te estarían diciendo cuál es el propósito. 00:40:15
Entonces no podrían, no, no se estarían dando la solución del ejercicio. 00:40:17
Por eso no lo han hecho. 00:40:20
¿De acuerdo? 00:40:22
Bien. 00:40:23
Entonces, este es el algoritmo, este. 00:40:24
También, bueno, yo ya me los he hecho, ¿vale? 00:40:27
Entonces, este algoritmo, si os fijáis, tendría, bueno, perdonad, 00:40:29
antes de hacer el siguiente algoritmo, una cosa que también es muy chula es esto. 00:40:34
Veréis. Yo puedo ejecutarlo paso a paso. Aquí en los pasitos estos, lo puedo ejecutar paso a paso. 00:40:39
Entonces, fijaros. Me sale la ventana de la salida y me va poniendo una flechita donde estamos. 00:40:46
Y además le digo explicar con detalle y me va a ir diciendo qué hace en cada paso. 00:40:51
Entonces, este algoritmo, lo voy a poner así para verlo todo. 00:40:56
Fijaros. Está leer en los detalles. Vale. Entonces, está leyendo el... 00:40:59
Pero voy a detener y voy a empezar a ejecutar. Comenzar. Vale, el algoritmo comienza con el proceso algoritmo A, vale, pues esto nada, sin problema. Siguiente. Escribimos por pantalla, introduzco el número, vale, se pone. En la pantalla veis que ha salido aquí, en la pantalla que es esta, vale, esta, hoy va, esta ventanita. Vale, esta ventanita. 00:41:05
Entonces, ahora, seguimos. 00:41:28
Se espera que el usuario ingrese un valor. 00:41:30
Vamos a ingresar un valor, el 2. 00:41:32
Sí, el 3. 00:41:35
Vamos a hacerlo corto. 00:41:36
¿De acuerdo? 00:41:38
Entra. 00:41:39
El valor ingresado se almacena en K, que es lo que estamos haciendo aquí, en esta flecha. 00:41:40
Pasamos a la siguiente orden. 00:41:44
Se evalúa la expresión a asignar, 0. 00:41:46
El resultado es 0, es decir, lo que está a la derecha, que es lo que tengo que asignar, es 0, 00:41:49
porque es lo que le he puesto a juego, y el resultado se guarda en L. 00:41:52
0 se guarda en L. 00:41:55
Se evalúa la expresión a asignar, que es 0, el resultado es 0, y eso se aguarda en suma, ¿vale? 00:41:57
Y ahora repetimos. 00:42:04
Se evalúa la expresión a asignar, que es n más 1, el resultado es 1, porque 0 más 1 es 1. 00:42:07
Y el resultado se guarda en n, n ahora vale 1. 00:42:14
Se evalúa la expresión suma más n, el resultado es 1, y el resultado se almacena en suma. 00:42:18
y ahora se evalúa la condición, ¿es n igual a k? 00:42:25
Falso, se continúa iterando, se continúa con la siguiente iteración, con la siguiente repetición. 00:42:30
¿Vale? n más 1, el resultado es 2, el resultado se guarda en n, 00:42:36
se hace suma más n, que es 3, se guarda en suma, 00:42:41
se evalúa la condición, ¿n es igual a k? 00:42:45
Falso, se continúa iterando, el resultado ahora es 3 y se guarda en n, 00:42:48
La suma es 6 y se guarda en suma, se evalúa, ¿es n igual a k? Ahora sí, porque le hemos dado el valor 3. 00:42:53
En la condición es verdadero, se sale de la estructura repetir y ahora se evalúa la expresión. 00:42:59
La suma de los números desde 1 hasta, se escribe, se evalúa la expresión k, se escribe el resultado, se evalúa la expresión es, se escribe el resultado y se evalúa la expresión suma y es 6. 00:43:04
Se evalúa, quiere decir que el programa hace ese proceso, ¿vale? Hace el proceso de entender qué es lo que tiene que hacer ahí, el resultado es simplemente el texto y lo escribo. 00:43:17
Y ya estaría, y termina el programa. Pinta el algoritmo, me da la marca de ejecución finalizada y se acabó. 00:43:25
Veis que he ejecutado el algoritmo pasito a pasito. También le puedo poner, en vez de con detalle, le puedo hacer esto, que avance. 00:43:32
A ver, un segundito, le voy a dar aquí a comenzar. Vale. Y entonces ahora lo que va a hacer es, con esta velocidad, le voy a poner una velocidad un poquito más lenta, ¿vale? Para que veáis que él va a ir haciendo aquí la ejecución. 00:43:40
Le pongo 8 para que sea más largo y fijaros lo que ocurre, va evaluando, va evaluando, repite, entra dentro del bucle, va haciendo, estos son los procesos, no te va poniendo ninguna salida porque son procesos internos que hace el programa, pero veis que ya está dentro del bucle, veis que está dentro del bucle, veis que está dentro del bucle. 00:43:55
¿Hasta cuándo? Hasta que el número sea 8. Y cuando sea 8, voy a ver un poquito más rápido, ¿vale? Y cuando sea 8, saldrá del bucle y me pondrá simplemente el resultado. 00:44:14
¿Vale? Debe estar a punto. Ahí está. 8, la suma de los números es 36. ¿De acuerdo? Veis que está súper chulo este programa porque me permite poner un algoritmo en formato de pseudocódigo y ejecutarlo y ver cuál es el resultado. 00:44:29
Bien, vamos a hacer otro ejemplo, voy a quitarle esto del paso a paso ya, ¿vale? Entonces, vamos a ver el ejemplo del otro algoritmo que teníamos, que era este, ¿de acuerdo? 00:44:46
el algoritmo un poquito más complicado. Como no quería estar aquí perdiendo la vida, 00:45:00
vale, un segundito, vale, si yo no voy a cerrar este, no quiero guardar cambios, vale, yo 00:45:06
ya me lo he preparado aquí, algoritmo B, vale, si no he equivocado es esto. Entonces, 00:45:16
fijaros, yo ya le he puesto también un poco algunas cositas, vale, bueno, este es el programa, 00:45:20
perdón, ese es el programa pelado, tal cual está, entonces, algoritmo B es leer n, si n es igual a 0, entonces escribimos factores de 0 igual a 1, 00:45:27
y si no, bajamos hacia abajo, entramos en la siguiente condición, si n es mayor que 0, entonces entraríamos, y si no, escribimos número negativo y prueba con positivo. 00:45:38
Y el bucle principal asignaría a p el valor 1, que sería esta caja. 00:45:48
Repetimos, p es p por n y n es igual a n menos 1 y esto va a repetirse hasta que n sea igual a 1. 00:45:55
Cuando n sea igual a 1 salimos y escribimos factorial igual a p y se acabó. 00:46:05
Entonces voy a ejecutarlo para ver qué pasa. 00:46:10
Voy a ponerle aquí un 4. Me dice 4 factorial 24, ¿vale? 4 por 3, 12, por 2, 24, por 1, 24. Perfecto. Funciona. Reiniciamos. 00:46:12
Ahora le voy a poner un 0 factorial de 0 igual a 1. Claro, era el caso que me sacaba por esta rama, ¿verdad? Y me ponía factorial de 0 igual a 1. Perfecto. 00:46:25
Después, le voy a poner un menos 4. 00:46:34
Número negativo, prueba con positivos, perfecto. 00:46:37
Está saliendo por esta rama de la condición con la cual está funcionando. 00:46:40
Pero, ¿qué pasa si le pongo un 1? 00:46:44
Se me ha quedado colgado. 00:46:48
Veis que no devuelve nada, no hace nada, se queda flipado. 00:46:50
¿Por qué? 00:46:53
Porque es el caso que hemos detectado que era erróneo y que me metía en este bucle de forma infinita. 00:46:54
¿Vale? 00:46:59
Entonces, ¿cómo hacemos que eso no pase? 00:47:01
Como os he dicho antes. 00:47:03
Entonces, si yo pongo aquí, si n es igual a 0, o, que tengo aquí los operadores que puedo utilizar, o, ¿vale? Es que quería utilizar la forma correcta, o, n igual a 1, entonces voy a poner factorial igual a 1. 00:47:04
ahora no pongo 0 porque no sé si es 0 o 1 00:47:32
ya tengo ahí un pequeño problema 00:47:35
¿veis? ahora, vamos a ver qué pasa ahora 00:47:37
ejecución iniciada 00:47:39
pongo 4, funciona, perfecto 00:47:40
reiniciamos 00:47:43
pongo un menos 5 00:47:44
o menos 4, vale, negativo 00:47:49
¿qué pasa si ahora pongo un 1? 00:47:51
¡ay amigo! ahora funciona 00:47:54
ya hemos protegido del caso 00:47:55
de que n sea igual a 1 00:47:57
y está funcionando el programa y lo hemos 00:47:58
resuelto el problema 00:48:00
yo además de esto 00:48:02
le cogería y le añadiría una segunda variable, ¿vale? 00:48:04
que es valor inicial, le voy a llamar v 00:48:08
y entonces lo que voy a hacer es asignarle al valor inicial v 00:48:11
para no perderlo, ¿de acuerdo? 00:48:15
v, a v le voy a asignar n 00:48:17
simplemente voy a coger el valor que introduce el usuario 00:48:21
y lo voy a almacenar, ¿vale? dentro de la variable v 00:48:24
entonces aquí cuando escriba el resultado voy a poner 00:48:28
factorial de 00:48:31
el valor v, que es el inicial 00:48:33
que este no lo voy a cambiar en toda la ejecución 00:48:37
vale 00:48:40
o si queréis lo ponemos en formato 00:48:42
matemático, que queda más chulo 00:48:45
v, que es el valor de 00:48:46
de la variable 00:48:49
admiración 00:48:51
igual, comillas 00:48:53
coma 00:48:56
en este caso sería, perdón 00:48:58
1, en este caso sería igual a 1, entonces ponemos el número que está en el valor inicial con una admiración detrás que es el factorial es igual a 1, después aquí en este resultado, ahora ya sí que le puedo poner que lo mismo que antes, v, comillas, admiración, es igual a comillas, coma, y ahora le pongo aquí p, fijaros como me queda ahora, 00:49:02
Y aquí, antes de leer este n, le voy a poner un escribir, porque si no, me quedo muy putre, introduce un número. 00:49:29
Vale, entonces, ¿qué hemos hecho? Lo voy a poner aquí todo ya visto, ¿vale? 00:49:43
¿Qué hemos hecho? Fijaros, introduzco un número y vamos a leer la variable. 00:49:48
Y yo voy a almacenar ese valor para que no se me pierda en una variable adicional que es v. 00:49:51
y después si n es 0 o n es 1 00:49:56
entonces voy a poner 00:50:01
el valor introducido inicialmente 00:50:02
con una admiración detrás es igual a 1 00:50:05
si no, que es esta salida 00:50:08
si no, veo si es negativo 00:50:10
y si no, repito el bucle, calculo el factorial 00:50:12
y veo, entonces fijaros que ahora 00:50:14
va a quedar mucho más mundo 00:50:16
ah vale, no sé si es que 00:50:18
como que no se encontró 00:50:19
ah vale, pero aquí me falta 00:50:22
me falta buena comida 00:50:24
vale, entonces 00:50:28
fijaros, introduzo el número 00:50:30
le pongo un número 00:50:33
6 y me dice 6 factorial 00:50:34
igual a 720, perfecto, quedado ahí 00:50:36
reiniciamos 00:50:39
introduzo el número 1 00:50:40
1 factorial es 1, perfecto 00:50:42
reiniciamos 00:50:44
0 factorial es 1 00:50:46
ahora está super chulo, ahora ya queda 00:50:48
mucho mejor la visualización del 00:50:50
programa a través del espargonismo con 00:50:52
de entradas y salidas más claras. 00:50:54
Y si le pongo menos 3, pues me dice, 00:50:56
número negativo, prueba compositiva. 00:50:58
¿Vale? 00:51:00
Otra mejora que yo le haría a este programa también, 00:51:01
sería que este número negativo, 00:51:03
este no, en vez de irme al final, 00:51:06
yo le pondría que me viniera de nuevo al EDM. 00:51:08
Es decir, que me volviera a insistir en la petición del número. 00:51:11
Me diría, número negativo, prueba compositivos, 00:51:15
y quedaría esperando el nuevo valor que yo le introduzca. 00:51:18
¿Vale? 00:51:20
Porque me dice prueba compositivos, 00:51:21
pero me lleva al final del algoritmo, 00:51:22
con lo cual es un poco absurdo, tengo que volverla a ejecutar 00:51:23
¿vale? entonces 00:51:25
esta orden de prueba con positivos 00:51:27
es mejor llevarla a volver a pedir 00:51:29
el, ¿vale? perdón 00:51:31
la variable, por lo tanto 00:51:33
esa 00:51:35
esta 00:51:36
comprobación yo la haría 00:51:39
protegiendo el 00:51:41
leer, esto es como yo lo haría 00:51:43
¿de acuerdo? entonces, ¿qué voy a hacer? 00:51:45
le voy a poner un 00:51:48
repetir hasta 00:51:49
¿de acuerdo? 00:51:51
Y le voy a decir que me repita hasta que, bueno, voy a repetir esto, escribir, control, x, como aquí dentro, ¿vale? 00:51:53
Voy a escribir, introducir el número y leer el número, ¿hasta cuándo? Hasta que n sea mayor, bueno, hasta que n sea mayor o igual que 0, ¿vale? 00:52:06
Bien, si, como quiero ponerle el texto este, lo de número negativo, proba con positivos, este de aquí, si n es, ¿vale? 00:52:23
Si, tengo que ponerle un sí, ¿vale? 00:52:39
Si n es mayor que 0 estrictamente, no, es menor que 0, perdón, esto no es menor o igual, esto es menor, 00:52:45
no voy a decir nada, ¿vale? 00:52:59
hasta que n sea a no mayor o igual 00:53:02
¿vale? entonces aquí le voy a poner 00:53:03
esto, estoy reescribiendo simplemente 00:53:06
la protección, ahora lo entendéis 00:53:08
¿vale? estoy cambiando un poco de orden las cosas 00:53:09
y si no, no va 00:53:12
vale, entonces 00:53:14
aquí asigno ahora 00:53:15
el valor a proteger 00:53:18
y esto ya simplemente 00:53:19
si no, todo esto es 00:53:21
es x 00:53:23
este sí 00:53:31
ahora ya no es 00:53:33
Entonces, fijaros 00:53:34
¿Qué es lo que estoy haciendo? 00:53:37
¿Cómo me queda a mí mi programa? 00:53:40
Me queda, voy a repetir, introduzco el número y leer la variable 00:53:41
¿Vale? 00:53:44
Voy a ver si es menor que 0 00:53:46
Si es menor que 0, escribo número negativo, prueba con positivos 00:53:48
Y esto del bucle lo voy a repetir hasta que n sea mayor o igual que 0 00:53:51
¿Vale? 00:53:55
Por lo cual voy a estar escribiendo el número negativo, prueba con positivos 00:53:56
Hasta que n sea 0 o más que 0 00:54:00
Después, v lo actualizo con la variable inicial, esto ya es lo mismo que antes. 00:54:03
Si n es igual a 0 o n es igual a 1, pongo que el factorial es 1 y si no, pues le calculo su factorial. 00:54:09
Esto tiene mucho más sentido porque he protegido las entradas y he pedido las peticiones, 00:54:14
luego he comprobado el sí y luego me he metido en el sí. 00:54:18
Fijaros cómo funciona ahora. 00:54:21
A ver aquí, a ver si esto es válido. 00:54:23
Creo que sí. 00:54:31
Vale, introduce el número, el número va a ser menos 4, número negativo, prueba con positivos, introduce un número, perfecto, menos 3, menos 8, como soy tonto, pues ahora digo, ah, vale, venga, un número positivo es un 4, el factorial de 4 es 24, ¿de acuerdo? 00:54:32
¿Vale? Reiniciamos. Introduce un número. Si le pongo el 0, me da factorial de 0 es 1. 00:54:54
Si le pongo un 1, me da factorial de 1 es 1. Y si le pongo un número negativo, pues me dice que prevé con el número. 00:55:00
Ahora está funcionando de una forma mejor. ¿Veis que tiene muchas mejoras? ¿Vale? 00:55:06
Entonces, bueno, pues también así veis cómo se pueden mejorar, ¿vale? los programas. 00:55:10
Esto de PSINT es una maravilla porque nos permite escribir los algoritmos de una forma sencilla. 00:55:14
Me permite ver cómo me quedan. Fijaros en el diagrama de flujo ahora, cómo cambia. 00:55:19
¿Vale? Entonces ahora el diagrama de flujo me queda como os he dicho. Voy a hacer un bucle en el cual hasta que n sea positivo voy a estar pidiendo el número, 00:55:24
introduzco el número n y si es negativo pongo por pantalla simplemente el texto. ¿Veis cómo está hecho? 00:55:36
Y luego lo que hago es simplemente, si n es 0 o 1, pongo que el factorial es 1 y si no, lo calculo con el algoritmo manual y se ha dado. 00:55:43
de acuerdo, vale 00:55:50
llevo mucho tiempo hablando, voy a ver si 00:55:52
alguien se ha perdido, chat 00:55:55
abierto 00:55:56
has puesto algo de mal 00:55:57
vale, sí 00:56:00
a veces cometo pequeños 00:56:02
errores, pero bueno, ya veis que al final el programa 00:56:05
también te va dando 00:56:06
esos errores, vale 00:56:07
a ver, alguien tiene alguna 00:56:10
pregunta, alguien tiene alguna duda 00:56:13
sobre lo que hemos visto, vale 00:56:14
ya estamos, ya lo hemos terminado 00:56:16
ya esto es el final de la clase. Entonces, preguntas, venga, 00:56:19
preguntas que tengáis sobre los algoritmos, sobre la forma de analizarlos, 00:56:23
sobre cómo utilizar PSI. Os quiero enseñar, antes de 00:56:26
acabar, una cosa, ¿vale? Si nos vamos a 00:56:31
YouTube, 00:56:35
voy a entrar, es que no, no veo Juanel. 00:56:37
Vale, con las pantallas estas, vale, ahora. 00:56:43
Entonces, si vamos a YouTube, ¿vale? Y buscáis Juanra, ¿vale? Y buscáis Juanra, ¿vale? No, Juanra García, ahí estoy, ¿vale? 00:56:45
entráis en mi canal y veis que aquí tengo varios vídeos, tengo varias listas de reproducción. 00:57:17
Entonces, bueno, en las listas de reproducción hay una concretamente que es la de programación, ¿de acuerdo? 00:57:23
Y entonces esta lista de reproducción tiene pues algunos conceptos básicos sobre los diagramas de flujo, 00:57:30
pero tiene, fijaros, esto que es la instalación del primer algoritmo con PSINT, este vídeo es el que os dice 00:57:36
cómo descargaros e instalaros el PSINT y luego aquí os explico un poquito cómo funcionar con 00:57:42
PSINT con los comandos básicos y los comandos avanzados y también cómo utilizar PSINT para 00:57:48
poder programar algoritmos de control de robots. Pues los robots al final las entradas las cogen 00:57:54
a través de sensores, las salidas son actuaciones sobre los dispositivos de salida, sobre los 00:58:01
actuadores, con lo cual yo voy a activar 00:58:07
o desactivar esos actuadores 00:58:09
y el proceso 00:58:11
intermedio es lo que yo hago con los 00:58:13
valores que he leído de los sensores 00:58:15
y que ando haciendo con variables 00:58:18
para poder decidir si actúo 00:58:19
o no actúo sobre los elementos 00:58:21
de esa línea. Bueno, entonces eso 00:58:23
un poquito aquí lo tenéis, ¿vale? 00:58:25
Si queréis, pues bueno, son unos cuantos vídeos, esto 00:58:27
lo estoy grabando para la gente de 00:58:29
CPRPT, de proyectos 00:58:31
tecnológicos, de robótica de cuarto, 00:58:33
pero bueno, pues aquí también tenéis algo de información 00:58:35
creo que os puede ser útil para vosotros, ¿de acuerdo? 00:58:37
Y nada más, en principio esto es todo lo que tenía que contaros. 00:58:40
Os voy a recordar que tenéis el blog, ¿vale? 00:58:44
Tenéis el blog de clase. 00:58:48
A ver, un segundito, perdón. 00:58:52
¿Vale? En el blog, a ver si sale. 00:59:02
Vale, en el blog vais a segundo bachillerato, 00:59:07
es educa2madrid.org, Juan.Garcia146. 00:59:10
Aquí tenéis, ¿vale? Toda la información de todo lo que os voy mandando. Aquí tenéis los vídeos sobre los diagramas de flujo y los organigramas, que son esos vídeos que os han dado a enseñar, ¿vale? Que estaría bien que los vierais. Y el trabajo de Scratch. Aquí tenéis todo lo que os voy poniendo. Bueno, pues os pondré esta clase y os pondré también, pues, los próximos trabajos que os voy a enseñar. ¿Vale? 00:59:14
Bueno, chicos, pues nada más. 00:59:40
Abro por aquí el chat por si me tenéis que decir algo. 00:59:42
¿Vale? ¿Va a haber alguna clase más esta semana? 00:59:45
No. En principio voy a hacer una clase como mucho a la semana. 00:59:47
¿De acuerdo? Según lo vaya viendo. 00:59:51
Y voy a intentar consolidar un poco todo en una clase. 00:59:53
¿De acuerdo? Y luego ya os iré avisando. 00:59:56
Como tengo el correo de todos vosotros, ¿vale? 00:59:58
Os mando un correo y os mando la convocatoria. 01:00:01
Lo que voy a hacer es que a partir de ahora 01:00:03
siempre va a ser la clase en horario 01:00:05
de clase vuestro, con lo cual así no me coincide 01:00:08
con ningún otro profesor. Buscaré una de las dos horas 01:00:12
o la del lunes o la del jueves, probablemente 01:00:14
será la del lunes y en la hora del lunes 01:00:17
haremos la clase, ¿vale? Tengo que ver si tengo 01:00:20
material para dar la clase y si no, pues un poco con ejercicios 01:00:23
y como lo íbamos haciendo, vamos a ver. ¿De acuerdo? 01:00:26
¿Alguna pregunta más? ¿Tenéis alguien algo que decir? 01:00:29
alguna mano arriba 01:00:32
veo que nadie ha levantado la mano 01:00:34
todavía, alguna cosita más 01:00:36
cuidaros 01:00:38
e intentar aprovechar 01:00:40
al máximo el tiempo, que al final 01:00:42
esto vuela y todavía no sabemos 01:00:44
ni qué va a pasar con la evau, así que 01:00:46
en principio se hará un poco más tarde 01:00:48
pero eso va a ser, con lo cual no perdáis 01:00:50
el ritmo, ¿vale? 01:00:52
Pues venga, nada 01:00:55
cuidaros y nos vemos en la próxima clase 01:00:56
Venga, hasta luego 01:00:58
Chao 01:01:00
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:
127
Fecha:
14 de abril de 2020 - 14:38
Visibilidad:
Público
Duración:
1h′ 01′ 07″
Relación de aspecto:
1.78:1
Resolución:
1866x1050 píxeles
Tamaño:
183.16 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid