Configurar Github para usarlo con SSH en Linux

Si usas Git y Github y no quieres estar introduciendo tu username y password cada vez que haces un push porque lo tienes configurado con HTTPS, lo mejor es que configures SSH, algunos IDEs, como Visual Studio, lo hacen de manera automática, en Linux es bastante sencillo, incluso en la página de Github te dicen como, sin embargo, para mi la mejor forma de aprender bien algo es intentar explicarlo 😃.

1- Generar una SSH Key
Lo primero es abrir una terminal, presiona ctrl+alt+t y generamos una Key SSH usando tus credenciales de Github, con el siguiente comando:

ssh-keygen -t rsa -b 4096 -C "tu_email_de_registro_en_github@email.com"

Luego sigues los pasos que te indican, ese comando genera un archivo que contiene tu configuración SSH usando el algoritmo RSA con un tamaño de clave de 4096 bits. Tu clave por defecto se almacena en ~/.ssh/id_rsa.pub

2- Añadir tu SSH Key a ssh-agent
Lo siguiente es añadir tu clave SSH a ssh-agent

ssh-add ~/.ssh/id_rsa

(Opcional) Verificamos si se añadió con:

ssh-add -L

Algoritmo Quicksort

Quicksort es uno algoritmos de ordenación más utilizados en las librerías bases de los lenguajes de programación, por su eficiencia y por su sencillez. Probablemente ya has escuchado o incluso conozcas este algoritmo, sin embargo siempre es bueno repasar lo básico porque, por ejemplo, si estas buscando empleo, es muy probable que en una entrevista de trabajo, especialmente empresas de EEUU, te pidan implementar Quicksort o te pregunten sobre alguno de los algoritmos básicos de ordenación o estructuras de datos como los Heaps.

Un poco de historia

Este algoritmo fue inventado por Tony Hoare a finales de los 60s y también es la base de otros como Quickselect -creado por el mismo Hoare- sin duda, es muy interesante y es uno de los métodos de ordenación “Linearítmicos” más eficientes que existen, sin embargo no siempre garantiza O(nlogn) en su peor caso la complejidad de este algoritmo es cuadrática, eso va a depender de la calidad de pivote que se elija. Ha sido muy estudiado, especialmente por Robert Sedgewick y utiliza la técnica de Divide and Conquer.

Descripción del algoritmo

Obviamente esta es una explicación mundana, como mencioné anteriormente el algoritmo se ha estudiado ampliamente, incluyendo pruebas matemáticas rigurosas. Sin embargo mi intención es que se pueda entender de manera fácil. Para una explicación más completa ver la referencia del libro de Sedgewick al final del post o buscar en Wikipedia. Anteriormente escribí sobre el Heapsort que garantizaba O(nlogn) Quicksort es diferente porque la eficiencia del algoritmo va a depender del elemento pivote.

Algoritmo Heap Sort

Una de las aplicaciones de los Heaps o Montículos es el algoritmo HeapSort, el cual es uno de tantos que permite ordenar un conjunto "S" de datos en tiempo “linearítmico“ O(n logn). No es un algoritmo estable, es decir, no garantiza que los elementos tengan el mismo orden relativo después de la ordenación, pero a diferencia de otros algoritmos como Quicksort siempre garantiza O(n logn) como mejor, promedio o peor caso.

Una vez que se entiende la estructura de datos Heap el algoritmo es bastante sencillo y se basa en los siguientes pasos:

1. Construir un MaxHeap o MinHeap a partir de un arreglo.
2. Inicializar un ciclo desde I=heap.Length – 1 hasta I > 1 e Ir eliminando el tope (intercambiándolo con el último elemento I). Luego se verifica desde el primer nodo que se mantenga la propiedad del montículo (El mayor o menor elemento esté en el tope) esta operación generalmente se conoce como Heapify.

La explicación de eliminar del tope junto con Heapify puedes leerlas en mi post sobre Heaps o montículos, donde las explico con imágenes para que se entienda un poco mejor. Cabe destacar que para ordenar de manera creciente se utiliza un MaxHeap y para ordenar de manera decreciente un MinHeap. De igual manera, vale mencionar que la mayoría de las implementaciones de este algoritmo son en sitio, es decir, se modifica directamente el arreglo que se quiere ordenar.

Heaps o Montículos

Si tienes una carrera formal en computación, o alguna rama relacionada, probablemente habrás visto alguna clase de estructura de datos y recordarás los Heaps o -montículos en español- En caso de que no recuerdes, o no sabías que existían, en este post intentaré explicar de manera resumida esta interesante estructura de datos.

Las operaciones en los heaps son eficientes, la mayoría son O(logn). Los montículos se usan principalmente en el algoritmo Heapsort y en las Priority Queues (Colas de prioridades). Está representada por una estructura de tipo árbol y su característica principal es que el nodo padre -o raíz- siempre es mayor, o menor según sea el caso, que sus nodos hijos.

Los Heaps pueden ser MaxHeaps (El nodo padre es mayor que los hijos) o MinHeaps (El nodo padre siempre es menor que los hijos). La representación más usada son los Binary Heaps (montículos binarios) que tienen la estructura de un árbol binario. La forma más usada para almacenar los datos en esta estructura es un Array (dinámico por lo general), esto genera un árbol binario completo (todas las secciones deben estar balanceadas, con una posible excepción de la última) por lo que sabemos de antemano su forma y con simple aritmética podemos calcular los índices en el array de los nodos hijos a partir del padre y viceversa.

La imagen representa un MaxHeap, nótese como los nodos padres o raíz siempre son mayores a los hijos, y cada vez que se inserte un nuevo nodo o se elimine el nodo raíz se debe garantizar esta propiedad.