Cuando colaboras con otros desarrolladores utilizando Git, es posible que te encuentres con el error: failed to push some refs to [remote repo].

Este error ocurre principalmente cuando intentas enviar tus cambios locales a GitHub, mientras que el repositorio local aún no ha sido actualizado con los cambios realizados en el repositorio remoto.

Entonces, Git está tratando de decirte que actualices el repositorio local con los cambios actuales en el remoto antes de enviar tus propios cambios. Esto es necesario para que no sobrescribas los cambios hechos por otros.

Discutiremos dos posibles formas de solucionar este error en las secciones que siguen.

¿Cómo solucionar el error: failed to push some refs to en Git?

Podemos solucionar el error: failed to push some refs to [remote repo] en Git usando los comandos git pull origin [branch] o git pull --rebase origin [branch]. En la mayoría de los casos, el último comando soluciona el error.

Veamos cómo puedes usar los comandos mencionados anteriormente.

¿Cómo solucionar el error: failed to push some refs to en Git usando git pull?

Enviar una solicitud de extracción (pull request) significa "buscar" nuevos cambios realizados en el repositorio remoto y fusionarlos con el repositorio local.

Una vez que se haya completado la fusión, puedes enviar tus propios cambios de código a GitHub.

En nuestro caso, estamos tratando de deshacernos del error: failed to push some refs to [remote repo] enviando una solicitud de extracción.

Así es como puedes hacerlo:

git pull origin main

Si estás trabajando con una rama diferente, entonces tendrías que reemplazar main en el ejemplo anterior con el nombre de tu rama.

Solo ten en cuenta que existen posibilidades de fallo al usar este comando para sincronizar tus repositorios remotos y locales y así deshacerte del error. Si la solicitud tiene éxito, entonces continúa y ejecuta el siguiente comando para enviar tus propios cambios:

git push -u origin main

Si el error persiste, obtendrás un error que dirá: fatal: refusing to merge unrelated histories. En este caso, utiliza la solución disponible en la siguiente sección.

¿Cómo arreglar el error:failed to push some refs to en Git usando git pull --rebase?

El comando git pull --rebase  es útil en situaciones donde tu rama local es un commit por detrás de la rama remota

Para arreglar el error, emplea los siguientes comandos:

git pull --rebase origin main

git push -u origin main 

Si el primer comando anterior se ejecuta con éxito, deberías recibir una respuesta que diga: Successfully rebased and updated refs/heads/main.

El segundo comando envía el estado actual de tu repositorio local a la rama remota.

Resumen

En este artículo, discutimos el error error: failed to push some refs to [remote repo].

Este error ocurre cuando intentas enviar tus cambios locales al repositorio remoto sin antes actualizar tu repositorio local con los cambios más recientes del repositorio remoto.

Exploramos dos comandos para abordar este error: los comandos git pull origin [branch] y git pull --rebase origin [branch].

Espero que esta información te ayude a resolver el error.

¡Feliz programación!

En este artículo, aprenderás sobre los tres operadores lógicos en C.

Primero, explicaré qué son los operadores en programación y listaré los diferentes tipos de operadores disponibles en C.

Luego, aprenderás el papel que tienen los operadores lógicos y cómo usarlos con la ayuda de ejemplos de código en el camino.

¡Comencemos! ¿Qué es un Operador en Programación de Computadoras?

En programación de computadoras, un operador es un carácter, símbolo, palabra clave o combinación de estos. Determina qué acción se realiza en uno o más operandos.

Un operando es un elemento de datos individual que es manipulado por el operador.

Cada lenguaje de programación de alto nivel define estos caracteres integrados y los utiliza para indicar al compilador que realice operaciones aritméticas, relacionales o lógicas que manipulan elementos de datos y luego devuelven un resultado final.

¿Cuáles son los Diferentes Tipos de Operadores en la Programación en C?

En la programación en C, los operadores caen en una de tres categorías:

Operadores Unarios

Operadores Binarios

Operadores Ternarios

Operadores unarios operan sobre un solo operando. Algunos de los operadores unarios en C son:

• Operadores aritméticos como el operador de incremento (++), que incrementa el valor del operando en 1. Y el operador de decremento (--), que decrementa el valor del operando en 1.
• Operadores lógicos como el operador NOT(!). Este operador invierte el valor lógico del operando: cambia true a false y false a true.
• Operadores a nivel de bits (bitwise) como el operador NOT(~), que cambia cada bit 0 a 1 y cada bit 1 a 0.

Los operadores binarios operan sobre dos operandos. Algunos de los operadores binarios en C son:

• Operadores aritméticos (+, -, *, /, %): Estos operadores realizan cálculos matemáticos en datos numéricos como la adición, sustracción, multiplicación, división y encontrar el resto.
• Operadores de igualdad/relacionales (==, !=, >, <, >=, <=): Estos operadores comparan dos valores y determinan si un operando es mayor que, menor que, igual a o no igual a otro operando.
• Operadores lógicos/condicionales como los operadores AND (&&) y OR (||).
• Operadores a nivel de bits (&, |, ^, <<, >>): Tratan los elementos de datos como una secuencia de bits (es decir, 0s y 1s).
• Operadores de asignación (=, +=, -= *=, /=, %=): Asignan un valor específico a una variable.

El operador Ternario (?:) opera en tres operandos. La sintaxis general se parece a la siguiente:

(condición) ? expresión1 : expresión2;

El operador ternario es un operador condicional que puedes usar como una abreviatura para if..else. Realiza comparaciones y genera un resultado.

¿Cuál es el papel de los Operadores Lógicos en la Programación en C?

Los operadores lógicos se utilizan comúnmente en declaraciones condicionales (como las declaraciones if..else), ya que ayudan en la toma de decisiones: determinan qué acción debe tener lugar y qué código debe ejecutarse a continuación según las condiciones que establezcas.

Combina los operadores lógicos con una o múltiples condiciones para crear una expresión lógica.

Los operadores lógicos evalúan la expresión lógica y devuelven un resultado.

El resultado siempre es un valor booleano. Un valor booleano determina si la expresión es verdadera true o falsa false.

Hay tres operadores lógicos en la programación en C: el AND lógico (&&), el OR lógico (||) y el NOT lógico (!).

Vamos a entrar en más detalle sobre cada uno en las siguientes secciones.

Cómo Usar el Operador Lógico AND (&&) en la Programación en C

El operador lógico AND (&&) verifica si todos los operandos son verdaderos: el resultado es verdadero solo cuando todos los operandos son verdaderos.

Aquí está la tabla de verdad para el operador AND (&&) cuando estás trabajando con dos operandos:

Algo importante a tener en cuenta aquí es que, cuando el primer operando es falso, el segundo operando no se evalúa.

Veamos un ejemplo: El resultado de (10 == 10) && (20 == 20) es verdadero porque ambos operandos son verdaderos: (10 == 10) es verdadero y (20 == 20) es verdadero.

Veamos otro ejemplo: El resultado de (10 == 20) && (20 == 20) es falso porque uno de los operandos es falso: en este caso, el primer operando es falso, por lo que el segundo operando no se evalúa.

Ahora, veamos cómo puedes usar el operador && en una declaración if:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 30;

  if (a > 10 && b > 10)
    printf("Ambos números son mayores que 10\n");
}

// salida

// Ambos números son mayores que 10

En el ejemplo anterior, la salida es "Al menos uno de los números es mayor que 10" porque se cumple la condición a > 10 || b > 10 – al menos uno de los operandos es verdadero.

La primera condición, a > 10, es verdadera, por lo que el resultado es verdadero.

Si tanto a como b fueran falsos, no habría salida.

Cómo usar el operador lógico to Use the OR (||) Logical en la programación en C

La operación lógica OR (||) verifica si al menos uno de los operandos es verdadero; el resultado es verdadero si al menos uno de los operandos es verdadero.

Aquí tienes la tabla de verdad para el operador OR (||) cuando estás trabajando con dos operandos:

Ten en cuenta que con el operador OR (||), si el primer operando es verdadero, entonces el segundo operando no se evalúa.

Veamos un ejemplo: El resultado de (10 == 20) || (20 == 20) es verdadero porque al menos uno de los operandos es verdadero; en este caso, es el segundo operando, incluso si el primer operando es falso.

Veamos otro ejemplo: El resultado de (20 == 20) || (10 == 20) es verdadero porque uno de los operandos es verdadero; en este caso, dado que el primer operando es verdadero, el segundo no se evalúa.

Ahora, veamos cómo puedes usar el operador OR (||) en una declaración if:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if (a > 10 || b > 10)
    printf("Al menos uno de los números es mayor que 10");
}

En el ejemplo anterior, la salida es "Al menos uno de los números es mayor que 10" porque se cumple la condición a > 10 || b > 10 – al menos uno de los operandos es verdadero.

La primera condición, a > 10, es verdadera, por lo que el resultado es verdadero.

Si tanto a como b fueran falsos, no habría salida.

Cómo Usar el Operador Lógico NOT (!) en la Programación en C

El operador lógico NOT (!) niega el operando – es decir, devuelve lo opuesto al operando.

Si el operando es true, devuelve false.

Y si es false, devuelve true.

Aquí está la tabla de verdad para el operador NOT (!):

Veamos un ejemplo: El resultado de !(10 == 10) es false.

La condición 10 == 10 es verdadera, pero el operador ! la niega.

Y veamos otro ejemplo: El resultado de !(10 == 20) es true.

La condición 10 == 20 es falsa, pero el operador ! la niega.

Ahora, revisa el siguiente ejemplo para ver cómo puedes usar el operador NOT (!) en una declaración if:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if (a > 10 || b > 10)
    printf("Al menos uno de los números es mayor que 10");
}

El resultado es a es mayor que b porque la condición a > b es verdadera.

Sin embargo, si usaste el operador NOT (!), la condición ya no es verdadera, por lo que no habría salida:

#include <stdio.h>

int main(void) {
  int a = 20;
  int b = 5;

  if ( a > b)
    printf("a es mayor que b\n");

Conclusión

¡Y ahí lo tienes! Ahora sabes cómo funcionan los tres operadores lógicos en la programación en C.

Para aprender más sobre C, te recomiendo leer este manual para principiantes en C para familiarizarte con los conceptos básicos del lenguaje.

¡Gracias por leer, y feliz codificación!

En el lenguaje de programación C, hay momentos en los que querrás cambiar el comportamiento de un bucle. Y las declaraciones continue y break te ayudan a omitir iteraciones y salir de los bucles bajo ciertas condiciones.

En este tutorial, aprenderás cómo las declaraciones break y continue alteran el flujo de control de tu programa.

¡Comencemos!

Cómo Usar break para Salir de Bucles en C

En C, si deseas salir de un bucle cuando se cumple una condición específica, puedes utilizar la declaración break.

Como con todas las declaraciones en C, la declaración break debe terminar con un punto y coma (;).

Veamos un ejemplo para entender qué significa esto.

Considera el siguiente fragmento de código.

#include<stdio.h>
int main()
{
    int count = 0;
    while(count < 100)
    {
        printf("The value of count is %d \n", count);
        count++;
    }
    return 0;
}

En este ejemplo, el bucle while repite las declaraciones en el cuerpo del bucle mientras que la variable count sea menor que 100.

El contador comienza en 0, y aumenta en 1 con cada iteración.

Ahora, este es el flujo de control normal.

Modifiquemos esto un poco.

• Lee un entero fav_num del usuario. Supongamos que fav_num es el número favorito del usuario del conjunto {0, 1, 2, ..., 99}.
• Durante cada paso a través del bucle, debes verificar si el valor actual de count es igual a fav_num.
• Te gustaría salir del bucle cuando count sea igual a fav_num.

Entonces, ¿cómo haces esto?

Lee a través del siguiente fragmento de código:

#include<stdio.h>
int main()
{
    // Read in the user's favorite number
    int fav_num;
    printf("Enter your favorite number from 0 to 99: ");
    scanf("%d", &fav_num);
    
    int count = 0;
    while(count < 100)
    {
        printf("\nThe value of count is %d.", count);
        if (count == fav_num)
    		break;
        count++;
    }
    return 0;
}

Durante cada paso a través del bucle, utilizas if (count == fav_num) para verificar si count es igual a fav_num.

Luego agregas la declaración break; al cuerpo del condicional if.

Mientras count ≠ fav_num, el control nunca alcanza la declaración break;.

Cuando count es igual a fav_num, se activa la declaración break;, y luego sales del bucle. El control ahora llega a la primera declaración fuera del bucle.

A continuación se muestra un ejemplo de salida:

Observa cómo el control sale del bucle una vez que el contador alcanza 3, que aquí es fav_num.

En la próxima sección, verás otro ejemplo que reforzará tu comprensión.

Ejemplo de Declaración break en C

▶ Considera el siguiente ejemplo:

• A[10] es un arreglo de 10 enteros, inicializado con ceros.
• Deseas leer los elementos del arreglo A del usuario y calcular la suma de los elementos en el arreglo.
• Sin embargo, requieres que cada elemento de A no sea mayor que 20.
• Una vez que el usuario ingresa un número mayor a 20, optas por terminar el bucle. Aquí es donde entra en juego la declaración break;.

Ahora, lee el siguiente fragmento de código que hace exactamente esto.

#include <stdio.h>

int main()
{
    int A[10] = {0};
    int sum = 0;
    
    for(int i = 0; i < 10; i++)
    {
        printf("Enter a number: ");
        scanf("%d",&A[i]);
        if (A[i] > 20)
            break;
        
        sum += A[i];
    }
    printf("Sum: %d",sum);
    return 0;
}

1. Aquí, la sum se inicializa en 0. En cada paso a través del bucle, se le pide al usuario que ingrese un número.
2. El número ingresado se suma al valor actual de sum.
3. Si el usuario ingresa un número mayor que 20, el control sale del bucle.

Observa cómo el bucle termina una vez que el usuario ingresa un número mayor que 20, en este caso 21. Posteriormente se imprime la suma de los otros dos números (2 y 3).

Si has utilizado la declaración switch en C, probablemente hayas utilizado la declaración break; para salir de la escalera de casos tan pronto como se encuentra una etiqueta de caso coincidente.

Sin embargo, este tutorial tiene como objetivo enseñar cómo utilizar las declaraciones break; y continue; para cambiar el comportamiento de los bucles.

Cómo usar continue para omitir Iteraciones en C

En C, si deseas omitir iteraciones en las que se cumpla una condición específica, puedes utilizar la declaración continue.

A diferencia de la declaración break;, la declaración continue; no sale del bucle. En cambio, omite solo aquellas iteraciones en las que la condición es verdadera.

Una vez que se activa la declaración continue;, se omiten las declaraciones en el resto del bucle. Y el control del bucle continúa con la siguiente iteración.

Ejemplo de Declaración continue en C

Utilicemos el ejemplo de la sección anterior y modifiquémoslo un poco.

Digamos que no deseas salir del bucle cuando el usuario ingresa un número mayor que 20. Más bien, deseas ignorar esas entradas particulares y calcular la suma de los números restantes en el arreglo A.

Supongamos que el usuario ingresa 10 números, 3 de los cuales son mayores que 20. Tu código ahora debería calcular y mostrar la suma de los 7 números restantes.

Entonces, ¿cómo lo haces?

Puedes utilizar la declaración continue; para omitir solo aquellas iteraciones para las cuales la entrada del usuario fue mayor que 20. Y puedes hacerlo como se muestra en el código a continuación:

#include <stdio.h>

int main()
{
    int A[10] = {0};
    int sum = 0;
    
    for(int i = 0; i < 10; i++)
    {
        printf("Enter a number: ");
        scanf("%d",&A[i]);
        if (A[i] > 20)
            continue;
        
        sum += A[i];
    }
    printf("Sum: %d",sum);
    return 0;
}

En la salida de ejemplo, puedes observar que el primer número ingresado es 21, que es mayor que 20.

Sin embargo, el bucle se ejecuta 10 veces. Y si estás listo para un rápido ejercicio de suma, puedes notar que los números distintos de 21 (2, 3, 5, 4, 7, 15, 14, 2 y 5) suman efectivamente 57. ✅

Conclusión

En este tutorial, has aprendido cómo puedes utilizar las declaraciones break; y continue; para controlar bucles en C.

En resumen, has aprendido:

• cómo la declaración break; ayuda a salir de bucles bajo condiciones específicas.
• cómo la declaración continue; ayuda a omitir iteraciones bajo condiciones específicas.

Espero que hayas encontrado útil este tutorial. ¡Feliz codificación! 😄

Git es un sistema de control de versiones gratuito y de código abierto. Es el sistema de control de versiones más popular en uso hoy en día.

Git realiza un seguimiento de los cambios realizados en un proyecto a lo largo del tiempo. Esto permite a múltiples desarrolladores colaborar y trabajar en el mismo proyecto en paralelo, sin importar dónde se encuentren en el mundo.

Permite a los desarrolladores ver el historial del proyecto y ver quién realizó qué cambios y por qué se realizaron esos cambios en primer lugar. Además, con Git, puedes revertir a una versión anterior del código si es necesario.

Básicamente, Git garantiza a los desarrolladores que están todos en la misma página y sepan qué está sucediendo en el proyecto.

Cuando trabajas en un proyecto, uno de los desafíos que puedes enfrentar es tratar de sincronizar tu trabajo, específicamente, sincronizar las ramas locales y remotas.

En este artículo, aprenderás cómo restablecer y hacer coincidir exactamente una rama Git local con una rama remota.

Esto es lo que cubriremos:

• ¿Qué es una rama en Git?
• ¿Cuál es la diferencia entre las ramas locales, remotas y las ramas de seguimiento remoto?
• ¿Cómo restablecer una rama local de Git a la remota?
• Guardar el estado actual de tu rama local
• Hacer un git checkout
• Hacer fetch de origen
• Restablecer el repositorio local
• Limpiar cualquier cambio no rastreado
• Conclusión

¿Qué es una rama en Git? Ramas de Git en pocas palabras para principiantes

La ramificación es un aspecto fundamental del control de versiones y un concepto importante de aprender.

Gracias a la ramificación, los desarrolladores pueden colaborar de una manera más flexible. La ramificación hace que el proceso de desarrollo diario sea más fluido y eficiente.

La ramificación es una forma de gestionar diferentes versiones de tu código y actúa como un puntero a una instantánea de tus cambios.

Cuando creas por primera vez un repositorio Git para tu proyecto, en ese mismo momento se crea también la rama principal.

La rama principal es la rama primaria y predeterminada de tu proyecto. Representa la versión libre de errores, estable y utilizable de tu código que está lista para ser lanzada y compartida con el público. Es la base de código principal.

Pero, ¿qué sucede cuando quieres añadir una nueva característica a tu proyecto?

Antes de añadirla, necesitas probarla y asegurarte de que no introduce nuevos errores o interfiere con el código existente.

Debe haber una forma de trabajar en la nueva característica sin afectar la base de código.

Y aquí es donde la ramificación resulta útil.

Las ramas son espacios aislados para experimentar y probar código nuevo sin afectar al código en la rama principal.

Puedes crear una nueva rama y hacer los cambios que desees. Si estás satisfecho con los cambios, puedes añadirlos a la rama principal fusionándolos. Si no lo estás, puedes eliminar esa rama sin interferir con el código principal en el proyecto.

Las ramas también permiten a los desarrolladores trabajar en diferentes características al mismo tiempo sin interferir en el trabajo de los demás.

Para obtener más información sobre las ramas en Git, echa un vistazo a este vídeo que explica cómo funcionan, y marca este artículo que proporciona una hoja de trucos sobre cómo usarlas.

Ramas locales VS remotas VS ramas de seguimiento remoto en Git - ¿Cuál es la diferencia?

Una rama local es una rama que solo es accesible en tu máquina local y existe allí de manera aislada. Desde aquí, puedes agregar archivos y hacer confirmaciones de cualquier cambio que realices. Esos cambios se guardarán localmente y solo serán visibles para ti y estarán disponibles en tu máquina física local.

Los otros desarrolladores no podrán ver tu trabajo ni los cambios que hayas hecho.

Puedes crear una rama local llamada my_branch usando el siguiente comando:

git branch my_branch

Y para luego listar todas tus ramas locales, solo necesitas usar el comando git branch.

Para colaborar con otros desarrolladores en el mismo proyecto y para que ellos puedan ver cualquier cambio que realices, necesitas enviar los cambios desde tu rama local a un repositorio remoto. Esto nos lleva a las ramas remotas.

Una rama remota se refiere a una rama que existe en un repositorio remoto. Un repositorio remoto, también conocido como remoto, típicamente será un repositorio alojado en algún lugar en Internet, en una ubicación remota como en los servidores de GitHub.

El nombre predeterminado de un repositorio remoto es origin.

Ahora, una rama de seguimiento remoto se refiere a una referencia local del estado de la rama remota. Por defecto, las ramas no tienen conexión entre sí. Dicho esto, puedes indicarle a una rama local que siga a una remota.

Cómo restablecer una rama local de Git a la remota

Es posible que hayas estado trabajando en tu rama local, realizando diversos cambios y modificaciones en un proyecto, y hayas concluido que esos cambios ya no son necesarios.

Quieres eliminarlos y restablecer la rama a la rama remota.

Además, otro desarrollador puede haber realizado cambios y los haya enviado a la rama remota, por lo que necesitas obtener esos últimos cambios del repositorio remoto para estar al día.

Los pasos que necesitas seguir para lograr esto son los siguientes:

• Guardar el estado actual de tu rama local (opcional).
• Obtener la última versión del código desde el remoto.
• Restablecer la rama local.
• Limpiar archivos (opcional).

Guardar el Estado Actual de tu Rama Local

Antes de comenzar, es posible que desees guardar el estado de tu rama actual en otra rama.

Cuando restableces una rama local de Git a la remota, perderás los cambios que hayas realizado localmente.

Este paso es opcional, y puedes elegir hacerlo en caso de que algo salga mal o desees volver a ese trabajo nuevamente en el futuro.

Para guardar el trabajo utiliza los siguientes comandos:

git commit -a -m "Estoy guardando mi trabajo"
git branch backup_trabajo

Tu trabajo se guardó como backup_trabajo.

Hacer un git checkout

Por lo general, habrá una rama de seguimiento remoto local con el mismo nombre que la remota a la que deseas restablecer, como main.

Para este proceso usamos:

git checkout main

Si estás utilizando un nombre diferente para esta rama, reemplaza main con el nombre que estés utilizando.

Obtener origen

Para obtener el repositorio remoto y el estado y la versión más recientes del código en el repositorio remoto, introduce el siguiente comando:

git fetch origin

origin es un alias creado por Git y especifica la URL remota del repositorio remoto. Por lo general, Git asume automáticamente que el nombre del repositorio remoto es origin.

Si tienes un nombre remoto diferente, reemplaza origin con el nombre que estés usando.

Restablecer el repositorio local

Ahora, restablece la rama local main al repositorio remoto utilizando el siguiente comando:

git reset --hard origin/main

Limpiar cualquier cambio no rastreado

Este paso es opcional. Después de usar los comandos anteriores, es posible que te encuentres con algunos archivos no rastreados. Utiliza el siguiente comando para limpiar cualquier cambio no rastreado:

git clean -xdf

Vamos a desglosar la bandera -xdf y explicar qué hace cada parte:

1. La bandera -x elimina archivos ignorados.
2. La bandera -d elimina carpetas no rastreadas.
3. La bandera -f elimina archivos no rastreados.

Conclusión

Y ahí lo tienes: ahora has restablecido tu rama local a la remota. Esperemos que hayas encontrado útil este artículo.

Para aprender más sobre Git, echa un vistazo a los siguientes recursos gratuitos:

• Git y GitHub para Principiantes - Curso Intensivo
• Tutorial de Git para Profesionales - Herramientas y Conceptos para Dominar el Control de Versiones con Git
• Tutorial Avanzado de Git - Rebase Interactivo, Cherry-Picking, Reflog, Submódulos y más

¡Gracias por leer y feliz codificación!

En Pandas, a veces necesitarás eliminar columnas de un Marco de Datos por varias razones, como limpiar datos, reducir el uso de memoria o simplificar el análisis. Es por ello que en este artículo, te mostraré cómo hacerlo.

Comenzaré presentando el método .drop() que es el método principal para eliminar columnas en Pandas.

Repasaremos la sintaxis y los parámetros del método .drop(), incluyendo cómo especificar las columnas a eliminar y cómo controlar si el Marco de Datos original se modifica en su lugar o se devuelve un nuevo Marco de Datos.

A continuación, proporcionaré un ejemplo de cómo usar el método .drop() para eliminar columnas de un Marco de Datos.

Cómo usar el método .drop() en Pandas

El método .drop() es una función incorporada en Pandas que te permite eliminar una o más filas o columnas de un Marco de Datos.

Devuelve un nuevo Marco de Datos con las filas o columnas especificadas eliminadas y no modifica el Marco de Datos original en su lugar, a menos que establezcas el parámetro inplace en True.

La sintaxis para usar el método .drop() es la siguiente:

DataFrame.drop(labels=None, axis=0, index=None, columns=None, level=None, inplace=False, errors='raise')

Aquí, DataFrame se refiere al Marco de Datos de Pandas del cual deseas eliminar filas o columnas. Los parámetros que puedes usar con el método .drop() incluyen:

• labels: Este parámetro especifica las etiquetas o índices de las filas o columnas que se van a eliminar. Puedes pasar una sola etiqueta o índice, o una lista de etiquetas o índices.
• axis: Este parámetro especifica si se van a eliminar filas o columnas. Por defecto, está configurado en 0, lo que significa que se eliminan filas. Si deseas eliminar columnas, configúralo en 1.
• index y columns: Estos parámetros son alternativas al parámetro de etiquetas y especifican las etiquetas o índices de las filas o columnas que se van a eliminar, respectivamente.
• level: Este parámetro se utiliza para eliminar un nivel específico de un índice jerárquico.
• inplace: Este parámetro es un valor booleano que determina si modificar el DataFrame original en su lugar. Por defecto, está configurado en False.
• errors: Este parámetro especifica cómo manejar errores si la(s) etiqueta(s) o índice(s) especificado(s) no se encuentran en el DataFrame. Por defecto, está configurado en raise, lo que significa que se genera un KeyError. Otras opciones son ignore y warn, que respectivamente ignorarán o mostrarán una advertencia cuando la etiqueta o índice no se encuentre.

Cómo eliminar una sola columna de un Marco de Datos en Pandas

Vamos a empezar suavemente aprendiendo primero cómo eliminar una sola columna de un Marco de Datos antes de eliminar múltiples columnas.

Muestra del código:

#Traducción al español del código
import pandas as pd
#Creamos un marco de datos de muestra
datos = {"nombre": ['Alicia', 'Bob', 'Charlie'],
        "edad": [25, 30, 35],
        "género": ['F', 'M', 'M']
        }
df = pd.DataFrame(datos)

# Mostramos el Marco de Datos original
print("DataFrame Original:\n", df)

# Damos drop a la columna "género"
df = df.drop(columns=['género'])

# Mostramos el Marco de Datos modificado
print("DataFrame Modificado:\n", df)

Resultado:

DataFrame Original:
     nombre  edad género
0   Alicia    25      F
1      Bob    30      M
2  Charlie    35      M
DataFrame Modificado:
     nombre  edad
0   Alicia    25
1      Bob    30
2  Charlie    35

En el ejemplo anterior, primero creamos un Marco de Datos de muestra con tres columnas: nombre, edad y género. Luego utilizamos el método .drop() con el parámetro columns para eliminar la columna género. El Marco de Datos resultante solo contiene las columnas nombre y edad.

Es importante tener en cuenta que el método .drop() no modifica el Marco de Datos original en su lugar. En su lugar, devuelve un nuevo Marco de Datos con la(s) columna(s) especificada(s) eliminada(s). Si deseas modificar el Marco de Datos original, necesitas asignar el resultado del método .drop() de nuevo a la variable original, como hicimos en el ejemplo anterior.

Además del parámetro columns, el método .drop() también tiene varios otros parámetros opcionales que puedes usar para controlar cómo se eliminan las columnas.

Por ejemplo, puedes usar el parámetro inplace para modificar el Marco de Datos original en su lugar en lugar de devolver un nuevo Marco de Datos. También puedes usar el parámetro axis para eliminar columnas por índice en lugar de por nombre.

Cómo eliminar varias columnas de un Marco de Datos en Pandas

En esta sección, eliminaremos varias columnas de nuestro Marco de Datos. Este enfoque es similar a eliminar una sola columna del Marco de Datos.

Para eliminar dos o más columnas de un Marco de Datos usando el método .drop() en Pandas, podemos pasar una lista de nombres de columnas al parámetro columns del método.

import pandas as pd

# creando -otra vez- un Marco de Datos
datos = {'nombre': ['John', 'Maria', 'Pedro'],
        'edad': [30, 25, 35],
        'género': ['M', 'F', 'M'],
        'ciudad': ['Ciudad de México', 'San José', 'Buenos Aires']}
df = pd.DataFrame(datos)

# Removiendo las columnas género y ciudad
df.drop(columns=['género', 'ciudad'], inplace=True)

# Damos print en el Marco de Datos modificado
print(df)

Resultado:

 nombre  edad
0   John    30
1  Maria    25
2  Pedro    35

Explicación del código:

En este ejemplo, primero creamos un Marco de Datos de muestra con cuatro columnas: nombre, edad, género y ciudad. Luego, usamos el método .drop() para eliminar las columnas ciudad y género  pasando una lista con sus nombres al parámetro columns.

Finalmente, establecemos el parámetro inplace en True para modificar el Marco de Datos original e imprimir el Marco de Datos modificado.

Ten en cuenta que también puedes eliminar columnas por sus índices pasando una lista de índices al parámetro columns. Por ejemplo, para eliminar la segunda y tercera columnas, puedes usar:

df.drop(columns=df.columns[1:3], inplace=True)

Esto eliminará las columnas con índices 1 y 2 (que son las columnas de edad y género en este ejemplo).

Conclusión

Espero que este artículo sea un recurso útil para cualquier persona que trabaje con Marco de Datos de Pandas y necesite eliminar columnas de manera eficiente y efectiva.

¡Conéctate conmigo en Twitter y LinkedIn! También puedes suscribirte a mi canal de YouTube.

¡Feliz Codificación!

Excel es una herramienta sorprendentemente común para el análisis de datos.

Los analistas de datos pueden modificar, examinar y mostrar grandes cantidades de datos con facilidad utilizando Excel, lo que facilita la obtención de perspectivas y la toma de decisiones acertadas.

La versatilidad de Excel permite a los usuarios llevar a cabo una variedad de actividades de análisis de datos, desde operaciones matemáticas sencillas hasta análisis estadísticos complejos. Además, Excel ofrece automatización mediante el uso de programas de terceros como Python o el lenguaje de programación integrado VBA.

Excel se utiliza con frecuencia para el análisis de datos en una variedad de industrias, incluyendo la banca, la atención médica y el marketing, gracias a su versatilidad y facilidad de uso.

Pero como analista de datos, es posible que te encuentres repitiendo tareas mundanas a diario cuando trabajas con Excel.

Estas tareas pueden incluir copiar y pegar datos, dar formato a celdas y crear gráficos, entre otras. Con el tiempo, esto puede volverse monótono y consumir mucho tiempo, dejándote con menos tiempo para concentrarte en aspectos más importantes del análisis de datos, como identificar tendencias, valores atípicos y perspectivas.

Por eso, automatizar Excel utilizando Python puede cambiar el juego, ayudándote a optimizar tus flujos de trabajo y liberar tiempo para un análisis más significativo.

En este tutorial, te mostraré algunas formas útiles de crear, actualizar y analizar hojas de cálculo de Excel utilizando programación en Python. ¡Vamos a sumergirnos!

¿Cómo fusionar dos hojas de cálculo separadas con Python?

Los analistas de datos a menudo tienen que trabajar con muchas hojas de cálculo, lo que puede volverse agobiante cuando tienes que fusionar esos archivos juntos.

El código a continuación te ayuda a fusionar dos archivos separados juntos.

import pandas as pd

# Read in the two Excel files

file1 = pd.read_excel('file1.xlsx')file2 = pd.read_excel('file2.xlsx')

# Merge the two files using the concat() method
merged_file = pd.concat([file1, file2], ignore_index=True)

# Write the merged file to a new Excel file
merged_file.to_excel('merged_file.xlsx', index=False)

En este código, primero importamos la biblioteca Pandas, que utilizaremos para leer y manipular los archivos de Excel.

Primero usamos el método read_excel() para leer tanto en file1.xlsx como en file2.xlsx.

Luego, empleamos el método concat() para unir los dos archivos juntos. El argumentoignore_index=True garantiza que los valores de índice de ambos archivos se reinicien, de modo que no terminemos con valores de índice duplicados en el archivo fusionado.

Finalmente recurrimos al método to_excel() para escribir el archivo fusionado en un nuevo archivo de Excel llamado merged_file.xlsx. También establecemos index=False para asegurarnos de que la columna de índice no se incluya en el archivo de salida.

Cómo Importar y Exportar Datos con Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para leer archivos de Excel en un objeto DataFrame. Luego puedes manipularlo y analizarlo utilizando Python.

También puedes exportar datos desde Python de vuelta a un archivo de Excel utilizando las mismas bibliotecas.

import pandas as pd
# Import Excel file

df = pd.read_excel('filename.xlsx', sheet_name='Sheet1')

# Export to Excel file
df.to_excel('new_filename.xlsx', index=False)

El código dado importa la biblioteca Pandas y lee un archivo de Excel llamado "filename.xlsx" desde la Hoja1 del libro de trabajo, almacenando los datos en un marco de datos de Pandas llamado "df". Luego, el marco de datos se exporta a un nuevo archivo de Excel llamado "new_filename.xlsx" utilizando el método "to_excel". El parámetro "index=False" se utiliza para excluir la indexación de filas en el archivo de salida.

Esencialmente, el código copia el contenido del archivo de Excel original a un nuevo archivo utilizando Pandas.

Cómo Limpiar y Transformar Datos usando Python

Esta tarea implica el uso de bibliotecas de Python como Pandas para limpiar y transformar datos en Excel.

Esto puede incluir la eliminación de duplicados, filtrado de datos según criterios específicos y realización de cálculos sobre los datos.

import pandas as pd

# Remove duplicates
df = df.drop_duplicates()

# Filter data
df = df[df['column_name'] > 10]

# Perform calculations
df['new_column'] = df['column1'] + df['column2']

El fragmento de código anterior realiza tareas de limpieza y manipulación de datos en un marco de datos de Pandas llamado 'df' utilizando la biblioteca Pandas.

En primer lugar, elimina filas duplicadas de 'df' utilizando el método "drop_duplicates". En segundo lugar, filtra el marco de datos 'df' seleccionando las filas donde el valor en la columna 'column_name' es mayor que 10 y asigna el resultado filtrado a un nuevo marco de datos llamado 'data_df'.

Por último, se añade una nueva columna llamada 'new_column' a 'df' que contiene la suma de los valores de 'column1' y 'column2'.

En general, el código limpia y manipula eficazmente los datos eliminando duplicados, filtrando filas específicas y añadiendo una nueva columna calculada al marco de datos original.

Cómo Realizar Análisis de Datos con Python

Este proceso implica utilizar bibliotecas de Python como Pandas y NumPy para llevar a cabo análisis de datos en datos de Excel.

Esto podría abarcar desde calcular estadísticas resumidas, como la media y la desviación estándar, hasta crear informes personalizados mediante la agrupación de datos según criterios específicos.

import pandas as pd
import numpy as np

# Calculate summary statistics
df.describe()
# Create custom reports
df.pivot_table(values='column_name', index='category_name', columns='date')

El código utiliza las bibliotecas Pandas y NumPy y realiza tareas de análisis de datos e informes en un marco de datos de Pandas llamado "df".

En primer lugar, calcula estadísticas resumidas para los datos numéricos en el marco de datos utilizando el método "describe". Este método genera información valiosa sobre la distribución, tendencia central y dispersión de los datos.

En segundo lugar, el código utiliza el método "pivot_table" para crear informes personalizados a partir del marco de datos. Este método resume y agrega los datos en el dataframe y puede producir tablas en varios formatos.

En este código, genera un nuevo marco de datos donde los valores de 'column_name' están agrupados por las columnas 'category_name' y 'date'.

En resumen, el código realiza tareas de análisis estadístico e informes en el marco de datos para obtener información de los datos.

Cómo Crear Gráficos con Python

Esta tarea implica utilizar bibliotecas de Python como matplotlib o seaborn para crear gráficos y diagramas a partir de datos de Excel.

Puedes personalizar estos gráficos para mostrar datos específicos y darles formato para cumplir con requisitos particulares.

import pandas as pd
import matplotlib.pyplot as plt
# Create a bar chart
df.plot(kind='bar', x='category_name', y='sales')
plt.show()
# Create a scatter plot
df.plot(kind='scatter', x='column1', y='column2')plt.show()

El código importa dos bibliotecas, Pandas y matplotlib.pyplot, utilizando los alias 'pd' y 'plt', respectivamente.

Luego, se utiliza el método "plot" de Pandas para crear dos tipos de gráficos. El primer tipo de gráfico es un gráfico de barras que muestra la relación entre las columnas 'category_name' y 'sales' en el dataframe "df".

El segundo tipo de gráfico es un gráfico de dispersión que muestra la relación entre las columnas 'column1' y 'column2' en el mismo marco de datos. El código utiliza los parámetros "kind='bar'" para el gráfico de barras y "kind='scatter'" para el gráfico de dispersión para crear los respectivos gráficos.

Por último, se llama al método "show" para mostrar los gráficos en la pantalla. En resumen, el código utiliza Pandas y matplotlib para crear un gráfico de barras y un gráfico de dispersión para visualizar los datos en el marco de datos "df".

Cómo Realizar Visualización de Datos en Python

Esta tarea implica utilizar bibliotecas de Python como Plotly y Bokeh para crear visualizaciones de datos interactivas a partir de datos de Excel.

Estas visualizaciones permiten a los usuarios explorar los datos de nuevas formas, como mediante el zoom en puntos de datos específicos o el filtrado de datos según criterios específicos.

import pandas as pd
import plotly.express as px
# Create a heatmap
fig = px.imshow(df.corr())
fig.show()
# Create a line chart
fig = px.line(df, x='date', y='sales', color='category')
fig.show()

El código utiliza las bibliotecas Pandas y plotly.express para crear dos tipos de visualizaciones. Primero, se crea un gráfico de mapa de calor utilizando el método "imshow" de plotly.express que visualiza la correlación entre las columnas en el marco de datos "df".

En segundo lugar, se crea un gráfico de líneas utilizando el método "line" de plotly.express que muestra la relación entre las columnas 'date' y 'sales' mientras diferencia entre las categorías basadas en la columna 'category' del dataframe. Ambos gráficos se muestran utilizando el método "show".

Cómo Automatizar la Generación de Informes con Python

Esta tarea implica utilizar scripts de Python para automatizar el proceso de generación de informes a partir de datos de Excel.

Puedes configurar estos scripts para que se ejecuten según un horario regular, como diario o semanal. También pueden actualizarse automáticamente a medida que haya nuevos datos disponibles.

import pandas as pd
# Create daily report
df_daily = df[df['date'] == '2022-01-01']
df_daily.to_excel('daily_report.xlsx', index=False)
# Create weekly report
df_weekly = df.groupby('category').sum()
df_weekly.to_excel('weekly_report.xlsx', index=False)

El código crea un informe diario mediante la creación de un nuevo marco de datos "df_daily" que incluye solo las filas donde la columna 'date' es igual a '2022-01-01'. Esto se logra utilizando la función de indexación booleana de Pandas.

Posteriormente, se utiliza el método "to_excel" para exportar los datos filtrados a un archivo de Excel llamado "daily_report.xlsx", sin incluir la columna de índice.

A continuación, el código crea un informe semanal agrupando el marco de datos "df" por la columna 'category' y sumando los valores de todas las demás columnas. Esto se logra utilizando los métodos "groupby" y "sum" de Pandas.

El resultado se guarda en un nuevo marco de datos llamado "df_weekly". Por último, se utiliza el método "to_excel" para exportar los datos agregados a un archivo de Excel llamado "weekly_report.xlsx", sin incluir la columna de índice.

En resumen, el código crea dos informes utilizando la biblioteca Pandas. El primer informe es un informe diario que incluye solo datos de una fecha específica, y el segundo informe es un informe semanal que agrupa los datos por categoría. Ambos informes se exportan a archivos de Excel utilizando el método "to_excel".

Cómo Automatizar Tareas Repetitivas con Macros y Scripts en Python

Esta tarea implica utilizar Python para automatizar tareas repetitivas en Excel, como la entrada de datos o el formato.

Puedes hacer esto creando macros o scripts que se ejecuten automáticamente, o utilizando Python para interactuar directamente con la aplicación de Excel.

import win32com.client as win32
# Open Excel file
excel = win32.gencache.EnsureDispatch('Excel.Application')
workbook = excel.Workbooks.Open(r'filename.xlsx')
# Run macro
excel.Application.Run('macro_name')
# Save and close Excel
 fileworkbook.Save()workbook.Close()excel.Quit()

El código utiliza el módulo win32com.client para interactuar con Microsoft Excel a través de la API de Windows.

Primero, se abre una instancia de la aplicación Excel utilizando el método EnsureDispatch(), y el archivo de Excel especificado se abre utilizando el método Workbooks.Open().

A continuación, se ejecuta una macro utilizando el método Application.Run(), pasando el nombre de la macro como argumento.

Finalmente, los cambios realizados en el archivo de Excel se guardan utilizando el método Save(), el libro de trabajo se cierra utilizando el método Close(), y la aplicación de Excel se termina utilizando el método Quit().

Cómo Extraer Datos con Python

Esta tarea implica utilizar bibliotecas de Python como requests y Beautiful Soup para extraer datos de páginas web u otras fuentes e importarlos a Excel.

Luego, puedes analizar y manipular estos datos utilizando bibliotecas de Python como Pandas.

import pandas as pd
import requests
from bs4 import BeautifulSoup
# Scrape data from web page
url = 'https://www.website.com/data'
response = requests.get(url)
soup = BeautifulSoup(response.text, 'html.parser')
table = soup.find('table')
df = pd.read_html(str(table))[0]
# Export to Excel file
df.to_excel('scraped_data.xlsx', index=False)

Este código utiliza la biblioteca requests para enviar una solicitud GET HTTP a la URL 'https://www.example.com'. Luego utiliza la biblioteca BeautifulSoup para analizar el contenido HTML de la respuesta en un objeto BeautifulSoup nombrado 'soup'.

Puedes luego utilizar métodos de BeautifulSoup como find_all() para extraer datos específicos del HTML:

links = []for link in soup.find_all('a'):    href = link.get('href')    links.append(href)

Este código encuentra todas las etiquetas de anclaje en el HTML y extrae el valor del atributo 'href' para cada una, agregándolos a una lista nombrada 'links'.

Cómo Utilizar Python para Integrar Excel con Otras Aplicaciones

Esta tarea implica utilizar Python para integrar Excel con otras aplicaciones, como bases de datos o servicios web.

Puedes hacer esto utilizando bibliotecas de Python como pyodbc para conectarte a bases de datos o mediante el uso de APIs para conectarte a servicios web. Esto permite una transferencia y análisis de datos sin problemas entre diferentes aplicaciones.

import pandas as pd
import pyodbc
# Connect to database
cnxn = pyodbc.connect('DRIVER={SQL Server};SERVER=server_name;DATABASE=db_name;UID=user_id;PWD=password')
# Read data from database
query = 'SELECT * FROM table_name'
df = pd.read_sql(query, cnxn)
# Export to Excel file
df.to_excel('database_data.xlsx', index=False)

El código establece una conexión a una base de datos SQL Server utilizando el método pyodbc.connect(), donde el controlador, el nombre del servidor, el nombre de la base de datos, el ID de usuario y la contraseña se proporcionan como argumentos.

Luego, se define y ejecuta una consulta SQL para recuperar datos de una tabla en la base de datos utilizando el método pd.read_sql(), donde la consulta SQL y el objeto de conexión se proporcionan como argumentos. Los datos recuperados se almacenan en un marco de datos de pandas.

Finalmente, los datos en el Marco de Datos se exportan a un archivo de Excel llamado "database_data.xlsx" utilizando el método to_excel(), excluyendo la columna de índice de la exportación al establecer el parámetro index en False.

Conclusión

Python es un lenguaje versátil que puedes utilizar para automatizar muchas tareas de Excel. También puedes utilizar diversas bibliotecas como Pandas, openpyxl, xlwings y pyautogui para manipular datos, extraer información, generar informes y automatizar tareas repetitivas.

La automatización puede ahorrar tiempo y esfuerzo, reducir errores y aumentar la productividad. La competencia en Python puede ser una habilidad valiosa para cualquier profesional que trabaje con Excel, ya sea un analista de datos o financiero. Al aprender Python, puedes llevar tu trabajo a nuevos niveles.

¡Conéctate en Twitter y LinkedIn. ¡Gracias por leer!

Cuando era principiante en contribuciones de código abierto, uno de mis mayores desafíos era encontrar los proyectos o problemas correctos en los que trabajar.

Durante mucho tiempo, confié en recursos seleccionados por diferentes autores en Internet -muy buenos-, por cierto.

No obstante, siempre quise encontrar una forma de evitar mi denominado problema personal: una forma de buscar, acceder y seguir proyectos que fueran adecuados para mis habilidades (a fin de poder maximizar mi contribución en línea).

Acordemos una cosa: a diferencia de Google, buscar en GitHub no es fácil. Pero como desarrollador, es probable que interactúes con GitHub o Gitlab a diario.

Ahora la pregunta no es para qué usas estos sistemas de control de versiones, sino cómo los estás usando.

Así como dominar las habilidades de búsqueda en Google es esencial para cualquier usuario regular de Internet; creo que también es esencial para los desarrolladores aprender a buscar eficazmente en GitHub.

En este artículo vamos a echar un vistazo a diferentes técnicas que puedes emplear para efectuar búsquedas más exactas en GitHub. Aprenderás cómo buscar a través de:

• Problemas y solicitudes de extracción
• Repositorios
• Usuarios
• Temas

Y más... Vamos a empezar.

Consultas de búsqueda de GitHub

Es bien sabido que para encontrar información detallada sobre algo en Internet, necesitas tener las habilidades de búsqueda correctas.

No es diferente con GitHub: para encontrar información detallada, puedes utilizar técnicas comunes de filtrado, ordenación y búsqueda para encontrar fácilmente problemas y solicitudes de extracción específicos de un proyecto dado.

Aunque tienes múltiples recursos enumerados en Internet para diferentes proyectos, el principal problema surge cuando quieres hacer una búsqueda por ti mismo.

¿Cómo empiezas? ¿Qué palabras clave deberías usar para encontrar los resultados correctos?

La mayoría de los mantenedores tienden a etiquetar sus proyectos con problemas, lo que facilita que los colaboradores encuentren proyectos adecuados. A continuación se muestran algunos de los trucos que pueden ayudarte cuando estás usando GitHub.

Cómo buscar problemas y solicitudes de extracción en GitHub

Una de las formas más comunes de encontrar proyectos para contribuir es buscando a través de problemas y solicitudes de extracción relacionadas. Aquí hay algunos trucos que puedes usar para encontrar fácilmente respuestas confiables:

1. is:issue is:open label:beginner - Esta consulta particular mostrará todos los proyectos con problemas abiertos etiquetados como principiante. beginner.
2. is:issue is:open label:easy - Aquí mostrará todos los problemas abiertos etiquetados como fáciles.easy.
3. is:issue is:open label:first-timers-only - De esta forma se listan todos los problemas abiertos que dan la bienvenida a contribuciones de recién llegados.
4. is:issue is:open label:good-first-bug - Esto enumera los proyectos con problemas abiertos (open issues) etiquetados como "buenos primeros errores" good-first-bug, para atraer a los colaboradores a trabajar en ellos.
5. is:issue is:open label:"good first issue" - Con esta consulta se te mostrarán todos los problemas abiertos con la etiqueta buen primer problema, good first issue, lo que significa que es un buen lugar para que los principiantes comiencen.
6. is:issue is:open label:starter - Lista todos los problemas abiertos de GitHub etiquetados como iniciadores starters
7. is:issue is:open label:up-for-grabs - Enumera problemas abiertos que están listos para ser trabajados si tienes las habilidades necesarias.
8. no:project type:issue is:open - Mostrará todos los problemas abiertos que no están asignados a un proyecto específico.
9. no:milestone type:issue is:open - Muchas veces, los proyectos están organizados con hitos. Pero si quieres encontrar problemas que no estén rastreados, esta consulta de búsqueda los listará para ti.
10. no:label type:issue is:open - Señala todos los problemas abiertos que no tienen etiquetas.
11. is:issue is:open no:assignee - Enseña todos los problemas abiertos que aún no han sido asignados a una persona.

Cómo buscar repositorios

Por defecto, para realizar una búsqueda, escribirás el nombre del repositorio en la barra de búsqueda ¡y voilà! Obtendrás algunos resultados de búsqueda.

Pero las probabilidades de que llegues al repositorio exacto que tenías en mente son muy bajas.

Veamos algunas formas de estrechar tu búsqueda:

Cómo encontrar por nombre, descripción/README

Al buscar por nombre y descripción del archivo README, hay que tener en cuenta que la frase de búsqueda debe comenzar con el calificador in. Esto hace posible buscar "dentro" de lo que estamos buscando.

Veamos un ejemplo de cómo sería una búsqueda individual:

• Usando in:name. Digamos que estás buscando recursos para aprender más sobre Ciencia de Datos. En este caso, puedes usar el comando Ciencia de Datos in:name, que listará los repositorios con Ciencia de Datos en el nombre del repositorio.
• Usando in:description. Si deseas encontrar repositorios con una descripción específica, por ejemplo, repositorios donde se incluya el término "freeCodeCamp" en la descripción, nuestra búsqueda será: freecodecamp in:description.
• Usando in:readme Utilizas esto para buscar a través de un README de un archivo para una cierta frase. Si queremos encontrar repositorios donde se incluya el término freecodecamp en el README, nuestra búsqueda será: freecodecamp in:readme.
• Usando in:topic. Utilizas esto para encontrar si una cierta frase o palabra está etiquetada en los temas. Por ejemplo, para encontrar todos los repositorios donde freecodecamp esté listado en el tema, nuestra búsqueda será: freecodecamp in:topic.

También se pueden combinar múltiples consultas de búsqueda para estrechar aún más la búsqueda.

Cómo encontrar por Estrellas, Forks

Podemos además buscar un repositorio basado en cuántas estrellas y forks tiene el proyecto. Esto nos facilita saber qué tan popular es el proyecto.

Ejemplos

Usando stars:n. Si buscamos un repositorio con 1000 estrellas entonces la consulta será stars:1000. Esta acción listará exactamente 1000 repositorios.

Empleando forks:n. Aquí especificamos el número de forks (es decir las bifurcaciones o ramificaciones) que deseamos de un repositorio. Si queremos que los forks sean menos de 100 entonces nuestra consulta será la siguiente: forks:<100.

¿La buena noticia? ¡Siempre podemos usar operadores relacionales!  <, >, <=, >= & .. Esto nos ayudará a hacer más fácil y rápida la búsqueda.

Realizando búsquedas mediante el lenguaje

Otra forma genial de buscar en GitHub es mediante el lenguaje. Ello nos ayuda a filtrar nuestro repositorio en base al lenguaje de programación que buscamos.

Por ejemplo:

• Tenemos la forma language:LANGUAGE. Si quisieramos buscar un proyecto con código en PHP, nuestra búsqueda sería: language:PHP

Búsquedas mediante el nombre de la organización

También podemos buscar repositorios/proyectos que son mantenidos o creados por una organización en específico. Para ello necesitamos empezar nuestra búsqueda con la palabra clave org: seguida del nombre de la organización.

Si usamos org:freecodecamp nos mostrará los repositorios que sean de freeCodeCamp.

Encontrando mediante fechas

Si deseamos que los resultados se ajusten a una fecha específica, podemos buscar usando una las siguientes palabras clave: created, updated, merged and closed. Estas palabras clave deberán estar acompañadas por la fecha en el formato YYYY-MM-DD.

Ejemplo:

• Usando keyword:YYYY-MM-DD. Supongamos que deseamos buscar todos los repositorios con la palabra freeCodeCamp que fueron creados después de 2022-10-01. Entonces nuestra búsqueda será: freecodecamp created:>2022-10-01

También podemos usar los operadores relaciones <, >, >= y<= para buscar repositorios después de, antes de o en una fecha exacta . Si queremos buscar en un rango, entonces usamos....

Encontrando repositorios mediante el tipo de licencia

Las licencias son muy importantes cuando estamos buscando un proyecto al cual contribuir. Diferentes licencias otorgan diferentes derechos en cuanto a lo que un contribuidor puede o no puede hacer.

Para facilitarnos la búsqueda de proyectos con las licencias adecuadas, necesitamos tener un buen entendimiento de las licencias. Podemos leer más sobre ellas aquí.

Ejemplo:

• Usamos license:LICENSE_KEYWORD. Esta es una buena forma de buscar proyectos con licencias específicas. Para buscar proyectos con la licencia MIT, por ejemplo, haríamos lo siguiente: license:MIT.

Encontrar por visibilidad

También podemos llevar a cabo nuestra búsqueda en términos de la visibilidad del repositorio. En este caso, podemos usar tanto público como privado.

Esto coincidirá con los problemas (issues) y las solicitudes de extracción (PRs) que estén en un repositorio público o privado, respectivamente.

Ejemplos:

• Usamos is:public. Esto mostrará una lista de repositorios públicos. Tomemos un ejemplo donde queramos buscar todos los repositorios públicos propiedad de freeCodeCamp. Entonces nuestra búsqueda será: is:public org:freecodecamp.
• Usando is:private. Dicha consulta significa que listará todos los repositorios privados dentro de los parámetros.

Conclusión

Aunque hemos cubierto muchas consultas de búsqueda aquí, siempre podemos agregar nuestra creatividad para estrechar aún más nuestra búsqueda combinando varios parámetros juntos.

Para obtener recursos adicionales y más parámetros de búsqueda, siempre podemos consultar la documentación de GitHub o hacer uso de la Búsqueda Avanzada de GitHub.

Estos métodos siempre nos serán útiles ya que ofrecen más opciones de filtrado. Hay una miríada de parámetros de búsqueda y variaciones que podríamos utilizar para hacer más fácil nuestra actividad diaria en GitHub.

Espero que esto les ayude a utilizar la plataforma de manera más fácil y efectiva.

Antes que nada tengo que aclarar que incluyo recursos aparte de FreeCodeCamp. Estos recursos pueden ser perfectamente complementarios para los que desean estudiar algunas de las certificaciones de FreeCodeCamp.

Este artículo es un poco más personal dado que la gran mayoría de estos recursos me han ayudado en mi aprendizaje de Ciencia de Datos. Los comparto como aditamiento a un futuro Podcast de FreeCodeCamp español, organizado por Rafael Hernandez.

Si lo que buscas son proyectos de Python, aquí tienes algunos. Por otra parte, si necesitas un esquema de la disciplina, puedes consultar este artículo. Las recomendaciones son opcionales y están basadas en mi análisis propio (que puede errar), aún así espero que alguna parte de este artículo te sea de ayuda. Sin más demoras, he aquí los recursos.

Recursos en español:

1. Afi Escuela - Machine Learning: Enlace
   Descripción: Este canal de YouTube ofrece una serie de videos sobre Machine Learning, donde podrás aprender los conceptos básicos y técnicas avanzadas de esta disciplina.
2. Data Science: Enlace
   Descripción: Explora esta lista de reproducción que cubre diversos temas relacionados con la Ciencia de Datos, incluyendo análisis exploratorio de datos, visualización y algoritmos de aprendizaje automático.
3. Píldoras Informáticas - SQL: Enlace
   Descripción: Aprende SQL, un lenguaje de consulta utilizado para trabajar con bases de datos, a través de esta serie de videos que cubren desde los fundamentos hasta técnicas más avanzadas.
4. Píldoras Informáticas - Python: Enlace
   Descripción: Descubre el lenguaje de programación Python con esta serie de videos que te guiarán desde los conceptos básicos hasta temas más avanzados.
5. Aprendizaje y Minería de Datos (Con R) - Universidad Politécnica de Valencia: Enlace
   Descripción: Esta lista de reproducción ofrece un curso completo sobre Aprendizaje y Minería de Datos utilizando el lenguaje R. Aprenderás técnicas estadísticas y algoritmos utilizados en este campo.
6. Fundamentos de Estadística - Universidad de los Andes: Enlace
   Descripción: A través de este curso en Coursera, obtendrás los fundamentos de la estadística y aprenderás a aplicarlos en situaciones reales.
7. Curso de R - SEE Sociedad Ecuatoriana de Estadística: Enlace          Descripción: Este es un curso en español ofrecido por la Sociedad Ecuatoriana de Estadística (SEE). Está enfocado en el lenguaje de programación R, ampliamente utilizado en análisis estadístico y en ciencia de datos. R es una herramienta poderosa para visualización, manipulación y análisis de datos. Es ideal para aquellos que deseen fortalecer sus habilidades en el análisis estadístico y la manipulación de datos utilizando R.

Recursos en inglés para aprender Ciencia de Datos:

A continuación, se presentan una serie de enlaces recomendados en inglés que te serán útiles para aprender sobre Ciencia de Datos:

1. Intro to Data Science (Enfoque Matemático)
2. Matemáticas para Ciencia de Datos (Álgebra Lineal) y Cálculo Multivariable
3. Aprendizaje Automático (Andrew NG es un clásico)
4. Aprendizaje Automático (También un clásico y mi primer curso teórico en ML)
5. Matemáticas para Ciencia de Datos (Avanzado)
6. Introducción al Aprendizaje Profundo (Mejor hacer este después de varios cursos introductorios)
7. Aprendizaje Automático (¡Este es mi curso favorito en ML! El curso del Prof. Kilian es muy recomendado)
8. Aprendizaje Automático (Curso muy práctico y estructurado, necesitarás trabajar en un Notebook de Jupyter para seguir el curso)
9. Teoría del Aprendizaje Estadístico (Curso bastante avanzado)
10. Bootcamp de Ciencia de Datos del Hasso Plattner Institute (Este es reciente, la información es libre pero para sacarle provecho tienes que saber las bases de Python y SQL.)

Cursos gratuitos que NO son simples MOOCs:

1. Programación en Python: Este curso es de la Universidad de Helsinki. Aprendí mucho en los cursos de 2019 y 2020, por lo que considero que la tradición aún continúa.
2. Data Análisis en Python: De la misma universidad, solo que centrado en el análisis de datos.
3. Certificado de Analítica de Datos de Google: Sinceramente, no hice el curso de Data Analytics porque era en R y en ese entonces estaba centrado en Python. Sin embargo, completé el Certificado en Gestión de Proyectos, por lo que puedo recomendar la calidad de los cursos de Google. El certificado es de pago, pero puedes pedir ayuda financiera a Coursera en caso de tener una situación económica difícil.
4. Beca AWS Machine Learning Scholarship Program: También tienes que aplicar a ayuda financiera. En este caso, la beca es condicional a una selección siguiendo los criterios y la fecha de aplicación.
5. Applied Data Science Lab: Este es como un bootcamp de Ciencia de Datos. El lenguaje de programación es Python y tienes que aprobar una preselección. El programa es bastante práctico y puede ser bastante demandante si no estás familiarizado/a con la programación orientada a objetos.

Por cierto, la universidad también tiene una Maestría en Ingeniería Financiera. Pero a ver, primero debes tener un título de pregrado, aprobar un test cuantitativo y comprometerte a dedicar hasta 25 horas a la semana en el estudio, lo cual puede generar tensión si ya tienes un trabajo.

Otros consejos para aprender:

Aporta a las comunidades: En mi caso, estuve activo en los foros de R Studio y de la Python Software Foundation, aunque la comunidad a la que más he contribuido ha sido FreeCodeCamp. También he tenido el placer de apreciar el proceso de colaboración en GitLab de la comunidad de NumPy. Incluso sin hacer aportes trascendentales, he aprendido mucho en el proceso. Solo en Python, por ejemplo, hay diversas comunidades que puedes explorar. Puedes encontrar sitios como Devto y otros que son muy útiles para conectar con desarrolladores. No todos necesariamente son científicos de datos, pero puedes aprender mucho de otros roles, lo que fortalecerá tu capacidad. Si estás interesado en una comunidad de nicho, puedes visitar Kaggle.

Lee materiales de Data Science: No voy a recomendar sitios específicos para evitar hacer publicidad, pero leer materiales de Data Science puede ayudarte a reforzar lo que has puesto en práctica.

Aunque no puedes aprender Data Science solo leyendo, el acto de leer puede consolidar tus conocimientos. También puedes optar por revisar exclusivamente el código de otros y analizar si podrías resolver los problemas de manera diferente.

No te preocupes por ser constante: Ok aclarando, hay dos formas de ser constante, una buena en la que tu empiezas algo y te has propuesto casi bajo juramento estudiar una determinada materia o avanzar en cierto proyecto hasta terminar. NO me refiero a ese tipo, eso está muy bien.

Me refiero a la forma "falsa" de ser constante que solo está en nuestra mente debido a nuestros sesgos, es algo así como "el perfil perfecto". Tienes que tener título x, más tantos años de experiencia, y esos mismos años deben de ser en un nicho muy específico, y además debes saber solo cierto lenguaje o cierta herramiento, cierto framework para los proyectos, etc.  No se permiten desvíos en la carrera, ni cambios de sector o algo que ponga en evidencia tu "carrera progresiva".

Este es un error que puede surgir en recursos humanos, perfiles idealizados en los que los requisitos están mucho más orientados a encontrar un personaje más que personas que sepan hacer el trabajo.

La diversidad de capacidades y experiencias es parte importante del ser humano, simplemente no necesitas ser el "personaje perfecto". Es muy cierto que muchas veces lo mejor es aplicar, no obstante, saber analizar cuales ofertas son realmente irrealistas te ayudará a ahorrar tiempo y esfuerzo.

Puede haber asomo de razón en juzgar a un hombre por los más comunes rasgos de su vida, pero en atención a la natural instabilidad de nuestras costumbres e ideas, entiendo que hasta los buenos autores hacen mal obstinándose en formar del hombre una contextura sólida y constante: eligen un principio general, y de acuerdo con él ordenan o interpretan las acciones, y si no logran acomodarlas a la idea preconcebida, toman el partido de disimular las que no entran en su patrón. Montaigne "De la inconstancia de nuestras acciones". Ensayos

La recomendación es la siguiente, no te dejes intimidar por este tipo de "ofertas", analiza bien y verás que hay empresas que cuyos requisitos realmente concuerdan con la necesidad que estas tienen.

Pregúntate lo siguiente: ¿Estos requisitos que solicitan, qué necesidad llegarán a satisfacer en la empresa? No es lógico solicitar a alguien con un MBA, con 4 años de experiencia en proyectos, dos de ellos solo con Kanban y que sepa Python, R, y también HTML solo para un puesto de analista de datos. O tampoco sería cuerdo solicitar alguien con ingeniería en ciencias de la computación y 3 años de experiencia solo en determinado sector para un puesto con funciones similares al de Junior Developer pero con otro nombre.

Escribe para reforzar lo aprendido: Este consejo puede ser un poco sesgado, ya que yo amo escribir. No es necesario tener el talento de Jorge Luis Borges, pero creo que en la escritura técnica sobre ciencia de datos, lo que importa es que el mensaje cumpla una función pedagógica.

No se trata de entretener o impresionar, sino de crear contenido útil que simplifique el aprendizaje. Debe ser un contenido educativo que facilite el proceso al máximo. Al ponerse en el lugar de quien explica y de la audiencia/estudiante, podrás reflexionar sobre el proceso y ayudarte a memorizar el tema de forma inconsciente.

Haz voluntariado: Existen dos formas de poner en práctica lo aprendido. Una es participar en proyectos de código en comunidades donde todos tienen conocimientos de programación, como trabajar en un repositorio de Github. La otra forma es trabajar en un entorno 100% "natural", donde la mayoría no tiene idea de programación o solo tiene conocimientos generales.

Contribuir a proyectos sociales u ONGs que te interesen realizando tareas como procesamiento, análisis y visualización de datos te dará una idea de las dificultades del "mundo real". Descubrirás que no todas las organizaciones tienen un marco adecuado para trabajar con los datos.

En algunos casos, incluso podrías convertirte en educador además de analista de datos, ya que tendrás que explicar los procesos a tu equipo. Incluso para el diseño de una campaña de educación ambiental, podrías necesitar una muestra confiable, y la recolección de datos en los plazos establecidos por el project manager requerirá ajustar la metodología y la gestión...

¡Ups! Perdón por la digresión, pero espero que haya quedado clara la moraleja: en un caso real, el entorno organizacional tiene su peso y siempre debes recordar que trabajarás con personas, no solo con programas. Tus habilidades de comunicación serán clave. Tu trabajo no consistirá simplemente en trabajar con notebooks de jupyter.

PD. Si puedes conseguir una pasantía o un trabajo junior remunerado, puedes prescindir del voluntariado.

Aquí te dejo 3 enlaces relevantes:

• Voluntariado en Data Science
• Data Science for Social Good
• Volunteer with DataKind

La pregunta del millón: ¿Es necesario tener estudios universitarios (pregrado, máster) para ejercer en Data Science?

Respuesta rápida: No. Respuesta extensa: Depende de lo que quieras hacer y dónde quieras trabajar.

Algunas empresas tienen requisitos específicos según el sector. Sin duda, tener una formación universitaria es beneficioso para solicitar el puesto, pero la experiencia suele tener más peso. Puedes empezar creando tu propio portafolio (incluso un portafolio como desarrollador de front-end podría ser un buen comienzo). También existe la posibilidad de hacer una transición desde otro rol como Software Testing a Data Science.

Incluso puestos como analista de negocios (business analyst) o analista de datos son buenos antecedentes. Estos roles también cuentan como experiencia relevante y, junto con un portafolio y algunas certificaciones, puedes realizar una transición. Esto también aplica si tienes formación universitaria pero en áreas no cuantitativas.

Otras Salidas Profesionales en el Campo de la Ciencia de Datos

Por último, es necesario que te preguntes acerca de tus objetivos. Al tener conocimientos de Data Science, hay opciones de carrera. No es como si Data Scientist fuera tu única opción. Incluso fuera del sector de tecnología, existen diversas salidas en las que tu conocimiento de programación te daría una ventaja.

Hoy día, hay periodistas utilizando la ciencia de datos en sus investigaciones, como se evidenció en el caso de los "Panamá Papers", donde se analizaron millones de documentos para revelar información sobre evasión fiscal y corrupción. Estos periodistas combinan su experiencia en periodismo con habilidades en ciencia de datos para desentrañar historias complejas y presentar información de manera impactante.

Los project managers también se benefician de tener conocimientos en ciencia de datos. Dirigir proyectos con soluciones centradas en inteligencia artificial se ha vuelto cada vez más relevante en el mundo empresarial. Los project managers con habilidades en ciencia de datos pueden aprovechar las capacidades analíticas y predictivas para tomar decisiones informadas y liderar proyectos exitosos en entornos tecnológicos.

Además, existen carreras especializadas en campos como el analista de investigación de mercado, donde la capacidad de utilizar herramientas de ciencia de datos para analizar datos de mercado y extraer información relevante es fundamental. Los analistas de investigación de mercado pueden utilizar técnicas de minería de datos y análisis predictivo para comprender mejor las tendencias del mercado y ayudar a las empresas a tomar decisiones estratégicas.

La consultoría en transformación digital es otro campo donde los conocimientos de ciencia de datos son altamente valorados. Recientemente un estudio de Deloitte encontró que la capitalización potencial de este mercado posee muy altas prospectivas.

Ayudar a las organizaciones a aprovechar los datos para optimizar sus procesos, tomar decisiones basadas en datos y adaptarse a los desafíos digitales se ha convertido en una necesidad en la era de la transformación digital. Los consultores en transformación digital con habilidades en ciencia de datos pueden guiar a las empresas en su viaje hacia la adopción de tecnologías y prácticas basadas en datos.

Estas son solo algunas de tantas opciones, por otra parte, cada vez es más popular el término Data Literacy, o alfabetismo de datos, de allí que un conocimiento mínimo de esta disciplina se pueda volver un requisito creciente en varios sectores.

Conclusión.

A lo largo de nuestro recorrido, hemos descubierto que adquirir habilidades en ciencia de datos no solo es valioso para convertirse en un Data Scientist, sino que también abre un abanico de oportunidades profesionales en campos muy diversos.

En un mundo impulsado por los datos, la capacidad de recopilar, analizar y transformar información en conocimiento es una habilidad altamente demandada. Los profesionales de la ciencia de datos son buscados por su capacidad para extraer insights significativos de grandes volúmenes de datos, identificar patrones, predecir tendencias y tomar decisiones basadas en evidencia.

No hay tal cosa como un "perfil fijo" para ciencia de datos, así que no te presiones más de lo necesario a la hora de las entrevistas.

Por último, sonará un poco cliché, pero la ciencia de datos se ha convertido en un elemento clave para que las organizaciones impulsen la innovación, optimicen sus operaciones, comprendan mejor a sus clientes y se adelanten a las demandas del mercado. La combinación de conocimientos en programación, estadísticas, aprendizaje automático y visualización de datos otorga a los científicos de datos una ventaja competitiva para abordar los desafíos complejos de hoy en día.

En 2017, pasé por algunas entrevistas de programación y recibí ofertas de varias grandes empresas tecnológicas. Entonces, en ese momento, decidí compartir lo que había aprendido en este artículo.

Y es que lo acabo de actualizar para 2022, por lo que será relativamente útil y relevante si estás buscando trabajo ahora.

A pesar de obtener calificaciones decentes tanto en mi clase de Algoritmos CS101 como en mi clase de Estructuras de Datos en la universidad, me estremezco al pensar en pasar por una entrevista de programación que se enfoca en algoritmos.

Por lo tanto, pasé los últimos tres meses averiguando cómo mejorar mis habilidades de programación de entrevistas y finalmente recibí ofertas de grandes compañías tecnológicas como Google, Facebook, Airbnb, Lyft, Dropbox y más.

En esta publicación, compartiré las ideas y los consejos que obtuve en el camino. Los candidatos experimentados también pueden esperar preguntas sobre el diseño de sistemas, pero eso está fuera del alcance de esta publicación.

Muchos de los conceptos algorítmicos probados en entrevistas de programación no son los que uso habitualmente en el trabajo, donde soy Ingeniero Front End (web). Naturalmente, me he olvidado un poco de estos algoritmos y estructuras de datos, que aprendí principalmente durante mi primer y segundo año de universidad.

Es estresante tener que producir código (de trabajo) en una entrevista, mientras alguien examina cada pulsación de tecla que haces. Lo que es peor es que, como entrevistado, se te anima a comunicar su proceso de pensamiento en voz alta al entrevistador.

Solía pensar que ser capaz de pensar, programar y comunicarse simultáneamente era una hazaña imposible, hasta que me di cuenta de que la mayoría de las personas simplemente no son buenas programando en entrevistas cuando recién comienzan. La entrevista es una habilidad en la que puedes mejorar estudiando, preparándose y practicando.

Mi reciente búsqueda de trabajo me ha llevado a un viaje para mejorar mis habilidades de programación en las entrevistas. A los ingenieros front-end les gusta despotricar sobre cómo se rompe el proceso de contratación actual porque las entrevistas técnicas pueden incluir habilidades que no están relacionadas con el desarrollo front-end.

Por ejemplo, escribir un algoritmo de resolución de laberintos y fusionar dos listas ordenadas de números. Como ingeniero front-end, puedo empatizar con ellos.

El front-end es un dominio especializado en el que los ingenieros tienen que preocuparse por muchos problemas relacionados con la compatibilidad de los navegadores, el modelo de objetos del documento, el rendimiento de JavaScript, los diseños de CSS, etc.

Es poco común que los ingenieros front-end implementen algunos de los complejos algoritmos probados en las entrevistas.

En empresas como Facebook y Google, las personas son ingenieros de software en primer lugar y, en segundo lugar, expertos en dominios.

Lamentablemente, las reglas las establecen las empresas, no los candidatos. Hay un gran énfasis en conceptos generales de informática como algoritmos, patrones de diseño, estructuras de datos. Habilidades básicas que debe poseer un buen ingeniero de software. Si deseas el trabajo, debes seguir las reglas establecidas por los maestros del juego: ¡Mejorar tus habilidades de entrevista de programación!

Este post está estructurado en las siguientes dos secciones. Siéntete libre de pasar directamente a la sección que te interese.

• El desglose de las entrevistas de programación y cómo prepararse para ellas.
• Sugerencias y sugerencias útiles para cada tema de algoritmo (matrices, árboles, programación dinámica, etc.), junto con preguntas de práctica recomendadas de LeetCode para revisar los conceptos básicos y mejorar esos temas.

El contenido de esta publicación se puede encontrar aquí. Haré actualizaciones allí cuando sea necesario.

Si estás interesado en el contenido de Front End, consulta mi manual de entrevistas de front end aquí.

Elige un lenguaje de programación

Antes que nada, debe elegir un lenguaje de programación para su entrevista de programación algorítmica.

La mayoría de las empresas te permitirán programar en el lenguaje de tu elección. La única excepción que conozco es Google. Permiten que sus candidatos elijan solo Java, C++, Python, Go o JavaScript.

En su mayor parte, recomiendo utilizar un lenguaje con el que esté muy familiarizado, en lugar de uno que sea nuevo para usted pero que la empresa utilice ampliamente.

Hay algunos lenguajes que son más adecuados que otros para codificar entrevistas. Luego hay algunos que absolutamente querrás evitar.

Según mi experiencia como entrevistador, la mayoría de los candidatos eligen Python o Java. Otros lenguajes comúnmente seleccionados incluyen JavaScript, Ruby y C++. Absolutamente, evitaría los lenguajes de nivel inferior como C o Go, simplemente porque carecen de estructuras de datos y funciones de biblioteca estándar.

Personalmente, Python es mi elección de facto para codificar algoritmos durante las entrevistas. Es sucinto y tiene una enorme biblioteca de funciones y estructuras de datos.

Una de las principales razones por las que recomiendo Python es que utiliza API consistentes que operan en diferentes estructuras de datos, como len(), for ... in ... y notación de corte en secuencias (cadenas, listas y tuplas). Obtener el último elemento en una secuencia es arr[-1] , e invertirlo es simplemente arr[::-1]. Puede lograr mucho con una sintaxis mínima en Python.

Java también es una opción decente. Pero debido a que tendrás que declarar constantemente tipos en su código, significa ingresar pulsaciones de teclas adicionales. Esto ralentizará la velocidad a la que codifica y escribe. Este problema será más evidente cuando tengas que escribir en una pizarra durante las entrevistas en el sitio.

Las razones para elegir o no C++ son similares a Java. En última instancia, Python, Java y C++ son opciones decentes. Si has estado usando Java por un tiempo y no tienes tiempo para familiarizarse con otro lenguaje, te recomiendo que te ciña a Java en lugar de retomar Python desde cero.

Esto te ayuda a evitar tener que usar un lenguaje para el trabajo y otro para las entrevistas. La mayoría de las veces, el cuello de botella está en el pensamiento y no en la escritura.

Una excepción a la convención de permitir que el candidato "escoja cualquier lenguaje de programación que desee" es cuando la entrevista es para un puesto de dominio específico, como roles de ingeniero front-end, iOS o Android. Debes estar familiarizado con los algoritmos en JavaScript, Objective-C, Swift y Java, respectivamente.

Si necesitas usar una estructura de datos que el lenguaje no admite, como una cola o un montón en JavaScript, pregúntale al entrevistador si puede suponer que tiene una estructura de datos que implementa ciertos métodos con complejidades de tiempo específicas.

Si la implementación de esa estructura de datos no es crucial para resolver el problema, el entrevistador generalmente lo permitirá.

En realidad, ser consciente de las estructuras de datos existentes y seleccionar las adecuadas para abordar el problema en cuestión es más importante que conocer los intrincados detalles de implementación.

Revisa introducción a las ciencias de la computación

Si has estado fuera de la universidad durante algún tiempo, es muy recomendable que revises los fundamentos de CS. Prefiero repasarlo mientras practico. Escaneo mis notas de la universidad y reviso los diversos algoritmos mientras trabajo en los problemas de algoritmos de LeetCode y Cracking the Coding Interview.

Si tienes interés en cómo se implementan las estructuras de datos, consulta Lago, un repositorio de GitHub que contiene ejemplos de estructuras de datos y algoritmos en JavaScript.

GitHub - yangshun/lago: ? Data Structures and Algorithms library in TypeScript

? Data Structures and Algorithms library in TypeScript - GitHub - yangshun/lago: ? Data Structures and Algorithms library in TypeScript

GitHubyangshun

La maestría deviene de la práctica

Luego, adquiere familiaridad y dominio de los algoritmos y las estructuras de datos en el lenguaje de programación elegido.

Practica y resuelve preguntas de algoritmos en el lenguaje que elijas. Si bien Cracking the Coding Interview es un buen recurso, prefiero resolver problemas escribiendo código, dejándolo funcionar y recibiendo comentarios instantáneos.

Existen diversos recursos online como LeetCode, HackerRank, y CodeForces con los que puedes practicar ejercicios a la vez que te acostumbras al lenguaje.

Según mi experiencia, las preguntas de LeetCode son muy similares a las preguntas que se hacen en las entrevistas.

Las preguntas de HackerRank y CodeForces son más similares a las preguntas de la programación competitiva. Si practicas suficientes preguntas de LeetCode, es muy probable que veas o completes una de las preguntas de su entrevista real (o alguna variante de la misma).
Aprender y llegar a comprender las complejidades de tiempo y espacio de las operaciones comunes en el lenguaje elegido. Para Python, esta página será útil. Además, aprende sobre el algoritmo de clasificación subyacente que se usa en la función sort() del lenguaje y sus complejidades de tiempo y espacio (en Python es Timsort, que es un híbrido).
Después de completar una pregunta sobre LeetCode, generalmente agrego las complejidades de tiempo y espacio del código escrito como comentarios sobre el cuerpo de la función.

En lo personal utilizo los comentarios para recordarme comunicar el análisis del algoritmo después de haber completado la implementación.
Lee sobre el estilo de programación recomendado para tu lenguaje y apégate a él. Si eliges Python, consulta la Guía de estil. Si eliges Java, consulta la Guía de estilo de Java de Google.
Aprende y acostúmbrate a las trampas y advertencias comunes del lenguaje. Si las señalas durante la entrevista y evitas caer en ellos, ganarás puntos de bonificación e impresionarás al entrevistador, independientemente de si el entrevistador está familiarizado con el lenguaje o no.
Obtén una amplia exposición a las preguntas de varios temas. En la segunda mitad del artículo, menciono temas de algoritmos y las preguntas útiles para practicar cada tema. Hacer alrededor de 100 a 200 preguntas de LeetCode debería considerarse como algo bueno.

Si prefieres cursos donde el aprendizaje está más estructurado, aquí hay algunas recomendaciones. De ninguna manera es obligatorio tomar cursos en línea para aprobar las entrevistas.

• AlgoMonster :Tiene como objetivo ayudarlo a superar la entrevista técnica en el menor tiempo posible. Diseñado por los ingenieros de Google, AlgoMonster utiliza un enfoque basado en datos para enseñarte los patrones de preguntas clave más útiles y tiene contenido para ayudarte a revisar rápidamente las estructuras de datos y los algoritmos básicos. Lo mejor de todo es que AlgoMonster no está basado en suscripción: paguas una tarifa única y obtienes acceso de por vida.
• Grokking the Coding Interview: Patterns for Coding Questions: por Educative amplía las preguntas de práctica recomendadas en este artículo, pero aborda la práctica desde una perspectiva de patrón de preguntas. Este es un enfoque con el que también estoy de acuerdo para aprender y que he usado personalmente para mejorar en las entrevistas de programación. El curso te permite practicar preguntas seleccionadas en Java, Python, C++, JavaScript y también proporciona soluciones de muestra en esos lenguajes. Aprende y entiende los patrones, no memorices las respuestas.
  Y por supuesto, práctica, práctica y más práctica!

Fases de una entrevesta de programación

¡Felicitaciones, estás listo para poner en práctica tus habilidades! En una entrevista de programación, el entrevistador te hará una pregunta técnica. Escribirás el código en un editor colaborativo en tiempo real (pantalla del teléfono) o en una pizarra (whiteboard), y tendrás de 30 a 45 minutos para resolver el problema.

¡Aquí es donde comienza la verdadera diversión!
Tu entrevistador buscará que cumplas con los requisitos del puesto. Depende de ti demostrarles que tienes las habilidades. Inicialmente, puede parecer extraño hablar mientras programan, ya que la mayoría de los programadores no tienen la costumbre de explicar en voz alta sus pensamientos mientras escriben el código.
Sin embargo, es difícil para el entrevistador saber lo que estás pensando con solo mirar tu código.

Si comunicas tu enfoque al entrevistador incluso antes de comenzar a codificar, puedes validar tu enfoque con ellos. De esta manera, los dos pueden ponerse de acuerdo sobre un enfoque aceptable.

Preparándote para una entrevista remota

Para pantallas telefónicas y entrevistas remotas, ten papel y bolígrafo o lápiz para anotar notas o diagramas. Si te hacen una pregunta sobre árboles y gráficos, generalmente ayuda si dibuja ejemplos de la estructura de datos.

Usa auriculares. Asegúrate de estar en un ambiente tranquilo. No querrás tener un teléfono en una mano y escribir con la otra. Trate de evitar el uso de altavoces. Si la retroalimentación es mala, la comunicación se hace más difícil. Tener que repetirse solo resultará en la pérdida de un tiempo valioso.

¿Qué hacer cuando tengas la pregunta?

Muchos candidatos comienzan a programar tan pronto como escuchan la pregunta. Eso suele ser un gran error. Primero, tómate un momento y repita la pregunta al entrevistador para asegurarse de que comprendes la pregunta.

Si no entiendes la pregunta, entonces el entrevistador puede aclararla.
Siempre busca una aclaración sobre la pregunta al escucharla, incluso si crees que está clara. Es posible que descubras que te has perdido de algo. De esta forma también le muestras al entrevistador que estás atento a los detalles.

Considera hacer las siguientes preguntas.

• ¿Cuál es el tamaño del input?
• ¿Cuál es el tamaño del rango de valores?
• ¿Qué tipo de valores hay? ¿Hay números negativos? ¿Puntos flotantes? ¿Habrá entradas vacías?
• ¿Hay duplicados en el input?
• ¿Cuáles son algunos casos extremos que aplican para el input?
• ¿Cómo se almacena el input ? Si me dan un diccionario de palabras... ¿Es una lista de cadenas o un trie?

Después de haber aclarado suficientemente el alcance y la intención del problema, explica tu enfoque de alto nivel al entrevistador, incluso si es una solución ingenua. Si estás atascado, considera varios enfoques y explica en voz alta por qué puede o no funcionar. A veces, tu entrevistador puede dar pistas y guiarte hacia el camino correcto.
Comienza con un enfoque algo directo; comunica al entrevistador. Explica las complejidades de tiempo y espacio y aclara por qué es malo. En este punto, el entrevistador generalmente mostrará el temido "¿Podemos hacerlo mejor?" pregunta.

Esto significa que están buscando un enfoque más óptimo.
Esta suele ser la parte más difícil de la entrevista. En general, busca trabajos repetidos e intenta optimizarlos almacenando potencialmente en caché el resultado calculado en alguna parte.

Consúltalo más tarde, en lugar de calcularlo todo de nuevo. Proporciono aquí algunos consejos sobre cómo abordar preguntas específicas del tema en detalle a continuación.
Solo comienza a programar después de que tú y tu entrevistador hayan acordado un enfoque y le hayan dado luz verde.

Comenzando a programar

Usa un buen estilo para escribir tu código. Leer código escrito por otros no suele ser una tarea agradable. Leer código con un formato horrible escrito por otros es aún peor. Tu objetivo es hacer que su entrevistador entienda tu código para que pueda evaluar rápidamente si tu código hace lo que se supone que debe hacer y si resuelve un problema determinado.
Utiliza nombres de variables claros y evita nombres que sean letras sueltas, a menos que sean para iteración. Sin embargo, si estás programando en whiteboard, evita usar nombres de variables detallados. Esto reduce la cantidad de escritura que tendrás que hacer.
Siempre explica al entrevistador lo que estás escribiendo. No se trata de leer, palabra por palabra, al entrevistador el código que estás produciendo. Habla sobre la sección del código que estás implementando actualmente en un nivel superior. Explica por qué está escrito así y qué estás tratando de lograr.
Cuando copies y pegues el código, considera si es necesario. A veces lo es, a veces no lo es.

Si te encuentras copiando y pegando una gran cantidad de código que abarca varias líneas, probablemente sea un indicador de que puedas reestructurar el código extrayendo esas líneas en una función. Si se trata de una sola línea que copiaste, por lo general está bien.
Sin embargo, recuerda cambiar las variables respectivas en tu línea de código copiada cuando sea relevante. Los errores de copiado y pegado son una fuente común de errores, ¡Incluso en la programación diaria!

Después de programar

Una vez que hayas terminado de codificar, no anuncies inmediatamente al entrevistador que has terminado. En la mayoría de los casos, tu código no suele ser perfecto. Puede contener bugs o errores de sintaxis. Lo que tienes que hacer es revisar tu código.
Primero, revisa tu código de principio a fin. Míralo como si lo hubiera escrito otra persona, lo estás viendo por primera vez y tratando de detectar errores en él. Eso es exactamente lo que hará tu entrevistador. Revisa y arregla cualquier problema que puedas encontrar.
A continuación, propón casos de prueba pequeños y avance a través del código (no tu algoritmo) con esas entradas de muestra.
A los entrevistadores les gusta cuando les lees la mente. Lo que suelen hacer después de que hayas terminado de codificar es pedirte que escribas pruebas. Es una gran ventaja si escribes pruebas para su código incluso antes de que te soliciten que lo haga. Deberías estar emulando un depurador al recorrer su código. Anota o diles los valores de ciertas variables mientras guía al entrevistador a través de las líneas de código.

Si hay grandes fragmentos de código duplicados en su solución, reestructura el código para mostrarle al entrevistador que valoras la progamación de calidad. Además, busca lugares donde pueda hacer una evaluación de cortocircuito.

Por último, menciona las complejidades de tiempo y espacio de su código y explicas por qué es así. Puedes anotar fragmentos de su código con sus diversas complejidades de tiempo y espacio para demostrar su comprensión del código. Incluso puedes proporcionar las API de su lenguaje de programación elegido. Explica cualquier compensación entre tu enfoque actual y los enfoques alternativos, posiblemente en términos de tiempo y espacio.
Si tu entrevistador está satisfecho con la solución, la entrevista generalmente termina aquí.

También es común que el entrevistador te haga preguntas de extensión, como cómo manejarías el problema si toda la entrada es demasiado grande para caber en la memoria, o si la entrada llega como un flujo. Esta es una pregunta de seguimiento común en Google, donde se preocupan mucho por la escala.
La respuesta suele ser un enfoque de divide y vencerás: realiza un procesamiento distribuido de los datos y solo lee ciertos fragmentos de la entrada del disco en la memoria, escribe la salida nuevamente en el disco y combínalos más tarde.

Practica con entrevistas simuladas

Los pasos mencionados anteriormente se pueden ensayar una y otra vez hasta que los hayas internalizado por completo y se conviertan en una segunda naturaleza para ti. Una buena manera de practicar es asociarse con un amigo y turnarse para entrevistarse.
Un gran recurso para prepararse para entrevistas de codificación es interviewing.io. Esta plataforma ofrece entrevistas de práctica gratuitas y anónimas con ingenieros de Google y Facebook, que pueden conducir a trabajos y pasantías reales.
En virtud de ser anónimo durante la entrevista, el proceso de entrevista inclusiva es imparcial y de bajo riesgo. Al final de la entrevista, tanto el entrevistador como el entrevistado pueden retroalimentarse mutuamente con el fin de ayudarse mutuamente a mejorar.
Hacer bien las entrevistas simuladas desbloqueará la página de trabajos para los candidatos y les permitirá reservar entrevistas (también de forma anónima) con las principales empresas como Uber, Lyft, Quora, Asana y más.

Para aquellos que son nuevos en las entrevistas de codificación, se puede ver una entrevista de demostración en este sitio. Ten en cuenta que este sitio requiere que los usuarios inicien sesión.
He usado interviewing.io, tanto como entrevistador como como entrevistado. La experiencia fue genial. A Aline Lerner, directora ejecutiva y cofundadora de entrevistas.io, y a su equipo les apasiona revolucionar el proceso de codificación de entrevistas y ayudar a los candidatos a mejorar sus habilidades de entrevista.
También ha publicado una serie de artículos relacionados con entrevistas de codificación en el blog interviewing.io. Recomiendo registrarse lo antes posible en interviewing.io, aunque esté en versión beta, para aumentar la probabilidad de recibir una invitación.

Otra plataforma útil para las entrevistas es Pramp. Mientras que Interviewing.io conecta a los posibles buscadores de empleo con entrevistadores de codificación experimentados, Pramp adopta un enfoque diferente. Pramp te empareja con otro compañero que también busca trabajo. Los dos se turnan para asumir los roles de entrevistador y entrevistado. Pramp también prepara preguntas y brinda soluciones e indicaciones para guiar al entrevistado.

Avanza y conquista

Después de hacer una buena cantidad de preguntas en LeetCode y tener suficiente práctica haciendo entrevistas simuladas, continúe y ponga a prueba sus nuevas habilidades de entrevista.
Postula a tus empresas favoritas o, mejor aún, obtén referencias de tus amigos que trabajan para esas empresas. Las referencias tienden a notarse antes y tienen una tasa de respuesta más rápida que la solicitud sin una referencia. ¡Buena suerte!

Consejos prácticos para resolver preguntas de programación

Esta sección profundiza en consejos prácticos para temas específicos de algoritmos y estructuras de datos, que aparecen con frecuencia en las preguntas de codificación. Muchas preguntas de algoritmos involucran técnicas que se pueden aplicar a preguntas de naturaleza similar.
Cuantas más técnicas tengas en tu arsenal, mayores serán tus posibilidades de pasar la entrevista. Para cada tema, también hay una lista de preguntas recomendadas, que es valiosa para dominar los conceptos básicos. Algunas de las preguntas solo están disponibles con una suscripción paga a LeetCode, que en mi opinión vale la pena si te consigue un trabajo.

Consejos generales

Siempre valida la entrada primero. Verifica las entradas que no son válidas, están vacías, son negativas o diferentes. Nunca asumas que te dan los parámetros válidos.

Alternativamente, aclara con el entrevistador si puedes asumir una entrada válida (generalmente sí), lo que puede ahorrarte tiempo al escribir código que valida la entrada.
¿Hay algún requisito o restricción de complejidad de tiempo y espacio?
Comprueba si hay errores de apagado por uno.

En lenguajes donde no hay coerción automática de tipos, comprobar que la concatenación de valores sea del mismo tipo: int,str, y list.

Después de terminar tu código, use algunas entradas de ejemplo para probar su solución.
¿Se supone que el algoritmo debe ejecutarse varias veces, quizás en un servidor web? En caso afirmativo, es probable que la entrada se pueda procesar previamente para mejorar la eficiencia en cada llamada a la API.

Usa una combinación de paradigmas de programación funcional e imperativa:

• Escribe funciones puras tan a menudo como sea posible.
• Usa funciones puras porque es más fácil razonar con ellas y pueden ayudar a reducir errores en su implementación.
• Evita mutar los parámetros pasados a su función, especialmente si se pasan por referencia, a menos que esté seguro de lo que está haciendo.
• Logra un equilibrio entre precisión y eficiencia. Usa la cantidad correcta de código funcional e imperativo cuando corresponda. La programación funcional suele ser costosa en términos de complejidad espacial debido a la no mutación y la asignación repetida de nuevos objetos. Por otro lado, el código imperativo es más rápido porque opera en objetos existentes.
• Evita confiar en la mutación de variables globales. Las variables globales introducen el estado.
• Asegúrate de no mutar accidentalmente las variables globales, especialmente si tienes que depender de ellas.

Generalmente, para mejorar la velocidad de un programa, podemos optar por usar una estructura de datos o algoritmo apropiado, o usar más memoria. Es un intercambio clásico de espacio y tiempo.
Las estructuras de datos son sus armas. Elegir el arma adecuada para la batalla adecuada es la clave de la victoria. Conozca las fortalezas de cada estructura de datos y la complejidad del tiempo para sus diversas operaciones.
Las estructuras de datos se pueden aumentar para lograr una complejidad de tiempo eficiente en diferentes operaciones. Por ejemplo, un HashMap se puede usar junto con una lista doblemente enlazada para lograr una complejidad de tiempo O(1) para la operación  get and put  en una memoria caché LRU.

HashMaps es probablemente la estructura de datos más utilizada para preguntas de algoritmos. Si estás atascado en una pregunta, su último recurso puede ser enumerar las posibles estructuras de datos (afortunadamente no hay tantas) y considerar si cada una de ellas se puede aplicar al problema. Esto ha funcionado para mí a veces.
Si estás tomando atajos en tu código, díselo en voz alta a tu entrevistador y explícale lo que harías fuera de un entorno de entrevista (sin limitaciones de tiempo). Por ejemplo, explica que escribirías una expresión regular para analizar una cadena en lugar de usar split , que no cubre todos los casos.

Secuencia

Notas

Las matrices y las cadenas se consideran secuencias (una cadena es una secuencia de caracteres). Hay consejos para tratar con matrices y cadenas, que se tratarán aquí.
¿Hay valores duplicados en la secuencia? ¿Afectarían la respuesta?
Comprueba si hay una secuencia fuera de los límites.
Ten cuidado con dividir o concatenar secuencias en tu código. Por lo general, las secuencias de corte y concatenación requieren tiempo O(n). Utiliza índices de inicio y finalización para delimitar un subarreglo o una subcadena siempre que sea posible.
A veces se atraviesa la secuencia desde el lado derecho en lugar de desde el izquierdo.

Domina la técnica de sliding window ya que se aplica a muchos problemas de subcadenas o subarreglos.

Cuando se le dan dos secuencias para procesar, es común tener un índice por secuencia para recorrer. Por ejemplo, usamos el mismo enfoque para fusionar dos matrices ordenadas.

Casos comunes

• Secuencia vacía
• Secuencia con 1 o 2 elementos
• Secuencia con elementos repetidos

Arreglos

Notas

¿La matriz está ordenada o parcialmente ordenada? Si es así, alguna forma de búsqueda binaria debería ser posible. Esto generalmente significa que el entrevistador está buscando una solución que sea más rápida que O(n).
¿Puedes ordenar la matriz? A veces, ordenar la matriz primero puede simplificar significativamente el problema. Asegúrate de que no sea necesario conservar el orden de los elementos de la matriz antes de intentar ordenarlos.
Para las preguntas en las que se trata de la suma o la multiplicación de un subarreglo, puede ser útil el cálculo previo mediante hashing o un prefijo, una suma de sufijos o un producto.
Si te dan una secuencia y el entrevistador te pide espacio O(1), podría ser posible usar la matriz en sí como una tabla hash. Por ejemplo, si la matriz tiene valores solo de 1 a N, donde N es la longitud de la matriz, niega el valor en ese índice (menos uno) para indicar la presencia de ese número.

Practice Questions

• Dos Sumas
• Mejor tiempo para comprar y vender existencias
• Contenido duplicado
• Producto del arreglo con excepción de Self
• Máximo subarreglo
• Máximo producto del subarreglo
• Encuentra el mínimo en una matriz traspuesta ordenada
• SearchBusca en un arreglo traspuesto ordenado
• 3Sum
• Contenedor con mayor cantidad de agua

Binario

Links de estudio

• Bits, Bytes, construyendo con los binarios

Notas

A veces se hacen preguntas que involucran representaciones binarias y operaciones bit a bit. Debes saber cómo convertir un número de forma decimal a forma binaria, y viceversa, en el lenguaje de programación elegido.
Algunos fragmentos útiles de utilidad:

• Probar que kth es: num & (1 << k) != 0
• Conjunto kth bit es: num |= (1 << k)
• Turn off kth bit: num &= ~(1 << k)
• Alternar el k-ésimo bit: num ^= (1 << k)
• Para comprobar si un número es una potencia de 2: num & num - 1 == 0.

Casos comunes

• Comprueba si hay desbordamiento/subdesbordamiento
• Números negativos

Preguntas de prácticas

• Suma de dos enteros
• Número de 1 Bits
• Contador de Bits
• Número faltante
• Reverso de Bits

Programación Dinámica

Links de estudio

• Desmistificando la Programación Dinámica

Notas

La Programación Dinámica (DP) se usa generalmente para resolver problemas de optimización. Alaina Kafkes ha escrito una publicación increíble sobre cómo abordar los problemas de DP. Deberías leerlo.
La única forma de mejorar en DP es con práctica. Se necesita mucha práctica para reconocer que un problema puede ser resuelto por DP.
Para optimizar el espacio, a veces no es necesario almacenar toda la tabla DP en la memoria. Los dos últimos valores o las dos últimas filas de la matriz serán suficientes.

Practice Questions

• 0/1 Knapsack
• Subiendo escaleras
• Cambio de moneda
• Subsecuencia creciente más larga
• Subsecuencia común más larga
• Problema de salto de palabra
• Suma de combinación
• House Robber y House Robber II
• Formas de decodificar
• Caminos únicos
• Jump Game

Geometría

Notas

Al comparar la distancia euclidiana entre dos pares de puntos, es suficiente usar dx² + dy². No es necesario sacar la raíz cuadrada del valor.
Para saber si dos círculos se superponen, verifica que la distancia entre los dos centros de los círculos sea menor que la suma de sus radios.

Grafos

Links de estudio

• De la teoría a la práctica: Representando grafos Theory To Practice: Representing Graphs
• Profundiza a través de un grafo: DFS Traversal
• Explicando un grafo: BFS Traversal

Notas

Estar familiarizado con las diversas representaciones gráficas y algoritmos de búsqueda de gráficos, y con sus complejidades de tiempo y espacio.
Se le puede dar una lista de bordes y se le puede asignar la tarea de construir su propio gráfico a partir de los bordes para realizar un recorrido. Las representaciones gráficas comunes son

• Matriz de adyacencia
• Lista de adyacencia
• HashMap de HashMaps

Algunas entradas parecen árboles, pero en realidad son grafos. Aclara esto con tu entrevistador. En ese caso, deberá manejar los ciclos y mantener un conjunto de nodos visitados al atravesar.

Algoritmos de búsqueda de grafos

• Común: Primera Búsqueda en Amplitud (BFS), Primera búsqueda en profundidad (DFS)
• Poco común: clasificación topológica, algoritmo de Dijkstra
  Raro: algoritmo de Bellman-Ford, algoritmo de Floyd-Warshall, algoritmo de Prim y algoritmo de Kruskal

En las entrevistas de codificación, los grafos se representan comúnmente como matrices 2-D, donde las celdas son los nodos y cada celda puede atravesar a sus celdas adyacentes (arriba, abajo, izquierda y derecha). Por lo tanto, es importante estar familiarizado con atravesar una matriz 2-D.
Cuando atravieses recursivamente la matriz, siempre asegúrate de que su próxima posición esté dentro de los límites de la matriz. Puedes encontrar más consejos para hacer DFS en una matriz aquí. Una plantilla simple para hacer DFS en una matriz aparece así:

def traverse(matrix):
  rows, cols = len(matrix), len(matrix[0])
  visited = set()
  directions = ((0, 1), (0, -1), (1, 0), (-1, 0))
  def dfs(i, j):
    if (i, j) in visited:
      return
    visited.add((i, j))
    # Traverse neighbors
    for direction in directions:
      next_i, next_j = i + direction[0], j + direction[1]
      if 0 <= next_i < rows and 0 <= next_j < cols: # Check boundary
        # Add any other checking here ^
        dfs(next_i, next_j)
  for i in range(rows):
    for j in range(cols):
      dfs(i, j)

Casos comunes

• Grafo vacío
• Grafo con uno o dos nodos
• Grafo disjuntas
• Grafo con ciclos

Preguntas de práctica

• Gráfica de clón
• Horario de clases
• Diccionario Alien
• Flujo de agua del Pacífico-Atlántico
• Número de islas
• Grafo de árbol válido
• Número de componentes conectados en un grafo no dirigido
• Secuencia consecutiva más larga Consecutive

Intervalo

Notas

Las preguntas de intervalo son preguntas que dan una matriz de matrices de dos elementos (un intervalo). Los dos valores representan un valor inicial y final. Las preguntas de intervalo se consideran parte de la familia de matrices, pero involucran algunas técnicas comunes. Por lo tanto, tienen su propia sección especial.

Un ejemplo de un arreglo con intervalo es el siguiente: [[1, 2], [4, 7]].

Las preguntas de intervalo pueden ser complicadas para aquellos que no tienen experiencia con ellas. Esto se debe a la gran cantidad de casos a considerar cuando las matrices de intervalos se superponen.

Aclara con el entrevistador si [1, 2] y [2, 3] se consideran intervalos superpuestos, porque afecta cómo escribirá sus comprobaciones de igualdad.

Una rutina común para las preguntas de intervalo es ordenar la matriz de intervalos por el valor inicial de cada intervalo.
Tienes que familiarizarte con la escritura de código para verificar si dos intervalos se superponen y fusionar dos intervalos superpuestos:

def is_overlap(a, b):
  return a[0] < b[1] and b[0] < a[1]
  
def merge_overlapping_intervals(a, b):
  return [min(a[0], b[0]), max(a[1], b[1])]

Casos comunes

• Intervalo único
• Intervalos no superpuestos
• Un intervalo totalmente consumido dentro de otro intervalo
• Intervalos duplicados

Practice Questions

• Inserta un Intervalo
• Une intervalos
• Meeting Rooms and Meeting Rooms II
• Intervalos no superpuestos

Lista enlazada

Notas

Al igual que las matrices, las listas enlazadas se utilizan para representar datos secuenciales. El beneficio de las listas enlazadas es que la inserción y eliminación de código desde cualquier lugar de la lista es O(1), mientras que en las matrices, los elementos deben cambiarse.
Agregar un nodo ficticio en la cabeza o en la cola podría ayudar a manejar muchos casos extremos en los que las operaciones deben realizarse en la cabeza o en la cola. La presencia de nodos ficticios asegura que las operaciones nunca se ejecutarán en la cabeza o la cola. Los nodos ficticios eliminan el dolor de cabeza de escribir comprobaciones condicionales para tratar con punteros nulos. Asegúrate de quitarlos al final de la operación.
A veces, el problema de las listas enlazadas se puede resolver sin almacenamiento adicional. Trata de tomar prestadas ideas del problema de listas enlazadas inversas.
Para la eliminación en listas vinculadas, puedes modificar los valores de los nodos o cambiar los punteros de los nodos. Es posible que debas mantener una referencia al elemento anterior.
Para particionar listas vinculadas, crea dos listas vinculadas separadas y vuelve a unirlas.
Los problemas de listas enlazadas comparten similitudes con los problemas de matrices. Piensa en cómo resolvería un problema de matriz y aplíquelo a una lista enlazada.

Los enfoques de dos punteros también son comunes para las listas enlazadas:

• Obtener el kth del último nodo: tienes dos punteros, donde uno está k nodos delante del otro. Cuando el nodo de delante llega al final, el otro nodo está k nodos detrás.
• Ciclos de detección: tienes dos punteros, donde un puntero aumenta el doble que el otro. Si los dos punteros se encuentran, significa que hay un ciclo.
• Obtener el nodo medio: tienes dos punteros. Un puntero se incrementa el doble que el otro. Cuando el nodo más rápido llegue al final de la lista, el nodo más lento estará en el medio.

Es bueno acostumbrarse a las siguientes rutinas porque muchas preguntas de listas enlazadas utilizan una o más de estas rutinas en su solución.

• Contar el número de nodos en la lista enlazada
• Invertir una lista enlazada en su lugar
• Encuentra el nodo medio de la lista enlazada usando punteros rápidos o lentos
• Combinar dos listas juntas

Casos comunes

• Nodo único
• Dos nodos
• La lista enlazada tiene un ciclo. Aclare con el entrevistador si puede haber un ciclo en la lista. Por lo general, la respuesta es no.

Preguntas de práctica

• Revierte una lista enlazada
• Detecta un ciclo en una lista enlazada
• Une dos listas ordenadas Two Sorted Lists
• Une K listas ordenadas
• Remueve el nodo Nth del final de la lista
• Reordena la Lista

Matemáticas

Notas

Si el código implica división o módulo, recuerda verificar si hay división o módulo por 0.
Cuando una pregunta involucra "un múltiplo de un número", el módulo puede ser útil.
Verifica y maneja el desbordamiento y el subdesbordamiento si estás utilizando un lenguaje escrito como Java y C++. Como mínimo, menciona que es posible un desbordamiento o un desbordamiento y pregunta si necesitas manejarlo.
Considera números negativos y números de coma flotante. Esto puede sonar obvio, pero cuando estás bajo presión en una entrevista, muchos puntos obvios pasan desapercibidos.
Si la pregunta pide implementar un operador como potencia, raíz cuadrada o división, y debes ser más rápido que O(n), la búsqueda binaria suele ser el enfoque.

Algunas fórmulas comunes

• Suma de 1 a N = (n+1) * n/2
• Suma de GP = 2⁰ + 2¹ + 2² + 2³ + … 2^n = 2^(n+1)-1
• Permutaciones of N = N! / (N-K)!
• Combinaciones of N = N! / (K! * (N-K)!)

Casos comunes

• División por 0
• Desbordamiento y subdesbordamiento de enteros

Preguntas de práctica

• Pow(x, n)
• Sqrt(x)
• Entero a palabras en inglés

Matriz

Notas

Una matriz es un arreglo bidimensional. Las preguntas que involucran matrices generalmente están relacionadas con la programación dinámica o el recorrido de gráficos.
Para preguntas que involucren programación transversal o dinámica, tienes que hacer una copia de la matriz con las mismas dimensiones que se inicializan a valores vacíos. Utiliza estos valores para almacenar el estado visitado o la tabla de programación dinámica. Familiarízate con esta rutina:

rows, cols = len(matrix), len(matrix[0])
copy = [[0 for _ in range(cols)] for _ in range(rows)

• Muchos juegos basados en cuadrículas se pueden modelar como una matriz. Por ejemplo, Tic-Tac-Toe, Sudoku, Crossword, Connect 4 y Battleship. No es raro que se te pida que verifiques la condición ganadora del juego.
• Para juegos como Tic-Tac-Toe, Connect 4 y Crosswords, la verificación debe realizarse vertical y horizontalmente. Un truco es escribir código para verificar la matriz de las celdas horizontales. Luego transpón la matriz, reutilizando la lógica utilizada para la verificación horizontal para verificar celdas originalmente verticales (que ahora son horizontales).
• Transponer una matriz en Python es simple:

transposed_matrix = zip(*matrix)

Casos comunes

• Matriz vacía. Verifique que ninguna de las matrices tenga una longitud de 0.
• Matriz 1 x 1.
• Matriz con una fila o columna

Preguntas de práctica

• Conjunto de matriz cero
• Matriz espiral
• Imagen traspuesta
• Buscador de palabras

Recursión

Notas

La recursividad es útil para la permutación, porque genera todas las combinaciones y preguntas basadas en árboles. Debes saber cómo generar todas las permutaciones de una secuencia y cómo manejar los duplicados.
Recuerda siempre definir un caso base para que su recursión termine.

La recursividad utiliza implícitamente una pila. Por lo tanto, todos los enfoques recursivos se pueden reescribir iterativamente usando una pila.

Ten cuidado con los casos en los que el nivel de recurrencia es demasiado profundo y provoca un desbordamiento de la pila (el límite predeterminado en Python es 1000). Puedes obtener puntos de bonificación por señalar esto al entrevistador.

La recursividad nunca será una complejidad de espacio O(1) porque se trata de una pila, a menos que haya una optimización de llamada final (TCO). Averigua si su lenguaje elegido es compatible con TCO.

Preguntas de práctica

• Subconjunto and Subconjunto II
• Número Strobogramático II

Cadenas

Notas

Por favor lee los siguientes tips en la secuencia. Aplica para las cadenas también.

Pregunta sobre el conjunto de caracteres de entrada y la distinción entre mayúsculas y minúsculas. Por lo general, los caracteres se limitan a caracteres latinos en minúsculas, por ejemplo, de la a a la z.
Cuando necesites comparar cadenas donde el orden no es importante (como un anagrama), puedes considerar usar un HashMap como contador.

Si tu lenguaje de programación tiene una clase Counter como Python, pregunta si puedes usar esta clase mejor.

Si necesitas mantener un contador de caracteres, un error común es decir que la complejidad del espacio requerida para el contador es O(n). El espacio requerido para un contador es O(1) no O(n). Esto se debe a que el límite superior es el rango de caracteres, que suele ser una constante fija de 26. El conjunto de entrada son solo caracteres latinos en minúsculas.
Las estructuras de datos comunes para buscar cadenas de manera eficiente son

• Trie/Árbol de prefijo
• Árbol de sufijo

Algunos algoritmos comunes son:

• Rabin Karp, que realiza búsquedas eficientes de subcadenas, utilizando un hash rodante
• KMP, que realiza búsquedas eficientes de subcadenas

Caracteres que no se repiten

Usa una máscara de bits de 26 bits para indicar qué caracteres latinos en minúsculas están dentro de la cadena.

mask = 0
for c in set(word):
  mask |= (1 << (ord(c) - ord('a')))

Para determinar si dos cadenas tienen caracteres comunes, realiza & en las dos máscaras de bits. Si el resultado es distinto de cero, mask_a & mask_b > 0 , entonces las dos cadenas tienen caracteres comunes.

Anagrama

Un anagrama es cambio de palabra o juego de palabras. Es el resultado de reorganizar las letras de una palabra o frase para producir una nueva palabra o frase, usando todas las letras originales una sola vez. En las entrevistas, por lo general solo nos molestan las palabras sin espacios en ellas.
Para determinar si dos cadenas son anagramas, existen algunos enfoques plausibles:

• Ordenar ambas cadenas debería producir la misma cadena resultante. Esto toma el tiempo O (log n) y el espacio O (logn).
• Si asignamos cada carácter a un número primo y multiplicamos cada número asignado, los anagramas deben tener el mismo múltiplo (descomposición en factores primos). Esto toma O(n) tiempo y O(1) espacio.
• El conteo de frecuencia de caracteres ayudará a determinar si dos cadenas son anagramas. Esto también toma tiempo O(n) y espacio O(1).
  Palíndromo

Palíndromo

Un palíndromo es una palabra, frase, número u otra secuencia de caracteres que se lee igual hacia adelante y hacia atrás, como señora o coche de carreras.
Aquí hay formas de determinar si una cadena es un palíndromo:

• Invierte la cuerda y debería ser igual a sí misma.
• Tienes dos punteros al principio y al final de la cadena. Mueve los punteros hacia adentro hasta que se encuentren. En cualquier momento, los caracteres de ambos punteros deben coincidir.

El orden de los caracteres dentro de la cadena es importante, por lo que los HashMaps generalmente no son útiles.
Cuando una pregunta se trata de contar el número de palíndromos, un truco común es tener dos punteros que se muevan hacia afuera, alejándose del centro. Ten en cuenta que los palíndromos pueden tener una longitud par o impar. Para cada posición de pivote central, debes verificarla dos veces: una vez que incluye el personaje y otra sin el personaje.

• Para las subcadenas, puedes terminar antes de tiempo una vez que no haya ninguna coincidencia.
• Para las subsecuencias, use la programación dinámica ya que hay subproblemas superpuestos. Mira esta pregunta.

Casos comunes

• Cadena vacía
• Cadena de un solo carácter
• Cadenas con un solo carácter diferente

Preguntas de práctica

• Subcadena más larga sin caracteres repetidos
• Reemplazo de caracteres repetitivo más largo
• Subcadena de ventana mínima
• Cadenas Encode y Decode
• Anagrama válidoa
• Anagramas de grupo
• Parentesis válidos
• Palíndromo válido
• Cadena con Palíndromos más larga
• Subcadenas con palíndromos

Árboles

Links de estudio

• Lánzalo a árboles binarios

Notas

Un árbol es un grafo acíclico no dirigido y conexo.
La recursividad es un enfoque común para los árboles. Cuando notes que el problema del subárbol se puede usar para resolver el problema completo, intenta usar la recursividad.
Cuando utilices la recursividad, recuerda siempre verificar el caso base, generalmente donde está el nodo. null.

Cuando se te pida que atravieses un árbol por nivel, utiliza primero la búsqueda en profundidad.
A veces es posible que tu función recursiva necesite devolver dos valores.
Si la pregunta involucra la suma de nodos en el camino, asegúrate de verificar si los nodos pueden ser negativos.
Debes estar muy familiarizado con la escritura transversal recursiva en orden previo, en orden y posterior al pedido. Como extensión, desafíate a ti mismo escribiéndolos iterativamente.

A veces, los entrevistadores preguntan a los candidatos por el enfoque iterativo, especialmente si el candidato termina de escribir el enfoque recursivo demasiado rápido.

Árbol binario

El recorrido en orden de un árbol binario no es suficiente para serializar un árbol de forma única. También se requiere un recorrido previo o posterior al pedido.

Árbol de búsqueda binario (BST)

El recorrido en orden de un BST te dará todos los elementos en orden.
Estar muy familiarizado con las propiedades de un BST. Valida que un árbol binario sea un BST. Esto aparece con más frecuencia de lo esperado.
Cuando una pregunta implica un BST, el entrevistador suele buscar una solución que se ejecute más rápido que O(n).

Casos comunes

• Árbol vacío
• Un solo nodo
• Dos nodos
• Árbol muy inclinado (como una lista enlazada)

Preguntas de prácticas

• Profundidad máxima del árbol binario
• Mismo árbol
• Invertir o voltear árbol binario
• Suma máxima de ruta de acceso del árbol binario
• Recorrido de orden a nivel de árbol binario
• Serializar y deserializar árbol binario
• Subárbol de otro árbol
• Construir árbol binario a partir de preorden y recorrido en orden
• Validar árbol de búsqueda binario
• Elemento Kth más pequeño en un BST
• Ancestro común más bajo de BST

Tries

Links de estudio

• Intentando entender los Tries
• Implementando un Trie (Tree de prefijo)

Notas

Los Tries son un tipo específico de estructura de datos.  Como tal son árboles especiales (árboles de prefijos) que hacen que la búsqueda y el almacenamiento de cadenas sean más eficientes. Los intentos tienen muchas aplicaciones prácticas, como realizar búsquedas y proporcionar autocompletado. Es útil conocer estas aplicaciones comunes para que puedas identificar fácilmente cuándo un problema se puede resolver de manera eficiente utilizando un trie.
A veces, el procesamiento previo de un diccionario de palabras (dado en una lista) en un trie mejorará la eficiencia de la búsqueda de una palabra de longitud k, entre n palabras. La búsqueda se convierte en O(k) en lugar de O(n).

Estar familiarizado con la implementación, desde cero, de una clase Trie y sus métodosadd, remove , y search.

Preguntas de Práctica

• Implementando un Trie ( Tree de prefijo)
• Añadir y buscar palabras
• Buscador de palabras II

Montículo

Links de estudios

• Aprendiendo a amar los montículos

Notas

Si ves un k superior o inferior mencionado en la pregunta, generalmente es una señal de que se puede usar un montón para resolver el problema, como en Elementos frecuentes K principales.
Si necesitas los k elementos superiores, use un Min Heap de tamaño k. Iterar a través de cada elemento, empujándolo en el montón.

Siempre que el tamaño del almacenamiento dinámico exceda k, elimina el elemento mínimo. Eso garantizará que tengas los k elementos más grandes.

Preguntas de práctica

• Une K listas ordenadas
• Top de elementos K más frecuentes
• Encuetra la mediana a partir de un conjunto de datos

Conclusión

Las entrevistas de programación son difíciles. Pero afortunadamente, puedes mejorar tus resultados estudiando y practicando para ellas, así como haciendo entrevistas simuladas.
En resumen, para hacerlo bien en la codificación de entrevistas:

1. Elige un lenguaje de programación
2. Estudia los principios de las Ciencias de la Computación.
3. Practica resolviendo ejercicios de algoritmos.
4. Internaliza el qué hacer y el qué no en las entrevistas
5. Practica haciendo entrevistas simuladas
6. Ve a la entrevista a obtener el trabajo

Al seguir estos pasos, mejorarás tus habilidades de codificación de entrevistas y estarás un paso más cerca (o probablemente más) de conseguir el trabajo de sus sueños.

¡Mis mejores deseos!

Si te ha gustado este artículo, ¡compártelo con tus amigos!
También puedes seguirme en GitHub y Twitter.

Sí, el título es un clickbait. No hay forma de que puedas comprender los conceptos básicos de la tecnología git en solo 10 minutos. Pero puedes acercarte bastante en unos 25 minutos. Y ese es el propósito de este artículo.

Si deseas comenzar a aprender sobre la tecnología Git, has venido al lugar correcto. Esta es una guía completa para principiantes de Git. Hay muchos clientes para Git. La tecnología es la misma sin importar el cliente. Pero en esta guía usaremos GitHub para entender Git.

¡Empecemos!

¿Qué es el control de versiones?

El control de versiones es un sistema que registra los cambios en un archivo o conjunto de archivos a lo largo del tiempo para que pueda recuperar versiones específicas más adelante. Es decir que, idealmente; podemos colocar cualquier archivo en la computadora en el control de versiones.

En teoría esto está bien... ¿Pero por qué habríamos de hacer eso?

Este es el por qué:

Un Sistema de control de versiones (VCS en inglés) nos permite revertir los archivos a un estado anterior, revertir todo el proyecto a un estado anterior, revisar los cambios realizados a lo largo del tiempo, ver quién modificó por última vez algo que podría estar causando un problema, quién introdujo un problema y cuando, y más. El uso de un VCS también significa que si por descuido arruinamos las cosas o perdemos nuestros archivos, generalmente podemos recuperarlos fácilmente. Y a veces solo quieres saber “quién escribió esta porquería”. ¿y tener acceso a esa información vale la pena?.

Entonces, ¿qué es Git?

Git es un sistema de control de versiones para rastrear cambios en archivos de computadora y coordinar el trabajo en esos archivos entre varias personas. Git es un sistema de control de versiones distribuido. Git no depende necesariamente de un servidor central para almacenar todas las versiones de los archivos de un proyecto. En cambio, cada usuario “clona” una copia de un repositorio (una colección de archivos) y tiene el historial completo del proyecto en su propio disco duro. Este clon tiene todos los metadatos del original, mientras que el original en sí se almacena en un servidor autohospedado o en un servicio de alojamiento de terceros como GitHub.

Git te ayuda a realizar un seguimiento de los cambios que realizas en tu código. Es básicamente la pestaña de historial para tu editor de código (¿sin modo de incógnito?). Si en algún momento durante la codificación te encuentras con un error fatal y no sabes qué lo está causando, siempre puedes volver al estado estable. Por lo tanto, es muy útil para la depuración. O simplemente puede ver qué cambios realizó en su código a lo largo del tiempo.

En el ejemplo anterior, las tres "tarjetas" representan diferentes versiones del mismo archivo. Podemos seleccionar qué versión del archivo queremos usar en cualquier momento. Entonces puedo saltar de un lado a otro a cualquier versión del archivo en el continuo de tiempo de git.

Git también te ayuda a sincronizar código entre varias personas. Así que imagina que tú y tu amigo están colaborando en un proyecto. Ambos están trabajando en los mismos archivos de proyecto. Git toma esos cambios que tú y su amigo hicieron de forma independiente y los fusiona en un solo repositorio "maestro" (Master). Entonces, al usar Git, puedes asegurarse de que ambos estén trabajando en la versión más reciente del repositorio. Por lo tanto, no tienes que preocuparte por enviar tus archivos por correo y trabajar con una cantidad ridícula de copias del archivo original. ¿Y colaborar a larga distancia se vuelve tan fácil como HTML?.

Flujo de trabajo Git:

Antes de comenzar a trabajar con los comandos de Git, es necesario que comprendas lo que representa.

¿Qué es un Repositorio?

Un repositorio, también conocido como repositorio, no es más que una colección de código fuente.

Hay cuatro elementos fundamentales en el flujo de trabajo de Git.

1.Directorio de trabajo.

2.Área de ensayo.

3.Repositorio local.

4.Repositorio remoto.

Si consideras un archivo en su Directorio de trabajo, puedes estar en tres estados posibles.

1. Puede ser escenificado. Lo que significa que los archivos con los cambios actualizados están marcados para ser confirmados en el repositorio local pero aún no confirmados.
2. Se puede modificar. Lo que significa que los archivos con los cambios actualizados aún no están almacenados en el repositorio local.
3. Se puede consolidar (commit). Lo que significa que los cambios que realizó en su archivo se almacenan de forma segura en el repositorio local.

• git add es un comando que se usa para agregar un archivo que está en el directorio de trabajo al área de preparación.
• git commit es un comando que se usa para agregar todos los archivos que están almacenados en el repositorio local.
• git push es un comando que se usa para agregar todos los archivos comprometidos en el repositorio local al repositorio remoto. Entonces, en el repositorio remoto, todos los archivos y cambios serán visibles para cualquier persona con acceso al repositorio remoto.
• git fetch es un comando que se usa para obtener archivos del repositorio remoto al repositorio local, pero no al directorio de trabajo.
• git merge es un comando que se usa para obtener los archivos del repositorio local en el directorio de trabajo.
• git pull Este comando se usa para obtener archivos del repositorio remoto directamente en el directorio de trabajo. es equivalente a un git fetch y un git merge .

Ahora que sabemos qué es Git y sus terminologías básicas, veamos cómo podemos colocar un archivo en git. Lo haremos de la manera correcta y de la manera difícil. Sin ninguna aplicación GUI.

Supongo que ya tienes un archivo que deseas colocar bajo el control de versiones. Si no, cree una carpeta de muestra llamada 'MuskCult' y coloques algunos archivos de código de muestra en ella.

Paso 0: Crea una cuenta de GitHub

Si aún no tienes una cuenta, puedes crear una aquí.

Paso 1: Asegúrate de tener installado Git en tu equipo

Si estás en una Mac, enciende la terminal e ingresa el siguiente comando:

$ git --version

Esto te pedirá que abras un instalador si aún no tienes git. Así que configúralo usando el instalador. Si ya tienes git, solo te mostrará qué versión de git tienes instalada.

Si estás usando Linux(deb), escribe lo siguiente en la terminal:

$ sudo apt install git-all

Si estás en Windows:

winget install --id Git.Git -e --source winget

Paso 2: Dile a Git quien eres

Preséntate. En serio, menciona tu nombre de usuario y dirección de correo electrónico de Git, ya que en cada confirmación de Git se utilizará esta información para identificarte como el autor.

$ git config --global user.name "YOUR_USERNAME"

$ git config --global user.email "im_satoshi@musk.com"

$ git config --global --list # To check the info you just provided

Paso 3: Genera/comprueba tu equipo en busca de claves SSH existentes. (Opcional)

¿Porque preguntas? Con el protocolo SSH, puede conectarse y autenticarse en servidores y servicios remotos. Con las claves SSH, puede conectarse a GitHub sin proporcionar su nombre de usuario o contraseña en cada visita.

Sigue este link para aprender más acerca de SSH.
Visita aquí para verificar si tienes una clave SSH existente.
Ve aquí para generar una clave SSH.
Ve aquí para añadir la clave SSH a tu cuenta de GitHub.
Finalmente aquí puedes comprobar la conección.

Si configuraste SSH, cada comando de git que tiene un enlace lo reemplazará por:

Instead of : https://github.com/username/reponame

You use    : git@github.com:username/reponame.git

           Note : You can use both ways alternatively

Usaré el protocolo SSH en este tutorial.

Paso 4: Hagamos Git

Crear un nuevo repositorio en GitHub. Sigue este link.
Ahora, ubica la carpeta que deseas colocar debajo de git en su terminal.

$ cd Desktop/MuskCult

Inicia Git:

Y para colocar la carpeta debajo de git, ingresa:

$ touch README.md    # To create a README file for the repository
$ git init           # Initiates an empty git repository

Cómo editar el archivo README.md para proporcionar información acerca del repositorio.

Agrega archivos al área de preparación para la confirmación:

Ahora, para agregar los archivos al repositorio de git el commit:

$ git add .  
# Adds all the files in the local repository and stages them for commit

OR if you want to add a specific file

$ git add README.md 
# To add a specific file

Antes del commit, veamos qué archivos se preparan:

$ git status # Lists all new or modified files to be committed

Confirma los cambios que realizaste en tu Git Repo:
Ahora para confirmar los archivos que agregó a su repositorio de git:

$ git commit -m "First commit"
# The message in the " " is given so that the other users can read the message and see what changes you made

Anula la confirmación de los cambios que acaba de realizar en su Git Repo:

Ahora supongamos que que acabamos de cometer algún error en el código o colocamos un archivo no deseado dentro del repositorio. Este archivo no deseado puede desorganizar los archivos que acabamos de agregar, por lo tanto usamos:

$ git reset HEAD~1
# Remove the most recent commit
# Commit again!

Añadiendo un origen remoto y un Git Push:

Ahora cada vez que tú hagas cambios en los archivos y los guardes, no será automáticamente actualizado en GitHub. Todos los cambios que hicimos en el archivo se actualizan en el repositorio local. Ahora para actualizar los cambios en el repositorio maestro:

$ git remote add origin remote_repository_URL
# sets the new remote

El comando git remote nos permite crear, ver y eliminar conexiones a otros repositorios.

$ git remote -v
# List the remote connections you have to other repositories.

El comando git remote -v enumera las URL de las conexiones remotas que tiene con otros repositorios.

$ git push -u origin master # pushes changes to origin

Ahora, el comando git push traslada los cambios en su repositorio local hasta el repositorio remoto que especificó como origen.

Y ahora, si vamos y revisamos nuestra página de repositorio en GitHub, debería verse así:

Y eso es. Acabas de agregar los archivos al repositorio que acabas de crear en GitHub.

Observa los cambios que realizaste en tu archivo:

Una vez que empieces a hacer cambios en tus archivos y los guardes, el archivo no coincidirá con la última versión que se comprometió con git. Para ver los cambios que acabas de hacer:

Has hecho lo siguiente:

$ git diff # To show the files changes not yet staged

Vuelve a la última versión comprometida con Git Repo:

Ahora puedes optar por volver a la última versión confirmada ingresando:

$ git checkout .

OR for a specific file

$ git checkout -- <filename>

Ver historial de commits:

Puedes emplear el comando git log para observar el historial de commits que has hecho en tus archivos.

$ git log

Cada vez que realiza cambios que desea que se reflejen en GitHub, los siguientes son los flujos de comandos más comunes:

$ git add .
$ git status # Lists all new or modified files to be committed
$ git commit -m "Second commit"
$ git push -u origin master

Ahora, si vamos y vemos nuestro repositorio, podemos identificar si la confirmación fue exitosa mirando el mensaje de confirmación para cada archivo.

Paso 5 : Eso está muy bien... Pero, ¿cómo descargo y trabajo en otros repositorios en GitHub?

Clonando un Repo de Git:

Localiza el directorio en el que deseas clonar el repositorio. Copia el enlace del repositorio que deseas e ingresa lo siguiente:

$ git clone remote_repository_URL

Siéntete libre de seguir adelante y clonar el repositorio que creé arriba usando: https://github.com/Gothamv/MuskCult

Empujar cambios al Git Repo:

Ahora puedes trabajar en los archivos que deseas y comprometerte con los cambios localmente. Si deseas enviar cambios a ese repositorio, debes agregarte como colaborador para el repositorio o bien, debes crear algo conocido como solicitud de extracción. Observa cómo hacer uno aquí y envíame una solicitud de extracción con tu archivo de código.

Colaborando:

Así que imagina que tú y tu amigo están colaborando en un proyecto. Ambos están trabajando en los mismos archivos de proyecto. Cada vez que realizas algunos cambios y los inserta en el repositorio maestro, tu amigo tiene que extraer los cambios que insertaste en el repositorio de git.

Es decir, para asegurarse de que está trabajando en la última versión del repositorio de git cada vez que comienzas a trabajar, un comando de extracción de git es el camino a seguir.
Ahora a continuación hay un ejemplo de un proyecto en el que mi amigo y yo estamos colaborando:

Entonces, para asegurarme de que esos cambios se reflejen en mi copia local del repositorio:

$ git pull origin master

Aquí hay dos comandos git más útiles:

$ git fetch
    AND
$ git merge

En los términos más simples, git fetch seguido de un git merge equivale a un git pull. Pero entonces... ¿Porqué existe?

Cuando usas git pull, Git intenta hacer tu trabajo automáticamente. Es sensible al contexto, por lo que Git fusionará cualquier confirmación extraída en la rama en la que estás trabajando actualmente. git pull fusiona automáticamente las confirmaciones sin permitirle revisarlas primero.

Cuando aplicas git fetch, Git recopila todas las confirmaciones de la rama de destino que no existen en tu rama actual y las almacena en tu repositorio local. Sin embargo, no los fusiona con su rama actual. Esto es particularmente útil si necesita mantener su repositorio actualizado, pero está trabajando en algo que podría fallar si actualiza sus archivos. Para integrar las confirmaciones en su rama maestra, usa git merge.

Un detalle más:

.gitignore

¿Qué es esto?

.gitignore le dice a git qué archivos (o patrones) debe ignorar. Por lo general, se usa para evitar enviar archivos transitorios de su directorio de trabajo que no son útiles para otros colaboradores, como productos de compilación, archivos temporales creados por IDE, etc.

Entonces, en el ejemplo anterior, el sistema usa archivos como pycache, .DS_Store para almacenar información para un acceso más rápido. Esto no es útil para otros colaboradores. Entonces podemos decirle a git que los ignore agregando un archivo .gitignore .

Usa el comando touch para crear el archivo  .gitignore :

$ touch .gitignore

Y puede agregar los siguientes patrones para decirle a git que ignore dichos archivos.

/*.cmake
/*.DS_Store
/.user
/build
etc. depending upon the files you want git to untrack

Y eso es todo por lo básico. Estén atentos a la Parte 2, que se centrará en Branch, Merge, Stash, Rebase, etc.

¿Qué es el algoritmo de descenso de gradiente?

El descenso de gradiente es probablemente el algoritmo de aprendizaje automático más popular. En esencia, el algoritmo existe para minimizar los errores tanto como sea posible.

El objetivo del descenso de gradiente como algoritmo es minimizar la función de costo de un modelo. Podemos decir esto por los significados de las palabras 'Gradiente' y 'Descenso'.

Mientras que gradiente significa la brecha entre dos puntos definidos (esa es la función de costo en este contexto), el descenso se refiere al movimiento hacia abajo en general (es decir, minimizar la función de costo en este contexto).

Entonces, en el contexto del aprendizaje automático, Descenso de Gradiente (Gradient Descent en inglés) se refiere al intento iterativo de minimizar el error de predicción de un modelo de aprendizaje automático ajustando sus parámetros para producir el menor error posible.

Este error se conoce como la Función de Costo. La función de costo es un gráfico de la respuesta a la pregunta "¿En cuánto difiere el valor predicho del valor real?". Si bien la forma de evaluar las funciones de costo a menudo difiere para diferentes modelos de aprendizaje automático, en un modelo de regresión lineal simple, generalmente se refiere al error cuadrático medio del modelo.

Es importante tener en cuenta que para los modelos más simples como la regresión lineal, un gráfico de la función de costo suele tener forma de arco, lo que facilita determinar el punto mínimo.

Sin embargo, este no es siempre el caso. Para modelos más complejos (por ejemplo, redes neuronales), es posible que el gráfico no tenga forma de arco. Es posible que la función de costo tenga múltiples puntos mínimos como se muestra en la imagen a continuación.

¿Cómo funciona el descenso de gradiente?

En primer lugar, es importante tener en cuenta que, como la mayoría de los procesos de aprendizaje automático, el algoritmo de descenso de gradiente es un proceso iterativo.

Suponiendo que tiene la función de costo para un modelo de regresión lineal simple como j(w,b) donde j es una función de w y b, el algoritmo de descenso de gradiente funciona de tal manera que comienza con una conjetura aleatoria inicial para w y b. El algoritmo seguirá modificando los parámetros w y b en un intento de optimizar la función de costo, j.

En la regresión lineal, la elección de los valores iniciales no importa mucho. Una opción común es cero.

La analogía perfecta para el algoritmo de descenso de gradiente que minimiza la función de costo j(w, b) y alcanza su mínimo local ajustando los parámetros w y b es caminar hasta el pie de una montaña o colina (como se muestra en la gráfica 3D de la función de costo de un modelo de regresión lineal simple mostrado anteriormente).

O bien, podemos imaginar que estamos tratando de llegar al punto más bajo de un campo de golf. En cualquier caso, darán pasos cortos, repetitivos hasta llegar al pie de la montaña o colina.

La fórmula de descenso de gradiente

Aquí está la fórmula para el descenso de gradiente: b = a - γ Δ f(a)

La ecuación anterior describe el accionar del algoritmo de descenso de gradiente.

Es decir, b es la siguiente posición del excursionista, mientras que representa la posición actual. El signo menos es para la parte de minimización del algoritmo de descenso de gradiente, ya que el objetivo es minimizar el error tanto como sea posible. γ en el medio es un factor conocido como tasa de aprendizaje, y el término Δf(a) es un término de gradiente que define la dirección del punto mínimo.

Como tal, esta fórmula indica la siguiente posición para el excursionista/la persona en el campo de golf (esa es la dirección del descenso más empinado).

Es importante notar que el término γΔ f(a) se resta de a porque el objetivo es moverse contra el gradiente, hacia el mínimo local.

¿Qué es la tasa de aprendizaje?

La tasa de aprendizaje es el determinante de cuán grandes son los pasos que toma el descenso del gradiente en la dirección del mínimo local. Determina la velocidad con la que el algoritmo se mueve hacia los valores óptimos de la función de coste.

Debido a esto, la elección de la tasa de aprendizaje, γ, es importante y tiene un impacto significativo en la efectividad del algoritmo.

Si la tasa de aprendizaje es demasiado grande como se muestra arriba, en un intento por encontrar el punto óptimo, se mueve desde el punto de la izquierda hasta el punto de la derecha (como la tasa de aprendizaje es muy grande, los "saltos" también lo son, por lo que es muy difícil que el algoritmo acierte en el punto óptimo).En ese caso, vemos que la función de costo ha empeorado.

Por otro lado, si la tasa de aprendizaje es demasiado pequeña, los descensos de gradiente funcionarán, aunque muy lentamente. Es decir, como los pasos son muy pequeños, es muy probable que el algoritmo acierte, aunque la optimización irá muy despacio.

Es por ello, importante elegir cuidadosamente la tasa de aprendizaje.

Cómo implementar el descenso de gradiente en la regresión lineal

import numpy as np
import matplotlib.pyplot as plt

class Linear_Regression:
	def __init__(self, X, Y):
		self.X = X
		self.Y = Y
		self.b = [0, 0]
	
	def update_coeffs(self, learning_rate):
		Y_pred = self.predict()
		Y = self.Y
		m = len(Y)
		self.b[0] = self.b[0] - (learning_rate * ((1/m) * np.sum(Y_pred - Y)))
		self.b[1] = self.b[1] - (learning_rate * ((1/m) * np.sum((Y_pred - Y) * self.X)))
        
	def predict(self, X=[]):
		Y_pred = np.array([])
		if not X: X = self.X
		b = self.b
		for x in X:
			Y_pred = np.append(Y_pred, b[0] + (b[1] * x))

		return Y_pred
	
	def get_current_accuracy(self, Y_pred):
		p, e = Y_pred, self.Y
		n = len(Y_pred)
		return 1-sum(
			[
				abs(p[i]-e[i])/e[i]
				for i in range(n)
				if e[i] != 0]
		)/n
	#def predict(self, b, yi):

	def compute_cost(self, Y_pred):
		m = len(self.Y)
		J = (1 / 2*m) * (np.sum(Y_pred - self.Y)**2)
		return J

	def plot_best_fit(self, Y_pred, fig):
				f = plt.figure(fig)
				plt.scatter(self.X, self.Y, color='b')
				plt.plot(self.X, Y_pred, color='g')
				f.show()


def main():
	X = np.array([i for i in range(11)])
	Y = np.array([2*i for i in range(11)])

	regressor = Linear_Regression(X, Y)

	iterations = 0
	steps = 100
	learning_rate = 0.01
	costs = []
	
	#original best-fit line
	Y_pred = regressor.predict()
	regressor.plot_best_fit(Y_pred, 'Initial Best Fit Line')
	

	while 1:
		Y_pred = regressor.predict()
		cost = regressor.compute_cost(Y_pred)
		costs.append(cost)
		regressor.update_coeffs(learning_rate)
		
		iterations += 1
		if iterations % steps == 0:
			print(iterations, "epochs elapsed")
			print("Current accuracy is :",
				regressor.get_current_accuracy(Y_pred))

			stop = input("Do you want to stop (y/*)??")
			if stop == "y":
				break

	#final best-fit line
	regressor.plot_best_fit(Y_pred, 'Final Best Fit Line')

	#plot to verify cost function decreases
	h = plt.figure('Verification')
	plt.plot(range(iterations), costs, color='b')
	h.show()

	# if user wants to predict using the regressor:
	regressor.predict([i for i in range(10)])

if __name__ == '__main__':
	main()

En esencia, puedes ver que el bloque de código entrena un algoritmo de descenso de gradiente para un modelo de aprendizaje automático de regresión lineal usando 0.01  como tasa de aprendizaje, basándose en 100 pasos.

Al ejecutar el código, tenemos lo siguiente:

Conclusión

En conclusión, es importante tener en cuenta que el algoritmo de descenso de gradiente es especialmente importante en los dominios de inteligencia artificial y aprendizaje automático, ya que los modelos deben optimizarse para la precisión.
En este artículo, aprendimos qué es el algoritmo de descenso de gradiente, cómo funciona, su fórmula, qué tasa de aprendizaje es y la importancia de elegir la tasa de aprendizaje correcta. También vimos una ilustración de código de cómo funciona Gradient Descent.
Finalmente, compartí mis escritos sobre inteligencia artificial, aprendizaje automático y Microsoft Azure en Twitter si disfrutaste este artículo y quieres ver más.

Puedes devolver múltiples valores de una función en Python.

Para hacerlo, devuelves una estructura de datos que contenga varios valores, como una lista con la cantidad de millas para correr cada semana.

def total_millas(minimo_millas):
    semana_1=minimo_millas+2
    semana_2=minimo_millas+4
    semana_3=minimo_millas+6
    return [semana_1,semana_2,semana_3]
print(total_millas(2))
#resultado: [4,6,8]

Las estructuras de datos en Python se utilizan para almacenar colecciones de datos, que pueden devolverse desde funciones. En este artículo, exploraremos cómo devolver múltiples valores de estas estructuras de datos: tuplas, listas y diccionarios.

Tuplas

Una tupla es una secuencia ordenada e inmutable. Eso significa que una tupla no puede cambiar.
Utilizamos una tupla, por ejemplo, para almacenar información sobre una persona: su nombre, edad y ubicación.

nancy = ("nancy", 55, "chicago")

Así es como yo escribiría una función que devuelve una tupla.

def persona():
   return "bob", 32, "boston"
 
print(persona())
# resultado: ('bob', 32, 'boston')

Ten en cuenta que no usamos paréntesis en la declaración de devolución. Esto se debe a que es posible devolver una tupla separando cada elemento con una coma, como se muestra en el ejemplo anterior.

“En realidad, es la coma la que forma una tupla, no los paréntesis”. Tal y como indica la documentación. Sin embargo, los paréntesis son requeridos con tuplas vacías o para evitar confusiones.

Aquí hay un ejemplo que emplea el paréntesis () para retornar una tupla.

def persona(nombre, edad):
   return (nombre, edad)
print(persona("henry", 5))
#resultado: ('henry', 5)

Listas

Una lista es una secuencia ordenada y mutable. Eso significa que una lista puede cambiar.
Puede utilizar una lista para almacenar ciudades:

ciudades = ["Boston", "Chicago", "Jacksonville"]

O resultados de exámenes:

puntuaciones_examenes = [55, 99, 100, 68, 85, 78]

Observa la función de abajo. Simplemente, nos regresa una línea que contiene 10 números

def diez_numeros():
   numeros = []
   for i in range(1, 11):
       numeros.append(i)
   return numeros
 
print(diez_numeros())
#resultado: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Aquí hay otro ejemplo. Esta vez pasamos varios argumentos cuando llamamos a la función.

def millas_recorridas(semana_1, semana_2, semana_3, semana_4):
   return [semana_1, semana_2, semana_3, semana_4]
 
recorrido_mensual = millas_recorridas(25, 30, 28, 40)
print(recorrido_mensual)
#resultado: [25, 30, 28, 40]

Es fácil confundir tuplas y listas. Al fin y al cabo, ambos son contenedores que almacenan objetos. No obstante, recuerda estas diferencias clave:
1.Las tuplas no pueden cambiar.
2.Las listas pueden cambiar.

Diccionarios

Un diccionario contiene pares clave-valor entre corchetes {}. Cada "clave" tiene un "valor" relacionado.
Consideremos el diccionario de empleados a continuación. Cada nombre de empleado es una "clave" y su posición es el "valor".

empleados = {
   "Muan": "ingeniero",
   "Maria": "gerente",
   "Henry": "escritor",
}

Así es como escribiríamos una función que devuelve un diccionario con un par clave-valor.

def ciudad_pais(ciudad,pais):
    lugar= {}
    lugar[ciudad]= pais
    return lugar
lugar_favorito= ciudad_pais("Santiago","Chile")
print(lugar_favorito)
#resultado: {"Santiago":"Chile"}

En el ejemplo anterior, "Santiago" es la clave y "Chile" es el valor.
Hemos cubierto mucho terreno. El punto clave es este: puede devolver múltiples valores desde una función de Python, y hay varias formas de hacerlo.

Escribo sobre las habilidades de programación que necesita desarrollar y los conceptos que necesitas aprender, y las mejores formas de aprenderlos en amymhaddad.com.

Antes de empezar, hablemos de qué es el problema de la Torre de Hanoi. Bueno, este es un divertido juego de rompecabezas en el que el objetivo es mover una pila completa de discos desde la posición de origen a otra posición. Se siguen tres reglas simples:

1.Solo se puede mover un disco a la vez.
2.Cada movimiento consiste en tomar el disco superior de una de las pilas y colocarlo encima de otra pila. En otras palabras, un disco solo se puede mover si es el disco superior de una pila.
3.No se puede colocar un disco más grande encima de un disco más pequeño.

Ahora, intentemos imaginar un escenario. Supongamos que tenemos una pila de tres discos. Nuestro trabajo es mover esta pila del origen A al destino C. ¿Cómo hacemos esto?

Antes de que podamos llegar allí, imaginemos que hay un punto intermedio B.

Podemos usar a B como ayudante para terminar este trabajo. Ahora estamos listos para seguir adelante. Veamos cada uno de los pasos:

Mueve el primer disco de A a C
Mover el primer disco de A a B
Mueva el primer disco de C a B
Mueve el primer disco de A a C
Mueva el primer disco de B a A
Mueva el primer disco de B a C
Mueve el primer disco de A a C
¡Excelente! Hemos resuelto nuestro problema.

Puedes ver la imagen animada de arriba para una mejor comprensión.

Ahora, intentemos construir el algoritmo para resolver el problema. Espera, tenemos una nueva palabra aquí: "Algoritmo". ¿Qué es eso? ¿Alguna idea? No hay problema, vamos a ver.

¿Qué es un algoritmo?

Un algoritmo es uno de los conceptos más importantes para un desarrollador de software. De hecho, creo que no solo es importante para el desarrollo o la programación de software, sino para todos. Los algoritmos nos afectan en nuestra vida cotidiana. Veamos cómo.

Supongamos que trabaja en una oficina. Así que cada mañana haces una serie de tareas en secuencia: primero te levantas, luego vas al baño, desayunas, te preparas para la oficina, sales de casa, luego puedes tomar un taxi o un autobús o empezar a caminar hacia la oficina y, después de un tiempo determinado, llega a su oficina. Puedes decir que todos esos pasos forman un algoritmo.

En términos simples, un algoritmo es un conjunto de tareas. Espero que no hayas olvidado los pasos que hicimos para mover tres pilas de discos de A a C. También puedes decir que esos pasos son el algoritmo para resolver el problema de la Torre de Hanoi.

En Matemáticas y Ciencias de la Computación; un algoritmo es una especificación inequívoca de cómo resolver una clase de problemas. Los algoritmos pueden realizar tareas de cálculo, procesamiento de datos y razonamiento automatizado. —

Si observas esos pasos, puedes ver que estábamos haciendo la misma tarea varias veces: mover discos de una pila a otra. Podemos denominar a estos pasos como recursión.

Recursión

Recursion es estar llamando a la misma acción desde esa acción. Al igual que en la imagen de arriba.

Entonces, hay una regla para hacer cualquier trabajo recursivo: debe haber una condición para detener la ejecución de esa acción. Espero que entiendas los conceptos básicos sobre la recursividad.

Ahora, intentemos construir un procedimiento que nos ayude a resolver el problema de la Torre de Hanoi. Estamos tratando de construir la solución usando pseudocódigo. El pseudocódigo es un método para escribir código de computadora utilizando el idioma inglés.

torre(disco, origen, intermedio, destinacion)
{

}

Este es el esqueleto de nuestra solución. Tomamos el número total de discos como argumento. Luego, debemos pasar el origen, el lugar intermedio y el destino para que podamos entender el mapa que usaremos para completar el trabajo.

Ahora necesitamos encontrar un estado terminal. El estado terminal es el estado en el que ya no vamos a llamar a esta función.

IF disco is igual 1

En nuestro caso, este sería nuestro estado terminal. Porque cuando haya un disco en nuestra pila, entonces es fácil hacer ese paso final y luego nuestra tarea estará completa. No te preocupes si no te queda claro. Cuando lleguemos al final, este concepto será más claro.

Muy bien, hemos encontrado nuestro punto de estado terminal donde movemos nuestro disco al destino de esta manera:

mover disco desde el origen a nuestra destinación

Ahora volvemos a llamar a nuestra función pasando estos argumentos. En ese caso, dividimos la pila de discos en dos partes. El disco más grande (disco n) está en una parte y todos los demás discos (n-1) están en la segunda parte. Allí llamamos al método dos veces para -(n-1).

torre(disco - 1, origen, destinacion, intermedio)

Ahora pasaremos a un ejemplo de pseudocódigo más realista. Usaremos total_discos_on_stack — 1 como un argumento. Después de ello, procedemos a mover nuestro disco nuevamente de esta forma:

mover disco desde el origen a la destinación

Después de eso, volvemos a llamar a nuestro método así:

torre(disco - 1, intermedio, origen, destinacion)

Veamos el pseudocódigo:

torre(disco, origen, inter, dest)

IF disco is equal 1, THEN
       mover disco desde el origen a la destinación
   ELSE
       torre(disco- 1, origen, destinacion, intermedio)   // Step 1
       mover disco desde el origen a la destinación       // Step 2
       torre(disco - 1, intermedio, origen, destinacion)  // Step 3
   END IF
   
END

Este es el árbol para tres discos:

Este es el código completo en Ruby:

def tower(disk_numbers, source, auxilary, destination)
  if disk_numbers == 1
    puts "#{source} -> #{destination}"
    return
  end
  tower(disk_numbers - 1, source, destination, auxilary)
  puts "#{source} -> #{destination}"
  tower(disk_numbers - 1, auxilary, source, destination)
  nil
end

Empleamos tower(3, 'source','aux','dest')

Resultado:

source -> dest
source -> aux
dest -> aux
source -> dest
aux -> source
aux -> dest
source -> dest

Se necesitaron siete pasos para que tres discos llegaran al destino. A esto lo llamamos un método recursivo.

Cálculos en la complejidad del tiempo y el espacio

Complejidad Temporal

Cuando ejecutamos código o una aplicación en nuestra máquina, lleva tiempo: ciclos de CPU. Pero no es lo mismo para todas las computadoras. Por ejemplo, el tiempo de procesamiento de un core i7 y de un dual core no es el mismo. Para resolver este problema existe un concepto utilizado en informática llamado complejidad temporal.

La complejidad del tiempo es un concepto en informática que se ocupa de la cuantificación de la cantidad de tiempo que tarda un conjunto de código o algoritmo en procesarse o ejecutarse en función de la cantidad de entrada.

En otras palabras, la complejidad del tiempo es esencialmente eficiencia, o cuánto tarda una función de programa en procesar una entrada determinada.

La complejidad temporal de los algoritmos se expresa más comúnmente utilizando la Cota superior asintótica. Una notación asintótica para representar la complejidad del tiempo.

Ahora, el tiempo requerido para mover n discos es T(n). Hay dos llamadas recursivas para (n-1). Hay una operación de tiempo constante para mover un disco desde el origen hasta el destino, sea m1. Por lo tanto:

T(n) = 2T(n-1) + m1    ..... eq(1)

Y también:

T(0) = m2, a constant   ...... eq(2)
From eq (1)
T(1) = 2T(1-1) + m1
     = 2T(0)+m1
     = 2m2 + m1 ..... eq(3) [From eq 2]
T(2) = 2T(2-1) + m1
     = 2T(1) + m1
     = 4m2 + 2m1 + m1 .... eq(4) [From eq(3)]
T(3) = 2T(3-1) + m1
     = 2T(2) + m1
     = 8m2 + 4m1 + 2m1 + m1  [From eq(4)]

A partir de estos patrones, eq(2) hasta el último, podemos decir que la complejidad temporal de este algoritmo es O(2^n) u O(a^n) donde a es una constante mayor que 1. Por lo tanto, tiene una exponencial complejidad del tiempo. Para el aumento único del tamaño del problema, el tiempo requerido es el doble del anterior. Esto es computacionalmente muy costoso. La mayoría de los programas recursivos toman un tiempo exponencial, y por eso es muy difícil escribirlos iterativamente.

Complejidad Espacial

Después de la explicación del análisis de la complejidad del tiempo, creo que ahora puedes adivinar qué es esto... Este es el cálculo del espacio requerido en RAM para ejecutar un código o una aplicación.

En nuestro caso, el espacio para el parámetro de cada llamada es independiente de n, lo que significa que es constante. Que sea J. Cuando hacemos la segunda llamada recursiva, la primera ha terminado. Eso significa que podemos reutilizar el espacio después de terminar el primero. Por eso:

Por tanto:

T(n) = T(n-1) + k .... eq(1)
T(0) = k, [constant] .... eq(2)
T(1) = T(1-1) + k
     = T(0) + k
     = 2K
T(2) = 3k
T(3) = 4k

Entonces la complejidad del espacio es O(n).

Después de estos análisis, podemos ver que la complejidad temporal de este algoritmo es exponencial, pero la complejidad espacial es lineal.

Conclusión
A partir de este artículo, espero que ahora puedas entender el rompecabezas de la Torre de Hanoi y cómo resolverlo. Además, traté de brindarle una comprensión básica sobre los algoritmos, su importancia, recursividad, pseudocódigo, complejidad temporal y complejidad espacial.

Si recién empiezas en la industria de la tecnología, es posible que hayas oído hablar del término Full Stack. Pero, ¿qué significa eso exactamente?

En este artículo, explicaré qué es Full Stack Development, qué habilidades necesitas para convertirte en Full Stack Developer, así como el tema de las expectativas salariales, sumado a unos consejos para conseguir el trabajo.

¿Qué es el Desarrollo Full Stack?

Un desarrollador Full Stack es alguien que trabaja tanto con el front-end como con el back-end de una aplicación web. El front-end es responsable de la apariencia visual del sitio web, mientras que el back-end es responsable de la lógica y la infraestructura detrás de escena del sitio.

Echemos un vistazo más de cerca a los términos front-end y back-end.

Desarrollo Frontend (Punto de vista del cliente)

Todo en una página web, desde el logotipo hasta la barra de búsqueda, los botones, el diseño general y la forma en que el usuario interactúa con la página, fue creado por un desarrollador front-end. Los desarrolladores front-end están a cargo de la apariencia del sitio web.

Los desarrolladores front-end también deben asegurarse de que el sitio web se vea bien en todos los dispositivos (teléfonos, tabletas y pantallas de computadora). Esto se llama Diseño Web Adaptable.

Desarrollo back-end (Punto de vista del servidor)

El desarrollo de back-end se refiere a la parte de la aplicación que el usuario no ve. Los desarrolladores de back-end se centran en la lógica del sitio, creando servidores y trabajando con bases de datos y API (interfaces de programación de aplicaciones).

Por ejemplo, el contenido y el diseño de un formulario se crearían en el lado del cliente. Pero cuando los usuarios envían su información, esta se procesa en el lado del servidor (back-end).

Ejemplo de una aplicación Full Stack del mundo real

Para comprender mejor el aspecto de una aplicación de pila completa, examinemos el sitio web de freeCodeCamp.

Todo lo que ves en la página se consideraría front-end. Todos los botones, texto, colores y diseño son trabajo del desarrollador front-end.

Cuando se trata de cosas como las credenciales de usuario, todo eso lo mantiene el back-end. Todos los procesos de inicio de sesión y la información del usuario son ejemplos de desarrollo de back-end en el trabajo.

Si tienes curiosidad y quieres echar un vistazo al código, puedes encontrarlo en la página de código abierto de freeCodeCamp.

Habilidades que necesitas en el desarrollo Full Stack

Echemos un vistazo a las tecnologías y herramientas que necesitará aprender para convertirse en un desarrollador de pila completa.

HTML
HTML significa lenguaje de marcado de hipertexto. HTML muestra el contenido de la página como botones, enlaces, encabezados, párrafos y listas.

Para aprender los conceptos básicos de HTML, freeCodeCamp tienes un curso acelerado de HTML para principiantes: Tutorial del sitio web.

CSS
CSS significa hojas de estilo en cascada. CSS es responsable del estilo de su página web, incluidos los colores, los diseños y las animaciones.

El curso de diseño web adaptativo de freeCodeCamp te enseñará los conceptos básicos de CSS, diseño adaptativo y accesibilidad. El diseño adaptativo es esencial para crear sitios web que se vean bien en todos los dispositivos.

La accesibilidad es la práctica de asegurarse de que todos puedan usar fácilmente sus sitios web. No deseamos crear sitios web que no puedan utilizar aquellos que utilizan tecnologías de asistencia como lectores de pantalla.

JavaScript
Utiliza JavaScript con HTML y CSS para crear páginas web y aplicaciones móviles dinámicas e interactivas. Los ejemplos de JavaScript incluyen animaciones, relojes de cuenta regresiva, menús móviles desplegables y mostrar/ocultar información cuando un usuario hace clic en un elemento de la página.

Para comenzar a aprender JavaScript, puedes tomar el curso de estructuras de datos y algoritmos de JavaScript de FreeCodeCamp. A partir de ahí, puedes comenzar a crear proyectos desde mi artículo 40 proyectos de JavaScript para principiantes. También están disponibles otros cursos.

Frameworks, bibliotecas y preprocesadores de CSS

Estas herramientas se crearon para ayudar a acelerar el proceso de desarrollo. En lugar de escribir todo el CSS personalizado, puedex usar el catálogo de un marco de clases de CSS en sus páginas web.

No hay necesidad de aprenderlos todos, pero aquí hay una lista de algunas opciones:

• Tailwind CSS
• Bootstrap
• Bulma
• Materialize
• Semantic UI

Los preprocesadores de CSS como Sass y Less le permiten agregar lógica y funcionalidad a su CSS. Estas herramientas hacen que tu CSS sea limpio y fácil de usar.

Bibliotecas y marcos de JavaScript

Estos marcos y bibliotecas te permiten ahorrar tiempo y hacer más con menos código.

Aquí hay algunas opciones populares:

• React
• Angular
• Vue

No es necesario aprenderlos todos. Simplemente debes investigar qué tecnología se usa en su área y comenzar a aprenderla bien.

Aquí hay algunos recursos de aprendizaje sugeridos.

• Curso de React en Youtube de freeCodeCamp
• Curso de Angular de Brad Traversy en YouTube
• Curso de Vue de Brad Traversy en YouTube

Bases de Datos

Es importante que un desarrollador Full Stack sepa cómo trabajar con bases de datos. Una base de datos en una aplicación web es un lugar para almacenar y organizar los datos de tu proyecto.

Hay muchos tipos de bases de datos para aprender, pero aquí hay algunas opciones populares.

• SQL
• MySQL
• PostgreSQL
• MongoDB

Lenguajes de Programación para Back- end
Los lenguajes que puedes emplear para el desarrollo de back-end incluyen Java, Python, Node y PHP. No es necesario aprender todos estos lenguajes, sino concentrarse en uno para comenzar.

Aquí hay algunos recursos de aprendizaje sugeridos.

• Curso de Python para principiantes de freeCodeCamp
• Curso de PHP de freeCodeCamp PHP
• Curso de programación en Java de Mosh's Java

También hay muchas tecnologías para el desarrollo de front-end y back-end. Aquí hay algunos populares.

• MEAN stack (MongoDB, Express, Angular and Node)
• MERN stack (MongoDB, Express, React and Node)
• NodeJS
• LAMP stack (Linux, Apache, MySQL, and PHP)

En realidad hay más lenguajes de back-end para elegir, pero te sugiero que investigues los idiomas más utilizados en tu área.

Habilidades de prueba y depuración

A medida que desarrollas tu aplicación, habrá errores en el código que deben corregirse. La depuración es el acto de identificar esos errores ("bugs") y corregirlos.

La prueba (mejor conocida como Testing) es otra habilidad importante para aprender. Escribir pruebas para tu código es una forma de asegurarte el mismo está haciendo lo que se supone que debe hacer.

Para una explicación más detallada sobre los diferentes tipos de pruebas, sugiero leer este artículo.

Control de versiones

El control de versiones es una forma de rastrear y administrar los cambios en el código del proyecto. Git es un software popular que puede usar para rastrear su código.

Si estropeas muchas cosas en tu código, puedes usar Git para volver a una versión anterior de este en lugar de volver a escribir todo manualmente.

Aprender Git también te permite colaborar con otros en un equipo y realizar cambios en la misma base de código desde diferentes ubicaciones.

Sugeriría comenzar a aprender Git y usar un servicio como GitHub para alojar tus proyectos personales.

Resolución de problemas

La habilidad más importante para cualquier desarrollador es saber cómo resolver problemas. Empresas y clientes te buscan para aportar soluciones.

Es importante aprender a abordar un problema, dividirlo en partes más pequeñas y manejables y solucionar el problema en estas aplicaciones web.

¿Debo perseguir como objetivo el desarrollo full stack?

Si recién estás comenzando y no puedes determinar si el desarrollo Full Stack es para tí, simplemente no se preocupes por eso tan temprano en tu aprendizaje.

Sugeriría centrarse en aprender los tres lenguajes principales de la web, que son HTML, CSS y JavaScript. A medida que avanza en su viaje, entonces puedes decidir qué camino es apropiado para tí.

¿Cuánto gana un desarrollador Full Stack?
El rango de salario para los trabajos de Full Stack completa diferirá según el lugar del mundo en el que te encuentres. Sugeriría usar sitios como Glassdoor, Indeed y ZipRecruiter para buscar salarios en su área.

Aquí hay ejemplos de salarios para los Estados Unidos. Estos datos fueron proporcionados por ZipRecruiter y muestran el promedio nacional.

Veamos primero el salario de un desarrollador junior Full Stack. Los desarrolladores junior son aquellos que han estado trabajando en la industria durante dos años o menos.

A continuación, echemos un vistazo a los salarios de full stack de nivel medio. Estos desarrolladores han estado trabajando entre 2-4 años aproximadamente.

Por último, echemos un vistazo a los salarios senior full stack. Estos desarrolladores han estado trabajando en la industria durante algunos años y, a menudo, sirven como mentores para desarrolladores de nivel junior y medio.

¿Cómo puedes obtener un trabajo como Desarrollador Full Stack?

Una vez que hayas aprendido los aspectos técnicos del desarrollo Full Stack; debes concentrarte en reunir los materiales de tu solicitud de empleo.

Hay muchos recursos increíbles que pueden ayudarlo a aprender cómo obtener un trabajo en el área.

Recursos para la elaboración de currículos

• Cómo obtener tu primer trabajo de desarrollador: Perspectivas de la revisión de los currículos de quienes cambian de carrera
• Cómo escribir un currículum de desarrollador que leerán los reclutadores
• Cómo escribir un impresionante currículum de desarrollador junior en unos simples pasos

Recursos para entrevistas técnicas

• Cómo prepararse para una entrevista técnica
• Cómo responder cualquier pregunta técnica de la entrevista: ejemplo incluido
• Lo que aprendí al hacer más de 60 entrevistas técnicas en 30 días
• El mejor libro para la preparación de la entrevista de codificación técnica
• Cómo prepararse para una entrevista técnica: consejos y trucos para ayudarlo a rendir al máximo

Consejos para conseguir un trabajo

• Cómo obtener su primer trabajo de desarrollador a través de networking genuino e inteligente
• Consejos para la búsqueda de empleo en 2021
• Cómo dominar su búsqueda de empleo
• ¡CÓMO USAR LINKEDIN COMO DESARROLLADOR para conseguir un trabajo en tecnología! ¡Cómo hacer networking!

También incluiré recursos sobre cómo comenzar a trabajar independientemente si está interesado en seguir esa ruta.

• ¿Qué es Freelance? Cómo encontrar trabajos independientes en línea y clientes en tu ciudad
• Cómo escribir propuestas independientes que atraigan a los clientes + una plantilla gratuita
• La guía completa para desarrolladores web independientes: Cómo ganar dinero a través de trabajos de programación independientes

Espero que hayas disfrutado este artículo. Te deseo mucha suerte en tu camino para convertirte en un desarrollador Full Stack.

NumPy proporciona una infraestructura para trabajar con arreglos numéricos y matrices, mientras que SciPy proporciona una amplia gama de algoritmos numéricos, cálculos matemáticos avanzados y herramientas para aplicaciones científicas.

Una de las principales razones por las que estas bibliotecas son tan populares en el ámbito científico es porque son muy eficientes en el manejo de grandes conjuntos de datos numéricos y matrices.

Además, SciPy y NumPy tienen una gran cantidad de funciones integradas para realizar operaciones numéricas complejas, como la transformada de Fourier, la optimización numérica, el álgebra lineal, la estadística y el procesamiento de señales.

Estas funciones son esenciales en muchas aplicaciones científicas, desde el procesamiento de imágenes hasta el análisis de datos biomédicos. Sin embargo, esto no excluye que podamos emplearlas para resolver problemas más burdos.

Otro aspecto importante es que ambas bibliotecas son de código abierto y tienen una gran comunidad de desarrolladores, lo que permite que los usuarios obtengan soporte y contribuyan a la mejora de las bibliotecas.

Motivo y enfoque de este artículo

Este artículo busca proporcionar una visión general aunque no por ello ligera, sobre algunas de las aplicaciones matemáticas y estadísticas que pueden tener NumPy y SciPy.

Si bien, ya existe información acerca de estas librerías, -especialmente sobre NumPy-. El enfoque de este contenido será dar un pantallazo amplio pero detallado a las principales aplicaciones científicas de estas librerías. No tanto así a un "procedimiento" en específico. Si por otra parte requieres de un tutorial más concreto te recomiendo esta guía y este curso de arreglos en NumPy.

Habiendo aclarado esto, en este artículo se presentan varias aplicaciones científicas y prácticas de SciPy y NumPy. Ya sea que te interesen los aspectos más teóricos de la ciencia de datos, tengas una profesión científica o de ingeniería, seas estudiante de carreras cuantitativas, o simplemente busques crecer en el desarrollo de aplicaciones especializadas; este tutorial podría serte útil.

Tres notas o más bien "disclaimers" antes de empezar:

1. Este artículo se centra en el desarrollo de varios problemas matemáticos y científicos y pese a que traté de organizarlos en un orden más o menos coherente algún ejercicio puede resultar chocante, o difícil de entender a nivel teórico. Mi consejo es el siguiente: Toma lo que te sirva, no te preocupes por tratar de entenderlo todo, aunque, desde luego, tampoco hay quejas si lo entiendes el 100% :D.
2. Debido a que son ejercicios separados verás repetidamente "import matplotlib.pyplot as plt" o import numpy as np. Sé que es redundante, pero la idea que es todos los ejercicios estén listos "para tomar" y tratar de replicarlos sin preocuparte por el orden.
3. Siento no poder incluir ejemplos de otros campos -eg. como la física o la epidemiología-, pero carezco de la formación para ello.

Bien, ahora sin más preámbulos pasemos a los ejercicios.

Estadística y probabilidad con SciPy y NumPy

Método de Montecarlo

El código presentado es una implementación de un método de simulación para estimar el valor de π (pi). La idea detrás del método es simular el lanzamiento de dardos aleatorios sobre un cuadrado con un círculo inscrito. Al lanzar dardos aleatorios, podemos contar cuántos de ellos caen dentro del círculo y cuántos fuera.

Con esta información, podemos hacer una estimación del área del círculo y, por lo tanto, del valor de π.

El código utiliza la biblioteca NumPy para generar coordenadas aleatorias para los dardos y para realizar operaciones matemáticas. La biblioteca SciPy se utiliza para calcular la función de densidad de probabilidad acumulada, que se utiliza para determinar cuántos dardos caen dentro del círculo.

#Cálculo del número PI de forma aleatoria
import matplotlib.pyplot as plt
import numpy as np
from scipy import stats

# Número de dardos a lanzar
N = 1000000

# Generar coordenadas aleatorias
x = np.random.uniform(low=-1, high=1, size=N)
y = np.random.uniform(low=-1, high=1, size=N)

# Calcular la distancia al centro
dist = np.sqrt(x**2 + y**2)

# Calcular el número de dardos que caen dentro del círculo
num_dentro = np.sum(dist < 1)

# Estimar pi
pi_estimado = 4 * num_dentro / N

# Comparar con el valor real de pi
pi_real = np.pi
error_relativo = np.abs(pi_estimado - pi_real) / pi_real

# Mostrar resultados
print(f"Valor estimado de pi: {pi_estimado}")
print(f"Valor real de pi: {pi_real}")
print(f"Error relativo: {error_relativo}")

#Visualización del círculo de pi
fig, ax = plt.subplots(figsize=(7, 7))
ax.set_aspect('equal')
circulo = plt.Circle((0, 0), 1, color='grey', alpha=0.2)
ax.add_artist(circulo)
ax.scatter(x[dist < 1], y[dist < 1], s=0.5, color='white')
ax.scatter(x[dist >= 1], y[dist >= 1], s=0.5, color='turquoise')

# Mostrar resultados gráficamente
ax.set_title(f"Estimación de Pi: {pi_estimado:.5f} (error relativo: {error_relativo:.5f})")
plt.show()

#Resultados
Valor estimado de pi: 3.143684
Valor real de pi: 3.141592653589793
Error relativo: 0.0006656962378038079
#Nuestro número estimado se aproxima mucho al número pi!

Primero, el número de dardos que se lanzará se define como N=1000000. A continuación, se generan coordenadas aleatorias para los dardos utilizando la función np.random.uniform(). Se genera un conjunto de coordenadas para la coordenada x y otro para la coordenada y, ambos en el rango de [-1, 1].

Luego, se calcula la distancia euclidiana desde el origen de cada punto generado. Si la distancia es menor que 1, significa que el punto cae dentro del círculo. Se cuentan cuántos puntos caen dentro del círculo mediante np.sum() y np.where().

Una vez se tiene el número de puntos que caen dentro del círculo, se estima el valor de π mediante la fórmula π = 4 * puntos dentro del círculo / total de puntos.

Por último, se comparan el valor estimado de π con el valor real y se muestra el error relativo en la estimación.

Este método de simulación es muy útil ya que puede ser utilizado para estimar π en cualquier dimensión. Además, este método se puede utilizar para simular cualquier otro problema donde se desee obtener una estimación numérica de una cantidad desconocida.

Ajustando una curva de datos

Estos son dos ejemplos de cómo ajustar una curva de datos con una función, utilizando la biblioteca NumPy, Matplotlib y SciPy de Python.

En general, el ajuste de curvas es un proceso importante en el análisis de datos que se utiliza para encontrar relaciones funcionales entre las variables. Los modelos que se ajustan pueden variar desde simples funciones polinómicas hasta modelos más complejos con múltiples parámetros.

El ajuste de curvas es una herramienta útil para la predicción y la interpretación de los datos, especialmente en áreas como la estadística, la física, la ingeniería y la ciencia de datos.

#Ajustando una curva de datos
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit

# Datos
x = np.array([1, 2, 3, 4, 5])
y = np.array([1.1, 3.5, 7.2, 13.1, 21.3])

# Función a ajustar
def func(x, a, b, c):
    return a * x**2 + b * x + c

# Ajuste
popt, pcov = curve_fit(func, x, y)

# Coeficientes
a, b, c = popt

# Gráfica
plt.plot(x, y, 'ro', label='Datos')
plt.plot(x, func(x, a, b, c), label='Ajuste')
plt.legend()
plt.show()

#Ejemplo 2
import numpy as np
from scipy.optimize import curve_fit
import matplotlib.pyplot as plt

# Función a la que se quiere ajustar la curva
def func(x, a, b, c):
    return a*np.exp(-b*x) + c

# Datos a los que se quiere ajustar la curva
xdata = np.linspace(0, 4, 50)
ydata = func(xdata, 2.5, 1.3, 0.5) + 0.2*np.random.normal(size=len(xdata))

# Ajuste de la curva
popt, pcov = curve_fit(func, xdata, ydata)

# Graficar los datos y la curva ajustada
plt.plot(xdata, ydata, 'o', label='Datos')
plt.plot(xdata, func(xdata, *popt), '-', label='Curva ajustada')
plt.legend()
plt.show()

Aquí hemos visto como ajustar una curva de datos con una función, utilizando la biblioteca NumPy, Matplotlib y SciPy de Python.

Primero, se definen dos matrices NumPy de 1D, x e y, que contienen los datos de los puntos a ajustar. Luego se define una función "func" que se utilizará para realizar el ajuste de la curva. Esta función toma tres argumentos, a, b y c, que son los coeficientes de la función cuadrática ax^2 + bx + c.

El ajuste de la curva se realiza utilizando la función curve_fit de SciPy. Esta función devuelve dos valores, popt y pcov. El primero es una matriz NumPy de 1D que contiene los valores óptimos para a, b y c, y el segundo es una matriz NumPy de 2D que contiene la covarianza de los parámetros.

A continuación, se asignan los valores óptimos de los coeficientes a, b y c a variables separadas a partir de popt. A continuación, se grafican los puntos de datos originales junto con la curva ajustada utilizando la función plot de Matplotlib.

Medidas de dispersión

Las medidas de dispersión son estadísticas que indican cuánto se alejan los datos de un conjunto de valores respecto a su valor central o promedio. Estas medidas se utilizan para analizar la variabilidad o heterogeneidad de los datos.

#Medidas de dispersión en Numpy y Scipy
import numpy as np
from scipy import stats

import numpy as np

# Datos
datos = np.array([4, 49, 19, 4, 14, 20, 17, 50, 4, 20])

# Media
media = np.mean(datos)
print("Media:", media)

# Mediana
mediana = np.median(datos)
print("Mediana:", mediana)

# Desviación estándar
desviacion_estandar = np.std(datos)
print("Desviación estándar:", desviacion_estandar)

# Moda
moda = stats.mode(datos)
print("Moda:", moda.mode[0])

#Resultado
Media: 20.1
Mediana: 18.0
Desviación estándar: 15.984054554461457
Moda: 4

Aquí se define una lista de datos llamada "data".La media, mediana y desviación estándar de los datos se calculan utilizando las funciones "mean", "median" y "std" de NumPy. Nótese que para el caso de la moda recurrimos a SciPy.

La media es la suma de todos los valores dividida por el número de valores, la mediana es el valor que se encuentra en el centro de un conjunto de datos ordenados, y la desviación estándar mide la cantidad de variabilidad o dispersión en los datos. La moda por su parte, es el valor que más se repite en la serie.

Ajuste de regresión lineal

Anteriormente vimos el ajuste de curva, esta vez veremos un ajuste parecido pero limitado a la regresión lineal, y por tanto, de una mayor aplicación estarística.

El ajuste de curva permite modelar una amplia variedad de formas de curva, mientras que el ajuste de regresión lineal se limita a modelos lineales. Pero esa no es la única diferencia. El primero es más una mera optimización, mientras que con el ajuste de regresión lineal, nos jugamos la integridad de todo el modelo estadístico, de allí que en esta ocasión trajemos con 'stats'.

#Ajuste de modelo de regresión lineal
import numpy as np
import matplotlib.pyplot as plt
from scipy import stats

# Datos de ejemplo
x = np.array([10, 20, 30, 40, 50, 60])
y = np.array([2.5, 5.1, 7.3, 9.1, 11.2, 13.5])

# Ajuste de modelo de regresión lineal
slope, intercept, r_value, p_value, std_err = stats.linregress(x, y)

# Imprimir resultados
print(f"Coeficiente de pendiente: {slope}")
print(f"Coeficiente de intersección: {intercept}")
print(f"Coeficiente de correlación: {r_value}")
print(f"Valor p: {p_value}")
print(f"Error estándar: {std_err}")

#Graficando los datos originales y la línea de regresión
plt.scatter(x, y)
plt.plot(x, slope*x + intercept, color='red')
plt.title('Regresión lineal')
plt.xlabel('Variable independiente')
plt.ylabel('Variable dependiente')
plt.show()

#Resutado
Coeficiente de pendiente: 0.21457142857142858
Coeficiente de intersección: 0.6066666666666665
Coeficiente de correlación: 0.998781193835107
Valor p: 2.227327440120712e-06
Error estándar: 0.0053017773941776

Este código realiza un ajuste de modelo de regresión lineal a un conjunto de datos utilizando la biblioteca SciPy.

Primero, se definen los datos de ejemplo x e y como matrices NumPy. Luego, se utiliza la función stats.linregress(x, y) de SciPy para realizar el ajuste de regresión lineal.

La función stats.linregress() devuelve cinco valores: la pendiente (slope), la intersección (intercept), el coeficiente de correlación (r_value), el valor p (p_value) y el error estándar (std_err).

Matemáticas financieras

Pasemos ahora a ver un par de aplicaciones de estas bibliotecas a las matemáticas financieras.

#Matemáticas financieras con Numpy
#Comenzamos instalando el paquete numpy-financial
pip install numpy-financial

#Calculando el VAN
import numpy_financial as npf

# Datos de entrada
tasa_descuento = 0.1
flujos_efectivo = [-100, 60, 60, 60, 60]
inversion_inicial = 100

# Cálculo del valor presente neto
vpn = npf.npv(tasa_descuento, flujos_efectivo) + inversion_inicial

print("El valor presente neto es:", round(vpn, 2))

#Resultado
El valor presente neto es: 190.19

El código anterior muestra cómo calcular el valor presente neto de una serie de flujos de efectivo utilizando la biblioteca numpy_financial. Recuerda primero instalar la librería Numpy Financial.

Primero, se definen las variables de entrada del problema. La tasa de descuento se establece en 0.1, lo que significa que se asume que el costo de oportunidad del capital es del 10%. Los flujos de efectivo se dan como una lista de valores. En este caso, hay un flujo inicial de efectivo de -100, lo que significa que hay una inversión inicial de 100, seguido de cuatro flujos positivos de efectivo de 60.

Luego, se utiliza la función npf.npv() de la biblioteca numpy_financial para calcular el valor presente neto de los flujos de efectivo. Esta función toma como argumentos la tasa de descuento y una lista de flujos de efectivo. También se agrega la inversión inicial al resultado final.

Finalmente, el valor presente neto se imprime en la pantalla redondeado a dos decimales.

El valor presente neto es una herramienta útil en la toma de decisiones de inversión, ya que permite evaluar la rentabilidad de un proyecto de inversión. Si el valor presente neto es positivo, significa que el proyecto es rentable, mientras que un valor negativo indica que el proyecto no es rentable.

#Calculando la TIR
import numpy_financial as npf

flujos_efectivo = [-1000, 200, 250, 300, 350, 400, 450]
tir = npf.irr(flujos_efectivo)

print("La TIR es:", round(tir, 4))

#Resultado
La TIR es: 0.1979

A continuación hemos utilizado la librería numpy_financial para calcular la TIR (tasa interna de retorno) de un flujo de caja.

Primero, se define la lista de flujos de efectivo llamada flujos_efectivo. Esta lista contiene los flujos de efectivo del proyecto en diferentes periodos de tiempo. En este caso, el proyecto requiere una inversión inicial de -1000 unidades monetarias y se espera que genere flujos de efectivo de 200, 250, 300, 350, 400 y 450 unidades monetarias en cada uno de los siguientes 6 periodos.

Luego, se utiliza la función npf.irr de la librería numpy_financial para calcular la TIR. La TIR es la tasa de interés que hace que el valor presente neto (VPN) de los flujos de efectivo sea igual a cero. En otras palabras, es la tasa a la que el proyecto es rentable. La función npf.irr utiliza una técnica de interpolación para encontrar la tasa de descuento que hace que el VPN sea igual a cero.

Finalmente, se imprime el resultado redondeado a 4 decimales utilizando la función round(). En este caso, la TIR calculada es de aproximadamente 18.97%, lo que significa que el proyecto es rentable y ofrece un rendimiento superior al 18.97% de interés anual.

Álgebra lineal con NumPy y SciPy

Tanto SciPy como NumPy proporcionan un conjunto de módulos específicos para el álgebra lineal. Estos incluyen herramientas para la solución de sistemas de ecuaciones lineales, la diagonalización de matrices, la descomposición de valores singulares y la descomposición de matrices de covarianza, entre muchas otras aplicaciones.

Producto de dos matrices

El producto de dos matrices es una operación matemática que se realiza entre dos matrices y produce una nueva matriz como resultado.

#Álgebra lineal con numpy
import numpy as np

a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6], [7, 8]])

c = np.dot(a, b)

print(c)

#Resultado
[[19 22]
 [43 50]]

Traspuesta de una matriz

La traspuesta de una matriz es simplemente una matriz en la que las filas y columnas han sido intercambiadas. En otras palabras, la traspuesta de una matriz es una matriz en la que las filas de la matriz original se convierten en columnas y las columnas se convierten en filas.

import numpy as np

a = np.array([[1, 2], [3, 4]])

b = np.transpose(a)

print(b)

#Resultado 
[[1 3]
 [2 4]]

Inversa de una matriz

La inversa de una matriz es una matriz que, al multiplicarse por la matriz original, produce la matriz identidad.

#Inversa de una matriz
import numpy as np
from scipy.linalg import inv

a = np.array([[1, 2], [3, 4]])

b = inv(a)

print(b)

#Resultado
[[-2.   1. ]
 [ 1.5 -0.5]]

Determinante de una matriz

Si bien podemos explicar el determinante de una matriz de muchas formas. En este artículo nos conformaremos con decir que el determinante de una matriz nos dice si una matriz posee inversa o no.

#Determinante de una matriz
import numpy as np
from scipy.linalg import det

a = np.array([[1, 2], [3, 4]])

b = det(a)

print(b)

#Resultado
-2.0

Eigenvalores

Solo como ejemplo, que sepas que el paquete de algebra lineal de SciPy no se limita a operaciones básicas con matrices, sino que también permite temas más avanzados .

#Eigenvalores
import numpy as np
from scipy.linalg import eig

a = np.array([[1, 2], [3, 4]])

b, c = eig(a)

print(b)
print(c)

#Resultado
[-0.37228132+0.j  5.37228132+0.j]
[[-0.82456484 -0.41597356]
 [ 0.56576746 -0.90937671]]

Esta función calcula los valores y vectores propios (también llamados eigenvalores y eigenvectores) de la matriz a.

La función eig devuelve dos matrices, b y c. La matriz b contiene los valores propios de a y la matriz c contiene los vectores propios de a, donde cada columna de c corresponde a un vector propio.

Sistemas de ecuaciones lineales

Esta función resuelve el sistema de ecuaciones lineales a x = b, donde a es la matriz definida anteriormente y b es el vector definido anteriormente, y devuelve el valor de x que satisface la ecuación. El resultado se almacena en la variable c.

import numpy as np
from scipy.linalg import solve

a = np.array([[1, 2], [3, 4]])
b = np.array([5, 6])

c = solve(a, b)

print(c)

#Resultado
[-4.   4.5]

Nota Final: Puedes encontrar la amalgama de funciones de algebra lineal de SciPy en su manual.

Cálculo diferencial e integral en NumPy y SciPy

El cálculo diferencial es el estudio del cambio y la tasa de cambio de funciones, mientras que el cálculo integral se ocupa de la acumulación de pequeños cambios para encontrar áreas, volúmenes y otros conceptos geométricos. Ambos temas son fundamentales en matemáticas y tienen una amplia gama de aplicaciones en ciencias físicas y sociales, ingeniería y otras áreas de la industria.

SciPy proporciona una serie de herramientas para trabajar con cálculo diferencial e integral, incluyendo la capacidad de integrar y diferenciar funciones de manera numérica. Algunas de las funciones clave incluyen scipy.integrate.quad para integrar funciones unidimensionales, scipy.integrate.nquad para integrar funciones de varias variables, y scipy.integrate.solve_ivp para resolver ecuaciones diferenciales ordinarias.

Además, SciPy tiene funciones para realizar la diferenciación numérica, lo que permite calcular la derivada de una función en un punto dado sin la necesidad de conocer la fórmula analítica de la función. Las funciones relevantes incluyen scipy.misc.derivative y scipy.interpolate.UnivariateSpline.

Veamos pues, solo unos cuantos ejemplos de este extenso campo de aplicación.

Derivadas

import numpy as np
from scipy.misc import derivative

# Definir la función para la que se calculará la derivada
def f(x):
    return x**2 + 2*x + 1

# Calcular la derivada de la función (evaluada) en x=2
derivada = derivative(f, 2)

# Imprimir la derivada
print(derivada)

#Resultado
6.0

Aquí no hicimos más que evaluar la función en 2. La derivada de la función es 2x+2, por lo que tenemos 2 (2) +2=6.  En este ejemplo lo vemos fácil pero la utilidad de SciPy radica en calcular derivadas mucho más complejas.

Derivadas Parciales

La derivada parcial de una función de varias variables es la derivada con respecto a cada una de esas variables manteniendo las otras como constantes.

import numpy as np
from scipy.misc import derivative

# Definir la función
def f(x,y):
    return x**2 + y**2

# Calcular la derivada parcial con respecto a x en el punto (1,2)
x0 = 1
y0 = 2
dx = 1e-6  # tamaño de paso para la derivada
df_dx = derivative(lambda x: f(x,y0), x0, dx=dx)

print(f"La derivada parcial de f(x,y) con respecto a x en el punto (1,2) es {df_dx:.2f}")

#Resultado
La derivada parcial de f(x,y) con respecto a x en el punto (1,2) es 2.00

La derivada parcial de f(x,y) = x^2 + y^2 con respecto a x es 2x, y evaluada en (1,2) nos da 2, ya que x en ese punto es igual a 1. Por lo tanto, la tasa de cambio instantánea de f en la dirección x en el punto (1,2) es 2.

Integrales

En este ejemplo vamos a empezar directamente con una integral definida. En el proceso veremos la función quad de SciPy para calcular la integral definida de f en el intervalo [0, 1].

Donde f es la función a integrar, a es el límite inferior de la integral y b es el límite superior de la integral.

La función quad utiliza un algoritmo de integración numérica para aproximar la integral definida de f. En este caso, la integral definida es:

from scipy.integrate import quad

# Definimos la función a integrar
def f(x):
    return x**2 + 2*x + 1

# Calculamos la integral definida entre 0 y 1
resultado, error = quad(f, 0, 1)

# Imprimimos el resultado
print(f"La integral definida es {resultado}")

#Resultado
La integral definida es 2.3333333333333335

Si lo hubieramos hecho "a mano" tendríamos que haber encontrado la primitiva de f: F(x) = (1/3)*x^3 + x^2 + x + C

Después nos habría tocado que evaluar la primitiva F(x) en los límites de integración [0,1] . La función quad de SciPy nos ahora este proceso y nos proporciona un valor aproximado de la integral sin conocer el valor de la constante de integración.

Mínimo Global

El mínimo global de una función es el valor más bajo que toma la función en todo su dominio. En otras palabras, es el punto más bajo en la gráfica de la función. Este valor representa el valor mínimo absoluto de la función, ya que no hay otro valor en el dominio de la función que produzca un resultado más bajo.

En términos matemáticos, un mínimo global es un valor "y" en la función "f(x)" que cumple con la condición de que "f(x) ≤ f(a)" para todos los valores de "x" en el dominio de la funció

from scipy.optimize import differential_evolution

# Definimos la función a minimizar
def f(x):
    return (x[0] - 1)**2 + (x[1] - 2.5)**2 + (x[2] - 5)**2

# Definimos los límites de búsqueda
limites = [(0, 5), (0, 5), (0, 10)]

# Buscamos el mínimo global
resultado = differential_evolution(f, limites)

# Imprimimos el resultado
print(f"El mínimo global es {resultado.x}")

#Resultado
El mínimo global es [1.  2.5 5. ]

Es importante recordar que solo hay un mínimo (y un máximo) global, aunque pueden haber diversos mínimos y máximos locales.

Series de Taylor

Las series de Taylor son una herramienta matemática utilizada para aproximar funciones mediante una serie infinita de términos polinómicos. La idea detrás de esta técnica es descomponer una función en términos de sus derivadas, lo que permite aproximar la función en un punto determinado.

import numpy as np
from scipy.misc import derivative
from scipy.special import factorial
from scipy import poly1d

# Función a la que queremos calcular la serie de Taylor
def f(x):
    return np.sin(x)

# Punto alrededor del cual queremos centrar la serie de Taylor
a = 0

# Orden de la serie de Taylor
n = 5

# Calculamos los coeficientes de la serie de Taylor utilizando la fórmula para la función seno
coeficientes = [(-1)**i/factorial(2*i+1) for i in range(n+1)]

# Creamos el polinomio a partir de los coeficientes
polinomio = poly1d(coeficientes)

# Evaluamos el polinomio en el punto x
x = 1
valor_aproximado = polinomio(x)

# Comparamos con el valor real de la función en el punto x
valor_real = f(x)
error_relativo = abs(valor_aproximado - valor_real)/valor_real

print(f"Valor aproximado: {valor_aproximado}")
print(f"Valor real: {valor_real}")
print(f"Error relativo: {error_relativo}")

#Resultado
Valor aproximado: 0.841470984648068
Valor real: 0.8414709848078965
Error relativo: 1.8993938788946215e-10

Este código calcula la serie de Taylor de la función seno en un punto específico y luego evalúa el polinomio de Taylor resultante en otro punto. A continuación, compara el valor aproximado obtenido a partir de la serie de Taylor con el valor real de la función en el punto evaluado, y calcula el error relativo.

Puedes encontrar una explicación más detallada y más técnica en el siguiente texto online.

Ecuaciones Diferenciales

from scipy.integrate import solve_ivp

# Definimos la ecuación diferencial
def f(t, y):
    return [y[1], -2*y[1] - y[0]]

# Condiciones iniciales
y0 = [0, 1]

# Intervalo de tiempo a considerar
t_span = [0, 10]

# Resolución de la ecuación diferencial
solucion = solve_ivp(f, t_span, y0)

# Resultado
print(solucion.y)

Este código resuelve una ecuación diferencial de segundo orden utilizando la función solve_ivp de la biblioteca SciPy.

Primero se define la ecuación diferencial a resolver en la función f, donde se especifica la derivada de la función y con respecto a t. En este caso, se trata de una ecuación diferencial de segundo orden de la forma y'' + 2y' + y = 0.

Luego se especifican las condiciones iniciales y0 para la función y y el intervalo de tiempo t_span en el que se desea resolver la ecuación diferencial.

Finalmente, se utiliza la función solve_ivp para resolver la ecuación diferencial con los parámetros especificados, y se almacena la solución en la variable solucion. Se imprime el resultado de la solución y en cada punto en el intervalo de tiempo especificado.

La solución devuelta será una matriz de dos filas, una para cada variable en el sistema de ecuaciones diferenciales.

Optimización con NumPy y SciPy: Ejemplo práctico de Maximización de Beneficios.

En economía, una función de producción describe la relación entre los insumos (factores productivos) y la cantidad de producto que una empresa puede producir utilizando esos insumos. Básicamente, es una fórmula que nos dice cuánta producción se puede obtener con diferentes combinaciones de trabajo, capital y otros insumos.

Los insumos son los recursos que una empresa utiliza para producir bienes o servicios. Los insumos más comunes son el trabajo (es decir, el tiempo y la energía que las personas dedican a la producción) y el capital (es decir, las herramientas, maquinaria y edificios que se utilizan en el proceso productivo).

La función de producción es importante porque permite modelar cómo los cambios a las cantidades de insumos afecta la cantidad de producción. Por ejemplo, si se aumenta la cantidad de trabajo, ¿cómo afectará esto a la cantidad de producción? ¿Cuánto capital es necesario para producir una cantidad determinada de producción?

Un ejemplo imaginario para entender la optimización

Veremos que en este ejemplo hipotético, la empresa no puede gastar más de $300 para adquirir el capital y trabajo para su proceso de producción (la restricción presupuestaria). En otras palabras, la restricción presupuestaria se define como el costo total de contratar trabajadores (4L) y unidades de capital (6K), que no puede superar los $300.

Es lógico pensar que $300 es muy poco para poner en marcha un proceso productivo, y ¡estamos en lo cierto! Pero en este caso solo queremos analizar la optimización en SciPy por lo que está simplificado al máximo. Si aún te parece un ejemplo "chocante"; podemos pensar que es una pequeña fábrica y que la producción es por hora.

Por otra parte; la función de beneficios se define como la diferencia entre los ingresos generados por la producción y los costos de los inputs (4L y 6K).

Buscamos la combinación de trabajo y capital que maximicen la producción los beneficios de esta empresa, teniendo en cuenta la restricción presupuestaria.

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import minimize

# Definimos la función de producción
def funcion_produccion(inputs):
    L, K = inputs
    return (L**(1/2)) * (K**(1/2))

# Definimos la función de beneficios
def funcion_beneficios(inputs):
    return 10 * funcion_produccion(inputs) - 4 * inputs[0] - 6 * inputs[1]

# Definimos la restricción presupuestaria
def restriccion_presupuestaria(inputs):
    return 4 * inputs[0] + 6 * inputs[1] - 300

# Encontramos los inputs óptimos sujetos a la restricción presupuestaria
guess_inicial = [1, 1]
resultado = minimize(lambda x: -funcion_beneficios(x), guess_inicial, constraints=[{'type': 'eq', 'fun': restriccion_presupuestaria}])
inputs_optimos = resultado.x

# Calculamos la producción y los beneficios óptimos
produccion_optima = funcion_produccion(inputs_optimos)
beneficios_optimos = funcion_beneficios(inputs_optimos)

# Graficamos la función de producción
valores_L = np.linspace(0, 100, 100)
valores_K = np.linspace(0, 100, 100)
L_mesh, K_mesh = np.meshgrid(valores_L, valores_K)
Q_mesh = funcion_produccion([L_mesh, K_mesh])
fig, ax = plt.subplots()
ax.set_xlabel('Trabajo (L)')
ax.set_ylabel('Capital (K)')
ax.set_title('Función de producción')
ax.contour(L_mesh, K_mesh, Q_mesh, levels=10)
ax.plot(inputs_optimos[0], inputs_optimos[1], 'ro', label='Punto óptimo')
ax.legend()

plt.show()

# Imprimimos los resultados
print(f"Inputs óptimos: {inputs_optimos}")
print(f"Producción óptima: {produccion_optima}")
print(f"Beneficios óptimos: {beneficios_optimos}")

#Resultado
Inputs óptimos: [37.49974611 25.00016926]
Producción óptima: 30.618621784087956
Beneficios óptimos: 6.186217840879607

Explicación de los resultados

Los resultados indican que la empresa debería utilizar aproximadamente 37 unidades de trabajo (L) y 25 unidades de capital (K) por hora para obtener la máxima producción y beneficios. Con estos inputs óptimos, la producción óptima es de aproximadamente 31 unidades por hora, mientras que los beneficios óptimos son de 6.19 dólares por hora.

Es decir, que si la empresa utiliza en promedio 37 unidades de trabajo y 25 de capital; obtendrá $6.19 de beneficios por cada $300 invertidos en capital y trabajo.

También podemos interpretar los resultados gráficamente a partir del gráfico de la función de producción. El punto óptimo, representado por un círculo rojo, se encuentra en el lugar donde las curvas de nivel de la función de producción son tangentes a la restricción presupuestaria.

En este punto, la pendiente de la curva de nivel de la función de producción coincide con la pendiente de la recta presupuestaria, lo que indica que la empresa está utilizando de manera eficiente sus recursos para maximizar sus beneficios.

Nuestro ejercicio resuelve un problema de optimización en el que una empresa hipotética desea maximizar sus beneficios al elegir la cantidad óptima de dos factores de producción: trabajo y capital.

La empresa está limitada por un presupuesto dado, es decir, no puede gastar más dinero del que tiene disponible, y además tiene una función de producción que describe cómo la cantidad de trabajo y capital utilizada afecta la cantidad producida.

El objetivo de la empresa es determinar la cantidad óptima de trabajo y capital para maximizar sus beneficios, dada la restricción presupuestaria y la función de producción. Para resolver este problema, utilizamos la biblioteca SciPy que proporciona herramientas para la optimización numérica.

Dado que el enfoque de este artículo es en la programación no entraremos en los detalles de la microeconomía (Función Cobb Douglas, isocuantas, rendimientos constantes a escala etc). Ten en cuenta que este ejercicio es un ejemplo grosso modo, de las capacidades de SciPy y que pudieramos agregar mucho más.

En nuestro código tenemos definida la función de producción, la función de beneficios y la restricción presupuestaria en términos matemáticos. Luego utilizamos la función minimize de SciPy para encontrar la combinación óptima de trabajo y capital que maximiza los beneficios de la empresa, sujeto a la restricción presupuestaria.

Finalmente, el código grafica la función de producción para visualizar la combinación óptima de trabajo y capital, y muestra los resultados óptimos de producción, beneficios y los inputs óptimos.

Palabras finales y recomendaciones.

Hemos llegado al final de este artículo. Si llegaste hasta aquí, muchísimas gracias por leer. En este artículo hemos cubierto algunas de las aplicaciones de SciPy y NumPy al cálculo scientífico.

Aún así, esto solo es una pequeña presentación de un campo de aplicación muchísimo más vasto. Aún así, espero haya sido de relevancia y utilidad.

Quisiera cerrar esta guía con 3 conclusiones/recomendaciones al respecto. Debido a que NumPy es un poco más popular, me centraré más en SciPy:

1. SciPy es la biblioteca de Python más utilizada para el análisis científico y matemático además de tener las características de optimización más potentes. A su vez destaca por su facilidad de usar para resolver problemas complejos.
2. Si bien hay muchas bibliotecas mucho más populares que SciPy, entre los científicos de datos y profesiones afines; lo cierto es que recomiendo aprender un poco de SciPy, o por lo menos ver algunos proyectos para tener una idea general. En lo personal considero que esta biblioteca ayuda a desarrollar el planteamiento y resolución de problemas así como el pensamiento sistémico.

A diferencia de Matplotlib o Pandas, en donde puedes pensar que ya sabes más o menos "cómo hacer lo que quieres hacer"; en SciPy necesitas plantear primero el problema y después estructurar el código.

1. En este artículo se introdujeron SciPy y NumPy juntos, pero no es que sea inseparables o algo por el estilo, la asociación fue por motivos pedagógicos. Lo cierto es que puedes integrar SciPy y NumPy cada vez que necesites un cálculo específico en tus proyectos, de hecho muy a menudo tienen el papel de simples "calculadoras" más que de protagonistas.

En otras palabras; estas bibliotecas no son una especie de "campo de estudio" o algo "exhaustivo" que hay que dominar, aunque ciertamente te pueden facilitar la vida en tu camino hacia la programación.

Nuevamente, muchas gracias por leer, y si te interesa aprender más acerca del cálculo científico en Python, freeCodeCamp ofrece una certificación en detalle. Te deseo lo mejor y, ¡Feliz Programación!