Merge branch 'main' of https://github.com/Maunish-dave/leetcode

Author: Maunish-dave

README.md

@@ -0,0 +1,142 @@
+#include <stdlib.h>
+#include <assert.h>
+
+// A structure to represent an element of the stack.
+typedef struct Node {
+    int value;
+    struct Node* next;
+} Node;
+
+Node* nodeCreate(int val) {
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->value = val;
+    node->next = NULL;
+    return node;
+}
+
+void nodePush(Node** obj, int val) {
+    assert(obj);
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->value = val;
+    node->next = *obj;
+    *obj = node;
+}
+
+void nodePop(Node** obj) {
+    assert(obj);
+    if (*obj) {
+        Node* tmp = *obj;
+        *obj = tmp->next;
+        free(tmp);
+    }
+}
+
+// A structure to represent a stack.
+typedef struct {
+    int size;
+    Node* top;
+} MyStack;
+
+MyStack* stackCreate()
+{
+    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
+    stack->size = 0;
+    stack->top = NULL;
+    return stack;
+}
+
+void stackPush(MyStack* stack, int item)
+{
+    if (!stack->top) {
+        stack->top = nodeCreate(item);
+    } else {
+        nodePush(&stack->top, item);
+    }
+    stack->size++;
+}
+
+void stackPop(MyStack* stack)
+{
+    nodePop(&stack->top);
+    stack->size--;
+}
+
+int stackTop(MyStack* stack)
+{
+    assert(stack);
+    assert(stack->top);
+    return stack->top->value;
+}
+
+typedef struct {
+    MyStack* stk;
+    MyStack* minStk;
+} MinStack;
+
+MinStack* minStackCreate() {
+    MinStack* min = (MinStack*)malloc(sizeof(MinStack));
+    min->stk = NULL;
+    min->minStk = NULL;
+    return min;
+}
+
+void minStackPush(MinStack* obj, int val) {
+    assert(obj);
+    if(!obj->stk) {
+        obj->stk = stackCreate();
+        obj->minStk = stackCreate();
+    }
+    stackPush(obj->stk, val);
+    if (obj->minStk->top) {
+        int minTop = stackTop(obj->minStk);
+        if ( val < minTop) {
+            stackPush(obj->minStk, val);
+        } else {
+            stackPush(obj->minStk, minTop);
+        }
+    } else {
+        stackPush(obj->minStk, val);
+    }
+}
+
+void minStackPop(MinStack* obj) {
+    assert(obj);
+    stackPop(obj->stk);
+    stackPop(obj->minStk);
+}
+
+int minStackTop(MinStack* obj) {
+    assert(obj);
+    return stackTop(obj->stk);
+}
+
+int minStackGetMin(MinStack* obj) {
+    assert(obj);
+    return stackTop(obj->minStk);
+}
+
+void minStackFree(MinStack* obj) {
+    assert(obj);
+    if (obj->stk) {
+        while(obj->stk->top) {
+            stackPop(obj->stk);
+        }
+        while(obj->minStk->top) {
+            stackPop(obj->minStk);
+        }
+        free(obj->stk);
+        free(obj->minStk);
+    }
+    free(obj);
+}
+
+/**
+ * Your MinStack struct will be instantiated and called as such:
+ * MinStack* obj = minStackCreate();
+ * minStackPush(obj, val);
+ * minStackPop(obj);
+ * int param_3 = minStackTop(obj);
+ * int param_4 = minStackGetMin(obj);
+ * minStackFree(obj);
+ */
+

c/0155-min-stack.c

@@ -0,0 +1,136 @@
+// A structure to represent an element of the queue.
+typedef struct Node {
+    int value;
+    struct Node* next;
+} Node;
+
+typedef struct MyQueue {
+    int size;
+    Node* front;
+    Node* rear;
+} MyQueue;
+
+MyQueue* MyQueueCreate() {
+    MyQueue* queue = (MyQueue*)malloc(sizeof(MyQueue));
+    queue->size = 0;
+    queue->front = NULL;
+    queue->rear = NULL;
+    return queue;
+}
+
+void MyQueuePush(MyQueue** obj, int val) {
+    assert(obj);
+    assert(*obj);
+    MyQueue* queue = *obj;
+    Node* node = (Node*)malloc(sizeof(Node));
+    node->value = val;
+    node->next = NULL;
+    if (queue->rear) {
+        queue->rear->next = node;
+        queue->rear = node;
+    } else {
+        queue->front = node;
+        queue->rear = node;
+    }
+    queue->size++;
+}
+
+void MyQueuePop(MyQueue** obj) {
+    assert(obj);
+    assert(*obj);
+    MyQueue* queue = *obj;
+    Node* tmp = queue->front;
+    if (queue->size > 0 && tmp) {
+        queue->front = queue->front->next;
+        queue->size--;
+        free(tmp);
+    }
+    if (queue->rear == tmp) {
+        queue->rear = NULL;
+    }
+}
+
+int MyQueueFront(MyQueue** obj) {
+    assert(obj);
+    MyQueue* queue = *obj;
+    assert(queue->front);
+    return queue->front->value;
+}
+
+int MyQueueRear(MyQueue** obj) {
+    assert(obj);
+    MyQueue* queue = *obj;
+    assert(queue->rear);
+    return queue->rear->value;
+}
+
+int MyQueueSize(MyQueue** obj) {
+    assert(obj);
+    assert(*obj);
+    return (*obj)->size;
+}
+
+typedef struct {
+    MyQueue* queue;
+} MyStack;
+
+
+MyStack* myStackCreate() {
+    MyStack* stack = (MyStack*)malloc(sizeof(MyStack));
+    stack->queue = NULL;
+    return stack;
+}
+
+void myStackPush(MyStack* obj, int x) {
+    assert(obj);
+    int size;
+    if (!obj->queue) {
+        obj->queue = MyQueueCreate();
+    }
+    MyQueuePush(&obj->queue, x);
+    size = obj->queue->size;
+    while(--size > 0) {
+        MyQueuePush(&obj->queue, MyQueueFront(&obj->queue));
+        MyQueuePop(&obj->queue);
+    }
+}
+
+int myStackPop(MyStack* obj) {
+    assert(obj);
+    int val = MyQueueFront(&obj->queue);
+    MyQueuePop(&obj->queue);
+    return val;
+}
+
+int myStackTop(MyStack* obj) {
+    assert(obj);
+    assert(obj->queue);
+    return MyQueueFront(&obj->queue);
+}
+
+bool myStackEmpty(MyStack* obj) {
+    assert(obj);
+    if (obj->queue) {
+        return obj->queue->size == 0;
+    }
+    return true;
+}
+
+void myStackFree(MyStack* obj) {
+    if(obj) {
+        while(obj->queue && obj->queue->front) {
+            MyQueuePop(&obj->queue);
+        }
+        free(obj);
+    }
+}
+
+/**
+ * Your MyStack struct will be instantiated and called as such:
+ * MyStack* obj = myStackCreate();
+ * myStackPush(obj, x);
+ * int param_2 = myStackPop(obj);
+ * int param_3 = myStackTop(obj);
+ * bool param_4 = myStackEmpty(obj);
+ * myStackFree(obj);
+ */

c/0225-implement-stack-using-queue.c

@@ -0,0 +1,14 @@
+class Solution {
+  String longestCommonPrefix(List<String> strs) {
+      String res = "";
+      for (int i=0; i<strs[0].length; i++) {
+          for (String s in strs) {
+              if (i >= s.length || strs[0][i] != s[i]){
+                  return res;
+              }
+          }
+          res += strs[0][i];
+      }
+      return res;
+  }
+}

dart/0014-longest-common-prefix.dart

@@ -0,0 +1,36 @@
+class Solution {
+  bool isValid(String s) {
+      var res = [];
+      for (int i=0; i<s.length; i++) {
+          if (s[i] != ']' && s[i] != ')' && s[i] != '}') {
+              res.add(s[i]);
+              continue;
+          } else {
+              if (res.isEmpty) {
+                  return false;
+              }
+          }
+
+          if (s[i] == ']') {
+              if (res.last == '[') {
+                  res.removeLast();
+              } else {
+                  return false;
+              }
+          } else if (s[i] == ')') {
+              if (res.last == '(') {
+                  res.removeLast();
+              } else {
+                  return false;
+              }
+          } else if (s[i] == '}') {
+              if (res.last == '{') {
+                  res.removeLast();
+              } else {
+                  return false;
+              }
+          }
+      }
+      return res.length == 0;
+  }
+}

dart/0020-valid-parentheses.dart

@@ -0,0 +1,26 @@
+/**
+ * Definition for singly-linked list.
+ * class ListNode {
+ *   int val;
+ *   ListNode? next;
+ *   ListNode([this.val = 0, this.next]);
+ * }
+ */
+class Solution {
+  ListNode? mergeTwoLists(ListNode? list1, ListNode? list2) {
+      ListNode? head = ListNode();
+      ListNode? cur = head;
+      while (list1 != null && list2 != null) {
+          if (list1!.val < list2!.val) {
+              cur!.next = list1;
+              list1 = list1!.next;
+          } else {
+              cur!.next = list2;
+              list2 = list2!.next;
+          }
+          cur = cur!.next;
+      }
+      cur!.next = (list1 == null) ? list2 : list1;
+      return head.next;
+  }
+}

dart/0021-merge-two-sorted-lists.dart

@@ -0,0 +1,17 @@
+class Solution {
+  int removeElement(List<int> nums, int val) {
+      int i = 0;
+      int end = nums.length - 1;
+      while (i <= end) {
+          if (nums[i] == val) {
+              int tmp = nums[end];
+              nums[end] = nums[i];
+              nums[i] = tmp;
+              end -= 1;
+          } else {
+              i += 1;
+          }
+      }
+      return i;
+  }
+}

dart/0027-remove-element.dart

@@ -0,0 +1,6 @@
+class Solution {
+  int lengthOfLastWord(String s) {
+      final words = s.trim().split(" ");
+      return words[words.length - 1].length;
+  }
+}