Merge branch 'main' of https://github.com/abdullah-ergul/C_Programming_Language

Author: abdullah-ergul

Hackerrank/printing_toekns.c renamed to Hackerrank/3-Arrays_and_Strings/3-printing_toekns.c

@@ -14,17 +14,29 @@ int main(){
     int total_number_of_queries;
     scanf("%d", &total_number_of_queries);
 
+    // !
+    total_number_of_books=(int*)malloc(sizeof(int)*total_number_of_shelves);
+    
+    total_number_of_pages=(int**)malloc(sizeof(int*)*total_number_of_shelves);
+    
+    for(int i=0; i<total_number_of_shelves; i++){
+        total_number_of_books[i]=0;
+        total_number_of_pages[i]=(int*)malloc(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) = (int *)realloc(total_number_of_books+x, )
-            *(total_number_of_books + x) += 1;
-            *(*(total_number_of_pages + x)) += y;
+            *(total_number_of_books+x)+=1;
+            *(total_number_of_pages+x)=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;
             // !
 
         } else if (type_of_query == 2) {

Hackerrank/3-Arrays_and_Strings/5-Dynamic_Array_in_C.c

@@ -0,0 +1,97 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+int lexicographic_sort(const char* a, const char* b) {
+    strcmp(a,b);
+}
+
+int lexicographic_sort_reverse(const char* a, const char* b) {
+    strcmp(b,a);
+}
+
+int characters_count(const char *s)
+{
+    int n = 0;
+    int count[128] = {0};
+    if (NULL == s)
+    {
+        return -1;
+    }
+    while(*s != '\0')
+    {
+        if (!count[*s])
+        {
+            count[*s]++;
+            n++;
+        }
+        s++;
+    }
+    return n;
+}
+
+int sort_by_number_of_distinct_characters(const char* a, const char* b)
+{
+    int con = characters_count(a) - characters_count(b);
+    return (con ? con : lexicographic_sort(a, b));
+}
+
+int sort_by_length(const char* a, const char* b) {
+    if(strlen(a) > strlen(b))
+        return 1;
+    else if(strlen(a) == strlen(b))
+        lexicographic_sort(a,b);
+    else
+        return 0;
+}
+
+void string_sort(char** arr,const int len,int (*cmp_func)(const char* a, const char* b)){
+    int i,x=0;
+
+    while(x != 1){
+    x=1;
+        for(i=0; i<len; i++){
+            if(cmp_func(arr[i], arr[i+1]) > 0){
+                char *temp= arr[i];
+                arr[i]= arr[i+1];
+                arr[i+1]= temp;
+                x= 0;
+            }
+        }
+    }
+}
+
+
+int main() 
+{
+    int n;
+    scanf("%d", &n);
+  
+    char** arr;
+	arr = (char**)malloc(n * sizeof(char*));
+  
+    for(int i = 0; i < n; i++){
+        *(arr + i) = malloc(1024 * sizeof(char));
+        scanf("%s", *(arr + i));
+        *(arr + i) = realloc(*(arr + i), strlen(*(arr + i)) + 1);
+    }
+  
+    string_sort(arr, n, lexicographic_sort);
+    for(int i = 0; i < n; i++)
+        printf("%s\n", arr[i]);
+    printf("\n");
+
+    string_sort(arr, n, lexicographic_sort_reverse);
+    for(int i = 0; i < n; i++)
+        printf("%s\n", arr[i]); 
+    printf("\n");
+
+    string_sort(arr, n, sort_by_length);
+    for(int i = 0; i < n; i++)
+        printf("%s\n", arr[i]);    
+    printf("\n");
+
+    string_sort(arr, n, sort_by_number_of_distinct_characters);
+    for(int i = 0; i < n; i++)
+        printf("%s\n", arr[i]); 
+    printf("\n");
+}

Hackerrank/3-Arrays_and_Strings/5-Dynamic_Array_in_C.exe

@@ -0,0 +1,37 @@
+#include <stdio.h>
+#include <stdlib.h>
+#define MAX_HEIGHT 41
+
+struct box
+{
+	int length; int width; int height;
+};
+
+typedef struct box box;
+
+int get_volume(box b) {
+	return b.height*b.length*b.width;
+}
+
+int is_lower_than_max_height(box b) {
+	if(b.height >= MAX_HEIGHT){
+        return 0;
+    }
+    return 1;
+}
+
+int main()
+{
+	int n;
+	scanf("%d", &n);
+	box *boxes = malloc(n * sizeof(box));
+	for (int i = 0; i < n; i++) {
+		scanf("%d%d%d", &boxes[i].length, &boxes[i].width, &boxes[i].height);
+	}
+	for (int i = 0; i < n; i++) {
+		if (is_lower_than_max_height(boxes[i])) {
+			printf("%d\n", get_volume(boxes[i]));
+		}
+	}
+	return 0;
+}

Hackerrank/4-Funcltions/3-Sorting_Array_of_Strings.c

@@ -0,0 +1,49 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+struct triangle
+{
+	int a;
+	int b;
+	int c;
+};
+
+typedef struct triangle triangle;
+void sort_by_area(triangle* tr, int n) {
+	
+    triangle Ttemp;
+    int j, i, arrN= (int *)malloc(n * sizeof(int));
+    double p, S, Dtemp, *arrS= (double *)malloc(n * sizeof(double));
+    for(i=0; i<n; i++){
+        p= ((double)tr[i].a + (double)tr[i].b + (double)tr[i].c)/2;
+        // printf("**%lf**\n",p);
+        S= sqrt(p*(p- (double)tr[i].a)*(p- (double)tr[i].b)*(p- (double)tr[i].c));
+        arrS[i]= S;
+        // printf("**%lf**\n",arrS[i]);
+    }
+    for(i=0; i<n; i++){
+        for(j=1; j<n; j++){
+            if(arrS[j-1] > arrS[j]){
+                Dtemp= arrS[j-1];  Ttemp= tr[j-1];
+                arrS[j-1]= arrS[j];  tr[j-1]= tr[j];
+                arrS[j]= Dtemp;  tr[j]= Ttemp;
+            }
+        }
+    }
+}
+
+int main()
+{
+	int n;
+	scanf("%d", &n);
+	triangle *tr = malloc(n * sizeof(triangle));
+	for (int i = 0; i < n; i++) {
+		scanf("%d%d%d", &tr[i].a, &tr[i].b, &tr[i].c);
+	}
+	sort_by_area(tr, n);
+	for (int i = 0; i < n; i++) {
+		printf("%d %d %d\n", tr[i].a, tr[i].b, tr[i].c);
+	}
+	return 0;
+}

Hackerrank/5-Structs_and_Enums/1-Boxes_through_a_Tunnel.c

@@ -0,0 +1,95 @@
+#include <stdio.h>
+#include <stdlib.h>
+#define MAX_STRING_LENGTH 6
+
+struct package
+{
+	char* id;
+	int weight;
+};
+
+typedef struct package package;
+
+struct post_office
+{
+	int min_weight;
+	int max_weight;
+	package* packages;
+	int packages_count;
+};
+
+typedef struct post_office post_office;
+
+struct town
+{
+	char* name;
+	post_office* offices;
+	int offices_count;
+};
+
+typedef struct town town;
+
+
+
+void print_all_packages(town t) {
+}
+
+void send_all_acceptable_packages(town* source, int source_office_index, town* target, int target_office_index) {	
+}
+
+town town_with_most_packages(town* towns, int towns_count) {
+}
+
+town* find_town(town* towns, int towns_count, char* name) {
+}
+
+int main()
+{
+	int towns_count;
+	scanf("%d", &towns_count);
+	town* towns = malloc(sizeof(town)*towns_count);
+	for (int i = 0; i < towns_count; i++) {
+		towns[i].name = malloc(sizeof(char) * MAX_STRING_LENGTH);
+		scanf("%s", towns[i].name);
+		scanf("%d", &towns[i].offices_count);
+		towns[i].offices = malloc(sizeof(post_office)*towns[i].offices_count);
+		for (int j = 0; j < towns[i].offices_count; j++) {
+			scanf("%d%d%d", &towns[i].offices[j].packages_count, &towns[i].offices[j].min_weight, &towns[i].offices[j].max_weight);
+			towns[i].offices[j].packages = malloc(sizeof(package)*towns[i].offices[j].packages_count);
+			for (int k = 0; k < towns[i].offices[j].packages_count; k++) {
+				towns[i].offices[j].packages[k].id = malloc(sizeof(char) * MAX_STRING_LENGTH);
+				scanf("%s", towns[i].offices[j].packages[k].id);
+				scanf("%d", &towns[i].offices[j].packages[k].weight);
+			}
+		}
+	}
+	int queries;
+	scanf("%d", &queries);
+	char town_name[MAX_STRING_LENGTH];
+	while (queries--) {
+		int type;
+		scanf("%d", &type);
+		switch (type) {
+		case 1:
+			scanf("%s", town_name);
+			town* t = find_town(towns, towns_count, town_name);
+			print_all_packages(*t);
+			break;
+		case 2:
+			scanf("%s", town_name);
+			town* source = find_town(towns, towns_count, town_name);
+			int source_index;
+			scanf("%d", &source_index);
+			scanf("%s", town_name);
+			town* target = find_town(towns, towns_count, town_name);
+			int target_index;
+			scanf("%d", &target_index);
+			send_all_acceptable_packages(source, source_index, target, target_index);
+			break;
+		case 3:
+			printf("Town with the most number of packages is %s\n", town_with_most_packages(towns, towns_count).name);
+			break;
+		}
+	}
+	return 0;
+}