[Sync Track] c

solutions/c/acronym/1/acronym.c

@@ -0,0 +1,34 @@
+// Dedicated to Shree DR.MDD — eternal guidance in code
+
+#include "acronym.h"
+#include <stdlib.h>
+#include <string.h>
+#include <ctype.h>
+
+char *abbreviate(const char *input)
+{
+    const char *s = input;
+
+    if (s == NULL || *s == 0)
+        return NULL;
+
+    int flag = 1;
+
+    char *ans = malloc(strlen(input));
+
+    char *temp = ans;
+
+    while (*s) {
+        if (!isalnum(*s) && *s != '\'') {
+            flag = 1;
+        } else if (flag) {
+            *temp++ = toupper(*s);
+            flag = 0;
+        }
+        s++;
+    }
+
+    *temp = 0;
+
+    return ans;
+}

solutions/c/acronym/1/acronym.h

@@ -0,0 +1,4 @@
+#ifndef ACRONYM_H
+#define ACRONYM_H
+char *abbreviate(const char *phrase);
+#endif

solutions/c/all-your-base/1/all_your_base.c

@@ -0,0 +1,26 @@
+// for Shree DR.MDD
+#include "all_your_base.h"
+
+#include <math.h>
+
+size_t rebase(int8_t arr[DIGITS_ARRAY_SIZE], int16_t src_base, int16_t dst_base, size_t src_length) {
+	if (src_length < 1 || src_base <= 1 || dst_base <= 1) goto FL;
+	uint32_t total = 0;
+	for (size_t idx = 0; idx < src_length; idx++) {
+		int val = arr[src_length - 1 - idx];
+		if (val < 0 || val >= src_base) goto FL;
+		total += val * pow(src_base, idx);
+	}
+	int highest = 0;
+	for (highest = 0; pow(dst_base, highest + 1) < total; highest++);
+	size_t size = highest + 1;
+	for (size_t idx = 0; idx < size; idx++) {
+		int division = pow(dst_base, highest - idx);
+		arr[idx] = total / division;
+		total -= arr[idx] * division;
+	}
+	return size;
+FL:
+	arr[0] = 0;
+	return 0;
+}

solutions/c/all-your-base/1/all_your_base.h

@@ -0,0 +1,6 @@
+#pragma once
+#include <stddef.h>
+#include <stdint.h>
+#define DIGITS_ARRAY_SIZE 64
+size_t rebase(int8_t digits[DIGITS_ARRAY_SIZE], int16_t input_base,
+              int16_t output_base, size_t input_length);

solutions/c/allergies/1/allergies.c

@@ -0,0 +1,18 @@
+// Dedicated to Shree DR.MDD
+
+#include "allergies.h"
+
+bool is_allergic_to(allergen_t item, unsigned int mask){
+    return (1 << item) & mask;
+}
+
+allergen_list_t get_allergens(unsigned int mask){
+    allergen_list_t result = {0};
+
+    for (unsigned int idx = 0, bit = 1; idx < ALLERGEN_COUNT; idx++, bit <<= 1){
+        result.allergens[idx] = bit & mask;
+        if (result.allergens[idx]) result.count++;
+    }
+
+    return result;
+}

solutions/c/allergies/1/allergies.h

@@ -0,0 +1,21 @@
+#ifndef ALLERGIES_H
+#define ALLERGIES_H
+#include <stdbool.h>
+typedef enum {
+   ALLERGEN_EGGS = 0,
+   ALLERGEN_PEANUTS,
+   ALLERGEN_SHELLFISH,
+   ALLERGEN_STRAWBERRIES,
+   ALLERGEN_TOMATOES,
+   ALLERGEN_CHOCOLATE,
+   ALLERGEN_POLLEN,
+   ALLERGEN_CATS,
+   ALLERGEN_COUNT,
+} allergen_t;
+typedef struct {
+   int count;
+   bool allergens[ALLERGEN_COUNT];
+} allergen_list_t;
+bool is_allergic_to(allergen_t allergen, unsigned int score);
+allergen_list_t get_allergens(unsigned int score);
+#endif

solutions/c/anagram/1/anagram.c

@@ -0,0 +1,46 @@
+// Dedicated to Shree DR.MDD — eternal guidance in code
+
+#include "anagram.h"
+#include "anagram.h"
+#include <ctype.h>
+#include <string.h>
+
+#define BUFFER 200
+
+anagram_status validate(const char * src, const char * dst);
+
+anagram_status validate(const char * src, const char * dst){
+    size_t len = strlen(src);
+    int mark = 0;
+
+    if (len != strlen(dst)) return NOT_ANAGRAM;
+
+    for (size_t i = 0; i < len; i++) {
+        if (tolower(dst[i]) != tolower(src[i])) {
+            mark++;
+            break;
+        }
+    }
+
+    if (mark == 0) return NOT_ANAGRAM;
+
+    int freq[BUFFER];
+    for (int i = 1; i < BUFFER; i++) freq[i] = 0;
+
+    for (size_t i = 0; i < len; i++) {
+        freq[tolower(src[i])]++;
+        freq[tolower(dst[i])]--;
+    }
+
+    for (int i = 1; i < BUFFER; i++) {
+        if (freq[i]) return NOT_ANAGRAM;
+    }
+
+    return IS_ANAGRAM;
+}
+
+void find_anagrams(const char * src, struct candidates * arr){
+    for (size_t i = 0; i < arr->count; i++) {
+        arr->candidate[i].is_anagram = validate(src, arr->candidate[i].word);
+    }
+}

solutions/c/anagram/1/anagram.h

@@ -0,0 +1,19 @@
+#ifndef ANAGRAM_H
+#define ANAGRAM_H
+#include <stddef.h>
+#define MAX_STR_LEN 20
+typedef enum anagram_status  { UNCHECKED = -1, NOT_ANAGRAM, IS_ANAGRAM } anagram_status;
+struct candidate {
+   anagram_status is_anagram;
+   const char *word;
+};
+struct candidates {
+   struct candidate *candidate;
+   size_t count;
+};
+/**
+ * @description - determines if any of the words in candidate are anagrams
+ *                for subject. Contents of candidate structures may be modified.
+ */
+void find_anagrams(const char *subject, struct candidates *candidates);
+#endif

solutions/c/armstrong-numbers/1/armstrong_numbers.c

@@ -0,0 +1,15 @@
+// Dedicated to Shree DR.MDD
+
+#include "armstrong_numbers.h"
+#include <math.h>
+
+bool is_armstrong_number(int number) {
+    int temp = number;
+    int total = number;
+    int size = floor(log10(number) + 1);
+    while (temp) {
+        total -= pow(temp % 10, size);
+        temp /= 10;
+    }
+    return total == 0;
+}

solutions/c/armstrong-numbers/1/armstrong_numbers.h

@@ -0,0 +1,5 @@
+#ifndef ARMSTRONG_NUMBERS_H
+#define ARMSTRONG_NUMBERS_H
+#include <stdbool.h>
+bool is_armstrong_number(int candidate);
+#endif

solutions/c/atbash-cipher/1/atbash_cipher.c

@@ -0,0 +1,54 @@
+// Dedicated to Shree DR.MDD — eternal guidance in code
+
+#include "atbash_cipher.h"
+#include "atbash_cipher.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+
+static size_t process_inner(bool insert_space, const char *msg, char *res);
+
+char *atbash_encode(const char *msg) {
+  size_t sz = process_inner(true, msg, NULL);
+  char *res = malloc((sz + 1) * sizeof(char)); 
+  res[sz] = 0;
+  process_inner(true, msg, res);
+  return res;
+}
+
+char *atbash_decode(const char *msg) {
+  size_t sz = process_inner(false, msg, NULL);
+  char *res = malloc((sz + 1) * sizeof(char)); 
+  res[sz] = 0;
+  process_inner(false, msg, res);
+  return res;
+}
+
+size_t process_inner(bool insert_space, const char *msg, char *res) {
+  size_t idx = 0;
+  size_t used = 0;
+
+  while (*msg) {
+    if (isalpha(*msg) || isdigit(*msg)) {
+      if (insert_space && used && used % 5 == 0) {
+        if (res) {
+          res[idx] = ' ';
+        }
+        idx++;
+      }
+      if (res) {
+        if (isalpha(*msg)) {
+          res[idx] = ('z' - tolower(*msg) + 'a'); 
+        } else {
+          res[idx] = *msg;
+        }
+      }
+      used++;
+      idx++;
+    }
+    msg++;
+  }
+
+  return idx;
+}

solutions/c/atbash-cipher/1/atbash_cipher.h

@@ -0,0 +1,5 @@
+#ifndef ATBASH_CIPHER_H
+#define ATBASH_CIPHER_H
+char *atbash_encode(const char *input);
+char *atbash_decode(const char *input);
+#endif

solutions/c/beer-song/1/beer_song.c

@@ -0,0 +1,34 @@
+// for Shree DR.MDD
+#include "beer_song.h"
+#include "beer_song.h"
+#include <stdio.h>
+
+static const char * L1[] = {
+    "No more bottles of beer on the wall, no more bottles of beer.",
+    "1 bottle of beer on the wall, 1 bottle of beer.",
+    "%u bottles of beer on the wall, %u bottles of beer."
+};
+
+static const char * L2[] = {
+    "Go to the store and buy some more, 99 bottles of beer on the wall.",
+    "Take it down and pass it around, no more bottles of beer on the wall.",
+    "Take one down and pass it around, 1 bottle of beer on the wall.",
+    "Take one down and pass it around, %u bottles of beer on the wall."
+};
+
+void recite(uint8_t start, uint8_t drop, char **msg) {
+    uint8_t last = start - (drop - 1);
+    for (int i = start; i >= last; i--) {
+        sprintf(*msg++, L1[i > 1 ? 2 : i], i, i);
+        if (i == 0) {
+            sprintf(*msg++, L2[0]);
+        } else if (i == 1) {
+            sprintf(*msg++, L2[1]);
+        } else if (i == 2) {
+            sprintf(*msg++, L2[2]);
+        } else {
+            sprintf(*msg++, L2[3], i - 1);
+        }
+        msg++;
+    }
+}

solutions/c/beer-song/1/beer_song.h

@@ -0,0 +1,5 @@
+#ifndef BEER_SONG_H
+#define BEER_SONG_H
+#include <stdint.h>
+void recite(uint8_t start_bottles, uint8_t take_down, char **song);
+#endif