Lo que no suelen enseñar en los bootcamps. Implementaciones prácticas de algoritmos comunes en JavaScript idiomático.

Te presentaré cómo pensar en algoritmos, cómo estimarlos, optimizarlos, recursiones y todo lo que necesitas saber como un ingeniero de JavaScript creíble . Cosas que desearía haber sabido antes en mi carrera al entrevistarme.

Relájate, tómate tu tiempo y disfruta.

¿Qué es un algoritmo?

• Es un conjunto de instrucciones para resolver un problema.
• Como ingeniero, su trabajo / objetivo es resolver problemas.
• Al resolver problemas, identifica patrones / técnicas que son más eficientes / eficaces
• Recuerde que hay muchas formas de resolver un solo problema, pero ¿cuál es la más rápida cuando aumenta la cantidad de datos de entrada a procesar?

• La complejidad del tiempo es cuántas operaciones primitivas se ejecutan en un algoritmo a medida que se le envían datos.
• Ayuda a razonar sobre la velocidad de un algoritmo
  - Es una aproximación del tiempo que lleva ejecutar un algoritmo a medida que aumentan los datos de entrada
  - Es una aproximación porque no se puede predecir exactamente cuánto tiempo tardará un algoritmo en ejecutarse en cada tipo posible de arquitecturas de máquina / entornos / configuraciones de hardware / etc.
  Entonces, en lugar de usar segundos o milisegundos, se usa un factor de crecimiento para indicar cuánto tiende a crecer un algoritmo a medida que lo alimenta con datos.
• En resumen, la complejidad del tiempo es cuántas operaciones primitivas se ejecutan para resolver un problema a medida que crece la entrada y en el peor de los casos .
• Piense en el costo de las operaciones realizadas. Cuanto más rápido es un algoritmo, más datos puede procesar en un tiempo razonable.

• La complejidad del espacio es cuánta memoria se usa con respecto al tamaño de entrada al ejecutar un algoritmo

Digamos que tiene una lista de proveedores de VPN en una plataforma. Quieres resolver por los más caros y los más baratos. Recuerde que se siguen agregando proveedores todos los días, por lo que la lista sigue creciendo.

const vpnProviders = [
 { name: 'totoVpn', price: 234 },
 { name: 'titoVpn', price: 321 },
 { name: 'tatoVpn', price: 99 },
 { name: 'tutoVpn', price: 54 },
 ...
];

A medida que recorre la lista, realiza un seguimiento del precio más alto y más bajo por iteración.

Veamos una representación de cuando se busca el precio más caro:

       |  234  |  321  |  99  |  54  |
--------------------------------------
  234  |  --   |  321  |  234 |  234 |
--------------------------------------
  321  |  321  |  --   |  321 |  321 |
--------------------------------------
   99  |  234  |  321  |  --  |  99  |
--------------------------------------
   54  |  234  |  321  |  99  |  --  |

 # of providers (n)  |   4  |  11  |  100     |  2000      |
------------------------------------------------------------
 # of operations     |  16  |  121 |  10,000  |  4,000,000 |

• a medida que aumenta el número n de proveedores, el número de operaciones aumenta en la potencia de dos (4², 11², 100² operaciones).
• Básicamente, cuanto más crezcan tus datos, más enorme será el trabajo que necesitarás.

      |  234  |  321   |  ...  |  99  |  54  |
----------------------------------------------
max?  |  234  |  321   |  ...  |  321 |  321 |

      |  234  |  321   |  ...  |  99  |  54  |
- --------------------------------------------
min?  |  234   |  234  |  ...  |  99  |  54  |

• Cada elemento de la lista se mira solo una vez en la iteración del bucle y se almacena si cumple la condición (es máximo, es mínimo)
• aquí, la complejidad del tiempo es lineal ( aquí, 2n) debido a los dos bucles distintos que miran todos los elementos una vez
• el número de operaciones a realizar es el doble del número de elementos o simplemente, a medida que aumentan los datos, el trabajo aumenta en 2.

# of providers (n)  |   4  |  11  |  100  |  2000  |
----------------------------------------------------
 # of operations    |   8  |   22 |  200  |  4,000 |

const vpnProviders = [
 { name: 'tutoVpn', price: 54 },
 { name: 'tatoVpn', price: 99 },
 { name: 'totoVpn', price: 234 },
 { name: 'titoVpn', price: 321 },
 ...
];

• sin necesidad de bucles, solo 2 operaciones, establezca el primer valor como mínimo y establezca el último valor como máximo
• por lo tanto, la complejidad temporal del algoritmo tiene un crecimiento constante porque no importa el número n de elementos, el número de operaciones permanece igual

# of providers (n)  |   4  |  11  |  100  |  2000  |
----------------------------------------------------
 # of operations    |   2 |    2  |    2  |   2    |

• El crecimiento de la complejidad en el tiempo está representado por la notación O grande
• Hasta ahora, hemos visto:
  - Complejidad de tiempo cuadrática representada por O (n²)
  - Complejidad de tiempo lineal representada por O (n)
  - Complejidad de tiempo constante representada por O (1)
• Debido a que la complejidad del tiempo es una aproximación, se eliminan números insignificantes, por lo tanto, una complejidad de tiempo de 2n es solo O (n) no O (2n)
• Los factores se eliminan:
  - 5n es O (n) [se pronuncia "o de n"]
  - 24n² es O (n²) [se pronuncia "o de n cuadrado"]
• aquí hay una representación gráfica del crecimiento:

• Conocer la complejidad del tiempo lo ayuda a comprender los límites de un algoritmo en términos de cuántos datos puede soportar antes de que tarde un millón de años en completarse.
• También ayuda a hacer concesiones sobre la elección de un algoritmo sobre otros en función de determinadas condiciones.
• la noción de corrección algorítmica se trata de su elección de un algoritmo, ¿es la solución más óptima / correcta?

• observe que con una complejidad de tiempo logarítmica (O (log n)) , cuantos más datos alimente al algoritmo, menos trabajo tendrá que hacer, pero también observe que al principio lleva más tiempo que una complejidad de tiempo cuadrática
• así que de muy eficiente a extremadamente lento, tiene:
  - Complejidad de tiempo constante representada por O (1)
  - Complejidad de tiempo logarítmica representada por O (log n)
  - Complejidad de tiempo lineal representada por O (n)
  - Complejidad de tiempo cuadrática representada por O (n²)
  - Complejidad de tiempo cubica representada por O (n³)
  - Complejidad de tiempo exponencial representada por O (k)