Merge branch 'main' into main

Author: vorenusCoA

README.md

@@ -0,0 +1,24 @@
+char *addBinary(const char *a, const char *b) {
+    int maxLen = strlen(a) > strlen(b) ? strlen(a) : strlen(b);
+    char *res = (char *)malloc((maxLen + 2) * sizeof(char));
+    memset(res, 0, (maxLen + 2) * sizeof(char));
+    unsigned int carry = 0;
+
+    for(int i = 0; i < maxLen; i++) {
+        unsigned int bitA = i < strlen(a) ? a[strlen(a) - i - 1] - '0' : 0;
+        unsigned int bitB = i < strlen(b) ? b[strlen(b) - i - 1] - '0' : 0;
+
+        unsigned int total = bitA + bitB + carry;
+        char sum = '0' + total % 2;
+        carry = total / 2;
+
+        // Add to the beginning of the string
+        memmove(res + 1, res, strlen(res));
+        res[0] = sum;
+    }
+    if(carry) {
+        memmove(res + 1, res, strlen(res));
+        res[0] = '1';
+    }
+    return res;
+}

c/0067-add-binary.c

@@ -0,0 +1,27 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+struct ListNode *getIntersectionNode(struct ListNode *headA, struct ListNode *headB) {
+        struct ListNode *currA = headA;
+        struct ListNode *currB = headB;
+
+        while (currA && currB){
+            if (currA == currB){
+                return currA;
+            }
+            currA = currA->next;
+            currB = currB->next;
+
+            if (!currA && currB){
+                currA = headB;
+            }
+            if (!currB && currA){
+                currB = headA;
+            }
+        }
+    return NULL;
+}

c/0160-intersection-of-two-linked-lists.c

@@ -0,0 +1,45 @@
+// Compare two numbers in a concatenated form.
+// eg: 12 and 34 will be compared as 1234 vs 3412
+int compareInt(const void *a, const void *b) {
+    int i = 10;
+    int j = 10;
+    int x = *(int*)a;
+    int y = *(int*)b;
+
+    while (x /= 10) i *= 10;
+    while (y /= 10) j *= 10;
+
+    return  (((unsigned int)*(int*)b * i) + *(int*)a) > (((unsigned int)*(int*)a * j) + *(int*)b);
+}
+
+char * largestNumber(int* nums, int numsSize){
+    char *res = NULL;
+    int i, len, pos;
+
+    if (numsSize < 0) {
+        return res;
+    }
+
+    // Sort the array with specified comparaotor.
+    qsort(nums, numsSize, sizeof(int), compareInt);
+
+    // Caculate the length of the return string.
+    len = 1;
+    for (i = 0; i < numsSize; i++) len +=  snprintf(NULL, 0, "%d", nums[i]);
+    res = calloc(len, sizeof(char));
+
+    // If the firs element of sorted array is 0,
+    // return a single digit of 0 no matter how long is the string.
+    if (nums[0] == 0) {
+        res[0] = '0';
+        return res;
+    }
+
+    // Print all nums to the return string.
+    pos = 0;
+    for (i = 0; i < numsSize; i++) {
+        pos += snprintf(res + pos, len, "%d", nums[i]);
+    }
+
+    return res;
+}

c/0179-largest-number.c

@@ -0,0 +1,36 @@
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     struct ListNode *next;
+ * };
+ */
+bool isPalindrome(struct ListNode* head){
+
+    // find middle of linked list
+    struct ListNode *slow = head, *fast = head;
+    while (fast && fast->next){
+        slow = slow->next;
+        fast = fast->next->next;
+    }
+    // reverse second half
+    struct ListNode* prev = NULL;
+    while (slow){
+        struct ListNode* nxt = slow->next;
+        slow->next = prev;
+        prev = slow;
+        slow = nxt;
+    }
+
+    // compare left and right
+    struct ListNode *left=head, *right=prev;
+    while (right){
+        if (left->val != right->val){
+            return false;
+        }
+        left = left->next;
+        right = right->next;
+    }
+    return true;
+    
+}

c/0234-palindrome-linked-list.c

@@ -0,0 +1,47 @@
+#define FREE_AND_RETURN(x, y) \
+free(x); \
+return y;
+
+bool checkSubarraySum(int* nums, int numsSize, int k){
+    unsigned int* sums = NULL;
+    int i, j;
+
+    // Early return edge cases.
+    if (numsSize < 2) {
+        return false;
+    }
+    if (k == 1) {
+        return true;
+    }
+
+    sums = (unsigned int*)malloc(numsSize * sizeof(unsigned int));
+    sums[0] = nums[0];
+    for (i = 1; i < numsSize; i++) {
+        // Return true, when there are two continuous nums are times of k.
+        if (nums[i] % k == 0 && nums[i - 1] % k == 0) {
+            FREE_AND_RETURN(sums, true);
+        }
+
+        sums[i] = nums[i] + sums[i - 1];
+
+        // Return true, when the current subarray sum is times of k.
+        if (sums[i] % k == 0) {
+            FREE_AND_RETURN(sums, true);
+        }
+    }
+
+    for (i = 0; i < numsSize; i++) {
+        if (sums[i] < k) {
+            continue;
+        }
+
+        for (j = 0; j < i - 1; j++) {
+            // Return true, when the any subarray sum is times of k.
+            if ((sums[i] - sums[j]) % k == 0) {
+                FREE_AND_RETURN(sums, true);
+            }
+        }
+    }
+
+    FREE_AND_RETURN(sums, false);
+}

c/0523-continuous-subarray-sum.c

@@ -0,0 +1,130 @@
+typedef struct Node {
+    struct Node* next;
+    struct Node* prev;
+    int val;
+} Node;
+
+typedef struct {
+    Node* head;
+    Node* tail;
+    int length;
+} MyLinkedList;
+
+Node* createNode(int val) {
+    Node* new_node = (Node*)malloc(sizeof(Node) );
+    new_node->next = NULL;
+    new_node->prev = NULL;
+    new_node->val = val;
+    return new_node;
+}
+
+MyLinkedList* myLinkedListCreate() {
+    MyLinkedList* list = (MyLinkedList*)malloc(sizeof(MyLinkedList) );
+    list->head = createNode(-1);
+    list->tail = list->head;
+    list->length = 0;
+    return list;
+}
+
+Node* traverseList(MyLinkedList* obj, int index) {
+    if (index < 0 || index >= obj->length)
+        return NULL;
+    Node* trev = obj->head;
+    while (index >= 0) {
+        trev = trev->next;
+        index -= 1;
+    }
+    return trev; 
+}
+
+int myLinkedListGet(MyLinkedList* obj, int index) {
+    Node *node = traverseList(obj, index);
+    if (node != NULL)
+        return node->val;
+    return -1;
+}
+
+void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
+    Node* new_node = createNode(val);
+    new_node->next = obj->head->next;
+    new_node->prev = obj->head;
+    obj->head->next = new_node;
+    if (new_node->next != NULL)
+        new_node->next->prev = new_node;
+    else
+        obj->tail = new_node;
+    obj->length += 1;
+    return;
+}
+
+void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
+    Node* new_node = createNode(val);
+    obj->tail->next = new_node;
+    new_node->prev = obj->tail;
+    obj->tail = obj->tail->next;
+    obj->length += 1;
+    return;
+}
+
+void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
+    if (index == 0) {
+        myLinkedListAddAtHead(obj, val);
+        return;
+    }
+    else if (index == obj->length) {
+        myLinkedListAddAtTail(obj, val);
+        return;
+    }
+    Node* prev_node = traverseList(obj, index - 1);
+    if (prev_node == NULL)
+        return;
+    Node* new_node = createNode(val);
+    new_node->next = prev_node->next;
+    new_node->prev = prev_node;
+    prev_node->next = new_node;
+    if (new_node->next != NULL)
+        new_node->next->prev = new_node;
+    obj->length += 1;
+    return;
+}
+
+void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
+    Node *node = traverseList(obj, index);
+    if (node == NULL)
+        return;
+    Node *temp = node;
+    node->prev->next = node->next;
+    if (node->next != NULL)
+        node->next->prev = node->prev;
+    else
+        obj->tail = node->prev; 
+    obj->length -= 1;
+    free(temp);
+    return;
+}
+
+void myLinkedListFree(MyLinkedList* obj) {
+    Node *prev = NULL, *cur = obj->head;
+    while (cur != NULL) {
+        prev = cur;
+        cur = cur->next;
+        free(prev);
+    }
+    free(obj);
+}
+
+/**
+ * Your MyLinkedList struct will be instantiated and called as such:
+ * MyLinkedList* obj = myLinkedListCreate();
+ * int param_1 = myLinkedListGet(obj, index);
+ 
+ * myLinkedListAddAtHead(obj, val);
+ 
+ * myLinkedListAddAtTail(obj, val);
+ 
+ * myLinkedListAddAtIndex(obj, index, val);
+ 
+ * myLinkedListDeleteAtIndex(obj, index);
+ 
+ * myLinkedListFree(obj);
+*/

c/0707-design-linked-list.c

@@ -0,0 +1,36 @@
+// Time Complexity = O(n^3)
+// Space Complexity = O(n)
+
+class Solution {
+public:
+    vector<vector<int>> fourSum(vector<int>& nums, int target) {
+        sort(nums.begin(), nums.end());
+
+        vector<vector<int> > res;
+        int n = nums.size();
+
+        for (int i = 0; i < n; i++) {
+            if (i > 0 && nums[i] == nums[i - 1])
+                continue;
+            for (int j = i + 1; j < n; j++) {
+                if (j > (i + 1) && nums[j] == nums[j - 1])
+                    continue;
+                int l = j + 1, r = n - 1;
+                while (l < r) {
+                    long sm = (long)nums[i] + (long)nums[j] + (long)nums[l] + (long)nums[r];
+                    if (sm == target) {
+                        res.push_back(vector<int>{nums[i], nums[j], nums[l], nums[r]});
+                        l += 1;
+                        while (l < r && nums[l] == nums[l - 1])
+                            l += 1;
+                    }
+                    else if (sm > target)
+                        r -= 1;
+                    else
+                        l += 1;
+                }
+            }
+        }
+        return res;
+    }
+};

cpp/0018-4sum.cpp

@@ -0,0 +1,45 @@
+/*
+    Given the head of a linked list, rotate the list to the right by k places.
+    Example: list = [1,2,3,4,5] and k = 2
+    Output: [4,5,1,2,3]
+    
+    Time complexity: O(n)
+    Space complexity: O(1)
+*/
+
+class Solution {
+private:
+    int findLen(ListNode* head){
+        int len = 0;
+        while(head!=NULL){
+            len++;
+            head = head->next;
+        }
+        return len;
+    }
+    ListNode* findNewHead(ListNode* head,int k){
+        int i=0;
+        while(i+1<k){
+            i++;
+            head = head->next;
+        }
+        ListNode* ret = head->next;
+        head->next = NULL;
+        return ret;
+    }
+    ListNode* findLast(ListNode* head){
+        while(head->next!=NULL) head = head->next;
+        return head;
+    }
+public:
+    ListNode* rotateRight(ListNode* head, int k) {
+        int len = findLen(head); // Finds the length of the Linked List
+        if(len==0) return head;
+        k = k%len;
+        if(k==0) return head;
+        ListNode* newHead = findNewHead(head,len-k); // Finds the node that is the new head
+        ListNode* last = findLast(newHead); // Finds the last node from the new head and connects it to the previous head
+        last->next = head;
+        return newHead;
+    }
+};