a nuestra siguiente speaker, una persona que estuve hace muy poquito con ella en Bogotá,
que estuvimos compartiendo, una persona maravillosa, que sabe un montón, muy simpática, que es
que, a ver, se me van a acabar las palabras buenas para hablar de la buena de Stephanie
Aguilar, así que vamos a darle paso a Tef Coat. Tef, ¿cómo estás?
Tef Coat. Hola, Miu, muy bien, muy feliz, aquí conectada en Miu Conf y antojadísima
de ese peluchito adorado que tienes. Está hermoso. Mejor dicho, felicidades por quienes
han ganado ese hermoso peluchito. Bueno, vamos a intentar hacer algo para que tú consigas
uno también. Lo haremos, lo haremos. Vamos a trabajar sobre ello. Pues, Stephanie, te dejo
a los mandos para que le comentes a esta gente cómo pueden subir su nivel en el mundo de
la programación, porque parece ser que vas a hablar de algo bastante interesante que la
gente luego dice, ay, es que no sé, la complejidad algorítmica. Bueno, pues, no va a ser tan complejo
con la charla de Tef Coat. Así que te dejo en los mandos, ¿vale? Voy a compartir tu pantalla.
Ponle las slides que las tienes por... Sí, yo aquí. Aquí, vale. Espero que aquí se vean.
Ahora, ya se ven y te dejo por aquí. Haga los mandos, lo tienes todo.
Perfecto. Gracias, Mido. Bueno, esta charla, más allá de que yo esté, hable y hable y hable
durante media hora, que es el tiempo que tengo, creo que voy a morar este tiempo, les tengo
un par de cuises. Entonces, yo estoy por acá súper juiciosa, los tengo aquí en el chat,
precisamente porque la idea es que yo haga esos cuises y ustedes respondan también aquí
en el chat. Vamos a ver qué tan bien les va. Pero solamente hay que tener mucha atención
en la charla, no es nada del otro mundo, así que vamos a ver, vamos a ver cómo les va
con este tema. Entonces, nada, vamos a hablar un poco de complejidad algorítmica, saber
cómo medirla, en especial cuando estemos trabajando con algoritmos, que cuando nos tocan este tema
de algoritmos, como que empezamos como, no, eso no es para mí, o eso es demasiado difícil,
por dónde empiezo, pero me gustaría, bueno. Entonces, resulta que el tema de algoritmia,
pues es muy amplio, son demasiados algoritmos, ustedes se van a encontrar un montón y la idea
o mi propuesta es que arranquen por algoritmos de ordenamiento, que justamente eso es que vamos
a hablar en esta charla. Entonces, resulta que hablando como a nivel general, si nosotros,
por ejemplo, vamos a invitar a nuestros amigos a nuestra casa a un súper desayuno,
pues, digamos que queremos desayunar obviamente al mismo tiempo, y para que eso suceda, pues
tenemos que empezar a calcular qué es lo que vamos a hacer. Si queremos hacer huevos, avena,
fruta, pues tenemos que, por ejemplo, empezar primero con los huevos, que por ejemplo pueden
tardar 10 minutos, yo estoy aquí diciendo cosas al azar, la avena 7 minutos, luego la fruta
la vas picando y se demoran 5 minutos. Entonces, ya sabes más o menos cómo organizar tu tiempo
para empezar primero por una cosa y luego terminar por otra. En este caso, estamos organizando
ingredientes y preparaciones para tener un desayuno, así tal cual en la vida cotidiana
es en software. Pero en este caso, cuando hablamos de algoritmos de ordenamiento, que sin querer
queriendo ahorita con el desayuno, hicimos un algoritmo de ordenamiento, pero ordenando ingredientes,
en este caso, en esencia es, si nosotros tenemos un array o una lista, como ustedes le llamen,
un diccionario, aquí tenemos unos números de 1 a 5, donde dice input, y están desordenados,
3, 1, 4, 5, 2. Justamente un algoritmo de ordenamiento busca ordenar esos números.
Entonces, ¿cómo nos quedaría? Pues, claramente, dependiendo del tipo de algoritmo, nos quedaría
al final 1, 2, 3, 4 y sí. Entonces, la esencia es organizar los números. ¿Para qué es importante
estudiar esto? Que muchas veces dirán como, bueno, ya organizo los números y ¿qué obtengo
con esto? Pues, bueno, la idea de estudiar esto es, uno, pues, resolución de problemas.
Nosotros en ingeniería de software estamos inmersos en este tema de resolución todo el tiempo,
o sea, todos los días tenemos que estar pensando en soluciones, en problemas, en solucionar bugs,
y esto nos sirve mucho para empezar a coger como cadencia en esta resolución de problemas.
Por otro lado, también iríamos con este tema de ampliar ya nuestro estudio, nuestro conocimiento
en algoritmos mucho más grandes. Entonces, para eso nos va a servir.
Y lo otro, por supuesto, es entrevistas técnicas, que estos sí o sí lo van a preguntar.
Entonces, es muy bueno que vayamos cogiendo como cierto ritmo, aprendiendo cómo solucionar
un problema, porque posiblemente en entrevistas de trabajo esto nos va a caer.
Entonces, para nosotros empezar a trabajar o estudiar con algoritmos de ordenamiento,
debemos tener en cuenta estos conceptos fundamentales.
Yo hice un súper resumen de todo lo que he estudiado, y eso es como el resumen diciéndoles
como, oigan, yo ya estudié un montón de cosas, esto es realmente lo único que ustedes van a necesitar.
Es, uno, saber de complejidad, tanto temporal como espacial, ya lo vamos a ver.
Estructuras de control muy sencillas, como lo son el if, el for y el why.
También los vamos a revisar más adelante, que uno también dice como, ah, un if, pues yo sé qué es eso.
Pero a la hora de uno tener un ejercicio, que ya lo vamos a ver, justamente vamos a tener un cuido sobre eso.
Uno dice, pero uno aquí, ¿qué utilizaría? ¿Un for? ¿Un why?
Entonces, bueno, vamos a entrar justamente en materia de estas estructuras de control.
Después, por supuesto, la creación de funciones, saber cómo se ejecutan, qué formas existen en JavaScript.
Entonces, esto es bien importante, porque un algoritmo, por supuesto, lo tenemos que ejecutar,
mandarle parámetros, el input, el output, bueno, eso lo tenemos que tener claro.
Luego, por supuesto, manipulación de arrays, porque si tenemos un array como entrada,
pues posiblemente en el camino de vamos a hacer algo con ese array, sea agregar elementos,
quitárselos, hacer un split o dividirlo, en fin.
Entonces, por eso es muy importante que tengamos también en cuenta este tipo de manipulación de arrays
con métodos, en este caso, de JavaScript.
Y por otro lado, por último, es como esas estrategias y esas implementaciones que tienen ciertos algoritmos.
Todos los algoritmos tienen como una forma como tal para poderse desarrollar.
Entonces, es muy importante que si nosotros estamos viendo el algoritmo A,
ese A, nosotros sepamos cómo es que se desarrolla.
También lo vamos a revisar más adelante.
Entonces, vamos a comenzar justamente con lo que es la complejidad temporal y espacial.
Mucho quedo con eso, porque por allí vienen las preguntas y los quiero súper atentos en el chat.
Cuando hablamos de complejidad, hablamos justamente de esos recursos
que nuestro código está consumiendo de nuestro computador como tal.
Entonces, cuando nosotros hablamos de un buen código, es justamente un código que sea escalable,
que nosotros podamos decir como hoy lo hice y mañana puedo mantenerlo.
Por ejemplo, que esto habla mucho del libro de Software Engineering at Google.
Me lo leí justamente este año, súper recomendado.
Y allí hablan mucho de la diferencia entre lo que es un programador y un software engineer.
La diferencia en sí aquí, spoiler alert del libro, es que un programador puede hacer tal cual un código y ya.
Pero un software engineer tiene muchos más conocimientos, entre ellos que hoy pueda tener este código,
pero mañana lo pueda seguir manteniendo y creando muchas más funcionalidades a partir de ese código.
Entre otras cosas, muchas otras, pero en esencia es esa como la gran diferencia.
Un coder hace código y un software engineer tiene otros tipos de consideraciones adicionales.
Y por otro lado, un muy buen código tiene que ser legible.
A veces creemos que por tener el código más complicado es el más pro y no.
La idea es que sea súper entendible, que de hecho este tema de los comentarios hay que tratar de incluso no hacerlos tanto en el código.
Digo no tanto porque a veces sí son necesarios, pero que la idea es que el código por sí mismo se lea y se entienda.
Entonces, para eso uno lo que hace es crear buenos nombres de variables, buenos nombres de funciones, etc.
Bueno, y ahora sí, entramos.
Complejidad temporal.
En esencia, hablamos de complejidad temporal cuando nosotros hablamos de la cantidad de operaciones que tenemos que hacer en un código como tal.
¿Qué causa esa complejidad de un tiempo?
Pueden ser, por ejemplo, operaciones, como estas que estamos viendo aquí en los slides.
Comparaciones, bucles, que esto es muy importante.
Bucles, complejidad tiempo.
Voy a volver a repetir, complejidad tiempo, bucles.
Llamadas a funciones y listo.
Por ese lado, si nosotros encontramos este tipo de cosas en nuestro código, ya sabemos que eso me aumenta la complejidad en tiempo.
Es decir, que si mi código tiene, por ejemplo, voy a decir cualquier cosa, ahorita lo revisamos con más detalle.
Pero entonces, si tiene, por ejemplo, un for dentro de otro for y tiene una llamada, una función.
Entonces, ahí empezamos a revisar.
Ah, es que tiene un for, pero por dentro hay otro, pero hay una llamada.
Entonces, eso le va aumentando cada vez esa complejidad en tiempo, haciendo más robusto nuestro código.
Y, por otro lado, tenemos la complejidad espacial, que nos habla de cuál es la memoria que estamos utilizando en nuestro computador.
Que muchas veces, no sé si han escuchado o se han puesto en la tarea de revisar qué computador es bueno para programar.
Bueno, justamente entra en qué tanto recursos a nivel de nuestro código estamos utilizando.
Si nosotros tenemos, como en este caso, que es lo que causa complejidad en espacio, muchas variables, muchas estructuras de datos, llamadas a funciones, asignaciones, pues eso va consumiendo recursos de nuestro computador.
Entonces, ahí es donde nosotros decimos, bueno, si yo tengo una súper máquina con una súper RAM, pues claramente me va a funcionar para todas las cosas que yo estoy necesitando, porque hay el espacio suficiente para yo almacenar todas estas cosas.
Entonces, bueno, resulta que ya hablamos nosotros de complejidad temporal y de complejidad espacial.
Ya sabemos que esos son recursos que nosotros necesitamos.
Esos recursos nosotros los medimos en algo que se llama notación Big O.
Entonces, qué tan rápido es, qué tan lento es, siempre vamos a hablar de esta notación.
Por ejemplo, si nosotros corremos 10 kilómetros, claro, hablamos de kilómetros.
En este caso, pues la unidad de medida sería notación Big O.
Bueno, aquí les hice una tabla ultra resumida.
Como les diría al principio, eso fue como que ya me estudié un montón de cosas, aquí es el resumen del resumen.
Tengo tres tablitas como tal, como unas muy buenas, que van a estar en verde, que ustedes lo van a súper notar.
Es muy importante que detecten los colores, solo diré eso.
Y esos colores acá van a denotar qué tan buena o qué tan mala es esa notación o esa complejidad como tal.
Entonces, en este caso, cuando nosotros hablamos de notación Big O, también lo vamos a relacionar con unas gráficas.
Yo en este caso omití el tema de las gráficas, pero ustedes también pueden ir a googlearlo.
Pero en esencia, la primera sería notación Big O de 1.
En este caso, sería constante.
La gráfica, pues por supuesto, ustedes se la imaginarán.
Y digamos que mi idea fue colocar en qué casos uno lo puede encontrar en el código.
O sea, si yo veo eso en el código, yo ya sé inmediatamente que eso es O de 1.
En este caso, es por ejemplo, acceder a un elemento de un array.
Como en este caso, que sería array en la posición 2, eso ya inmediatamente sé qué es O de 1.
Y qué es constante y que como está en verde, check.
Por otro lado, entre las buenas complejidades, sería log n, que sería logarítmico.
Y en este caso, debemos pensar en cuándo se divide este input o este array varias veces.
Hay un método de resolución de algoritmos que se llama divide y vencerás.
Y justamente esto habla de hacer una partición de ese array.
Entonces, justamente cuando ya veamos qué debemos entre las analogías o las formas de resolver el algoritmo,
dividirlo, ya inmediatamente sabemos qué es logaritmo de n.
Listo.
Segunda tabla de 3.
En este caso tenemos, casi no se ve bien, pero es tan amarillo, big o n, que este no lo vamos a encontrar muchísimo.
Su nombre es lineal, ya también por la gráfica sabemos cómo va.
Y cuándo sucede, pues justamente cuando tenemos un for o cuando tenemos un while,
mejor dicho, cuando tenemos que recorrer justamente ese input que ya tenemos desde ese array.
Por otro lado, tenemos log n, que es lineal logarítmico.
Y aquí es algo parecido a lo que veíamos ahorita de dividir el array,
pero en este caso es dividirlo, pero volverlo a dividir.
Entonces, cuando tengamos ese tipo de casos, ya sabemos y ya inmediatamente tenemos comúnmente qué es n, log n.
Última tablita donde está anotación big o, tenemos dos que son como críticas,
que en este caso sería n cuadrado o cuadrático, y sucede en esencia cuando nosotros tenemos que recorrer un array,
pero al recorrerlo también tenemos que comparar ese recorrido con otro inmediatamente.
Básicamente cuando tenemos como un for dentro de otro for.
Entonces tengo, por ejemplo, el for de afuera con i, i igual a cero.
Entonces ahí ya tenemos array en la posición cero.
Y si entra nuevamente otro for, que sería con j, por ejemplo, que es como lo más común,
ahí inmediatamente ya sabemos que si estoy en la posición 1 y empiezo a comparar con los otros índices de mi array,
ahí ya sé que, por supuesto, es n cuadrado.
Y lo último es 2 a la n, o también exponencial, y es cuando nosotros hablamos de posibilidades.
Entonces si tenemos X cantidad de posibilidades de que X cosa suceda, ya sabemos que es exponencial.
Entonces, espera, haya servido mi carreta porque aquí viene lo interesante.
Vamos a hacer un resumen.
Notación big o, en esencia es para nosotros expresar esa complejidad de un algoritmo,
ya vimos que puede ser o temporal o espacial, dependiendo de los recursos que nosotros estemos como analizando en el momento.
Complejidad temporal, ya sabemos que es cuánto se puede tardar mi algoritmo.
Hay unos que se demoran más, hay otros que se demoran menos, dependiendo también de la cantidad de input que nosotros tengamos.
Si tenemos un array de 5 va a ser muy distinto a si tenemos un array de 20 elementos o 100, lo que sea.
Y complejidad espacial, pues ya sabemos que es la cantidad de memoria que puede utilizar.
Y ya también vimos que hay ciertos casos especiales en los que nosotros podemos decir,
ah, si estoy creando una variable, entonces estoy utilizando un recurso de la memoria,
entonces aquí se está, mejor dicho, utilizando más espacio en mi memoria, entonces hay complejidad espacial.
Muy bien, ya tenemos ese resumen.
Ahora, teníamos esos conceptos fundamentales desde el principio, ya hablamos de complejidad,
ahora sigue lo que son las estructuras de control, voy a pasar muy rápidamente por ahí,
no me voy a tener como demasiado en esto, pero más adelante les voy a decir dónde sí pueden estudiar estas cosas.
Entonces tenemos if, que básicamente es una condición en donde nosotros decimos como,
bueno, si da esta condición, es verdadera, entonces sucede lo que hay dentro de ese if,
y si no, pues sucede otra cosa. Entonces, en esencia es un condicional.
Un for, lo que hace es, si nosotros tenemos, en el caso, en este que está aquí,
let i igual a cero, i menor a cinco, i más más, vamos a imprimir un hola estudiante y class one.
En este caso sería hola estudiante y todas las iteraciones, ¿no?
Entonces lo que va a hacer es un recorrido, dependiendo de lo que tengamos en este caso,
que puede ser, por ejemplo, un array. Un if y un for pueden ir juntos,
en este caso podría ser un for y dentro sería un condicional.
Entonces, a medida que vamos iterando en algo, puede ser un array,
le podemos decir, ah, cuando llegues a tal punto, entonces imprímeme tal cosa.
Eso es lo que podemos hacer con un if y con un for.
Y por último, tenemos un while, que también se puede asemejar,
o siempre como que lo ponemos en comparación con el for,
que aunque son diferentes, también nos ayudan como a empezar a iterar,
o a ir revisando elementos, que ya vamos a revisar también ese tipo de casos.
Pero acá, por ejemplo, tenemos un contador,
y ese contador le estamos diciendo, bueno, inicialmente es un uno,
pero cuando entré al while es, ah, bueno, si ese valor de contador es menor o igual a cinco,
entonces imprímeme tal cosa.
Y súmalo. Entonces aquí le estamos diciendo como, ah, mira,
vas a sumarle, pero hasta cuando llegue a cinco.
Y fin, entonces ahí termina.
Muy bien.
Entonces vamos a empezar.
Yo por acá tengo ya el chat activado para ver cómo nos va en mis preguntas
y qué tan atentos están y atentas.
Entonces, bueno, tenemos este ejercicio que curiosamente,
recuerdo que en mi primera charla, pero como asistente,
la speaker, me acuerdo que había puesto este ejercicio que se llama FISBAS,
y nos dijo como, ay, este ejercicio me cayó en una entrevista técnica para Junior,
y bueno, se los voy a mostrar y hagámoslo.
Recuerdo que ese fue el primer ejercicio, en la primera charla yo fui asistente.
Yo le digo, pero ¿cómo se hará?
Yo estaba en la universidad en ese entonces,
y resulta que tiempo después me cayó en una entrevista para Junior,
este mismo ejercicio, curiosamente.
Pero bueno, el tema es que como se utilizan bucles,
entonces, bueno, por eso es que es tan sonado,
obviamente ya lo han cambiado, y bueno, ya,
además que han pasado los años, y dirán, pues, cambiémoslo.
Pero bueno, entonces, este, en esencia, lo que les quise contar aquí es que
es un ejercicio muy común, y muy, también muy sonado,
y que es, mejor dicho, clave, pues, en uno como programador.
Se llama FISBAS, y dice, imprime FIS, es la palabra FIS,
para los números que sean múltiplos de 3,
imprime BAS para los números que sean múltiplos de 5,
imprime FISBAS para los números que sean múltiplos de los 2,
o sea, de 3 y de 5.
Y si no es múltiplo de ninguno,
entonces, vamos a imprimir el mismo número.
El código, yo aquí se los tengo, no se preocupen,
no los iba a poner a ser código.
Aquí está.
Es una función que se llama FISBAS,
y tenemos un FOR,
en este caso, empieza desde 1 hasta n,
y lo que hace por dentro es empezar a validar
cada una de esas posiciones de ese número.
Entonces, ah, ok, este número es múltiplo de 3 y de 5.
Ah, entonces, hasta el cosa.
Ah, es solamente de 3, hasta el cosa.
Ah, es solamente de 5, entonces, hasta el cosa.
Entonces, él hace un recorrido,
y después, con el IF, empieza a validar
si es múltiplo o no de eso que nos dijeron al principio,
de 3 o de 5, o lo que sea.
La salida sería algo como lo que vemos al lado derecho,
que es 1, 2,
se imprimen los números normales
porque no son múltiplos ni de 3, ni de 5, ni de ambos.
Luego FIS, porque es múltiplo de 3.
4, BAS, FIS, 7, 8, FIS, BAS, 11, FIS, 13, 14, FIS, BAS.
That's it.
Listo.
Ahora, ahora sí.
Ahora sí, queridos míos.
Viene la parte interesante.
Vamos a calcular la complejidad en tiempo de este ejercicio,
que es bastante sencillo.
Yo al principio les conté cómo es que nosotros podemos hacer
para calcular esa complejidad en tiempo.
Entonces, ¿cuál sería esa complejidad?
Ustedes, ¿qué dicen?
Me encantaría que me cuenten también por aquí en el chat.
Si es buena, no es necesaria tampoco.
Si de pronto no se lo memorizaron,
que me cuenten si es de color verde, amarilla, naranjita,
o si es roja.
Entonces, como muy buena, crítica, en la mitad.
No importa, no es necesario que me digan
cómo la complejidad como tal en Big O.
Entonces, por ahí han dicho que ODN, ODN, lineal, rosita.
Bueno, muy bien, listo.
Entonces, vamos a revisar cómo es.
Bueno, para quienes dijeron ODN, súper bien, aplausos,
abracitos virtuales.
Y bueno, en la esencia es porque nosotros ya tenemos un FOR
y ese FOR nos crea esa complejidad en tiempo,
en este caso, en este ejercicio.
Ahora, pregunta número dos.
¿Cuál es complejidad en espacio de este mismo ejercicio?
Entonces, vamos a ver, por ahí están dando aplausitos.
Igual, de nuevo, pueden decirme si es OD1, ODN, ODN cuadrado.
Si me dicen el por qué, ganadorcísimo.
Por ahí dicen que ODN, OD1, ahí están como muy dudosos y dudosas.
Bueno, tres, no, pero tres, acuérdense que no.
O de uno, constante, O de uno, listo.
Vamos a revisar.
Muy bien, aplausos para quienes respondieron.
O de uno, en este caso, es porque creamos una variable.
Acuérdense que espacio es memoria, o sea, como que uno lo asocia de una vez.
Y en este caso, solamente creamos una variable que es dentro de este FOR,
que es LED y igual a uno.
Ya estamos ocupando un espacio.
Y por eso es que tenemos este OD1, que de todas formas es complejidad buena.
Listo.
Bueno, este tema de los condicionales me lo salté,
pero justamente en diciembre del año pasado,
tuve la oportunidad de grabar una ruta de JavaScript en Platzi justamente.
Entonces, por si están interesados de aprender JavaScript desde cero,
aquí se los dejo, platzi.com.
Y bueno, en Platzi.com es las cursos, las JavaScript como más enfocado,
ahí están todos los conceptos de IF, FOR y WHY.
Muy bien.
Ahora sí, vamos con el tercer concepto fundamental.
Ya pasamos por las complejidades, luego por las estructuras de control,
y ahora vamos por la creación y ejecución de funciones.
En esta también va a ser como abuelo de pájaro, muy rápido.
Y es en esencia que nosotros podamos saber cómo crear una función,
qué otras funciones hay, cómo las llamamos, los parámetros,
o sea, que sepamos ese tipo de cosas son esenciales,
porque como podemos ver, un algoritmo necesitamos ejecutarlo.
Entonces, claro, al tener que ejecutarlo de alguna manera,
pues necesitamos una función.
¿Verdad?
Entonces, listo.
También en este curso que tuve la oportunidad de grabar,
también se los dejo.
Ahí tengo como un súper módulo que les preparé para contarles
todo, todo, todo sobre este tema.
Y se viene manipulación de arrays.
También creo que eso se los contaba también al principio,
y es que nosotros podamos entender qué es un array.
Un array, el tipo de dato en JavaScript como tal,
no es un array, es un objeto.
Y como objeto tiene métodos, y esos métodos nos permiten precisamente la manipulación de estos arrays.
Entonces, métodos que nos podemos encontrar, por ejemplo,
shift, pop, push, unshift, que lo que nos hace es ingresar elementos o sacar elementos del array.
También les había mencionado que podemos hacer división de ese array.
En fin, como que al menos conocer los principales y poco a poco también irse desenvolviendo a medida que se van desarrollando diferentes ejercicios.
También en este curso les tengo varios métodos explicados por si de pronto se pegan una chismosadita por allá.
Y finalmente está el tema de las estrategias de implementaciones.
O sea, es decir, lo que también les comentaba al principio.
Si tenemos un algoritmo, normalmente tienen ciertas formas de hacerse.
Y es importante que entendamos cómo es que son esas formas de hacerse.
Yo sé que algoritmos de ordenamiento hay aproximadamente nueve.
A veces podemos encontrar uno que otro de más, pero básicamente son estos que vemos acá.
Hoy, por temas de tiempo, vamos a ver solamente uno de ellos, que es Babelsort.
Pero aquí lo que tengo en mente, y mejor dicho, mi idea con esta charla en esencia,
es que nosotros podamos entender cómo estudiar este tipo de cosas.
Que yo sé que muchas veces uno como que se sienta en un sillón a llorar porque no sabe cómo hacerle.
Esta es mi forma y cómo lo he venido estudiando y que a mí me funciona.
A cada uno le puede funcionar de una manera diferente y está súper bien.
Yo les comparto lo que a mí me ha funcionado y que les des muchas ideas
para que ustedes puedan seguir estudiando esto y otras cosas que necesiten.
Entonces, vamos a empezar por Babelsort.
Este, que aquí también vienen los quizzes, señores y señoras.
Resulta que Babelsort lo que va a hacer es tener un array y va a tomar dos posiciones de ese array.
Así como vemos aquí en pantalla.
Tenemos, por ejemplo, el 3 y el 1.
Lo que él va a hacer con esas dos posiciones que siempre va a tomar es empezar a decir,
bueno, el primero, en este caso sería 3, es mayor que el segundo, que en este caso sería 1.
Entonces, sí, sí, hace un cambio.
Claro, porque necesitamos organizar.
Necesitamos que, en este caso, tenemos este array que es 3, 1, 4, 2.
Nos queda al final como 1, 2, 3, 4.
Entonces, él lo que va a hacer es tomar dos posiciones.
Esa es la idea de Babelsort.
Tomar dos posiciones, compararlas y switcharlas.
Luego, vuelve y toma las otras dos posiciones y las switchea.
Y así sucesivamente, que es lo que vamos a ver en los pasos.
Entonces, primer paso de Babelsort.
Toma el 3, toma el 1.
Dice, 3 es mayor que 1, entonces sí, hago el swap.
Y el resultado sería como el array de abajo.
Paso número 2.
Ya tendríamos el segundo array, o sea, el resultado de lo que nos dio anterior a hacer el swap.
Y pasa como a la siguiente casillita, que en este caso sería 3 y 4.
Y empieza otra vez a preguntar, ¿3 es mayor que 4?
En este caso, él dice no.
Entonces, como 3 no es mayor que 4, los deja igual.
Luego, pasa lo siguiente, que ya serían 4 y 2.
¿4 es mayor que 2?
Sí.
Entonces, dice, bueno, entonces ese no es el orden correcto.
Vamos a hacer el swap.
Y quedaría como está en la parte de abajo.
Cuando termina, él vuelve a empezar.
Porque él necesita, o sea, una vez él termina, imagínense un array mucho más grande.
Él hace el swap de dos elementos, pero eso no quiere decir que ya todo el array esté terminado.
Él debe volver a empezar, en este caso sería el paso número 4, pero miren que otra vez volvió a lo inicial,
para garantizar que estos dos elementos sí estén en el orden que son.
Entonces, por ejemplo, 1 y 3, vuelve y pregunta, ¿1 es mayor que 3?
No.
O sea, que están bien, dejémoslos ahí.
Luego sigue y dice, ¿3 es mayor que 2?
En este caso sí, entonces hace el cambio.
Miren que acá, a pesar de que volvió a pasar, no quería decir que estuvieran en el orden correcto.
Le tocó volver a revisarlos y hacer el swap.
De nuevo, va a estas dos posiciones, 3 y 4, 3 es mayor que 4, sí.
Y digamos que en este caso ya terminó.
Y eso sería como un zoom out de todo lo que acabamos de hacer.
Podemos empezar desde la parte número 1, desde el paso 1, y analizarlo de nuevo.
3 y 1, 3 es mayor que 1, y hace ese swap.
Luego 3 y 4, no hace el swap.
Y así sucesivamente.
Es como que nosotros entendamos muy bien qué está pasando.
Aquí es netamente nosotros sentarnos en una mesa, en un escritorio, coger lápiz, papel y rayar y analizar qué es lo que hace Babelsort a nivel visual.
Una vez uno ya tiene súper entendido esto a nivel visual, ahí sí, uno lo que hace es pasar al código, que eso también es un súper tip para entrevistas de trabajo.
¿Por qué?
Porque esto, si a uno le ponen un ejercicio, uno llega, y si uno llega a hacerlo de una, entonces es porque no ha analizado bien el ejercicio.
Bueno, y que le estás hablando al entrevistador, entonces es muy bueno que ustedes en una entrevista se sienten a analizar el ejercicio,
que lo hablen también, lo expongan y digan, ah, mira, yo creo que esto es así, así, así, así, si tienen algún iPad o algo para rayar virtual, también lo hagan.
O sea, que muestren realmente que ustedes están entendiendo y que luego de entenderlo, ahí sí pasamos al código.
Entonces, eso es lo que vamos a hacer ahorita.
La primera parte de nuestro ejercicio, nuestro Babelsort, teníamos este 3, 1, 4, 2.
Esto es tomar el array en la posición 0 y el array en la posición 1.
Bueno, aquí viene el quiz, aquí viene el quiz.
Luego, él toma array en la posición 1 y array en la posición 2.
Después, toma array en la posición 2 y array en la posición 3.
Miren que ahí como que terminó el array, pero él volvió a empezar y dijo, ah, bueno, array en la posición 0, array en la posición 1.
Y siguió así sucesivamente hasta que él vio que ya estaba organizado.
Ese proceso de nosotros tomar 2 elementos, luego 2, 2, 2, y luego volver a empezar 2, 2, 2, 2.
¿Cómo sería en código?
Esa es la pregunta del millón.
Entonces, aquí se viene el quiz time.
Aquí los tengo, mejor dicho, en el chat.
Entonces, ¿cómo se le llamaría a él?
¿Ustedes cómo harían esto en código?
A, con un if, B con un for, C con un for, if, o D con un y.
Entonces, por aquí dicen D, C.
Muchas gracias.
De nada.
D, D, D, D, D, D, B, C.
Eso está entre la D y la B.
Dios, Dios, C, D.
Bueno, vamos a revelar la respuesta.
La respuesta correcta es D, guay.
Abracito virtual para quienes lo tuvieron bien.
Sí, es un guay.
¿Se acuerdan que también les hablaba de que teníamos el for, teníamos el guay?
Y a veces como lo asemejábamos.
Bueno, en este caso le estamos diciendo a él que mientras pase algo, va a suceder otra cosa.
Aquí en esto, ¿cómo sería en el código?
Nosotros tenemos que saber si él está organizado, o si se hizo el swap, o si no se hizo el swap.
Y ese va a ser como nuestro detonante, y nuestro, mejor dicho, el que va a ponerle el stop o el arranque a nuestro while.
Entonces vamos a decir, ese swipe, no quiero decirlo en spanglish, pero me toca, porque no sé cómo decirlo en español.
Pero bueno, el swap, como el giro de los dos, bueno.
Sería do, empezamos con un do.
En este caso decimos que no, no sea swipeado.
Entonces le colocamos false, es decir, que está quietico.
Y entonces el while nos va a decir que solamente mientras hagamos ese swap, que nosotros vamos a entrar justamente a ese do, ¿no?
Entonces, así quedaría como esa partecita de código.
Miren como, miren lo bonito.
Como desde la parte visual, uno puede analizar qué es lo que está haciendo para de una vez empezar a traducirlo en la parte de código.
Segundo quiz, señores y señoras.
Tenemos otra vez nuestro array, y ya dijimos que en el paso uno hacemos el swap, porque él compara tres y uno, y como tres es mayor que uno, entonces hacemos el swap.
Ay, me quedan blanco estas líneas, pero bueno.
Tres y cuatro, no swap.
Cuatro y dos, swap.
Luego uno y tres, no swap.
Eso de swap, no swap, ¿con qué lo haríamos en código?
Entonces, quiz time.
A con if, D con for, C con for if, o D, ay, me equivoqué, lo siento, es D, while.
Ustedes ahí pónganle el D.
Listo.
D de Diosito.
Me encanta Alejo Barra.
A, listo, C, A, A, uf, muchos están yendo por el A.
Piénsenlo muy bien, yo solamente diré eso, piénsenlo muy bien, muy bien.
Porque, miren que él hace el swap, pero tiene otra cosa.
¿Y cuándo hace ese swap?
Pero ya dicen C, F, jajaja, F no está.
Jajaja, listo.
Entonces, respuesta del quiz es C, un for if.
Miren lo que tocó hacer.
Tocó ir posición por posición.
Entonces, ya cuando uno le dicen, ah, es que yo tengo que ir pasito a pasito, pues, tiene que haber un for,
y luego tengo que comparar tres con uno.
Entonces, ya sabemos, recorrido más comparación, if, entonces for, if.
Muy bien para quienes tuvieron la C.
El código se vería algo así.
Tenemos un for que intera desde la posición número cero.
En el if lo que hacemos es saber si existen esas posiciones que estamos validando.
Y una vez sepamos que sí, empezamos a decir, posición uno es mayor que posición dos.
Empezamos a almacenar una de las dos para hacer el swap.
Y listo, ahí queda.
Entonces, ese sería nuestro maravilloso swap con un for if.
Muy bien.
Entonces, este sería nuestro bubble sort.
Ya el ejercicio terminado, imagínense.
Ya terminamos.
Fue demasiado rápido, ¿no?
Entonces, aquí tenemos una función que se llama bubble sort.
Tenemos el let que tiene esta variable que es swap.
Luego el do, que entra con este for, el if, para saber si hacemos el swap.
Y termino.
Ahora, viene el tema de la complejidad.
Que siempre que estemos trabajando con algoritmia, tenemos que revisar dos cosas importantes.
Complejidad en tiempo y complejidad en espacio.
Y para complejidad temporal, lo más, también para espacial, pero más para temporal, debemos revisar mejor, promedio y peor caso.
¿Cómo nosotros sabemos eso?
Vámonos primero al mejor caso.
Complejidad temporal, mejor caso.
Ustedes que dicen, ¿uno cómo puede revisar?
Yo aquí los sigo leyendo en el chat.
Uno, ¿cómo puede saber cuándo es el mejor caso para este ejercicio?
Y encima, analizarle la complejidad temporal.
Dios mío, ahí ya se nos estalló el cerebro.
Dios como, no, hasta ahí estaba muy bien.
Bueno, ahí ya me dieron la respuesta de los dos, pero no, wait, wait.
Vamos, paso por paso.
¿Cuándo es el mejor tiempo?
¿Cuándo es el mejor momento para este array?
Díganme acá.
La pregunta, empecemos por esa pregunta súper sencilla.
¿Cuál es el mejor tiempo para este ejercicio?
Para este bubble switch.
Sí, yo creo que aquí lo dijo ztwarriorbudu.
El mejor tiempo va a ser, por supuesto, cuando el array esté ordenado.
Entonces, si nos dan el array, un, dos, tres, cuatro, no hay que hacer nada.
O sea, nuestro programa no tendría que hacer nada.
Ese es el mejor tiempo.
Entonces, ¿nosotros cómo lo calculamos?
Por supuesto, esto sería con nuestro...
Estefani, te voy a cortar porque es que no sé cuánto te queda,
pero es que te has pasado ya cinco minutos.
Y va un fatal de tiempo y me sale fatal.
Me sale fatal.
Entonces, nada, si le puedes dar cañita para que veamos la solución final.
De una, de una.
Solo nos falta esta y ya.
Perfecto.
Bueno, listo.
Entonces, ODN, precisamente porque pasa por nuestro for, pero ustedes dirán, bueno, hay un for y hay un while.
Entonces, el while, ¿qué pasa con él?
Pues, por supuesto, como el array ya está organizado, pues, él no tiene que hacer nada más.
Entonces, nunca entra ese while y por eso no lo incluye.
Entonces, es muy importante también tener en cuenta ese tipo de cosas.
Y ya, por supuesto, tendríamos la parte promedio o la parte peor, que en este caso sería la misma.
Y es cuando el array ya no esté ordenado, sino que, por supuesto, esté súper desordenado.
Es decir, que tenga que entrar tanto a nuestro for como a nuestro while.
Y listo.
Aquí lo que hacemos es multiplicarlas y ya nos daría ODN cuadrado.
Complejidad espacial, para que terminemos.
Ya seríamos contar, por supuesto, nuestras variables, las que creamos y que nos crean, por supuesto, espacio en la memoria.
Y sería LEDSwap, el LEDI que está dentro del for.
Y la otra es esa constante temporal para nosotros poder guardar el valor y hacer ese swipe, etc.
Nosotros podemos decir que es OD3, pero es ideal que en este caso lo simplifiquemos y digamos que es OTN.
Bueno, que en este caso, el peor caso, pues es bueno, pero eso solamente es para arrays que tengan poquitos elementos como esto.
Y bueno, entonces, ya para terminar, entonces tenemos BubbleSort.
Yo sé que hay muchos más algoritmos de ordenamiento.
Ya les di como una guía, pero aquí les presento también a mi súper amigo ChatGPT.
Este sería un ejemplo de prompt que ustedes podrían hacer para poder seguir aprendiendo esto y así, como muy visual, que les explique y demás.
¿Cómo sería?
¿Podrías explicarme el algoritmo de InsertionSort?
Me gustaría una guía paso a paso para entenderlo tanto a nivel visual como el código en JavaScript.
Además, me gustaría que me ayudes a comprender la complejidad en tiempo y en espacio el algoritmo,
incluyendo los casos de mejor, peor y promedio.
También le he dicho que me lo expliqué con manzanas y lo ha hecho.
Entonces, ustedes tómense la libertad de poder explicarle esto, de hacer un muy buen prompt,
para que ChatGPT les pueda como orientar ahí en este caso.
Siguientes pasos.
Nada, nuevamente la ruta de JavaScript que tuve la oportunidad de grabar que les comentaba al principio.
Solamente ingresen a platzi.com, slash ruta, slash javascript, guión, fundamentos.
Y ahí tenemos un montón de cosas para aprender JavaScript desde cero.
Lo otro es agendémonos para estudiar.
Y aparte de agendarnos, pues, por supuesto, es no solamente agendarnos, sino cumplirnos.
Entonces, podemos decir como el lunes repaso la semana anterior, martes y miércoles entendimiento visual,
y el jueves y el viernes, pues, por ejemplo, conversión visual a código, pues, lo que hicimos justamente ahorita.
Entonces, cada uno se agenda y se cumple también.
Se vería algo así, como que rayen mucho, traten de tomar hojas, apuntes, cuadernos, bueno, lo que sea.
Y un libro recomendado, pero esto sí ya es más matemática, para que puedan entender un poquitico más por debajo cómo es que esto funciona,
que también hace muchísimo sentido, es este de Introduction to Algorithms.
Entonces, ahí se los dejo.
Y nada, me pueden seguir en redes sociales como Tefcoat.
Muchas gracias, Stephanie, que lo siento, que es que vamos de tiempos justos.
Y cuando he visto que todavía ha faltado por calcular más complejidad, he dicho, hostia, que no lo da.
Y al pobre Pablo le va a salir hasta pelo al pobre que tenía al Pablo ahí esperando.
Bueno, es que ya se nos ha acumulado que tenemos aquí hasta el siguiente, del siguiente, del siguiente.
Así que, bueno, no pasa nada, no pasa nada.
La verdad es que se va acumulando los retrasos uno detrás del otro y es lo que hay, lo que tiene las conferencias.
Bueno, Stephanie, muchas gracias por pasarte, gracias por enseñarnos sobre complejidad algoritmica
y espero y deseo verte pronto.
Nos vemos en Medellín.
Listo, gracias a ti, Mido.
Muchas gracias, Tef.
Bye, éxitos en la MidoConf.
Bye.
Gracias, muchas gracias.
Por lo que sigue, bye.