Merge branch 'smv1999:master' into master

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;
+}

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)
+     
+'''

Backtracking/graph_coloring.c

@@ -0,0 +1,83 @@
+/*Write a program to implement the graph coloring problem with  m=3 using back tracking method. Consider the  
+following adjacency matrix for the graph. 
+           1 2 3 4
+        1  0 1 1 1
+        2  1 0 1 0
+        3  1 1 0 1
+        4  1 0 1 0
+*/
+#include<stdio.h>
+#define v 4
+void printsol(int color[]) {
+	int i;
+	printf("The assigned colors are: ");
+	for (i = 0; i < v; i++)
+		printf(" %d ", color[i]);
+	printf("\n");
+}
+
+int isSafe(int adj[v][v], int color[]) {
+	int i,j;
+	for (i = 0; i < v; i++)
+		for (j = i + 1; j < v; j++)
+			if (adj[i][j] && color[j] == color[i]){
+				return 1;
+			}
+	return 0;
+}
+int graphcolor(int adj[v][v], int m, int i, int color[v]){
+	int j;
+	if (i == v){ // If we got all the vertex colored we check if it is safe
+		if (isSafe(adj, color) == 0) {
+			// If yes we print solution and return 0
+			printsol(color);
+			return 0;
+		} else{
+			return 1;
+		}
+	}
+	//Recursively colors all the vertex
+	for(j=1;j<=m;j++){
+		color[i] = j;
+		if (graphcolor(adj,m,i+1,color) == 0){ // Since we returned 0 i.e we got one solution we return the func
+			return 0;
+		}
+		color[i] = 0; // If we didn't get safe solu (i.e return value is 1) we start again
+	}
+	return 1;
+}
+
+int main(){
+	int i,j,m;
+	printf("Enter the number of colors [m] : ");
+	scanf("%d",&m);
+	int adj[v][v];
+	printf("\nEnter values of the Adjacency Matrix: \n");
+	for(i=0;i<v;i++){
+		for(j=0;j<v;j++){
+			printf("\nEnter the value of adj[%d][%d]: ",i,j);
+			scanf("%d",&adj[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\n\n");
+	printf("Adjacency Matrix: \n");
+	for(i=0;i<v;i++){
+		for(j=0;j<v;j++){
+			printf("%d ",adj[i][j]);
+		}
+		printf("\n");
+	}
+	printf("\nThe value of m is: %d \nThe value of v is: %d\n",m,v);
+	
+	int color[v]; //Keeps record of the color, each vertex is colored with
+    for (i = 0; i < v; i++){
+        color[i] = 0; //first set all the nodes color as 0
+    }
+ 
+    if (graphcolor(adj, m, 0, color) == 1){
+    	printf("Solution does not exist");
+	}
+	return 0;
+}
+

DSA 450 GFG/TowerOfHanoi.cpp

@@ -0,0 +1,46 @@
+
+/* Tower of Hanoi is a mathematical puzzle where we have three rods and n disks. The objective of the puzzle is to move the entire stack to another rod, obeying the following simple rules: 
+
+1. Only one disk can be moved at a time.
+2. Each move consists of taking the upper disk from one of the stacks and placing it on top of another stack i.e. a disk can only be moved if it is the uppermost disk on a stack.
+3. No disk may be placed on top of a smaller disk.
+*/
+
+#include<iostream>
+using namespace std;
+
+void towerofHanoi(int n, char src, char helper ,char dest){// number of element , source, helper, destination
+	
+	
+	if(n==0){
+		return; //base case
+	}
+	
+	towerofHanoi(n-1, src, dest, helper);// Move n-1 disks from source to helper
+	cout<<"Move from "<<src<<" to "<<helper<<endl;
+	towerofHanoi(n-1, dest, helper, src);// Move n-1 disks from destination to helper
+	
+	
+	
+}
+
+int main(){
+	
+	towerofHanoi(3, 'A', 'B', 'C');// A = Source , B = helper, C = destination.
+	
+	return 0;
+	
+	
+}
+/* Input = 3
+
+Output:
+
+Move from A to B
+Move from A to C
+Move from B to C
+Move from A to B
+Move from C to A
+Move from C to B
+Move from A to B
+*/