.gitignore

+.nfs*

20221103/1.c

+#include <stdio.h>
+
+void print_repeat_char(char c, unsigned n) {
+    for (unsigned i = 0; i < n; ++i) {
+        printf("%c", c);
+    }
+}
+
+int main(void) {
+    puts("Lato del quadrato");
+    unsigned side;
+    scanf("%u", &side);
+
+    for (unsigned row = 1; row <= side; ++row) {
+        unsigned stars_amount = row;
+        print_repeat_char('*', stars_amount);
+
+        unsigned plus_amount = side - stars_amount;
+        print_repeat_char('+', plus_amount);
+
+        puts("");
+    }
+
+    return 0;
+}

20221103/2.c

+#include <stdio.h>
+#include <stdbool.h>
+#include <assert.h>
+
+#define END -1000
+
+#define ASC_STR "crescente"
+#define DESC_STR "decrescente"
+#define NEITHER_STR "ne' " ASC_STR "ne' " DESC_STR
+
+const char *sequence_monotony_str(bool asc, bool desc) {
+    const char *sequence_kind_str;
+    printf("la sequenza e' ");
+    if (asc) {
+        assert(!desc);
+        sequence_kind_str = ASC_STR;
+    } else if (desc) {
+        assert(!asc);
+        sequence_kind_str = DESC_STR;
+    } else {
+        sequence_kind_str = NEITHER_STR;
+    }
+    return sequence_kind_str;
+}
+
+int main(void) {
+    int sum = 0;
+    int prev, num;
+    bool asc = true, desc = true;
+    unsigned num_counter = 0;
+
+    scanf("%d", &prev);
+    sum += prev;
+
+    if (prev != END) {
+        num_counter = 1;
+        while (scanf("%d", &num), num != END) {
+            ++num_counter;
+            sum += num;
+            asc &= num > prev;
+            desc &= num < prev;
+
+            prev = num;
+        }
+    }
+
+
+    if (num_counter > 1) {
+        puts(sequence_monotony_str(asc, desc));
+    } else {
+        puts("la sequenza non e' abbastanza lunga per essere definita crescente o decrescente");
+    }
+    
+    printf("somma: %d\n", sum);
+
+    return 0;
+}

20221117/1.c

+#include <stdio.h>
+#include <assert.h>
+#include <stdbool.h>
+
+# define LEN(x) (sizeof(x) / sizeof(*x))
+
+enum Product { COFFE = 0, TEA = 1, CHOCOLATE = 2, CAPPUCCINO = 3, LAST_PRODUCT };
+const char *const products_str[] = { "caffe'", "the", "cioccolata", "cappuccino", };
+const int products_price[] = { 50, 40, 60, 70 };
+
+const int coins[] = { 1, 5, 10, 20, 50 };
+
+void print_numbered_strings(const char *const products[], size_t len) {
+    for (size_t i = 0; i < len; ++i) {
+        printf("%zu. %s\n", i, products[i]) ;
+    }
+}
+
+int input_int() {
+    int ret;
+    scanf("%d", &ret);
+    return ret;
+}
+
+int input_int_range(int lower, int upper) {
+    int ret;
+    while ((ret = input_int()) < lower || ret > upper) {
+        puts("Valore non ammesso");
+    }
+    return ret;
+}
+
+bool is_in_array(int needle, const int haystack[], size_t len) {
+    bool found = false;
+    // could use memmem(3) instead
+    for (size_t i = 0; i < len && !found; i++) {
+        if (haystack[i] == needle) { found = true; }
+    }
+    return found;
+}
+
+int input_int_filter(const int whitelist[], size_t len) {
+    int ret;
+    while (ret = input_int(), !is_in_array(ret, whitelist, len)) {
+        puts("Valore non ammesso");
+    }
+    return ret;
+}
+
+void calculate_change(int total, int *count_5, int *count_1) {
+    *count_5 = total / 5;
+    total -= 5 * *count_change;
+
+    *count_1 = total;
+}
+
+int main(void) {
+    assert(LEN(products_str) == LEN(products_price));
+    assert(LEN(products_str) == LAST_PRODUCT);
+
+    int selected_product;
+    int credit = 0;
+    int inserted_coin;
+    int count_change_5 = 0, count_change_1 = 0;
+
+    puts("Seleziona il prodotto");
+    print_numbered_strings(products_str, LEN(products_str));
+    selected_product = input_int_range(0, LAST_PRODUCT);
+
+    printf("Costo: %d centesimi\n", products_price[selected_product]);
+
+    puts("Inserisci monete");
+    while (credit < products_price[selected_product]) {
+        inserted_coin = input_int_filter(coins, LEN(coins));
+        credit += inserted_coin;
+    }
+
+    calculate_change(
+            credit - products_price[selected_product],
+            &count_change_5, &count_change_1
+    );
+
+    printf("Resto: %d monete da 5, %d monete da 1\n", count_change_5, count_change_1);
+
+    return 0;
+}

20221117/2.c

+#include <stdio.h>
+#include <math.h>
+
+#define PERC_CRASHED (+0.12)
+#define PERC_NOT_CRASHED (-0.04)
+
+int main(void) {
+    double new_total_amount = 0;
+    double old_total_amount = 0;
+    do {
+        puts("Inserire numero di auto");
+        unsigned int n_cars;
+        scanf("%u", &n_cars);
+
+        double old_client_amount = 0;
+        double new_client_amount = 0;
+        for (unsigned int i = 0; i < n_cars; i++) {
+            double old_car_amount;
+            double new_car_amount;
+
+            printf("Inserire importo dell'auto %u\n", i + 1);
+            do {
+                scanf("%lf", &old_car_amount);
+            } while (old_car_amount < 0);
+
+            old_client_amount += old_car_amount;
+
+            puts("Inserire numero di incidenti dell'anno scorso");
+            int n_crashes;
+            do {
+                scanf("%u", &n_crashes);
+            } while (n_crashes < 0);
+
+            if (n_crashes > 0) {
+                new_car_amount = old_car_amount + PERC_CRASHED * old_car_amount;
+            } else {
+                new_car_amount = old_car_amount - PERC_NOT_CRASHED * old_car_amount;
+            }
+
+            new_client_amount += new_car_amount;
+        }
+        printf("Importo da pagare per il cliente: %lf\n", new_client_amount);
+
+        old_total_amount += old_client_amount;
+        new_total_amount += new_client_amount;
+
+        puts("Inserire nuovo cliente? y/n");
+    } while (getchar() == 'y');
+
+    printf("Totale degli importi: %lf, variazione rispetto al precedente: %lf\n",
+            new_total_amount, fabs(new_total_amount - old_total_amount));
+}

20221118/1.c

+#include <stdio.h>
+
+void input_int_array(int arr[], size_t len) {
+    for (size_t i = 0; i < len; ++i) {
+        scanf("%d", arr[i]);
+    }
+}

20221118/2.c

+#include <stdio.h>
+
+void print_int_array(int arr[], size_t len) {
+    for (size_t i = 0; i < len; ++i) {
+        printf("%d", arr[i]);
+        if (i < len - 1) { printf(", "); }
+    }
+    puts("");
+}

20221118/3.c

+#include <assert.h>
+
+void add_int_array(int A[], int dimA, int B[], int dimB, int C[], int dimC) {
+    assert(dimA == dimB);
+    assert(dimB == dimC);
+
+    for (int i = 0; i < dimA; ++i) {
+        C[i] = A[i] + B[i];
+    }
+}

20221118/4.c

+int sum_int_array(int arr[], int len) {
+    int ret = 0;
+    for (int i = 0; i < len; i++) {
+        ret += arr[i];
+    }
+    return ret;
+}
+
+int f(int A[], int dimA, int B[], int dimB) {
+    int sumi = 0;
+    for (int i = 0; i < dimA; ++i) { sumi += A[i] * sum_int_array(B, dimB); }
+    return sumi;
+}

20221124/1.c

+#include <stdio.h>
+
+void minmax(int array[], int len, int *min, int *max) {
+    int i = 0;
+    *min = array[i];
+    *max = array[i];
+
+    for (i = 1; i < len; i++) {
+        if (array[i] < *min) { *min = array[i]; }
+        if (array[i] > *max) { *max = array[i]; }
+    }
+}

20221124/2.c

+#include <stdio.h>
+
+int max(int array[], int len, int *n_max_occurr) {
+    int max;
+    *n_max_occurr = 0;
+    int i = 0;
+    max = array[i];
+    (*n_max_occurr)++;
+
+    for (i = 1; i < len; i++) {
+        if (array[i] == max) { (*n_max_occurr)++; }
+        else if (array[i] > max) {
+            max = array[i];
+            (*n_max_occurr) = 1;
+        }
+    }
+    return max;
+}

20221124/3.c

+#include <stdio.h>
+
+int maxcount(int array[], int len) {
+    int i = 0;
+    int max_i = i;
+
+    for (i = 1; i < len; i++) {
+        if (array[i] > array[max_i]) { max_i = i; }
+    }
+
+    int ret = array[max_i];
+    array[max_i] = -1;
+    return ret;
+}

20221125/1.c

+#include <stdio.h>
+
+size_t slen(char *s) {
+    size_t i = 0;
+    while (s[i] != '\0') { ++i; }
+    return i;
+}
+
+void strrev(char *src, char *dst) {
+    size_t len = slen(src);
+    for (size_t i = 0; i < len; ++i) {
+        dst[i] = src[len - 1 - i];
+    }
+    src[len] = '\0';
+}
+
+int main(void) {
+    char s[] = "Informatica";
+    char s_rev[sizeof(s)];
+
+    strrev(s, s_rev);
+    printf("%s", s_rev);
+}

20221125/2.c

+size_t lunghezza(char *s) {
+    size_t i = 0;
+    while (s[i] != '\0') { ++i; }
+    return i;
+}
+
+int palindroma(char *s) {
+    int is_palindrome = 1;
+    size_t len = lunghezza(s);
+    for (size_t i = 0; i < len / 2 && is_palindrome; ++i) {
+        if (s[i] != s[len - 1 - i]) { is_palindrome = 0; }
+    }
+    return is_palindrome;
+}
+
+void cswap(char *c1, char *c2) {
+    char temp = *c1;
+    *c1 = *c2;
+    *c2 = temp;
+}
+
+void inverti(char *s) {
+    size_t len = lunghezza(s);
+    for (size_t i = 0; i < len / 2; ++i) {
+        cswap(&s[i], &s[len - 1 - i]);
+    }
+}

20221201/1.c

+#include <stdio.h>
+#include <string.h>
+
+#define BUF_SIZE 4096
+#define ARR_SIZE(a) (sizeof(a) / sizeof(*a))
+
+void str_strip_trailing(char *s) {
+    char *pos = strchr(s, '\n');
+    if (pos != NULL) { *pos = '\0'; }
+}
+
+int main(void) {
+    char str1[BUF_SIZE];
+    char str2[BUF_SIZE];
+
+    fgets(str1, ARR_SIZE(str1), stdin);
+    str_strip_trailing(str1);
+    fgets(str2, ARR_SIZE(str2), stdin);
+    str_strip_trailing(str2);
+
+    if (strcmp(str1, str2) == 0) {
+        puts("Le due stringhe sono uguali");
+    } else if (strstr(str1, str2) != NULL) {
+        puts("La seconda stringa e' contenuta nella prima");
+    } else if (strstr(str2, str1) != NULL) {
+        puts("La prima stringa e' contenuta nella seconda");
+    }
+
+    return 0;
+}

20221201/2.c

+#include <stdio.h>
+#include <string.h>
+
+#define BUF_SIZE 4096
+#define ARR_SIZE(a) (sizeof(a) / sizeof(*a))
+
+const char vowels[] = "aeiouAEIOU";
+
+void str_strip_trailing(char *s) {
+    char *pos = strchr(s, '\n');
+    if (pos != NULL) { *pos = '\0'; }
+}
+
+void change_forbidden_chars(char *s, const char *remove, char new) {
+    char *match = s;
+    while ((match = strpbrk(match, remove)) != NULL) {
+        *match = new;
+    }
+}
+
+int main(void) {
+    char str1[BUF_SIZE];
+    char str2[BUF_SIZE];
+    char str12[BUF_SIZE * 2 - 1];
+
+    fgets(str1, ARR_SIZE(str1), stdin);
+    str_strip_trailing(str1);
+    fgets(str2, ARR_SIZE(str2), stdin);
+    str_strip_trailing(str2);
+
+    strcpy(str12, str1);
+    strcat(str12, str2);
+
+    change_forbidden_chars(str12, vowels, '*');
+
+    puts(str12);
+}

20221201/3.c

+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define BUF_SIZE 100
+#define ARR_SIZE(a) (sizeof(a) / sizeof(*a))
+
+const char vowels[] = {'a', 'e', 'i', 'o', 'u' };
+
+void str_strip_trailing(char *s) {
+    char *pos = strchr(s, '\n');
+    if (pos != NULL) { *pos = '\0'; }
+}
+
+void count_vowels(char *s, unsigned int counts[]) {
+    while (*s) {
+        int match = 0;
+        size_t i;
+        for (i = 0; i < ARR_SIZE(vowels) && !match; ++i) {
+            if (vowels[i] == tolower(*s)) { match = 1; }
+        }
+        if (match) { ++counts[i - 1]; }
+        ++s;
+    }
+}
+
+unsigned int arr_sum(unsigned int arr[], size_t len) {
+    unsigned int ret = 0;
+    for (size_t i = 0; i < len; ++i) { ret += arr[i]; }
+    return ret;
+}
+
+int main(void) {
+    char str[BUF_SIZE];
+
+    fgets(str, ARR_SIZE(str), stdin);
+    str_strip_trailing(str);
+
+    unsigned int vowels_counters[5] = {0};
+    count_vowels(str, vowels_counters);
+    
+    unsigned int n_vowels = arr_sum(vowels_counters, ARR_SIZE(vowels_counters));
+    size_t len = strlen(str);
+    unsigned int n_consonants = len - n_vowels;
+
+    printf("vocali: %u, consonanti: %u\n", n_vowels, n_consonants);
+    puts("frequenze vocali:");
+    for (size_t i = 0; i < 5; ++i) {
+        printf("%c: %lf\n", vowels[i], ((double)vowels_counters[i] / len) * 100);
+    }
+}

20221202/1.c

+#include <stdio.h>
+#include <assert.h>
+
+#define MARKER -1
+#define ARR_SIZE(a) (sizeof(a) / sizeof(*a))
+
+int populate(int arr[], size_t size) {
+    int insert;
+    size_t i = 0;
+    while (i < size && ((scanf("%d", &insert)), insert != MARKER)) {
+        arr[i] = insert;
+        ++i;
+    }
+
+    int ret;
+    if (i < size) {
+        arr[i] = MARKER;
+        ret = 1;
+    }
+    else { ret = -1; }
+    return ret;
+}
+
+void print(int arr[]) {
+    size_t i = 0;
+    if (arr[i] != MARKER) {
+        while (arr[i + 1] != MARKER) {
+            printf("%d*", arr[i]);
+            ++i;
+        }
+        printf("%d", arr[i]);
+    }
+}
+
+int *find(int where[], int what) {
+    size_t i = 0;
+    int found = 0;
+    while (where[i] != MARKER && !found) {
+        if (where[i] == what) { found = 1; }
+        else { ++i; }
+    }
+
+    int *ret;
+    if (found) { ret = &where[i]; }
+    else { ret = NULL; }
+    return ret;
+}
+
+void remove_first(int where[], int what) {
+    assert(what != MARKER);
+
+    int *pos = find(where, what);
+    if (pos != NULL) {
+        while ((*pos) != MARKER) {
+            *pos = *(pos + 1);
+            ++pos;
+        }
+    }
+}
+
+void remove_all(int where[], int what) {
+    size_t shift_width = 0;
+    size_t i = 0;
+    while (where[i + shift_width] != MARKER) {
+        if (where[i] == what) {
+            ++shift_width;
+        } else {
+            ++i;
+        }
+        where[i] = where[i + shift_width];
+    }
+    where[i] = MARKER;
+}
+
+int main(void) {
+    int array[10];
+    if (populate(array, ARR_SIZE(array))) {
+        remove_all(array, 5);
+        print(array);
+    }
+}

20221215/main.c

+#include <stdio.h>
+
+#define MARK -1
+#define LEN(x) (sizeof(x) / sizeof(*x))
+
+void copy(int to[], int from[], int n, int *ret) {
+    int i = 0;
+    while (from[i] != MARK && i < n - 1) {
+        to[i] = from[i];
+        ++i;
+    }
+    to[i] = MARK;
+
+    *ret = from[i] == MARK ? 1 : -1;
+}
+
+void cmp(int a1[], int a2[], int *ret) {
+    int i = 0;
+    while (a1[i] != MARK && a2[i] != MARK && a1[i] == a2[i]) { ++i; }
+
+    *ret = a1[i] == a2[i] ? 1 : -1;
+}
+
+int count_greater(int a1[], int a2[]) {
+    int i = 0;
+    int ret = 0;
+    while (a1[i] != MARK && a2[i] != MARK) {
+        if (a1[i] > a2[i]) { ++ret; }
+        ++i;
+    }
+    while (a2[i] != MARK) {
+        ++ret;
+        ++i;
+    }
+    return ret;
+}
+
+int copy_even_positions(int to[], int from[], int n) {
+    int i = 0;
+    while (from[i * 2] && from[(i * 2) + 1] != MARK && i < n - 1) {
+        to[i] = from[i * 2];
+        ++i;
+    }
+    to[i] = MARK;
+    return i;
+}
+
+int sum(int a1[], int a2[], int n, int sum[]) {
+    int i = 0;
+    while (a1[i] != MARK && a2[i] != MARK && i < n - 1) {
+        sum[i] = a1[i] + a2[i];
+        ++i;
+    }
+    while (a1[i] != MARK && i < n - 1) {
+        sum[i] = a1[i];
+        ++i;
+    }
+    while (a2[i] != MARK && i < n - 1) {
+        sum[i] = a2[i];
+        ++i;
+    }
+
+    sum[i] = MARK;
+
+    return a1[i] == MARK || a2[i] == MARK ? 1 : -1;
+}