keshav singh

Hash dividing string

@@ -0,0 +1,22 @@
+
+char* stringHash(char* s, int k) {
+    int n = strlen(s);
+    int resultSize = n / k;
+    char* result = (char*)malloc((resultSize + 1) * sizeof(char));
+    if (result == NULL) {
+        return NULL;
+    }
+
+    result[resultSize] = '\0';
+
+    for (int i = 0; i < resultSize; i++) {
+        int sum = 0;
+        for (int j = 0; j < k; j++) {
+            sum += s[i * k + j] - 'a';
+        }
+        int hashedChar = sum % 26;
+        result[i] = 'a' + hashedChar;
+    }
+
+    return result;
+}

anagram.c

@@ -0,0 +1,28 @@
+#include <stdbool.h>
+
+bool isAnagram(char* s, char* t) {
+    int sLen = strlen(s);
+    int tLen = strlen(t);
+
+    if (sLen != tLen) {
+        return false;
+    }
+
+    int charCount[26] = {0};
+
+    for (int i = 0; i < sLen; i++) {
+        charCount[s[i] - 'a']++;
+    }
+
+    for (int i = 0; i < tLen; i++) {
+        charCount[t[i] - 'a']--;
+    }
+
+    for (int i = 0; i < 26; i++) {
+        if (charCount[i] != 0) {
+            return false;
+        }
+    }
+
+    return true;
+}

check if number

@@ -0,0 +1,17 @@
+
+bool digitCount(char* num) {
+    int n = strlen(num);
+    int counts[10] = {0};
+
+    for (int i = 0; i < n; i++) {
+        counts[num[i] - '0']++;
+    }
+
+    for (int i = 0; i < n; i++) {
+        if (counts[i] != (num[i] - '0')) {
+            return false;
+        }
+    }
+
+    return true;
+}

contains duplicate

@@ -0,0 +1,19 @@
+
+int cmp(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b); 
+}
+
+bool containsDuplicate(int* nums, int numsSize) {
+    if (numsSize <= 1) {
+        return false;
+    }
+
+    qsort(nums, numsSize, sizeof(int), cmp);
+
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i] == nums[i - 1]) { 
+            return true;
+        }
+    }
+    return false;
+}

divide two integers

@@ -0,0 +1,22 @@
+#include <limits.h>
+#include <stdlib.h>
+
+int divide(int dividend, int divisor) {
+    if (dividend == INT_MIN && divisor == -1) return INT_MAX;
+    long long a = llabs((long long)dividend);
+    long long b = llabs((long long)divisor);
+    long long res = 0;
+    while (a >= b) {
+        long long temp = b, multiple = 1;
+        while (a >= (temp << 1)) {
+            temp <<= 1;
+            multiple <<= 1;
+        }
+        a -= temp;
+        res += multiple;
+    }
+    if ((dividend > 0) ^ (divisor > 0)) res = -res;
+    if (res > INT_MAX) return INT_MAX;
+    if (res < INT_MIN) return INT_MIN;
+    return (int)res;
+}

duplicate

@@ -0,0 +1,19 @@
+
+int cmp(const void* a, const void* b) {
+    return (*(int*)a - *(int*)b); 
+}
+
+bool containsDuplicate(int* nums, int numsSize) {
+    if (numsSize <= 1) {
+        return false;
+    }
+
+    qsort(nums, numsSize, sizeof(int), cmp);
+
+    for (int i = 1; i < numsSize; i++) {
+        if (nums[i] == nums[i - 1]) { 
+            return true;
+        }
+    }
+    return false;
+}