HACKTOBER Selection_sort

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

Rat_in_maze.cpp

@@ -0,0 +1,91 @@
+// C++ program to solve Rat in a Maze problem using
+// backtracking
+#include <bits/stdc++.h>
+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<<" "<<sol[i][j]<<" ";
+		cout<<endl;
+	}
+}
+
+// A utility function to check if x, y is valid index for
+// N*N maze
+bool isSafe(int maze[N][N], int x, int y)
+{
+	// if (x, y outside maze) return false
+	if (x >= 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;
+}
+

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)