Feedback

lab/01_recap_pc/skel/Makefile

@@ -1,5 +1,5 @@
 CC=clang
-CFLAGS=-Wall -Wextra -pedantic -ansi
+CFLAGS=-Wall -Wextra -pedantic -ansi -lm
 DEBUG=-g -ggdb -O0 -march=native
 
 ELF=circles

lab/01_recap_pc/skel/matrice.c

@@ -0,0 +1,34 @@
+//Gheorghisor Ileana-Teodora 313CA
+#include <stdio.h>
+#include <stdlib.h>
+
+int main(void) 
+{
+	int n, m, i, j;
+	int **matrice;
+	scanf("%d%d", &n, &m);
+	// Alocarea dinamica a matricei
+	matrice = (int**)calloc(m, sizeof(int*));
+	for (i = 0; i < n; i++)
+		matrice[i]= (int*)calloc(n, sizeof(int));
+
+	//Rezolvarea problemei
+	int x, y;
+	while(scanf("%d%d", &x, &y)) {
+		for (i = 0; i < x; i++)
+			for (j = 0; j < y; j++) {
+				matrice[i][j]++;
+			}
+	}
+	for (i = 0; i < n; i++) {
+		for (j = 0; j < m; j++)
+			printf("%d ", matrice[i][j]);
+		printf("\n");
+	}
+
+	//Eliberarea memoriei
+		for( i = 0; i < n; i++)
+			free(matrice[i]);
+		free(matrice);
+
+}

lab/01_recap_pc/skel/src/circles.c

@@ -1,10 +1,32 @@
+//Gheorghisor Ileana-Teodora 313CA
 #include <stdio.h>
-
+#include <math.h>
 #include "utils.h"
 
+struct {
+	int x;
+	int y;
+	int r;
+} circle[100];
+
 int main()
 {
-    printf("Hello, world!\n");
-
+    int N, nr = 0, i, j;
+    scanf("%d", &N);
+    for (i = 0; i < N; i++) {
+	    scanf("%d %d %d", &circle[i].x, &circle[i].y, &circle[i].r);
+    }
+    for (i = 0; i < N - 1; i++) 
+	    for (j = i + 1; j < N; j++) {
+		    double distanta;
+		    distanta = sqrt(pow((circle[i].x - circle[j].x), 2) + pow((circle[i].y - circle[j].y), 2));
+		    if (circle[i].r + circle[j].r >= distanta)
+		    	nr++;
+		    else if(circle[i].r > circle[j].r && circle[i].r - circle[j].r >= distanta)
+		    	nr++;
+		    else if(circle[i].r < circle[j].r && circle[j].r - circle[i].r >= distanta)
+		    	nr++;
+		  }
+		  printf("%d", nr);
     return 0;
 }

lab/02_simple_linked_list/skel/src/LinkedList.c

@@ -1,14 +1,22 @@
+/* Gheorghisor Ileana-Teodora, 313CA */
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "LinkedList.h"
 #include "utils.h"
 
-linked_list_t*
-ll_create(unsigned int data_size)
+
+linked_list_t* ll_create(unsigned int data_size)
 {
-    /* TODO */
+	struct linked_list_t *list;
+
+    list = malloc(sizeof(linked_list_t));
+    list->head = NULL;
+    list->data_size = data_size;
+    list->size = 0;
+
+    return list;
 }
 
 /*
@@ -18,10 +26,54 @@ ll_create(unsigned int data_size)
  * pozitia n=0). Daca n >= nr_noduri, noul nod se adauga la finalul listei. Daca
  * n < 0, eroare.
  */
-void
-ll_add_nth_node(linked_list_t* list, unsigned int n, const void* new_data)
+void ll_add_nth_node(linked_list_t* list, unsigned int n, const void* new_data)
 {
-    /* TODO */
+	/* Daca n < 0, afisez eroare. */
+	if (n < 0) {
+		printf("%s\n", "Eroare.\n");
+	}
+	else {
+		struct ll_node_t *new, *curr, *nextt;
+
+		if (list == NULL) {
+			return;
+		}
+		new = (struct ll_node_t*)malloc(sizeof(struct ll_node_t));
+		new->data = (void*)malloc(sizeof(void*));
+
+		/* Daca n >= nr_noduri, adaug la final. */
+	    if (n >= list->size && list->size != 0) {
+	    	memcpy(new->data, new_data, sizeof(void*));
+			new->next = NULL;
+			curr = list->head;
+			while (curr->next != NULL) {
+				curr = curr->next;
+			}
+			curr->next = new;
+			list->size++;
+
+		} else if (n > 0 && list->size != 0) {
+			/* Altfel, inserez nodul intre curr si nextt, pe pozitia n. */
+			unsigned int i = 0;
+			curr = list->head;
+			while (curr->next != NULL && i < n) {
+				curr = curr->next;
+				i++;
+			}
+			memcpy(new->data, new_data, sizeof(void*));
+			nextt = curr->next;
+			curr->next = new;
+			new->next = nextt;
+			list->size++;
+
+		} else if (n == 0 || list->size == 0) {
+			/* Pentru primul nod, n = 0. */
+			memcpy(new->data, new_data, sizeof(void*));
+			new->next = list->head;
+			list->head = new;
+			list->size++;
+		}
+	}
 }
 
 /*
@@ -32,20 +84,68 @@ ll_add_nth_node(linked_list_t* list, unsigned int n, const void* new_data)
  * nod proaspat eliminat din lista. Este responsabilitatea apelantului sa
  * elibereze memoria acestui nod.
  */
-ll_node_t*
-ll_remove_nth_node(linked_list_t* list, unsigned int n)
+ll_node_t* ll_remove_nth_node(linked_list_t* list, unsigned int n)
 {
-    /* TODO */
+    /* Daca n < 0, afisez eroare. */
+	if (n < 0) {
+		printf("%s\n", "Eroare.\n");
+		return NULL;
+	}
+	else {
+		struct ll_node_t *last, *prev, *curr, *first;
+
+		if (list == NULL || list->head == NULL) {
+			return NULL;
+		}
+
+		/* Daca n >= nr_noduri - 1, sterg ultimul nod. */
+		if (n >= list->size - 1) {
+			if(list->size == 1) {
+				list->size--;
+				return(list->head);
+			}
+			last = list->head->next;
+			prev = list->head;
+			while (last->next != NULL) {
+				prev = last;
+				last = last->next;
+			}
+			prev->next = NULL;
+			list->size--;
+			return last;
+
+		} else if (n != 0) {
+			/* Altfel, sterg nodul de pe pozitia n (cu exceptia n = 0). */
+			unsigned int i = 1;
+			prev = list->head;
+			curr = list->head->next;
+			while (curr->next != NULL && i < n) {
+				prev = curr;
+				curr = curr->next;
+				i++;
+			}
+			prev->next = curr->next;
+			list->size--;
+			return curr;
+
+		} else if (n == 0) {
+			/* Sterg primul nod pt n = 0. */
+			first = list->head;
+			list->head = first->next;
+			list->size--;
+			return first;
+		}
+	}
+	return NULL;
 }
 
 /*
  * Functia intoarce numarul de noduri din lista al carei pointer este trimis ca
  * parametru.
  */
-unsigned int
-ll_get_size(linked_list_t* list)
+unsigned int ll_get_size(linked_list_t* list)
 {
-    /* TODO */
+    return (unsigned int)list->size;
 }
 
 /*
@@ -54,22 +154,35 @@ ll_get_size(linked_list_t* list)
  * NULL valoarea pointerului la care pointeaza argumentul (argumentul este un
  * pointer la un pointer).
  */
-void
-ll_free(linked_list_t** pp_list)
+void ll_free(linked_list_t** pp_list)
 {
-    /* TODO */
+    if (*pp_list == NULL || pp_list == NULL) {
+    	return;
+    }
+    while (ll_get_size(*pp_list) > 0) {
+    	free(ll_remove_nth_node(*pp_list, 0));
+    }
+    free(*pp_list);
+    *pp_list = NULL;
 }
 
 /*
  * Atentie! Aceasta functie poate fi apelata doar pe liste ale caror noduri STIM
  * ca stocheaza int-uri. Functia afiseaza toate valorile int stocate in nodurile
  * din lista inlantuita separate printr-un spatiu.
  */
-void
-ll_print_int(linked_list_t* list)
+void ll_print_int(linked_list_t* list)
 {
-    /* TODO */
+    struct ll_node_t *curr;
 
+    if (list == NULL) {
+    	return;
+    }
+    curr = list->head;
+    while (curr != NULL) {
+    	printf("%u ", *((unsigned int*)curr->data));
+    	curr = curr->next;
+    }
     printf("\n");
 }
 
@@ -78,10 +191,42 @@ ll_print_int(linked_list_t* list)
  * ca stocheaza string-uri. Functia afiseaza toate string-urile stocate in
  * nodurile din lista inlantuita, separate printr-un spatiu.
  */
-void
-ll_print_string(linked_list_t* list)
+void ll_print_string(linked_list_t* list)
 {
-    /* TODO */
+    struct ll_node_t *curr;
 
+    if (list == NULL) {
+    	return;
+    }
+    curr = list->head;
+    while (curr != NULL) {
+    	printf("%s ", (char*)curr->data);
+    	curr = curr->next;
+    }
     printf("\n");
 }
+
+/* Functia de la exercitiul 2*/
+void ll_ex2(linked_list_t* list)
+{
+	unsigned int i = 0;
+	struct linked_list_t *indici_pari, *indici_impari;
+	struct ll_node_t *curr;
+
+	indici_pari = ll_create(sizeof(int));
+	indici_impari = ll_create(sizeof(int));
+	curr = list->head;
+
+	while (curr != NULL) {
+		ll_add_nth_node(indici_pari, i, curr->data);
+		curr = curr->next;
+		i++;
+		if (curr != NULL) {
+			ll_add_nth_node(indici_impari, i, curr->data);
+			curr = curr->next;
+			i++;
+		}
+	}
+	ll_print_int(indici_pari);
+	ll_print_int(indici_impari);
+}

lab/02_simple_linked_list/skel/src/LinkedList.h

@@ -16,25 +16,18 @@ struct linked_list_t
     unsigned int size;
 };
 
-linked_list_t*
-ll_create(unsigned int data_size);
+linked_list_t* ll_create(unsigned int data_size);
 
-void
-ll_add_nth_node(linked_list_t* list, unsigned int n, const void* data);
+void ll_add_nth_node(linked_list_t* list, unsigned int n, const void* data);
 
-ll_node_t*
-ll_remove_nth_node(linked_list_t* list, unsigned int n);
+ll_node_t* ll_remove_nth_node(linked_list_t* list, unsigned int n);
 
-unsigned int
-ll_get_size(linked_list_t* list);
+unsigned int ll_get_size(linked_list_t* list);
 
-void
-ll_free(linked_list_t** pp_list);
+void ll_free(linked_list_t** pp_list);
 
-void
-ll_print_int(linked_list_t* list);
+void ll_print_int(linked_list_t* list);
 
-void
-ll_print_string(linked_list_t* list);
+void ll_print_string(linked_list_t* list);
 
 #endif /* __LINKED_LIST_H_ */

lab/02_simple_linked_list/skel/src/TestLinkedList.c

@@ -5,8 +5,7 @@
 
 #define MAX_STRING_SIZE 64
 
-int
-main()
+int main()
 {
     linked_list_t* linkedList;
     int is_int = 0;
@@ -35,7 +34,7 @@ main()
         }
         if (strcmp(command, "remove") == 0) {
             scanf("%ld", &pos);
-            ll_remove_nth_node(linkedList, pos);
+            free(ll_remove_nth_node(linkedList, pos));
         }
         if (strcmp(command, "print") == 0) {
             if (is_int == 1) {
@@ -49,6 +48,9 @@ main()
             ll_free(&linkedList);
             break;
         }
+        if (strcmp(command, "ex2") == 0) {
+            ll_ex2(linkedList);
+        }
     }
     return 0;
 }