Algorithms Finding all Armstrong Numbers in a given range In this article, we will develop an approach to find all armstrong numbers in a given range. The approach is to check for each number in the range if it is an armstrong number or not.
Algorithms Split a number into K unique parts such that their GCD is maximum The problem is to split a number N into K unique parts such that the sum of the parts is equal to N and the greatest common divisor of the K parts is maximum. This can be solved in O(N^1/2) time complexity using a greedy approach.
Algorithms Pairs whose sum is divisible by a given number In this article, we explored how we can find the number of pairs whose sum is divisible by a given number K. This can be done using brute force approach in O(N^2) time but an efficient approach can reduce it to O(N) time.
Algorithms Evolution of Integer Multiplication Algorithms (from 1960 with end in 2019) We started with an O(N^2) time Integer Multiplication algorithm and it was the first time ever in 1960 that we developed an faster Integer Multiplication algorithm which ran at O(N^1.58) time and now in 2019, we are nearly at the end of this domain with O(N logN) time algorithm.
Algorithms Research papers on Integer Multiplication (1960 to 2019) hese are the papers that you should read and understand to understand how we have improved Integer Multiplication over the years and now in 2020, we are on the verge of completing this domain once for all.
Algorithms Binary exponentiation (Power in log N) Binary exponentiation is an algorithm to find the power of any number N raise to an number M (N^M) in logarithmic time O(log M). The normal approach takes O(M) time provided multiplication takes constant time.
Algorithms Check if a number is an Armstrong Number An Armstrong number is an integer such that the sum of the digits raised to the power of the number of digits is equal to the number itself. We verify it in O(logN * loglogN) time.
Algorithms Easiest IMO problems that will make you feel like a Genius IMO problems are known to be difficult but we have identified 5 problems which you can solve without using a paper. This will make you feel like a GENIUS
Algorithms Subset of maximum size with no pair sum divisible by 'K' Our focus is to find the subset of largest size in which the sum of elements of a pair is not divisible by K. Using mathematical ideas, we solved it in linear time.
Algorithms Difference between square of sum (Σn)² and sum of squares (Σn²) In this problem, we to need find the difference between the sum of squares of all numbers from 1 to N and the square of the sum of 1 to N. We solved it in constant time.
Algorithms Sum of squares of first N numbers ( Σ n² ) Our focus is to find the sum of the quares of the first N numbers that is from 1 to N. With an insightful equation, we can solve this in constant time O(1).
Algorithms Sum of first N numbers ( Σ n ) In this problem, we will find the sum of the first N integers that is 1 to N. We can solve this in constant time O(1) by using an insightful formula.
Algorithms Smallest number with all numbers from 1 to N as multiples We will find the smallest number that is perfectly divisible by all numbers from 1 to N and used 3 approaches: Brute force O(N^3 * log N), using prime factorization O(N * log N * log N) and using insights into the problem O(N * log log N).
Algorithms Largest palindrome made from product of two 3-digit numbers We will find the largest palindrome that is a product of two three-digit numbers. In brute force, there are 810000 comparisons which we have reduced to 362 computations based on three deep insights.
Algorithms Largest prime factor of a number (Project Euler Problem 3) We need to find the largest prime factor of a given number N. We will bring in some insights and solve this in O(√N log log N) time complexity.
Algorithms Sum of Even Fibonacci Numbers (Project Euler Problem 2) The problem is find the sum of even fibonacci numbers that is fibonacci numbers that are even and is less than a given number N. We will present 3 insightful ideas to solve this efficiently.
Algorithms Sum of multiples of 3 and 5 (Project Euler Problem 1) The problem at hand is to find the sum of all numbers less than a given number N which are divisible by 3 and/ or 5 using a constant time algorithm.
Algorithms Find point of 2D Line Intersection The point of intersection of two 2D lines can be calculated using two algorithms namely Elimination method and Determinant method which takes constant time O(1)
Algorithms Secant Method to find root of any function Secant Method is a numerical method for solving an equation in one unknown. It avoids this issue of Newton’s method by using a finite difference to approximate the derivative.
Algorithms Newton Raphson Method to find root of any function Newton's Method, also known as Newton-Raphson method, named after Isaac Newton and Joseph Raphson, is a popular iterative method to find a good approximation for the root of a real-valued function f(x) = 0.
Algorithms Regula Falsi Method for finding root of a polynomial Regula Falsi method or the method of false position is a numerical method for solving an equation in one unknown. It is quite similar to bisection method algorithm and is one of the oldest approaches.
Algorithms Bisection Method for finding the root of any polynomial Bisection Method for root finding (also called the interval halving method, the binary search method, or the dichotomy method) is based on the Bolzano’s theorem for continuous functions
Algorithms Find all primes with Sieve of Sundaram Sieve of Sundaram is an efficient algorithm used to find all the prime numbers till a specific number say N.
Algorithms Finding the Lexicographical Next Permutation in O(N) time complexity In Lexicographical Permutation Algorithm we will find the immediate next smallest Integer number or sequence permutation. Finding all permutations take O(N!) time complexity but we present an efficient algorithm which can solve this in O(N) time complexity
Algorithms Heap’s algorithm for generating permutations Heap's Algorithm is used to generate all the possible permutation of n-decimals of a number. It generates each permutation from the previous one by interchanging a single pair of elements; the other n−2 elements are not disturbed. For N numbers, it takes O(N!) time complexity
