Merge branch 'master' of https://github.com/vishvarana/CompetitiveProgrammingQuestionBank

Author: vishvarana

Arrays/Fair Playoff.cpp

@@ -0,0 +1,72 @@
+/* Problem Statement:
+Four players participate in the playoff tournament. The tournament is held according to the following scheme: the first player will play with the second, and the third player with the fourth, then the winners of the pairs will play in the finals of the tournament.
+
+It is known that in a match between two players, the one whose skill is greater will win. The skill of the i-th player is equal to si and all skill levels are pairwise different (i. e. there are no two identical values in the array s).
+
+The tournament is called fair if the two players with the highest skills meet in the finals.
+
+Determine whether the given tournament is fair.
+
+Example:
+
+Input:
+4
+3 7 9 5
+4 5 6 9
+5 3 8 1
+6 5 3 2
+
+Output:
+YES
+NO
+YES
+NO
+*/
+
+#include<iostream>
+using namespace std;
+
+int main()
+{
+	long int T;
+	cin>>T;
+	
+	while(T--)
+	{
+		int s[4], i, f1 = 0, f2 = 0, sm = 0, no = 0, yes = 0;
+		for(i = 0; i < 4; i++)
+			cin>>s[i];				//a 1-D array to store the skills of 4 players
+			
+		if(s[0] > s[1])				//comparing first player with second
+			f1 = s[0];
+			
+		else
+			f1 = s[1];
+			
+		if(s[2] > s[3])				//comparing third player with fourth
+			f2 = s[2];
+			
+		else
+			f2 = s[3];
+			
+			
+		if(f2 - f1 > 0)
+			sm = f1;
+		else
+			sm = f2;
+			
+		
+		for(i = 0; i < 4; i++)
+		{
+			if(s[i] > sm)				//to check if the finals were fair or not
+				yes++;					//assign 'yes' if the players with highest skills are in finals
+			else
+				no++;					//assign 'no' if the players with highest skills were not in finals
+		}
+		if(yes == 1)
+			cout<<"YES"<<endl;			//print 'YES' for a fair playoff
+		else 
+			cout<<"NO"<<endl;			//print 'NO' for an unfair playoff
+	}
+	return 0;
+}

Arrays/RunningSumOf1dArray.cpp

@@ -0,0 +1,47 @@
+/*Question:-
+Given an array nums. We define a running sum of an array as runningSum[i] = sum(nums[0]…nums[i]).
+
+Return the running sum of nums.
+
+ 
+
+Example 1:
+
+Input: nums = [1,2,3,4]
+Output: [1,3,6,10]
+Explanation: Running sum is obtained as follows: [1, 1+2, 1+2+3, 1+2+3+4].
+Example 2:
+
+Input: nums = [1,1,1,1,1]
+Output: [1,2,3,4,5]
+Explanation: Running sum is obtained as follows: [1, 1+1, 1+1+1, 1+1+1+1, 1+1+1+1+1].
+Constraints:
+
+1 <= nums.length <= 1000
+-10^6 <= nums[i] <= 10^6
+*/
+#include<bits/stdc++.h>
+using namespace std;
+vector<int> runningSum(vector<int>& nums) {
+        for(int i=1;i<nums.size();i++){
+            nums[i]+=nums[i-1];
+        }
+        return nums;//returning the array
+    }
+int main(){
+vector<int> nums;//to store elements
+int n,element;
+cin>>n;
+ for (int i = 0; i < n; i++)
+    {
+        cin>>element;
+       nums.push_back(element);//storeing the elements
+    }
+vector<int> result=runningSum(nums);//calling the fuction to return the running sum of array
+for (int i = 0; i < result.size(); i++)
+{
+    cout<<result[i]<<",";//print the elements of running sum array
+}
+
+return 0;
+}

Arrays/move_zeroes_end_1traversal.cpp

@@ -0,0 +1,44 @@
+//Move all zeros to End
+//Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+//Approach 2
+//O(n) O(1)
+
+
+// i/p: n=5, 0 1 0 3 12
+// o/p: 1 3 12 0 0
+
+// Here we replace another loop with count
+
+#include<iostream>
+using namespace std;
+void moveToEnd(int arr[],int n)
+{
+	int count=0;
+	for(int i=0;i<n;i++)
+	{
+		if(arr[i]!=0)
+		{
+			//if we get 0 we ignore it
+			//and if we get non zero we swap with count which point at 0
+			swap(arr[i],arr[count]); 
+			count++;				 
+									
+		}
+	}
+}
+
+int main()
+{
+	int n,i;
+	cout<<"Enter the number of elements in array\n";
+	cin>>n;
+	int arr[n];
+	cout<<"Enter the elements in array\n";
+	for(i=0;i<n;i++)
+	  cin>>arr[i];
+	moveToEnd(arr,n);
+	cout<<"Array having zeroes at end\n";
+	for(i=0;i<n;i++)
+	  cout<<arr[i]<<" ";
+
+}

Arrays/move_zeroes_end_2traversal.cpp

@@ -0,0 +1,56 @@
+//Move all zeros to End
+//Given an integer array nums, move all 0's to the end of it while maintaining the relative order of the non-zero elements.
+//Approach 1
+//O(n^2) O(1)
+
+// i/p: n=5, 0 1 0 3 12
+// o/p: 1 3 12 0 0
+
+/*
+Brute froce approach
+n=5
+traversals :
+0 0 1 2 3
+1 0 0 2 3
+1 2 0 0 3
+1 2 3 0 0
+*/
+
+#include<iostream>
+using namespace std;
+void moveToEnd(int arr[],int n)
+{
+	for(int i=0;i<n;i++)
+	{
+	  //We 1st find is there any 0 present
+	  if(arr[i]==0)				
+	   {
+	   for(int j=i+1;j<n;j++){
+		//if non zero then swap with ith 0
+		if(arr[j]!=0)		
+		{
+	         //swap both
+		 swap(arr[i],arr[j]); 
+		 break;
+		}
+	     }	   
+	  }
+	}
+}
+
+
+int main()
+{
+	int n,i;
+	cout<<"Enter the number of elements in array\n";
+	cin>>n;
+	int arr[n];
+	cout<<"Enter the elements in array\n";
+	for(i=0;i<n;i++)
+	  cin>>arr[i];
+	moveToEnd(arr,n);
+	cout<<"Array having zeroes at end\n";
+	for(i=0;i<n;i++)
+	  cout<<arr[i]<<" ";
+
+}

Backtracking/N_Queens.py

@@ -0,0 +1,111 @@
+'''
+Aim: To place N queens in a N*N Chessboard such that no two queens
+     attack each other. A queen is said to be attacked by another queen
+     if they share same diagonal(right/left), Row or Column.
+Intution: Since there could be only one queen in each row, we can assume the
+          N*N chessboard to be a 1d array which each index denotes one of the
+          row and the row value denotes the column. Now in each row, we will
+          put a queen and check whether it is possible or not. If possible, then
+          we recursively check for the next row. If its not possible to place
+          a queen in any of the column is a particular row, then we backtrack
+          and try next Column.
+
+'''
+
+# Main function argument =size of the board
+def n_queens(board_size):
+
+    # Occupied Diagonals and Columns
+    # For right and left Diagonal respectively
+    diagonal1 = {}
+    diagonal2 = {}
+    Col = {}
+
+    ans = place_queen(0, [], board_size, diagonal1, diagonal2, Col)
+
+    return ans
+
+# Recursive Function to check and place the queens
+def place_queen(row, a, n, diagonal1, diagonal2, Col):
+
+    # If the answer is found, row will be equal to the size of the board i.e. n
+    if(row == n):
+        return a
+    R = row + 1
+
+    for C in range(1, n + 1):
+        # Check that particular Column is free to place a queen or not
+        if((C not in Col) and ((R + C) not in diagonal1) and ((R - C) not in diagonal2)):
+
+            # Add the Column and their respective Diagonals to the dictionary
+            # to mark they are Occupied
+            Col[C] = 0
+            diagonal1[R + C] = 0
+            diagonal2[R - C] = 0
+            chk = place_queen(
+                row + 1, a + [(row, C - 1)], n, diagonal1, diagonal2, Col)
+
+            # If the answer is found, Stop the recursion
+            if chk:
+                return chk
+
+            # Deleaating the Column and Diagonals to vacant that place
+            del diagonal1[R + C]
+            del Col[C]
+            del diagonal2[R - C]
+
+    return False
+
+
+# -------------------------------Driver Code-------------------------------
+
+if __name__ == "__main__":
+    n = int(input("Enter the Board Size: "))
+    answer = n_queens(n)
+
+    if not answer:
+        print("Queens cannot be placed in the given Chessboard")
+
+    else:
+        print("Queens are Placed in the chessboard")
+        print("Position :", *answer)
+
+'''
+Sample Working:
+    
+Enter the Board Size: 3
+Queens cannot be placed in the given Chessboard
+
+Enter the Board Size: 4
+Queens are Placed in the chessboard
+Position : (0, 1) (1, 3) (2, 0) (3, 2)
+
+                0       1       2       3
+            +-------+-------+-------+-------+
+            |       |       |       |       |
+        0   |       |   X   |       |       |
+            |       |       |       |       |
+            +---------------+-------+-------+
+            |       |       |       |       |
+        1   |       |       |       |   X   |
+            |       |       |       |       |
+            +-------+-------+-------+-------+
+            |       |       |       |       |
+        2   |   X   |       |       |       |
+            |       |       |       |       |
+            +-------+-------+-------+-------+
+            |       |       |       |       |
+        3   |       |       |   X   |       |
+            |       |       |       |       |
+            +-------+-------+-------+-------+
+            
+Enter the Board Size: 8
+Queens are Placed in the chessboard
+Position : (0, 0) (1, 4) (2, 7) (3, 5) (4, 2) (5, 6) (6, 1) (7, 3)
+
+COMPLEXITY:
+
+     Time Complexity: O(2^N)
+     Space complexity: O(N)
+     
+'''

Backtracking/Subset_Sum.py

@@ -0,0 +1,57 @@
+'''
+Aim: From a list of integers, check and return a set of integers whose sum 
+     will be equal to the target value K.
+
+'''
+
+# Main Recursive function to find the desired Subset Sum
+def Subset_Sum(li, target, ans=[]):
+
+    # Base Cases
+    if target == 0 and ans != []:
+        return ans
+
+    elif li == []:
+        return False
+
+    # li[0] is not included in the answer Subset
+    temp = Subset_Sum(li[1:], target, ans)
+    if temp:
+        return temp
+
+    # li[0] included in the answer Subset
+    temp = Subset_Sum(li[1:], target - li[0], ans + [li[0]])
+
+    return temp
+
+# --------------------------- DRIVER CODE------------------------------
+
+if __name__ == "__main__":
+
+    li = [int(i) for i in input("Enter the List of Integers: ").split()]
+    Target = int(input("Enter the Target value: "))
+
+    ans = Subset_Sum(li, Target)
+    if not ans:
+        print("No Subset Sum matched to the Target")
+    else:
+        print("The Required Subset is : ", *ans)
+
+'''
+
+Sample Input: 
+Enter the List of Integers: -1 2 6 7 -4 7 5 -2 
+Enter the Target value: 0
+
+Sample Output:
+The Required Subset is :  6 -4 -2
+
+Explanation:
+6 - 4 - 2 = 0, the required result
+
+COMPLEXITY:
+
+     Time Complexity: O(2^N)
+     Space complexity: O(N)
+     
+'''