till 10

Author: chirag127

.vscode/launch.json

@@ -0,0 +1,11 @@
+{
+    "configurations": [
+        {
+            "type": "java",
+            "name": "Launch QuickSort",
+            "request": "launch",
+            "mainClass": "QuickSort",
+            "projectName": "5th-sem-labs_867ed7e"
+        }
+    ]
+}

.vscode/settings.json

@@ -1,5 +1,10 @@
 {
     "files.associations": {
         "string.h": "c"
-    }
+    },
+    "java.project.sourcePaths": [
+        "daa/11. Sort a given set of n integer elements using Quick Sort method and compute its time complexity. Run the program for"
+    ],
+    "editor.tabCompletion": "on",
+    "diffEditor.codeLens": true
 }

daa/10. Implement N Queen Problem using Backtracking/qp

@@ -0,0 +1,114 @@
+/* C program to solve N Queen Problem using
+backtracking */
+#define N 4
+#include <stdbool.h>
+#include <stdio.h>
+
+/* A utility function to print solution */
+void printSolution(int board[N][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+            printf(" %d ", board[i][j]);
+        printf("\n");
+    }
+}
+
+/* A utility function to check if a queen can
+be placed on board[row][col]. Note that this
+function is called when "col" queens are
+already placed in columns from 0 to col -1.
+So we need to check only left side for
+attacking queens */
+bool isSafe(int board[N][N], int row, int col)
+{
+    int i, j;
+
+    /* Check this row on left side */
+    for (i = 0; i < col; i++)
+        if (board[row][i])
+            return false;
+
+    /* Check upper diagonal on left side */
+    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
+        if (board[i][j])
+            return false;
+
+    /* Check lower diagonal on left side */
+    for (i = row, j = col; j >= 0 && i < N; i++, j--)
+        if (board[i][j])
+            return false;
+
+    return true;
+}
+
+/* A recursive utility function to solve N
+Queen problem */
+bool solveNQUtil(int board[N][N], int col)
+{
+    /* base case: If all queens are placed
+    then return true */
+    if (col >= N)
+        return true;
+
+    /* Consider this column and try placing
+    this queen in all rows one by one */
+    for (int i = 0; i < N; i++)
+    {
+        /* Check if the queen can be placed on
+        board[i][col] */
+        if (isSafe(board, i, col))
+        {
+            /* Place this queen in board[i][col] */
+            board[i][col] = 1;
+
+            /* recur to place rest of the queens */
+            if (solveNQUtil(board, col + 1))
+                return true;
+
+            /* If placing queen in board[i][col]
+            doesn't lead to a solution, then
+            remove queen from board[i][col] */
+            board[i][col] = 0; // BACKTRACK
+        }
+    }
+
+    /* If the queen cannot be placed in any row in
+        this column col then return false */
+    return false;
+}
+
+/* This function solves the N Queen problem using
+Backtracking. It mainly uses solveNQUtil() to
+solve the problem. It returns false if queens
+cannot be placed, otherwise, return true and
+prints placement of queens in the form of 1s.
+Please note that there may be more than one
+solutions, this function prints one of the
+feasible solutions.*/
+bool solveNQ()
+{
+    int board[N][N] = {{0, 0, 0, 0},
+                       {0, 0, 0, 0},
+                       {0, 0, 0, 0},
+                       {0, 0, 0, 0}};
+
+    if (solveNQUtil(board, 0) == false)
+    {
+        printf("Solution does not exist");
+        return false;
+    }
+
+    printSolution(board);
+    return true;
+}
+
+// driver program to test above function
+int main()
+{
+    solveNQ();
+    return 0;
+}
+
+// This code is contributed by chirag singhal

daa/10. Implement N Queen Problem using Backtracking/qp.c

@@ -0,0 +1,62 @@
+/*  Sort a given set of n integer elements using Quick Sort method and compute its time complexity. Run the program for
+varied values of n> 5000 and record the time taken to sort. Plot a graph of the time taken versus non graph sheet. The
+elements can be read from a file or can be generated using the random number generator. Demonstrate using Java how the
+divide and- conquer method works along with its time complexity analysis: worst case, average case and best case*/
+
+import java.io.*;
+
+class QuickSort
+{
+	public static void main(String args[])throws IOException
+	{
+		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
+		System.out.println("Enter the number of elements");
+		int n=Integer.parseInt(br.readLine());
+		int a[]=new int[n];
+		System.out.println("Enter the elements");
+		for(int i=0;i<n;i++)
+		{
+			a[i]=Integer.parseInt(br.readLine());
+		}
+		System.out.println("The unsorted elements are");
+		for(int i=0;i<n;i++)
+		{
+			System.out.println(a[i]);
+		}
+		QuickSort ob=new QuickSort();
+		ob.sort(a,0,n-1);
+		System.out.println("The sorted elements are");
+		for(int i=0;i<n;i++)
+		{
+			System.out.println(a[i]);
+		}
+	}
+	void sort(int a[],int l,int r)
+	{
+		if(l<r)
+		{
+			int pi=partition(a,l,r);
+			sort(a,l,pi-1);
+			sort(a,pi+1,r);
+		}
+	}
+	int partition(int a[],int l,int r)
+	{
+		int pivot=a[r];
+		int i=l-1;
+		for(int j=l;j<r;j++)
+		{
+			if(a[j]<=pivot)
+			{
+				i++;
+				int temp=a[i];
+				a[i]=a[j];
+				a[j]=temp;
+			}
+		}
+		int temp=a[i+1];
+		a[i+1]=a[r];
+		a[r]=temp;
+		return i+1;
+	}
+}

daa/11. Sort a given set of n integer elements using Quick Sort method and compute its time complexity. Run the program for/QuickSort.class

@@ -0,0 +1,38 @@
+// write program for the heap sort in c
+
+#include<stdio.h>
+
+int main()
+{
+    int  a[100], n, i, j, temp;
+
+    printf("The program for the heap sort in c \n written by Chirag Singhal \n roll number 2000330100084 \n");
+
+    printf( "Enter the number of elements : " );
+
+
+    scanf( "%d" , &n);
+    printf( "Enter the elements : " );
+
+
+    for (i = 0; i < n; i++)
+        scanf( "%d" , &a[i]);
+    for (i = 0; i < n; i++)
+    {
+        for (j = 0; j < n - i - 1; j++)
+        {
+            if (a[j] > a[j + 1])
+            {
+                temp = a[j];
+                a[j] = a[j + 1];
+                a[j + 1] = temp;
+            }
+        }
+    }
+    printf( "Sorted array is : " );
+    for (i = 0; i < n; i++)
+        printf( "%d " , a[i]);
+
+    printf("\n");
+    return  0;
+}

daa/11. Sort a given set of n integer elements using Quick Sort method and compute its time complexity. Run the program for/tc.java

@@ -0,0 +1,34 @@
+// write a program for the merge sort in c
+
+#include<stdio.h>
+
+int main()
+{
+    int  a[100], n, i, j, temp;
+
+    printf("This is the program for the merge sort in c \n written by Chirag Singhal \n roll number 2000330100084 \n");
+
+    printf( "Enter the number of elements : " );
+    scanf( "%d" , &n);
+    printf( "Enter the elements : " );
+    for (i = 0; i < n; i++)
+        scanf( "%d" , &a[i]);
+    for (i = 0; i < n; i++)
+    {
+        for (j = 0; j < n - i - 1; j++)
+        {
+            if (a[j] > a[j + 1])
+            {
+                temp = a[j];
+                a[j] = a[j + 1];
+                a[j + 1] = temp;
+            }
+        }
+    }
+    printf( "Sorted array is : " );
+    for (i = 0; i < n; i++)
+        printf( "%d " , a[i]);
+
+    printf("\n");
+    return  0;
+}