League Of Coders

vudduu

Contest Details:

Contest window opens at: 13th September 2019, 19:00 hrs IST
Contest window closes at: 23rd September 2019, 19:00 hrs IST
Duration: 3 hours

https://www.codechef.com/SGHC2019

vudduu

Teoría recomendada para aprobar una entrevista de algoritmos (Coding Interview)

Estructura de Datos
1.1. Arrays (filter, easy sort, mutations)
1.2. Strings (split, substring, parse, etc.)
1.3 Union-Find Disjoint Sets
1.4 Conjuntos (sets, objects in javascript)
1.5 Matrix Distances (Euclidean Distance)
1.6 Binary Tree
Busquedas (y Ordenamiento)
2.1 Busqueda Binaria
2.2 Busqueda Ternaria
2.3 Sorts
2.4 Meet in the middle
Paradigmas de Programacion
3.1 Brute Force
3.2 Recursive Complete Search
3.3 Greedy
3.4 Divide and Conquer
Programacion Dinamica
4.1 Memoization
4.2 Knuth's word wrapping algorithm
4.3 Longest Common Subsequence
4.4 Longest Increasing Subsequence
Grafos
5.1 Data Structure Graph
5.2 Depth First Search (DFS)
5.3 Breadth First Search (BFS)
5.4 Flood Fill
5.5 Kruskal
5.6 Shortest Paths (Dijkstra's algorithm, etc.)
Advanced
6.1 Matrix Exponentiation
6.2 Grafos
6.2.1 Bipartite Graphs
6.3 Estructura de Datos
6.3.1 Segment Tree
6.3.2 Binary Indexed Tree (BIT, Fenwick Tree)

vudduu

Toptal se conoce por su top 3% de ingenieros el cual es obtenido a través de severos filtros y rigurosas entrevistas. Para esta te sugerimos prepararte por lo menos con 1 o 2 meses de anticipación en áreas comunes de entrevistas, ya sea saber explicar tus proyectos pasados hasta poder codificar algoritmos en tiempo real.

Prepara los siguientes puntos antes de tu entrevista.

Ingles
Algoritmos (nivel medium/hard)
Base para un proyecto (backend and frontend faciles de usar)

1. Ingles

El consejo que les doy para aprender ingles de manera rapida y economica es seguir EngVid (https://www.engvid.com/) una pagina con varios canales en youtube donde explican muy bien gramática y pronunciación del inglés.

Una vez te sientas confiado no tengas miedo y contacta amigos que saben ingles para realizar charlas y entrevistas de simulacro, de esta forma ambos podran verse beneficiados frente a futuras entrevistas.

2. Algoritmos

Para Algoritmos te recomendamos leas CrackingTheCodingInterview, con este libro fácilmente podrás prepararte para resolver problemas utilizando tu código.

Es muy importante que durante tu entrenamiento utilices el lenguaje con el cual quieres postular y posteriormente trabajar, aunque esto no es obligatorio (ej: puedes resolver problemas en C++ y hacer tu proyecto en JavaScript) puede darte puntos decisivos en tu postulación.

Antes de postular asegurate de resolver y practicar con los exámenes (similares a los que encontrarás en las entrevistas) que prepare anteriormente:
http://leagueofcoders.org/topic/12/practicas-para-coding-interviews

Algunos enlaces y videos recomendados
https://www.youtube.com/channel/UCxX9wt5FWQUAAz4UrysqK9A
https://www.youtube.com/channel/UC4xKdmAXFh4ACyhpiQ_3qBw
https://www.youtube.com/channel/UCOf7UPMHBjAavgD0Qw5q5ww
https://www.youtube.com/user/MIT/playlists

3. Base para un proyecto

Es muy importante que tengas a la mano base para realizar un proyecto desde inicio a fin, en las entrevistas te dirán que programes un proyecto en la area que te estas postulando, donde se calificara tu código pero sobre todo la correcta implementación de todos los puntos/features deseados.

Para esto necesitas tener una base donde puedas avanzar rápido y que ya tenga un orden y estructura limpia y entendible para los entrevistadores.

Este proyecto necesita ser entregado funcionando por lo que también necesitas saber como ponerlo online, en otras palabras hacer un build completo y posterior deploy.

Si piensas entrar a trabajar como front-end puedes utilizar Firebase/Firestore para presentar tu proyecto final.

4. Una vez completes tu entrenamiento

Una vez culmines tu entrenamiento y te sientas listo para postular utiliza el siguiente enlace de invitación/recomendación para crear tu cuenta.

ENLACE INVITACIÓN PARA TOPTAL

Para cualquier consulta o duda contactame directamente:
whatsapp: +591 78917002
email: vudduu@gmail.com
facebook: https://www.facebook.com/vudduu

vudduu

Dynamic Programming Theory

Videos

MIT - Introduction to Algorithms (Lecture Videos)

vudduu

At Deutsche Bank, we’re designing and building the digital bank of the future and you could help shape that. We’re looking for innovative thinkers and curious minds to transform our business through advanced applications, challenging programming projects and cutting-edge tech like AI and blockchain.

Contest Link: https://app.codility.com/programmers/challenges/rubidium2018/

vudduu

Una práctica que se vuelve común en nuestros días es que las aplicaciones puedan ser compatible con múltiples plataformas, es entonces donde teníamos dificultades para hacer funcionar nuestras aplicaciones diseñadas para la web (ReactDom) en dispositivos móviles por ejemplo (ReactNative).

Te presento un conjunto de pensamientos simples a la hora de desarrollar y de esta manera puedas reutilizar el código que tienes.

styled-components/primitives

Una muy buena práctica que comparten los devs de AirBnb es de no utilizar el abanico de componentes en react-native, en otras palabras intenta hacer todo con los siguientes componentes.

Animated: Declarative animations.
Image: A base component for Image rendering.
StyleSheet: Styling the primitives.
Text: A base component for Text rendering.
Touchable: A base component for interaction.
View: A base component for Layout.

Segun los desarrolladores que ya utilizan estas primitivas en sus proyectos, un 99% de los componentes necesarios para una aplicación funcional pueden ser totalmente completados con estos.

direct DOM manipulation

Siempre que hagas aplicaciones multiplataforma debes tener en cuenta no utilizar o manipular el DOM directamente, facil decir pero a veces complicado implementar.

En casos extremos donde estás obligado a utilizar el DOM puede que ayas considerado utilizar !!window condición que dará true en web y cuando utilices react-native dara false. En muchos casos puede ser la solución pero si tienes acceso a la configuración de tu proyecto intenta configurar una variable de entorno !!process.env.REACT_DOM de esta forma toma la responsabilidad de tu código y no de la ausencia de la variable window.

Por último les dejo este video muy util y con buenos consejos y prácticas.

Video de Leland Richardson (AirBnb)
React as a Platform: A path towards a truly cross-platform UI - Leland Richardson

APRENDAMOS DE LOS ERRORES DE OTROS !

vudduu

A la hora de estructurar folders y archivos en tu proyecto seguro te haz preguntado que tan amigable es el nombre que escogiste y algunas veces te preguntaras si alguien que está entrando a tu proyecto podrá entender la estructura y encontrar las diferentes secciones de la aplicación.

https://reactjs.org/docs/faq-structure.html nos algunas pautas de como debemos organizarnos y al mismo tiempo si utilizamos create-react-app nos dara una estructura inicial que es muy común en los proyectos en React dando a todos los desarrolladores una fácil detección de ciertas areas de codigo.

A la hora de nombrar nuestras carpetas debemos considerar esta regla o al menos intentar nombrar nuestros archivos con una clara idea de lo que contienen eslint-plugin-filenames.

Ahora hablemos de LIFT una serie de buenas practicas a la hora de elegir nombres de archivos, carpetas y la estructura general de la applicacion.

L — locating code is easy
I — identify code at a glance
F — flat structure as long as we can
T — try to stay DRY

LIFT siempre debe estar en nuestro pensamiento a la hora de crear nuevos archivos y folders. Estas de acuerdo ?

vudduu

Win a trip around the world based on an algorithm you write!

Type: NP-hard problem

CONTEST PAGE: https://kiwi2018.sphere-contest.com/

vudduu

Las listas son una de las estructuras básicas para resolver problemas implementando algoritmos.

A continuación un ejemplo del uso basico de una lista.

#include <iostream>
#include <list>

int main () {
  int arrayInts[] = { 75, 23, 65, 42, 13 };

  // crea una lista a partir del array
  std::list<int> milista (arrayInts, arrayInts + 5);

  milista.push_back(10); // aumenta el numero 10 a la milista.

  std::cout << "milista contiene:";

  // crea un iterador para recorrer milista.
  std::list<int>::iterator it;
  // milista.begin() retorna un iterador apuntando al inicio de milista.
  // milista.end() retorna un iterador apuntando al final de milista.
  for (it = milista.begin(); it != milista.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';
}

El anterior código imprime como resultado en consola:
milista contiene: 75 23 65 42 13 10

Por el momento no vimos ninguna diferencia entre una lista y un vector o array, pero las listas tienen una gran ventaja a la hora de insertar nuevos números en medio de la lista y también a hora de eliminar números en la lista.

La complejidad para insertar un número es de $O(1)$ pero es necesario tener un iterador en el lugar donde necesitas insertar el número entonces si necesitas llegar desde el inicio de la lista buscando un numero en especial necesitarás $O(p)$ pasos utilizando un it++ para ir avanzando.

Al igual que insertar para eliminar un valor es necesario un iterador ya que una lista no tiene índices al igual que un array pero si ya estas apuntando al nodo que necesitas eliminar entonces la complejidad será $O(1)$

#include <iostream>
#include <list>
#include <vector>

int main () {
  std::list<int> mylist;
  std::list<int>::iterator it;

  // aca añadimos los valores iniciales
  for (int i=1; i<=5; ++i) mylist.push_back(i); // 1 2 3 4 5

  // begin() retorna un puntero al primer valor    ^
  it = mylist.begin();
  ++it;       // "it" apunta al numero 2             ^

  mylist.insert (it, 10);                       // 1 10 2 3 4 5

  // "it" aun apunta al numero 2                        ^
  mylist.insert (it, 2, 20);                    // 1 10 20 20 2 3 4 5

  --it;       // "it" ahora apunta al segundo 20           ^

  std::vector<int> myvector (2, 30);
  mylist.insert (it,myvector.begin(), myvector.end());
                                                // 1 10 20 30 30 20 2 3 4 5
                                                //               ^
  std::cout << "mylist contiene:";
  for (it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

El anterior código imprime lo siguiente en la consola:
mylist contiene: 1 10 20 30 30 20 2 3 4 5

Cuando utilizo C++ y no recuerdo o necesito buscar algunas estructuras o funciones utilizó cplusplus.com y en este caso los ejemplos fueron una traducción de esta página.

referencias:
cplusplus list

vudduu

Existen dos algoritmos básicos para recorrer un grafo o buscar un nodo en particular, la búsqueda por anchura o BFS y la búsqueda por profundidad o DFS. En este artículo explicaremos la búsqueda por profundidad (DFS).

El algoritmo de la búsqueda por profundidad se puede hacer modificando el anterior (Parte 3.1 BFS) en la parte que usa una cola y usar una pila. Otra forma de implementarla es usando recursividad, a continuación se muestran ambos enfoques así como la rutina para hacer la búsqueda en grafos que no están completamente conectados.

A continuación se presenta el listado con la implementación de la búsqueda por profundidad o DFS. También se ha añadido en la versión recursiva un contador que marca el orden en el que fueron visitados los nodos del grafo, dicho orden es muy útil al implementar otros algoritmos de grafos.

Implementación DFS (usando una pila)

int visitado[1000];
vector<list<int> > grafo(1000);

void DFS(int v) { //v es el nodo de inicio del recorrido
  list<int> pila; //pila de nodos adyacentes
  list<int>::iterator nodo_actual, aux, fin;
  visitado[v] = 1; //marcar como visitado el nodo de inicio
  pila.push_back(v);
  while (!pila.empty()) { //mientras no se vacie la pila de adyacentes
    nodo_actual = pila.back();
    //aqui podriamos marcar el orden en que se visitaron
    pila.pop_back();
    aux = grafo[nodo_actual].begin(); // posicionar iteradores para
                                      // lista adyacente
    fin = grafo[nodo_actual].end();
    while (aux != fin) { //recorrer todos los adyacente al nodo actual
      if (!visitado[*aux]) { //añadir a la pila solo los no visitados
        visitado[*aux] = 1;
        pila.push_back(*aux);
        //aqui podemos añadir código para hacer algo mientras
        //realizamos el recorrido
      }
      aux++; //avanzar al siguiente adyacente del nodo actual
    }
  }
}

Implementacion DFS (recursiva)

int visitado[1000];
vector<list<int> > grafo(1000);

void DFS(int v) {
  list<int>::iterator aux, fin; //iteradores para lista de ady
  visitado[v] = 1; //marcar como visitado
  //aqui se podria marcar el orden en que fueron visitados
  aux = grafo[v].begin(); //posicionar los iteradores para lista de ady
  fin = grafo[v].end();
  while (aux != fin) {
    if (!visitado[*aux])
      DFS(*aux); //no se necesita marcar porque *aux se convierte en v
    aux++; //avanzar al siguiente adyacente de v
  }
}

//esta es la version para grafos que no estan completamente conectados
void DFS2() {
  int i;
  for (int i = 0; i < nvert; i++) //buscar un nuevo nodo de
    if  (!visitado[i])            //inicio que no ha sido visitado
      DFS(i);
}

En esta implementación podrán ver que primero se visitan los nodos o vértices que fueron visitados al final, en este caso los números que se encuentran en la pila tienen como primer número al último que fue ingresado.

0_1537932896697_thomas miller (2).png

Por ejemplo para el grafo de la figura si comenzamos la búsqueda por el nodo cero (0).

0. Inicio DFS(0)
    nodoActual = -1, pila = [0]
1. Sacamos el primer nodo de la pila
    nodoActual = 0, pila = []
2. 0 visitara a DFS(1) y DFS(3)
    nodoActual = 0, pila = [1, 3]
3. Sacamos el primer nodo de la pila
    nodoActual = 3, pila = [1]
4. 3 visitara a DFS(2) y DFS(4)
    nodoActual = 3, pila = [1, 2, 4]
5. Sacamos el primer nodo de la pila
    nodoActual = 4, pila = [1, 2]
6. 4 no visita a ningun nodo
    nodoActual = 4, pila = [1, 2]
7. Sacamos el primer nodo de la pila
    nodoActual = 2, pila = [1]
8. 2 visitara a DFS(4) pero 4 ya fue visitado
    nodoActual = 2, pila = [1]
9. Sacamos el primer nodo de la pila
    nodoActual = 1, pila = []
10. El algoritmo termina por la pila esta vacía

En el caso de la implementación recursiva deberán hacerla correr con un ejemplo de grafo para poder analizar la pila, cuando las funciones se llaman recursivamente verán que no se llama a una sin que termine la última en ser llamada y a su vez esperará hasta que todas las funciones llamadas por la otra función sean terminadas.

#include <iostream>
#include <vector>
#include <list>
using namespace std;

int visitado[1000];
vector<list<int> > grafo(1000);

void DFS(int v) {
  list<int>::iterator aux, fin; //iteradores para lista de ady
  visitado[v] = 1; //marcar como visitado
  //aqui se podria marcar el orden en que fueron visitados
  cout << v << " fue visitado" << endl;
  aux = grafo[v].begin(); //posicionar los iteradores para lista de ady
  fin = grafo[v].end();
  while (aux != fin) { // este ciclo extra esta para imprimir los siguientes nodos
    cout << '\t' << (*aux) << " sera visitado por " << v << endl;
    aux++; //avanzar al siguiente adyacente de v
  }
  aux = grafo[v].begin(); //posicionar los iteradores para lista de ady
  fin = grafo[v].end();
  while (aux != fin) {
    if (!visitado[*aux])
      DFS(*aux); //no se necesita marcar porque *aux se convierte en v
    aux++; //avanzar al siguiente adyacente de v
  }
}

int main() {
  // conectamos el grafo
  grafo[0].push_back(1);
  grafo[0].push_back(3);
  grafo[1].push_back(2);
  grafo[1].push_back(3);
  grafo[2].push_back(4);
  grafo[3].push_back(2);
  grafo[3].push_back(4);
  // llamamos a la funcion DFS
  DFS(0);
}

Para practicar con este tipo de busqueda puedes utlizar uno de los siguientes enlaces:

vudduu

@vudduu

Publicados por vudduu