🚀 21-Aug-2020

Author: sureshmangs

backtracking/rat_in_a_maze.cpp

@@ -0,0 +1,66 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+#define N 4
+
+
+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;
+	}
+}
+
+
+bool isSafe(int maze[N][N], int x, int y){
+   return (x >= 0 && x < N && y >= 0 && y < N && maze[x][y]);
+}
+
+
+bool solveMaze(int maze[N][N], int x,int y, int sol[N][N]){
+	// if we reached our destination
+	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) {
+
+		sol[x][y] = 1;   // mark x, y as part of solution path
+
+		// Move forward in x direction
+		if (solveMaze(maze, x + 1, y, sol) == true)
+			return true;
+
+		// If moving in x direction doesn't give solution then move down in y direction
+		if (solveMaze(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;
+}
+
+
+int main(){
+	int maze[N][N] = { { 1, 0, 0, 0 },
+					{ 1, 1, 0, 1 },
+					{ 0, 1, 0, 0 },
+					{ 1, 1, 1, 1 } };
+
+    int sol[N][N];
+	memset(sol, 0, sizeof(sol));
+
+	if(solveMaze(maze, 0, 0, sol)== false){  // <maze, start x, start y, output matrix>
+		cout<<"Solution doesn't exist";
+	} else {
+	    printSolution(sol);
+	}
+
+	return 0;
+}

competitive programming/leetcode/143. Reorder List.cpp

@@ -0,0 +1,92 @@
+Given a singly linked list L: L0→L1→…→Ln-1→Ln,
+reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
+
+You may not modify the values in the list's nodes, only nodes itself may be changed.
+
+Example 1:
+
+Given 1->2->3->4, reorder it to 1->4->2->3.
+Example 2:
+
+Given 1->2->3->4->5, reorder it to 1->5->2->4->3.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+
+    ListNode* getMiddle(ListNode* head){
+        ListNode *slow=head, *fast=head;
+        while(fast!=NULL && fast->next!=NULL){
+            slow=slow->next;
+            fast=fast->next->next;
+        }
+        return slow;
+    }
+
+    ListNode* reverseList(ListNode* head){
+        if(!head) return head;
+        ListNode *prev=head, *curr=head, *ahead=head->next;
+        prev->next=NULL;
+        curr=ahead;
+        while(ahead!=NULL){
+            ahead=ahead->next;
+            curr->next=prev;
+            prev=curr;
+            curr=ahead;
+        }
+        head=prev;
+        return head;
+    }
+
+    void reorderList(ListNode* head) {
+        if(!head) return;
+        if(head->next==NULL) return; // only one element
+
+        // find middle of the list
+        ListNode *mid=getMiddle(head);
+
+        // Making middles previous equal to NULL
+        ListNode *curr=head;
+        while(curr->next!=mid){
+            curr=curr->next;
+        }
+        curr->next=NULL;
+
+        // reverse the list after mid
+        ListNode *revHead=reverseList(mid);
+
+        // connecting both the nodes in zigzag manner
+        ListNode *h1=head, *h2=revHead, *ahead=NULL;
+        while(h1!=NULL && h2!=NULL){
+            ahead=h1->next;
+            h1->next=h2;
+            h1=h2;
+            h2=ahead;
+        }
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-20-Reorder List.cpp

@@ -0,0 +1,92 @@
+Given a singly linked list L: L0→L1→…→Ln-1→Ln,
+reorder it to: L0→Ln→L1→Ln-1→L2→Ln-2→…
+
+You may not modify the values in the list's nodes, only nodes itself may be changed.
+
+Example 1:
+
+Given 1->2->3->4, reorder it to 1->4->2->3.
+Example 2:
+
+Given 1->2->3->4->5, reorder it to 1->5->2->4->3.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode() : val(0), next(nullptr) {}
+ *     ListNode(int x) : val(x), next(nullptr) {}
+ *     ListNode(int x, ListNode *next) : val(x), next(next) {}
+ * };
+ */
+class Solution {
+public:
+
+    ListNode* getMiddle(ListNode* head){
+        ListNode *slow=head, *fast=head;
+        while(fast!=NULL && fast->next!=NULL){
+            slow=slow->next;
+            fast=fast->next->next;
+        }
+        return slow;
+    }
+
+    ListNode* reverseList(ListNode* head){
+        if(!head) return head;
+        ListNode *prev=head, *curr=head, *ahead=head->next;
+        prev->next=NULL;
+        curr=ahead;
+        while(ahead!=NULL){
+            ahead=ahead->next;
+            curr->next=prev;
+            prev=curr;
+            curr=ahead;
+        }
+        head=prev;
+        return head;
+    }
+
+    void reorderList(ListNode* head) {
+        if(!head) return;
+        if(head->next==NULL) return; // only one element
+
+        // find middle of the list
+        ListNode *mid=getMiddle(head);
+
+        // Making middles previous equal to NULL
+        ListNode *curr=head;
+        while(curr->next!=mid){
+            curr=curr->next;
+        }
+        curr->next=NULL;
+
+        // reverse the list after mid
+        ListNode *revHead=reverseList(mid);
+
+        // connecting both the nodes in zigzag manner
+        ListNode *h1=head, *h2=revHead, *ahead=NULL;
+        while(h1!=NULL && h2!=NULL){
+            ahead=h1->next;
+            h1->next=h2;
+            h1=h2;
+            h2=ahead;
+        }
+    }
+};

competitive programming/leetcode/2020-August-Challenge/Day-22-Sort Array By Parity.cpp

@@ -0,0 +1,62 @@
+Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.
+
+You may return any answer array that satisfies this condition.
+
+
+
+Example 1:
+
+Input: [3,1,2,4]
+Output: [2,4,3,1]
+The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
+
+
+Note:
+
+1 <= A.length <= 5000
+0 <= A[i] <= 5000
+
+
+
+
+
+
+
+// Without extra space
+class Solution {
+public:
+    vector<int> sortArrayByParity(vector<int>& A) {
+        int n=A.size();
+        int j=0;
+        for(int i=0;i<n;i++){
+            if(A[i]%2==0){
+                swap(A[i], A[j]);
+                j++;
+            }
+        }
+        return A;
+    }
+};
+
+
+
+
+
+
+// Extra space
+class Solution {
+public:
+    vector<int> sortArrayByParity(vector<int>& A) {
+        int n=A.size();
+        vector<int> res(n);
+        int start=0, last=n-1;
+        for(int i=0;i<n;i++){
+            if(A[i]%2==0){
+                res[start++]=A[i];
+            } else {
+                res[last--]=A[i];
+            }
+        }
+        return res;
+    }
+};

competitive programming/leetcode/905. Sort Array By Parity.cpp

@@ -0,0 +1,62 @@
+Given an array A of non-negative integers, return an array consisting of all the even elements of A, followed by all the odd elements of A.
+
+You may return any answer array that satisfies this condition.
+
+
+
+Example 1:
+
+Input: [3,1,2,4]
+Output: [2,4,3,1]
+The outputs [4,2,3,1], [2,4,1,3], and [4,2,1,3] would also be accepted.
+
+
+Note:
+
+1 <= A.length <= 5000
+0 <= A[i] <= 5000
+
+
+
+
+
+
+
+// Without extra space
+class Solution {
+public:
+    vector<int> sortArrayByParity(vector<int>& A) {
+        int n=A.size();
+        int j=0;
+        for(int i=0;i<n;i++){
+            if(A[i]%2==0){
+                swap(A[i], A[j]);
+                j++;
+            }
+        }
+        return A;
+    }
+};
+
+
+
+
+
+
+// Extra space
+class Solution {
+public:
+    vector<int> sortArrayByParity(vector<int>& A) {
+        int n=A.size();
+        vector<int> res(n);
+        int start=0, last=n-1;
+        for(int i=0;i<n;i++){
+            if(A[i]%2==0){
+                res[start++]=A[i];
+            } else {
+                res[last--]=A[i];
+            }
+        }
+        return res;
+    }
+};