Add solutions to C domain

Author: srgnk

README.md

@@ -5,7 +5,8 @@ Solutions to HackerRank problems
 * [Data Structures](#data-structures)
 * [Python](#python)
 * [Linux Shell](#linux-shell)
-* [C++](#c)
+* [CPP](#cpp)
+* [C](#c)
 
 ## Algorithms
 | Subdomain | Difficulty | Challenge | Solution |
@@ -410,7 +411,7 @@ Solutions to HackerRank problems
 |Grep Sed Awk|Medium|['Sed' command #1](https://www.hackerrank.com/challenges/text-processing-in-linux-the-sed-command-1/problem)|[text-processing-in-linux-the-sed-command-1.sh](shell/text-processing-in-linux-the-sed-command-1.sh)|
 |Grep Sed Awk|Medium|['Sed' command #2](https://www.hackerrank.com/challenges/text-processing-in-linux-the-sed-command-2/problem)|[text-processing-in-linux-the-sed-command-2.sh](shell/text-processing-in-linux-the-sed-command-2.sh)|
 
-## C++
+## CPP
 | Subdomain | Difficulty | Challenge | Solution |
 |:---------:|:----------:|:---------:|:--------:|
 |Introduction|Easy|[Say "Hello, World!" With C++](https://www.hackerrank.com/challenges/cpp-hello-world/problem)|[cpp-hello-world.cpp](cpp/cpp-hello-world.cpp)|
@@ -438,3 +439,30 @@ Solutions to HackerRank problems
 |STL|Easy|[Maps-STL](https://www.hackerrank.com/challenges/cpp-maps/problem)|[cpp-maps.cpp](cpp/cpp-maps.cpp)|
 |STL|Easy|[Print Pretty](https://www.hackerrank.com/challenges/prettyprint/problem)|[prettyprint.cpp](cpp/prettyprint.cpp)|
 |STL|Medium|[Deque-STL](https://www.hackerrank.com/challenges/deque-stl/problem)|[deque-stl.cpp](cpp/deque-stl.cpp)|
+
+## C
+| Subdomain | Difficulty | Challenge | Solution |
+|:---------:|:----------:|:---------:|:--------:|
+|Introduction|Easy|["Hello World!" in C](https://www.hackerrank.com/challenges/hello-world-c/problem)|[hello-world-c.c](c/hello-world-c.c)|
+|Introduction|Easy|[Playing With Characters](https://www.hackerrank.com/challenges/playing-with-characters/problem)|[playing-with-characters.c](c/playing-with-characters.c)|
+|Introduction|Easy|[Sum and Difference of Two Numbers](https://www.hackerrank.com/challenges/sum-numbers-c/problem)|[sum-numbers-c.c](c/sum-numbers-c.c)|
+|Introduction|Easy|[Functions in C](https://www.hackerrank.com/challenges/functions-in-c/problem)|[functions-in-c.c](c/functions-in-c.c)|
+|Introduction|Easy|[Pointers in C](https://www.hackerrank.com/challenges/pointer-in-c/problem)|[pointer-in-c.c](c/pointer-in-c.c)|
+|Conditionals and Loops|Easy|[Conditional Statements in C](https://www.hackerrank.com/challenges/conditional-statements-in-c/problem)|[conditional-statements-in-c.c](c/conditional-statements-in-c.c)|
+|Conditionals and Loops|Easy|[For Loop in C](https://www.hackerrank.com/challenges/for-loop-in-c/problem)|[for-loop-in-c.c](c/for-loop-in-c.c)|
+|Conditionals and Loops|Easy|[Sum of Digits of a Five Digit Number](https://www.hackerrank.com/challenges/sum-of-digits-of-a-five-digit-number/problem)|[sum-of-digits-of-a-five-digit-number.c](c/sum-of-digits-of-a-five-digit-number.c)|
+|Conditionals and Loops|Easy|[Bitwise Operators](https://www.hackerrank.com/challenges/bitwise-operators-in-c/problem)|[bitwise-operators-in-c.c](c/bitwise-operators-in-c.c)|
+|Conditionals and Loops|Medium|[Printing Pattern using Loops](https://www.hackerrank.com/challenges/printing-pattern-2/problem)|[printing-pattern-2.c](c/printing-pattern-2.c)|
+|Arrays and Strings|Medium|[1D Arrays in C](https://www.hackerrank.com/challenges/1d-arrays-in-c/problem)|[1d-arrays-in-c.c](c/1d-arrays-in-c.c)|
+|Arrays and Strings|Medium|[Array Reversal](https://www.hackerrank.com/challenges/reverse-array-c/problem)|[reverse-array-c.c](c/reverse-array-c.c)|
+|Arrays and Strings|Medium|[Printing Tokens](https://www.hackerrank.com/challenges/printing-tokens-/problem)|[printing-tokens-.c](c/printing-tokens-.c)|
+|Arrays and Strings|Medium|[Digit Frequency](https://www.hackerrank.com/challenges/frequency-of-digits-1/problem)|[frequency-of-digits-1.c](c/frequency-of-digits-1.c)|
+|Arrays and Strings|Medium|[Dynamic Array in C](https://www.hackerrank.com/challenges/dynamic-array-in-c/problem)|[dynamic-array-in-c.c](c/dynamic-array-in-c.c)|
+|Functions|Easy|[Calculate the Nth term](https://www.hackerrank.com/challenges/recursion-in-c/problem)|[recursion-in-c.c](c/recursion-in-c.c)|
+|Functions|Easy|[Students Marks Sum](https://www.hackerrank.com/challenges/students-marks-sum/problem)|[students-marks-sum.c](c/students-marks-sum.c)|
+|Functions|Medium|[Permutations of Strings](https://www.hackerrank.com/challenges/permutations-of-strings/problem)|[permutations-of-strings.c](c/permutations-of-strings.c)|
+|Functions|Medium|[Variadic functions in C](https://www.hackerrank.com/challenges/variadic-functions-in-c/problem)|[variadic-functions-in-c.c](c/variadic-functions-in-c.c)|
+|Functions|Hard|[Sorting Array of Strings](https://www.hackerrank.com/challenges/sorting-array-of-strings/problem)|[sorting-array-of-strings.c](c/sorting-array-of-strings.c)|
+|Structs and Enums|Easy|[Boxes through a Tunnel](https://www.hackerrank.com/challenges/too-high-boxes/problem)|[too-high-boxes.c](c/too-high-boxes.c)|
+|Structs and Enums|Medium|[Small Triangles, Large Triangles](https://www.hackerrank.com/challenges/small-triangles-large-triangles/problem)|[small-triangles-large-triangles.c](c/small-triangles-large-triangles.c)|
+|Structs and Enums|Hard|[Post Transition](https://www.hackerrank.com/challenges/post-transition/problem)|[post-transition.c](c/post-transition.c)|

c/1d-arrays-in-c.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+
+int main() {
+    int n;
+    int sum = 0;
+    int *arr;
+    
+    scanf("%d", &n);
+    arr = (int*) malloc(n * sizeof(int));
+    
+    for (int i = 0; i < n; i++)
+        scanf("%d", &arr[i]);
+    
+    for (int i = 0; i < n; i++)
+        sum += arr[i];
+    
+    printf("%d\n", sum);
+
+    free(arr);
+    return 0;
+}

c/bitwise-operators-in-c.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+
+#define max(a,b) \
+    ({ __typeof__ (a) _a = (a); \
+        __typeof__ (b) _b = (b); \
+        _a > _b ? _a : _b; })
+
+void calculate_the_maximum(int n, int k) {
+    int res = 0;
+    
+    for (int i = 1; i < n; i++) {
+        for (int j = i+1; j < n+1; j++) {
+            int tmp = i & j;
+            if ((tmp < k) && (res < tmp))
+                res = tmp;
+        }
+    }
+    printf("%d\n", res);
+    res = 0;
+    
+    for (int i = 1; i < n; i++) {
+        for (int j = i+1; j < n+1; j++) {
+            int tmp = i | j;
+            if ((tmp < k) && (res < tmp))
+                res = tmp;
+        }
+    }
+    printf("%d\n", res);
+    res = 0;
+    
+    for (int i = 1; i < n; i++) {
+        for (int j = i+1; j < n+1; j++) {
+            int tmp = i ^ j;
+            if ((tmp < k) && (res < tmp))
+                res = tmp;
+        }
+    }
+    printf("%d\n", res);
+}
+
+int main() {
+    int n, k;
+  
+    scanf("%d %d", &n, &k);
+    calculate_the_maximum(n, k);
+ 
+    return 0;
+}

c/conditional-statements-in-c.c

@@ -0,0 +1,61 @@
+#include <assert.h>
+#include <limits.h>
+#include <math.h>
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+char* readline();
+
+int main()
+{
+    char* n_endptr;
+    char* n_str = readline();
+    const char *numbers[9] = {"one", "two", "three", "four", "five",
+                        "six", "seven", "eight", "nine"};
+    int n = strtol(n_str, &n_endptr, 10);
+
+    if (n_endptr == n_str || *n_endptr != '\0') { exit(EXIT_FAILURE); }
+
+    if ((n > 0) && (n < 10))
+        printf("%s\n", numbers[n-1]);
+    else
+        printf("Greater than 9\n");
+
+    return 0;
+}
+
+char* readline() {
+    size_t alloc_length = 1024;
+    size_t data_length = 0;
+    char* data = malloc(alloc_length);
+
+    while (true) {
+        char* cursor = data + data_length;
+        char* line = fgets(cursor, alloc_length - data_length, stdin);
+
+        if (!line) { break; }
+
+        data_length += strlen(cursor);
+
+        if (data_length < alloc_length - 1 || data[data_length - 1] == '\n') { break; }
+
+        size_t new_length = alloc_length << 1;
+        data = realloc(data, new_length);
+
+        if (!data) { break; }
+
+        alloc_length = new_length;
+    }
+
+    if (data[data_length - 1] == '\n') {
+        data[data_length - 1] = '\0';
+    }
+
+    data = realloc(data, data_length);
+
+    return data;
+}

c/dynamic-array-in-c.c

@@ -0,0 +1,22 @@
+int main()
+{
+    int total_number_of_shelves;
+    scanf("%d", &total_number_of_shelves);
+    
+    int total_number_of_queries;
+    scanf("%d", &total_number_of_queries);
+    
+    total_number_of_books = (int *) malloc(total_number_of_shelves * sizeof(int));
+    total_number_of_pages = (int **) malloc(total_number_of_shelves * sizeof(int *));
+    
+    while (total_number_of_queries--) {
+        int type_of_query;
+        scanf("%d", &type_of_query);
+        
+        if (type_of_query == 1) {
+            int x, y;
+            scanf("%d %d", &x, &y);
+            total_number_of_books[x]++;
+            total_number_of_pages[x] = (int *) realloc(total_number_of_pages[x],
+                                               total_number_of_books[x] * sizeof(int));
+            total_number_of_pages[x][total_number_of_books[x]-1] = y;

c/for-loop-in-c.c

@@ -0,0 +1,24 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+
+
+
+int main() 
+{
+    int a, b;
+    const char *numbers[9] = {"one", "two", "three", "four", "five",
+                              "six", "seven", "eight", "nine"};
+    scanf("%d\n%d", &a, &b);
+    
+    for (int i = a; i <= b; i++) {
+        if ((i > 0) && (i < 10))
+            printf("%s\n", numbers[i-1]);
+        else
+            printf("%s\n", (i%2) ? "odd" : "even");
+    }
+
+    return 0;
+}
+

c/frequency-of-digits-1.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+
+int main() {
+    int freq[10];
+    char string[1000];
+    
+    scanf("%s", &string);
+    
+    for (int i = 0; i < 10; i++)
+        freq[i] = 0;
+    
+    for (int i = 0; i < strlen(string); i++) {
+        int pos = string[i] - '0';
+        if (pos >= 0 && pos < 10)
+            freq[pos]++;
+    }
+    
+    for (int i = 0; i < 10; i++)
+        printf("%d ", freq[i]);
+
+    return 0;
+}

c/functions-in-c.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+
+int max_of_four(int a, int b, int c, int d)
+{
+    int res = a;
+    
+    if (b > res)
+        res = b;
+    if (c > res)
+        res = c;
+    if (d > res)
+        res = d;
+    
+    return res;
+}
+
+
+int main() {
+    int a, b, c, d;
+    scanf("%d %d %d %d", &a, &b, &c, &d);
+    int ans = max_of_four(a, b, c, d);
+    printf("%d", ans);
+    
+    return 0;
+}

c/hello-world-c.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+
+int main() 
+{
+	
+    char s[100];
+    scanf("%[^\n]%*c", &s);
+  	
+    /* Enter your code here. Read input from STDIN. Print output to STDOUT */    
+    printf("Hello, World!\n%s", s);
+    return 0;
+}

c/permutations-of-strings.c

@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int lexicographic_sort(const void *a, const void *b) {
+    const char **ia = (const char **)a;
+    const char **ib = (const char **)b;
+    return strcmp(*ia, *ib);
+}
+
+/* A utility function two swap two strings a and b */
+void swap(char **a, char **b) {
+    char *t = *a;
+    *a = *b;
+    *b = t;
+}
+ 
+/*
+ * This function finds the index of the smallest string
+ * which is greater than 'first' and is present in s[l..h]
+ */
+int find_ceil(char **s, char *first, int l, int h) {
+    /* initialize index of ceiling element */
+    int ceil_index = l;
+ 
+    /*
+     * Now iterate through rest of the elements and find
+     * the smallest character greater than 'first'
+     */
+    
+    for (int i = l+1; i <= h; i++)
+        if ((strcmp(s[i], first) > 0) && (strcmp(s[i], s[ceil_index]) < 0))
+            ceil_index = i;
+ 
+    return ceil_index;
+}
+
+int next_permutation(int n, char **s) {
+    int theres_more = 1;
+    int i;
+    
+    /*
+     * Find the rightmost string which is smaller than its next
+     * character. Let us call it 'first str'
+    */
+    for (i = n-2; i >= 0; i--)
+        if (strcmp(s[i], s[i+1]) < 0)
+            break;
+
+    /*
+     * If there is no such string, all are sorted in decreasing order,
+     * means we just found the last permutation and we are done.
+     */
+    if (i == -1) {
+        theres_more = 0;
+    } else {
+        /*
+         * Find the ceil of 'first char' in right of first character.
+         * Ceil of a character is the smallest character greater than it
+         */
+        int ceil_index = find_ceil(s, s[i], i + 1, n - 1);
+        
+        /* Swap first and second strings */
+        swap(&s[i], &s[ceil_index]);
+
+        /* Sort the string on right of 'first char' */
+        qsort(s + i + 1, n - i - 1, sizeof(s[0]), lexicographic_sort);
+    }
+    
+    return theres_more;
+}