/**
* @brief
*
* @param s
* @return length of s
* @example if s is "Bonjour" then it returns 7
*/
int strlen_homemade(const char *s)
{
int c = 0;
while (*s) // continue the loop when the current char is non-zero
{
s++; // move the pointer to the right
c++;
}
return c;
}
void enlarge_tab(intarray* pa, size_t new_capacity) {
pa->begin = realloc(pa->begin, new_capacity * sizeof(uint32_t));
pa->capacity = new_capacity;
}
// Renvoie une copie du tableau a
intarray copy(intarray a) {
// On copie ici le tableau utilisé en pratique, les éléments "superflues" (ie le tableau réel) sont ici ignorés
uint32_t* t = malloc(a.size * sizeof(uint32_t));
// On copie les éléments du tableau
for (size_t k = 0; k < a.size; k++) {
t[k] = a.begin[k];
}
return (intarray){t, a.size, a.size};
}
/**
* @brief Retire le dernier élément du tableau
*
* @param pa Le tableau
* @return L'élément supprimé
*/
u_int32_t pop(intarray* pa) {
assert(pa->size > 0);
return pa->begin[--pa->size];
}
/**
* @brief Cherche un élément dans le tableau
*
* @param a Le tableau
* @param i L'indice
* @return L'élément trouvé si indice valide
* @return 0 si indice non valide
*/
u_int32_t force_get(const intarray a, const int i) {
if (0 > i || i >= a.size) return 0;
return a.begin[i];
}
/*@brief Créer un tableau dynamique vide
@return Un tableau dynamique avec un pointeur quelquonque, size =0 et capacity = 0*/
intarray make(){
u_int32_t *i = malloc(sizeof(u_int32_t *));
intarray a = {i, 0 , 0};
return a;
}
/*@brief Fonction qui rajoute un élément à un tableau dynamique (alloue de la mémoire si nécessaire)
@param le tableau dynamique
@param l'élément à ajouter
@return Rien*/
void push(intarray *pa , u_int32_t x){
if (pa->size +1 > pa->capacity);{
pa->begin = (u_int32_t*) realloc(pa->begin,(5/4)*(pa->capacity) +4);
pa->capacity = (5/4)*(pa->capacity) +4;
}
pa->size += 1;
pa->begin[pa->size]=x;
}
/// @brief Insertion de l'élement x dans le tableau dynamique pointé par pa. Si besoin on augmente la capacité du tableau avec la formule new_capacity = 5/2*capacity +4
/// @param pa Un pointeur vers le tableau dynamique
/// @param x Un entier sur 32 bit.
void push(intarray* pa, u_int32_t x) {
if (pa->size < pa->capacity) {
pa->begin[pa->size+1] = x ;
pa->size ++ ;
}
else {
int new_capacity = 5/2*pa->capacity +4;
pa->begin = realloc(pa->begin, new_capacity*4 ) ;
pa->begin[pa->size+1] = x ;
pa->size ++ ;
pa->capacity = new_capacity ;
}
}
/// @brief Copie le tableau a et renvoie un nouveau tableau, la capacité et size reste inchangé, les éléments sont insérés un par un.
/// @param a Un tableau dynamique de type intarray
/// @return Un tableau dynamique b de type intarray.
intarray copy(intarray a) {
intarray b = make() ;
b.begin = malloc(a.capacity * 4) ;
b.size = a.size ;
for (int i=0;i<a.size+1; i++){
b.begin[i] = a.begin[i] ;
}
return b ;
}
/// @brief Renvoie la valeur a[i] si elle existe sinon 0
/// @param a Un tableau dynamique de type intarray
/// @param i Un entier int
/// @return Un entier sur 32 bit soit appartenant au tableau ou 0.
u_int32_t force_get(intarray a , int i ) {
if ( 0 <= i && i <= a.size ) {
u_int32_t x = get(a, i) ;
return x ;
}
u_int32_t x = 0 ;
return x ;
}
/*revoien un intarray de taille=capacité=0 pointant vers aucun tableau*/
intarray make () {
intarray t;
t.size=0;
t.capacity=0;
t.begin=NULL;
return t;
}
/*Rajoute a la fin d'un tableau pointé par pa:intarray* l'entier x: __uint32_t si pas assew de place realloue un tableau plus grand*/
void push(intarray* pa, __uint32_t x){
if (pa->capacity>= (pa->size +1))
{
/* on a suffisment de place */
pa->begin[pa->size]=x;
pa->size=pa->size+1;
}
else
{
/*On creer un nouveau tableau*/
pa->capacity=5/4*pa->capacity+4;
__uint32_t* nv_begin=malloc(sizeof(__uint32_t)*(pa->capacity));
for (int i = 0; i < pa->size; i++)
{
nv_begin[i]=pa->begin[i];
}
free(pa->begin);
pa->begin=nv_begin;
push(pa,x);
}
}
/*Essaie de mettre x:__uint32_t a la case i;int du tableau pointé par pa:int array
si pa pas assez long il souleve une erreur*/
void set (intarray a, int i, __uint32_t x){
assert(i<a.size);
/* On regarde si le ieme element du tableau existe deja pour pouvoir le modifier*/
a.begin[i]=x;
}
/*Cherche l'element a l'indice i:int dans a:intarray, si existe pas alors renvoie 0 */
__uint32_t force_get(intarray a, int i){
if (i<a.size)
{
return a.begin[i];
}
else
{
return 0;
}
}
// teste les fontions précédentes
void test_exo_1() {
intarray a = make();
push(&a, 1);
push(&a, 2);
push(&a, 3);
print_array(a);
assert(get(a, 1) == 2);
set(a, 1, 7);
assert(get(a, 1) == 7);
u_int32_t element = pop(&a);
print_array(a);
reset(&a);
}
void print_value(big_int b)
{
intarray digits = make();
big_int temp = copy(b);
while(temp.size > 0)
push(&digits, tenth(&temp));
for(int i = temp.size-1; i>=0; i--) printf("%u", temp.begin[i]);
printf("\n");
return;
}
// Ce fichier étant inlcus dans le fichier ex2.c, je ne peux mettre 2 fonctions main et donc je commente celle-ci.
// int main() {
// intarray t = make();
// push(&t, 15);
// push(&t, 20);
// push(&t, 5);
// push(&t, 12);
// print_array(t);
// printf("L'élément d'indice 2 est : %u.\n", get(t, 2));
// // printf("L'élément d'indice 6 est : %u.\n", get(t, 6)); // Test pour vérifier que l'assertion fonctionne bien.
// set(t, 2, 55);
// print_array(t);
// printf("L'élément enlevé du haut de la pile était : %u.\n", pop(&t));
// print_array(t);
// reset(&t);
// return 0;
// }
#include "ex1.c"
//on travaillera uniquement avec des pointeurs vers des intarray donc un seul malloc est ici nécessaire
intarray* make(){
intarray* new = malloc(sizeof(intarray));
new->begin = NULL;
new->size = 0;
new->capacity = 0;
return new;
}
intarray* copy(intarray* pa){
intarray* pb = malloc(sizeof(intarray));
pb->capacity = pa->capacity;
pb->size = pa->size;
pb->begin = malloc(sizeof(uint32_t)*pb->capacity);
for(int i=0; i<pb->size; i++){
pb->begin[i] = pa->begin[i];
}
return pb;
}
intarray make(){ // On initialise le tableau vide par un pointeur nul, une capacité nulle et une taille de 0
intarray tab;
tab.begin=NULL;
tab.capacity = 0;
tab.size = 0;
return tab;
}
u_int32_t pop(intarray* pa){
assert((*pa).size>0); //Pour enlever le dernier élément du tableau, on commence par vérifier que la tableau n'est pas vide,
(*pa).size=((*pa).size)-1; // On diminue ensuite la taille du tableau (il n'est pas nécessaire de modifier la valeur inscrite)
return *((*pa).begin+(*pa).size); //On renvoie la dernière valeur de l'ancien tableau
}
//on créée dynamiquement un intarray sur la pile
//il faut un pointeur sans quoi la durée de vie de l'objet crééé ne dépasse pas celui de la fonction
intarray* make() {
intarray* t = malloc(sizeof(intarray));
(*t).begin = NULL; (*t).size = 0; (*t).capa = 0;
return t;
}
*/
int main(void) {
// TEST EXERCICE 1 ET 2
intarray test = make();
for (int i = 0; i < 20; i++) {
push(&test, i);
if (i % 3 == 0) set(test, i / 2, i * 2);
}
for (int i = 0; i < 10; i++) {
printf("%d\n", pop(&test));
}
printf("get : %d\n", get(test, 5));
printf("force_get : %d\n", force_get(test, 5));
printf("force_get : %d\n", force_get(test, 15));
intarray test2 = copy(test);
printf("Tableau test : ");
print_array(test);
force_set(&test2, 15, 30);
push_front(&test, 50);
printf("Tableau test : ");
print_array(test);
printf("Tableau test2 : ");
print_array(test2);
reset(&test);
reset(&test2);
//FIN TEST EXERCICE 1 ET 2
// TEST EXERCICE 3
big_int b = make();
print_repr(b);
push(&b, 3);
push(&b, 15);
push(&b, 7);
push(&b, 0);
push(&b, 0);
push(&b, 0);
print_repr(b);
canonical(&b);
print_repr(b);
printf("%d\n", half(&b));
reset(&b);
return 0;
}
int main() {
// Test every function
test_intarray();
test_bigint();
}
- Est-ce que le dépôt mentionné dans le formulaire existe ou non ?
- Utilisation de commentaires (si possible docstring, pas un blabla horrible)
- Pas de commentaires utiles dans le corps d'une fonction
- Utilisation de realloc au lieu de malloc
si c'est pour réallouer
- Gestion d'erreurs de malloc faite
- Séparation en fichier .h et .c
- Indentation bien faite et uniforme
- Ecriture de tests
- Pas d'utilisation de "5 / 4" qui vaut 1
- Pas de pratique bizarre (inclure un fichier
.c)
- De combien l'étudiant.e est allé