
## Question {#Question}

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have ***exactly one solution***, and you may not use the same element twice.

You can return the answer in any order.

## Examples {#Examples}
1. >**Input**: nums = [2,7,11,15], target = 9\
**Output**: [0,1]\
**Explanation**: Because nums[0] + nums[1] == 9, we return [0, 1].

2. >**Input**: nums = [2,7,11,15], target = 9\
**Output**: [0,1]\
**Explanation**: Because nums[0] + nums[1] == 9, we return [0, 1].

## Code {#Code}
#### C++ {#C++}
```c++
class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        unordered_map<int, int> map;
        for (int i = 0; i < nums.size(); i++) {
            int complement = target - nums[i];
            if (map.find(complement) != map.end()) {
                return { map[complement], i };
            }
            map[nums[i]] = i;
        }
        return {-1, -1}; // or return {};
    }
};
```

#### Java {#Java}
```java
class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        // In case there is no solution, we'll just return null
        return null;
    }
}
```


1. Two Sum


## Question {#Question}

Let's play the minesweeper game

You are given an m x n char matrix board representing the game board where:

'M' represents an unrevealed mine,
'E' represents an unrevealed empty square,
'B' represents a revealed blank square that has no adjacent mines (i.e., above, below, left, right, and all 4 diagonals),
digit ('1' to '8') represents how many mines are adjacent to this revealed square, and
'X' represents a revealed mine.
You are also given an integer array click where click = [clickr, clickc] represents the next click position among all the unrevealed squares ('M' or 'E').

***Return the board after revealing this position according to the following rules :***

If a mine 'M' is revealed, then the game is over. You should change it to 'X'.
If an empty square 'E' with no adjacent mines is revealed, then change it to a revealed blank 'B' and all of its adjacent unrevealed squares should be revealed recursively.
If an empty square 'E' with at least one adjacent mine is revealed, then change it to a digit ('1' to '8') representing the number of adjacent mines.
Return the board when no more squares will be revealed.

## Examples {#Examples}
1. ![image](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_1.png)
>**Input**: board = [["E","E","E","E","E"],["E","E","M","E","E"],["E","E","E","E","E"],["E","E","E","E","E"]], click = [3,0]\
**Output**: [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]\

2. ![image](https://assets.leetcode.com/uploads/2018/10/12/minesweeper_example_2.png)
>**Input**: board = [["B","1","E","1","B"],["B","1","M","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]], click = [1,2]\
**Output**: [["B","1","E","1","B"],["B","1","X","1","B"],["B","1","1","1","B"],["B","B","B","B","B"]]\

## Code {#Code}
#### C++ {#C++}
```c++
class Solution {
public:
    vector<vector<char>> updateBoard(vector<vector<char>>& A, vector<int>& C) {
        int x=C[0],y=C[1];
        int n=A.size();
        int m=A[0].size();
        if(A[x][y]=='M'){
            A[x][y]='X';
            return A;
        }
        vector<int> r={1,1,0,-1,-1,-1,0,1};
        vector<int> c={0,1,1,1,0,-1,-1,-1};
        queue<pair<int,int>> q;
        vector<vector<int>> V(n,vector<int>(m,0));
        q.push({x,y});
        V[x][y]=1;
        
        while(!q.empty()){
            pair<int,int> p=q.front();
            q.pop();
            int cnt=0;
            int x=p.first;
            int y=p.second;
            if(A[x][y]>='1' && A[x][y]<='9'){
                continue;
            }
            for(int k=0;k<8;k++){
                int x1=x+r[k];
                int y1=y+c[k];
                if(x1>=0 && x1<n && y1>=0 && y1<m && A[x1][y1]=='M'){
                    cnt++;
                }
            }
            if(cnt>0){
                A[x][y]='0'+cnt;
                continue;
            }
            A[x][y]='B';
            for(int k=0;k<8;k++){
                int x1=x+r[k];
                int y1=y+c[k];
                if(x1>=0 && x1<n && y1>=0 && y1<m && V[x1][y1]==0){
                    q.push({x1,y1});
                    V[x1][y1]=1;
                }
            }
        }
        return A;
    }
};
```

#### Java {#Java}
```java
class Solution {
    private static final int[][] DIRS = { { 0, 1 }, { 1, 1 }, { 1, 0 }, { 1, -1 }, { 0, -1 }, { -1, -1 }, { -1, 0 }, { -1, 1 } };

    public char[][] updateBoard(char[][] board, int[] click) {
        if (board[click[0]][click[1]] != 'M' && board[click[0]][click[1]] != 'E') {
            return board;
        }
        if (board[click[0]][click[1]] == 'M') {
            board[click[0]][click[1]] = 'X';
            return board;
        }

        int mines = getMinesCount(board, click[0], click[1]);
        if (mines != 0) {
            board[click[0]][click[1]] = (char) (mines + '0');
            return board;
        }
        board[click[0]][click[1]] = 'B';

        Queue<int[]> queue = new LinkedList<>();
        queue.offer(click);
        while (!queue.isEmpty()) {
            int[] cur = queue.poll();
            for (int[] d : DIRS) {
                int x = cur[0] + d[0];
                int y = cur[1] + d[1];
                if (x < 0 || x >= board.length || y < 0 || y >= board[0].length || board[x][y] != 'E') {
                    continue;
                }
                mines = getMinesCount(board, x, y);
                if (mines != 0) {
                    board[x][y] = (char) (mines + '0');
                    continue;
                }
                board[x][y] = 'B';
                queue.offer(new int[] { x, y });
            }
        }

        return board;
    }

    private int getMinesCount(char[][] board, int x, int y) {
        int mines = 0;
        for (int[] d : DIRS) {
            int r = x + d[0];
            int c = y + d[1];
            if (r >= 0 && r < board.length && c >= 0 && c < board[0].length && board[r][c] == 'M') {
                mines++;
            }
        }
        return mines;
    }
}
```


529. Minesweeper


## Question {#Question}

You are given a list of bombs. The range of a bomb is defined as the area where its effect can be felt. This area is in the shape of a circle with the center as the location of the bomb.

The bombs are represented by a 0-indexed 2D integer array bombs where bombs[i] = [xi, yi, ri]. xi and yi denote the X-coordinate and Y-coordinate of the location of the ith bomb, whereas ri denotes the radius of its range.

You may choose to detonate a single bomb. When a bomb is detonated, it will detonate all bombs that lie in its range. These bombs will further detonate the bombs that lie in their ranges.

***Given the list of bombs, return the maximum number of bombs that can be detonated if you are allowed to detonate only one bomb.***

## Examples {#Examples}
1. ![image](https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-3.png)
>**Input**: bombs = [[1,1,5],[10,10,5]]\
**Output**: 1\
**Explanation**: Detonating either bomb will not detonate the other bomb, so the maximum number of bombs that can be detonated is 1.

2. ![image](https://assets.leetcode.com/uploads/2021/11/06/desmos-eg-2.png)
>**Input**: bombs = [[1,2,3],[2,3,1],[3,4,2],[4,5,3],[5,6,4]]\
**Output**: 5\
**Explanation**: 
The best bomb to detonate is bomb 0 because:
> - Bomb 0 detonates bombs 1 and 2. The red circle denotes the range of bomb 0.
> - Bomb 2 detonates bomb 3. The blue circle denotes the range of bomb 2.
> - Bomb 3 detonates bomb 4. The green circle denotes the range of bomb 3.
Thus all 5 bombs are detonated.

## Code {#Code}
#### C++ {#C++}
```c++
#define ll long long int
class Solution {
    public:
    void dfs(vector<vector<int>> &gr,vector<bool> &visited,int &c,int &i) {
        visited[i]=true;
        c++;
        for(int j=0;j<gr[i].size();j++) {
            if(!visited[gr[i][j]])
                dfs(gr,visited,c,gr[i][j]);   
        }
    }

    int maximumDetonation(vector<vector<int>>& bombs) {

        int n=bombs.size();
        vector<vector<int> > gr(n);
        for(int i=0;i<n;i++) {
            ll x1,y1,r1;
            x1=bombs[i][0];
            y1=bombs[i][1];
            r1=bombs[i][2];
            for(int j=0;j<n;j++) {
                if(i!=j) {
                    ll x,y;
                    x=abs(x1-bombs[j][0]);
                    y=abs(y1-bombs[j][1]);
                    if(x*x+y*y<=r1*r1)
                        gr[i].push_back(j);
                }
            }
        }

        int ans=INT_MIN;
        for(int i=0;i<n;i++) {
            int c=0;
            vector<bool> visited(n,false);
            dfs(gr,visited,c,i);
            ans=max(ans,c);
        }

        return ans;
    }
};
```

#### Java {#Java}

```java
class Solution {
    private void dfs(List<List<Integer>> gr, boolean[] visited, int[] c, int i) {
        visited[i] = true;
        c[0]++;
        for (int j : gr.get(i)) {
            if (!visited[j]) {
                dfs(gr, visited, c, j);
            }
        }
    }

    public int maximumDetonation(int[][] bombs) {
        int n = bombs.length;
        List<List<Integer>> gr = new ArrayList<>(n);
        for (int i = 0; i < n; i++) {
            gr.add(new ArrayList<>());
            for (int j = 0; j < n; j++) {
                if (i != j) {
                    long x1 = bombs[i][0];
                    long y1 = bombs[i][1];
                    long r1 = bombs[i][2];
                    long x = bombs[j][0];
                    long y = bombs[j][1];
                    long distanceSq = (x - x1) * (x - x1) + (y - y1) * (y - y1);
                    if (distanceSq <= r1 * r1) {
                        gr.get(i).add(j);
                    }
                }
            }
        }

        int ans = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            int[] c = new int[1];
            boolean[] visited = new boolean[n];
            dfs(gr, visited, c, i);
            ans = Math.max(ans, c[0]);
        }

        return ans;
    }
}
```


2101. Detonate the Maximum Bombs


## Question {#Question}

You are given a positive integer n representing the number of nodes of a Directed Acyclic Graph (DAG). The nodes are numbered from 0 to n - 1 (inclusive).

You are also given a 2D integer array edges, where edges[i] = [fromi, toi] denotes that there is a unidirectional edge from fromi to toi in the graph.

***Return a list answer, where answer[i] is the list of ancestors of the ith node, sorted in ascending order.***

A node u is an ancestor of another node v if u can reach v via a set of edges.

## Examples {#Examples}
1. ![image](https://assets.leetcode.com/uploads/2019/12/12/e2.png)
>**Input**: n = 5, edgeList = [[0,1],[0,2],[0,3],[0,4],[1,2],[1,3],[1,4],[2,3],[2,4],[3,4]]\
**Output**: [[],[0],[0,1],[0,1,2],[0,1,2,3]]\
**Explanation**: \
The above diagram represents the input graph.
> - Node 0 does not have any ancestor.
> - Node 1 has one ancestor 0.
> - Node 2 has two ancestors 0 and 1.
> - Node 3 has three ancestors 0, 1, and 2.
> - Node 4 has four ancestors 0, 1, 2, and 3.

2. ![image](https://assets.leetcode.com/uploads/2019/12/12/e1.png)
>**Input**: n = 8, edgeList = [[0,3],[0,4],[1,3],[2,4],[2,7],[3,5],[3,6],[3,7],[4,6]]\
**Output**: [[],[],[],[0,1],[0,2],[0,1,3],[0,1,2,3,4],[0,1,2,3]]\
**Explanation**: \
The above diagram represents the input graph.
> - Nodes 0, 1, and 2 do not have any ancestors.
> - Node 3 has two ancestors 0 and 1.
> - Node 4 has two ancestors 0 and 2.
> - Node 5 has three ancestors 0, 1, and 3.
> - Node 6 has five ancestors 0, 1, 2, 3, and 4.
> - Node 7 has four ancestors 0, 1, 2, and 3.

## Code {#Code}
#### C++ {#C++}
```c++
class Solution {
public:
    void dfs(vector<vector<int>> &graph,int i,int j,vector<vector<int>> &ans,vector<bool> &vis){
        vis[j]=true;
        for(auto &x:graph[j]){
            if(!vis[x]){
                ans[x].push_back(i);
                dfs(graph,i,x,ans,vis);
            }
            
        }
    }
    vector<vector<int>> getAncestors(int n, vector<vector<int>>& edges) {
        
        vector<vector<int>> ans(n),graph(n);
        for(auto &v:edges){
            graph[v[0]].push_back(v[1]);
        }
        for(int i=0;i<n;i++){
            vector<bool> vis(n);
            dfs(graph,i,i,ans,vis);
        }
        return ans;
    }
};
```

#### Java {#Java}

```java
class Solution {
    boolean[] vis;
    public List<List<Integer>> getAncestors(int n, int[][] edges) {
        List<List<Integer>> res = new ArrayList<>(n);
        
        ArrayList<Integer>[] a = new ArrayList[n];
        for(int i=0;i<n;i++){
            a[i] = new ArrayList<>();
            res.add(new ArrayList<>());
        }
        for(int[] x:edges){
            a[x[1]].add(x[0]);
        }
        for(int i=0;i<n;i++){
            boolean[] vis = new boolean[n];
            vis[i] = true;
            dfs(a,i,res.get(i),vis);
            Collections.sort(res.get(i));
        }
        return res;
    }


    private void dfs(ArrayList<Integer>[] a,int curr, List<Integer> temp,boolean[] vis){
        for(int x:a[curr]){
            if(!vis[x]){
                vis[x] = true;
                temp.add(x);
                dfs(a,x,temp,vis);
            }
        }
    }
}
```


2192. All Ancestors of a Node in a Directed Acyclic Graph


## What is git? {#What-is-git}

Git is a version control system which is maintained on your local system. Git gives us a record for ongoing programming versions. It can be used completely exclusive of any cloud-hosting service i.e. we don’t even need internet to access git.

## Version Control System {#Version-Control-System}

![What is VCS](/BL-1001/vcs.png)

It is a program to keep track of the changes in projects, by tracking or logging the files changes over time. A version control system allows us to review, restore earlier versions and even branching and merging or code.

## What Is GitHub? {#What-Is-GitHub}

GitHub is a cloud-based hosting service that lets us manage Git repositories. It’s an online database that allows you to keep track of and share your Git version control projects outside of your local computer.
Other Git repository hosting services also exist: Eg:- GitLab, BitBucket, and SourceForge

GitHub just takes things a little bit further than Git, offering more functionality and resources, as well as a place online to store and collaborate on projects. And because GitHub is cloud-based, an individual’s Git repositories can be remotely accessed by any authorized person, from any computer, anywhere in the world.

Through GitHub, one can share code with others, giving them the power to make revisions or edits on your various Git branches. This makes it possible for entire teams to coordinate together on single projects in real-time. As changes are introduced, new branches are created, allowing the team to continue to revise the code without overwriting each other's work.

## Conclusion {#Conclusion}

![Diffrence between git and github](/BL-1001/gitVsGithub.webp)

## Why Use a Version Control System? {#Why-Use-a-Version-Control-System}

- Collaboration
- Storing Versions
- Restoring Previous Versions


Understanding the  difference between Git and Github with examples and their main use cases or how they are helpful for the developers.

Understanding Git and Github


## Client Side Rendering {#Client-Side-Rendering}

![Client Side Rendering](/BL-1002/csr.png)

When we talk about client-side rendering,it’s about rendering content in the browser using JavaScript.

So instead of getting all the content from the HTML document itself, a simple HTML document with a JavaScript file in initial loading itself is received, which renders the rest of the site using the browser.

With client-side rendering, the initial page load is naturally a bit slow. However, after that, every subsequent page load is very fast. In this approach, communication with server happens only for getting the run-time data. Moreover, there is no need to reload the entire UI after every call to the server. The client-side framework manages to update UI with changed data by re-rendering only that particular DOM element.

## Server Side Rendering {#Server-Side-Rendering}

![Server Side Rendering](/BL-1002/ssr.png)

In server-side rendering when a user makes a request to a webpage, the server prepares an HTML page by fetching user-specific data and sends it to the user’s machine over the internet. Webpages are generated on your server for every request. This entire process of fetching data from the database, creating an HTML page and serve it to user is known as SSR.

## Static Site Generation {#Static-Site-Generation}

At build time, your app will fetch all the data required and compile it down to static webpages. After a production build is created, every request is going to reuse that statically generated HTML file. This provides the best performance and can easily be cached on a CDN.

## Problems with React.js {#Problems-with-React.js}

React uses Client Side Rendering. With React, nothing gets displayed until all of your JavaScript loads. Your HTML is nearly empty and React injects your content in your HTML with JavaScript.
This leads multiple problems:-

- When the browser is loading the JavaScript, the screen is blank because `<div id="root"></div>` does not show anything. Depending on the size of your JavaScript bundle, this could lead to your visitors staring at a white screen for a couple of seconds.

- Most SEO crawlers do not have JavaScript enabled. DuckDuckGo, Google, Bing and any other search engine would not actually know what is on your website since it requires JavaScript to display the content. You will not be ranked at all on Search Engines.

## Methods for Prerendering using Next.js {#Methods-for-Prerendering-using-Next.js}

Next.js offers `(Server Side Rendering)SSR` and `(Static Site Generation)SSG` using `getStaticProps` and `getServerSideProps`.

### getStaticProps {#getStaticProps}

getStaticProps is a server-side function that will only be called at build time. The build will then use the response from getStaticProps to generate a static webpage.

Since stale data is a problem with static generated pages, there is an option you can set to revalidate your static page and rebuild it if data changes. revalidate: 60 will check your data every 60 seconds and rebuild the page if needed.

Example Use:

```
// This function gets called at build time on server-side.
export async function getStaticProps() {
const res = await fetch('https://.../data');
const data = await res.json();

// By returning { props: data }, the Dashboard component
// will receive `data` as a prop at build time
return {
props: {
data
},
// Check if data changes every 60 seconds.
// Rebuild page if different
revalidate: 60
};
}

// data will be populated at build time by getStaticProps()
export default function Dashboard({ data }) {
return <div>{data}</div>;
}
```

### getServerSideProps {#getServerSideProps}

getServerSideProps is similar to getStaticProps but is called every time the page loads instead of at build time. This ensures that all of your initial data is up to date on every load.

Since this is called on every load, you do not need to revalidate like getStaticProps. This also leads to a slower load time since you are no longer serving a static file, but have to rebuild on every load.

Example Use:

```
// This function gets called at build time on server-side.
export async function getServerSideProps() {
const res = await fetch('https://.../data');
const data = await res.json();

// By returning { props: data }, the Dashboard component
// will receive `data` as a prop at build time
return {
props: {
data
}
};
}

// data will be populated at build time by getServerSideProps()
export default function Dashboard({ data }) {
return <div>{data}</div>;
}
```

## Benefits of using Next.js {#Benefits-of-using-Next.js}

- Search engines can crawl the site for better SEO.
- The initial page load is faster.
  ![nextjs pros and cons](/BL-1002/nextjs-pros-and-cons.png)

**References:**

- <a href="https://nextjs.org/docs/getting-started" target="_blank">Next.js</a>


Difference between different types of rendering techniques and advantage of Next.js over React.js.

Client Vs Server Side Rendering


## Question {#Question}

Santa is still not married. He approaches a marriage bureau and asks them to hurry the process. The bureau checks the list of eligible girls of size N and hands it over to Santa. Santa being conscious about his marriage is determined to find a girl with maximum connections so that he can gather more information about her. Accordingly, he looks to figure out the maximum number of girls (from the list) who know each other to achieve the above purpose.

In order to finalize the girl, he needs to find the Kth prime. Where k = largest group of girls who know each other. Considering Santa's poor knowledge of Maths, he seeks Banta's help for the answer. Now you, a fan of Santa Banta Jokes, take this prestigious opportunity to solve the problem.

In case no of connections is zero, print "-1". Here the connection between girls is represented by a 2-D array g of dimension Mx2, ***where M is the number of connections.***
**Note :**
1. Suppose girl "a" knows girl "b" and girl "b" knows girl "c", then girl "a" also knows girl "c". Transitivity holds here.
2. Consider 1 as a composite number.
3. For precompute function given in the template you just have to complete it and use it wherever required, do not call it again and again, it is already being called by driver function before executing test cases.

## Examples {#Examples}
1. >**Input**: N = 10, M = 6, g = [[1,2],[2,3],[3,4],[4,5],[6,7],[9,10]]\
**Output**: 11\
**Explanation**: \
Here in this graph there are 4 groups.\
In 1st group: (1 -> 2 -> 3 -> 4 -> 5) are there.\
In 2nd group: (6 -> 7) are there.\
In 3rd group: (8) is there.\
In 4th group: (10 -> 9) are there.\
In these 4 group the maximum number of 
value is 5. So, K = 5 and the 5th prime number 
is 11. Return 11.

2. >**Input**: N = 2, M = 1, g = [[1, 2]]\
**Output**: 3\
**Explanation**: \
In this Example there will only be a single group of 2 girls, and hence the value of K is 2, The 2nd prime is 3.

## Code {#Code}
#### C++ {#C++}
```c++
const int maxn=1000001;
int a[maxn+1];	
vector<int> pl={2};

class Solution{
public:
    void precompute(){
    	for(int i=1;i<=maxn;i++)
    	    a[i]=1;
    	
    	a[0]=a[1]=0;
    	
    	for(int i=2;i*i<=maxn;i++){
    		if(a[i]==1){
    			for(int j=i*i;j<=maxn;j+=i){
    				a[j]=0;
    			}
    		}
    	}
    	for(int i=3;i<=maxn;i++)
    	    if(a[i])
    	        pl.push_back(i);
    }
    
    int dfs(int i, vector<vector<int>> &g, vector<int> &vis){
    	vis[i]=1;
    	int cnt=1;
    	for(int x:g[i]){
    		if(!vis[x]){
    			cnt+=dfs(x, g, vis);
    		}
    	}
    	return cnt;
    }
    
    int helpSanta(int n, int m, vector<vector<int>> &g)
    {
        vector<int> vis(n+1, 0);
        int lc=0;
    	for(int i = 0; i <= n; i++){
    		if(!vis[i]){
    			lc=max(lc,dfs(i, g, vis));
    		}
    	}
    	if(lc==1)
    	    return -1;
    	return pl[lc-1];
    }
};
```

#### Java {#Java}

```java
class Complete{
    static ArrayList<Integer> graph[];
    static int cnt;
    static ArrayList<Integer> primes;
    public static void precompute () {
        //Complete the function
        primes=new ArrayList<>();
        int N=3000000;
        boolean v[]=new boolean[N+1];
        Arrays.fill(v,true);
        for(int i=2;i*i<=N;i++){
            if(v[i]){
                for(int j=i*i;j<=N;j+=i){
                    v[j]=false;
                }
            }
        }
        for(int i=2;i<=N;i++){
            if(v[i]){
                primes.add(i);
            }
        }
    }
    // Function for finding maximum and value pair
    public static int helpSanta (int n, int m, int g[][]) {
        graph=new ArrayList[n+1];
        for(int i=0;i<=n;i++){
            graph[i]=new ArrayList<>();
        }
        for(int i=0;i<m;i++){
            graph[g[i][0]].add(g[i][1]);
            graph[g[i][1]].add(g[i][0]);
        }
        boolean v[]=new boolean[n+1];
        int max_connection=0;
        for(int i=1;i<=n;i++){
            if(!v[i]){
                cnt=0;
                dfs(i,v);
                max_connection=Math.max(max_connection,cnt);
            }
        }
        if(max_connection==1)return -1;
        return primes.get(max_connection-1);
    }
    public static void dfs(int s,boolean v[])
    {
        v[s]=true;
        cnt++;
        for(int i:graph[s]){
            if(!v[i]){
                dfs(i,v);  
            }
        }
    }
}
```


1. Santa Banta


## Question {#Question}

Given three stacks S1, S2 & S3 of size N1, N2 & N3 respectively, having only Positive Integers. The task is to find the possible equal maximum sum of the stacks with the removal of top elements allowed. Stacks are represented as an array, and the first index of the array represents the top element of the stack.

## Examples {#Examples}
1. >**Input**: N1 = 3, N2 = 4, N3 = 2, S1 = [4,2,3], S2 = [1,1,2,3], S3= [1,4]\
**Output**: 5\
**Explanation**: We can pop 1 element from the 1st stack, and 2
elements from the 2nd stack. Now remaining elements
yield the equal sum of the three stacks, that is 5.

2. >**Input**:N1 =2, N2 = 1, N3 = 3, S1 = [4,7], S2 = [10], S3 = [1,2,3]\
**Output**: 0\
**Explanation**: We will never get an equal sum after popping some elements, so the answer will be 0.

## Code {#Code}
#### C++ {#C++}
```c++
int maxSum(int stack1[], int stack2[], int stack3[], int n1,
           int n2, int n3)
{
    int sum1 = 0, sum2 = 0, sum3 = 0;
 
    // Finding the initial sum of stack1.
    for (int i = 0; i < n1; i++)
        sum1 += stack1[i];
 
    // Finding the initial sum of stack2.
    for (int i = 0; i < n2; i++)
        sum2 += stack2[i];
 
    // Finding the initial sum of stack3.
    for (int i = 0; i < n3; i++)
        sum3 += stack3[i];
 
    // As given in question, first element is top
    // of stack..
    int top1 = 0, top2 = 0, top3 = 0;
    while (1) {
        // If any stack is empty
        if (top1 == n1 || top2 == n2 || top3 == n3)
            return 0;
 
        // If sum of all three stack are equal.
        if (sum1 == sum2 && sum2 == sum3)
            return sum1;
 
        // Finding the stack with maximum sum and
        // removing its top element.
        if (sum1 >= sum2 && sum1 >= sum3)
            sum1 -= stack1[top1++];
        else if (sum2 >= sum1 && sum2 >= sum3)
            sum2 -= stack2[top2++];
        else if (sum3 >= sum2 && sum3 >= sum1)
            sum3 -= stack3[top3++];
    }
}
```

#### Java {#Java}

```java
class GFG {
      
    // Returns maximum possible equal sum of three
    // stacks with removal of top elements allowed
    public static int maxSum(int N1,int N2,int N3,vector<int> &S1,vector<int> &S2,vector<int> &S3)
    {
      int sum1 = 0, sum2 = 0, sum3 = 0;
       
      // Finding the initial sum of stack1.
      for (int i=0; i < n1; i++)
          sum1 += stack1[i];
      
      // Finding the initial sum of stack2.
      for (int i=0; i < n2; i++)
          sum2 += stack2[i];
      
      // Finding the initial sum of stack3.
      for (int i=0; i < n3; i++)
          sum3 += stack3[i];
      
      // As given in question, first element is top
      // of stack..
      int top1 =0, top2 = 0, top3 = 0;
      int ans = 0;
      while (true)
      {
          // If any stack is empty
          if (top1 == n1 || top2 == n2 || top3 == n3)
             return 0;
      
          // If sum of all three stack are equal.
          if (sum1 == sum2 && sum2 == sum3)
             return sum1;
          
          // Finding the stack with maximum sum and
          // removing its top element.
          if (sum1 >= sum2 && sum1 >= sum3)
             sum1 -= stack1[top1++];
          else if (sum2 >= sum1 && sum2 >= sum3)
             sum2 -= stack2[top2++];
          else if (sum3 >= sum2 && sum3 >= sum1)
             sum3 -= stack3[top3++];
       }
    }
}
```


Explore Learn Build 🚀