Merge branch 'smv1999:master' into master

Author: simranquirky

Backtracking/Knight's_Tour.java

@@ -0,0 +1,65 @@
+/*Moving according to the rules of chess knight must visit each square exactly once. Print the order of each the cell in which they are visited.*/
+import java.util.*;
+public class MyClass {
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        // provide start position
+        int r = sc.nextInt();
+        int c = sc.nextInt();
+        int board[][] = new int[n][n];
+        // The 8 possible moves where a knight can move from its current position
+        int posx[] = {-1,-1,1,1,-2,-2,2,2};
+        int posy[] = {-2,2,-2,2,-1,1,-1,1};
+        path(board, r, c, 1, posx, posy);
+    }
+    public static boolean path(int board[][], int row, int col, int move, int posx[], int posy[]) {
+        board[row][col] = move;
+        // if all the positions are visited then print the result
+        if (move == board.length*board.length) {
+            // printing result in matrix form
+            for (int i = 0; i < board.length; i++) {
+                for (int j = 0; j < board.length; j++)
+                    if (board[i][j] < 10)
+                        System.out.print("0" + board[i][j] + " ");
+                    else
+                        System.out.print(board[i][j] + " ");
+                System.out.println();
+            }
+            return true;
+        }
+        for (int i = 0; i < 8; i++) {
+            int newx = row + posx[i];
+            int newy = col + posy[i];
+            // checking if the new position is a valid move and not visited yet
+            if (validmove(newx, newy, board) && board[newx][newy] == 0) {
+                if (path(board, newx, newy, move + 1, posx, posy)) {
+                    return true;
+                }
+            }
+        }
+        // if position is not valid mark position as unvisited in the matrix
+        board[row][col] = 0;
+        return false;
+    }
+    // checks that the new position is not outside the matrix of n*n
+    static boolean validmove(int newx, int newy, int board[][]) {
+        if (newx >= 0 && newx < board.length && newy >= 0 && newy < board.length)
+            return true;
+        return false;
+    }
+}
+
+/*Input
+8
+0 
+0
+Output
+01 08 15 22 03 10 19 64 
+16 23 02 09 18 21 04 11 
+07 14 17 24 05 12 63 20 
+34 25 06 13 44 27 52 61 
+55 46 33 26 53 62 43 28 
+32 35 54 45 40 29 60 51 
+47 56 37 30 49 58 39 42 
+36 31 48 57 38 41 50 59 */

Backtracking/N-Queen Problem.cpp

@@ -0,0 +1,108 @@
+/* N-Queen Problem
+
+
+You have to place n queens on an nxn chessboard.
+Idea: Try all the possible positions for the queen. isSafe functions check whether
+the current position is safe or not
+
+*/
+
+#include<iostream>
+using namespace std;
+
+	
+bool isSafe(int board[][10], int i, int j, int n){
+	//Check in col
+		
+	for(int row=0;row<i;row++){
+		if(board[row][j] == 1){
+			return false;
+		}
+	}
+	//Left diagonal
+	int x=i;
+	int y=j;
+		
+	while(x>=0 && y>=0){
+		if(board[x][y]==1){
+			return false;
+		}
+		x--;
+		y--;
+	}
+	//Right diagonal
+	x=i;
+	y=j;
+		
+	while(x>=0 && y>=0){
+		if(board[x][y]==1){
+			return false;
+		}
+		x--;
+		y++;
+	}
+	//The position is safe
+	return true;
+	
+	
+}
+
+bool nQueen(int board[][10], int i,int n){
+	if(i==n){//base case
+	// Place Queeen in n rows (0..n-1)
+	//print the board
+	for(int i=0;i<n;i++){
+		for(int j=0;j<n;j++){
+			if(board[i][j]==1){
+				cout<<"Q ";
+			}
+			else{
+				cout<<"_ ";
+			}
+		}
+		cout<<endl;
+	}
+		return true;
+	}
+	//Recursive case
+	
+	for(int j=0;j<n;j++){
+		//Check i,j th position is safe to place the queen or not.
+		if(isSafe(board,i,j,n)){
+			//Place the Queen ,i, j in the right position
+			board[i][j]=1;
+			
+			if(nQueen(board,i+1,n)){
+				return true;
+			}
+			//Means i,j is not the right position
+			board[i][j]=0; //backtracking
+		}
+	}
+	//coudln't place the queen in current position.
+	return false;
+}
+		
+	
+int main(){
+	int n;
+	cin>>n;
+	
+	int board[10][10]={0};
+	nQueen(board,0,n);
+	
+	return 0;
+	
+}
+
+/* Input:
+4
+
+Output:
+
+_ Q _ _
+_ _ _ Q
+Q _ _ _
+_ _ Q _
+
+*/

Data Structures/Linked Lists/Singly Linked List/Single-linked-list-operations.py

@@ -6,6 +6,7 @@ def __init__(self, data=None, next=None):   # Creation of Node
         self.data = data
         self.next = next
 
+
 class LinkedList:
     def __init__(self):
         self.head = None  # head points the first node
@@ -88,13 +89,51 @@ def insert_values(self, data_list):
         for data in data_list:
             self.insert_at_end(data)
 
+    # removing element at linkedlist with Value
+    def removeval(self, value):
+        count = 0
+        temp = self.head
+        while temp:
+            if value != temp.data:
+                count += 1
+            temp = temp.next
+        if count == self.length():
+            print("Value is not present")
+
+        else:
+            if value == self.head.data:
+                self.head = self.head.next
+                return
+            temp = self.head
+            while temp:
+                if value == temp.next.data:
+                    temp.next = temp.next.next
+                    break
+
+                temp = temp.next
+
 
 if __name__ == '__main__':
     node1 = LinkedList()
-    node1.insert_values(["python","C++","C","Java"])
-    node1.insert_at(1,"Javascript")
-    node1.remove_at(2)
+    ins = list(input("Enter a values to be inserted by giving space[eg: python c++ java] : ").rstrip().split())
+    node1.insert_values(ins)
+    node1.print()
+    ind = int(input("Enter the index to be added: "))
+    val = input('Enter the value: ')
+    node1.insert_at(ind, val)
+    node1.print()
+    remm = int(input('Enter the index to be removed: '))
+    node1.remove_at(remm)
+    node1.print()
+    remval = input('Enter the value to be removed: ')
+    node1.removeval(remval)
+    node1.print()
+    inss = list(input("Enter a values to be inserted by giving space[eg: 45 30 22] : ").rstrip().split())
+    node1.insert_values(inss)
+    node1. print()
+    inend = int(input('Enter the number to be inserted at the end: '))
+    node1.insert_at_end(inend)
     node1.print()
-    node1.insert_values([45,7,12,567,99])
-    node1.insert_at_end(67)
+    remval1 = input('Enter the value to be removed: ')
+    node1.removeval(remval1)
     node1.print()

Data Structures/Linked Lists/Singly Linked List/oddEvenLinkedList.cpp

@@ -0,0 +1,120 @@
+/*
+
+Given the head of a singly linked list, group all the nodes with odd indices together followed by the nodes 
+with even indices, and return the reordered list.
+
+The first node is considered odd, and the second node is even, and so on.
+
+Note that the relative order inside both the even and odd groups should remain as it was in the input.
+
+You must solve the problem in O(1) extra space complexity and O(n) time complexity.
+
+Input: head = [1,2,3,4,5]
+Output: [1,3,5,2,4]
+
+Constraints:
+ n == number of nodes in the linked list
+ 0 <= n <= 104
+ -106 <= Node.val <= 106
+
+*/
+
+/*
+Time Complexity: O(N), where N is the size of the array
+Space Complexity: O(1), Constant Space
+*/
+
+/*
+
+Given the head of a singly linked list, group all the nodes with odd indices together followed by the nodes 
+with even indices, and return the reordered list.
+
+The first node is considered odd, and the second node is even, and so on.
+
+Note that the relative order inside both the even and odd groups should remain as it was in the input.
+
+You must solve the problem in O(1) extra space complexity and O(n) time complexity.
+
+Input: head = [1,2,3,4,5]
+Output: [1,3,5,2,4]
+
+Constraints:
+ n == number of nodes in the linked list
+ 0 <= n <= 104
+ -106 <= Node.val <= 106
+
+*/
+
+/*
+Time Complexity: O(N), where N is the size of the array
+Space Complexity: O(1), Constant Space
+*/
+
+#include <bits/stdc++.h>
+using namespace std;
+
+struct ListNode // Linked list node
+{
+    int val;
+    ListNode *next;
+    ListNode(int x)
+    {
+        val = x;
+        next = NULL;
+    }
+};
+
+ListNode *oddEvenList(ListNode *head)
+{
+    int len = 1;// variable to store length of linked List
+    ListNode *end = head;
+    if (head == NULL)
+        return NULL;
+    while (end->next != NULL) // calculation of length
+    {
+        end = end->next;
+        len++;
+    }
+    if (len <= 2)
+        return head;
+    ListNode *Nend = end; // pointer to point to the new end of the list
+    ListNode *temp = head;
+    while (temp != end)
+    { 
+        ListNode *t = temp->next; 
+        temp->next = t->next; // breaking the link
+        temp = temp->next; 
+        t->next = NULL;
+        Nend->next = t; // adding the node to the end
+        Nend = Nend->next; // updating end
+        if (t == end)
+            break;
+    }
+    return head;
+}
+void printList(ListNode *head) // function to print the list
+{
+    ListNode *temp = head;
+    while (temp != NULL)
+    {
+        cout<<temp->val<<" ";
+        temp = temp->next;
+    }
+    cout<<"\n";
+}
+int main() // driver function
+{
+    int data = 1; // adding the elements to the list
+    ListNode *head = new ListNode(data);
+    ListNode *tail = head;
+    for (int i = 2; i<=5 ; i++)
+    {
+        tail->next = new ListNode(i);
+        tail = tail->next;
+    }
+    
+    head = oddEvenList(head);
+    printList(head);
+
+    return 0;
+}