Algorithms Count total set bits in all numbers from 1 to N We have presented an efficient approach to find the total number of set bits in all numbers from 1 to N in O(logN) time by deriving a pattern and a formula.

Algorithms Integer Factorization Algorithms We have explored in great detail some of the different factorization algorithms for Integers such as Trial Division, Pollard's rho algorithm, Dixon's algorithm and Quadratic Sieve.

Algorithms Longest Increasing Consecutive Subsequence We have to find the Longest Increasing Consecutive Subsequence in N elements. We can solve this problem efficiently using Dynamic Programming in O(N) time.

Algorithms Find Peak Element in an Array We have explained the problem of finding Peak Element in an Array along with different approaches to solve it efficiently.

Data Structures Design data structure that support insert, delete and get random operations We will understand in depth the designing of a data structure that supports "insert value", "delete value" and "get random" operations where these tasks are performed in constant time O(1).

Algorithms Majority Element in an array We have discussed algorithmic techniques to find the majority element in an array. The brute force algorithm takes O(N^2) time while the most efficient algorithm can do it in O(N) time.

Algorithms Applications of XOR operation We will begin with a brief introduction of what the XOR operation is, followed by its syntax in C++ and its applications such as memory-optimized doubly linked lists, swapping, XOR ciphers, Comparing two values, Gray codes and Partiy check.

Algorithms Adding 2 integers as linked lists We will represent an Integer as Singly Linked List and define an addition algorithm to add two integers as Linked Lists. This is used to add very large integers which is not stored in existing data types.

Graph Algorithms 100+ Graph Algorithms and Techniques [Complete List] We have listed 100+ problems on Graph data structure, Graph Algorithms, related concepts, Competitive Programming techniques and Algorithmic problems.

Algorithms Swap 2 variables [6+ techniques] We have explored about Swapping of 2 variables. We have presented different methods to do so including swapping using third variable, using arithmetic operations, XOR, macro and much more along with their pros and cons.

Algorithms Two Pointer Technique in Array We have explained the Two Pointer Technique in array which is used to solve a vast range of problems efficiently. Problems include Reversing an array and Find if a pair with given sum exists in a sorted array.

Algorithms Block Swap Algorithm [for Array Rotation] This article discusses Block Swap Algorithm. It is used to rotate an array by any number of positions with a Time Complexity of O(N) and Space Complexity of O(1).

C++ Static and extern pointers in C/ C++ Static and extern are storage classes in C which defines scope and life-time of a variable. Similar to any variables in C, we can use these keywords with pointers for different use cases.

Algorithms Move even number to front of array We have explained two efficient approaches to Move even number to front of array using Hoare's Partition and Lomuto Partition.

Algorithms Two Sum Problem in Binary Search Tree We have solved the Two Sum Problem in Binary Search Tree using three different approaches involving Depth First Search, Inorder Traversal and Augmented Binary Search Tree.

Culture "Time Complexity Analysis" book "Time Complexity Analysis" is a book focused on Mathematical Analysis of Time and Space Complexity of various algorithms and data structures along with basics of Time Complexity like Big-O notations.

Algorithms Longest Common Suffix Problem In this article, we will see how we can find the longest common suffix (i.e ending) that all the strings given to us have. We shall start with the brute-force approach for two strings. Following this, we will implement the Trie data structure to solve the problem for more than two strings.

Algorithms Lempel Ziv Welch compression and decompression In this article, we will learn about the Lempel Ziv Welch compression and decompression algorithm, a famous compression technique that is widely used in Unix systems and GIF format files

Algorithms Lomuto Partition Scheme We have explained the Lomuto partition scheme, which is used in the famous Quicksort algorithm. It is an algorithm to partition an array into two parts based on a given condition.

Algorithms Multiplication using bitwise operations We have explained how to compute Multiplication using Bitwise Operations. We can solve this using left shift, right shift and negation bitwise operations.

Algorithms Inside Outside Test [2 algorithms: Even-Odd and Winding Number] In Computer Graphics, Inside Outside is performed to test whether a given point lies inside of a closed polygon or not. Mainly, there are two methods to determine a point is interior/exterior to polygon: Even-Odd / Odd-Even Rule or Odd Parity Rule and Winding Number Method.

Algorithms Invert / Reverse a Binary Tree [3 methods] Inverting a binary tree is one of the most common questions asked in the interviews of many companies. In this article, we will see in detail as to how one can understand and tackle this task of inverting a binary tree using recursion, stack and queue.

Algorithms Construct BST from pre-order traversal (using monotonic stack; no recursion) This article discusses on a way in which, Binary Search Tree (BST) can be reconstructed when corresponding pre-order traversal of the tree is input, using a concept of monotonic stack.

Algorithms Why O(1) time complexity does not exist? + Memory Model We have taken an in-depth look at the operations or algorithms that have a constant time in terms of asymptotic notation of time complexities. Is O(1) really a practical way of representing the time complexity of certain algorithms/ operations?

Algorithms Reversal Algorithm to rotate an array We have discussed Reversal algorithm. It is widely used for rotating arrays. This algorithm is specifically useful for rotating array by any number of places because it efficiently does the operation in O(N) time and O(1) auxiliary space.