Merge branch 'main' of https://github.com/skully-coder/hacktoberfest-competitiveprogramming

Author: skully-coder

Linked Lists/Middle Of Linked List/MiddleOfLinkedList.cpp

@@ -0,0 +1,52 @@
+#include <iostream>
+using namespace std;
+
+class Node {
+public:
+    int val;
+    Node *next;
+    Node(int v) {
+        val = v;
+        next = NULL;
+    }
+};
+
+void insertAtStart(Node* &head, int v) {
+    Node *n = new Node(v);
+    if (head == NULL) {
+        head = n;
+        return;
+    }
+    n->next  = head;
+    head = n;
+}
+
+Node* midOfLL(Node* head) {
+    if (head == NULL)
+        return head;
+    if (head->next == NULL)
+        return head;
+
+    Node* s = head;
+    Node* f = head->next;
+
+    while (f != NULL && f->next != NULL) {
+        s = s->next;
+        f = f->next;
+        f = f->next;
+    }
+    return s;
+}
+
+int main() {
+    Node* head = NULL;
+    insertAtStart(head, 6);
+    insertAtStart(head, 5);
+    insertAtStart(head, 4);
+    insertAtStart(head, 3);
+    insertAtStart(head, 2);
+    insertAtStart(head, 1);
+
+    Node* mid = midOfLL(head);
+    cout << mid->val << endl;
+}

Linked Lists/Middle Of Linked List/README.md

@@ -0,0 +1,12 @@
+# Middle of the Linked List 
+
+Given the head of a singly linked list, return the middle node of the linked list.
+If there are even nodes, then there would be two middle nodes, we need to print the second middle element.
+
+# Examples: 
+
+## Example 1: 
+ If the given linked list is 1->2->3->4->5 then the output should be 3.
+
+## Example 2: 
+If given linked list is 1->2->3->4->5->6 then the output should be 4.

Searching/KMP algorithm for pattern searching/READMEkmp.md.txt

@@ -0,0 +1,25 @@
+# Implement KMP algorithm for pattern search
+
+## 
+
+#### Time Complexity O(N) which best possible time we can get in any pattern serching algorithm
+
+This Function return indext of first element of match pattern elements as output.
+
+
+ 
+
+### Example 1:
+```
+Input: RDBMSSURSURAJJPG 
+Pattern to search : SURAJ
+Output: 9
+
+```
+### Example 2:
+```
+Input: SEROJSHASHESHERSHAH
+Pattern to search : SHERSHAH
+Output: 12
+
+```

Searching/KMP algorithm for pattern searching/main.c

@@ -0,0 +1,75 @@
+//KMP ALGOTITHM IN CPP
+
+#include <bits/stdc++.h>
+#include <iostream> 
+
+void computeLPSArray(char* pat, int M, int* lps);
+
+
+void KMPSearch(char* pat, char* txt)
+{
+	int M = strlen(pat);
+	int N = strlen(txt);
+	int lps[M];
+ 
+	computeLPSArray(pat, M, lps);
+
+	int i = 0; 
+	int j = 0; 
+	while (i < N) {
+		if (pat[j] == txt[i]) {
+			j++;
+			i++;
+		}
+
+		if (j == M) {
+			printf("Found pattern at index %d ", i - j);
+			j = lps[j - 1];
+		}
+
+		
+		else if (i < N && pat[j] != txt[i]) {
+			
+			if (j != 0)
+				j = lps[j - 1];
+			else
+				i = i + 1;
+		}
+	}
+}
+
+void computeLPSArray(char* pat, int M, int* lps)
+{
+	int len = 0;
+
+	lps[0] = 0;
+	int i = 1;
+	while (i < M) {
+		if (pat[i] == pat[len]) {
+			len++;
+			lps[i] = len;
+			i++;
+		}
+		else 
+		{
+			
+			if (len != 0) {
+				len = lps[len - 1];
+			}
+			else 
+			{
+				lps[i] = 0;
+				i++;
+			}
+		}
+	}
+}
+
+
+int main()
+{
+	char txt[] = "ABABDABACDABABCABAB";
+	char pat[] = "ABABCABAB";
+	KMPSearch(pat, txt);
+	return 0;
+}

Social/banner.png

@@ -0,0 +1,41 @@
+## Problem Statement  
+- You have been given a string s which consists of only characters '[', ']', '(', ')', '{', and '}'. Your task is to check whether the string is valid or not.
+1. Open brackets has to be closed with closing brackets properly.
+2. Open and closed brackets has to be in proper order.
+
+# Input Format
+
+You will be given a string 's'. 
+
+Constraints
+```
+1 <= s.length <= 104
+s consists of parentheses only i.e. '()[]{}'.
+```
+# Output Format
+
+The task is to complete the function isValid() which takes a string as a parameter. You will have to return true after checking if the string is valid otherwise false.
+
+Sample Input 1
+```
+"()[]{}"
+```
+Sample Output  1
+```
+true
+```
+
+Sample Input 2
+```
+"([)]"
+```
+Sample Output  2
+```
+false
+```
+
+Explanation
+```
+
+All the brackets exists in a pair with proper ordering.
+s = "(((}", s = "(]", and s="({[]}]" are invalid.

Stack/Valid Parenthesis/README.md

@@ -0,0 +1,37 @@
+#include <bits/stdc++.h>
+using namespace std;
+
+class Solution
+{
+public:
+    bool isParenthesisValid(string s)
+    {
+        stack<int> stk;
+
+        for (auto ch : s)
+        {
+            if (ch == '(' or ch == '[' or ch == '{')
+                stk.push(ch);
+
+            else {
+                if(stk.empty() or (stk.top() == '(' and ch != ')') or (stk.top() == '[' and ch != ']') or (stk.top() == '{' and ch != '}')) return false;
+                stk.pop();
+            }
+  
+        }
+
+        return stk.empty();
+    }
+};
+
+int main()
+{
+    string s;
+    cin >> s;
+    Solution *obj = new Solution;
+    bool valid = obj->isParenthesisValid(s);
+    if (valid)
+        cout << "Valid" << '\n';
+    else
+        cout << "Invalid" << '\n';
+}