Interview Reference Materials

gistfile1.txt

Introduction. A couple of minutes about what you’re most interested in and excited about at ava labs and crypto in general.
- Tell me about your previous most exciting task.
- Tell me about a tech project you’ve worked on in your spare time.
- Tell me about NodeJs event loop.
- Implement API to serve crypto prices in NodeJS.

    ───────────────────────────┐
┌─>│           timers          │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │     pending callbacks     │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
│  │       idle, prepare       │
│  └─────────────┬─────────────┘      ┌───────────────┐
│  ┌─────────────┴─────────────┐      │   incoming:   │
│  │           poll            │<─────┤  connections, │
│  └─────────────┬─────────────┘      │   data, etc.  │
│  ┌─────────────┴─────────────┐      └───────────────┘
│  │           check           │
│  └─────────────┬─────────────┘
│  ┌─────────────┴─────────────┐
└──┤      close callbacks      │
   └───────────────────────────┘

ref. https://nodejs.org/en/docs/guides/event-loop-timers-and-nexttick/

# Phases Overview
timers: this phase executes callbacks scheduled by setTimeout() and setInterval().
pending callbacks: executes I/O callbacks deferred to the next loop iteration.

idle, prepare: only used internally.

poll: retrieve new I/O events; execute I/O related callbacks (almost all with the exception of close callbacks, the ones 
scheduled by timers, and setImmediate()); node will block here when appropriate.

check: setImmediate() callbacks are invoked here.

close callbacks: some close callbacks, e.g. socket.on('close', ...).
   

codeshare: https://codeshare.io/

# nodejs
https://github.com/noamsauerutley/breadth-first-search/
https://levelup.gitconnected.com/finding-the-shortest-path-in-javascript-pt-1-breadth-first-search-67ae4653dbec


# Query Planner
# EXPLAIN command
# Inner and Outer Join
What is the difference between partitioning and sharding in PostgreSQL?
An Overview of Sharding & Partitioning | Hazelcast
What Is the Difference between Sharding and Partitioning? Sharding and partitioning are both about breaking up a large data set into smaller subsets. The difference is that sharding implies the data is spread across multiple computers while partitioning does not.

 /* 
 tree
	   10
    /  \
   5    16
  / \   / \
 1   8 12  18 
*/

// javascript representation of the above tree
let tree = {
  /* ? */
};

let BreadthFirstSearch = (tree, root, searchValue) => {};

BFS vs DFS

Params	BFS	DFS
Stands for	BFS stands for Breadth First Search.	DFS stands for Depth First Search.
Data Structure	BFS(Breadth First Search) uses Queue data structure for finding the shortest path.	DFS(Depth First Search) uses Stack data structure.
Definition	BFS is a traversal approach in which we first walk through all nodes on the same level before moving on to the next level.	DFS is also a traversal approach in which the traverse begins at the root node and proceeds through the nodes as far as possible until we reach the node with no unvisited nearby nodes.
Technique	BFS can be used to find a single source shortest path in an unweighted graph because, in BFS, we reach a vertex with a minimum number of edges from a source vertex.	In DFS, we might traverse through more edges to reach a destination vertex from a source.
Conceptual Difference	BFS builds the tree level by level.	DFS builds the tree sub-tree by sub-tree.
Approach used	It works on the concept of FIFO (First In First Out).	It works on the concept of LIFO (Last In First Out).
Suitable for	BFS is more suitable for searching vertices closer to the given source.	DFS is more suitable when there are solutions away from source.
Suitable for	Decision Trees theirwinning	BFS considers all neighbors first and therefore not suitable for decision-making trees used in games or puzzles.
Time Complexity	The Time complexity of BFS is O(V + E) when Adjacency List is used and O(V^2) when Adjacency Matrix is used, where V stands for vertices and E stands for edges.	The Time complexity of DFS is also O(V + E) when Adjacency List is used and O(V^2) when Adjacency Matrix is used, where V stands for vertices and E stands for edges.
Visiting of Siblings/ Children Here	siblings are visited before the children.	Here, children are visited before the siblings.
Removal of Traversed Nodes	Nodes that are traversed several times are deleted from the queue.	The visited nodes are added to the stack and then removed when there are no more nodes to visit.
Backtracking	In BFS there is no concept of backtracking.	DFS algorithm is a recursive algorithm that uses the idea of backtracking
Applications	BFS is used in various applications such as bipartite graphs, shortest paths, etc.	DFS is used in various applications such as acyclic graphs and topological order etc.
Memory	BFS requires more memory.	DFS requires less memory.
Optimality	BFS is optimal for finding the shortest path.	DFS is not optimal for finding the shortest path.
Space complexity	In BFS, the space complexity is more critical as compared to time complexity.	DFS has lesser space complexity because at a time it needs to store only a single path from the root to the leaf node.
Speed	BFS is slow as compared to DFS.	DFS is fast as compared to BFS.
When to use?	When the target is close to the source, BFS performs better.	When the target is far from the source, DFS is preferable.