├── Advanced Recursion
    ├── Merge Sort Code.cpp
    ├── Print Keypad combination code.cpp
    ├── Print Keypad combination code2.cpp
    ├── Quick sort code.cpp
    ├── Remove duplicates Recursively.cpp
    ├── Replace Characters recursively.cpp
    └── Return keypad code.py
├── Assignment Backtracking and searching and sorting applications
    ├── Collecting the balls.cpp
    ├── Collecting the balls.exe
    ├── Find power of a number.cpp
    ├── Sudoku solver.cpp
    └── sorting the skills.py
├── Backtracking
    ├── Crossword Problem.cpp
    ├── Nqueen.cpp
    └── Rat in a maze problem.cpp
├── Basics of recursion
    ├── check numbers.py
    ├── check numbers.txt
    ├── first index of number.py
    ├── first index of number.txt
    ├── number of digits.py
    ├── number of digits.txt
    ├── power.py
    ├── power.txt
    ├── print numbers.py
    ├── print numbers.txt
    ├── sum of array.py
    └── sum of array.txt
├── Bit manipulation
    ├── Clear all bits from msb.cpp
    ├── Set ith bit.cpp
    ├── Turn off first set bit.cpp
    ├── find 1st set bit.cpp
    └── unset ith bit.cpp
├── Greedy problems
    └── Minimum absolute difference in array.cpp
├── Language Tools
    ├── Diffrent Names.cpp
    ├── Diffrent Names.txt
    ├── Extract unique characters.py
    ├── Extract unique characters.txt
    ├── Love for Characters.py
    ├── Love for Characters.txt
    ├── Tell the position.cpp
    ├── Tell the position.txt
    ├── Warm reception.cpp
    └── Warm reception.txt
├── Language tools and time complexity assignment
    ├── Duplicate the array.cpp
    ├── Duplicate the array.txt
    ├── Find the Unique element.cpp
    ├── Find the Unique element.txt
    ├── Longest consecutive subsequence.cpp
    ├── Longest consecutive subsequence.txt
    ├── Pair sum to zero.cpp
    ├── Pair sum to zero.txt
    ├── Rotate array.cpp
    ├── Rotate array.txt
    ├── Sum me up.cpp
    ├── Sum me up.txt
    ├── Triplet sum.cpp
    ├── Triplet sum.txt
    └── triplet sum 2.cpp
├── Prerequisites
    ├── Even and Odd indices.cpp
    ├── Even and odd indices.txt
    ├── Oscillating prices of chakri.py
    ├── Oscillating prices of chakri.txt
    ├── PRE3.py
    ├── PRE4.py
    ├── PRE4.txt
    ├── PREQ3.txt
    ├── Target marbles.txt
    └── target marbles.cpp
├── README.md
├── Searching and sorting applications
    ├── Aggressive cows problem.cpp
    ├── Aggressive cows problem.txt
    ├── Distribute Candies.cpp
    ├── Inversion count.txt
    ├── Momos Market.cpp
    ├── Murder.cpp
    ├── Murder.txt
    ├── Taj mahal entry.py
    └── inversion count.cpp
├── _config.yml
├── miserman.cpp
├── miserman.exe
└── segment tree
    └── maximum sum in subarray.cpp


/Advanced Recursion/Merge Sort Code.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Merge Sort Code
 3 | Send Feedback
 4 | Sort an array A using Merge Sort.
 5 | Change in the input array itself. So no need to return or print anything.
 6 | Input format :
 7 | Line 1 : Integer n i.e. Array size
 8 | Line 2 : Array elements (separated by space)
 9 | Output format :
10 | Array elements in increasing order (separated by space)
11 | Constraints :
12 | 1 <= n <= 1000
13 | Sample Input:
14 | 6 
15 | 2 6 8 5 4 3
16 | Sample Output:
17 | 2 3 4 5 6 8
18 | */
19 | 
20 | void merge(int input[], int start, int mid, int end){
21 |     int n1 = mid - start + 1;
22 |     int n2 = end-mid;
23 |     int L[n1];
24 |     int R[n2];
25 |     
26 |     int i = 0;
27 |     int j = 0;
28 |     int k = start;
29 |     for(i = 0; i < n1; i++){
30 |         L[i] = input[k];
31 |         k++;
32 |     }
33 |     for(j = 0; j < n2; j++){
34 |         R[j] = input[k];
35 |         k++;
36 |     }
37 |     i = 0;
38 |     j = 0;
39 |     k = start;
40 |     
41 |     while(i < n1 && j < n2){
42 |         if(L[i]<R[j]){
43 |             input[k] = L[i];
44 |             i++;
45 |             k++;
46 |         } else {
47 |             input[k] = R[j];
48 |             j++;
49 |             k++;
50 |         }
51 |     }
52 |     while(i<n1){
53 |         input[k] = L[i];
54 |         i++;
55 |         k++;
56 |     }
57 |     while(j<n2){
58 |         input[k] = R[j];
59 |         j++;
60 |         k++;
61 |     }
62 | }
63 | 
64 | 
65 | void _mergeSort(int input[], int first, int last){
66 |     if(first >= last){
67 |         return;
68 |     }
69 |     int mid = (first+last)/2;
70 |     _mergeSort(input, first, mid);
71 |     _mergeSort(input, mid + 1, last);
72 |     merge(input, first, mid, last);
73 | }
74 | 
75 | void mergeSort(int input[], int size){
76 |     _mergeSort(input,0,size-1);
77 |     return;
78 | }
79 | 
80 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Print Keypad combination code.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print Keypad Combinations Code
 3 | Send Feedback
 4 | Given an integer n, using phone keypad find out and print all the possible strings that can be made using digits of input n.
 5 | Note : The order of strings are not important. Just print different strings in new lines.
 6 | Input Format :
 7 | Integer n
 8 | Output Format :
 9 | All possible strings in different lines
10 | Constraints :
11 | 1 <= n <= 10^6
12 | Sample Input:
13 | 23
14 | Sample Output:
15 | ad
16 | ae
17 | af
18 | bd
19 | be
20 | bf
21 | cd
22 | ce
23 | cf
24 | */
25 | 
26 | #include <iostream>
27 | #include <string>
28 | using namespace std;
29 | string dir[]={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
30 | 
31 | void print(int num,string output)
32 | {
33 |     if(num==0)
34 |     {
35 |         cout<<output<<endl;
36 |     }
37 |   int recall=num/10;
38 |     int combo=num%10;
39 |      for(int i=0;i<dir[combo].size();i++)
40 |     {
41 |         //dir element to be inserted at the first of output string
42 |          
43 |           print(recall,dir[combo][i]+output);
44 |     
45 |     }
46 | }
47 | void printKeypad(int num){
48 |     string output="";
49 |     print(num,output);
50 |    
51 |     
52 | }
53 | 
54 | 
55 | 
56 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Print Keypad combination code2.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Print Keypad Combinations Code
 3 | Send Feedback
 4 | Given an integer n, using phone keypad find out and print all the possible strings that can be made using digits of input n.
 5 | Note : The order of strings are not important. Just print different strings in new lines.
 6 | Input Format :
 7 | Integer n
 8 | Output Format :
 9 | All possible strings in different lines
10 | Constraints :
11 | 1 <= n <= 10^6
12 | Sample Input:
13 | 23
14 | Sample Output:
15 | ad
16 | ae
17 | af
18 | bd
19 | be
20 | bf
21 | cd
22 | ce
23 | cf
24 | */
25 | 
26 | #include <iostream>
27 | #include <string>
28 | using namespace std;
29 | 
30 | 
31 | string getString(int n){
32 |   if(n==1){
33 |     return "";
34 |   }
35 |   if(n==2){
36 |     return "abc";
37 |   }
38 |   if(n==3){
39 |     return "def";
40 |   }
41 |   if(n==4){
42 |     return "ghi";
43 |   }
44 |   if(n==5){
45 |     return "jkl";
46 |   }
47 |   if(n==6){
48 |     return "mno";
49 |   }
50 |   if(n==7){
51 |     return "pqrs";
52 |   }
53 |   if(n==8){
54 |     return "tuv";
55 |   }
56 |   if(n==9){
57 |     return "wxyz";
58 |   }
59 | }
60 | 
61 | void printkeypadUtil(int num,string output){
62 |   if(num==0){
63 |     cout<<output<<endl;
64 |     return;
65 |   }
66 |   int smallNum = num/10;
67 |   int remainder = num%10;
68 |   string option = getString(remainder);
69 |   for(int i = 0;i<option.length();i++){
70 | //    printkeypadUtil(smallNum,output);
71 |     printkeypadUtil(smallNum,option[i] + output);
72 |   }
73 | }
74 | 
75 | void printKeypad(int num){
76 |   printkeypadUtil(num,"");
77 | }
78 | 
79 | 
80 | 
81 | 
82 | 
83 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Quick sort code.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Quick Sort Code
 3 | Send Feedback
 4 | Sort an array A using Quick Sort.
 5 | Change in the input array itself. So no need to return or print anything.
 6 | Input format :
 7 | Line 1 : Integer n i.e. Array size
 8 | Line 2 : Array elements (separated by space)
 9 | Output format :
10 | Array elements in increasing order (separated by space)
11 | Constraints :
12 | 1 <= n <= 1000
13 | Sample Input:
14 | 6 
15 | 2 6 8 5 4 3
16 | Sample Output:
17 | 2 3 4 5 6 8
18 | 
19 | */
20 | 
21 | void swap(int *a,int *b){
22 |   int temp = *a;
23 |   *a = *b;
24 |   *b = temp;
25 | }
26 | 
27 | int partition(int input[], int low, int high){
28 |     int pivot = input[high];
29 |     int i = low-1;
30 |     for(int j = low; j<=high-1; j++){
31 |         if(input[j] <= pivot ){
32 |             i++;
33 |             swap(&input[i], &input[j]);
34 |         }
35 |     }
36 |     swap(&input[i+1], &input[high]);
37 |     return i+1;
38 | }
39 | 
40 | void _quickSort(int input[], int start, int end){
41 |     if(start<end){
42 |         int pi = partition(input, start, end);
43 |         _quickSort(input, start, pi -1);
44 |         _quickSort(input, pi+1, end); 
45 |     }
46 | }
47 | 
48 | 
49 | void quickSort(int input[], int size) {
50 |     _quickSort(input, 0, size-1);
51 | }
52 | 
53 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Remove duplicates Recursively.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Remove Duplicates Recursively
 3 | Send Feedback
 4 | Given a string S, remove consecutive duplicates from it recursively.
 5 | Input Format :
 6 | String S
 7 | Output Format :
 8 | Output string
 9 | Constraints :
10 | 1 <= Length of String S <= 10^3
11 | Sample Input :
12 | aabccba
13 | Sample Output :
14 | abcba
15 | */
16 | 
17 | void removeConsecutiveDuplicates(char *input) {
18 |    
19 |     if(input[0] == '\0'){
20 |         return;
21 |     }
22 |     if(input[0]==input[1]){
23 |         int i = 0;
24 |         for(; input[i]!= '\0'; i++){
25 |             input[i] = input[i+1];
26 |         }
27 |         input[i] = '\0';
28 |         removeConsecutiveDuplicates(input);
29 |     }    
30 |     removeConsecutiveDuplicates(input+1);
31 | }
32 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Replace Characters recursively.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Replace Character Recursively
 3 | Send Feedback
 4 | Given an input string S and two characters c1 and c2, you need to replace every occurrence of character c1 with character c2 in the given string.
 5 | Do this recursively.
 6 | Input Format :
 7 | Line 1 : Input String S
 8 | Line 2 : Character c1 and c2 (separated by space)
 9 | Output Format :
10 | Updated string
11 | Constraints :
12 | 1 <= Length of String S <= 10^6
13 | Sample Input :
14 | abacd
15 | a x
16 | Sample Output :
17 | xbxcd
18 | */
19 | void replaceCharacter(char input[], char c1, char c2) {
20 |     if(input[0] == '\0'){
21 |         return;
22 |     }
23 |     if(input[0] == c1){
24 |         input[0] = c2;
25 |     }
26 |     replaceCharacter(input + 1, c1, c2);
27 | }
28 | 


--------------------------------------------------------------------------------
/Advanced Recursion/Return keypad code.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Return Keypad Code
 3 | Send Feedback
 4 | Given an integer n, using phone keypad find out all the possible strings that can be made using digits of input n.
 5 | Return empty string for numbers 0 and 1.
 6 | Note : The order of strings are not important.
 7 | Input Format :
 8 | Integer n
 9 | Output Format :
10 | All possible strings in different lines
11 | Constraints :
12 | 1 <= n <= 10^6
13 | Sample Input:
14 | 23
15 | Sample Output:
16 | ad
17 | ae
18 | af
19 | bd
20 | be
21 | bf
22 | cd
23 | ce
24 | cf
25 | '''
26 | 
27 | def keypad(n):
28 |   opt = ["","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"]
29 |   if(n==0):
30 |     lst = [""]
31 |     return lst
32 |   
33 |   small = n//10
34 |   remainder = n%10
35 |   lst = keypad(small)
36 |   lstlen = len(lst)
37 |   optionlen = len(opt[remainder])
38 |   lst *= optionlen
39 |   k = 0
40 |   for i in range(0,optionlen):
41 |     for j in range(0,lstlen):
42 |       lst[k] = lst[k] + opt[remainder][i]
43 |       k+=1
44 |   return lst
45 | 
46 | 
47 | t = int(input())
48 | print(t)
49 | l = keypad(t)
50 | 
51 | for a in l:
52 |   print(a)
53 | 


--------------------------------------------------------------------------------
/Assignment Backtracking and searching and sorting applications/Collecting the balls.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/Assignment Backtracking and searching and sorting applications/Collecting the balls.cpp


--------------------------------------------------------------------------------
/Assignment Backtracking and searching and sorting applications/Collecting the balls.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/Assignment Backtracking and searching and sorting applications/Collecting the balls.exe


--------------------------------------------------------------------------------
/Assignment Backtracking and searching and sorting applications/Find power of a number.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Find power of a number
 3 | Send Feedback
 4 | Write a program to find x to the power n (i.e. x^n). Take x and n from the user. You need to print the answer.
 5 | Input format :
 6 | Two integers x and n (separated by space)
 7 | Output Format :
 8 | x^n (i.e. x raise to the power n)
 9 | Sample Input 1 :
10 |  3 4
11 | Sample Output 1 :
12 | 81
13 | Sample Input 2 :
14 |  2 5
15 | Sample Output 2 :
16 | 32
17 | 
18 | */
19 | 
20 | 
21 | #include<iostream>
22 | using namespace std;
23 | 
24 | 
25 | int function(int x,int n){
26 |   if(n<=1){
27 |     return x;
28 |   }
29 |   else {
30 |     return x*function(x,n-1);
31 |   }
32 | }
33 | 
34 | int main() {
35 | 	// Write your code here
36 | 	int x,n;
37 |   cin>>x>>n;
38 |   int result = function(x,n);
39 |   cout<<result;
40 | }
41 | 
42 | 


--------------------------------------------------------------------------------
/Assignment Backtracking and searching and sorting applications/Sudoku solver.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Sudoku Solver
 3 | Send Feedback
 4 | Given a 9*9 sudoku board, in which some entries are filled and others are 0 (0 indicates that the cell is empty), you need to find out whether the Sudoku puzzle can be solved or not i.e. return true or false.
 5 | Input Format :
 6 | 9 Lines where ith line contains ith row elements separated by space
 7 | Output Format :
 8 |  true or false
 9 | Sample Input :
10 | 9 0 0 0 2 0 7 5 0 
11 | 6 0 0 0 5 0 0 4 0 
12 | 0 2 0 4 0 0 0 1 0 
13 | 2 0 8 0 0 0 0 0 0 
14 | 0 7 0 5 0 9 0 6 0 
15 | 0 0 0 0 0 0 4 0 1 
16 | 0 1 0 0 0 5 0 8 0 
17 | 0 9 0 0 7 0 0 0 4 
18 | 0 8 2 0 4 0 0 0 6
19 | Sample Output :
20 | true
21 | */
22 | 
23 | bool FindUnassignedLocation(int grid[9][9], int &row, int &col);
24 | bool isSafe(int grid[9][9], int row, int col, int num);
25 |  
26 | 
27 | bool sudokuSolver(int grid[][9]){
28 |     int row,col;
29 |     if(!FindUnassignedLocation(grid,row,col)){
30 |         return true;
31 |     }
32 |     for(int num=1;num<=9;num++){
33 |         if(isSafe(grid,row,col,num)){
34 |             grid[row][col] = num;
35 |             if(sudokuSolver(grid)){
36 |                 return true;
37 |             }
38 |             else {
39 |                 grid[row][col]=0;
40 |             }
41 |         }
42 |     }
43 |     return false;
44 | }
45 | 
46 | bool FindUnassignedLocation(int grid[9][9], int &row, int &col){
47 |     for(row=0;row<9;row++){
48 |         for(col=0;col<9;col++){
49 |             if(grid[row][col]==0){
50 |                 return true;
51 |             }
52 |         }
53 |     }
54 |     return false;
55 | }
56 | 
57 | bool UsedInRow(int grid[9][9], int row, int num)
58 | {
59 |     for (int col = 0; col < 9; col++)
60 |         if (grid[row][col] == num)
61 |             return true;
62 |     return false;
63 | }
64 | 
65 | bool UsedInCol(int grid[9][9], int col, int num)
66 | {
67 |     for (int row = 0; row < 9; row++)
68 |         if (grid[row][col] == num)
69 |             return true;
70 |     return false;
71 | }
72 | 
73 | bool UsedInBox(int grid[9][9], int boxStartRow, int boxStartCol, int num)
74 | {
75 |     for (int row = 0; row < 3; row++)
76 |         for (int col = 0; col < 3; col++)
77 |             if (grid[row+boxStartRow][col+boxStartCol] == num)
78 |                 return true;
79 |     return false;
80 | }
81 | 
82 | bool isSafe(int grid[9][9], int row, int col, int num)
83 | {
84 |     return !UsedInRow(grid, row, num) && !UsedInCol(grid, col, num) &&
85 |            !UsedInBox(grid, row - row % 3 , col - col % 3, num);
86 | }
87 | 


--------------------------------------------------------------------------------
/Assignment Backtracking and searching and sorting applications/sorting the skills.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Sorting the Skills
 3 | Send Feedback
 4 | There is a company named James Peterson & Co. The company has ‘n’ employees. The employees have skills from 0 to n-1. All the employees have distinct skills. The manager of James Peterson & Co. wants to sort the employees on the basis of their skills in ascending order. He is only allowed to swap two employees which are adjacent to each other. He is given the skills of employees in an array of size ‘n’. He can swap the skills as long as the absolute difference between their skills is 1. You need to help the manager out and tell whether it is possible to sort the skills of employees or not.
 5 | Input Format:
 6 | First Line will have an integer ‘t’ denoting the no. of test cases.
 7 | First line of each test case contains an integer ‘n’ denoting the no. of employees in the company.
 8 | Second line of each test case contains ‘n’ distinct integers in the range [0, n-1].
 9 | Output Format:
10 | For each test case, print “Yes” if it is possible to sort the skills otherwise “No”.
11 | Constraints:
12 | 1 <= t <= 10
13 | 1 <= n <= 10^5
14 | Sample Input:
15 | 2
16 | 4
17 | 1 0 3 2
18 | 3
19 | 2 1 0
20 | 
21 | '''
22 | t = int(input())
23 | while t:
24 |   t-=1
25 |   flag = True
26 |   l = int(input())
27 |   ar = list(map(int,input().split()))
28 |   for idx,a in enumerate(ar):
29 |     if a<=(idx+1) and a>=(idx-1):
30 |       pass
31 |     else:
32 |       flag = False
33 |       break
34 |   if flag:
35 |     print("Yes")
36 |   else:
37 |     print("No")
38 | 


--------------------------------------------------------------------------------
/Backtracking/Crossword Problem.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | 
  3 | Crossword Problem
  4 | Send Feedback
  5 | CodingNinjas has provided a crossword of 10*10 grid. The grid contains '+' or '-' as its cell values. Now, you are also provided with word list which needs to placed accurately in the grid. Cells marked with '-' are to be filled with word list.
  6 | For example: The following is an example for the input crossword grid and the word list.
  7 | +-++++++++
  8 | +-++-+++++
  9 | +-------++
 10 | +-++-+++++
 11 | +-++-+++++
 12 | +-++-+++++
 13 | ++++-+++++
 14 | ++++-+++++
 15 | ++++++++++
 16 | ----------
 17 | CALIFORNIA;NIGERIA;CANADA;TELAVIV
 18 | Output for the given input should be:
 19 | +C++++++++
 20 | +A++T+++++
 21 | +NIGERIA++
 22 | +A++L+++++
 23 | +D++A+++++
 24 | +A++V+++++
 25 | ++++I+++++
 26 | ++++V+++++
 27 | ++++++++++
 28 | CALIFORNIA
 29 | Note: We have provided such test cases that there is only one solution for the given input.
 30 | Input format:
 31 | The first 10 lines of input contains crossword. Each of 10 lines have a character array of size 10. Input characters are either '+' or '-'.
 32 | Next line of input contains the word list, in which each word is separated by ';'. 
 33 | Output format:
 34 | Print the crossword grid, after placing the words of word list in '-' cells.  
 35 | Sample Test Cases:
 36 | Sample Input 1:
 37 | +-++++++++
 38 | +-++-+++++
 39 | +-------++
 40 | +-++-+++++
 41 | +-++-+++++
 42 | +-++-+++++
 43 | ++++-+++++
 44 | ++++-+++++
 45 | ++++++++++
 46 | ----------
 47 | CALIFORNIA;NIGERIA;CANADA;TELAVIV
 48 | Sample Output 1:
 49 | +C++++++++
 50 | +A++T+++++
 51 | +NIGERIA++
 52 | +A++L+++++
 53 | +D++A+++++
 54 | +A++V+++++
 55 | ++++I+++++
 56 | ++++V+++++
 57 | ++++++++++
 58 | CALIFORNIA
 59 | 
 60 | */
 61 | 
 62 | #include<bits/stdc++.h>
 63 | #include<string>
 64 | 
 65 | using namespace std;
 66 | pair<bool,int> IsVertical(char input[10][10], string name, int n){
 67 |     
 68 |     pair<bool,int> ans;
 69 |     ans.first=false;
 70 |      int j=0;
 71 |     
 72 |     int counter=0;
 73 |     
 74 |     for(int i=0; i<10; i++){
 75 |      
 76 |         if(input[i][n]=='-' || input[i][n]== name[j]){
 77 |         counter++;
 78 |         j++;  
 79 |         
 80 |         if(counter==name.length()){
 81 |             ans.first=true;
 82 |             ans.second=i-counter+1;
 83 |             break;
 84 |         }
 85 |          
 86 |         }
 87 |        
 88 |         else{
 89 |         counter=0;
 90 |         j=0;
 91 |     }
 92 |         }
 93 |     
 94 |     return ans;
 95 | }
 96 |     
 97 |     
 98 |   pair<bool,int> IsHorizontal(char input[10][10],string name, int n){
 99 |     
100 |     pair<bool,int> ans;
101 |     
102 |     ans.first=false;
103 |     
104 |     int j=0;
105 |     
106 |     int counter=0;
107 |     
108 |     for(int i=0; i<10; i++){
109 |     if(input[n][i]=='-' || input[n][i]== name[j] ){
110 |         counter++;
111 |         j++;
112 |         
113 |         if(counter==name.length()){
114 |             ans.first=true;
115 |             ans.second=i-counter+1;
116 |             break;
117 |         }
118 |     }
119 |        
120 |         else{
121 |         counter=0;
122 |         j=0;
123 |     
124 |     } } 
125 |         return ans;
126 |         
127 | }
128 |       
129 |       
130 |         
131 |  void setVertical(char input[10][10], string name, int n, bool helper[10], int start){
132 |      
133 |      for(int i=0; i<name.length(); i++){
134 |         if(input[n][start+i]==name[i]){
135 |              i++;
136 |          }
137 |          input[i+start][n]=name[i];
138 |          helper[i+start]=true;
139 |      }
140 |      
141 |      
142 |  }
143 |         
144 | void setHorizontal(char input[10][10],string name, int n, bool helper[10], int start){
145 |      
146 |      for(int i=0; i<name.length(); i++){
147 |          if(input[n][start+i]==name[i]){
148 |              i++;
149 |          }
150 |          input[n][start+i]=name[i];
151 |          helper[i+start]=true;
152 |      }
153 |      
154 |      
155 |  }
156 |       
157 |       void resetVertical(char input[10][10],bool helper[10], int n){
158 |           for(int i=0; i<10; i++){
159 |               if(helper[i]==true){
160 |                   input[i][n]='-';
161 |                   helper[i]=false;
162 |               }
163 |           }
164 |       }
165 |         
166 |        void resetHorizontal(char input[10][10],bool helper[10], int n){
167 |           for(int i=0; i<10; i++){
168 |               if(helper[i]==true){
169 |                   input[n][i]='-';
170 |                   helper[i]=false;
171 |               }
172 |           }
173 |       }
174 |         
175 |         
176 | 
177 |        bool crossward(char input[10][10],string* names, int index, int number){
178 |            
179 |            if(index==number){
180 |                return true;
181 |            }
182 |            
183 |            // cout<<index<<number<<" ";
184 |            
185 |            bool helper[10];
186 |            for(int i=0; i<10; i++){
187 |                helper[i]=false;
188 |            }
189 |            
190 |            pair<bool,int> check;
191 |            
192 |            for(int i=0; i<10; i++){
193 |               check=IsVertical(input,names[index],i);
194 |                
195 |                if(check.first==true){
196 |                     
197 |                    setVertical(input,names[index],i,helper,check.second); 
198 |                    if(crossward(input,names,index+1,number)==true){
199 |                        return true;
200 |                    } else{
201 |                        resetVertical(input,helper,i);
202 |                    }
203 |                    
204 |                }
205 |                
206 |            }
207 |            
208 |            
209 |             for(int i=0; i<10; i++){
210 |               check=IsHorizontal(input,names[index],i);
211 |               
212 |                 if(check.first==true){
213 |                    
214 |                     setHorizontal(input,names[index],i,helper,check.second);
215 |                          
216 |              if(crossward(input,names,index+1,number)==true){
217 |                        return true;
218 |                    } else{
219 |                        resetHorizontal(input,helper,i);
220 |                    }
221 |                    
222 |                }
223 |                 
224 |                }
225 |            
226 |           
227 |            return false;
228 |        }
229 |            
230 |            
231 |              
232 |    
233 | 
234 | 
235 | int main() {
236 | 
237 | 	// Write your code here
238 |     
239 |     char input[10][10];
240 |     
241 |     for(int i=0; i<10; i++){
242 |         for(int j=0; j<10; j++){
243 |             cin>>input[i][j];
244 |         }
245 |     }
246 |     
247 |     string names[100];
248 |     
249 |     string input_line;
250 |     
251 |     cin>>input_line;
252 | 
253 |     int k=0;
254 |     
255 |     for(int i=0; input_line[i]!='\0'; i++){
256 |         if(input_line[i]==';'){
257 |             k++;
258 |             i++;
259 |         }
260 |         names[k]=names[k]+input_line[i];
261 |         }
262 |     
263 |     
264 |      bool help= crossward(input,names,0,k+1);
265 |     
266 |     
267 |       for(int i=0; i<10; i++){
268 |         for(int j=0; j<10; j++){
269 |             cout<<input[i][j];
270 |         }
271 |         cout<<endl;
272 |     }    
273 | }
274 | 


--------------------------------------------------------------------------------
/Backtracking/Nqueen.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/Backtracking/Nqueen.cpp


--------------------------------------------------------------------------------
/Backtracking/Rat in a maze problem.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/Backtracking/Rat in a maze problem.cpp


--------------------------------------------------------------------------------
/Basics of recursion/check numbers.py:
--------------------------------------------------------------------------------
 1 | def checkNumber(arr, x):
 2 |     # Please add your code here
 3 |     pass
 4 | 
 5 | # Main
 6 | from sys import setrecursionlimit
 7 | setrecursionlimit(11000)
 8 | n=int(input())
 9 | arr=list(int(i) for i in input().strip().split(' '))
10 | x=int(input())
11 | if checkNumber(arr, x):
12 |     print('true')
13 | else:
14 |     print('false')
15 | 


--------------------------------------------------------------------------------
/Basics of recursion/check numbers.txt:
--------------------------------------------------------------------------------
 1 | Check Number
 2 | 
 3 | Given an array of length N and an integer x, you need to find if x is present in the array or not. Return true or false.
 4 | Do this recursively.
 5 | Input Format :
 6 | Line 1 : An Integer N i.e. size of array
 7 | Line 2 : N integers which are elements of the array, separated by spaces
 8 | Line 3 : Integer x
 9 | Output Format :
10 | true or false
11 | Constraints :
12 | 1 <= N <= 10^3
13 | Sample Input :
14 | 3
15 | 9 8 10
16 | 8
17 | Sample Output :
18 | true


--------------------------------------------------------------------------------
/Basics of recursion/first index of number.py:
--------------------------------------------------------------------------------
 1 | def firstIndex(arr, x, idx):
 2 |     if(idx==len(arr)):
 3 |         return -1
 4 |     if arr[idx]==x:
 5 |         return idx
 6 |     return firstIndex(arr,x, idx+1)
 7 | 
 8 | # Main
 9 | from sys import setrecursionlimit
10 | setrecursionlimit(11000)
11 | n=int(input())
12 | arr=list(int(i) for i in input().strip().split(' '))
13 | x=int(input())
14 | print(firstIndex(arr, x, 0))
15 | 


--------------------------------------------------------------------------------
/Basics of recursion/first index of number.txt:
--------------------------------------------------------------------------------
 1 | First Index of Number
 2 | 
 3 | Given an array of length N and an integer x, you need to find and return the first index of integer x present in the array. Return -1 if it is not present in the array.
 4 | First index means, the index of first occurrence of x in the input array.
 5 | Do this recursively. Indexing in the array starts from 0.
 6 | Input Format :
 7 | Line 1 : An Integer N i.e. size of array
 8 | Line 2 : N integers which are elements of the array, separated by spaces
 9 | Line 3 : Integer x
10 | Output Format :
11 | first index or -1
12 | Constraints :
13 | 1 <= N <= 10^3
14 | Sample Input :
15 | 4
16 | 9 8 10 8
17 | 8
18 | Sample Output :
19 | 1


--------------------------------------------------------------------------------
/Basics of recursion/number of digits.py:
--------------------------------------------------------------------------------
1 | t = input()
2 | print(len(t))
3 | 


--------------------------------------------------------------------------------
/Basics of recursion/number of digits.txt:
--------------------------------------------------------------------------------
 1 | Number of Digits
 2 | 
 3 | Given the code to find out and return the number of digits present in a number recursively. But it contains few bugs, that you need to rectify such that all the test cases should pass.
 4 | Input Format :
 5 | Integer n
 6 | Output Format :
 7 | Count of digits
 8 | Constraints :
 9 | 1 <= n <= 10^6
10 | Sample Input :
11 |  156
12 | Sample Output :
13 | 3


--------------------------------------------------------------------------------
/Basics of recursion/power.py:
--------------------------------------------------------------------------------
 1 | def power(x, n):
 2 |     if n==0:
 3 |         return 1
 4 |     else:
 5 |         return x*power(x,n-1)
 6 |     
 7 | 
 8 | # Main
 9 | from sys import setrecursionlimit
10 | setrecursionlimit(11000)
11 | x, n=list(int(i) for i in input().strip().split(' '))
12 | print(x**n)
13 | 


--------------------------------------------------------------------------------
/Basics of recursion/power.txt:
--------------------------------------------------------------------------------
 1 | Power
 2 | 
 3 | Write a program to find x to the power n (i.e. x^n). Take x and n from the user. You need to return the answer.
 4 | Do this recursively.
 5 | Input format :
 6 | Two integers x and n (separated by space)
 7 | Output Format :
 8 | x^n (i.e. x raise to the power n)
 9 | Constraints :
10 | 1 <= x <= 30
11 | 0 <= n <= 30
12 | Sample Input 1 :
13 |  3 4
14 | Sample Output 1 :
15 | 81
16 | Sample Input 2 :
17 |  2 5
18 | Sample Output 2 :
19 | 32


--------------------------------------------------------------------------------
/Basics of recursion/print numbers.py:
--------------------------------------------------------------------------------
 1 | ## Read input as specified in the question.
 2 | ## Print output as specified in the question.
 3 | 
 4 | def rec(t):
 5 |     if t==1:
 6 |         print(t,end=' ')
 7 |         return
 8 |     else:
 9 |         rec(t-1)
10 |         print(t,end=' ')
11 |         return
12 | 
13 | 
14 | t = int(input())
15 | 
16 | for a in range(t):
17 |     print(a+1,end=' ')
18 | 


--------------------------------------------------------------------------------
/Basics of recursion/print numbers.txt:
--------------------------------------------------------------------------------
 1 | Print Numbers
 2 | 
 3 | Given the code to print number from 1 to n in increasing order recursively. But it contains few bugs, that you need to rectify such that all the test cases should pass.
 4 | Input Format :
 5 | Integer n
 6 | Output Format :
 7 | Numbers from 1 to n (separated by space)
 8 | Constraints :
 9 | 1 <= n <= 10000
10 | Sample Input :
11 |  6
12 | Sample Output :
13 | 1 2 3 4 5 6
14 | 


--------------------------------------------------------------------------------
/Basics of recursion/sum of array.py:
--------------------------------------------------------------------------------
 1 | def sumArray(arr):
 2 |     # Please add your code here
 3 |     pass
 4 | 
 5 | # Main
 6 | from sys import setrecursionlimit
 7 | setrecursionlimit(11000)
 8 | n=int(input())
 9 | arr=list(int(i) for i in input().strip().split(' '))
10 | print(sumArray(arr))
11 | 


--------------------------------------------------------------------------------
/Basics of recursion/sum of array.txt:
--------------------------------------------------------------------------------
 1 | Sum of Array
 2 | 
 3 | Given an array of length N, you need to find and return the sum of all elements of the array.
 4 | Do this recursively.
 5 | Input Format :
 6 | Line 1 : An Integer N i.e. size of array
 7 | Line 2 : N integers which are elements of the array, separated by spaces
 8 | Output Format :
 9 | Sum
10 | Constraints :
11 | 1 <= N <= 10^3
12 | Sample Input :
13 | 3
14 | 9 8 9
15 | Sample Output :
16 | 26


--------------------------------------------------------------------------------
/Bit manipulation/Clear all bits from msb.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Clear All Bits From MSB
 3 | Send Feedback
 4 | You are given two integers N and i. You need to clear all bits from MSB to ith bit (start i from right to left) and return the updated N.
 5 | Counting of bits starts from 0 from right to left.
 6 | Input Format :
 7 | Two integers N and i (separated by space)
 8 | Output Format :
 9 | Updated N
10 | Sample Input 1 :
11 | 15 2
12 | Sample Output 1 :
13 | 3
14 | Sample Output 1 Explanation :
15 | We need to clear all bits from MSB to ith bit i.e. clear all bits except 0th and 1st.
16 | Sample Input 2 :
17 | 4 4
18 | Sample Output 2 :
19 | 4
20 | */
21 | 
22 | 
23 | int clearAllBits(int n, int i){
24 |     /* Don't write main().
25 |      * Don't read input, it is passed as function argument.
26 |      * Return output and don't print it.
27 |      * Taking input and printing output is handled automatically.
28 |      
29 |      00001111	2
30 | >>   00000100
31 | 	 00000011
32 | 
33 | 
34 |  ~   11111011
35 |      00000111
36 |      
37 |      */
38 |   int m = (1<<i)-1;
39 |   
40 |   
41 |  // int m = 1<<i;
42 | //  m = m-1;
43 |   return n&m;
44 | }
45 | 
46 | 
47 | 


--------------------------------------------------------------------------------
/Bit manipulation/Set ith bit.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Set ith bit
 3 | Send Feedback
 4 | You are given two integers N and i. You need to make ith bit of binary representation of N to 1 and return the updated N.
 5 | Counting of bits start from 0 from right to left.
 6 | Input Format :
 7 | Two integers N and i (separated by space)
 8 | Output Format :
 9 | Updated N
10 | Sample Input 1 :
11 | 4 1
12 | Sample Output 1 :
13 | 6
14 | Sample Input 2 :
15 | 4 4
16 | Sample Output 2 :
17 | 20
18 | */
19 | 
20 | int turnOnIthBit(int n, int i){
21 |    int  m = 1<<i;
22 |     return m|n;
23 | }
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/Bit manipulation/Turn off first set bit.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Turn off 1st set bit
 3 | Send Feedback
 4 | You are given an integer Ni. You need to make first set bit of binary representation of N to 0 and return the updated N.
 5 | Counting of bits start from 0 from right to left.
 6 | Input Format :
 7 | Integer N 
 8 | Output Format :
 9 | Updated N
10 | Sample Input 1 :
11 | 4
12 | Sample Output 1 :
13 | 0
14 | Sample Input 2 :
15 | 12 
16 | Sample Output 2 :
17 | 8
18 | */
19 | 
20 | int turnOffFirstSetBit(int n){
21 |     /* Don't write main().
22 |      * Don't read input, it is passed as function argument.
23 |      * Return output and don't print it.
24 |      * Taking input and printing output is handled automatically.
25 |      */
26 |     return n^(n&(-n));
27 | 
28 | }
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/Bit manipulation/find 1st set bit.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Find first set bit
 3 | Send Feedback
 4 | You are given an integer N. You need to return an integer M, in which only one bit is set which at position of lowest set bit of N (from right to left).
 5 | Input Format :
 6 | Integer N
 7 | Output Format :
 8 | Integer M
 9 | Sample Input 1 :
10 | 7
11 | Sample Output 1 :
12 | 1
13 | Sample Input 2 :
14 | 12
15 | Sample Output 2 :
16 | 4
17 | */
18 | 
19 | int returnFirstSetBit(int n){
20 |     /* Don't write main().
21 |      * Don't read input, it is passed as function argument.
22 |      * Return output and don't print it.
23 |      * Taking input and printing output is handled automatically.
24 |      */
25 |     for(int i=0;i<=32;i++){
26 |         if((n&(1<<i))==(1<<i)){
27 |             if(i and not(i & (i-1)))
28 |                 return i+1;
29 |         }
30 |     }
31 |     return 0;
32 | }
33 | 
34 | 
35 | 


--------------------------------------------------------------------------------
/Bit manipulation/unset ith bit.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Unset ith bit
 3 | Send Feedback
 4 | You are given two integers N and i. You need to make ith bit of binary representation of N to 0 and return the updated N.
 5 | Counting of bits start from 0 from right to left.
 6 | Input Format :
 7 | Two integers N and i (separated by space)
 8 | Output Format :
 9 | Updated N
10 | Sample Input 1 :
11 | 7 2
12 | Sample Output 1 :
13 | 3
14 | Sample Input 2 :
15 | 12 1
16 | Sample Output 2 :
17 | 12
18 | */
19 | 
20 | int turnOffIthBit(int n, int i){
21 |     /* Don't write main().
22 |      * Don't read input, it is passed as function argument.
23 |      * Return output and don't print it.
24 |      * Taking input and printing output is handled automatically.
25 |      */
26 |   return n&~(1<<i);
27 |   // or return n^(1<<i)&n;  
28 | }
29 | 
30 | 
31 | 


--------------------------------------------------------------------------------
/Greedy problems/Minimum absolute difference in array.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Min. Absolute Difference In Array
 3 | Send Feedback
 4 | Given an integer array A of size N, find and return the minimum absolute difference between any two elements in the array.
 5 | We define the absolute difference between two elements ai, and aj (where i != j ) is |ai - aj|.
 6 | Input format :
 7 | Line 1 : Integer N, Array Size
 8 | Line 2 : Array elements (separated by space)
 9 | Output Format :
10 | Minimum difference
11 | Constraints :
12 | 1 <= N <= 10^6
13 | Sample Input :
14 | 5
15 | 2 9 0 4 5
16 | Sample Input :
17 | 1
18 | 
19 | */
20 | 
21 | // arr - input array
22 | // n - size of array
23 | #include<bits/stdc++.h>
24 | using namespace std;
25 | int minAbsoluteDiff(int arr[], int n) {
26 |     /* Don't write main().
27 |      * Don't read input, it is passed as function argument.
28 |      * Return output and don't print it.
29 |      * Taking input and printing output is handled automatically.
30 |      */
31 |   sort(arr,arr+n);
32 |   int min = arr[n-1]-arr[0];
33 |   for(int i=1;i<n;i++){
34 |     if(min>(arr[i]-arr[i-1])){
35 |       min = arr[i]-arr[i-1];
36 |     }
37 |   }
38 |   return min;
39 | 
40 | }
41 | 
42 | 


--------------------------------------------------------------------------------
/Language Tools/Diffrent Names.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |   string s;
 6 |   getline(cin,s);
 7 |   long start = 0;
 8 |   map<string,int> m;
 9 |   for(int i = 0;i<s.length();i++){
10 |     //cout<<s[i]<<" ";
11 |     if (s[i]==' '){
12 |       string word = s.substr(start,i);
13 |       start = i+1;
14 |       m[word]++;
15 |     }
16 |   }
17 |   string wordl = s.substr(start,s.length()-1);
18 |   m[wordl]++;
19 |   map<string,int> :: iterator it;
20 |   for(it = m.begin();it!=m.end();it++){
21 |   	cout<<(*it).first<<" a "<<endl;
22 | 	}
23 |   /*
24 |   for(it = m.begin();it!=m.end();it++){
25 |     if((*it).second>1){
26 |       cout<<(*it).first<<" "<<(*it).second<<endl;
27 |     }
28 |   }
29 |   */
30 |   return 0;
31 | }
32 | 
33 | 


--------------------------------------------------------------------------------
/Language Tools/Diffrent Names.txt:
--------------------------------------------------------------------------------
 1 | Different Names
 2 | Send Feedback
 3 | In Little Flowers Public School, there are many students with same first names. You are given a task to find the students with same names. You will be given a string comprising of all the names of students and you have to tell the name and count of those students having same. If all the names are unique, print -1 instead.
 4 | Note: We don't have to mention names whose frequency is 1.
 5 | Input Format:
 6 | The only line of input will have a string ‘str’ with space separated first names of students.
 7 | Output Format:
 8 | Print the names of students along with their count if they are repeating. If no name is repeating, print -1
 9 | Constraints:
10 | 1 <= |str| <= 10^5
11 | Time Limit: 1 second
12 | Sample Input 1:
13 | Abhishek harshit Ayush harshit Ayush Iti Deepak Ayush Iti
14 | Sample Output 1:
15 | harshit 2
16 | Ayush 3
17 | Iti 2
18 | Sample Input 2:
19 | Abhishek Harshit Ayush Iti
20 | Sample Output:
21 | -1


--------------------------------------------------------------------------------
/Language Tools/Extract unique characters.py:
--------------------------------------------------------------------------------
 1 | 
 2 | s = input()
 3 | ar = []
 4 | for a in s:
 5 |     if a not in ar:
 6 |         ar.append(a)
 7 | s = ''
 8 | for a in ar:
 9 |     s+=a
10 | 
11 | print(s)
12 | 


--------------------------------------------------------------------------------
/Language Tools/Extract unique characters.txt:
--------------------------------------------------------------------------------
 1 | Extract Unique characters
 2 | Send Feedback
 3 | Given a string, you need to remove all the duplicates. That means, the output string should contain each character only once. The respective order of characters should remain same.
 4 | Input format :
 5 | String S
 6 | Output format :
 7 | Output String
 8 | Constraints :
 9 | 1 <= Length of S <= 50000
10 | Sample Input 1 :
11 | ababacd
12 | Sample Output 1 :
13 | abcd
14 | Sample Input 2 :
15 | abcde
16 | Sample Output 2 :
17 | abcde


--------------------------------------------------------------------------------
/Language Tools/Love for Characters.py:
--------------------------------------------------------------------------------
 1 | t = int(input())
 2 | s = input()
 3 | A,S,P = 0,0,0
 4 | for a in s:
 5 |   if a=='a':
 6 |     A += 1
 7 |   if a=='s':
 8 |     S += 1
 9 |   if a=='p':
10 |     P +=1
11 |     
12 | print(A,S,P)
13 | 


--------------------------------------------------------------------------------
/Language Tools/Love for Characters.txt:
--------------------------------------------------------------------------------
 1 | Love for Characters
 2 | 
 3 | Ayush loves the characters ‘a’, ‘s’, and ‘p’. He got a string of lowercase letters and he wants to find out how many times characters ‘a’, ‘s’, and ‘p’ occurs in the string respectively. Help him find it out.
 4 | Input:
 5 | First line contains an integer denoting length of the string.
 6 | Next line contains the string.
 7 | Constraints:
 8 | 1<=n<=10^5
 9 | ‘a’<= each character of string <= ‘z’
10 | Output:
11 | Three space separated integers denoting the occurrence of letters ‘a’, ‘s’ and ‘p’ respectively.
12 | Sample Input:
13 | 6
14 | aabsas
15 | Sample output:
16 | 3 2 0


--------------------------------------------------------------------------------
/Language Tools/Tell the position.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | class sort_map
 4 | {
 5 |   public:
 6 | 	string key;
 7 | 	int val;
 8 | }sm;
 9 | 
10 | bool Sort_by(const sort_map& a ,const sort_map& b)
11 | {
12 | 	return a.val > b.val;
13 | }
14 | int main()
15 | {
16 |   long t;
17 |   map<string,int> d;
18 |   cin>>t;
19 |   for(long i = 0;i<t;i++){
20 |     string temp;
21 |     cin>>temp;
22 |     int s1,s2,s3;
23 |     cin>>s1>>s2>>s3;
24 |     int s = s1+s2+s3;
25 |     d[temp] = s;
26 |   }
27 | 	vector< sort_map > v;
28 | 	vector< sort_map >::iterator itv;
29 |  	map<string,int> :: iterator it;
30 |   for (it = d.begin(); it != d.end(); ++it)
31 | 	{
32 | 		sm.key = (*it).first; sm.val = (*it).second;
33 | 		v.push_back(sm);
34 | 	}
35 | //	for (itv = v.begin(); itv != v.end(); ++itv)
36 | //	{
37 | //	//	cout << (*itv).key << " : " << (*itv).val << endl;
38 | //	}
39 | //	
40 | 	sort(v.begin(),v.end(),Sort_by);
41 | 	
42 | //	cout << "sorted" << endl;
43 | 	long f = 0;
44 | 	for (itv = v.begin(); itv != v.end(); ++itv)
45 | 	{
46 | //		cout << (*itv).key << " : " << (*itv).val << endl;
47 |       cout << f+1<<" "<<(*itv).key<< endl;
48 |       f++;
49 | 	}
50 | 	
51 |   return 0;
52 | }
53 | 
54 | 


--------------------------------------------------------------------------------
/Language Tools/Tell the position.txt:
--------------------------------------------------------------------------------
 1 | Tell the positions
 2 | Send Feedback
 3 | In a class there are ‘n’ number of students. They have three different subjects: Data Structures, Algorithm Design & Analysis and Operating Systems. Marks for each subject of all the students are provided to you. You have to tell the position of each student in the class. Print the names of each student according to their position in class. Tie is broken on the basis of their roll numbers. Between two students having same marks, the one with less roll number will have higher rank. The input is provided in order of roll number.
 4 | Input Format:
 5 | First line will have a single integer ‘n’, denoting the number of students in the class.
 6 | Next ‘n’ lines each will have one string denoting the name of student and three space separated integers m1, m2, m3 denoting the marks in three subjects.
 7 | Output Format:
 8 | Print ‘n’ lines having two values: First, the position of student in the class and second his name.
 9 | Constraints:
10 | 1 <= n <= 10^5
11 | 0 <= m1, m2, m3 <= 100
12 | Sample Input:
13 | 3
14 | Mohit 94 85 97
15 | Shubham 93 91 94
16 | Rishabh 95 81 99
17 | Sample Output:
18 | 1 Shubham
19 | 2 Mohit
20 | 3 Rishabh


--------------------------------------------------------------------------------
/Language Tools/Warm reception.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | struct interval{
 5 |   long st;
 6 |   long et;
 7 | };
 8 | 
 9 | int main() {
10 |   long t;
11 |   cin>>t;
12 |   long counter = 0;
13 |   interval ar[t];
14 |   for(long i = 0;i<t;i++){
15 |     cin>>ar[i].st;
16 |   }
17 |   for(long i = 0;i<t;i++){
18 |     cin>>ar[i].et;
19 |   }
20 |   long max = 0;
21 |   for(long i = 0;i<2400;i++){
22 |     for(long j = 0;j<t;j++){
23 |       if(i==ar[j].st){
24 |         counter++;
25 |         if(max<counter){
26 |           max = counter;
27 |         }
28 |       }
29 |     }
30 |     for(long j = 0;j<t;j++){
31 |       if(i==ar[j].et){
32 |         counter--;
33 |         if(max<counter){
34 |           max = counter;
35 |         }
36 |       }
37 |     }
38 |   }
39 |   
40 |   cout<<max;
41 |     
42 | 
43 |   return 0;
44 | }
45 | 


--------------------------------------------------------------------------------
/Language Tools/Warm reception.txt:
--------------------------------------------------------------------------------
 1 | Warm Reception
 2 | Send Feedback
 3 | There is only one beauty parlour in the town CodingNinjasLand. The receptionist at beauty parlour is flooded with appointment requests because “Hakori” festival is round the corner and everyone wants to look good on it.
 4 | S/he needs your help. The problem is they don’t have chairs in reception. They are ordering chairs from NinjasKart. They don’t want to order more than required. You have to tell minimum number of chairs required such that none of the customer has to stand.
 5 | Input Format :
 6 | First line contains number of customers that will come. Second line contains N space separated integers which represent arrival timings of the customer. Third line contains N space separated integers which represent departure timings of the customer. Arrival and departure timings are given in 24 hour clock.
 7 | Constraints:
 8 | 1<= N <= 100
 9 | Arrival and departure timings lie in the range [0000 to 2359]
10 | Time Limit: 1 second
11 | Output Format :
12 | You have to print the minimum number of chairs required such that no customer has to wait standing. 
13 | Sample Test Cases:
14 | Sample Input 1 :
15 | 5
16 | 900 1000 1100 1030 1600
17 | 1900 1300 1130 1130 1800
18 | Sample Output 1:
19 | 4
20 | Explanation:
21 | 4 because at 1100 hours, we will have maximum number of customers at the shop, throughout the day. And that maximum number is 4. 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Duplicate the array.cpp:
--------------------------------------------------------------------------------
 1 | // arr - input array
 2 | // size - size of array
 3 | 
 4 | int MissingNumber(int arr[], int size){
 5 |     /* Don't write main().
 6 |      * Don't read input, it is passed as function argument.
 7 |      * Return output and don't print it.
 8 |      * Taking input and printing output is handled automatically.
 9 |      */
10 |     int ar[size] = {0};
11 |   for(int i = 0;i<size;i++){
12 |     int z = arr[i];
13 |     ar[z]+=1;
14 |   }
15 |   for(int i = 0;i<size;i++){
16 |     if(ar[i]>1){
17 |       return i;
18 |     }
19 |   }
20 | 	return 0;
21 | }
22 | 
23 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Duplicate the array.txt:
--------------------------------------------------------------------------------
 1 | Duplicate in array
 2 | 
 3 | Given an array of integers of size n which contains numbers from 0 to n - 2. Each number is present at least once. That is, if n = 5, numbers from 0 to 3 is present in the given array at least once and one number is present twice. You need to find and return that duplicate number present in the array.
 4 | Assume, duplicate number is always present in the array.
 5 | Input format :
 6 | Line 1 : Size of input array
 7 | Line 2 : Array elements (separated by space)
 8 | Output Format :
 9 | Duplicate element
10 | Constraints :
11 | 1 <= n <= 10^6
12 | Sample Input:
13 | 9
14 | 0 7 2 5 4 7 1 3 6
15 | Sample Output:
16 | 7
17 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Find the Unique element.cpp:
--------------------------------------------------------------------------------
 1 | // arr - input array
 2 | // size - size of array
 3 | #include<bits/stdc++.h>
 4 | using namespace std;
 5 | 
 6 | int FindUnique(int arr[], int size){
 7 |     /* Don't write main().
 8 |      * Don't read input, it is passed as function argument.
 9 |      * Return output and don't print it.
10 |      * Taking input and printing output is handled automatically.
11 |      */
12 | 	map<int,int> m;
13 |   for(int i = 0;i<size;i++){
14 |     m[arr[i]] = 0;
15 |   }
16 |   for(int i = 0;i<size;i++){
17 |     m[arr[i]]+=1;
18 |   }
19 |   map<int,int> :: iterator it;
20 |   for(it = m.begin();it!=m.end();it++){
21 |     if((*it).second==1){
22 |       return (*it).first;
23 |     }
24 |   }
25 |   
26 | }
27 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Find the Unique element.txt:
--------------------------------------------------------------------------------
 1 | Find the Unique Element
 2 | Send Feedback
 3 | Given an integer array of size 2N + 1. In this given array, N numbers are present twice and one number is present only once in the array.
 4 | You need to find and return that number which is unique in the array.
 5 | Note : Given array will always contain odd number of elements.
 6 | Input format :
 7 | Line 1 : Array size i.e. 2N+1
 8 | Line 2 : Array elements (separated by space)
 9 | Output Format :
10 | Unique element present in the array
11 | Constraints :
12 | 1 <= N <= 10^6
13 | Sample Input :
14 | 7
15 | 2 3 1 6 3 6 2
16 | Sample Output :
17 | 1


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Longest consecutive subsequence.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | 
 5 | vector<int> longestSubsequence(int *arr, int n){
 6 | 
 7 |   unordered_map<int,bool> m;
 8 |   for(int i = 0;i<n;i++){
 9 |     m[arr[i]] = true;
10 |   }
11 |   
12 |   int count = 0,max = 0,newstart;
13 |   for(int i = 0;i<n;i++){
14 |     if(m[arr[i]]){
15 |       bool begin = true,end = true;
16 |       int b=arr[i],e=arr[i]+1;
17 |       count = 0;
18 |       int start;
19 |       while(begin){
20 |         if(m.count(b)){
21 |           b-=1;
22 |         }
23 |         else {
24 |           begin = false;
25 |         }
26 |       }
27 |       while(end){
28 |         if(m.count(e)){
29 |           e+=1;
30 |         }
31 |         else {
32 |           end = false;
33 |         }
34 |       }
35 |       count = e-b-2;
36 |       start = b+1;
37 |       
38 |       if(count>max){
39 |         max = count;
40 |         newstart = start;
41 |       }
42 |     }
43 |   }
44 |   
45 |   
46 |   vector<int> vc;
47 |   for(int i = newstart;i<=max+newstart;i++){
48 |     //cout<<i<<endl;
49 |     vc.push_back(i);
50 |   }
51 |   if(vc.size()==1){
52 |     vc.pop_back();
53 |     vc.push_back(arr[0]);
54 |   }
55 |   return vc;
56 | }
57 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Longest consecutive subsequence.txt:
--------------------------------------------------------------------------------
 1 | Longest Consecutive Subsequence
 2 | Send Feedback
 3 | You are given with an array of integers that contain numbers in random order. Write a program to find the longest possible sub sequence of consecutive numbers using the numbers from given array.
 4 | You need to return the output array which contains consecutive elements. Order of elements in the output is not important.
 5 | Best solution takes O(n) time.
 6 | If two arrays are of equal length return the array whose index of smallest element comes first.
 7 | Input Format :
 8 | Line 1 : Integer n, Size of array
 9 | Line 2 : Array elements (separated by space)
10 | Constraints :
11 | 1 <= n <= 10^5
12 | Sample Input 1 :
13 | 13
14 | 2 12 9 16 10 5 3 20 25 11 1 8 6 
15 | Sample Output 1 :
16 | 8 
17 | 9 
18 | 10 
19 | 11 
20 | 12
21 | Sample Input 2 :
22 | 7
23 | 15 13 23 21 19 11 16
24 | Sample Output 2 :
25 | 15 
26 | 16


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Pair sum to zero.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void PairSum(int *input, int n){
 5 | 		/* Don't write main().
 6 |      	* the input array is already passed as function argument.
 7 |      	* Don't need to return anything. Print the desired pairs in the function itself.
 8 |      	*/
 9 |       map<int,int> um;
10 |       for(int i = 0;i<n;i++){
11 |         um[input[i]] += 1;
12 |       }
13 | 
14 | 	  map<int,int> :: iterator it;
15 |   	for(it = um.begin();it!=um.end();it++){
16 |       if((*it).first>0)
17 |       if((*it).second>0){
18 |         if(um[0-(*it).first]){
19 |           for(int i = 0;i<((*it).second * um[0-(*it).first]);i++){
20 |             cout<<0-(*it).first<<" "<<(*it).first<<endl;
21 |           }
22 |         }
23 |       }
24 |     }
25 | }
26 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Pair sum to zero.txt:
--------------------------------------------------------------------------------
 1 | Pair sum to 0
 2 | Send Feedback
 3 | Given a random integer array A of size N. Find and print the pair of elements in the array which sum to 0.
 4 | Array A can contain duplicate elements.
 5 | While printing a pair, print the smaller element first.
 6 | That is, if a valid pair is (6, -6) print "-6 6". There is no constraint that out of 5 pairs which have to be printed in 1st line. You can print pairs in any order, just be careful about the order of elements in a pair.
 7 | Input format :
 8 | Line 1 : Integer N (Array size)
 9 | Line 2 : Array elements (separated by space)
10 | Output format :
11 | Line 1 : Pair 1 elements (separated by space)
12 | Line 2 : Pair 2 elements (separated by space)
13 | Line 3 : and so on
14 | Constraints :
15 | 1 <= N <= 10^6
16 | Ai contains all non-zero values
17 | Sample Input:
18 | 5
19 | 2 1 -2 2 3
20 | Sample Output :
21 | -2 2
22 | -2 2


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Rotate array.cpp:
--------------------------------------------------------------------------------
 1 | // arr - input array
 2 | // size - size of array
 3 | // d - array to be rotated by d elements
 4 | 
 5 | void Rotate(int arr[], int d, int size) {
 6 |     /* Don't write main().
 7 |      * Don't read input, it is passed as function argument.
 8 |      * No need to print or return the output.
 9 |      * Taking input and printing the output is handled automatically.
10 |      */
11 |   int ar[size];
12 |   int j = 0;
13 |   for(int i = d ;i<size;i++){
14 |     ar[j] = arr[i];
15 |     j++;
16 |   }
17 |   for(int i = 0;i<d;i++){
18 |     ar[j] = arr[i];
19 |     j++;
20 |   }
21 |   
22 |   for(int i = 0;i<size;i++){
23 |     arr[i] = ar[i];
24 |     //cout<<ar[i]<<" ";
25 |    // printf("%d ",ar[i]);
26 |   }
27 |   
28 |   
29 | }	
30 | 
31 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Rotate array.txt:
--------------------------------------------------------------------------------
 1 | Rotate array
 2 | Send Feedback
 3 | Given a random integer array of size n, write a function that rotates the given array by d elements (towards left)
 4 | Change in the input array itself. You don't need to return or print elements.
 5 | Input format :
 6 | Line 1 : Integer n (Array Size)
 7 | Line 2 : Array elements (separated by space)
 8 | Line 3 : Integer d
 9 | Output Format :
10 | Updated array elements (separated by space)
11 | Constraints :
12 | 1 <= N <= 1000
13 | 1 <= d <= N
14 | Sample Input :
15 | 7
16 | 1 2 3 4 5 6 7
17 | 2
18 | Sample Output :
19 | 3 4 5 6 7 1 2


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Sum me up.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef unsigned long long ull;
 4 | int main() {
 5 | 
 6 |   ull t;
 7 |   cin>>t;
 8 |   while(t--){
 9 |     ull val;
10 |     cin>>val;
11 |     ull s = 0;
12 |     while(val!=0){
13 |       s+=val%10;
14 |       val/=10;
15 |     }
16 |     cout<<s<<endl;
17 |   }
18 |   return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Sum me up.txt:
--------------------------------------------------------------------------------
 1 | Sum me Up
 2 | Send Feedback
 3 | There will be ‘t’ test cases having an integer. You have to sum up all the digits of this integer. For e.g. For 6754, the answer will be 6 + 7 + 5 + 4 = 22.
 4 | Input Format:
 5 | First line will have an integer ‘t’ denoting the number of test cases.
 6 | Next ‘t’ lines will have an integer ‘val’ each.
 7 | Output format:
 8 | Print ‘t’ lines of output denoting the sum of all the digits of the number in each test case.
 9 | Constraints:
10 | 1 <= t <= 10^5
11 | 0 <= val <= 10^18
12 | Sample Input:
13 | 2
14 | 1547
15 | 45876
16 | Sample Output:
17 | 17
18 | 30
19 | Explanation:
20 | 1 + 5 + 4 + 7 = 17
21 | 4 + 5 + 8 + 7 + 6 = 30


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Triplet sum.cpp:
--------------------------------------------------------------------------------
 1 | // arr - input array
 2 | // size - size of array
 3 | // x - sum of triplets
 4 | 
 5 | void FindTriplet(int arr[], int size, int x) {
 6 |     /* Don't write main().
 7 |      * Don't read input, it is passed as function argument.
 8 |      * Print output and don't return it.
 9 |      * Taking input is handled automatically.
10 |      */
11 |   
12 |   for(int i = 0;i<size;i++){
13 |     for(int j = i;j<size;j++){
14 |       if(arr[i]>arr[j]){
15 |         int temp = arr[i];
16 |         arr[i] = arr[j];
17 |         arr[j] = temp;
18 |       }
19 |     }
20 |   }
21 |   
22 |   for(int i = 0;i<size;i++){
23 |     for(int j = i;j<size;j++){
24 |       for(int k = j;k<size;k++){
25 |         if(arr[i]+arr[j]+arr[k]==x && (i!=j && j!=k && i!=k)){
26 |           cout<<arr[i]<<" "<<arr[j]<<" "<<arr[k]<<endl;
27 |         }
28 |       }
29 |     }
30 |   }
31 | return;
32 | }
33 | 
34 | 


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/Triplet sum.txt:
--------------------------------------------------------------------------------
 1 | Triplet sum
 2 | Send Feedback
 3 | Given a random integer array and a number x. Find and print the triplets of elements in the array which sum to x.
 4 | While printing a triplet, print the smallest element first.
 5 | That is, if a valid triplet is (6, 5, 10) print "5 6 10". There is no constraint that out of 5 triplets which have to be printed on 1st line. You can print triplets in any order, just be careful about the order of elements in a triplet.
 6 | Input format :
 7 | Line 1 : Integer N (Array Size)
 8 | Line 2 : Array elements (separated by space)
 9 | Line 3 : Integer x
10 | Output format :
11 | Line 1 : Triplet 1 elements (separated by space)
12 | Line 2 : Triplet 3 elements (separated by space)
13 | Line 3 : and so on
14 | Constraints :
15 | 1 <= N <= 1000
16 | 1 <= x <= 100
17 | Sample Input:
18 | 7
19 | 1 2 3 4 5 6 7 
20 | 12
21 | Sample Output ;
22 | 1 4 7
23 | 1 5 6
24 | 2 3 7
25 | 2 4 6
26 | 3 4 5


--------------------------------------------------------------------------------
/Language tools and time complexity assignment/triplet sum 2.cpp:
--------------------------------------------------------------------------------
 1 | #include <algorithm>
 2 | void FindTriplet(int *input,int size, int x) {
 3 |     sort(input,input+size);
 4 |     for(int i=0;i<size;i++) {
 5 |         int st=i+1; int end=size-1; 
 6 |         int val=x-input[i]; 
 7 |         while(st<end){ 
 8 |             if(input[st]+input[end] > val) 
 9 |             end--; 
10 |             else
11 |             if(input[st]+input[end]<val)
12 |             st++;
13 |             else {
14 |                 int count1=0,count2=0; 
15 |                 for(int ptr=st;ptr<=end;ptr++) { 
16 |                     if(input[ptr] == input[st]) count1++; 
17 |                     else
18 |                     break; 
19 |                     
20 |                 } 
21 |                 for(int ptr= end;ptr>=st;ptr--) { 
22 |                     if(input[ptr] == input[end]) 
23 |                     count2++;
24 |                     else 
25 |                     break;
26 |                 }
27 |                 int combinations = count1*count2;
28 |                 if(input[st] == input[end])
29 |                     combinations = ((end-st+1)*(end-st))/2;
30 |                     for(int k=0;k<combinations;k++) { 
31 |                         cout<<input[i] << " "<<input[st]<<" "<<input[end]<<endl;
32 |                     }
33 |                     st=st +count1; 
34 |                     end=end - count2; 
35 |                 
36 |             }
37 |         }
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/Prerequisites/Even and Odd indices.cpp:
--------------------------------------------------------------------------------
 1 | #include <stdio.h>
 2 | #include <iostream>
 3 | using namespace std;
 4 | 
 5 | int main() {
 6 |   	long int even=0,odd=0;
 7 |   	long int t;
 8 | 	cin>>t;
 9 |   	int *ar;
10 |   	ar = new int[t];
11 |   	for(int i = 0;i<t;i++){
12 |       cin>>ar[i];
13 |       if(i%2==0){
14 |         if(ar[i]%2==0){
15 |           even += ar[i];
16 |         }
17 |       }
18 |       else{
19 |         if(ar[i]%2!=0){
20 |           odd += ar[i];
21 |         }
22 |       }
23 |     }
24 |   	cout<<even<<" "<<odd;
25 |   return 0;
26 | }


--------------------------------------------------------------------------------
/Prerequisites/Even and odd indices.txt:
--------------------------------------------------------------------------------
 1 | Even and Odd Indexes
 2 | 
 3 | Given an array of integers, print two integer values:
 4 | First, the sum of all numbers which are even as well as whose index are even.
 5 | Second, the sum of all numbers which are odd as well as whose index are odd.
 6 | Print the two integers space separated. (Arrays is 0-indexed)
 7 | Input:
 8 | Given an integer denoting the size of array.
 9 | Next line will have a line containing ‘n’ space separated integers.
10 | Constraints:
11 | 1<=n<=10^5
12 | 1 <= Ai <= 10^6 
13 | Output:
14 | Two space separated integers denoting even and odd sums respectively.


--------------------------------------------------------------------------------
/Prerequisites/Oscillating prices of chakri.py:
--------------------------------------------------------------------------------
 1 | t = int(input())
 2 | ar = list(map(int,input().split()))
 3 | s = 0
 4 | for a in range(len(ar)):
 5 |   for b in range(a,len(ar)):
 6 |     if(s<(ar[b]-ar[a])):
 7 |       s = ar[b]-ar[a]
 8 | 
 9 | print(s)
10 | 


--------------------------------------------------------------------------------
/Prerequisites/Oscillating prices of chakri.txt:
--------------------------------------------------------------------------------
 1 | Oscillating Prices of "Chakri"
 2 | 
 3 | Diwali is here. While everyone here is busy texting "Happy Diwali" wishes to everybody else, NinjaCoder has some other plans and wants to earn some money this season.
 4 | Now, the Apex court has allowed sale of only green crackers this Diwali. Out of all green crackers, "Chakri" is most popular. Because of irregular supply of "Chakri", price of "Chakri" is oscillating daily. NinjaCoder saw a business opportunity in this. He/She got price list for coming N days from an insider in market union. Prices in the list are for 1 unit of large packet of "Chakri". Each large packet contains 100 units of Chakri.
 5 | Now, due to financial limitations, NinjaCoder can transact only 1 large packet (100 units of "Chakri") in the market. You have to tell maximum profit possible, given that he/she can transact atmost one time.
 6 | 
 7 | Note: 1. Transaction refers to the act of buying and selling.
 8 |       2. "Chakri" cannot be sold individually. NinjaCoder has to buy/sell the entire packet. 
 9 | 
10 | Input Format
11 | 
12 | First line contains N - (Integer)
13 | Second line contains N spaced integers.
14 | 
15 | Constraints
16 | 
17 | 1 <= N <= 10000
18 | 50 <= A(i) <= 100
19 | 
20 | Output Format
21 | 
22 | Print the maximum profit that can be generated by NinjaCoder.
23 | 
24 | Sample Input 0
25 | 
26 | 7
27 | 62 63 70 66 64 68 61
28 | 
29 | Sample Output 0
30 | 
31 | 8
32 | 
33 | 


--------------------------------------------------------------------------------
/Prerequisites/PRE3.py:
--------------------------------------------------------------------------------
 1 | t = int(input())
 2 | ar = []
 3 | sum=0
 4 | for a in range(t):
 5 |   ar.append(list(map(int,input().split())))
 6 | 
 7 | for idx,a in enumerate(ar):
 8 |   if(idx==0 or idx==t-1):
 9 |     for i in a:
10 |       sum+=i
11 |   else:
12 |     sum+=a[0]
13 |     sum+=a[-1]
14 |     if (2*idx+1==t):
15 |       sum+=a[idx]
16 |     else:
17 |       sum+=a[idx]
18 |       sum+=a[-idx-1]
19 | print(sum)
20 | 


--------------------------------------------------------------------------------
/Prerequisites/PRE4.py:
--------------------------------------------------------------------------------
1 | t = int(input())
2 | ar = list(map(int,input().split()))
3 | for a in range(t//2):
4 |   sum = ar[a]+ar[-a-1]
5 |   print(sum//10,sum%10)
6 |     
7 | 


--------------------------------------------------------------------------------
/Prerequisites/PRE4.txt:
--------------------------------------------------------------------------------
 1 | PRE4
 2 | Send Feedback
 3 | There are ‘n’ number of villages. You are given an array of size ‘n’ representing the population of each village. Every year, there is a cricket competition between two teams and villagers come to see the match. Villagers from ith village and (n-i)-1th village (0 <= i < n/2) are combined and then formed groups of 10 people each. For e.g. villagers from village 0 and n-1, 1 and n-2, 2 and n-3 are combined. The number of villages are always even. So, clearly there will be n/2 combinations from all the villages. You have to tell that how many groups will be formed in each combination and how many villagers will be left without the complete group of 10 peoples.
 4 | Input Format:
 5 | First line will have a single integer ‘n’ denoting the number of villages.
 6 | Second line will have ‘n’ space separated integers denoting the population of villages.
 7 | Output format:
 8 | Print ‘n/2’ lines of two space separated integers, first will be no. of groups and second will be villagers left without group. First line will have the result of combination of 0 and n-1, second will have 1 and n-2 and so on.
 9 | Constraints:
10 | 1 <= n <= 10^5
11 | 1 <= Ai <= 10^6
12 | ‘n’ will always be even
13 | Sample Input:
14 | 10
15 | 26 96 18 24 87 51 44 86 75 32
16 | Sample Output:
17 | 5 8
18 | 17 1
19 | 10 4
20 | 6 8
21 | 13 8
22 | 
23 | 


--------------------------------------------------------------------------------
/Prerequisites/PREQ3.txt:
--------------------------------------------------------------------------------
 1 | PRE3
 2 | 
 3 | Given a 2-d square matrix of order ‘n’, find the sum of elements of both diagonals and all boundaries elements. Boundary elements refer to the elements present on all the four boundaries of matrix.
 4 | Input:
 5 | First line will have a single integer ‘n’ denoting the order of matrix.
 6 | Next ‘n’ lines will have ‘n’ space separated integers each denoting the elements of matrix.
 7 | Constraints:
 8 | 1<=n<=100
 9 | Output:
10 | Print a single integer denoting the sum.
11 | Sample input:
12 | 3
13 | 1 2 3
14 | 4 5 6
15 | 7 8 9
16 | Sample Output:
17 | 45


--------------------------------------------------------------------------------
/Prerequisites/Target marbles.txt:
--------------------------------------------------------------------------------
 1 | Target Marbles
 2 | 
 3 | At CodingNinjas, we love to play with marbles. We have many marble games, but the most popular one is “Target Marbles”. Now, our marbles are unique. Each marble has a number on it.
 4 | In Target Marbles, the player is given a number in the starting and this number is called target. The player is also given N number of marbles to play with. Now, player has to arrange the marbles in a specific way such that sum of the values of at least one of the continuous subset of the arrangement is equal to given target.
 5 | Now, NinjaCoder came to play this game and made an arrangement of marbles. The judges of the game need your help. You have to determine if NinjaCoder has won it or not.
 6 | Input Format :
 7 | 
 8 | First line contains number of marbles(N) and target (target_number) that was assigned to NinjaCoder. Second line contains N space separated integers, which represent arrangement of the marbles and value written on that particular marble.
 9 | 
10 | Constraints:
11 | 
12 | 1<= N <=100
13 | 1<=target_number<=10000
14 | Value on the marbles lies in the range [0, 1000].
15 | 
16 | Output Format :
17 | 
18 | You have to print “true”, if the NinjaCoder wins with the given arrangement and you have to print the values of the continuous subsets. If there are more that one continuous subsets, then you have to print the values of first continuous subset. If the Ninjas coder is unable to win, you just have to print “false”.
19 | 
20 | Sample Input 1 :
21 | 
22 | 10 10
23 | 9 1 2 3 4 5 5 16 17 19
24 | 
25 | Sample Output 1 :
26 | 
27 | true
28 | 9 1
29 | 
30 | Explanation:
31 | 
32 | Here, if the NinjaCoder arranges the given 10 marbles in this arrangement, then he/she will win the game. Now, there are many continuous subsets of marbles which will win the game such as (9,1) or (1, 2, 3, 4). Out of these winning combinations, you have to print first one which is (9,1).
33 | 
34 | Sample Input 2 :
35 | 
36 | 10 10
37 | 19 11 12 131 14 15 5 16 17 19
38 | 
39 | Sample Output 2:
40 | 
41 | false
42 | 
43 | 


--------------------------------------------------------------------------------
/Prerequisites/target marbles.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | void printing(int ar[],int i, int j){
 5 |   cout<<"true"<<endl;
 6 |   for(int x = i;x<=j;x++ ){
 7 |     cout<<ar[x]<<" ";
 8 |   }
 9 |   return;
10 | }
11 | 
12 | int main() {
13 |   long n,s;
14 |   cin>>n>>s;
15 |   int ar[n];
16 |   for(int i = 0;i<n;i++){
17 |    cin>>ar[i]; 
18 |   }
19 |   bool flag = false;
20 |   for(int i = 0; i<n;i++){
21 |     int sum = 0;
22 |     for(int j = i;j<n;j++){
23 |       sum += ar[j];
24 |       if(sum==s){
25 |         printing(ar,i,j);
26 |         flag = true;
27 |         break;
28 |       }
29 |       else if(sum>s){
30 |         break;
31 |       }
32 |     }
33 |     if(flag){
34 |       break;
35 |     }
36 |   }
37 |   if (!flag){
38 |     cout<<"false";
39 |   }
40 |   return 0;
41 | }
42 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | ## The repo consist of some of the very popular questions of SPOJ, codezen and HackerEarth. 
 2 | 
 3 | The questions are well categorised and picked in the sequence of a popular course of coding ninjas (https://codingninjas.in/)
 4 | 
 5 | I solved the questions accordingly and the solutions are capable of passing all the testcases that i think of. 
 6 | 
 7 | This repo is for those who wants to start their coding days in a sequential order by grasping all the concepts orderly. However it is mandatory for them to have a good knowledge of c++ or Python syntax.
 8 | 
 9 | The order to follow the modules are listed:
10 | 1. Prerequisites
11 | 2. Basics of recursion
12 | 3. Time and space complexity
13 | 4. Language tools
14 | 5. Language tools and time complexity analysis
15 | 6. Searching and sorting applications
16 | 7.
17 | 


--------------------------------------------------------------------------------
/Searching and sorting applications/Aggressive cows problem.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | using namespace std;
 3 | #include<algorithm>
 4 | int main()
 5 |  {
 6 |     long long int  t;
 7 |     cin>>t;
 8 |     while(t--)
 9 |      {
10 |       long long int  n,c;
11 |         cin>>n>>c;
12 |         long long int  arr[n+5];
13 |         for(long long int  i=0;i<n;i++)
14 |          {
15 |           cin>>arr[i];
16 |          }
17 |          sort(arr,arr+n);
18 |     long long int  hi=arr[n-1];
19 |     long long int  lo=arr[0];   
20 |     long long int  mid;
21 |         int ans=-1;
22 |         while(lo<hi)
23 |          {
24 |           long long int  taken=1;
25 |           long long int  last_pos=0;
26 |                mid=(lo+hi)/2;
27 |                   //cout<<"mid "<<mid<<endl;
28 |           	for(long long int  i=1;i<n;i++)//  n-1
29 |            	  {
30 |                 if(arr[i]-arr[last_pos]>=mid)
31 |                  {
32 |                   taken++;
33 |                   if(taken==c) break;
34 |                   last_pos=i;
35 |                  }
36 |                }
37 |              //  cout<<"taken "<<taken<<endl;
38 |               
39 |                if(taken<c)
40 |                 {
41 |                  hi=mid;
42 |                 }
43 |                 else
44 |                 {
45 |                  
46 |                  lo=mid+1;
47 |                 }
48 |                 if(taken==c && mid>ans)
49 |                  {
50 |                   ans=mid;
51 |                  }
52 |          }
53 |          cout<<ans<<endl;
54 |         
55 |      }
56 |      return 0;
57 |  }
58 | 


--------------------------------------------------------------------------------
/Searching and sorting applications/Aggressive cows problem.txt:
--------------------------------------------------------------------------------
 1 | Aggressive Cows Problem
 2 | Send Feedback
 3 | Farmer John has built a new long barn, with N (2 <= N <= 100,000) stalls. The stalls are located along a straight line at positions x1,...,xN (0 <= xi <= 1,000,000,000).
 4 | His C (2 <= C <= N) cows don't like this barn layout and become aggressive towards each other once put into a stall. To prevent the cows from hurting each other, FJ wants to assign the cows to the stalls, such that the minimum distance between any two of them is as large as possible. What is the largest minimum distance?
 5 | Input
 6 | t – the number of test cases, then t test cases follows. 
 7 | * Line 1: Two space-separated integers: N and C
 8 | * Lines 2..N+1: Line i+1 contains an integer stall location, xi
 9 | Output
10 | For each test case output one integer: the largest minimum distance.
11 | Sample Input :
12 | 1
13 | 5 3
14 | 1
15 | 2
16 | 8
17 | 4
18 | 9
19 | Sample Output:
20 | 3 
21 | Output details:
22 | FJ can put his 3 cows in the stalls at positions 1, 4 and 8, 
23 | resulting in a minimum distance of 3.


--------------------------------------------------------------------------------
/Searching and sorting applications/Distribute Candies.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | Distribute Candies
 3 | Send Feedback
 4 | Shaky has N (1<=N<=50000) candy boxes each of them contains a non-zero number of candies (between 1 and 1000000000). Shaky want to distibute these candies among his K (1<=K<=1000000000) IIIT-Delhi students. He want to distibute them in a way such that:
 5 | 1. All students get equal number of candies.
 6 | 2. All the candies which a student get must be from a single box only.
 7 | As he want to make all of them happy so he want to give as many candies as possible. Help Shaky in finding out what is the maximum number of candies which a student can get.
 8 | Input
 9 | First line contains 1<=T<=20 the number of test cases. Then T test cases follow. First line of each test case contains N and K. Next line contains N integers, ith of which is the number of candies in ith box.
10 | Output
11 | For each test case print the required answer in a seperate line.
12 | Sample Input:
13 | 2
14 | 3 2 
15 | 3 1 4
16 | 4 1
17 | 3 2 3 9
18 | Sample Output:
19 | 3
20 | 9
21 | */
22 | 
23 | #include<bits/stdc++.h>
24 | using namespace std;
25 | 
26 | typedef long long ll;
27 | 
28 |  bool func(ll a[],ll val,ll k,ll n)
29 | {
30 |     if(k==1)
31 |         return true;
32 |     ll sum=0;
33 |     for(ll i=n-1;i>=0;i--)
34 |     {
35 |         sum +=(a[i]/val);
36 |     }
37 |     if(sum >= k)
38 |         return true;
39 |     else
40 |         return false;
41 | }
42 | void binary_search(ll a[],ll n,ll k)
43 | {
44 |     ll lo =1;
45 |     ll high =a[n-1]+1;
46 |     ll mid=0;
47 |     while(high > lo)
48 |     {
49 |          mid = (lo+high)/2;
50 |         if(func(a,mid,k,n))
51 |             lo = mid+1;
52 |         else
53 |             high = mid;
54 |     }
55 |     cout<<lo-1<<endl;
56 | }
57 | 
58 | int main() {
59 | 	ll t;
60 |   cin>>t;
61 |   while(t--){
62 |     ll n,k;
63 |     cin>>n>>k;
64 |     ll ar[500010];
65 |     
66 |     for(ll i = 0;i<n;i++){
67 |       cin>>ar[i];
68 |     }
69 |     sort(ar,ar+n);
70 |     binary_search(ar,n,k);
71 |   }
72 |   return 0;
73 | 
74 | }
75 | 


--------------------------------------------------------------------------------
/Searching and sorting applications/Inversion count.txt:
--------------------------------------------------------------------------------
 1 | Inversion Count
 2 | 
 3 | Let A[0 ... n-1] be an array of n distinct positive integers. If i < j and A[i] > A[j] then the pair (i, j) is called an inversion of A (where i and j are indexes of A). Given an integer array A, your task is to find the number of inversions in A.
 4 | Input format :
 5 | Line 1 : n, array size
 6 | Line 2 : Array elements (separated by space).
 7 | Output format :
 8 | Count of inversions
 9 | Constraints :
10 | 1 <= n <= 10^5
11 | 1 <= A[i] <= 10^9
12 | Sample Input 1 :
13 | 3
14 | 3 2 1
15 | Sample Output 1 :
16 | 3
17 | Sample Input 2 :
18 | 5
19 | 2 5 1 3 4
20 | Sample Output 1 :
21 | 4


--------------------------------------------------------------------------------
/Searching and sorting applications/Momos Market.cpp:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/Searching and sorting applications/Momos Market.cpp


--------------------------------------------------------------------------------
/Searching and sorting applications/Murder.cpp:
--------------------------------------------------------------------------------
 1 | #include<iostream>
 2 | #include<climits>
 3 | 
 4 | #define ll long long
 5 | 
 6 | using namespace std;
 7 | 
 8 | ll count(int a[],int l,int mid,int r){
 9 | 	int c[r-l+1];
10 | 	int ci=0,i = l,j=mid+1;
11 | 	ll sum =0;
12 | 	while(i <= mid && j<= r){
13 | 		if(a[i] < a[j]){
14 | 			sum += (ll)((ll)(r-j+1)*(ll)a[i]);
15 | 			c[ci++] = a[i];
16 | 			i++;
17 | 		}
18 | 		else{
19 | 			c[ci++] = a[j];
20 | 			j++;
21 | 		}
22 | 	}
23 | 	while(i<=mid){
24 | 		c[ci++] = a[i++];
25 | 	}
26 | 	while(j <= r){
27 | 		c[ci++] = a[j++];
28 | 	}
29 | 	for(int i=0;i<ci;i++){
30 | 		a[l+i] = c[i];
31 | 	}
32 | 	return sum;
33 | }
34 | 
35 | ll murder(int a[],int l,int r){
36 | 	if(l < r){
37 | 		int mid = (l+r)/2;
38 | 		ll x = murder(a,l,mid);
39 | 		ll y = murder(a,mid+1,r);
40 | 		ll z = count(a,l,mid,r);
41 | 		return x+y+z;
42 | 	}
43 | 	return 0;
44 | }
45 | 
46 | int main(){
47 | 
48 |   int T;
49 |   cin>>T;
50 |   while(T--){
51 | 	int n;
52 | 	cin>>n;
53 | 	int a[n];
54 | 	for(int i=0;i<n;i++){
55 | 		cin>>a[i];
56 | 	}
57 | 	cout<<murder(a,0,n-1)<<"\n";
58 |   }
59 | return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/Searching and sorting applications/Murder.txt:
--------------------------------------------------------------------------------
 1 | Murder
 2 | Send Feedback
 3 | Once detective Saikat was solving a murder case. While going to the crime scene he took the stairs and saw that a number is written on every stair. He found it suspicious and decides to remember all the numbers that he has seen till now. While remembering the numbers he found that he can find some pattern in those numbers. So he decides that for each number on the stairs he will note down the sum of all the numbers previously seen on the stairs which are smaller than the present number. Calculate the sum of all the numbers written on his notes diary.
 4 | Answer may not fit in integer . You have to take long.
 5 | Input
 6 | First line gives T, number of test cases.
 7 | 
 8 | 2T lines follow.
 9 | 
10 | First line gives you the number of stairs N
11 | 
12 | Next line gives you N numbers written on the stairs.
13 | Output
14 | For each test case output one line giving the final sum for each test case.
15 | Constraints
16 | T<=10
17 | 
18 | 1<=N<=10^5
19 | 
20 | All numbers will be between 0 and 10^6.
21 | Sample Input:
22 | 1
23 | 5
24 | 1 5 3 6 4


--------------------------------------------------------------------------------
/Searching and sorting applications/Taj mahal entry.py:
--------------------------------------------------------------------------------
 1 | '''
 2 | Taj Mahal Entry
 3 | Send Feedback
 4 | Taj Mahal is one of the seven wonders of the world. Aahad loves to travel places and wants to visit Taj Mahal. He visited Agra to view Taj Mahal. There is a ticketing system at Taj Mahal. There are total ‘n’ windows which provide the tickets to get entry into Taj Mahal. There are ‘Ai’ people already present at each window to get the tickets. Each window gives ticket to one person in one minute. Initially, Aahad stands in front of the first window. After each minute, if he didn’t get the ticket, he moves on to the next window to get the ticket. If he is at window 1, he will move to 2. If at 2nd, he will move to 3rd. If he is at last window, he will move to 1st again and so on. Find the window number at which he will get the ticket.
 5 | Input Format:
 6 | First line contains a single integer ‘n’ denoting the no. of windows.
 7 | Next line contains ‘n’ space separated integers denoting the no. of people already standing in front of the ith window. (1 <= i <= n)
 8 | Output Format:
 9 | Print a single integer denoting the window number that Aahad will get ticket from.
10 | Constraints:
11 | 1 <= n <= 10^5
12 | 1 <= Ai <= 10^9
13 | Sample Input:
14 | 4
15 | 2 3 2 0
16 | Sample Output:
17 | 3
18 | Explanation:
19 | Aahad at Window 1: [2, 3, 2, 0]
20 | Aahad at Window 2: [1, 2, 1, 0]
21 | Aahad at Window 3: [0, 1, 0, 0]
22 | So, when Aahad is at window 3, he got zero people before him. Hence, he will get the ticket at window 3.
23 | '''
24 | 
25 | n = int(input())
26 | ar = list(map(int,input().split()))
27 | '''
28 | for idx,a in enumerate(ar):
29 |   if(a-idx<=0):
30 |     print(idx+1)
31 |     break
32 |   if(a<=0):
33 |     print(idx+1)
34 |     break
35 | '''
36 | 
37 | for idx,a in enumerate(ar):
38 |   v = (a-idx)//n
39 |   if((a-idx)%n!=0):
40 |     v+=1
41 |   ar[idx] = v
42 | 
43 | for idx,a in enumerate(ar):
44 |   ar[idx] = idx+a*n
45 | 
46 | m = 10000000000
47 | for idx,a in enumerate(ar):
48 |   if(a<m):
49 |     m = a
50 |     ans = idx
51 |     
52 | print(ans+1)
53 | 


--------------------------------------------------------------------------------
/Searching and sorting applications/inversion count.cpp:
--------------------------------------------------------------------------------
 1 | #include<bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long ll;
 4 | 
 5 |   
 6 | ll merge(int arr[], int temp[], int left, int mid, int right) 
 7 | { 
 8 |     int i, j, k; 
 9 |     ll inv_count = 0; 
10 |   
11 |     i = left;
12 |     j = mid; 
13 |     k = left; 
14 |     while ((i <= mid - 1) && (j <= right)) { 
15 |         if (arr[i] <= arr[j]) { 
16 |             temp[k++] = arr[i++]; 
17 |         } 
18 |         else { 
19 |             temp[k++] = arr[j++]; 
20 |             inv_count = inv_count + (mid - i); 
21 |         } 
22 |     } 
23 |   	while (i <= mid - 1) 
24 |         temp[k++] = arr[i++]; 
25 |   
26 |     while (j <= right) 
27 |         temp[k++] = arr[j++]; 
28 |   	for (i = left; i <= right; i++) 
29 |         arr[i] = temp[i]; 
30 |   
31 |     return inv_count; 
32 | } 
33 | ll zmergeSort(int arr[], int temp[], int left, int right) 
34 | { 
35 |     int mid;
36 |     ll inv_count = 0; 
37 |     if (right > left) { 
38 |         mid = (right + left) / 2; 
39 |         inv_count = zmergeSort(arr, temp, left, mid); 
40 |         inv_count += zmergeSort(arr, temp, mid + 1, right); 
41 |         inv_count += merge(arr, temp, left, mid + 1, right); 
42 |     } 
43 |     return inv_count; 
44 | } 
45 | 
46 | 
47 | ll mergeSort(int arr[], int array_size) 
48 | { 
49 |     int* temp = (int*)malloc(sizeof(int) * array_size); 
50 |     return zmergeSort(arr, temp, 0, array_size - 1); 
51 | } 
52 | 
53 | long long solve(int A[], int n)
54 | {
55 |   return mergeSort(A,n);
56 | }
57 | 
58 | /*
59 | int main() {
60 | 	ll t;
61 |   cin>>t;
62 |   ll arr[t];
63 |   for(ll i = 0;i<t;i++){
64 |     cin>>arr[i];
65 |   }
66 |   ll inv_count = 0;
67 |   inv_count = mergeSort(arr,t);
68 |   cout<<inv_count<<endl;
69 |   return 0;
70 | }*/
71 | 


--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | theme: jekyll-theme-hacker


--------------------------------------------------------------------------------
/miserman.cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <cstring>
 3 | using namespace std;
 4 | int dp[101][100];
 5 | int main() {
 6 |     int N, M;
 7 |     cin >> N >> M;
 8 |     memset(dp[0], 0, sizeof(dp[0]));
 9 |     for (int i = 0; i < N; i++) {
10 |         for (int j = 0; j < M; j++) {
11 |             int val; cin >> val;
12 |             dp[i+1][j] = val + dp[i][j];
13 |             if (j > 0) dp[i+1][j] = min(dp[i+1][j], val + dp[i][j-1]);
14 |             if (j < M-1) dp[i+1][j] = min(dp[i+1][j], val + dp[i][j+1]);
15 |         }
16 |     }
17 |     int best = 1e9;
18 |     for (int i = 0; i < M; i++) {
19 |         best = min(best, dp[N][i]);
20 |     }
21 | 	for (int i = 0; i < N; i++) {
22 |         for (int j = 0; j < M+1; j++) {
23 | 			cout<<dp[i][j]<<" ";	
24 | 		}
25 | 		cout <<endl;
26 | 	}
27 | 	
28 |     cout << best << endl;
29 |     return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/miserman.exe:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/Adityaraj1711/Eminance-coding-ninjas/8b7393fe8db10dd047d8841b15f332899e52daf3/miserman.exe


--------------------------------------------------------------------------------
/segment tree/maximum sum in subarray.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | Maximum Sum In Subarray
  3 | You are given a sequence A[1], A[2], ..., A[N] . ( |A[i]| = 15007 , 1 = N = 50000 ). A query is defined as follows:
  4 | Query(x,y) = Max { a[i]+a[i+1]+...+a[j] ; x = i = j = y }.
  5 | Given M queries, your program must output the results of these queries.
  6 | Input
  7 | The first line of the input file contains the integer N.
  8 | In the second line, N numbers follow.
  9 | The third line contains the integer M.
 10 | M lines follow, where line i contains 2 numbers xi and yi.
 11 | Output
 12 | Your program should output the results of the M queries, one 
 13 | query per line.
 14 | Sample Input:
 15 | 3 
 16 | -1 2 3 
 17 | 1
 18 | 1 2
 19 | Sample Output:
 20 | 2
 21 | */
 22 | 
 23 | #include <bits/stdc++.h>
 24 | using namespace std;
 25 | 
 26 | struct node {
 27 |     long long int sum, prefixsum, suffixsum, maxsum;
 28 | };
 29 | 
 30 | node tree[1000100];
 31 | long long int arr[5000100];
 32 | 
 33 | void build(int index, int start, int end)
 34 | {
 35 | 
 36 |     if (start == end) {
 37 | 
 38 |         tree[index].sum = arr[start];
 39 |         tree[index].prefixsum = arr[start];
 40 |         tree[index].suffixsum = arr[start];
 41 |         tree[index].maxsum = arr[start];
 42 |     }
 43 |     else if(start>end) return ;
 44 |     else {
 45 |         int mid = (start + end) / 2;
 46 |         build(2 * index, start, mid);
 47 |         build(2 * index + 1, mid + 1, end);
 48 | 
 49 |         tree[index].prefixsum = max(tree[2 * index].prefixsum, tree[2 * index].sum + tree[2 * index + 1].prefixsum);
 50 |         tree[index].suffixsum = max(tree[2 * index + 1].suffixsum, tree[2 * index + 1].sum + tree[2 * index].suffixsum);
 51 |         tree[index].sum = tree[2 * index].sum + tree[2 * index + 1].sum;
 52 |         tree[index].maxsum = max(tree[2*index].maxsum, max(tree[2 * index + 1].maxsum, tree[2 * index].suffixsum + tree[2 * index + 1].prefixsum));
 53 | 
 54 |         // tree[index].maxsum = max(tree[index].prefixsum,
 55 |         //     max(tree[index].suffixsum,
 56 |         //                              max(tree[2 * index + 1].maxsum,
 57 |         //                                  max(tree[2 * index + 2].maxsum,
 58 |         //                                      tree[2 * index + 1].suffixsum + tree[2 * index + 1].suffixsum
 59 |         //                                          + tree[2 * index + 2].prefixsum))));
 60 |     }
 61 | }
 62 | 
 63 | node query(int index, int start, int end, int l, int r)
 64 | {
 65 |     node result;
 66 |     result.sum = result.prefixsum = INT_MIN;
 67 |     result.suffixsum = result.maxsum = INT_MIN;
 68 |     if (start > end || start > r || end < l){
 69 |         return result;
 70 |     }
 71 | 
 72 |     if (l <= start && end <= r)
 73 |         return tree[index];
 74 | 
 75 |     int mid = (start + end) / 2;
 76 |     // if (l > mid)
 77 |         // return query(2 * index + 2, mid + 1, end, l, r);
 78 |     // if (r <= mid)
 79 |         // return query(2 * index + 1, start, mid, l, r);
 80 | 
 81 |     node left = query(2 * index, start, mid, l, r);
 82 |     node right = query(2 * index + 1, mid + 1, end, l, r);
 83 | 
 84 |     result.prefixsum = max(left.prefixsum, left.sum + right.prefixsum);
 85 |     result.suffixsum = max(right.suffixsum, right.sum + left.suffixsum);
 86 |     result.sum = left.sum + right.sum;
 87 |     result.maxsum=max(left.maxsum,max(right.maxsum,left.suffixsum+right.prefixsum));
 88 | 
 89 |     // result.maxsum = max(result.prefixsum,
 90 |     //     max(result.suffixsum,
 91 |     //                         max(left.maxsum,
 92 |     //                             max(right.maxsum,
 93 |     //                                 left.suffixsum + right.prefixsum))));
 94 |     return result;
 95 | }
 96 | 
 97 | int main()
 98 | {
 99 |     long long int n, m, a, b;
100 |     scanf("%lld", &n);
101 |     // cin>>n;
102 |     for (int i = 0; i < n; ++i)
103 |         scanf("%lld", &arr[i]);
104 | 
105 |     build(1, 0, n - 1);
106 |     scanf("%d", &m);
107 | 
108 |     for (int i = 0; i < m; ++i) {
109 |         scanf("%lld%lld", &a, &b);
110 |         // cin>>a>>b;
111 |         printf("%lld\n", query(1, 0, n - 1, a - 1, b - 1).maxsum);
112 |         
113 |     }
114 |     return 0;
115 | }
116 | 
117 | 


--------------------------------------------------------------------------------