The ultimate guide to coding interviews. Developed by FAANG engineers. Boost problem-solving skills with number theory, dynamic programming, and graph theory. Get interview-ready in just a few hours.

Competitive Programming - Crack Your Coding Interview.png

Whether you’re gearing up for online coding challenges, code-a-thons, or interviews, then this course is for you. With this course, you will solidify your problem-solving skills ensuring a swift sail through any problem. 


You will be tasked with solving some of the most frequently asked questions that are brought up in FAANG interviews. You will start with the concepts of Number Theory and Divide and Conquer, and gradually move towards more complex problems like dynamic programming and graph theory.


With each problem you solve, there will be insightful explanations and full implementation details to really hammer home the concepts. By the time you finish this course, you will have the confidence to solve any problem, no matter the difficulty.

Competitive Programming - Crack Your Coding Interview, C++

# Problem statement
In this problem, we need to find the result of the multiplication of two numbers, `a` and `b` but without using `*` operator. This looks like a pretty simple problem. We can easily iterate a loop from `1` to `b` and add `a` to our result. But there is a catch: you need to write a solution with a Recursive approach.

# Implementation
Let's write the solution first, and then visualize how recursion is working.

#include <iostream>
using namespace std;

int prod(int a , int b){
    if(b==0){
        return 0;
    }
    else if(b==1){
        return a;
    }
    else if(b>0){
        return a + prod(a,b-1);
    }
    else {
        return -prod(a,-b);
    }
}

int main() {
    int a = 2, b = -3;
    cout << prod(a,b);
    return 0;
}

**Explanation:** 
* On line 4, we define our recursive function `prod()`.
* On line 5, we check for the base case as ${a*0}$ = ${0}$.
* On line 8, we have another base case, i.e., ${a * 1}$ = ${a}$.
* On line 12, we call the function in a recursive manner and reduce the value of `b` by one.
* On line 14, if the value of `b` is negative, we call the function recursively by passing the value of `b` as `-b` and we also return the negative from the function `prod()`.
* In the `main()` function, we just define the values of `a` and `b` and then call our recursive function `prod()`.

Let's now visualize how Recursion is working to solve this problem.

Use Recursion to multiply two numbers without using the * operator.

Overview

Number Theory

Number Theory

Divide and Conquer

Greedy Algorithms

Greedy Algorithms

Recursion and Backtracking

Recursion and Backtracking

Dynamic Programming

Graphs

Bonus Lessons

Multiplication Without Using * Operator

Problem statement