From 03d95ee9bfb222365827a84440324235cb194190 Mon Sep 17 00:00:00 2001 From: Rushil2812 <80237815+Rushil2812@users.noreply.github.com> Date: Tue, 18 Oct 2022 15:00:01 +0530 Subject: [PATCH 1/3] HACKTOBER Selection_sort --- selection_sort.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 selection_sort.py diff --git a/selection_sort.py b/selection_sort.py new file mode 100644 index 0000000..5fb5e57 --- /dev/null +++ b/selection_sort.py @@ -0,0 +1,20 @@ +# Selection sort in Python +# time complexity O(n*n) +#sorting by finding min_index +def selectionSort(array, size): + + for ind in range(size): + min_index = ind + + for j in range(ind + 1, size): + # select the minimum element in every iteration + if array[j] < array[min_index]: + min_index = j + # swapping the elements to sort the array + (array[ind], array[min_index]) = (array[min_index], array[ind]) + +arr = [-2, 45, 0, 11, -9,88,-97,-202,747] +size = len(arr) +selectionSort(arr, size) +print('The array after sorting in Ascending Order by selection sort is:') +print(arr) From cfe2b1a222b6b4895acd0e61dc4fb313f95f9e4a Mon Sep 17 00:00:00 2001 From: Rushil2812 <80237815+Rushil2812@users.noreply.github.com> Date: Tue, 18 Oct 2022 15:02:49 +0530 Subject: [PATCH 2/3] Hactober N-Queen Problem --- N-queen_problem.py | 91 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 N-queen_problem.py diff --git a/N-queen_problem.py b/N-queen_problem.py new file mode 100644 index 0000000..a7d447d --- /dev/null +++ b/N-queen_problem.py @@ -0,0 +1,91 @@ +# Python program to solve N Queen +# Problem using backtracking + +global N +N = 4 + +def printSolution(board): + for i in range(N): + for j in range(N): + print (board[i][j],end=' ') + print() + + +# 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 +def isSafe(board, row, col): + + # Check this row on left side + for i in range(col): + if board[row][i] == 1: + return False + + # Check upper diagonal on left side + for i, j in zip(range(row, -1, -1), range(col, -1, -1)): + if board[i][j] == 1: + return False + + # Check lower diagonal on left side + for i, j in zip(range(row, N, 1), range(col, -1, -1)): + if board[i][j] == 1: + return False + + return True + +def solveNQUtil(board, 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 i in range(N): + + 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) == True: + return True + + # If placing queen in board[i][col + # doesn't lead to a solution, then + # queen from board[i][col] + board[i][col] = 0 + + # if the queen can not 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 +# placement of queens in the form of 1s. +# note that there may be more than one +# solutions, this function prints one of the +# feasible solutions. +def solveNQ(): + board = [ [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0], + [0, 0, 0, 0] + ] + + if solveNQUtil(board, 0) == False: + print ("Solution does not exist") + return False + + printSolution(board) + return True + +# driver program to test above function +solveNQ() + +# This code is contributed by Divyanshu Mehta From 475ae8cbce0735326caa6f3f0da6de8c31eb812f Mon Sep 17 00:00:00 2001 From: Rushil2812 <80237815+Rushil2812@users.noreply.github.com> Date: Sat, 22 Oct 2022 16:22:52 +0530 Subject: [PATCH 3/3] Rat in maze --- Rat_in_maze.cpp | 91 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 91 insertions(+) create mode 100644 Rat_in_maze.cpp diff --git a/Rat_in_maze.cpp b/Rat_in_maze.cpp new file mode 100644 index 0000000..a9cf880 --- /dev/null +++ b/Rat_in_maze.cpp @@ -0,0 +1,91 @@ +// C++ program to solve Rat in a Maze problem using +// backtracking +#include +using namespace std; +// Maze size +#define N 4 + +bool solveMazeUtil(int maze[N][N], int x, int y,int sol[N][N]); + +// A utility function to print solution matrix sol[N][N] +void printSolution(int sol[N][N]) +{ + for (int i = 0; i < N; i++) { + for (int j = 0; j < N; j++) + cout<<" "<= 0 && x < N && y >= 0 && y < N && maze[x][y] == 1) + return true; + return false; +} + +// This function solves the Maze problem using Backtracking. +// It mainly uses solveMazeUtil() to solve the problem. It +// returns false if no path is possible, otherwise return +// true and prints the path in the form of 1s. Please note +// that there may be more than one solutions, this function +// prints one of the feasible solutions. +bool solveMaze(int maze[N][N]) +{ + int sol[N][N] = { { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 } }; + if (solveMazeUtil(maze, 0, 0, sol) == false) { + cout<<"Solution doesn't exist"; + return false; + } + printSolution(sol); + return true; +} + +// A recursive utility function to solve Maze problem +bool solveMazeUtil(int maze[N][N], int x, int y, int sol[N][N]) +{ + // if (x, y is goal) return true + if (x == N - 1 && y == N - 1 && maze[x][y] == 1) { + sol[x][y] = 1; + return true; + } + // Check if maze[x][y] is valid + if (isSafe(maze, x, y) == true) { + // Check if the current block is already part of + // solution path. + if (sol[x][y] == 1) + return false; + // mark x, y as part of solution path + sol[x][y] = 1; + /* Move forward in x direction */ + if (solveMazeUtil(maze, x + 1, y, sol) == true) + return true; + // If moving in x direction doesn't give solution + // then Move down in y direction + if (solveMazeUtil(maze, x, y + 1, sol) == true) + return true; + // If none of the above movements work then + // BACKTRACK: unmark x, y as part of solution path + sol[x][y] = 0; + return false; + } + return false; +} + +// driver program to test above function +int main() +{ + int maze[N][N] = { { 1, 0, 0, 0 }, + { 1, 1, 0, 1 }, + { 0, 1, 0, 0 }, + { 1, 1, 1, 1 } }; + solveMaze(maze); + return 0; +} +