Esercizio 1:
palindroma.c

#include "palindroma.h"

bool palindroma(const char *str) {
if (str == NULL)
return false;
if (str[0] == 0)
return false;
int n = strlen(str);
int i = 0;
while (i <= n) {
if (str[i] != str[n - 1])
return false;
i++;
n--;
}

return true;
}
Esercizio 2:
palindroma.h

#if !defined PALINDROMA_H
#define PALINDROMA_H
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>

extern bool palindroma(const char *str);
#endif
Esercizio 2:
croce.c

#include <stdlib.h>
#include <stdio.h>

void stampa_croce(FILE *f, size_t dim)
{
if (dim == 0)
return;
int c = 0;
int n = dim * 2 - 1;
for (int i = 0; i < dim * 2; i++) {
for (int j = 0; j < dim * 2; j++) {
if (j == c) {
fprintf(f, "%c", '');
}
else if (j == n) {
fprintf(f, "%c", '/');
}
else {
fprintf(f, "%c", ' ');
}

}
fprintf(f, "
");
c++;
n--;
}
}
Esercizio 3:
matrix.h

#if !defined MATRIX_H
#define MATRIX_H

#include <stdio.h>
#include <stdlib.h>

struct matrix {
size_t rows, cols;
double *data;
};

extern struct matrix *matrix_flip_v(const struct matrix *m);

#endif

matrix.c

#include "matrix.h"

struct matrix *matrix_flip_v(const struct matrix *m)
{
if (m == NULL)
return NULL;
struct matrix *mat = malloc(sizeof(struct matrix));
mat->rows = m->rows;
mat->cols = m->cols;
mat->data = malloc(mat->cols * mat->rows * sizeof(double));
int primariga = 0;
int ultimariga = m->rows - 1;
double *dat = malloc(m->cols * sizeof(double));
while (primariga <= ultimariga) {
for (int c = 0; c < m->cols;c++) {
dat[c] = m->data[primariga*m->cols + c];
mat->data[primariga*mat->cols + c] = m->data[ultimariga*m->cols + c];
mat->data[ultimariga*mat->cols + c] = dat[c];
}
primariga++;
ultimariga--;
}
return mat;
}
Esercizio 4:
rational.h

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#if !defined RATIONAL_H
#define RATIONAL_H
struct rational {
int num;
unsigned int den;
};

extern struct rational *rational_read(const char *filename, size_t *size);

#endif //RATIONAL_H

rational.c

#include "rational.h"
#define ever (;;)

struct rational *rational_read(const char *filename, size_t *size)
{
FILE *f = fopen(filename, "rt");
if (f == NULL) { *size = 0; return NULL; }

struct rational *ris = NULL;
size_t cont = 0;

for ever
{
int tmpnum, ret;
unsigned int tmpden;

if ((ret = fscanf(f, "%i /%u", &tmpnum, &tmpden)) == EOF) break;
if (ret != 2) { *size = cont; return ris; }

ris = realloc(ris, (++cont) * sizeof(struct rational));
ris[cont - 1].num = tmpnum;
ris[cont - 1].den = tmpden;
}

*size = cont;
return ris;
}
Esercizio 5:
leggi_stringhe.h

#define _CRT_SECURE_NO_WARNINGS
#ifndef STRINGHE_H
#define STRINGHE_H
#include <stdio.h>
#include <stdlib.h>
extern char **leggi_stringhe(const char *filename, size_t *size);

#endif

leggi_stringhe.c

#include "leggi_stringhe.h"

char **leggi_stringhe(const char *filename, size_t *size)
{
FILE *f = fopen(filename, "rb");
if (f == NULL)
return NULL;
char **vet = NULL;
*size = 0;
unsigned int n;
//fread(&variabile,la dim. tipo della variabile,quante volte vuoi leggere quel tipo, il file)
//fread ritorna un intero che rappresenta quante volte ha letto quel tipo di quella variabile
int r1 = fread(&n, sizeof(unsigned int), 1, f);
if (r1 != 1) {
return vet;
}
int l = 0;
while (l < n) {
unsigned int d;
int r2 = fread(&d,sizeof(unsigned int), 1, f);
if (r2 != 1) {
*size = 0;
return vet;
}
char *str = malloc(sizeof(char)*d + 1);
int r3 = fread(str, sizeof(char), d, f);
if (r3 != d) {
*size = 0;
return vet;
}
*size = *size + 1;
vet = realloc(vet, *size * sizeof(char**));
vet[*size - 1] = malloc(sizeof(char)*d);
int i;
for (i = 0; i < d;i++) {
vet[*size - 1][i] = str[i];
}
vet[*size - 1][i] = 0;
l++;
}
fclose(f);
return vet;
}