diff --git a/package-lock.json b/package-lock.json
index 3397ec1..3159b21 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -1,6 +1,6 @@
{
"name": "@sourcecodeoer/cli",
- "version": "1.0.0",
+ "version": "1.1.3",
"lockfileVersion": 1,
"requires": true,
"dependencies": {
diff --git a/results/results1.json b/results/results1.json
index fa9a223..ad2696e 100644
--- a/results/results1.json
+++ b/results/results1.json
@@ -2,7 +2,7 @@
"exercises": [
{
"title": "Absolute value",
- "description": "The absolute value of a number is defined as *|n| = n* if *n >= 0*,\r\n*|n| = -n* else.\r\n",
+ "description": "
The absolute value of a number is defined as |n| = n if n >= 0, |n| = -n else.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -51,7 +51,7 @@
},
{
"title": "Advanced queue",
- "description": "You must implement the `enqueue` and `dequeue` functions of a Queue that is implemented as a simple circular\r\nlist. This [Wikipedia\r\npage](https://en.wikipedia.org/wiki/Linked_list#Circularly_linked_vs._linearly_linked)\r\ndescribes such a list as follows:\r\n\r\n\"With a circular list, a pointer to the last node gives easy access also\r\nto the first node, by following one link. Thus, in applications that\r\nrequire access to both ends of the list (e.g., in the implementation of\r\na queue), a circular structure allows one to handle the structure by a\r\nsingle pointer, instead of two.\"\r\n\r\n\r\n\r\nAssume that the head of the queue is the leftmost node and that the tail\r\nof the queue is the rightmost node. In the previous example, the head\r\nand the tail are respectively `12` and `37`. So in this case, the only\r\npointer you can use will point to the `37` node.\r\n\r\nYou can use the following datastructures for this exercise:\r\n\r\n``` c\r\ntypedef struct node{\r\n struct node* next;\r\n int value;\r\n} node_t;\r\n\r\ntypedef struct queue{\r\n struct node* tail;\r\n int size;\r\n} queue_t ;\r\n```\r\n",
+ "description": "
You must implement the enqueue and dequeue functions of a Queue that is implemented as a simple circular list. This Wikipedia page describes such a list as follows:
\r\n
\"With a circular list, a pointer to the last node gives easy access also to the first node, by following one link. Thus, in applications that require access to both ends of the list (e.g., in the implementation of a queue), a circular structure allows one to handle the structure by a single pointer, instead of two.\"
\r\n
\r\n
Assume that the head of the queue is the leftmost node and that the tail of the queue is the rightmost node. In the previous example, the head and the tail are respectively 12 and 37. So in this case, the only pointer you can use will point to the 37 node.
\r\n
You can use the following datastructures for this exercise:
\r\n
typedef struct node{\r\n struct node* next;\r\n int value;\r\n} node_t;\r\n\r\ntypedef struct queue{\r\n struct node* tail;\r\n int size;\r\n} queue_t ;
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -110,7 +110,7 @@
},
{
"title": "ArrayList",
- "description": "Vous devez modifier une librairie qui implémente une ArrayList en y\r\najoutant une fonction. Cette ArrayList s'utilise comme suit\r\n\r\n``` c\r\nint main(void) {\r\n struct array_list *head = arraylist_init((size_t) 2, (size_t) sizeof(int));\r\n int first = 5;\r\n int second = 6;\r\n int third = 7;\r\n int tmp;\r\n\r\n int ret;\r\n\r\n if (!head)\r\n return 0;\r\n\r\n set_element(head, 0, (void *)&first);\r\n set_element(head, 1, (void *)&second);\r\n\r\n get_element(head, 1, (void *)&tmp);\r\n // tmp contient 6\r\n add_tail(head, (void *)&third);\r\n get_element(head, 2, (void *)&tmp);\r\n // tmp contient 7\r\n printf(\"array-list size: %d element-size %d\\n\", get_size(head), get_elem_size(head));\r\n // affiche array-list size: 3 element-size 4\r\n array_list_destroy(head);\r\n return 0;\r\n}\r\n```\r\n\r\nLe syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : -\r\n (commandes) -\r\n (appels systèmes) -\r\n (fonctions\r\nlibrairies)\r\n",
+ "description": "
Vous devez modifier une librairie qui implémente une ArrayList en y ajoutant une fonction. Cette ArrayList s'utilise comme suit
\r\n
int main(void) {\r\n struct array_list *head = arraylist_init((size_t) 2, (size_t) sizeof(int));\r\n int first = 5;\r\n int second = 6;\r\n int third = 7;\r\n int tmp;\r\n\r\n int ret;\r\n\r\n if (!head)\r\n return 0;\r\n\r\n set_element(head, 0, (void *)&first);\r\n set_element(head, 1, (void *)&second);\r\n\r\n get_element(head, 1, (void *)&tmp);\r\n // tmp contient 6\r\n add_tail(head, (void *)&third);\r\n get_element(head, 2, (void *)&tmp);\r\n // tmp contient 7\r\n printf("array-list size: %d element-size %d\\n", get_size(head), get_elem_size(head));\r\n // affiche array-list size: 3 element-size 4\r\n array_list_destroy(head);\r\n return 0;\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -169,7 +169,7 @@
},
{
"title": "Get an array from a binary file using mmap",
- "description": "Given a file containing a linked list of the structure *student\\_t*\r\nfollowing, you have to write a function to load the entire linked list\r\nfrom the file and to return a pointer to the head of this linked list.\r\nAssume that, in the file, if **a** is followed by **b**, you will have\r\n`a->next = b`.\r\n\r\n``` c\r\ntypedef struct student{\r\n struct student* next;\r\n int noma;\r\n} student_t;\r\n```\r\n\r\nIn this exercice, you **cannot** use *fopen*, *read*, *fread*, *fgetc*,\r\n*fgets*, which means that you must use\r\n[mmap(2).](https://sites.uclouvain.be/SystInfo/manpages/man2/mmap.2.html)\r\n\r\nIn case of error (using malloc), you have to free **all** the memory you\r\nhave allocated.\r\n",
+ "description": "
Given a file containing a linked list of the structure student_t following, you have to write a function to load the entire linked list from the file and to return a pointer to the head of this linked list. Assume that, in the file, if a is followed by b, you will have a->next = b.
\r\n
typedef struct student{\r\n struct student* next;\r\n int noma;\r\n} student_t;
\r\n
In this exercice, you cannot use fopen, read, fread, fgetc, fgets, which means that you must use mmap(2).
\r\n
In case of error (using malloc), you have to free all the memory you have allocated.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -235,7 +235,7 @@
},
{
"title": "Traduction de code assembleur",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants :\r\n\r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions\r\n librairies)\r\n",
+ "description": "
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -294,7 +294,7 @@
},
{
"title": "Traduction de code assembleur",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants :\r\n\r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n",
+ "description": "
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -353,7 +353,7 @@
},
{
"title": "Traduction de code assembleur",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -412,7 +412,7 @@
},
{
"title": "Traduction de code assembleur",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -471,7 +471,7 @@
},
{
"title": "Simple linked list",
- "description": "We ask you to write two simple functions that are needed to implement a\r\nsimple linked list.\r\n\r\n``` c\r\n/**\r\n* Structure node\r\n*\r\n* @next: pointer to the next node in the list, NULL if last node_t\r\n* @value: value stored in the node\r\n*/\r\ntypedef struct node {\r\n struct node *next;\r\n int value;\r\n} node_t;\r\n\r\n/**\r\n* Structure list\r\n*\r\n* @first: first node of the list, NULL if list is empty\r\n* @size: number of nodes in the list\r\n*/\r\ntypedef struct list {\r\n struct node *first;\r\n int size;\r\n} list_t;\r\n```\r\n\r\n**In your functions, you cannot use the function**\r\n[calloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\n",
+ "description": "
We ask you to write two simple functions that are needed to implement a simple linked list.
\r\n
/**\r\n* Structure node\r\n*\r\n* @next: pointer to the next node in the list, NULL if last node_t\r\n* @value: value stored in the node\r\n*/\r\ntypedef struct node {\r\n struct node *next;\r\n int value;\r\n} node_t;\r\n\r\n/**\r\n* Structure list\r\n*\r\n* @first: first node of the list, NULL if list is empty\r\n* @size: number of nodes in the list\r\n*/\r\ntypedef struct list {\r\n struct node *first;\r\n int size;\r\n} list_t;
\r\n
In your functions, you cannot use the functioncalloc(3)
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -534,7 +534,7 @@
},
{
"title": "Bitwise operation: high order bits",
- "description": "In this exercise, we will work with operation on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. 0b11010 = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operation on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -588,7 +588,7 @@
},
{
"title": "Bitwise operation: extract low order bits",
- "description": "In this exercise, we will work with operations on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. `0b11010` = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operations on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -642,7 +642,7 @@
},
{
"title": "Bitwise operation: cycling bits",
- "description": "In this exercise, we will work with operations on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. 0b11010 = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operations on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -696,7 +696,7 @@
},
{
"title": "Bitwise operation: resetting the highest order bit",
- "description": "In this exercise, we will work with operations on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. 0b11010 = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operations on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -750,7 +750,7 @@
},
{
"title": "Bitwise operation: counting set bits",
- "description": "In this exercise, we will work with operations on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. 0b11010 = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operations on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -804,7 +804,7 @@
},
{
"title": "Opérations sur les bits",
- "description": "On souhaite effectuer des opérations spécifiques sur certains bits d'un\r\nentier non-signé de 32 bits. Lorsque l'on parle de position, l'indice 0\r\ncorrespond au bit le plus faible, et 31 au bit le plus fort. Dans cet\r\nexercice, un unsigned char représente\r\ntoujours un seul bit et ne pourra donc que prendre les valeurs\r\nnumériques 0 ou 1 (et non '0' et '1')\r\n\r\nÉcrivez une fonction unsigned char\r\nget\\_bit(unsigned int x, unsigned int pos) qui renvoie le bit à\r\nla position pos de x.\r\n\r\nÉcrivez une fonction unsigned int\r\nset\\_bit(unsigned int x, unsigned int pos, unsigned char value)\r\nqui met le bit à la position pos de x à\r\nla valeur value.\r\n\r\nÉcrivez une fonction unsigned char\r\nget\\_3\\_leftmost\\_bits(unsigned int x) qui renvoie les 3 bits les\r\nplus à gauches de x. Par exemple, si on a la séquence 11011001, la\r\nfonction doit renvoyer la valeur correspondant à 00000110.\r\n\r\nÉcrivez une fonction unsigned char\r\nget\\_4\\_rightmost\\_bits(unsigned int x) qui renvoie les 4 bits\r\nles plus à droite de x.\r\n\r\nÉcrivez une fonction unsigned int\r\nunset\\_last\\_bit(unsigned int x) qui met à 0 le premier bit de\r\npoids fort à 1 qu'il trouve, et ne fait rien s'il n'y a pas de bit mis à\r\n1.\r\n\r\nÉcrivez une fonction unsigned int\r\ncycle\\_bits(unsigned int x, unsigned int n) qui déplace tous les\r\nbits de n places vers la gauche selon la formule x\\[(i+n)%32\\] = x\\[i\\]\r\noù x\\[i\\] représente le ième bit de x.\r\n\r\nVous pouvez faire appel aux fonctions get\\_bit et set\\_bit dans les autres.\r\n",
+ "description": "
On souhaite effectuer des opérations spécifiques sur certains bits d'un entier non-signé de 32 bits. Lorsque l'on parle de position, l'indice 0 correspond au bit le plus faible, et 31 au bit le plus fort. Dans cet exercice, un unsigned char représente toujours un seul bit et ne pourra donc que prendre les valeurs numériques 0 ou 1 (et non '0' et '1')
\r\n
Écrivez une fonction unsigned char get_bit(unsigned int x, unsigned int pos) qui renvoie le bit à la position pos de x.
\r\n
Écrivez une fonction unsigned int set_bit(unsigned int x, unsigned int pos, unsigned char value) qui met le bit à la position pos de x à la valeur value.
\r\n
Écrivez une fonction unsigned char get_3_leftmost_bits(unsigned int x) qui renvoie les 3 bits les plus à gauches de x. Par exemple, si on a la séquence 11011001, la fonction doit renvoyer la valeur correspondant à 00000110.
\r\n
Écrivez une fonction unsigned char get_4_rightmost_bits(unsigned int x) qui renvoie les 4 bits les plus à droite de x.
\r\n
Écrivez une fonction unsigned int unset_last_bit(unsigned int x) qui met à 0 le premier bit de poids fort à 1 qu'il trouve, et ne fait rien s'il n'y a pas de bit mis à 1.
\r\n
Écrivez une fonction unsigned int cycle_bits(unsigned int x, unsigned int n) qui déplace tous les bits de n places vers la gauche selon la formule x[(i+n)%32] = x[i] où x[i] représente le ième bit de x.
\r\n
Vous pouvez faire appel aux fonctions get_bit et set_bit dans les autres.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -858,7 +858,7 @@
},
{
"title": "Gestion d'une librairie",
- "description": "On souhaite gérer le catalogue d'une librairie dans lequel chaque livre\r\nest identifié par son auteur et son titre. La structure de données\r\nchoisie est la suivante : il y a une liste chaînée d'auteurs dont chaque\r\nélément pointe vers une liste chaînée d'ouvrages.\r\n\r\n``` c\r\ntypedef struct cellAuteur {\r\n char *auteur;\r\n struct cellLivre *Livres;\r\n struct cellAuteur *next;\r\n} cellAuteur;\r\n\r\ntypedef struct cellLivre {\r\n char *titre;\r\n struct cellLivre *suiv;\r\n} cellLivre;\r\n```\r\n\r\nÉcrivez une fonction cellAuteur\r\n\\*existe(cellAuteur \\*librairie, char \\*strAuteur) qui teste si\r\nun auteur existe dans la liste librairie et dans ce cas renvoie un\r\npointeur sur sa cellule de la liste (et NULL sinon).\r\n\r\nÉcrivez une fonction int\r\ncompteOuvrage(cellAuteur \\*librairie, char \\*strAuteur) qui\r\ncompte le nombre de livres d'un auteur dans la liste librairie.\r\n\r\nÉcrivez une fonction void add(cellAuteur\r\n\\*librairie, char \\*strAuteur, char \\*strTitre) qui ajoute dans\r\nle catalogue un livre de l'auteur indiqué. L'auteur existe dans le\r\ncatalogue. Un même livre ne peut pas être présent 2 fois dans la\r\ncatalogue.\r\n\r\nÉcrivez une fonction void supprimer(cellAuteur\r\n\\*\\*librairie, char \\*strAuteur) qui supprime du catalogue un\r\nauteur et tous ses livres. L'auteur existe dans le catalogue.\r\n\r\nVous avez accès aux fonctions de string.h.\r\n",
+ "description": "
On souhaite gérer le catalogue d'une librairie dans lequel chaque livre est identifié par son auteur et son titre. La structure de données choisie est la suivante : il y a une liste chaînée d'auteurs dont chaque élément pointe vers une liste chaînée d'ouvrages.
Écrivez une fonction cellAuteur *existe(cellAuteur *librairie, char *strAuteur) qui teste si un auteur existe dans la liste librairie et dans ce cas renvoie un pointeur sur sa cellule de la liste (et NULL sinon).
\r\n
Écrivez une fonction int compteOuvrage(cellAuteur *librairie, char *strAuteur) qui compte le nombre de livres d'un auteur dans la liste librairie.
\r\n
Écrivez une fonction void add(cellAuteur *librairie, char *strAuteur, char *strTitre) qui ajoute dans le catalogue un livre de l'auteur indiqué. L'auteur existe dans le catalogue. Un même livre ne peut pas être présent 2 fois dans la catalogue.
\r\n
Écrivez une fonction void supprimer(cellAuteur **librairie, char *strAuteur) qui supprime du catalogue un auteur et tous ses livres. L'auteur existe dans le catalogue.
\r\n
Vous avez accès aux fonctions de string.h.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -912,7 +912,7 @@
},
{
"title": "Simple Binary Search Tree",
- "description": "For this task, you will implement a simple binary search on an existing\r\nbinary tree. A binary tree has the following structure:\r\n\r\n\r\n\r\nThis binary tree is composed of nodes implemented using the following\r\nstructure.\r\n\r\n``` c\r\n/*\r\n* Node has a value, @value, and two children, @left and @right.\r\n* All the children of @left and itself have a smaller value than the node and all the children of @right and itself have a larger value than node\r\n*/\r\ntypedef struct node{\r\n int value;\r\n struct node* left; // to smaller values\r\n struct node* right; // to larger values\r\n} node_t;\r\n```\r\n\r\nThe binary tree itself is defined as follows.\r\n\r\n``` c\r\ntypedef struct bt{\r\n struct node* root;\r\n} bt_t;\r\n```\r\n",
+ "description": "
For this task, you will implement a simple binary search on an existing binary tree. A binary tree has the following structure:
\r\n
\r\n
This binary tree is composed of nodes implemented using the following structure.
\r\n
/*\r\n* Node has a value, @value, and two children, @left and @right.\r\n* All the children of @left and itself have a smaller value than the node and all the children of @right and itself have a larger value than node\r\n*/\r\ntypedef struct node{\r\n int value;\r\n struct node* left; // to smaller values\r\n struct node* right; // to larger values\r\n} node_t;
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -975,7 +975,7 @@
},
{
"title": "BST : Insert and Delete",
- "description": "To help you study your english course, you've got the wonderful idea of\r\ncreating a Binary Search Tree (BST). This will also help you to study\r\nfor the LSINF1252 course! The key of each node will be the english word\r\nand the value will be the french word corresponding. Those are\r\nrepresented using an array of char. So let's define our 2 structures :\r\n\r\n``` c\r\ntypedef struct bt {\r\n struct node *root;\r\n} bt_t;\r\n\r\ntypedef struct node {\r\n char *enWord;\r\n char *frWord;\r\n struct node *left;\r\n struct node *right;\r\n} node_t;\r\n```\r\n\r\n**What is a Binary Search Tree (BST) ?**\r\n\r\nA Binary Search Tree is a tree for which every node has a special\r\nproperty : the subtree defined by node.left only contains keys(enWord)\r\nlower than the node's key. Similarly, the subtree defined by node.right\r\nonly contains keys higher than the node's key. This is helpful when\r\nsearching for a specific key in the data structure.\r\n\r\nTODO : SCHEME NEEDED + EXPLAIN WHICH NODE IS THE ROOT. + CHANGE THE CODE\r\n: word -> enWord, definition -> frWord.\r\n\r\n**Your mission**\r\n\r\nYour mission will be to implement the **insert** and the **delete**\r\nfunctions.\r\n\r\n- **Insert** function :\r\n\r\nFor each node we know this : every key (*enWord*) in the node.left\r\nsubpart is lower than the key of the node. Similarly, every key\r\n(*enWord*) in the node.right subpart is lower than the key of the node.\r\nWe use the alphabetical order to check if one word is lower or higher\r\nthan another one.\r\n\r\n- **Delete** function :\r\n\r\nDeleting a node in a tree like that might not be easy ! That's why I'll\r\nexplain you how to proceed (you'll have to use this procedure in order\r\nto get the points). If the node we want to delete has 0 or only 1 child,\r\nit's quite easy, we only have to replace this node by his child (if\r\nthere is one). When it comes to a node which has two children, it's\r\nharder. We first have to find the right subtree's leftmost child. In the\r\nexample, if we want to suppress *XXX*, the leftmost node of the right\r\nsubpart is *YYY*. Then, we can move *YYY* to *XXX* and replace *YYY* by\r\nhis child (if it has one).\r\n\r\nSCHEME NEEDED for XXX and YYY.\r\n\r\n*Hints :*\r\n\r\n- `char *enWord` and `char *frWord` are pointers, memory must be\r\n allocated by using\r\n [malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\n to copy the strings in the tree.\r\n- Other useful commands:\r\n [strcpy(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strcpy.3.html),\r\n [strlen(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strlen.3.html)\r\n and\r\n [strcmp(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strcmp.3.html).\r\n- Do not forget to free **all** the allocated space deleting an\r\n element.\r\n",
+ "description": "
To help you study your english course, you've got the wonderful idea of creating a Binary Search Tree (BST). This will also help you to study for the LSINF1252 course! The key of each node will be the english word and the value will be the french word corresponding. Those are represented using an array of char. So let's define our 2 structures :
A Binary Search Tree is a tree for which every node has a special property : the subtree defined by node.left only contains keys(enWord) lower than the node's key. Similarly, the subtree defined by node.right only contains keys higher than the node's key. This is helpful when searching for a specific key in the data structure.
\r\n
TODO : SCHEME NEEDED + EXPLAIN WHICH NODE IS THE ROOT. + CHANGE THE CODE : word -> enWord, definition -> frWord.
\r\n
Your mission
\r\n
Your mission will be to implement the insert and the delete functions.
\r\n
\r\n
Insert function :
\r\n
\r\n
For each node we know this : every key (enWord) in the node.left subpart is lower than the key of the node. Similarly, every key (enWord) in the node.right subpart is lower than the key of the node. We use the alphabetical order to check if one word is lower or higher than another one.
\r\n
\r\n
Delete function :
\r\n
\r\n
Deleting a node in a tree like that might not be easy ! That's why I'll explain you how to proceed (you'll have to use this procedure in order to get the points). If the node we want to delete has 0 or only 1 child, it's quite easy, we only have to replace this node by his child (if there is one). When it comes to a node which has two children, it's harder. We first have to find the right subtree's leftmost child. In the example, if we want to suppress XXX, the leftmost node of the right subpart is YYY. Then, we can move YYY to XXX and replace YYY by his child (if it has one).
\r\n
SCHEME NEEDED for XXX and YYY.
\r\n
Hints :
\r\n
\r\n
char *enWord and char *frWord are pointers, memory must be allocated by using malloc(3) to copy the strings in the tree.
Do not forget to free all the allocated space deleting an element.
\r\n
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1025,7 +1025,7 @@
},
{
"title": "Parcours d'un arbre binaire de recherche",
- "description": "On souhaite parcourir un arbre binaire de recherche. Un arbre de\r\nrecherche binaire est une structure de données où chaque nœud possède\r\nune clé et une valeur. En outre, chaque nœud peut avoir 2 nœuds fils :\r\nun à gauche dont la clé est toujours inférieure à la sienne, et un à\r\ndroite dont la clé est toujours supérieure à la sienne. Autrement dit si\r\nvous êtes à un nœud dont la clé vaut 10 et que vous cherchez un nœud\r\ndont la clé vaut 5, vous savez que vous devez descendre à gauche pour\r\nespérer trouver un éventuel nœud dont la clé vaut 5.\r\n\r\n``` c\r\ntypedef struct BSTreeNode {\r\n int key;\r\n int value;\r\n\r\n struct BSTreeNode *left;\r\n struct BSTreeNode *right;\r\n} Node;\r\n```\r\n\r\nÉcrivez une fonction int has\\_key(Node root, int\r\nkey) qui vérifie si l'arbre binaire dont le sommet est le nœud\r\nroot possède un nœud dont la clé vaut key et renvoie 1 si oui, renvoie 0\r\nsinon.\r\n\r\nÉcrivez une fonction int compare(Node root\\_a,\r\nNode root\\_b) qui vérifie si les 2 arbres binaires passés en\r\nargument sont identiques (ils ont la même structure et tous les nœuds\r\npossèdent la même paire clé/valeur). Renvoie 1 si les arbres sont\r\nidentiques, 0 sinon. Indice : pensez récursivement.\r\n",
+ "description": "
On souhaite parcourir un arbre binaire de recherche. Un arbre de recherche binaire est une structure de données où chaque nœud possède une clé et une valeur. En outre, chaque nœud peut avoir 2 nœuds fils : un à gauche dont la clé est toujours inférieure à la sienne, et un à droite dont la clé est toujours supérieure à la sienne. Autrement dit si vous êtes à un nœud dont la clé vaut 10 et que vous cherchez un nœud dont la clé vaut 5, vous savez que vous devez descendre à gauche pour espérer trouver un éventuel nœud dont la clé vaut 5.
\r\n
typedef struct BSTreeNode {\r\n int key;\r\n int value;\r\n\r\n struct BSTreeNode *left;\r\n struct BSTreeNode *right;\r\n} Node;
\r\n
Écrivez une fonction int has_key(Node root, int key) qui vérifie si l'arbre binaire dont le sommet est le nœud root possède un nœud dont la clé vaut key et renvoie 1 si oui, renvoie 0 sinon.
\r\n
Écrivez une fonction int compare(Node root_a, Node root_b) qui vérifie si les 2 arbres binaires passés en argument sont identiques (ils ont la même structure et tous les nœuds possèdent la même paire clé/valeur). Renvoie 1 si les arbres sont identiques, 0 sinon. Indice : pensez récursivement.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1079,7 +1079,7 @@
},
{
"title": "Coder calloc en utilisant malloc",
- "description": "Ecrire la fonction `calloc2`, ayant le même prototype et le même\r\nfonctionnement que\r\n[calloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/calloc.3.html)\r\nmais qui utilise\r\n[malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\npour allouer la mémoire.\r\n",
+ "description": "
Ecrire la fonction calloc2, ayant le même prototype et le même fonctionnement que calloc(3) mais qui utilise malloc(3) pour allouer la mémoire.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1133,7 +1133,7 @@
},
{
"title": "Comparing functions",
- "description": "Pointers to functions can be used to handle functions in a dynamic\r\nfashion, and will be of great importance later in this course. It is\r\nhence important to grasp how they work.\r\n\r\nIn this exercise, you will code a function which receives pointers to\r\ntwo functions, to determine if these functions are equivalent. Two\r\nfunctions are considered to be equivalent if they always produce the\r\nsame output for the same input.\r\n\r\nThe functions passed by pointers will be of the form\r\n`uint8_t func(uint8_t n)`.\r\n",
+ "description": "
Pointers to functions can be used to handle functions in a dynamic fashion, and will be of great importance later in this course. It is hence important to grasp how they work.
\r\n
In this exercise, you will code a function which receives pointers to two functions, to determine if these functions are equivalent. Two functions are considered to be equivalent if they always produce the same output for the same input.
\r\n
The functions passed by pointers will be of the form uint8_t func(uint8_t n).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1192,7 +1192,7 @@
},
{
"title": "Le programme test",
- "description": "La commande\r\n[test(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/test.1.html)\r\npermet d'évaluer une expression passée en paramètre. Elle retourne:\r\n\r\n- `0` si l'expression passée en argument est vraie\r\n- `1` si l'expression passée en argument est fausse\r\n\r\nOn vous demande d'écrire un sous-ensemble de la commande\r\n[test(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/test.1.html)\r\nen C. Les expressions à implémenter sont `-eq`, `-ge`, `-gt`, `-le`,\r\n`-lt` et `-ne`.\r\n\r\nPour rappel, la commande\r\n[test(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/test.1.html)\r\nest décrite dans la [page de\r\nmanuel](https://sites.uclouvain.be/SystInfo/manpages/man1/test.1.html)\r\nqui lui est consacrée.\r\n\r\nPour répondre à cette question, vous devez structurer votre programme\r\navec des appels de sous-fonction et donc de ne pas faire toute\r\nl'exécution dans la fonction `main()`.\r\n\r\nIl existe plusieurs façons pour tester votre code, une de ces façons est\r\nde regarder dans le shell le contenu de la variable `$?` après chaque\r\nexécution de votre programme. Une autre façon est de profiter de\r\nl'instruction conditionnelle `if-then-else` du shell.\r\n",
+ "description": "
La commande test(1) permet d'évaluer une expression passée en paramètre. Elle retourne:
\r\n
\r\n
0 si l'expression passée en argument est vraie
\r\n
1 si l'expression passée en argument est fausse
\r\n
\r\n
On vous demande d'écrire un sous-ensemble de la commande test(1) en C. Les expressions à implémenter sont -eq, -ge, -gt, -le, -lt et -ne.
\r\n
Pour rappel, la commande test(1) est décrite dans la page de manuel qui lui est consacrée.
\r\n
Pour répondre à cette question, vous devez structurer votre programme avec des appels de sous-fonction et donc de ne pas faire toute l'exécution dans la fonction main().
\r\n
Il existe plusieurs façons pour tester votre code, une de ces façons est de regarder dans le shell le contenu de la variable $? après chaque exécution de votre programme. Une autre façon est de profiter de l'instruction conditionnelle if-then-else du shell.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1251,7 +1251,7 @@
},
{
"title": "Count the '\\0'",
- "description": "The character '\\\\0' identifies the end of a string in C. But it can also\r\nplay the role of a real character.\r\n\r\nIn this exercice, write the body of the function `counting_zero`, which\r\ncounts the number of occurence of the character '\\\\0'.\r\n\r\nYou cannot use any function from the string library.\r\n",
+ "description": "
The character '\\0' identifies the end of a string in C. But it can also play the role of a real character.
\r\n
In this exercice, write the body of the function counting_zero, which counts the number of occurence of the character '\\0'.
\r\n
You cannot use any function from the string library.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1354,7 +1354,7 @@
},
{
"title": "Liste doublement chaînée",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1413,7 +1413,7 @@
},
{
"title": "Manipulation de liste",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1467,7 +1467,7 @@
},
{
"title": "Factorial",
- "description": "The factorial of an integer *n!* is defined as `n! = 1*2*3*...*(n-1)*n`,\r\nwith *0! = 1*.\r\n",
+ "description": "
The factorial of an integer n! is defined as n! = 1*2*3*...*(n-1)*n, with 0! = 1.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1521,7 +1521,7 @@
},
{
"title": "Parcours de fichiers",
- "description": "Parcourez un fichier sans jamais utiliser l'appel système read. Le\r\nsyllabus est accessible depuis \r\n",
+ "description": "
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1571,7 +1571,7 @@
},
{
"title": "Déterminer la valeur de retour d'un programme exécutable",
- "description": "Dans un programme similaire à un shell, on vous demander d'écrire une\r\nfonction qui permet de lancer un exécutable et d'indiquer si :\r\n\r\n- le programme ne s'est pas exécuté ou a retourné une valeur de retour\r\n positive\r\n- le programme s'est exécuté correctement et a retourné une valeur de\r\n retour =0\r\n- le programme a été interrompu par un signal\r\n\r\nLe syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n",
+ "description": "
Dans un programme similaire à un shell, on vous demander d'écrire une fonction qui permet de lancer un exécutable et d'indiquer si :
\r\n
\r\n
le programme ne s'est pas exécuté ou a retourné une valeur de retour positive
\r\n
le programme s'est exécuté correctement et a retourné une valeur de retour =0
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1630,7 +1630,7 @@
},
{
"title": "Threads : plus grand commun diviseur",
- "description": "On cherche à calculer le plus grand commun diviseur de deux très grands\r\nnombres. Pour ce faire, on calcule tous les diviseurs de chacun des 2\r\nnombres, et on regarde quel est leur PGCD. Pour ce faire, on déclare la\r\nliste chaînée suivante, permettant d'enregistrer en mémoire les\r\ndiviseurs d'un nombre :\r\n\r\n``` c\r\nstruct Node {\r\n unsigned int divisor;\r\n struct Node *next;\r\n};\r\n```\r\n\r\nÉcrivez une fonction void \\*factorize(void\r\n\\*n) qui retourne un pointeur vers une liste chaînée contenant\r\ntous les diviseurs dans l'ordre décroissant du nombre de type unsigned int vers lequel n pointe.\r\n\r\nÉcrivez une fonction unsigned int gcd(unsigned\r\nint a, unsigned int b) qui va lancer l'exécution de factorize pour a et b dans 2 threads différents\r\net va extraire des deux listes renvoyées le PGCD. Le nombre 1 est\r\nconsidéré comme un diviseur. Cette fonction renvoie 0 si une erreur\r\ns'est produite.\r\n",
+ "description": "
On cherche à calculer le plus grand commun diviseur de deux très grands nombres. Pour ce faire, on calcule tous les diviseurs de chacun des 2 nombres, et on regarde quel est leur PGCD. Pour ce faire, on déclare la liste chaînée suivante, permettant d'enregistrer en mémoire les diviseurs d'un nombre :
\r\n
struct Node {\r\n unsigned int divisor;\r\n struct Node *next;\r\n};
\r\n
Écrivez une fonction void *factorize(void *n) qui retourne un pointeur vers une liste chaînée contenant tous les diviseurs dans l'ordre décroissant du nombre de type unsigned int vers lequel n pointe.
\r\n
Écrivez une fonction unsigned int gcd(unsigned int a, unsigned int b) qui va lancer l'exécution de factorize pour a et b dans 2 threads différents et va extraire des deux listes renvoyées le PGCD. Le nombre 1 est considéré comme un diviseur. Cette fonction renvoie 0 si une erreur s'est produite.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1684,7 +1684,7 @@
},
{
"title": "Conversions hexadécimales",
- "description": "On souhaite convertir un entier non signé vers sa représentation\r\nhexadécimale. Par exemple l'entier 42 vaut \"2A\" en hexadécimal. De même,\r\non souhaite faire la conversion dans l'autre sens.\r\n\r\nÉcrivez une fonction unsigned int\r\nhex\\_to\\_int(char \\*hex) qui prend en argument une chaîne de\r\ncaractères représentant un nombre hexadécimal (cette chaîne ne peut\r\ncomporter que les chiffres de 0 à 9 et les lettres A à F).\r\n\r\nÉcrivez une fonction char\r\n\\*int\\_to\\_hex(unsigned int value, char \\*dest) qui prend en\r\nargument un entier non-signé et enregistre sa représentation\r\nhexadécimale dans la chaîne de caractères indiquée par dest. On suppose\r\nque dest est un tableau de 9 char au minimum. La fonction devra toujours\r\nrenvoyer le pointeur dest.\r\n",
+ "description": "
On souhaite convertir un entier non signé vers sa représentation hexadécimale. Par exemple l'entier 42 vaut \"2A\" en hexadécimal. De même, on souhaite faire la conversion dans l'autre sens.
\r\n
Écrivez une fonction unsigned int hex_to_int(char *hex) qui prend en argument une chaîne de caractères représentant un nombre hexadécimal (cette chaîne ne peut comporter que les chiffres de 0 à 9 et les lettres A à F).
\r\n
Écrivez une fonction char *int_to_hex(unsigned int value, char *dest) qui prend en argument un entier non-signé et enregistre sa représentation hexadécimale dans la chaîne de caractères indiquée par dest. On suppose que dest est un tableau de 9 char au minimum. La fonction devra toujours renvoyer le pointeur dest.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1738,7 +1738,7 @@
},
{
"title": "Indexation d'un texte",
- "description": "On souhaite indexer un texte afin de savoir quels mots reviennent le\r\nplus fréquemment dans un corpus. Le processus d'indexation se fait en 2\r\nphases : on compte d'abord le nombre d'occurrences de chaque mot, et on\r\nsupprime ensuite de la table d'indexation tous les mots qui n'ont pas\r\nété indexés au moins N fois. Le corpus est une chaîne de caractères\r\ncomposées uniquement de minuscules et où le seul délimiteur est un\r\nespace (pas de ponctuation). Votre programme n'est jamais censé produire\r\nd'erreurs de segmentation.\r\n\r\nOn définit la structure suivante représentant une entrée de l'index :\r\n\r\n``` c\r\ntypedef struct indexEntry {\r\n char word[26];\r\n int count; //nombre de fois qu'un mot est apparu dans le corpus\r\n struct indexEntry *next;\r\n} Entry;\r\n```\r\n\r\nÉcrivez une fonction Entry \\*build\\_index(char\r\n\\*corpus) qui renvoie l'index associé au corpus passé en\r\nparamètre. Vous pouvez modifier la chaine passée en argument.\r\n\r\nÉcrivez une fonction void filter\\_index(Entry\r\n\\*\\*index\\_head, int treshold) qui supprime de l'index tous les\r\nmots qui n'ont pas été recensés au moins treshold fois.\r\n\r\nVous avez accès aux fonctions de string.h\r\net de stdlib.h.\r\n",
+ "description": "
On souhaite indexer un texte afin de savoir quels mots reviennent le plus fréquemment dans un corpus. Le processus d'indexation se fait en 2 phases : on compte d'abord le nombre d'occurrences de chaque mot, et on supprime ensuite de la table d'indexation tous les mots qui n'ont pas été indexés au moins N fois. Le corpus est une chaîne de caractères composées uniquement de minuscules et où le seul délimiteur est un espace (pas de ponctuation). Votre programme n'est jamais censé produire d'erreurs de segmentation.
\r\n
On définit la structure suivante représentant une entrée de l'index :
\r\n
typedef struct indexEntry {\r\n char word[26];\r\n int count; //nombre de fois qu'un mot est apparu dans le corpus\r\n struct indexEntry *next;\r\n} Entry;
\r\n
Écrivez une fonction Entry *build_index(char *corpus) qui renvoie l'index associé au corpus passé en paramètre. Vous pouvez modifier la chaine passée en argument.
\r\n
Écrivez une fonction void filter_index(Entry **index_head, int treshold) qui supprime de l'index tous les mots qui n'ont pas été recensés au moins treshold fois.
\r\n
Vous avez accès aux fonctions de string.h et de stdlib.h.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1792,7 +1792,7 @@
},
{
"title": "Tri par insertion",
- "description": "On désire implémenter un algorithme de tri par insertion sur un tableau\r\nde N entiers, le tableau et sa taille étant passés en argument.\r\n\r\nL'algorithme de tri est le suivant : Pour chaque élément d'indice i (i\r\nvariant de 1 à N-1)\r\n\r\n- cet élément devient la clé\r\n- on la compare avec l'élément d'indice i-1\r\n- si la clé est plus petite, on les échange et on recommence la\r\n comparaison avec l'élément précédent (d'indice i-2) et ainsi de\r\n suite, tant que la clé est plus petite que l'élément qui lui précède\r\n (ou qu'on est revenu au début du tableau)\r\n- quand la clé est à sa place (c'est-à-dire qu'elle est plus grande\r\n que ou égale à l'élément qui lui précède), la boucle intérieure est\r\n finie et on passe à l'élément d'indice i+1.\r\n",
+ "description": "
On désire implémenter un algorithme de tri par insertion sur un tableau de N entiers, le tableau et sa taille étant passés en argument.
\r\n
L'algorithme de tri est le suivant : Pour chaque élément d'indice i (i variant de 1 à N-1)
\r\n
\r\n
cet élément devient la clé
\r\n
on la compare avec l'élément d'indice i-1
\r\n
si la clé est plus petite, on les échange et on recommence la comparaison avec l'élément précédent (d'indice i-2) et ainsi de suite, tant que la clé est plus petite que l'élément qui lui précède (ou qu'on est revenu au début du tableau)
\r\n
quand la clé est à sa place (c'est-à-dire qu'elle est plus grande que ou égale à l'élément qui lui précède), la boucle intérieure est finie et on passe à l'élément d'indice i+1.
\r\n
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1846,7 +1846,7 @@
},
{
"title": "Intersection de fichiers",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2005,7 +2005,7 @@
},
{
"title": "Filtering a linked list",
- "description": "You have a linked list. Each element of the list is a `struct node`.\r\n\r\n``` c\r\nstruct node {\r\n struct node *next;\r\n int hash;\r\n int id;\r\n char name[20];\r\n char buffer[100];\r\n unsigned int timestamp;\r\n char acl;\r\n short flow;\r\n char *parent;\r\n void *fifo;\r\n};\r\n```\r\n",
+ "description": "
You have a linked list. Each element of the list is a struct node.
\r\n
struct node {\r\n struct node *next;\r\n int hash;\r\n int id;\r\n char name[20];\r\n char buffer[100];\r\n unsigned int timestamp;\r\n char acl;\r\n short flow;\r\n char *parent;\r\n void *fifo;\r\n};
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2064,7 +2064,7 @@
},
{
"title": "Reading arguments",
- "description": "When you execute a C program, its function `main()` is called with, as\r\nparameters, the name of the program and the arguments after the\r\nexecutable's name.\r\n",
+ "description": "
When you execute a C program, its function main() is called with, as parameters, the name of the program and the arguments after the executable's name.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2118,7 +2118,7 @@
},
{
"title": "malloc, realloc et free INCOMPLETE",
- "description": "La type de la plupart des variables en C est facile à déterminer.\r\nNéanmoins, le C contient aussi des types qui ne diffèrent que de façons\r\nsubtiles, comme les\r\n",
+ "description": "
La type de la plupart des variables en C est facile à déterminer. Néanmoins, le C contient aussi des types qui ne diffèrent que de façons subtiles, comme les
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2168,7 +2168,7 @@
},
{
"title": "Multiplication de matrices",
- "description": "Écrivez une fonction\r\n`int access(int *A, int taille, int ordonnee, int abscisse)` qui renvoie\r\nl'élément d'abscisse et d'ordonnée indiquées dans une matrice carrée\r\ntaille x taille d'entiers (il s'agit donc de l'élément A\\[ordonnee\\]\\[abscisse\\]). Les indices ordonnee et abscisse vont de 1 à taille.\r\n\r\nÉcrivez une fonction qui effectue la multiplication de deux matrices\r\ncarrées taille x taille d'entiers. Le prototype de la fonction est la\r\nsuivante : void mult(int \\*A, int \\*B, int \\*C,\r\nint taille) et elle calcule C = A x B. Les trois matrices sont\r\nstockées sous forme de tableau ligne par ligne et la place de la matrice\r\nC est déjà allouée.\r\n",
+ "description": "
Écrivez une fonction int access(int *A, int taille, int ordonnee, int abscisse) qui renvoie l'élément d'abscisse et d'ordonnée indiquées dans une matrice carrée taille x taille d'entiers (il s'agit donc de l'élément A[ordonnee][abscisse]). Les indices ordonnee et abscisse vont de 1 à taille.
\r\n
Écrivez une fonction qui effectue la multiplication de deux matrices carrées taille x taille d'entiers. Le prototype de la fonction est la suivante : void mult(int *A, int *B, int *C, int taille) et elle calcule C = A x B. Les trois matrices sont stockées sous forme de tableau ligne par ligne et la place de la matrice C est déjà allouée.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2222,7 +2222,7 @@
},
{
"title": "strlen, strcat et strcasecmp",
- "description": "La libraire\r\n[string(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/string.3.html)\r\nimplémente un grand nombre de fonctions de manipulation des strings qui\r\nvous seront utiles lors de différents projets de programmation.\r\n",
+ "description": "
La libraire string(3) implémente un grand nombre de fonctions de manipulation des strings qui vous seront utiles lors de différents projets de programmation.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2280,7 +2280,7 @@
},
{
"title": "Reading from the wire",
- "description": "Back in 1977, you want to read your e-mail with your freshly bought\r\nApple II. You are connected to the ARPANET through a modem, but\r\nunfortunately the modem's manufacturer has only given a single function\r\n`modem_read`, to read the data received by the modem, with the following\r\nprototype :\r\n\r\n`void modem_read(void *buffer, int *buf_len);`\r\n\r\nThis function fills the supplied buffer with the data received from the\r\nmodem (an array of `char`), and writes the number of bytes written to\r\nthe value pointed by `buf_len`. It can write up to maximum 256 bytes in\r\na single call. This function is guaranteed to return.\r\n",
+ "description": "
Back in 1977, you want to read your e-mail with your freshly bought Apple II. You are connected to the ARPANET through a modem, but unfortunately the modem's manufacturer has only given a single function modem_read, to read the data received by the modem, with the following prototype :
\r\n
void modem_read(void *buffer, int *buf_len);
\r\n
This function fills the supplied buffer with the data received from the modem (an array of char), and writes the number of bytes written to the value pointed by buf_len. It can write up to maximum 256 bytes in a single call. This function is guaranteed to return.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2343,7 +2343,7 @@
},
{
"title": "Manipulate the memory",
- "description": "Given the following structure *university\\_t*:\r\n\r\n``` c\r\ntypedef struct university {\r\n char* city;\r\n int creation;\r\n person_t* rector;\r\n} university_t;\r\n```\r\n\r\nAnd the structure *person\\_t*:\r\n\r\n``` c\r\ntypedef struct person {\r\n char* name;\r\n int salary;\r\n int age;\r\n} person_t;\r\n```\r\n\r\nYou are asked to implement the functions `init_all` and `free_all`,\r\nwhich respectively initialises the structure *universiy\\_t* and frees\r\nall the memory associated with it.\r\n\r\nThe *name* and the *city* have been allocated with *malloc*.\r\n\r\n*Hint:* all the data may not have been initialised correctly. Therefore,\r\nyou have to handle all the cases (e.g. some pointers can be already\r\nNULL, and don't need to be freed).\r\n",
+ "description": "
Given the following structure university_t:
\r\n
typedef struct university {\r\n char* city;\r\n int creation;\r\n person_t* rector;\r\n} university_t;
\r\n
And the structure person_t:
\r\n
typedef struct person {\r\n char* name;\r\n int salary;\r\n int age;\r\n} person_t;
\r\n
You are asked to implement the functions init_all and free_all, which respectively initialises the structure universiy_t and frees all the memory associated with it.
\r\n
The name and the city have been allocated with malloc.
\r\n
Hint: all the data may not have been initialised correctly. Therefore, you have to handle all the cases (e.g. some pointers can be already NULL, and don't need to be freed).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2402,7 +2402,7 @@
},
{
"title": "Mes propres sémaphores",
- "description": "On souhaite écrire notre propre type de sémaphore à l'aide de mutex. On\r\ndéclare pour ce faire les 2 structures suivantes :\r\n\r\n``` c\r\ntypedef struct semProcess {\r\n pthread_mutex_t mutex;\r\n struct semProcess *next;\r\n} sem_process_t;\r\n\r\ntypedef struct mySem {\r\n int value;\r\n int capacity;\r\n sem_process_t *blocked_procs;\r\n pthread_mutex_t mutex;\r\n} mysem_t;\r\n```\r\n\r\nChaque sémaphore contient une valeur et une liste de processus bloqués.\r\nLe mutex de mySem devra être utilisé pour éviter que des appels\r\nconcurrents des fonctions sousmentionnées sur la même sémaphore ne\r\nsoient pas exécutés simultanément.\r\n\r\nÉcrivez une fonction int mysem\\_wait(mysem\\_t\r\n\\*sem) qui bloque le fil d'exécution si value de sem\r\nvaut 0 et ajoute le processus à la fin de la liste des processus\r\nbloqués. Pour bloquer un processus, vous devrez ajouter un sem\\_process\\_t à blocked\\_procs du sémaphore et verrouiller le\r\nmutex de sem\\_process\\_t. Si value est plus grand que 0, il est décrémenté.\r\n\r\nÉcrivez une fonction int mysem\\_post(mysem\\_t\r\n\\*sem) qui incrémente value de\r\nsem si aucun autre processus n'est\r\nbloqué, et sinon débloque le premier processus de la liste des processus\r\nbloqués. value ne peut jamais excéder\r\ncapacity. **ATTENTION** : Ne libérez pas\r\nla structure sem\\_process\\_t d'un processus libéré, contentez-vous de\r\nsupprimer son mutex. Considérez que la fonction mysem\\_close que vous n'avez pas à implémenter\r\ns'occupe de la libération des ressources.\r\n",
+ "description": "
On souhaite écrire notre propre type de sémaphore à l'aide de mutex. On déclare pour ce faire les 2 structures suivantes :
Chaque sémaphore contient une valeur et une liste de processus bloqués. Le mutex de mySem devra être utilisé pour éviter que des appels concurrents des fonctions sousmentionnées sur la même sémaphore ne soient pas exécutés simultanément.
\r\n
Écrivez une fonction int mysem_wait(mysem_t *sem) qui bloque le fil d'exécution si value de sem vaut 0 et ajoute le processus à la fin de la liste des processus bloqués. Pour bloquer un processus, vous devrez ajouter un sem_process_t à blocked_procs du sémaphore et verrouiller le mutex de sem_process_t. Si value est plus grand que 0, il est décrémenté.
\r\n
Écrivez une fonction int mysem_post(mysem_t *sem) qui incrémente value de sem si aucun autre processus n'est bloqué, et sinon débloque le premier processus de la liste des processus bloqués. value ne peut jamais excéder capacity. ATTENTION : Ne libérez pas la structure sem_process_t d'un processus libéré, contentez-vous de supprimer son mutex. Considérez que la fonction mysem_close que vous n'avez pas à implémenter s'occupe de la libération des ressources.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2456,7 +2456,7 @@
},
{
"title": "My strlen - REVIEWED",
- "description": "Your objective is to implement\r\n[strlen](https://sites.uclouvain.be/SystInfo/manpages/man3/strlen.3.html)\r\none of the basic functions of the C library that deals with strings.\r\n",
+ "description": "
Your objective is to implement strlen one of the basic functions of the C library that deals with strings.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2510,7 +2510,7 @@
},
{
"title": "Ordered linked list",
- "description": "Given the provided implementation of a linked list, you need to\r\nimplement the `insert` function based on a specific order relation. The\r\ngoal is to implement an ordered list similar to a LinkedList with a Comparator in Java.\r\n",
+ "description": "
Given the provided implementation of a linked list, you need to implement the insert function based on a specific order relation. The goal is to implement an ordered list similar to a LinkedList with a Comparator in Java.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2569,7 +2569,7 @@
},
{
"title": "Soumission du projet de seconde session",
- "description": "Cette tâche permet de vérifier la validité de l'archive à soumettre pour\r\nle projet de seconde session sur les matrices creuses. Une archive ne\r\npassant pas le test ne sera pas corrigée.\r\n",
+ "description": "
Cette tâche permet de vérifier la validité de l'archive à soumettre pour le projet de seconde session sur les matrices creuses. Une archive ne passant pas le test ne sera pas corrigée.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2609,7 +2609,7 @@
},
{
"title": "Palindrome",
- "description": "Palindrome are strings of text which read the same backward as forward,\r\ni.e. : \"racecar\", \"a man a plan a canal panama\" or \"kayak\".\r\n",
+ "description": "
Palindrome are strings of text which read the same backward as forward, i.e. : \"racecar\", \"a man a plan a canal panama\" or \"kayak\".
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2663,7 +2663,7 @@
},
{
"title": "Producteurs/Consommateurs",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n\r\n\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2722,7 +2722,7 @@
},
{
"title": "Pointer arithmetic",
- "description": "A hacker wanted to challenge you and encrypted your hard drive. To\r\nunlock your drive, he gave you a function\r\n`get_key(int a, char b, int c)` which returns the decryption key if the\r\ncorrect parameters are given.\r\n\r\nHe then hid the parameters *a*, *b* and *c* in memory, and gave you a\r\npointer from which you can retrieve these parameters.\r\n",
+ "description": "
A hacker wanted to challenge you and encrypted your hard drive. To unlock your drive, he gave you a function get_key(int a, char b, int c) which returns the decryption key if the correct parameters are given.
\r\n
He then hid the parameters a, b and c in memory, and gave you a pointer from which you can retrieve these parameters.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2776,7 +2776,7 @@
},
{
"title": "Polynômes",
- "description": "On souhaite gérer des polynômes réels de degré inférieur ou égal à 10 en\r\nutilisant la structure suivante :\r\n\r\ntypedef struct { double coeff\\[10\\]; }\r\npoly;\r\n\r\nqui servira à représenter le polynôme où coeff\\[0\\] est le coefficient\r\ndu terme indépendant, coeff\\[1\\] le coefficient du terme en x, etc.\r\n\r\nÉcrivez une fonction double eval(poly \\*P,\r\ndouble x) qui calcule la valeur du polynôme P au point x. On\r\npourra se servir de la formule de Horner : P(x) = ((...(a\\_9\\*x +\r\na\\_8)*x + a\\_7)*x + ...)x + a\\_1)\\*x + a\\_0 où a\\_i est coeff\\[i\\].\r\n\r\nÉcrivez une fonction void derivee(poly \\*P, poly\r\n\\*Pderiv) qui inscrit dans Pderiv\r\nla dérivée du polynôme P.\r\n\r\nÉcrivez une fonction double racine(poly \\*P,\r\ndouble x0) qui calcule via la méthode de Newton la racine du\r\npolynôme P. La méthode est la suivante : on part d'un point initial, et\r\non construit une suite de points qui se rapprochent de la racine en\r\ncalculant à chaque étape un nouveau point à partir de la valeur du\r\npolynôme et de sa dérivée : x\\_n+1 = x\\_n - P(x\\_n)/P'(x\\_n). La\r\nfonction s'arrête lorsque abs(P(x\\_n)) < 0.0001. On suppose que le\r\ncalcul converge toujours vers une racine.\r\n",
+ "description": "
On souhaite gérer des polynômes réels de degré inférieur ou égal à 10 en utilisant la structure suivante :
\r\n
typedef struct { double coeff[10]; } poly;
\r\n
qui servira à représenter le polynôme où coeff[0] est le coefficient du terme indépendant, coeff[1] le coefficient du terme en x, etc.
\r\n
Écrivez une fonction double eval(poly *P, double x) qui calcule la valeur du polynôme P au point x. On pourra se servir de la formule de Horner : P(x) = ((...(a_9*x + a_8)x + a_7)x + ...)x + a_1)*x + a_0 où a_i est coeff[i].
\r\n
Écrivez une fonction void derivee(poly *P, poly *Pderiv) qui inscrit dans Pderiv la dérivée du polynôme P.
\r\n
Écrivez une fonction double racine(poly *P, double x0) qui calcule via la méthode de Newton la racine du polynôme P. La méthode est la suivante : on part d'un point initial, et on construit une suite de points qui se rapprochent de la racine en calculant à chaque étape un nouveau point à partir de la valeur du polynôme et de sa dérivée : x_n+1 = x_n - P(x_n)/P'(x_n). La fonction s'arrête lorsque abs(P(x_n)) < 0.0001. On suppose que le calcul converge toujours vers une racine.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2830,7 +2830,7 @@
},
{
"title": "Printing data",
- "description": "In this exercise, you will familiarize yourself with the functions\r\n[printf(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/printf.3.html)\r\n(printing on the standard output) and\r\n[sprintf(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/sprintf.3.html)\r\n(text formatting).\r\n",
+ "description": "
In this exercise, you will familiarize yourself with the functions printf(3) (printing on the standard output) and sprintf(3) (text formatting).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2889,7 +2889,7 @@
},
{
"title": "Modification de fichier",
- "description": "La fonction `reverse`, dont les spécifications sont reprises ci-dessous,\r\npermet de manipuler les données dans un fichier.\r\n\r\nLe syllabus est accessible depuis l'URL\r\n Les pages de manuel sont\r\naccessibles depuis les URLs suivants :\r\n\r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions\r\n librairies)\r\n",
+ "description": "
La fonction reverse, dont les spécifications sont reprises ci-dessous, permet de manipuler les données dans un fichier.
\r\n
Le syllabus est accessible depuis l'URL http://sites.uclouvain.be/SystInfo Les pages de manuel sont accessibles depuis les URLs suivants :
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2948,7 +2948,7 @@
},
{
"title": "Calculatrice en notation polonaise inversée",
- "description": "La notation polonaise inversée permet d'écrire de façon non-ambigüe sans\r\nparenthèses des formules arithmétiques. Par exemple, le calcul ((1 + 2)\r\n× 4) + 3 peut être noté 1 2 + 4 \\* 3 + en notation polonaise inverse, ou\r\nencore 3 4 1 2 + \\* +. L'avantage de cette notation est qu'elle est très\r\nfacilement compréhensible par un ordinateur : on imagine une pile où on\r\npeut soit ajouter un élément sur la pile, soit retirer le dernier\r\nélément ajouté. En parcourant la formule arithmétique, si on rencontre\r\nun nombre, on l'ajoute à la pile, si on rencontre une opérande (par ex.\r\nle symbole '+'), on retire les 2 derniers éléments de la pile, on en\r\nfait la somme et on ajoute le résultat à la pile.\r\n\r\nPour ce problème, vous ne pourrez utiliser que la variable globale double stack\\[STACK\\_SIZE\\], représentant la\r\npile, et int stack\\_height, représentant\r\nla hauteur actuelle de la pile, qui seront déjà initialisées à 0 et\r\naccessibles par vos fonctions. Vous pouvez supposer que les exemples\r\nutilisés par les tests feront en sorte que le nombre d'éléments actuels\r\ndans la pile ne dépassera jamais STACK\\_SIZE.\r\n\r\nÉcrivez une fonction void push(double value)\\` qui permet d'ajouter\r\nl'élément value à la pile.\r\n\r\nÉcrivez une fonction double pop(void) qui\r\nenlève et retourne l'élément au sommet de la pile.\r\n\r\nÉcrivez une fonction double rpn(char\r\n\\*expr) qui calcule l'expression en notation polonaise inverse\r\ncontenue dans expr et retourne le résultat. Vous pouvez supposer que\r\nexpr contiendra toujours une expression\r\ncorrecte où il ne restera jamais qu'un seul élément sur la pile à la fin\r\nde l'exécution. Indice : utilisez la fonction strtok(3) pour séparer les\r\ndifférents éléments de la chaîne et la fonction atof(3) pour convertir\r\nl'éventuel nombre rencontré en double. Exemple : \"4 2 5 \\* + 1 3 2 \\* +\r\n/\" est censé renvoyer 2. Les opérandes possibles sont + (addition), -\r\n(soustraction), \\* (multiplication) et / (division).\r\n",
+ "description": "
La notation polonaise inversée permet d'écrire de façon non-ambigüe sans parenthèses des formules arithmétiques. Par exemple, le calcul ((1 + 2) × 4) + 3 peut être noté 1 2 + 4 * 3 + en notation polonaise inverse, ou encore 3 4 1 2 + * +. L'avantage de cette notation est qu'elle est très facilement compréhensible par un ordinateur : on imagine une pile où on peut soit ajouter un élément sur la pile, soit retirer le dernier élément ajouté. En parcourant la formule arithmétique, si on rencontre un nombre, on l'ajoute à la pile, si on rencontre une opérande (par ex. le symbole '+'), on retire les 2 derniers éléments de la pile, on en fait la somme et on ajoute le résultat à la pile.
\r\n
Pour ce problème, vous ne pourrez utiliser que la variable globale double stack[STACK_SIZE], représentant la pile, et int stack_height, représentant la hauteur actuelle de la pile, qui seront déjà initialisées à 0 et accessibles par vos fonctions. Vous pouvez supposer que les exemples utilisés par les tests feront en sorte que le nombre d'éléments actuels dans la pile ne dépassera jamais STACK_SIZE.
\r\n
Écrivez une fonction void push(double value)` qui permet d'ajouter l'élément value à la pile.
\r\n
Écrivez une fonction double pop(void) qui enlève et retourne l'élément au sommet de la pile.
\r\n
Écrivez une fonction double rpn(char *expr) qui calcule l'expression en notation polonaise inverse contenue dans expr et retourne le résultat. Vous pouvez supposer que expr contiendra toujours une expression correcte où il ne restera jamais qu'un seul élément sur la pile à la fin de l'exécution. Indice : utilisez la fonction strtok(3) pour séparer les différents éléments de la chaîne et la fonction atof(3) pour convertir l'éventuel nombre rencontré en double. Exemple : \"4 2 5 * + 1 3 2 * + /\" est censé renvoyer 2. Les opérandes possibles sont + (addition), - (soustraction), * (multiplication) et / (division).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3002,7 +3002,7 @@
},
{
"title": "Redirection des flux de sortie et d'erreur standards",
- "description": "Dans un shell, il est parfois nécessaire d'exécuter des programmes en\r\nredirigeant leurs flux standards de sortie et d'erreur vers un fichier.\r\n\r\nLe syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : -\r\n (commandes) -\r\n (appels systèmes) -\r\n (fonctions des\r\nlibrairies)\r\n",
+ "description": "
Dans un shell, il est parfois nécessaire d'exécuter des programmes en redirigeant leurs flux standards de sortie et d'erreur vers un fichier.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3056,7 +3056,7 @@
},
{
"title": "Capture The Flag 1",
- "description": "Téléchargez [cette\r\narchive](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_ctf1/archive.tar.gz),\r\nouvrez `FirstMission` et suivez les instructions. Un code individuel\r\nvous sera fourni à la fin de l'exercice. Entrez-le ci-dessous pour\r\nconfirmer que vous avez complètement réalisé cet exercice.\r\n",
+ "description": "
Téléchargez cette archive, ouvrez FirstMission et suivez les instructions. Un code individuel vous sera fourni à la fin de l'exercice. Entrez-le ci-dessous pour confirmer que vous avez complètement réalisé cet exercice.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3109,7 +3109,7 @@
},
{
"title": "Capture The Flag 2",
- "description": "Téléchargez [cette\r\narchive](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_ctf2/CTF2.tar.gz).\r\nPlacez son contenu dans un dossier de votre choix, lisez le fichier\r\n`FirstMission` et suivez les consignes.\r\n",
+ "description": "
Téléchargez cette archive. Placez son contenu dans un dossier de votre choix, lisez le fichier FirstMission et suivez les consignes.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3158,7 +3158,7 @@
},
{
"title": "Diff",
- "description": "3 students are suspected of doing illegal things with computers of the\r\nuniversity. They know that the computers send logs to the server and so\r\nhid their activity from the server. But they don't know that logs are\r\nalso saved on the different computers. There are the logs from the\r\nserver and from the students, use\r\n[diff(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/diff.1.html)\r\nto compare them and find which students are innocent.\r\n\r\n- [syslog](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_diff/syslog.log)\r\n- [student\r\n 1](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_diff/student1.log)\r\n- [student\r\n 2](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_diff/student2.log)\r\n- [student\r\n 3](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_diff/student3.log)\r\n",
+ "description": "
3 students are suspected of doing illegal things with computers of the university. They know that the computers send logs to the server and so hid their activity from the server. But they don't know that logs are also saved on the different computers. There are the logs from the server and from the students, use diff(1) to compare them and find which students are innocent.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3211,7 +3211,7 @@
},
{
"title": "grep",
- "description": "The [grep(1)\r\ncommand](https://sites.uclouvain.be/SystInfo/manpages/man1/grep.1.html)\r\ncan be used to detect or extract lots of information from text files.\r\nWhen working with source code,\r\n[grep(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/grep.1.html)\r\ncan help you to find in which files some functions or constants have\r\nbeen defined. For this exercise, we will use the source code of the\r\n[CUnit](http://cunit.sourceforge.net) testing framework that you can\r\ndownload as a [tar\r\narchive](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_grep/CUnit.tar).\r\n",
+ "description": "
The grep(1) command can be used to detect or extract lots of information from text files. When working with source code, grep(1) can help you to find in which files some functions or constants have been defined. For this exercise, we will use the source code of the CUnit testing framework that you can download as a tar archive.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3260,7 +3260,7 @@
},
{
"title": "Pipes",
- "description": "In this exercise you will learn to use pipes, refer to [this\r\nsection](https://sites.uclouvain.be/SystInfo/notes/Theorie/html/intro.html#shell)\r\nfor their use.\r\n\r\nDownload the following\r\n[input](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_pipes/input.txt)\r\nfrom where you want to extract an alphabetically **sorted** list of\r\n**unique** hashtags. This can easily be done with pipes. To only select\r\nhashtags from the input, you can either use `sed '/ [^{#}]/d'` or\r\n[grep(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/grep.1.html).\r\n",
+ "description": "
In this exercise you will learn to use pipes, refer to this section for their use.
\r\n
Download the following input from where you want to extract an alphabetically sorted list of unique hashtags. This can easily be done with pipes. To only select hashtags from the input, you can either use sed '/ [^{#}]/d' or grep(1).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3313,7 +3313,7 @@
},
{
"title": "tar",
- "description": "Unix users often need to backup files and directories or send them over\r\nthe Internet.\r\n[tar(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/tar.1.html)\r\nis a very useful tool which can be used to create compressed archives of\r\ndirectories and all the files that they contain. At the end of a\r\nproject, you will have created the following files (you can download\r\nthem from\r\n[here](https://inginious.info.ucl.ac.be/course/LSINF1252/s1_tar/Enonce.zip))\r\n\r\n``` console\r\n/\r\n file\r\n folder1/\r\n file1.c\r\n file2.c\r\n file3.c\r\n folder2/\r\n file1.h\r\n fime2.h\r\n file3.h\r\n```\r\n\r\nUsing\r\n[tar(1)](https://sites.uclouvain.be/SystInfo/manpages/man1/tar.1.html),\r\ncreate a `.tar.gz` compressed archive which contains all these files and\r\ndirectories and submit it below.\r\n",
+ "description": "
Unix users often need to backup files and directories or send them over the Internet. tar(1) is a very useful tool which can be used to create compressed archives of directories and all the files that they contain. At the end of a project, you will have created the following files (you can download them from here)
Using tar(1), create a .tar.gz compressed archive which contains all these files and directories and submit it below.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3366,7 +3366,7 @@
},
{
"title": "make basics",
- "description": "*Estimated time: 20 minutes*\r\n\r\n`make` is a task runner for targets described in a Makefile. It is mostly used to control the\r\ncompilation of an executable from source code. Thus, you can use it to\r\nautomate the tidious task of compiling your c code, or even automate the\r\ncompilation of a report made with LaTeX.\r\n\r\n`make` a new beginning\r\n======================\r\n\r\nTo give you a first taste, open up a *terminal* and type the following\r\ncommand: `make`.\r\n\r\n`make` will greet you with the following message:\r\n\r\n``` \r\nmake: *** No targets specified and no makefile found. Stop.\r\n```\r\n\r\nSo what happened? `make` first start to search in your *current\r\ndirectory* for a file called `Makefile`. This file contains\r\n*instructions*, aka *rules*, that tell `make` what to do. Since there is\r\nno such file, `make` stops almost instantly.\r\n\r\n`make` it simple\r\n================\r\n\r\nNow write a simple hello world program, which you will save into a file\r\ncalled `hello.c`. This program will print the following on the standard\r\noutput:\r\n\r\n``` \r\nHello make\r\n```\r\n\r\nNow, fire up your terminal, use `cd path/to/hello/folder/` to go to the\r\ndirectory which contains `hello.c` ([download\r\nhello.c](https://inginious.info.ucl.ac.be/course/LSINF1252/s2_make/hello.c)\r\nto compare with what you did) and type: `make hello`\r\n\r\nNow the `make` comes alive and tells you something like:\r\n\r\n``` \r\ngcc hello.c -o hello\r\n```\r\n\r\nWow! What happened? When you typed `make hello`, `hello` is what is\r\ncalled a **target**. A **target** is usually the name of a file that is\r\ngenerated by a program; examples of targets are executable or object\r\nfiles.\r\n\r\nBasically, `make` will search for a file named `hello` and detect from\r\nthat file what programming language it uses. For most languages, `make`\r\nhas some basic builtin recipes, called **implicit rules**, to compile\r\nit. Here the **recipe** is given in the above output.\r\n\r\nIn that output:\r\n\r\n- `gcc` stands for *GNU C Compiler*;\r\n- `hello.c` the C program to be compiled;\r\n- `-o hello` an option to place the output of the compilation in the\r\n file `hello`.\r\n\r\nNow if you type `ls` in your command line, you will see that a file\r\n`hello` appeared. This is the **executable** built by `make` from\r\n`hello.c`. Now you can execute it and verify what is printed on the\r\nstandard output.\r\n\r\nIf you type again `make hello` in your command line, it will tell you:\r\n\r\n``` \r\nmake: 'hello' is up to date.\r\n```\r\n\r\nThat is because `make` only builds the files that are changed. If\r\n`hello` is more recent than its source file `hello.c`, `make` will skip\r\nthe compilation process.\r\n\r\nTo see this, modify `hello.c` to write the following on the standard\r\noutput:\r\n\r\n``` \r\nHello, make!\r\n```\r\n\r\nFinally, run `make hello` again. Since `hello.c` is more recent than\r\n`hello`, `make` will compile the source file again.\r\n\r\nThats it, you made your first experiences with `make`.\r\n\r\nNow I strongly recommend you read [sections 2.1 to 2.3. in the GNU make\r\nmanual](https://www.gnu.org/software/make/manual/make.html#Introduction).\r\nIt will only take you 10 minutes (included in the above given estimated\r\ntime) and will help you understand how to `make` magic happen.\r\n\r\nOnce you read these 3 sections, let us practice a bit.\r\n\r\nTo try the following questions locally, you can download a zip file of\r\nthe questions folder\r\n[here](https://inginious.info.ucl.ac.be/course/LSINF1252/s2_make/make_me.zip).\r\n\r\n------------------------------------------------------------------------\r\n\r\nReferences\r\n==========\r\n\r\n- \r\n- \r\n",
+ "description": "
Estimated time: 20 minutes
\r\n
make is a task runner for targets described in a Makefile. It is mostly used to control the compilation of an executable from source code. Thus, you can use it to automate the tidious task of compiling your c code, or even automate the compilation of a report made with LaTeX.
\r\n
make a new beginning
\r\n
To give you a first taste, open up a terminal and type the following command: make.
\r\n
make will greet you with the following message:
\r\n
make: *** No targets specified and no makefile found. Stop.
\r\n
So what happened? make first start to search in your current directory for a file called Makefile. This file contains instructions, aka rules, that tell make what to do. Since there is no such file, make stops almost instantly.
\r\n
make it simple
\r\n
Now write a simple hello world program, which you will save into a file called hello.c. This program will print the following on the standard output:
\r\n
Hello make
\r\n
Now, fire up your terminal, use cd path/to/hello/folder/ to go to the directory which contains hello.c (download hello.c to compare with what you did) and type: make hello
\r\n
Now the make comes alive and tells you something like:
\r\n
gcc hello.c -o hello
\r\n
Wow! What happened? When you typed make hello, hello is what is called a target. A target is usually the name of a file that is generated by a program; examples of targets are executable or object files.
\r\n
Basically, make will search for a file named hello and detect from that file what programming language it uses. For most languages, make has some basic builtin recipes, called implicit rules, to compile it. Here the recipe is given in the above output.
\r\n
In that output:
\r\n
\r\n
gcc stands for GNU C Compiler;
\r\n
hello.c the C program to be compiled;
\r\n
-o hello an option to place the output of the compilation in the file hello.
\r\n
\r\n
Now if you type ls in your command line, you will see that a file hello appeared. This is the executable built by make from hello.c. Now you can execute it and verify what is printed on the standard output.
\r\n
If you type again make hello in your command line, it will tell you:
\r\n
make: 'hello' is up to date.
\r\n
That is because make only builds the files that are changed. If hello is more recent than its source file hello.c, make will skip the compilation process.
\r\n
To see this, modify hello.c to write the following on the standard output:
\r\n
Hello, make!
\r\n
Finally, run make hello again. Since hello.c is more recent than hello, make will compile the source file again.
\r\n
Thats it, you made your first experiences with make.
\r\n
Now I strongly recommend you read sections 2.1 to 2.3. in the GNU make manual. It will only take you 10 minutes (included in the above given estimated time) and will help you understand how to make magic happen.
\r\n
Once you read these 3 sections, let us practice a bit.
\r\n
To try the following questions locally, you can download a zip file of the questions folder here.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3433,7 +3433,7 @@
},
{
"title": "make basics - calculator",
- "description": "*Estimated time: 5 minutes*\r\n\r\nYou have just built a simple calculator. When typing `ls` in your\r\ncommand line, the source folder has the following structure:\r\n\r\n``` console\r\ncalc.c calc.h Makefile operations.c operations.h\r\n```\r\n\r\n`calc.c` contains the calculator which handles the 4 basic operations:\r\naddition, substraction, multiplication, and division. These 4 operations\r\nare implemented in `operations.c`.\r\n\r\nAs you might have noticed, there are also two other files: `calc.h` and\r\n`operations.h`. These are the corresponding **header** files of `calc.c`\r\nand `operations.c`. These headers contain the function prototypes and\r\nspecifications, but not their definitions. They can also contain\r\n`extern` declarations of variables. For more on that, see [this\r\npage](https://www.tutorialspoint.com/cprogramming/c_header_files.htm) or\r\nchapter 4 in\r\n[kernighan2006c].\r\n\r\nWhen compiling this calculator, you need to specify in the `Makefile`\r\nrules the header files needed by `calc.c`, that is both `calc.h` and\r\n`operations.h`.\r\n\r\n------------------------------------------------------------------------\r\n\r\nkernighan2006c \r\nKernighan, B. W., & Ritchie, D. M. (2006). The C programming language.\r\n",
+ "description": "
Estimated time: 5 minutes
\r\n
You have just built a simple calculator. When typing ls in your command line, the source folder has the following structure:
\r\n
calc.c calc.h Makefile operations.c operations.h
\r\n
calc.c contains the calculator which handles the 4 basic operations: addition, substraction, multiplication, and division. These 4 operations are implemented in operations.c.
\r\n
As you might have noticed, there are also two other files: calc.h and operations.h. These are the corresponding header files of calc.c and operations.c. These headers contain the function prototypes and specifications, but not their definitions. They can also contain extern declarations of variables. For more on that, see this page or chapter 4 in [kernighan2006c].
\r\n
When compiling this calculator, you need to specify in the Makefile rules the header files needed by calc.c, that is both calc.h and operations.h.
\r\n\r\n
\r\n
\r\n
kernighan2006c
\r\n
Kernighan, B. W., & Ritchie, D. M. (2006). The C programming language.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3604,7 +3604,7 @@
},
{
"title": "make more basics",
- "description": "*Estimated time: 20 minutes*\r\n\r\nFirst, read [sections 2.4 to 2.7. in the GNU make\r\nmanual](https://www.gnu.org/software/make/manual/make.html#Variables-Simplify).\r\nIt will only take you 10 minutes (included in the above given estimated\r\ntime) and will help you understand how to `make` more magic happen.\r\n\r\nAs you have just read, one very useful use of Makefiles is to use\r\nvariables. You can use a variable to define the C compiler you will use\r\nand the flags you want it to use.\r\n\r\nFor instance, let us consider the following excerpt of a Makefile:\r\n\r\n``` console\r\n# See gcc/clang manual to understand all flags\r\nCFLAGS += -std=c99 # Define which version of the C standard to use\r\nCFLAGS += -Wall # Enable the 'all' set of warnings\r\nCFLAGS += -Werror # Treat all warnings as error\r\nCFLAGS += -Wshadow # Warn when shadowing variables\r\nCFLAGS += -Wextra # Enable additional warnings\r\nCFLAGS += -O2 -D_FORTIFY_SOURCE=2 # Add canary code, i.e. detect buffer overflows\r\nCFLAGS += -fstack-protector-all # Add canary code to detect stack smashing\r\n\r\n# Object files\r\nOBJ = # TODO\r\n\r\n## all : Build calculator (by default)\r\n# Default target\r\nall: calc\r\n\r\n## calc : Build calculator\r\ncalc: # TODO\r\n\r\ncalc.o: # TODO\r\n\r\noperations.o: # TODO\r\n\r\n.PHONY: clean mrproper help\r\n\r\n## clean : Remove auto-generated files\r\nclean:\r\n @rm -f src/*.o\r\n\r\n## mrproper : Remove both auto-generated & built files\r\nmrproper: clean\r\n @rm -f calc\r\n\r\n## help : Show different make options\r\nhelp: Makefile\r\n @sed -n 's/^##//p' $<\r\n```\r\n\r\nIn this file we used 3 variables: `CC` to define the C Compiler;\r\n`CFLAGS` to define the C Compiler flags; `OBJ` to define the object\r\nfiles. This is a common use of variables to both simplify the Makefile\r\nand easily change the settings of the compiler.\r\n\r\nNotice the use of two `.PHONY` targets: `clean` which will remove\r\nauto-generated files, e.g. object files; `mrproper` which will remove\r\nboth auto-generated & built files, e.g. executable files; `help` which\r\nwill search for lines starting with `##` and print them on `stdout`\r\nwithout the `##`. Try it out by tipping `make help`.\r\n",
+ "description": "
Estimated time: 20 minutes
\r\n
First, read sections 2.4 to 2.7. in the GNU make manual. It will only take you 10 minutes (included in the above given estimated time) and will help you understand how to make more magic happen.
\r\n
As you have just read, one very useful use of Makefiles is to use variables. You can use a variable to define the C compiler you will use and the flags you want it to use.
\r\n
For instance, let us consider the following excerpt of a Makefile:
\r\n
# See gcc/clang manual to understand all flags\r\nCFLAGS += -std=c99 # Define which version of the C standard to use\r\nCFLAGS += -Wall # Enable the 'all' set of warnings\r\nCFLAGS += -Werror # Treat all warnings as error\r\nCFLAGS += -Wshadow # Warn when shadowing variables\r\nCFLAGS += -Wextra # Enable additional warnings\r\nCFLAGS += -O2 -D_FORTIFY_SOURCE=2 # Add canary code, i.e. detect buffer overflows\r\nCFLAGS += -fstack-protector-all # Add canary code to detect stack smashing\r\n\r\n# Object files\r\nOBJ = # TODO\r\n\r\n## all : Build calculator (by default)\r\n# Default target\r\nall: calc\r\n\r\n## calc : Build calculator\r\ncalc: # TODO\r\n\r\ncalc.o: # TODO\r\n\r\noperations.o: # TODO\r\n\r\n.PHONY: clean mrproper help\r\n\r\n## clean : Remove auto-generated files\r\nclean:\r\n @rm -f src/*.o\r\n\r\n## mrproper : Remove both auto-generated & built files\r\nmrproper: clean\r\n @rm -f calc\r\n\r\n## help : Show different make options\r\nhelp: Makefile\r\n @sed -n 's/^##//p' $<
\r\n
In this file we used 3 variables: CC to define the C Compiler; CFLAGS to define the C Compiler flags; OBJ to define the object files. This is a common use of variables to both simplify the Makefile and easily change the settings of the compiler.
\r\n
Notice the use of two .PHONY targets: clean which will remove auto-generated files, e.g. object files; mrproper which will remove both auto-generated & built files, e.g. executable files; help which will search for lines starting with ## and print them on stdout without the ##. Try it out by tipping make help.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3713,7 +3713,7 @@
},
{
"title": "make tests",
- "description": "*Estimated time: 15 minutes*\r\n\r\nThis week, we will see how to automate the testing process. You have the\r\nfollowing project folder structure:\r\n\r\n``` \r\nsrc/\r\n calc.c\r\n calc.h\r\n operations.c\r\n operations.h\r\ntest/\r\n calc_test.c\r\n operations_test.c\r\nMakefile\r\n```\r\n\r\nThe `Makefile` is partially done, but somehow the target `test` for\r\nbuilding the tests was lost.\r\n\r\n``` \r\nCC = gcc\r\n# See gcc/clang manual to understand all flags\r\nCFLAGS += -std=c99 # Define which version of the C standard to use\r\nCFLAGS += -Wall # Enable the 'all' set of warnings\r\nCFLAGS += -Werror # Treat all warnings as error\r\nCFLAGS += -Wshadow # Warn when shadowing variables\r\nCFLAGS += -Wextra # Enable additional warnings\r\nCFLAGS += -O2 -D_FORTIFY_SOURCE=2 # Add canary code, i.e. detect buffer overflows\r\nCFLAGS += -fstack-protector-all # Add canary code to detect stack smashing\r\n\r\n# We have no libraries to link against except libc, but we want to keep\r\n# the symbols for debugging\r\nLDFLAGS= -rdynamic -lcunit\r\n\r\n## all : Build calc (by default)\r\n# Default target\r\nall: calc\r\n\r\n## debug : Build calc in debug mode\r\n# If we run `make debug` instead, keep the debug symbols for gdb\r\n# and define the DEBUG macro.\r\ndebug: CFLAGS += -g -DDEBUG -Wno-unused-parameter -fno-omit-frame-pointer\r\ndebug: clean calc\r\n\r\n## calc : Build calc\r\n# We use an implicit rule: look for the files {calc,operations}.{c,h},\r\n# compile them and link the resulting *.o into an executable named calc\r\ncalc: calc.o operations.o\r\n $(CC) $(CFLAGS) -o calc {calc,operations}.o\r\n\r\n# We use an implicit rule: look for the files calc.{c,h},\r\n# compile them w/out linking\r\ncalc.o: src/calc.c src/calc.h\r\n $(CC) $(CFLAGS) -c src/calc.{c,h}\r\n# We use an implicit rule: look for the files operations.{c,h},\r\n# compile them w/out linking\r\noperations.o: src/operations.c src/operations.h\r\n $(CC) $(CFLAGS) -c src/operations.{c,h}\r\n\r\n# YOUR CODE HERE #\r\n\r\n# Declare clean, mrproper and help as a phony targets\r\n.PHONY: clean mrproper help\r\n\r\n## clean : Remove auto-generated files from build\r\nclean:\r\n @rm -f *.o\r\n\r\n## clean-debug : Removve auto-generated files from debug mode build\r\nclean-debug:\r\n @rm -f src/*.gch\r\n## mrproper : Remove both auto-generated & built files\r\nmrproper: clean clean-debug\r\n @rm -f calc\r\n\r\n## help : Show different make options\r\nhelp: Makefile\r\n @sed -n 's/^##//p' $<\r\n```\r\n\r\nTo try locally, you can download the project folder \\_here <>\r\n",
+ "description": "
Estimated time: 15 minutes
\r\n
This week, we will see how to automate the testing process. You have the following project folder structure:
The Makefile is partially done, but somehow the target test for building the tests was lost.
\r\n
CC = gcc\r\n# See gcc/clang manual to understand all flags\r\nCFLAGS += -std=c99 # Define which version of the C standard to use\r\nCFLAGS += -Wall # Enable the 'all' set of warnings\r\nCFLAGS += -Werror # Treat all warnings as error\r\nCFLAGS += -Wshadow # Warn when shadowing variables\r\nCFLAGS += -Wextra # Enable additional warnings\r\nCFLAGS += -O2 -D_FORTIFY_SOURCE=2 # Add canary code, i.e. detect buffer overflows\r\nCFLAGS += -fstack-protector-all # Add canary code to detect stack smashing\r\n\r\n# We have no libraries to link against except libc, but we want to keep\r\n# the symbols for debugging\r\nLDFLAGS= -rdynamic -lcunit\r\n\r\n## all : Build calc (by default)\r\n# Default target\r\nall: calc\r\n\r\n## debug : Build calc in debug mode\r\n# If we run `make debug` instead, keep the debug symbols for gdb\r\n# and define the DEBUG macro.\r\ndebug: CFLAGS += -g -DDEBUG -Wno-unused-parameter -fno-omit-frame-pointer\r\ndebug: clean calc\r\n\r\n## calc : Build calc\r\n# We use an implicit rule: look for the files {calc,operations}.{c,h},\r\n# compile them and link the resulting *.o into an executable named calc\r\ncalc: calc.o operations.o\r\n $(CC) $(CFLAGS) -o calc {calc,operations}.o\r\n\r\n# We use an implicit rule: look for the files calc.{c,h},\r\n# compile them w/out linking\r\ncalc.o: src/calc.c src/calc.h\r\n $(CC) $(CFLAGS) -c src/calc.{c,h}\r\n# We use an implicit rule: look for the files operations.{c,h},\r\n# compile them w/out linking\r\noperations.o: src/operations.c src/operations.h\r\n $(CC) $(CFLAGS) -c src/operations.{c,h}\r\n\r\n# YOUR CODE HERE #\r\n\r\n# Declare clean, mrproper and help as a phony targets\r\n.PHONY: clean mrproper help\r\n\r\n## clean : Remove auto-generated files from build\r\nclean:\r\n @rm -f *.o\r\n\r\n## clean-debug : Removve auto-generated files from debug mode build\r\nclean-debug:\r\n @rm -f src/*.gch\r\n## mrproper : Remove both auto-generated & built files\r\nmrproper: clean clean-debug\r\n @rm -f calc\r\n\r\n## help : Show different make options\r\nhelp: Makefile\r\n @sed -n 's/^##//p' $<
\r\n
To try locally, you can download the project folder _here <>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3775,7 +3775,7 @@
},
{
"title": "Save struct into file",
- "description": "*Estimated time: 25 minutes*\r\n\r\nYou are currently processing an array composed of `struct point` defined\r\nbelow. In this programme, you need to store the content of the entire\r\narray in a file to be able to reuse it later. Write a C function to\r\nwrite the array composed of `struct point` into a file. The file may\r\nalready exist or not. After the execution of the function, the file\r\nshould only contain the array. If the file has to be created, the user\r\nwho created it must have the permission to read it.\r\n\r\n``` c\r\ntypedef struct point {\r\n int x;\r\n int y;\r\n int z;\r\n} point_t;\r\n```\r\n\r\nUse only `open(2)`, `write(2)` and `close(2)`. You can only call\r\n`write(2)` once.\r\n\r\nHint : read carefully the man page of `open(2)` to manage all the cases\r\nmentioned above. Be sure to open the file with the appropriate rights.\r\n",
+ "description": "
Estimated time: 25 minutes
\r\n
You are currently processing an array composed of struct point defined below. In this programme, you need to store the content of the entire array in a file to be able to reuse it later. Write a C function to write the array composed of struct point into a file. The file may already exist or not. After the execution of the function, the file should only contain the array. If the file has to be created, the user who created it must have the permission to read it.
\r\n
typedef struct point {\r\n int x;\r\n int y;\r\n int z;\r\n} point_t;
\r\n
Use only open(2), write(2) and close(2). You can only call write(2) once.
\r\n
Hint : read carefully the man page of open(2) to manage all the cases mentioned above. Be sure to open the file with the appropriate rights.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3841,7 +3841,7 @@
},
{
"title": "Reading integers in a binary file",
- "description": "*Estimated time: 25 minutes*\r\n\r\nGiven a binary file containing some (possibly none) positive integers\r\n(`int`) that were stored in the file by successive calls of\r\n`write(fd,&num,sizeof(int))` write code that computes the sum of all\r\nintegers that were stored in the file. The function returns the sum when\r\nthere are no errors. In case of errors, it returns.\r\n\r\n- If `open()` fails, return `-1`.\r\n- If `read()` fails, return `-2`.\r\n- If `close()` fails, return `-3`.\r\n\r\nYou can only use `open(2)`, `read(2)`, `write(2)` and `close(2)`.\r\n",
+ "description": "
Estimated time: 25 minutes
\r\n
Given a binary file containing some (possibly none) positive integers (int) that were stored in the file by successive calls of write(fd,&num,sizeof(int)) write code that computes the sum of all integers that were stored in the file. The function returns the sum when there are no errors. In case of errors, it returns.
\r\n
\r\n
If open() fails, return -1.
\r\n
If read() fails, return -2.
\r\n
If close() fails, return -3.
\r\n
\r\n
You can only use open(2), read(2), write(2) and close(2).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3911,7 +3911,7 @@
},
{
"title": "Get and set on array stored in binary file",
- "description": "*Estimated time: 30 minutes*\r\n\r\nGiven a file containing a large array of integers, you have to write a\r\nfunction to edit the element at a given index in the array and another\r\nfunction to retrieve a specific element from this array.\r\n\r\nSince the array is huge, you cannot load it completely in memory.\r\nConsequently, you have to naviguate directly through the array in the\r\nfile by using `lseek(2)`.\r\n\r\nYou may want to use `fstat(2)` to obtain informations about a given\r\nfile.\r\n\r\nUse only `open(2)`, `read(2)`, `write(2)`, `close(2)` and `lseek(2)`.\r\n",
+ "description": "
Estimated time: 30 minutes
\r\n
Given a file containing a large array of integers, you have to write a function to edit the element at a given index in the array and another function to retrieve a specific element from this array.
\r\n
Since the array is huge, you cannot load it completely in memory. Consequently, you have to naviguate directly through the array in the file by using lseek(2).
\r\n
You may want to use fstat(2) to obtain informations about a given file.
\r\n
Use only open(2), read(2), write(2), close(2) and lseek(2).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3973,7 +3973,7 @@
},
{
"title": "File copy",
- "description": "*Estimated time: 30 minutes*\r\n\r\nGiven a file containing arbitrary bytes, you must write a function that\r\ncopies the file. Obviously, your function cannot modify the content of\r\nthe original file. Beware that the copied file should have the same\r\npermissions as the original file.\r\n\r\nUse only `open(2)`, `read(2)`, `write(2)`, `stat(2)` and `close(2)`.\r\n\r\n*Hint: you may need either to go through the file or to get the total\r\nsize to copy all of it.*\r\n",
+ "description": "
Estimated time: 30 minutes
\r\n
Given a file containing arbitrary bytes, you must write a function that copies the file. Obviously, your function cannot modify the content of the original file. Beware that the copied file should have the same permissions as the original file.
\r\n
Use only open(2), read(2), write(2), stat(2) and close(2).
\r\n
Hint: you may need either to go through the file or to get the total size to copy all of it.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4101,7 +4101,7 @@
},
{
"title": "Search and replace",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : -\r\n (commandes) -\r\n (appels systèmes) -\r\n (fonctions des\r\nlibrairies)\r\n",
+ "description": "
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4155,7 +4155,7 @@
},
{
"title": "Bitwise operation: setting a bit",
- "description": "In this exercise, we will work with operations on bits. When we speak\r\nabout the position of a bit, index 0 corresponds to lowest order bit, 1\r\nto the second-lowest order bit, ...\r\n\r\nIn C source code, you can write a number in binary (base 2) by prefixing\r\nit via 0b., e.g. 0b11010 = 26.\r\n\r\nThis exercise will introduce some non-standard data types which\r\nguarantee that the variable has a fixed number of bits. Indeed, on some\r\nmachines, a *int* could use 2, 4 or 8 bytes. Hence, if we want to\r\nperform bitwise operations, we have to know first on how many bits we\r\nare working.\r\n\r\nFor this, C introduces a new class of variable types :\r\n\r\n- *int8\\_t* (signed integer of 8 bits)\r\n- *uint8\\_t* (unsigned integer of 8 bits)\r\n- *uint16\\_t* (unsigned integer of 16 bits)\r\n\r\nYou can mix *uint* or *int* with bit-lengths 8, 16, 32 and 64). These\r\ntypes are defined in <stdint.h>\r\n",
+ "description": "
In this exercise, we will work with operations on bits. When we speak about the position of a bit, index 0 corresponds to lowest order bit, 1 to the second-lowest order bit, ...
\r\n
In C source code, you can write a number in binary (base 2) by prefixing it via 0b., e.g. 0b11010 = 26.
\r\n
This exercise will introduce some non-standard data types which guarantee that the variable has a fixed number of bits. Indeed, on some machines, a int could use 2, 4 or 8 bytes. Hence, if we want to perform bitwise operations, we have to know first on how many bits we are working.
\r\n
For this, C introduces a new class of variable types :
\r\n
\r\n
int8_t (signed integer of 8 bits)
\r\n
uint8_t (unsigned integer of 8 bits)
\r\n
uint16_t (unsigned integer of 16 bits)
\r\n
\r\n
You can mix uint or int with bit-lengths 8, 16, 32 and 64). These types are defined in <stdint.h>
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4259,7 +4259,7 @@
},
{
"title": "Simple stack",
- "description": "You are asked to implement the `pop` and `push` functions of the\r\nfollowing\r\n[stack](https://en.wikipedia.org/wiki/Stack_(abstract_data_type))\r\ninterface :\r\n\r\n``` c\r\nstruct node {\r\n node *next;\r\n char *name;\r\n};\r\n```\r\n\r\n\r\n\r\n*Hints* :\r\n\r\n- `char *name` is also a pointer, memory must be allocated by using\r\n [malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\n to copy the string on the stack.\r\n- Other useful commands:\r\n [strncpy(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strncpy.3.html)\r\n and\r\n [strlen(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strlen.3.html).\r\n- Do not forget to free **all** the allocated space when popping one\r\n element.\r\n",
+ "description": "
You are asked to implement the pop and push functions of the following stack interface :
Do not forget to free all the allocated space when popping one element.
\r\n
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4318,7 +4318,7 @@
},
{
"title": "Sleepy malloc",
- "description": "The\r\n[malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\nfunction may fail, for instance if the OS has no free memory remaining.\r\nIn this case, it may be possible that some other processes may free some\r\nmemory after some time.\r\n\r\nIn our program, instead of reporting an error immediately if no free\r\nmemory is available, we will wait some time to see if the OS has freed\r\nmemory for us.\r\n",
+ "description": "
The malloc(3) function may fail, for instance if the OS has no free memory remaining. In this case, it may be possible that some other processes may free some memory after some time.
\r\n
In our program, instead of reporting an error immediately if no free memory is available, we will wait some time to see if the OS has freed memory for us.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4377,7 +4377,7 @@
},
{
"title": "Soumission du projet fractale",
- "description": "Cette tâche vous permet de soumettre votre projet. Elle va également\r\nvalider le format de votre archive, la présence des fichiers requis, la\r\nprésence des cibles requises dans votre Makefile et la bonne compilation\r\nde votre projet. Le format requis est décrit dans l'énoncé disponible\r\nsur Moodle.\r\n\r\nVotre archive doit respecter le format de nommage fractal\\_NUMGroupe\\_NOM1\\_NOM2.zip. **Un seul\r\ndes deux membres du groupe doit soumettre.**\r\n\r\nLa dernière soumission **valide** sera considérée pour l'évaluation. En\r\nl'absence de telle soumission (donc si votre soumission comporte une\r\nerreur), votre projet **ne sera pas considéré pour l'évaluation**.\r\n",
+ "description": "
Cette tâche vous permet de soumettre votre projet. Elle va également valider le format de votre archive, la présence des fichiers requis, la présence des cibles requises dans votre Makefile et la bonne compilation de votre projet. Le format requis est décrit dans l'énoncé disponible sur Moodle.
\r\n
Votre archive doit respecter le format de nommage fractal_NUMGroupe_NOM1_NOM2.zip. Un seul des deux membres du groupe doit soumettre.
\r\n
La dernière soumission valide sera considérée pour l'évaluation. En l'absence de telle soumission (donc si votre soumission comporte une erreur), votre projet ne sera pas considéré pour l'évaluation.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4422,7 +4422,7 @@
},
{
"title": "Global and local variables",
- "description": "In a C program, variables are stored in different regions in memory,\r\ndepending on where the variables have been initialized. Each memory\r\nregion has different properties about how the variables can be accessed,\r\nmodified, ... This exercise will show you how global variables and\r\nvariables on the stack are managed.\r\n\r\n``` c\r\nint result;\r\n\r\nvoid sum1(int a1, int b1) {\r\n a1 = a1 + b1;\r\n}\r\n\r\nvoid main(int argc, char **argv) {\r\n int a1 = 5, b1 = 6;\r\n\r\n sum1(a1, b1);\r\n printf(\"sum1: %d\\n\", a1);\r\n\r\n int a2 = 3, b2 = 7;\r\n sum2(a2, b2)\r\n printf(\"sum2: %d\\n\", result);\r\n\r\n int a3 = 1, b3 = 8;\r\n sum3(&a3, &b3);\r\n printf(\"sum3: %d\\n\", a3);\r\n}\r\n```\r\n",
+ "description": "
In a C program, variables are stored in different regions in memory, depending on where the variables have been initialized. Each memory region has different properties about how the variables can be accessed, modified, ... This exercise will show you how global variables and variables on the stack are managed.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4490,7 +4490,7 @@
},
{
"title": "Exponentially static counter - REVIEWED",
- "description": "A variable declared inside a function with the keyword *static* implies\r\nthat the value of this variable will be kept across the different calls\r\nto this function.\r\n\r\nFor example, the first call to your function should return `1`. The next\r\ncall `2`, then `4`, ..., `4096`, `1`, ...\r\n",
+ "description": "
A variable declared inside a function with the keyword static implies that the value of this variable will be kept across the different calls to this function.
\r\n
For example, the first call to your function should return 1. The next call 2, then 4, ..., 4096, 1, ...
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4544,7 +4544,7 @@
},
{
"title": "Improved strcpy",
- "description": "The classic function\r\n`char *strcpy(char *destination, const char *source);`\r\n[strcpy(3)](https://linux.die.net/man/3/strcpy) needs a destination\r\nbuffer where the source string is copied. We ask you to code a function\r\nwhich allocates a buffer itself, and then performs the copy.\r\n\r\nThe use of copy functions as `memcpy` is not allowed.\r\n\r\n*Hint* : use\r\n[malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\n",
+ "description": "
The classic function char *strcpy(char *destination, const char *source);strcpy(3) needs a destination buffer where the source string is copied. We ask you to code a function which allocates a buffer itself, and then performs the copy.
\r\n
The use of copy functions as memcpy is not allowed.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4602,7 +4602,7 @@
},
{
"title": "Manipulation de chaines de caractères",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
Attention: veuillez utiliser la version HTML du syllabus
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4661,7 +4661,7 @@
},
{
"title": "Echange de valeurs de fractions",
- "description": "Soit la définition de la structure représentant des fractions entières\r\nsuivante:\r\n\r\n``` c\r\nstruct fract_t {\r\n int num;\r\n int denum;\r\n};\r\n```\r\n\r\nOn veut pouvoir swapper (échanger) les valeurs de deux fractions en\r\nutilisant la fonction `void swap(struct fract_t *a, struct fract_t *b)`.\r\nEcrivez le code de cette fonction.\r\n",
+ "description": "
Soit la définition de la structure représentant des fractions entières suivante:
\r\n
struct fract_t {\r\n int num;\r\n int denum;\r\n};
\r\n
On veut pouvoir swapper (échanger) les valeurs de deux fractions en utilisant la fonction void swap(struct fract_t *a, struct fract_t *b). Ecrivez le code de cette fonction.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4778,7 +4778,7 @@
},
{
"title": "Through the array",
- "description": "In C, an array is a set of variables sharing the same data type :\r\n`int array[3] = {42, 1337, 0};`.\r\n\r\nAn item of an array can be retrieved through its index. For example\r\n`array[1]` gives the second element of the array (here `1337`).\r\n",
+ "description": "
In C, an array is a set of variables sharing the same data type : int array[3] = {42, 1337, 0};.
\r\n
An item of an array can be retrieved through its index. For example array[1] gives the second element of the array (here 1337).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4832,7 +4832,7 @@
},
{
"title": "Trier une liste chainée",
- "description": "Le but de cet exercice est de trier une liste chaînée. Pour ce faire, on\r\nvous laisse le choix de l'algorithme que vous souhaitez implémenter. La\r\nseule contrainte est que la liste se décrit comme suit :\r\n\r\n``` c\r\nstruct list {\r\n struct node* head;\r\n}\r\nstruct node {\r\n int elem;\r\n struct node* next;\r\n}\r\n```\r\n",
+ "description": "
Le but de cet exercice est de trier une liste chaînée. Pour ce faire, on vous laisse le choix de l'algorithme que vous souhaitez implémenter. La seule contrainte est que la liste se décrit comme suit :
\r\n
struct list {\r\n struct node* head;\r\n}\r\nstruct node {\r\n int elem;\r\n struct node* next;\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4940,7 +4940,7 @@
},
{
"title": "Les types (1/2)",
- "description": "Le type de la plupart des variables en C est facile à déterminer.\r\nNéanmoins, le C contient aussi des types qui diffèrent de façons parfois\r\nsubtiles.\r\n",
+ "description": "
Le type de la plupart des variables en C est facile à déterminer. Néanmoins, le C contient aussi des types qui diffèrent de façons parfois subtiles.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -4994,7 +4994,7 @@
},
{
"title": "Les types (2/2)",
- "description": "Le type de la plupart des variables en C est facile à déterminer.\r\nNéanmoins, le C contient aussi des types qui diffèrent de façons parfois\r\nsubtiles.\r\n",
+ "description": "
Le type de la plupart des variables en C est facile à déterminer. Néanmoins, le C contient aussi des types qui diffèrent de façons parfois subtiles.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -5048,7 +5048,7 @@
},
{
"title": "Stockage d'un vecteur de réels dans un fichier",
- "description": "Le syllabus est accessible depuis l'URL\r\n\r\n\r\nLes pages de manuel sont accessibles depuis les URLs suivants : \r\n- (commandes)\r\n- (appels systèmes)\r\n- (fonctions des\r\n librairies)\r\n\r\n**Attention:** veuillez utiliser la version **HTML** du syllabus\r\n",
+ "description": "
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -128,7 +128,7 @@
},
{
"title": "Abstract Class",
- "description": "In this task, you have to implement the following code represented by\r\nthis UML diagram :\r\n\r\n\r\n\r\n\r\n\r\nBefore jumping to the code, a few things to keep in mind : \r\n- Shape and all its methods are abstract (since instantiating a Shape\r\n class doesn't make sense )\r\n- Don't forget every needed modifier, keywords, etc (abstract, public,\r\n ...)\r\n- No need of instance variables in your code as we pass you the needed\r\n parameter to apply your computation\r\n- Use Math.PI in your Circle implementation\r\n- Advanced feedback are available only if your code has complied\r\n",
+ "description": "
In this task, you have to implement the following code represented by this UML diagram :
\r\n\r\n\r\n\r\n
\r\n
Before jumping to the code, a few things to keep in mind :
\r\n
\r\n
Shape and all its methods are abstract (since instantiating a Shape class doesn't make sense )
\r\n
Don't forget every needed modifier, keywords, etc (abstract, public, ...) as your classes are stored inside another package that the one for the testing
\r\n
No need of instance variables in your code as we pass you the needed parameter to apply your computation
\r\n
Use Math.PI in your Circle implementation
\r\n
Advanced feedback are available only if your code has complied
\r\n
\r\n
\r\n
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -171,7 +171,7 @@
"text": "java"
},
{
- "text": "Module 4",
+ "text": "Module 3",
"category": 2
}
],
@@ -241,7 +241,7 @@
},
{
"title": "Arrays 2D and Matrix",
- "description": "In order to understand the differences between a matrix and a\r\nmultidimensional array, you have to implement the functions of the\r\n[MyBuilder](https://inginious.info.ucl.ac.be/course/LEPL1402/Array2D/MyBuilder.java) class that\r\nimplements the\r\n[Array2DBuilderInterface](https://inginious.info.ucl.ac.be/course/LEPL1402/Array2D/Array2DBuilderInterface.java):\r\n\r\n``` java\r\npackage src;\r\n\r\npublic interface Array2DBuilderInterface {\r\n// from a String of int, build and return a array of 2D\r\n// integers are separated by spaces ; lines by the \\n character\r\n// As array 2d aren't always regular matrix, you may build a Irregular matrix with the given input\r\n// Example :\r\n// String s = \"1 2 3 \\n 4 5 \\n 42 \\n\";\r\n// Gives :\r\n// int[][] array2d = { {1, 2, 3}, {4, 5}, {42} };\r\n// hint: there is a method in java that removes space at the start and end of a string\r\npublic int[][] buildFrom(String s);\r\n\r\n// Compute the sum of all integers in the 2d array (not necessarily a regular matrix )\r\npublic int sum(int[][] array);\r\n\r\n// return the transpose of the matrix (the given parameter is a regular matrix)\r\npublic int[][] transpose(int[][] matrix);\r\n\r\n// return the product of : matrix1 X matrix2\r\n// (row1 X column1) X (row2 X column2) (row1 and column2 not necessarily the same but regular matrices)\r\npublic int[][] product(int[][] matrix1, int[][] matrix2);\r\n}\r\n```\r\n\r\nYour job:\r\n\r\n``` java\r\npublic class MyBuilder implements Array2DBuilderInterface {\r\n public int[][] buildFrom(String s){\r\n //TODO\r\n }\r\n public int sum(int[][] array){\r\n //TODO\r\n }\r\n public int[][] transpose(int[][] matrix){\r\n //TODO\r\n }\r\n public int[][] product(int[][] matrix1, int[][] matrix2){\r\n //TODO\r\n }\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Array2D/LEPL1402_Array2D.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
In order to understand the differences between a matrix and a multidimensional array, you have to implement the functions of the MyBuilder class that implements the Array2DBuilderInterface:
\r\n
package src;\r\n\r\npublic interface Array2DBuilderInterface {\r\n// from a String of int, build and return a array of 2D\r\n// integers are separated by spaces ; lines by the \\n character\r\n// As array 2d aren't always regular matrix, you may build a Irregular matrix with the given input\r\n// Example :\r\n// String s = "1 2 3 \\n 4 5 \\n 42 \\n";\r\n// Gives :\r\n// int[][] array2d = { {1, 2, 3}, {4, 5}, {42} };\r\n// hint: there is a method in java that removes space at the start and end of a string\r\npublic int[][] buildFrom(String s);\r\n\r\n// Compute the sum of all integers in the 2d array (not necessarily a regular matrix )\r\npublic int sum(int[][] array);\r\n\r\n// return the transpose of the matrix (the given parameter is a regular matrix)\r\npublic int[][] transpose(int[][] matrix);\r\n\r\n// return the product of : matrix1 X matrix2\r\n// (row1 X column1) X (row2 X column2) (row1 and column2 not necessarily the same but regular matrices)\r\npublic int[][] product(int[][] matrix1, int[][] matrix2);\r\n}
\r\n
Your job:
\r\n
public class MyBuilder implements Array2DBuilderInterface {\r\n public int[][] buildFrom(String s){\r\n //TODO\r\n }\r\n public int sum(int[][] array){\r\n //TODO\r\n }\r\n public int[][] transpose(int[][] matrix){\r\n //TODO\r\n }\r\n public int[][] product(int[][] matrix1, int[][] matrix2){\r\n //TODO\r\n }\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -300,7 +300,7 @@
},
{
"title": "ASCII Decoder",
- "description": "For this exercise we want you to make a method able to decode a set of\r\nASCII (decimal) codes into a String. Please, read carefully the\r\nsignature and the comments above the method's signature below :\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ASCIIDecoder/LEPL1402_ASCIIDecoder.zip) that\r\ncontains few tests to help you.\r\n\r\n``` java\r\n/*\r\n* Forbidden characters are passed as an array of int.\r\n* Each element of this array correspond to the decimal ASCII code\r\n* of a forbidden character OR null if there's no forbidden character\r\n* If you encounter one of these forbidden character\r\n* you must ignore it when you translate your sentence.\r\n*\r\n* the 2D array \"sentences\" contain a set of decimal ASCII code we want you\r\n* to translate. Each sub-element of this array is a different sentence.\r\n* Ex : if we pass this array : { {\"42\", \"72\", \"88\"}, {\"98\", \"99\", \"111\", \"47\", \"55\"} }\r\n* to your decode method, you should return : { \"*HX\", \"bco/7\" }\r\n*\r\n* You should NEVER return null or an array containing null\r\n*/\r\npublic static String [] decode(int[] forbidden, String[][] sentences){\r\n // YOUR CODE HERE\r\n}\r\n```\r\n\r\nWe also highly suggest you to have a look at the\r\n[StringBuilder](https://docs.oracle.com/javase/8/docs/api/java/lang/StringBuilder.html)\r\nand\r\n[ArrayList](https://docs.oracle.com/javase/8/docs/api/java/util/ArrayList.html)\r\nAPIs. We strongly encourage you to use them for this exercise.\r\n",
+ "description": "
For this exercise we want you to make a method able to decode a set of ASCII (decimal) codes into a String. Please, read carefully the signature and the comments above the method's signature below :
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
/*\r\n* Forbidden characters are passed as an array of int.\r\n* Each element of this array correspond to the decimal ASCII code\r\n* of a forbidden character OR null if there's no forbidden character\r\n* If you encounter one of these forbidden character\r\n* you must ignore it when you translate your sentence.\r\n*\r\n* the 2D array "sentences" contain a set of decimal ASCII code we want you\r\n* to translate. Each sub-element of this array is a different sentence.\r\n* Ex : if we pass this array : { {"42", "72", "88"}, {"98", "99", "111", "47", "55"} }\r\n* to your decode method, you should return : { "*HX", "bco/7" }\r\n*\r\n* You should NEVER return null or an array containing null\r\n*/\r\npublic static String [] decode(int[] forbidden, String[][] sentences){\r\n // YOUR CODE HERE\r\n}
\r\n
We also highly suggest you to have a look at the StringBuilder and ArrayList APIs. We strongly encourage you to use them for this exercise.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -354,7 +354,7 @@
},
{
"title": "BlackBox Testing - Binary Search",
- "description": "In this task, you will need to provide a JUnit4 TestSuite for the\r\n**static method** `binarySearch` located in the **class** `Exercise` :\r\n\r\n``` java\r\n/*\r\n * This method returns:\r\n * index of elem if it is between the \"low\" and \"high\" indexes.\r\n * -1 if elem is not the there\r\n * -2 if the parameters do not respect the preconditions.\r\n *\r\n * @pre low >= 0, high <= |arr|, low <= high, sorted(arr[low...high]) == true\r\n * @post returns :\r\n * index in which the searched element is located,\r\n * -1 if it is not present.\r\n * -2 if it does not respect @pre\r\n */\r\npublic static int binarySearch(int [] arr, int low, int high, int elem) {\r\n ...\r\n}\r\n```\r\n\r\nBased on the specifications provided, create test cases for different\r\ninput and possible outputs. We strongly suggest you to read the\r\n[Junit4](https://junit.org/junit4/javadoc/4.12/org/junit/Assert.html)\r\nasserts documentation. Here is a signature to start your test suite:\r\n\r\n``` java\r\nimport org.junit.Test;\r\nimport static org.junit.Assert.*;\r\n\r\npublic class TestSuite{\r\n\r\n @Test\r\n public void test(){\r\n Exercise.binarySearch(...)\r\n }\r\n\r\n // Add more tests here.\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task, you will need to provide a JUnit4 TestSuite for the static methodbinarySearch located in the classExercise :
\r\n
/*\r\n * This method returns:\r\n * index of elem if it is between the "low" and "high" indexes.\r\n * -1 if elem is not the there\r\n * -2 if the parameters do not respect the preconditions.\r\n *\r\n * @pre low >= 0, high < |arr|, low <= high\r\n * @post returns :\r\n * index in which the searched element is located,\r\n * -1 if it is not present.\r\n * -2 if it does not respect @pre\r\n */\r\npublic static int binarySearch(int [] arr, int low, int high, int elem) {\r\n ...\r\n}
\r\n
Based on the specifications provided, create test cases for different input and possible outputs. We strongly suggest you to read the Junit4 asserts documentation. Here is a signature to start your test suite:
\r\n
import org.junit.Test;\r\nimport static org.junit.Assert.*;\r\n\r\npublic class TestSuite{\r\n\r\n @Test\r\n public void test(){\r\n Exercise.binarySearch(...)\r\n }\r\n\r\n // Add more tests here.\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -413,7 +413,7 @@
},
{
"title": "Bounded Buffer",
- "description": "A bounded buffer is a way for multiple producers and consumers to\r\nsynchronised. Indeed multiple producers are going to fill the buffer\r\nwhile consumers are going to clear out this buffer.\r\n\r\nYou have to implement the class\r\n[BoundedBuffer](https://inginious.info.ucl.ac.be/course/LEPL1402/BoundedBuffer/BoundedBuffer.java). In a\r\nbounded buffer, the element window grows to the right, shrinks to the\r\nleft and slides t the right on the buffer. Here is a little example\r\nabout the fonctioning of a bounded buffer :\r\n\r\n\r\n\r\nBefore submitting don't hesitate to create a producer and a consumer and\r\nto test your code.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/BoundedBuffer/LEPL1402_BoundedBuffer.zip):\r\n",
+ "description": "
A bounded buffer is a way for multiple producers and consumers to synchronised. Indeed multiple producers are going to fill the buffer while consumers are going to clear out this buffer.
\r\n
You have to implement the class BoundedBuffer. In a bounded buffer, the element window grows to the right, shrinks to the left and slides t the right on the buffer. Here is a little example about the fonctioning of a bounded buffer :
\r\n
\r\n
Before submitting don't hesitate to create a producer and a consumer and to test your code.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -472,7 +472,7 @@
},
{
"title": "Bubble Sort Invariant (MCQ)",
- "description": "In this exercise, the questions will be about the bubble sort algorithm,\r\nits complexities and invariant.\r\n\r\nHere its implementation in java:\r\n\r\n``` java\r\npublic static void bubbleSort(Comparable[] array){\r\n int n = array.length;\r\n Comparable temp = 0;\r\n for(int i=0; i < n; i++){\r\n for(int j=1; j < (n-i); j++){\r\n if(array[j-1].compareTo(array[j])>0){\r\n //swap elements\r\n temp = array[j-1];\r\n array[j-1] = array[j];\r\n array[j] = temp;\r\n }\r\n }\r\n }\r\n}\r\n```\r\n",
+ "description": "
In this exercise, the questions will be about the bubble sort algorithm, its complexities and invariant.
\r\n
Here its implementation in java:
\r\n
public static void bubbleSort(Comparable[] array){\r\n int n = array.length;\r\n Comparable temp = 0;\r\n for(int i=0; i < n; i++){\r\n for(int j=1; j < (n-i); j++){\r\n if(array[j-1].compareTo(array[j])>0){\r\n //swap elements\r\n temp = array[j-1];\r\n array[j-1] = array[j];\r\n array[j] = temp;\r\n }\r\n }\r\n }\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -580,7 +580,7 @@
},
{
"title": "Circular Linked list",
- "description": "In this task, you have to implement a Circular linked list : a list\r\nwhere the last element points to the first element. In this exercise,\r\nthe list must maintain a reference to the last of its elements. Each\r\ntime you want to add an element, you must append it at the end of the\r\nlist. Removing an element is a bit different: you need to specify an\r\nindex to choose which element of the list you want to remove\r\n(`remove(0)` for the first ... `remove(size()-1)` for the last). **Pay\r\nattention**: your `remove` method must throw an\r\n`IndexOutOfBoundsException` if the index parameter is smaller than `0`\r\nor greater than `size()-1`\r\n\r\n\r\n\r\n\r\n\r\nYou also need to implement the `ListIterator` class.\r\n[Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)\r\nis an interface you have to implement in order to make the class\r\nimplementing it able to enumerate/browse/iterate over an object : here,\r\nwe want you to implement a FIFO order iterator over your\r\n`CircularLinkedList`. **Pay attention**:\r\n\r\n> - Your iterator don't have to implement the `remove` method from\r\n> [Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html).\r\n> - Your iterator must throw a `ConcurrentModificationException` when\r\n> you want to get the next element but some other element has been\r\n> added to the list meanwhile.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/CircularLL/LEPL1402_CircularLL.zip):\r\n\r\nHere is the class (downloadable\r\n[here](https://inginious.info.ucl.ac.be/course/LEPL1402/CircularLL/CircularLinkedList.java)) where we\r\nwill insert your code :\r\n\r\n``` java\r\nimport java.util.ConcurrentModificationException;\r\nimport java.util.Iterator;\r\n\r\n\r\npublic class CircularLinkedList implements Iterable {\r\n\r\n private int n; // size of the list\r\n private Node last; // trailer of the list\r\n\r\n // helper linked list class\r\n private class Node {\r\n\r\n private Item item;\r\n private Node next;\r\n\r\n private Node(Item item){\r\n this.item = item;\r\n this.next = null;\r\n }\r\n\r\n }\r\n\r\n public CircularLinkedList() {\r\n last = null;\r\n n = 0;\r\n }\r\n\r\n public boolean isEmpty() {\r\n return n == 0;\r\n }\r\n\r\n public int size() {\r\n return n;\r\n }\r\n\r\n public Node getLast(){\r\n return last;\r\n }\r\n\r\n public Item getItem(Node n){\r\n return n.item;\r\n }\r\n\r\n\r\n\r\n /**\r\n * Append an item at the end of the list\r\n * @param item the item to append\r\n */\r\n public void enqueue(Item item) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n /**\r\n * Removes the element at the specified position in this list.\r\n * Shifts any subsequent elements to the left (subtracts one from their indices).\r\n * Returns the element that was removed from the list.\r\n */\r\n public Item remove(int index) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /**\r\n * Returns an iterator that iterates through the items in FIFO order.\r\n * @return an iterator that iterates through the items in FIFO order.\r\n */\r\n public Iterator iterator() {\r\n return new ListIterator();\r\n }\r\n\r\n /**\r\n * Implementation of an iterator that iterates through the items in FIFO order.\r\n *\r\n */\r\n private class ListIterator implements Iterator {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task, you have to implement a Circular linked list : a list where the last element points to the first element. In this exercise, the list must maintain a reference to the last of its elements. Each time you want to add an element, you must append it at the end of the list. Removing an element is a bit different: you need to specify an index to choose which element of the list you want to remove (remove(0) for the first ... remove(size()-1) for the last). Pay attention: your remove method must throw an IndexOutOfBoundsException if the index parameter is smaller than 0 or greater than size()-1
\r\n\r\n\r\n\r\n
You also need to implement the ListIterator class. Iterator is an interface you have to implement in order to make the class implementing it able to enumerate/browse/iterate over an object : here, we want you to implement a FIFO order iterator over your CircularLinkedList. Pay attention:
\r\n
\r\n
\r\n
Your iterator don't have to implement the remove method from Iterator.
\r\n
Your iterator must throw a ConcurrentModificationException when you want to get the next element but some other element has been added to the list meanwhile.
Here is the class (downloadable here) where we will insert your code :
\r\n
import java.util.ConcurrentModificationException;\r\nimport java.util.Iterator;\r\n\r\n\r\npublic class CircularLinkedList<Item> implements Iterable<Item> {\r\n\r\n private int n; // size of the list\r\n private Node last; // trailer of the list\r\n\r\n // helper linked list class\r\n private class Node {\r\n\r\n private Item item;\r\n private Node next;\r\n\r\n private Node(Item item){\r\n this.item = item;\r\n this.next = null;\r\n }\r\n\r\n }\r\n\r\n public CircularLinkedList() {\r\n last = null;\r\n n = 0;\r\n }\r\n\r\n public boolean isEmpty() {\r\n return n == 0;\r\n }\r\n\r\n public int size() {\r\n return n;\r\n }\r\n\r\n public Node getLast(){\r\n return last;\r\n }\r\n\r\n public Item getItem(Node n){\r\n return n.item;\r\n }\r\n\r\n\r\n\r\n /**\r\n * Append an item at the end of the list\r\n * @param item the item to append\r\n */\r\n public void enqueue(Item item) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n /**\r\n * Removes the element at the specified position in this list.\r\n * Shifts any subsequent elements to the left (subtracts one from their indices).\r\n * Returns the element that was removed from the list.\r\n */\r\n public Item remove(int index) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /**\r\n * Returns an iterator that iterates through the items in FIFO order.\r\n * @return an iterator that iterates through the items in FIFO order.\r\n */\r\n public Iterator<Item> iterator() {\r\n return new ListIterator();\r\n }\r\n\r\n /**\r\n * Implementation of an iterator that iterates through the items in FIFO order.\r\n *\r\n */\r\n private class ListIterator implements Iterator<Item> {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -693,7 +693,7 @@
},
{
"title": "Quick Sort - Implem exercise",
- "description": "In order to discover the importance of pre/post conditions and\r\ninvariants in your programs, we will take the example of QuickSort.\r\n\r\nQuicksort is a divide-and-conquer method for sorting. It works by\r\npartitioning an array into two parts, then sorting the parts\r\nindependently. It takes the first element of the Array, then it\r\ndetermines its position in the array by iterating through it. If an\r\nelement is lower, it moves the element to its left and increment its own\r\nposition. Then it recursivly do the same operation for each sub array\r\n(left and right of the pivot).\r\n\r\n\r\n\r\n\r\n\r\nThe crux of the method is the partitioning process , which can be\r\nsummarized as follows :\r\n\r\n\r\n\r\n\r\n\r\nEven with this simple algorithm, mistakes can occur and that is why we\r\nask you to complete the implementation contained in this\r\n[file](https://inginious.info.ucl.ac.be/course/LEPL1402/CodeAccuracy2/QuickSort.java) , without\r\nforgetting to add assert statements in each method (as they will be\r\ntested separately in INGINIOUS).\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/CodeAccuracy2/LEPL1402_CodeAccuracy2.zip).\r\n",
+ "description": "
In order to discover the importance of pre/post conditions and invariants in your programs, we will take the example of QuickSort.
\r\n
Quicksort is a divide-and-conquer method for sorting. It works by partitioning an array into two parts, then sorting the parts independently. It takes the first element of the Array, then it determines its position in the array by iterating through it. If an element is lower, it moves the element to its left and increment its own position. Then it recursivly do the same operation for each sub array (left and right of the pivot).
\r\n\r\n\r\n\r\n
The crux of the method is the partitioning process , which can be summarized as follows :
\r\n\r\n\r\n\r\n
Even with this simple algorithm, mistakes can occur and that is why we ask you to complete the implementation contained in this file , without forgetting to add assert statements in each method (as they will be tested separately in INGINIOUS).
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -806,7 +806,7 @@
},
{
"title": "Comparator and Collections",
- "description": "In this task, the challenge is to sort a custom class **Person**\r\ndescribed as :\r\n\r\n``` java\r\npublic class Person {\r\n\r\n public String name;\r\n public int age;\r\n\r\n public Person(String name, int age) {\r\n this.name = name;\r\n this.age = age;\r\n }\r\n\r\n @Override\r\n public String toString() {\r\n return name + \" \" + age;\r\n }\r\n}\r\n```\r\n\r\nYour task is to implement the function\r\n`public static void sortPerson(ArrayList persons)` that should\r\nsort an ArrayList of Persons as follows :\r\n\r\n- sort in the lexicographical order of their name\r\n- If two persons have the same name, they should be classified\r\n according to their age (ascending order).\r\n\r\nIn order to succeed this task (whose solution is contained on 8 lines),\r\nwe invite you to discover the following JavaDoc resource :\r\n[Collections](https://docs.oracle.com/javase/8/docs/api/java/util/Collections.html)\r\n(method sort)\r\n\r\nGiven this example :\r\n\r\n``` java\r\npublic class Main\r\n\r\n public static void main(String[] args) {\r\n ArrayList persons = new ArrayList<>();\r\n persons.add(new Person(\"Guillaume\",20));\r\n persons.add(new Person(\"John\",50));\r\n persons.add(new Person(\"Guillaume\",10));\r\n persons.add(new Person(\"John\",10));\r\n persons.add(new Person(\"Luc\",5));\r\n\r\n sortPerson(persons);\r\n System.out.println(persons);\r\n\r\n }\r\n}\r\n```\r\n\r\nYou should get this on the output :\r\n\r\n``` java\r\n[Guillaume 10, Guillaume 20, John 10, John 20, Luc 5]\r\n```\r\n",
+ "description": "
In this task, the challenge is to sort a custom class Person described as :
\r\n
public class Person {\r\n\r\n public String name;\r\n public int age;\r\n\r\n public Person(String name, int age) {\r\n this.name = name;\r\n this.age = age;\r\n }\r\n\r\n @Override\r\n public String toString() {\r\n return name + " " + age;\r\n }\r\n}
\r\n
Your task is to implement the function public static void sortPerson(ArrayList<Person> persons) that should sort an ArrayList of Persons as follows :
\r\n
\r\n
sort in the lexicographical order of their name
\r\n
If two persons have the same name, they should be classified according to their age (ascending order).
\r\n
\r\n
In order to succeed this task (whose solution is contained on 8 lines), we invite you to discover the following JavaDoc resource : Collections (method sort)
\r\n
Given this example :
\r\n
public class Main\r\n\r\n public static void main(String[] args) {\r\n ArrayList<Person> persons = new ArrayList<>();\r\n persons.add(new Person("Guillaume",20));\r\n persons.add(new Person("John",50));\r\n persons.add(new Person("Guillaume",10));\r\n persons.add(new Person("John",10));\r\n persons.add(new Person("Luc",5));\r\n\r\n sortPerson(persons);\r\n System.out.println(persons);\r\n\r\n }\r\n}
\r\n
You should get this on the output :
\r\n
[Guillaume 10, Guillaume 20, John 10, John 20, Luc 5]
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -860,7 +860,7 @@
},
{
"title": "Comparator vs Comparable",
- "description": "In this exercise, you have to answer questions about\r\n[Comparator](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html)\r\nand\r\n[Comparable](https://docs.oracle.com/javase/8/docs/api/java/lang/Comparable.html).\r\n\r\nWe are going to work on the\r\n[Plant](https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable/Plant.java),\r\n[Tree](https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable/Tree.java),\r\n[Flower](https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable/Flower.java) and\r\n[Sorter](https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable/Sorter.java) classes.\r\nRead and understand the code in this classes before doing this is\r\nexercise!\r\n\r\nAll the information on how the different method should work are given in\r\ncomments in each class.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable/LEPL1402_ComparatorvsComparable.zip).\r\n",
+ "description": "
We are going to work on the Plant, Tree, Flower and Sorter classes. Read and understand the code in this classes before doing this is exercise!
\r\n
All the information on how the different method should work are given in comments in each class.
\r\n
\r\n
\r\n
Warning
\r\n
\r\n
In the code, when we write \"in that order\", we mean that you must first sort in function of the first criterion, and in case of equality, sort in function of the second, and so on.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -903,8 +903,12 @@
"text": "java"
},
{
- "text": "Module 5",
+ "text": "Module 3",
"category": 2
+ },
+ {
+ "category": 2,
+ "text": "Module3"
}
],
"url": "https://inginious.info.ucl.ac.be/course/LEPL1402/ComparatorvsComparable",
@@ -919,7 +923,7 @@
},
{
"title": "Array Search",
- "description": "In this task, you have to implement a method `search` that looks for an\r\nelement in an ascending sorted array. Your method must return the\r\n**index** of the element in the array or **-1** if you can't find the\r\nelement in the array.\r\n\r\nWe'll test the complexity of your code so try to find the best possible\r\nalgorithm.\r\n\r\n``` java\r\npublic class Search {\r\n\r\n /**\r\n * @param tab is an ordered array of int.\r\n * @return index of elem or -1\r\n */\r\n public static int search(int[] tab, int elem){\r\n //TODO YOUR CODE HERE\r\n }\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ComplexityArraySearch/LEPL1402_ComplexityArraySearch.zip)\r\nthat contains few tests to help you.\r\n",
+ "description": "
In this task, you have to implement a method search that looks for an element in an ascending sorted array. Your method must return the index of the element in the array or -1 if you can't find the element in the array.
\r\n
We'll test the complexity of your code so try to find the best possible algorithm.
\r\n
public class Search {\r\n\r\n /**\r\n * @param tab is an ordered array of int.\r\n * @return index of elem or -1\r\n */\r\n public static int search(int[] tab, int elem){\r\n //TODO YOUR CODE HERE\r\n }\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1032,7 +1036,7 @@
},
{
"title": "Time Complexity MCQ (trees, tsp, sort, lists)",
- "description": "The three first questions will be time complexity questions about trees,\r\nthe trees we are talking about is a complete ordered binary tree. Like\r\nthe example you see here under:\r\n\r\n\r\n\r\nThe rest of the questions are harder question about the time complexity\r\nof operations on list and arrays. Some questions will be about simple\r\nlinked list, other about double linked list and some about circular\r\nlinked list.\r\n",
+ "description": "
The three first questions will be time complexity questions about trees, the trees we are talking about is a complete ordered binary tree. Like the example you see here under:
\r\n
\r\n
The rest of the questions are harder question about the time complexity of operations on list and arrays. Some questions will be about simple linked list, other about double linked list and some about circular linked list.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1140,7 +1144,7 @@
},
{
"title": "Coverage Testing",
- "description": "In this task, you should provide a TestSuite for coverage check of the\r\nfollowing class :\r\n\r\n``` java\r\npublic class BigDecimal {\r\n /*\r\n * parse exponent\r\n */\r\n public static long parseExp(char[] in, int offset, int len){\r\n long exp = 0;\r\n offset++;\r\n char c = in[offset];\r\n len--;\r\n boolean negexp = (c == '-');\r\n // optional sign\r\n if (negexp || c == '+') {\r\n offset++;\r\n c = in[offset];\r\n len--;\r\n }\r\n if (len <= 0) // no exponent digits\r\n throw new NumberFormatException();\r\n // skip leading zeros in the exponent\r\n while (len > 10 && (c=='0' || (Character.digit(c, 10) == 0))) {\r\n offset++;\r\n c = in[offset];\r\n len--;\r\n }\r\n if (len > 10) // too many nonzero exponent digits\r\n throw new NumberFormatException();\r\n // c now holds first digit of exponent\r\n for (;; len--) {\r\n int v;\r\n if (c >= '0' && c <= '9') {\r\n v = c - '0';\r\n } else {\r\n v = Character.digit(c, 10);\r\n if (v < 0) // not a digit\r\n throw new NumberFormatException();\r\n }\r\n exp = exp * 10 + v;\r\n if (len == 1)\r\n break; // that was final character\r\n offset++;\r\n c = in[offset];\r\n }\r\n if (negexp) // apply sign\r\n exp = -exp;\r\n return exp;\r\n }\r\n}\r\n```\r\n\r\nIn order to succeed this task, you must cover all the different\r\nexecution cases. To grade your tests, we use the tool `Jacoco`, it\r\nchecks wether you navigate among the entire code that was given. First\r\nunderstand what this code does, then you should write tests that will\r\nnavigate through each condition, loop etc.\r\n\r\nTake a look at this\r\n[link](https://www.eclemma.org/jacoco/trunk/doc/counters.html) to\r\nunderstand the feedback you'll be given.\r\n",
+ "description": "
In this task, you should provide a TestSuite for coverage check of the following class :
\r\n
public class BigDecimal {\r\n /*\r\n * parse exponent\r\n */\r\n public static long parseExp(char[] in, int offset, int len){\r\n long exp = 0;\r\n offset++;\r\n char c = in[offset];\r\n len--;\r\n boolean negexp = (c == '-');\r\n // optional sign\r\n if (negexp || c == '+') {\r\n offset++;\r\n c = in[offset];\r\n len--;\r\n }\r\n if (len <= 0) // no exponent digits\r\n throw new NumberFormatException();\r\n // skip leading zeros in the exponent\r\n while (len > 10 && (c=='0' || (Character.digit(c, 10) == 0))) {\r\n offset++;\r\n c = in[offset];\r\n len--;\r\n }\r\n if (len > 10) // too many nonzero exponent digits\r\n throw new NumberFormatException();\r\n // c now holds first digit of exponent\r\n for (;; len--) {\r\n int v;\r\n if (c >= '0' && c <= '9') {\r\n v = c - '0';\r\n } else {\r\n v = Character.digit(c, 10);\r\n if (v < 0) // not a digit\r\n throw new NumberFormatException();\r\n }\r\n exp = exp * 10 + v;\r\n if (len == 1)\r\n break; // that was final character\r\n offset++;\r\n c = in[offset];\r\n }\r\n if (negexp) // apply sign\r\n exp = -exp;\r\n return exp;\r\n }\r\n}
\r\n
In order to succeed this task, you must cover all the different execution cases. To grade your tests, we use the tool Jacoco, it checks wether you navigate among the entire code that was given. First understand what this code does, then you should write tests that will navigate through each condition, loop etc.
\r\n
Take a look at this link to understand the feedback you'll be given.
\r\n
To start your test suite :
\r\n
import org.junit.Test;\r\nimport static org.junit.Assert.*;\r\n\r\npublic class TestSuite{\r\n\r\n @Test\r\n public void test(){\r\n // parameters for parseExp\r\n char[] in = new char[]{/*Some chars here*/};\r\n // also possible to use .toCharArray from String class for that :\r\n // char[] in = myString.toCharArray();\r\n int offset = /*Some value HERE*/;\r\n int len = /*Some value HERE*/;\r\n // run the program with the given situation\r\n BigDecimal.parseExp(in, offset, len);\r\n }\r\n\r\n // Add more tests here.\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1199,7 +1203,7 @@
},
{
"title": "Cyclic Barrier",
- "description": "A Cyclic barrier in concurrent programming is a synchronization\r\nconstruct that helps you synchronize threads every once in a while. The\r\nidea is simple, after a thread finished executing a certain amount of\r\noperation, it waits until the barrier thread recover the result to\r\nrestart. Note that the barrier recover this result when every thread is\r\nwaiting, it thus recover all the results and then the threads can\r\nrestart their computing before stopping at the next checkpoint.\r\n\r\nIn this exercise we ask you to compute the highest sum in a set of\r\narray. Imagine that you have a large set of 2D-arrays stored as one\r\n3D-array. We ask you to use a fixed amount of threads, and a small\r\nbuffer. Each thread is going to compute the sum of the values in a\r\n2D-array and store this sum in the shared buffer. Once every thread has\r\nfinished computing the sum of his array, the barrier recovers the\r\nmaximum. When you don't need to compute sums the threads stop and the\r\nbarrier returns the final result (the index of the maximal sum).\r\n\r\nWe give you the class\r\n[MaxFinder](https://inginious.info.ucl.ac.be/course/LEPL1402/CyclicBarrier/MaxFinder.java) that you must\r\ncomplete, read the code carefully before you start writing any line of\r\ncode.\r\n\r\nYou should also read the class\r\n[CyclicBarrier](https://docs.oracle.com/javase/8/docs/api/index.html?java/util/concurrent/CyclicBarrier.html)\r\nin the java api.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/CyclicBarrier/LEPL1402_CyclicBarrier.zip).\r\n",
+ "description": "
A Cyclic barrier in concurrent programming is a synchronization construct that helps you synchronize threads every once in a while. The idea is simple, after a thread finished executing a certain amount of operation, it waits until the barrier thread recover the result to restart. Note that the barrier recover this result when every thread is waiting, it thus recover all the results and then the threads can restart their computing before stopping at the next checkpoint.
\r\n
In this exercise we ask you to compute the highest sum in a set of array. Imagine that you have a large set of 2D-arrays stored as one 3D-array. We ask you to use a fixed amount of threads, and a small buffer. Each thread is going to compute the sum of the values in a 2D-array and store this sum in the shared buffer. Once every thread has finished computing the sum of his array, the barrier recovers the maximum. When you don't need to compute sums the threads stop and the barrier returns the final result (the index of the maximal sum).
\r\n
We give you the class MaxFinder that you must complete, read the code carefully before you start writing any line of code.
\r\n
You should also read the class CyclicBarrier in the java api.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1258,7 +1262,7 @@
},
{
"title": "Factory design pattern - Level generator",
- "description": "In this task, we will ask you to implement a labyrinth mini-game level\r\nbuilder using The factory design pattern. Each level consists in a set\r\nof [Wall](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/Wall.java),\r\n[Key](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/Key.java),\r\n[Floor](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/Floor.java),\r\n[Door](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/Door.java), all of them implementing the\r\n[LevelComponent](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/LevelComponent.java)\r\ninterface. Your objective is thus to implement the two following\r\nclasses:\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/LEPL1402_Factory.zip).\r\n\r\n``` java\r\npublic class ElementFactory extends Factory {\r\n\r\n // YOUR CODE HERE\r\n\r\n public static ElementFactory getInstance() {\r\n // YOUR SINGLETON HERE\r\n }\r\n\r\n}\r\n\r\n\r\npublic class Level extends AbstractLevel {\r\n\r\n public Level(String input){\r\n // YOUR CODE HERE\r\n }\r\n\r\n //Example of level building with this String : String s = \"#-K\\n-D-\\n#-K\"\r\n //Gives : LevelComponent[][] componentsObjects = {\r\n // {new Wall(), new Floor(), new Key()},\r\n // {new Floor(), new Door(), new Floor()},\r\n // {new Wall(), new Floor(), new Key()}}\r\n public LevelComponent getElement(char c){\r\n // YOUR CODE HERE\r\n }\r\n\r\n // YOUR CODE HERE\r\n}\r\n```\r\n\r\nNote that these two classes extends the abstract classes\r\n[Factory](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/Factory.java) and\r\n[AbstractLevel](https://inginious.info.ucl.ac.be/course/LEPL1402/Factory/AbstractLevel.java). Pay\r\nattention, we add a small constraint to this exercise: your\r\nElementFactory **must** be a singleton (i.e, it should not be possible\r\nto instantiate your factory with java's `new` keyword). For your `Level`\r\nclass, what we want you to do is, given a String, create a `Level`\r\nobject whose `components` is a 2D array where each cell represent a\r\n`LevelComponent`. Note that all sub-arrays in `components` will have the\r\nsame size as we will only ask you to create \"square\" labyrinths. If a\r\ncharacter does not correspond to one of the component, your code should\r\nthrow an IllegalArgumentException.\r\n",
+ "description": "
In this task, we will ask you to implement a labyrinth mini-game level builder using The factory design pattern. Each level consists in a set of Wall, Key, Floor, Door, all of them implementing the LevelComponent interface. Your objective is thus to implement the two following classes:
public class ElementFactory extends Factory {\r\n\r\n // YOUR CODE HERE\r\n\r\n public static ElementFactory getInstance() {\r\n // YOUR SINGLETON HERE\r\n }\r\n\r\n}\r\n\r\n\r\npublic class Level extends AbstractLevel {\r\n\r\n public Level(String input){\r\n // YOUR CODE HERE\r\n }\r\n\r\n /* Example of level building with this String : String s = "#-K\\n-D-\\n#-K\\n"\r\n * Gives : LevelComponent[][] componentsObjects = {\r\n * {new Wall(), new Floor(), new Key()},\r\n * {new Floor(), new Door(), new Floor()},\r\n * {new Wall(), new Floor(), new Key()}}\r\n */\r\n\r\n\r\n // YOUR CODE HERE\r\n}
\r\n
Note that these two classes extends the abstract classes Factory and AbstractLevel. Pay attention, we add a small constraint to this exercise: your ElementFactory must be a singleton (i.e, it should not be possible to instantiate your factory with java's new keyword). For your Level class, what we want you to do is, given a String, create a Level object whose components is a 2D array where each cell represent a LevelComponent and whose size is the total number of components in the level. Note that all sub-arrays in components will have the same size as we will only ask you to create \"square\" labyrinths. If a character does not correspond to one of the component, your code should throw an IllegalArgumentException.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1317,7 +1321,7 @@
},
{
"title": "Introduction to recursion in Java - Fibonacci",
- "description": "In this task, we will ask you to implement two different versions of the\r\n[Fibonacci](https://inginious.info.ucl.ac.be/course/LEPL1402/Fibonacci/Fibonacci.java) sequence number:\r\na recursive one and an iterative one. The objective of this exercise is\r\nto make you aware of what a call stack is and what problem could occur.\r\nWe strongly suggest you to test your code with various input : what will\r\nhappen if you test your recursive implementation with a very large\r\nindex. Why ? Will the same thing happen with your iterative\r\nimplementation ? Why ?\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Fibonacci/LEPL1402_Fibonacci.zip) that\r\ncontains few tests to help you.\r\n\r\n``` java\r\npublic class Fibonacci {\r\n\r\n /*\r\n * Returns the index-th element of the fibonnaci sequence, computed recursively\r\n */\r\n public static int fiboRecursive(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n /*\r\n * Returns the index-th element of the fibonnaci sequence, computed iteratively\r\n */\r\n public static int fiboIterative(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}\r\n```\r\n\r\nReminder : Fibonacci's sequence is computed as follows\r\n\r\n$$\\\\begin{aligned}\r\nf(n) =\\\\begin{cases}0 & n=0 \\\\\\\\1 & n = 1\\\\\\\\ f(n-1) + f(n-2) & n > 1\\\\end{cases}\r\n\\\\end{aligned}$$\r\n",
+ "description": "
In this task, we will ask you to implement two different versions of the Fibonacci sequence number: a recursive one and an iterative one. The objective of this exercise is to make you aware of what a call stack is and what problem could occur. We strongly suggest you to test your code with various input : what will happen if you test your recursive implementation with a very large index. Why ? Will the same thing happen with your iterative implementation ? Why ?
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
public class Fibonacci {\r\n\r\n /*\r\n * Returns the index-th element of the fibonnaci sequence, computed recursively\r\n */\r\n public static int fiboRecursive(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n /*\r\n * Returns the index-th element of the fibonnaci sequence, computed iteratively\r\n */\r\n public static int fiboIterative(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}
\r\n
Reminder : Fibonacci's sequence is computed as follows
\r\n
$$\\begin{aligned}\r\nf(n) =\\begin{cases}0 & n=0 \\\\1 & n = 1\\\\ f(n-1) + f(n-2) & n > 1\\end{cases}\r\n\\end{aligned}$$
Functional programming is an increasingly important programming paradigm. In this paradigm, data structures are immutable. You are asked to implement an immutable list called FList that can be used in functionnal programming.
\r\n
You should first make sure that you understood the code that is given to you and what is asked to you before trying any implementation.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
Here is the API of an FList and the FList class you have to implement:
\r\n
public abstract class FList<A> implements Iterable<A> {\r\n\r\n // creates an empty list\r\n public static <A> FList<A> nil();\r\n\r\n // prepend a to the list and return the new list\r\n public final FList<A> cons(final A a);\r\n\r\n public final boolean isNotEmpty();\r\n\r\n public final boolean isEmpty();\r\n\r\n public final int length();\r\n\r\n // return the head element of the list\r\n public abstract A head();\r\n\r\n // return the tail of the list\r\n public abstract FList<A> tail();\r\n\r\n // return a list on which each element has been applied function f\r\n public final <B> FList<B> map(Function<A,B> f);\r\n\r\n // return a list on which only the elements that satisfies predicate are kept\r\n public final FList<A> filter(Predicate<A> f);\r\n\r\n // return an iterator on the element of the list\r\n public Iterator<A> iterator();\r\n\r\n}
\r\n
Here is an example of how we could test your code:
\r\n
FList<Integer> list = FList.nil();\r\n\r\nfor (int i = 0; i < 10; i++) {\r\n list = list.cons(i);\r\n}\r\n\r\nlist = list.map(i -> i+1);\r\n// will print 1,2,...,11\r\nfor (Integer i: list) {\r\n System.out.println(i);\r\n}\r\n\r\nlist = list.filter(i -> i%2 == 0);\r\n// will print 2,4,6,...,10\r\nfor (Integer i: list) {\r\n System.out.println(i);\r\n}
\r\n
Since you know how your code should work, we strongly recommend you to test it on your computer before trying any submission. The iterator is the most critical part, if it doesn't work, most of the test will not work.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1435,7 +1439,7 @@
},
{
"title": "FList MergeSort",
- "description": "To complete this task you must implement a mergesort for FList using\r\nonly FList. Arrays, ArrayList, etc. are prohibited for this exercise.\r\n\r\nHere is the class [FList](https://inginious.info.ucl.ac.be/course/LEPL1402/FListMergeSort/FList.java)\r\nyou will be using. Try first to implement the FList by yourself in this\r\n[exercise](https://inginious.info.ucl.ac.be/course/LEPL1402/FList)\r\nbefore starting this one.\r\n\r\nAnd here is the method you must implement: note that you have to\r\nimplement merge recursivly and you are allowed to create other methods.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/FListMergeSort/LEPL1402_FListMergeSort.zip)\r\nthat contains few tests to help you.\r\n\r\n``` java\r\npublic class FListMerge {\r\n\r\n\r\n /*\r\n * This method receives an FList and returns the FList containing the same values but sorted with the smallest value to the highest one.\r\n *\r\n */\r\n public static FList mergeSort(FList fList){\r\n //TODO By Student\r\n }\r\n\r\n //TO Complete if needed\r\n}\r\n```\r\n",
+ "description": "
To complete this task you must implement a mergesort for FList using only FList. Arrays, ArrayList, etc. are prohibited for this exercise.
\r\n
Here is the class FList you will be using. Try first to implement the FList by yourself in this exercise before starting this one.
\r\n
And here is the method you must implement: note that you have to implement merge recursivly and you are allowed to create other methods.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
public class FListMerge {\r\n\r\n\r\n /*\r\n * This method receives an FList and returns the FList containing the same values but sorted with the smallest value to the highest one.\r\n *\r\n */\r\n public static FList<Integer> mergeSort(FList<Integer> fList){\r\n //TODO By Student\r\n }\r\n\r\n //TO Complete if needed\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1494,7 +1498,7 @@
},
{
"title": "Functional immutable tree",
- "description": "In this exercise you have to complete the class\r\n[FTree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java),\r\n[Node](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Node.java) and\r\n[Leaf](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Leaf.java).\r\n[Ftree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java) is an abstract class that\r\nrepresents a binary true, it is extended by Node and Leaf. A\r\n[Node](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Node.java) is a\r\n[FTree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java) with two children (left and\r\nright) and a value. A [Leaf](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Leaf.java) is\r\nterminal, so it has a value but no children.\r\n\r\nIn the [FTree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java) class you must *recursivly* implement: \r\n- depth : returns the depth of the tree (we assume that the tree is\r\n balanced)\r\n- map : receives a function as argument and apply it to all the values\r\n contained in the tree\r\n\r\nTo complete the [Node](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Node.java) class you must: \r\n- implement the constructor\r\n- extend [FTree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java)\r\n\r\nTo complete the [Leaf](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/Leaf.java) class you must : \r\n- implement the constructor\r\n- extend [FTree](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/FTree.java)\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/FTree/LEPL1402_FTree.zip) that contains few\r\ntests to help you.\r\n",
+ "description": "
In this exercise you have to complete the class FTree, Node and Leaf. Ftree is an abstract class that represents a binary true, it is extended by Node and Leaf. A Node is a FTree with two children (left and right) and a value. A Leaf is terminal, so it has a value but no children.
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1553,7 +1557,7 @@
},
{
"title": "Future",
- "description": "For this task you will learn use\r\n[Future](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/Future.html)\r\nand\r\n[ExecutorService](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ExecutorService.html)\r\nin order to load a web page with images asynchronously. Indeed html is\r\nlightweight compared to the images so we want the images to be\r\ndownloaded asynchronously while the html is displayed without the\r\nimages.\r\n\r\nIn this task we give you the\r\n[WebPage](https://inginious.info.ucl.ac.be/course/LEPL1402/Future/WebPage.java) class to complete and\r\nthree other class to use : [URL](https://inginious.info.ucl.ac.be/course/LEPL1402/Future/URL.java),\r\n[Image](https://inginious.info.ucl.ac.be/course/LEPL1402/Future/Image.java) and\r\n[HTML](https://inginious.info.ucl.ac.be/course/LEPL1402/Future/HTML.java).\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Future/LEPL1402_Future.zip) that contains few\r\ntests to help you.\r\n\r\n``` java\r\nimport java.util.ArrayList;\r\nimport java.util.List;\r\nimport java.util.concurrent.ExecutionException;\r\nimport java.util.concurrent.ExecutorService;\r\nimport java.util.concurrent.Executors;\r\nimport java.util.concurrent.Future;\r\n\r\npublic class WebPage {\r\n\r\n private ExecutorService executor;\r\n private HTML html;\r\n\r\n /*\r\n * Bound executor to a fixed thread pool size\r\n */\r\n public WebPage(int threadNumber, HTML html){\r\n //TODO\r\n }\r\n\r\n /*\r\n * submit the download of the image specified by the url\r\n * to be executed by thread pool\r\n */\r\n public Future loadImage(URL url){\r\n //TODO\r\n }\r\n\r\n /*\r\n * Download the image specified by the url\r\n */\r\n public Image downloadImageFromURL(URL url){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * Load all images of the page\r\n */\r\n public List> loadImages(List urls){\r\n //TODO\r\n }\r\n\r\n /*\r\n * Load the page while images are being downloaded\r\n */\r\n private void displayPageWithoutImage(){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * Display all images on the page\r\n */\r\n private void displayImages(List images){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * load the page\r\n */\r\n public void loadPage(){\r\n // First the image are downloaded asynchronously\r\n List> futures = loadImages(this.html.getUrls());\r\n // While the image are being downloaded, we display the page without them\r\n displayPageWithoutImage();\r\n // Then we need all images to display them\r\n List images = new ArrayList(futures.size());\r\n try{\r\n for(Future future : futures){\r\n // the \"get()\" function is waiting for the result of the future task (here download the images)\r\n images.add(future.get());\r\n }\r\n } catch(InterruptedException e){\r\n\r\n } catch (ExecutionException e){\r\n\r\n }\r\n // we can display now images on the page\r\n displayImages(images);\r\n // shut down the executor service now\r\n executor.shutdown();\r\n\r\n }\r\n\r\n}\r\n```\r\n",
+ "description": "
For this task you will learn use Future and ExecutorService in order to load a web page with images asynchronously. Indeed html is lightweight compared to the images so we want the images to be downloaded asynchronously while the html is displayed without the images.
\r\n
In this task we give you the WebPage class to complete and three other class to use : URL, Image and HTML.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
import java.util.ArrayList;\r\nimport java.util.List;\r\nimport java.util.concurrent.ExecutionException;\r\nimport java.util.concurrent.ExecutorService;\r\nimport java.util.concurrent.Executors;\r\nimport java.util.concurrent.Future;\r\n\r\npublic class WebPage {\r\n\r\n private ExecutorService executor;\r\n private HTML html;\r\n\r\n /*\r\n * Bound executor to a fixed thread pool size\r\n */\r\n public WebPage(int threadNumber, HTML html){\r\n //TODO\r\n }\r\n\r\n /*\r\n * submit the download of the image specified by the url\r\n * to be executed by thread pool\r\n */\r\n public Future<Image> loadImage(URL url){\r\n //TODO\r\n }\r\n\r\n /*\r\n * Download the image specified by the url\r\n */\r\n public Image downloadImageFromURL(URL url){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * Load all images of the page\r\n */\r\n public List<Future<Image>> loadImages(List<URL> urls){\r\n //TODO\r\n }\r\n\r\n /*\r\n * Load the page while images are being downloaded\r\n */\r\n private void displayPageWithoutImage(){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * Display all images on the page\r\n */\r\n private void displayImages(List<Image> images){\r\n //HIDDEN\r\n }\r\n\r\n /*\r\n * load the page\r\n */\r\n public void loadPage(){\r\n // First the image are downloaded asynchronously\r\n List<Future<Image>> futures = loadImages(this.html.getUrls());\r\n // While the image are being downloaded, we display the page without them\r\n displayPageWithoutImage();\r\n // Then we need all images to display them\r\n List<Image> images = new ArrayList<Image>(futures.size());\r\n try{\r\n for(Future<Image> future : futures){\r\n // the "get()" function is waiting for the result of the future task (here download the images)\r\n images.add(future.get());\r\n }\r\n } catch(InterruptedException e){\r\n\r\n } catch (ExecutionException e){\r\n\r\n }\r\n // we can display now images on the page\r\n displayImages(images);\r\n // shut down the executor service now\r\n executor.shutdown();\r\n\r\n }\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1611,8 +1615,8 @@
}
},
{
- "title": "Generics 1",
- "description": "In this task, you have to implement the map / filter functions of the\r\nfollowing class :\r\n\r\n``` java\r\npublic class Cons {\r\n // the item inside this list node\r\n public int v;\r\n // The next element, null if nothing\r\n public Cons next;\r\n // creates a new Cons that applies function f on all elements\r\n public Cons map(F f) {\r\n // TODO by student\r\n }\r\n // creates a new Cons with all elements that matches predicate p\r\n public Cons filter(P p) {\r\n // TODO by student\r\n }\r\n // Constructor\r\n public Cons(int v, Cons next) {\r\n this.v = v;\r\n this.next = next;\r\n }\r\n}\r\n```\r\n\r\nHere are the interfaces for the object parameter for filter/map\r\n\r\n``` java\r\ninterface F {\r\n int apply(int v);\r\n}\r\n\r\ninterface P {\r\n boolean filter(int v);\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics/LEPL1402_Generics.zip) that contains\r\nfew tests to help you.\r\n\r\n( You can find all the required files here :\r\n[Cons](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics/Cons.java) ,\r\n[Function](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics/F.java) ,\r\n[Predicate](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics/P.java) )\r\n",
+ "title": "Map, Filter, Cons",
+ "description": "
In this task, you have to implement the map / filter functions of the following class :
\r\n
public class Cons {\r\n // the item inside this list node\r\n public int v;\r\n // The next element, null if nothing\r\n public Cons next;\r\n // creates a new Cons that applies function f on all elements\r\n public Cons map(F f) {\r\n // TODO by student\r\n }\r\n // creates a new Cons with all elements that matches predicate p\r\n public Cons filter(P p) {\r\n // TODO by student\r\n }\r\n // Constructor\r\n public Cons(int v, Cons next) {\r\n this.v = v;\r\n this.next = next;\r\n }\r\n}
\r\n
Here are the interfaces for the object parameter for filter/map
\r\n
interface F {\r\n int apply(int v);\r\n}\r\n\r\ninterface P {\r\n boolean filter(int v);\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1655,7 +1659,7 @@
"text": "java"
},
{
- "text": "Module 3",
+ "text": "Module 5",
"category": 2
}
],
@@ -1670,8 +1674,8 @@
}
},
{
- "title": "Generics 2",
- "description": "In this task, you have to implement the generic map / filter functions\r\nof the following class :\r\n\r\n``` java\r\nimport java.util.function.Predicate;\r\nimport java.util.function.Function;\r\n\r\npublic class Cons < E > {\r\n // the item inside this list node\r\n public E v;\r\n // The next element, null if nothing\r\n public Cons next;\r\n // creates a new Cons that applies function f on all elements\r\n public Cons map(Function function) {\r\n // TODO by student\r\n }\r\n // creates a new Cons with all elements that matches predicate p\r\n public Cons filter(Predicate predicate) {\r\n // TODO by student\r\n }\r\n // Constructor\r\n public Cons(E v, Cons < E > next) {\r\n this.v = v;\r\n this.next = next;\r\n }\r\n}\r\n```\r\n\r\nTo help you understand how Predicate and Function works, check the\r\n[documentation](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html).\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics2/LEPL1402_Generics2.zip) that\r\ncontains few tests to help you.\r\n\r\n(You can find here all documents :\r\n[Cons](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics2/Cons.java),\r\n[Function](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics2/F.java),\r\n[Predicate](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics2/P.java))\r\n",
+ "title": "Map, Filter, Cons with Generics",
+ "description": "
In this task, you have to implement the generic map / filter functions of the following class :
\r\n
import java.util.function.Predicate;\r\nimport java.util.function.Function;\r\n\r\npublic class Cons < E > {\r\n // the item inside this list node\r\n public E v;\r\n // The next element, null if nothing\r\n public Cons<E> next;\r\n // creates a new Cons that applies function f on all elements\r\n public <R> Cons <R> map(Function <E,R> function) {\r\n // TODO by student\r\n }\r\n // creates a new Cons with all elements that matches predicate p\r\n public Cons <E> filter(Predicate <E> predicate) {\r\n // TODO by student\r\n }\r\n // Constructor\r\n public Cons(E v, Cons < E > next) {\r\n this.v = v;\r\n this.next = next;\r\n }\r\n}
\r\n
To help you understand how Predicate and Function works, check the documentation. You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1714,7 +1718,7 @@
"text": "java"
},
{
- "text": "Module 3",
+ "text": "Module 5",
"category": 2
}
],
@@ -1729,8 +1733,8 @@
}
},
{
- "title": "Generics 3",
- "description": "In this task, you have to implement the solver of this well-known logic\r\ncircuit :\r\n\r\n\r\n\r\n\r\n\r\nInstead of directly using a chain of logical operators ( that can lead\r\nyou to a error prone code sometimes), we will be using\r\n[BiFunction](https://docs.oracle.com/javase/8/docs/api/java/util/function/BiFunction.html)\r\nand\r\n[Function](https://docs.oracle.com/javase/8/docs/api/java/util/function/Function.html)\r\nto implement the logic gates. Your task is thus to implement the\r\nfollowing class : [Evaluator](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics3/Evaluator.java)\r\n. You can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Generics3/LEPL1402_Generics3.zip) that\r\ncontains few tests to help you.\r\n",
+ "title": "Logical Circuit Functional",
+ "description": "
In this task, you have to implement the solver of this well-known logic circuit :
\r\n\r\n\r\n\r\n
Instead of directly using a chain of logical operators ( that can lead you to a error prone code sometimes), we will be using BiFunction and Function to implement the logic gates. Your task is thus to implement the following class : Evaluator . You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1773,7 +1777,7 @@
"text": "java"
},
{
- "text": "Module 3",
+ "text": "Module 5",
"category": 2
}
],
@@ -1789,7 +1793,7 @@
},
{
"title": "Hanoi Tower",
- "description": "The tower of Hanoi is a mathematical puzzle, it consists of three rods\r\nand a number of disk of different size which can slide onto any rod. The\r\ngame starts with all the disks in an ascending order forming a stack on\r\nthe first rod. The objective of this puzzle is to move the entire stack\r\nto another rod. We know, it sounds easy, but there are 3 simple rules\r\nthat make the game harder than you think.\r\n\r\nHere they are : \r\n- You can only move one disk at a time.\r\n- Each move consists of taking the upper disk from one stack and\r\n moving it to another stack or on an empty rod.\r\n- No larger disk may be placed on top of a smaller disk.\r\n\r\nTo help you a little bit, here is an example of how you can solve the\r\nproblem with a stack of size 3.\r\n\r\n\r\n\r\nIn this exercise, you are asked to solve this puzzle for any size of\r\nstack by implementing this method and this method only! We are using\r\n[Stack](https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html),\r\nto get the first element of a stack, use the method `pop`, and to add an\r\nelement use the method `push`. The object\r\n[Disk](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/Disk.java) is here to make sure you\r\nwill not solve the exercise by just creating another stack.\r\n\r\nHere is the class\r\n[TowerOfHanoi](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/TowerOfHanoi.java) you must\r\nimplement, you can create disk by yourself to test your method but it\r\nwill not compile on Inginious if you try to do it.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/LEPL1402_HanoiTower.zip) that\r\ncontains few tests to help you.\r\n\r\n**hint:** you can call `towerOfHanoi` inside itself\r\n",
+ "description": "
The tower of Hanoi is a mathematical puzzle, it consists of three rods and a number of disk of different size which can slide onto any rod. The game starts with all the disks in an ascending order forming a stack on the first rod. The objective of this puzzle is to move the entire stack to another rod. We know, it sounds easy, but there are 3 simple rules that make the game harder than you think.
\r\n
\r\n
Here they are :
\r\n
\r\n
You can only move one disk at a time.
\r\n
Each move consists of taking the upper disk from one stack and moving it to another stack or on an empty rod.
\r\n
No larger disk may be placed on top of a smaller disk.
\r\n
\r\n
\r\n
\r\n
To help you a little bit, here is an example of how you can solve the problem with a stack of size 3.
\r\n
\r\n
In this exercise, you are asked to solve this puzzle for any size of stack by implementing this method and this method only! We are using Stack, to get the first element of a stack, use the method pop, and to add an element use the method push. The object Disk is here to make sure you will not solve the exercise by just creating another stack.
\r\n
Here is the class TowerOfHanoi you must implement, you can create disk by yourself to test your method but it will not compile on Inginious if you try to do it.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
hint: you can call towerOfHanoi inside itself
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1848,7 +1852,7 @@
},
{
"title": "Infinite Streams",
- "description": "The\r\n[Stream](https://docs.oracle.com/javase/8/docs/api/java/util/stream/Stream.html)\r\ninterface of java allows to create infinite streams. In order to\r\nunderstand how it works, we will create our own infinite streams.\r\n\r\nFor this task we give you an incomplete interface named\r\n[IStream](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/IStream.java) that represents\r\nan infinite stream. You first have to complete the three default methods\r\nof this interface. Since IStream is an interface, you have to complete\r\nthe class [Cons](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/Cons.java) that\r\nimplements [IStream](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/IStream.java).\r\n\r\nSince an infinite stream is not always usefull, we give you the class\r\n[Empty](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/Empty.java) that implements\r\n[IStream](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/IStream.java) and marks the\r\nend of a stream.\r\n\r\nFinally you will use all of it to create different finite and infinite\r\nstreams in the class\r\n[PlayWithStreams](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/PlayWithStreams.java).\r\n\r\nThere may seem like a lot to do, but most functions can be implemented\r\nin one line.\r\n\r\nNote that you will need to use the\r\n[Supplier](https://docs.oracle.com/javase/8/docs/api/java/util/function/Supplier.html)\r\nobject in order to make the creation of your stream (so the tail of a\r\nCons) lazy.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/InfiniteStreams/LEPL1402_InfiniteStreams.zip)\r\nthat contains few tests to help you.\r\n",
+ "description": "
The Stream interface of java allows to create infinite streams. In order to understand how it works, we will create our own infinite streams.
\r\n
For this task we give you an incomplete interface named IStream that represents an infinite stream. You first have to complete the three default methods of this interface. Since IStream is an interface, you have to complete the class Cons that implements IStream.
\r\n
Since an infinite stream is not always usefull, we give you the class Empty that implements IStream and marks the end of a stream.
\r\n
Finally you will use all of it to create different finite and infinite streams in the class PlayWithStreams.
\r\n
There may seem like a lot to do, but most functions can be implemented in one line.
\r\n
Note that you will need to use the Supplier object in order to make the creation of your stream (so the tail of a Cons) lazy.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1907,7 +1911,7 @@
},
{
"title": "Inheritance : Fill the gaps (Small Exercise)",
- "description": "Will you be able to fill the gaps inside these three source files (\r\n[Animal](https://inginious.info.ucl.ac.be/course/LEPL1402/Inheritance/Animal.java) ,\r\n[Cat](https://inginious.info.ucl.ac.be/course/LEPL1402/Inheritance/Cat.java) ,\r\n[SuperCat](https://inginious.info.ucl.ac.be/course/LEPL1402/Inheritance/SuperCat.java) ) so that it\r\ncompiles and passes our tests ?\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Inheritance/LEPL1402_Inheritance.zip) that\r\ncontains few tests to help you.\r\n",
+ "description": "
Will you be able to fill the gaps inside these three source files ( Animal , Cat , SuperCat ) so that it compiles and passes our tests ?
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -1966,7 +1970,7 @@
},
{
"title": "Introduction to java, exercises",
- "description": "Welcome to the first task of a long series!\r\n\r\nThis serie of inginious tasks will accompany you throughout the\r\nquadrimester to learn java and apprehend the material seen in class.\r\nSuccessful completion of all tasks is a major step towards the success\r\nof this course. We encourage you to try to do them yourself without\r\ngoing on the Internet.\r\n\r\nWe also encourage you to try your solutions by yourself on you computer.\r\nTo do so take a look at [this\r\ntutorial](https://lepl1402.readthedocs.io/en/latest/tools/index.html) on\r\nthe tools you will need.\r\n\r\nThis first task will cover the basics of java step by step. In most\r\nexercises we want you to paste the **signature** and the **body** of the\r\nmethods you create. In other cases we just wan to you paste the **body**\r\nand we give you the **signature**.\r\n\r\nHere is the class that you must implements in this task. The context of\r\nall variable must be static and the modifier public. You must find the\r\nreturn type by yourself.\r\n\r\n``` java\r\npublic class IntroductionExercises {\r\n\r\n public static int variable = 0;\r\n\r\n public static int[] squares;\r\n\r\n //TODO\r\n\r\n}\r\n```\r\n",
+ "description": "
Welcome to the first task of a long series!
\r\n
This serie of inginious tasks will accompany you throughout the quadrimester to learn java and apprehend the material seen in class. Successful completion of all tasks is a major step towards the success of this course. We encourage you to try to do them yourself without going on the Internet.
\r\n
We also encourage you to try your solutions by yourself on you computer. To do so take a look at this tutorial on the tools you will need.
\r\n
This first task will cover the basics of java step by step. In most exercises we want you to paste the signature and the body of the methods you create. In other cases we just wan to you paste the body and we give you the signature.
\r\n
Here is the class that you must implements in this task. The context of all variable must be static and the modifier public. You must find the return type by yourself.
\r\n
public class IntroductionExercises {\r\n\r\n public static int variable = 0;\r\n\r\n public static int[] squares;\r\n\r\n //TODO\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2025,7 +2029,7 @@
},
{
"title": "Lambda Expression in Java",
- "description": "In this exercise you will learn to use basic lambda expression. Since\r\nyou are going to use them later, they are worth a small introduction\r\nexercise.\r\n\r\nSince we work with lambda, we have decided to block the `return`\r\nstatement.\r\n\r\nHere you can find the java documentation about\r\n[Function](https://docs.oracle.com/javase/8/docs/api/java/util/function/package-summary.html),\r\n[Predicate](https://docs.oracle.com/javase/8/docs/api/java/util/function/Predicate.html)\r\nand\r\n[Comparator](https://docs.oracle.com/javase/8/docs/api/java/util/Comparator.html).\r\n",
+ "description": "
In this exercise you will learn to use basic lambda expression. Since you are going to use them later, they are worth a small introduction exercise.
\r\n
Since we work with lambda, we have decided to block the return statement.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2084,7 +2088,7 @@
},
{
"title": "Learn Exception in Java",
- "description": "In this task we ask you to implement method throwing and catching\r\nexceptions. In Java, Exceptions are handled using `try` and `catch`\r\nstatement like the example below\r\n\r\n``` java\r\ntry{\r\n String s = methodThatCanThrowException();\r\n}catch(ExceptionCaught e){\r\n //Do something\r\n}\r\n\r\n//Continue\r\n```\r\n\r\nWhen a method can throw an exception, it has to be specified in the\r\nsignature like the example below:\r\n\r\n``` java\r\npublic static double divide(int i1, int i2) throws ArithmeticException\r\n```\r\n\r\nIt means that it is possible that the method uses a statement like this:\r\n\r\n``` java\r\nthrow new ArithmeticException();\r\n```\r\n\r\nDownload [Divider](https://inginious.info.ucl.ac.be/course/LEPL1402/LearnException/Divider.java) and\r\nread the comment to know what you have to do. Download [intellij\r\nproject](https://inginious.info.ucl.ac.be/course/LEPL1402/LearnException/LEPL1402_LearnException.zip)\r\nwith tests.\r\n",
+ "description": "
In this task we ask you to implement method throwing and catching exceptions. In Java, Exceptions are handled using try and catch statement like the example below
\r\n
try{\r\n String s = methodThatCanThrowException();\r\n}catch(ExceptionCaught e){\r\n //Do something\r\n}\r\n\r\n//Continue
\r\n
When a method can throw an exception, it has to be specified in the signature like the example below:
\r\n
public static double divide(int i1, int i2) throws ArithmeticException
\r\n
It means that it is possible that the method uses a statement like this:
\r\n
throw new ArithmeticException();
\r\n
Download Divider and read the comment to know what you have to do. Download intellij project with tests.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2143,7 +2147,7 @@
},
{
"title": "Make Mistake To Understand Them",
- "description": "Although it will seem a bit weird, we will ask you to write code\r\ngenerating Exception. But why? The reason is simple, when you start\r\nprogramming in a new language it sometimes is really hard to understand\r\nwhy your code won't run properly. We made this exercise to help you\r\nunderstand what your mistake can be.\r\n\r\nBefore starting this exercise we recommend you to read about\r\n[NullPointerException](https://docs.oracle.com/javase/8/docs/api/java/lang/NullPointerException.html),\r\n[ArrayIndexOutOfBoundsException](https://docs.oracle.com/javase/8/docs/api/java/lang/ArrayIndexOutOfBoundsException.html)\r\nand\r\n[ConcurrentModificationException](https://docs.oracle.com/javase/8/docs/api/java/util/ConcurrentModificationException.html).\r\n",
+ "description": "
Although it will seem a bit weird, we will ask you to write code generating Exception. But why? The reason is simple, when you start programming in a new language it sometimes is really hard to understand why your code won't run properly. We made this exercise to help you understand what your mistake can be.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2202,7 +2206,7 @@
},
{
"title": "Largest Sum Contiguous Subarray",
- "description": "In this exercise you must write a method `maxSubArray` that finds the\r\nlargest sum in a contiguous subarray :\r\n\r\nGiven: \r\n- an array *s*,\r\n- (*i*, *j*), two indexes defining the start and the end of a subarray\r\n *s**u**b* such that 0 ≤ *i* ≤ *j* < *s*.*l**e**n**g**t**h*\r\n- *s**u**m*(*s**u**b*) the sum of all elements of the subarray\r\n *s**u**b*.\r\n\r\n∀*s**u**b* ∈ *s* such that\r\n*s**u**b* ≠ *s**u**b**o**p**t**i**m**a**l*;\r\n*s**u**b**o**p**t**i**m**a**l* is the maximum subarray of *s*\r\nif and only if\r\n*s**u**m*(*s**u**b**o**p**t**i**m**a**l*) > *s**u**m*(*s**u**b*).\r\n\r\nWhat it means is that given an array, your program should find the\r\n**first** subarray that produces the maximum result.\r\n\r\nYour method must return an array of three integers : \r\n- The sum of the subarray\r\n- The index of the start of the subarray\r\n- The index of the end of the subarray\r\n\r\n\r\n\r\n``` java\r\n/*\r\n* Given the array [-2,1,-3,4,-1,2,1,-5,4]\r\n* The contiguous subarray that produces the best result is [4,-1,2,1]\r\n* For this array your method should return [6, 3, 6]\r\n*/\r\npublic static int[] maxSubArray(int[] a){\r\n\r\n //TODO By Student\r\n\r\n}\r\n```\r\n\r\nNote that the length of the array **a** is strictly greater than 0.\r\n",
+ "description": "
In this exercise you must write a method maxSubArray that finds the largest sum in a contiguous subarray :
\r\n
\r\n
Given:
\r\n
\r\n
an array s,
\r\n
(i, j), two indexes defining the start and the end of a subarray sub such that 0 ≤ i ≤ j < s.length
\r\n
sum(sub) the sum of all elements of the subarray sub.
\r\n
\r\n
\r\n
\r\n
∀sub ∈ s such that sub ≠ suboptimal; suboptimal is the maximum subarray of s if and only if sum(suboptimal) > sum(sub).
\r\n
What it means is that given an array, your program should find the first subarray that produces the maximum result.
\r\n
\r\n
Your method must return an array of three integers :
\r\n
\r\n
The sum of the subarray
\r\n
The index of the start of the subarray
\r\n
The index of the end of the subarray
\r\n
\r\n
\r\n
\r\n
/*\r\n* Given the array [-2,1,-3,4,-1,2,1,-5,4]\r\n* The contiguous subarray that produces the best result is [4,-1,2,1]\r\n* For this array your method should return [6, 3, 6]\r\n*/\r\npublic static int[] maxSubArray(int[] a){\r\n\r\n //TODO By Student\r\n\r\n}
\r\n
Note that the length of the array a is strictly greater than 0.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2261,7 +2265,7 @@
},
{
"title": "Merge Sort Implementation",
- "description": "In this exercise we ask you to implement the\r\n[top-down](https://inginious.info.ucl.ac.be/course/LEPL1402/MergeSortImplementation/topdown.png) merge\r\nsort algorithm on an array of integer. You have to use **2 methods**:\r\n\r\n> - Sort, this method has to divide the array and apply merge.\r\n> - Merge, this method has to merge the array given the 2 index, it\r\n> receives from sort 3 index, lower bound, middle and high. It also\r\n> receives a copy of the first array.\r\n\r\nThe tests are build to make you able to test the two methods separly but\r\nwe **recommand** you to test them by yourself.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/MergeSortImplementation/LEPL1402_MergeSortImplementation.zip)\r\nthat contains few tests to help you.\r\n\r\nHere is the class\r\n[MergeSort](https://inginious.info.ucl.ac.be/course/LEPL1402/MergeSortImplementation/MergeSort.java):\r\n\r\n``` java\r\npublic class MergeSort {\r\n\r\n /**\r\n * Pre-conditions: a[lo..mid] and a[mid+1..hi] are sorted\r\n * Post-conditions: a[lo..hi] is sorted\r\n */\r\n private static void merge(int[] a, int[] aux, int lo, int mid, int hi) {\r\n // TODO By Student\r\n }\r\n /**\r\n * Rearranges the array in ascending order, using the natural order\r\n */\r\n public static void sort(int[] a) {\r\n // TODO By Student\r\n }\r\n\r\n //TODO Optionnal additionnal method\r\n}\r\n```\r\n",
+ "description": "
In this exercise we ask you to implement the top-down merge sort algorithm on an array of integer. You have to use 2 methods:
\r\n
\r\n
\r\n
Sort, this method has to divide the array and apply merge.
\r\n
Merge, this method has to merge the array given the 2 index, it receives from sort 3 index, lower bound, middle and high. It also receives a copy of the first array.
\r\n
\r\n
\r\n
The tests are build to make you able to test the two methods separly but we recommand you to test them by yourself.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
public class MergeSort {\r\n\r\n /**\r\n * Pre-conditions: a[lo..mid] and a[mid+1..hi] are sorted\r\n * Post-conditions: a[lo..hi] is sorted\r\n */\r\n private static void merge(int[] a, int[] aux, int lo, int mid, int hi) {\r\n // TODO By Student\r\n }\r\n /**\r\n * Rearranges the array in ascending order, using the natural order\r\n */\r\n public static void sort(int[] a) {\r\n // TODO By Student\r\n }\r\n\r\n //TODO Optionnal additionnal method\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2310,7 +2314,7 @@
},
{
"title": "MyArrayList",
- "description": "In this task, you have to implement your own version of the famous\r\njava's `ArrayList` : a dynamic sized array. Each time you want to add\r\nan element, you must check that the item can fit and then append it at\r\nthe end of the list. If the array is too small, you need to resize it so\r\nthat new items can be added in the future. To remove an element you need\r\nto specify an index to choose which element of the list you want to\r\nremove (`remove(0)` for the first ... `remove(size()-1)` for the last).\r\n**Never** leave \"blanks\" in your array. When you remove an element at\r\nsome `index`, **all subsequents** elements must be \"shifted\".\r\n\r\nSo if your list look like this:\r\n\r\n\r\n\r\n\r\n\r\nThen after the call `remove(1)` it should look like this:\r\n\r\n\r\n\r\n\r\n\r\nYou also need to implement the `MyArrayListIterator` class.\r\n[Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html)\r\nis an interface you have to implement in order to make the class\r\nimplementing it able to enumerate/browse/iterate over an object : here,\r\nwe want you to implement a FIFO order iterator over your `MyArrayList`.\r\n\r\n> **Pay attention**, we add some constraints for this task:\r\n>\r\n> > - Your iterator don't have to implement the `remove` method from\r\n> > [Iterator](https://docs.oracle.com/javase/8/docs/api/java/util/Iterator.html).\r\n> > - Your iterator must throw a `ConcurrentModificationException`\r\n> > when you want to get the next element but some other element has\r\n> > been added to the list meanwhile.\r\n> > - You cannot use `System.arraycopy` for this task.\r\n> > - Your constructor must throw an `IndexOutOfBoundsException` if\r\n> > the parameter is smaller than 0.\r\n> > - your `remove` method must throw an `IndexOutOfBoundsException`\r\n> > if the index parameter is smaller than `0` or greater than\r\n> > `size()-1`.\r\n\r\nA lot of classes implement this interface, including the official\r\n[ArrayList](https://docs.oracle.com/javase/7/docs/api/java/util/ArrayList.html)\r\nfrom java. We **strongly** encourage you to experiment how the\r\n`ArrayList` iterator works before implementing yours.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/MyArrayList/LEPL1402_MyArrayList.zip) that\r\ncontains few tests to help you.\r\n\r\nHere is the class (downloadable\r\n[here](https://inginious.info.ucl.ac.be/course/LEPL1402/MyArrayList/MyArrayList.java)) where we will\r\ninsert your code :\r\n\r\n``` java\r\nimport java.util.ConcurrentModificationException;\r\nimport java.util.Iterator;\r\n\r\npublic class MyArrayList implements Iterable {\r\n\r\n private Object [] list;\r\n private int size;\r\n\r\n\r\n public MyArrayList(int initSize){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Checks if 'list' needs to be resized then add the element at the end\r\n * of the list.\r\n */\r\n public void enqueue(Item item){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Removes the element at the specified position in this list.\r\n * Returns the element that was removed from the list. You dont need to\r\n * resize when removing an element.\r\n */\r\n public Item remove(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public int size(){\r\n return this.size;\r\n }\r\n\r\n\r\n @Override\r\n public Iterator iterator() {\r\n return new MyArrayListIterator();\r\n }\r\n\r\n\r\n private class MyArrayListIterator implements Iterator {\r\n // YOUR CODE HERE\r\n }\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task, you have to implement your own version of the famous java's ArrayList<E> : a dynamic sized array. Each time you want to add an element, you must check that the item can fit and then append it at the end of the list. If the array is too small, you need to resize it so that new items can be added in the future. To remove an element you need to specify an index to choose which element of the list you want to remove (remove(0) for the first ... remove(size()-1) for the last). Never leave \"blanks\" in your array. When you remove an element at some index, all subsequents elements must be \"shifted\".
\r\n
So if your list look like this:
\r\n\r\n\r\n\r\n
Then after the call remove(1) it should look like this:
\r\n\r\n\r\n\r\n
You also need to implement the MyArrayListIterator class. Iterator is an interface you have to implement in order to make the class implementing it able to enumerate/browse/iterate over an object : here, we want you to implement a FIFO order iterator over your MyArrayList.
\r\n
\r\n
Pay attention, we add some constraints for this task:
\r\n
\r\n
\r\n
Your iterator don't have to implement the remove method from Iterator.
\r\n
Your iterator must throw a ConcurrentModificationException when you want to get the next element but some other element has been added to the list meanwhile.
\r\n
You cannot use System.arraycopy for this task.
\r\n
Your constructor must throw an IndexOutOfBoundsException if the parameter is smaller than 0.
\r\n
your remove method must throw an IndexOutOfBoundsException if the index parameter is smaller than 0 or greater than size()-1.
\r\n
\r\n
\r\n
\r\n
A lot of classes implement this interface, including the official ArrayList from java. We strongly encourage you to experiment how the ArrayList<E> iterator works before implementing yours.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
Here is the class (downloadable here) where we will insert your code :
\r\n
import java.util.ConcurrentModificationException;\r\nimport java.util.Iterator;\r\n\r\npublic class MyArrayList<Item> implements Iterable<Item> {\r\n\r\n private Object [] list;\r\n private int size;\r\n\r\n\r\n public MyArrayList(int initSize){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Checks if 'list' needs to be resized then add the element at the end\r\n * of the list.\r\n */\r\n public void enqueue(Item item){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Removes the element at the specified position in this list.\r\n * Returns the element that was removed from the list. You dont need to\r\n * resize when removing an element.\r\n */\r\n public Item remove(int index){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public int size(){\r\n return this.size;\r\n }\r\n\r\n\r\n @Override\r\n public Iterator<Item> iterator() {\r\n return new MyArrayListIterator();\r\n }\r\n\r\n\r\n private class MyArrayListIterator implements Iterator<Item> {\r\n // YOUR CODE HERE\r\n }\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2369,7 +2373,7 @@
},
{
"title": "Observer design pattern",
- "description": "In this task, you have to implement the Observer design pattern for the\r\ncase of a meteo station:\r\n\r\n``` java\r\npublic class MeteoStation extends Observable {\r\n // YOUR CODE HERE\r\n}\r\n\r\n\r\npublic class Client extends Observer {\r\n // YOUR CODE HERE\r\n}\r\n```\r\n\r\nNote that [Observable](https://inginious.info.ucl.ac.be/course/LEPL1402/Observer/Observable.java) and\r\n[Observer](https://inginious.info.ucl.ac.be/course/LEPL1402/Observer/Observer.java) are two abstract\r\nclasses containing abstract methods. Therefore, check and read them\r\ncarefully in order to implement things correctly. For your `Client`\r\nclass you have to extend the observer class and implement a constructor\r\n(do not forget instance variables). For the `MeteoStation` class, extend\r\nthe Observable abstract class, you will need to use\r\n[Pair](https://inginious.info.ucl.ac.be/course/LEPL1402/Observer/Pair.java) for this one.\r\n\r\nNote that your observers start to receive messages at the moment they\r\nsubscribe but they should not see messages that were broadcast before\r\nthey subscribed.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Observer/LEPL1402_Observer.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
In this task, you have to implement the Observer design pattern for the case of a meteo station:
\r\n
public class MeteoStation extends Observable {\r\n // YOUR CODE HERE\r\n}\r\n\r\n\r\npublic class Client extends Observer {\r\n // YOUR CODE HERE\r\n}
\r\n
Note that Observable and Observer are two abstract classes containing abstract methods. Therefore, check and read them carefully in order to implement things correctly. For your Client class you have to extend the observer class and implement a constructor (do not forget instance variables). For the MeteoStation class, extend the Observable abstract class, you will need to use Pair for this one.
\r\n
Note that your observers start to receive messages at the moment they subscribe but they should not see messages that were broadcast before they subscribed.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2428,7 +2432,7 @@
},
{
"title": "Optional - no more concerns about NullPointerException",
- "description": "The 8th version of java introduced the\r\n[Optional](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)\r\nobject to avoid NullPointerException in our codes without using too many\r\ncheck on nullable objects.\r\n\r\nFor this task, we give you three small classes\r\n([Person](https://inginious.info.ucl.ac.be/course/LEPL1402/Optional/Person.java),\r\n[Team](https://inginious.info.ucl.ac.be/course/LEPL1402/Optional/Team.java) and\r\n[TeamLeader](https://inginious.info.ucl.ac.be/course/LEPL1402/Optional/TeamLeader.java)) and you have to\r\nimplement the different methods of\r\n[OptionalTest](https://inginious.info.ucl.ac.be/course/LEPL1402/Optional/OptionalTest.java). All methods\r\ncan be implemented in one line of code thanks to the different methods\r\nof\r\n[Optional](https://docs.oracle.com/javase/8/docs/api/java/util/Optional.html)\r\nand the lambda expressions.\r\n\r\nYou are not allow to use `new TeamLeader()` in these exercises.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Optional/LEPL1402_Optional.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
The 8th version of java introduced the Optional object to avoid NullPointerException in our codes without using too many check on nullable objects.
\r\n
For this task, we give you three small classes (Person, Team and TeamLeader) and you have to implement the different methods of OptionalTest. All methods can be implemented in one line of code thanks to the different methods of Optional and the lambda expressions.
\r\n
You are not allow to use new TeamLeader() in these exercises.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2487,7 +2491,7 @@
},
{
"title": "Parallel Merge Sort",
- "description": "In this task, you will be asked to implement a special kind of merge\r\nsort using the\r\n[RecursiveAction](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/RecursiveAction.html)\r\n,\r\n[ForkJoinPool](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ForkJoinPool.html)\r\nand\r\n[ForkJoinTask](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/ForkJoinTask.html)\r\ninterfaces. You will understand by reading these interfaces that the\r\nmerge sort you must implement is not only recursive but in parallel.\r\n\r\nYou have to complete the following class :\r\n[ParallelMergeSort](https://inginious.info.ucl.ac.be/course/LEPL1402/ParallelelMergeSort/ParallelMergeSort.java)\r\n\r\nHere is an example of how we can use your implementation :\r\n\r\n``` java\r\nint size = 1000;\r\nInteger[] array = new Integer[size];\r\nfor(int i = 0 ; i < size ; i++){\r\n array[i] = rng.nextInt(10000);\r\n}\r\nParallelMergeSort task = new ParallelMergeSort(array, 0, size-1, new Integer[size],\r\n Comparator.comparing(Integer::intValue));\r\nnew ForkJoinPool().invoke(task);\r\n```\r\n\r\nYou will see that we've fixed a threshold, the reason we are using a\r\nthreshold is easy to understand. Since you want your code to be\r\neffective on very large array, starting a thread for every element can\r\nbe very ressource consuming and thus you would be losing the advantage\r\nyou had of using concurrent programming. So when the subarray you're\r\nworking on is smaller than the threshold, it simply run a normal sort.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ParallelelMergeSort/LEPL1402_ParallelelMergeSort.zip)\r\nthat contains few tests to help you.\r\n",
+ "description": "
In this task, you will be asked to implement a special kind of merge sort using the RecursiveAction , ForkJoinPool and ForkJoinTask interfaces. You will understand by reading these interfaces that the merge sort you must implement is not only recursive but in parallel.
Here is an example of how we can use your implementation :
\r\n
int size = 1000;\r\nInteger[] array = new Integer[size];\r\nfor(int i = 0 ; i < size ; i++){\r\n array[i] = rng.nextInt(10000);\r\n}\r\nParallelMergeSort task = new ParallelMergeSort(array, 0, size-1, new Integer[size],\r\n Comparator.comparing(Integer::intValue));\r\nnew ForkJoinPool().invoke(task);
\r\n
You will see that we've fixed a threshold, the reason we are using a threshold is easy to understand. Since you want your code to be effective on very large array, starting a thread for every element can be very ressource consuming and thus you would be losing the advantage you had of using concurrent programming. So when the subarray you're working on is smaller than the threshold, it simply run a normal sort.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2546,7 +2550,7 @@
},
{
"title": "Postscript interpreter",
- "description": "You are asked to write a mini-PostScript interpreter as described in the\r\n*pdf* ([Mission](https://inginious.info.ucl.ac.be/course/LEPL1402/PostScript/mission.pdf)) of the\r\nmission. Precisely, you must implement the following interface :\r\n\r\n``` java\r\npublic interface InterpreterInterface {\r\n /**\r\n * @pre: 'instructions' is a valid chain of PostScript instructions\r\n * @post: returns a String representing the state of the stack when a 'pstack' instruction is encountered.\r\n * If several 'pstack' instructions are present in the chain, a concatenation of the corresponding states (when 'pstack' is encountered) must be returned, separated by whitespaces.\r\n * If several elements are still on the stack, separate them with whitespaces.\r\n * If there is no element on the stack or no 'pstack' instruction, return the empty string (\"\").\r\n */\r\n public String interpret(String instructions);\r\n}\r\n```\r\n\r\nWe expect your interpreter to be able to handle all of the following\r\nspecified operations:\r\n\r\n
\r\n
\r\n
\r\n
\r\n
\r\n
\r\n\r\n
\r\n
\r\n
Before
\r\n
\r\n
After
\r\n
Description
\r\n
\r\n
\r\n
any pstack
\r\n
pstack
\r\n
print the top element of the pile to the standard output
\r\n
\r\n
\r\n
any1 any2 exch
\r\n
any2 any1
\r\n
Swap the two top most element of the stack
\r\n
\r\n
\r\n
any pop
\r\n
\r\n
Pop the top most element of the stack
\r\n
\r\n
\r\n
any dup
\r\n
any any
\r\n
Duplicate the top most element of the stack
\r\n
\r\n
\r\n
any1 any2 add
\r\n
any1+any2
\r\n
Pop two elements from the stack, compute their sum and push the result
\r\n
\r\n
\r\n
any1 any2 sub
\r\n
any1-any2
\r\n
Same, but with a subtraction
\r\n
\r\n
\r\n
any1 any2 mul
\r\n
any1*any2
\r\n
Same, but with a multiplication
\r\n
\r\n
\r\n
any1 any2 div
\r\n
any1/any2
\r\n
Same, but with a division
\r\n
\r\n
\r\n
any1 any2 idiv
\r\n
any3
\r\n
\r\n
Compute the quotient of an integer division of any1 by any2, then push the result to the stack
\r\n
\r\n
\r\n\r\n
\r\n\r\nThe element of the stack could be: \r\n- Operators - any operators from the array above.\r\n- Operands - any integer, double or boolean (true, false)\r\n\r\nDon't forget to throw exceptions : `EmptyStackException` if there's not\r\nenough operand left on the stack, `ArithmeticException` when an illegal\r\ncomputation is submitted to your interpreter, `IllegalArgumentException`\r\nwhen a bad operand is found (for example, a boolean instead of an\r\ninteger when performing a mathematical operation)\r\n",
+ "description": "
You are asked to write a mini-PostScript interpreter as described in the pdf (Mission) of the mission. Precisely, you must implement the following interface :
\r\n
public interface InterpreterInterface {\r\n /**\r\n * @pre: 'instructions' is a valid chain of PostScript instructions\r\n * @post: returns a String representing the state of the stack when a 'pstack' instruction is encountered.\r\n * If several 'pstack' instructions are present in the chain, a concatenation of the corresponding states (when 'pstack' is encountered) must be returned, separated by whitespaces.\r\n * If several elements are still on the stack, separate them with whitespaces.\r\n * If there is no element on the stack or no 'pstack' instruction, return the empty string ("").\r\n */\r\n public String interpret(String instructions);\r\n}
\r\n
We expect your interpreter to be able to handle all of the following specified operations:
\r\n
\r\n
\r\n
\r\n
\r\n
\r\n
\r\n\r\n
\r\n
\r\n
Before
\r\n
\r\n
After
\r\n
Description
\r\n
\r\n
\r\n
any pstack
\r\n
pstack
\r\n
print the top element of the pile to the standard output
\r\n
\r\n
\r\n
any1 any2 exch
\r\n
any2 any1
\r\n
Swap the two top most element of the stack
\r\n
\r\n
\r\n
any pop
\r\n
\r\n
Pop the top most element of the stack
\r\n
\r\n
\r\n
any dup
\r\n
any any
\r\n
Duplicate the top most element of the stack
\r\n
\r\n
\r\n
any1 any2 add
\r\n
any1+any2
\r\n
Pop two elements from the stack, compute their sum and push the result
\r\n
\r\n
\r\n
any1 any2 sub
\r\n
any1-any2
\r\n
Same, but with a subtraction
\r\n
\r\n
\r\n
any1 any2 mul
\r\n
any1*any2
\r\n
Same, but with a multiplication
\r\n
\r\n
\r\n
any1 any2 div
\r\n
any1/any2
\r\n
Same, but with a division
\r\n
\r\n
\r\n
any1 any2 idiv
\r\n
any3
\r\n
\r\n
Compute the quotient of an integer division of any1 by any2, then push the result to the stack
\r\n
\r\n
\r\n\r\n
\r\n
\r\n
The element of the stack could be:
\r\n
\r\n
Operators - any operators from the array above.
\r\n
Operands - any integer, double or boolean (true, false)
\r\n
\r\n
\r\n
\r\n
Don't forget to throw exceptions : EmptyStackException if there's not enough operand left on the stack, ArithmeticException when an illegal computation is submitted to your interpreter, IllegalArgumentException when a bad operand is found (for example, a boolean instead of an integer when performing a mathematical operation)
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2605,7 +2609,7 @@
},
{
"title": "Threads - Producer/Consumer with locks",
- "description": "In this task we will ask you to solve the producer/consumer problem,\r\nrepresented here as a concurrent bounded FIFO queue. We will run\r\nsimultaneously two different types of threads on your queue :\r\n\r\n> - Consumers, consuming (= dequeuing) elements from the queue.\r\n> - Producers, producing (= enqueuing) elements to the queue.\r\n\r\nYour queue needs to be thread-safe : it must be able to operate in a\r\nconcurrent environment. It also means that threads must wait if\r\nnecessary. A producer can't progress if there's no space left in the\r\nqueue. A consumer can't take element from the queue if it is empty. For\r\nthis exercise, you will need to implement `enqueue` and `dequeue`, using\r\nall the instance variables that are in the\r\n[LockQueue](https://inginious.info.ucl.ac.be/course/LEPL1402/ProducerConsumer/LockQueue.java) class\r\nbelow. We strongly suggest you to look at\r\n[await](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#await--)\r\nand\r\n[signal](https://docs.oracle.com/javase/8/docs/api/java/util/concurrent/locks/Condition.html#signal--)\r\n(or `signalAll`) methods. You are not allowed to instantiate new locks\r\nor condition objects.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ProducerConsumer/LEPL1402_ProducerConsumer.zip)\r\nthat contains few tests to help you.\r\n\r\n``` java\r\nimport java.util.concurrent.locks.Condition;\r\nimport java.util.concurrent.locks.ReentrantLock;\r\n\r\npublic class LockQueue {\r\n\r\n public final static int SIZE = 100;\r\n\r\n private final ReentrantLock lock = new ReentrantLock();\r\n private final Condition notFull = lock.newCondition();\r\n private final Condition notEmpty = lock.newCondition();\r\n\r\n public int head = 0;\r\n public int tail = 0;\r\n public final Integer [] cells = new Integer[SIZE];\r\n public int count = 0;\r\n\r\n\r\n\r\n public Integer dequeue() {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public void enqueue(Integer i) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n public boolean full(){\r\n return this.count == SIZE;\r\n }\r\n\r\n public boolean empty(){\r\n return this.head == this.tail;\r\n }\r\n\r\n public int size() { return this.tail - this.head; }\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task we will ask you to solve the producer/consumer problem, represented here as a concurrent bounded FIFO queue. We will run simultaneously two different types of threads on your queue :
\r\n
\r\n
\r\n
Consumers, consuming (= dequeuing) elements from the queue.
\r\n
Producers, producing (= enqueuing) elements to the queue.
\r\n
\r\n
\r\n
Your queue needs to be thread-safe : it must be able to operate in a concurrent environment. It also means that threads must wait if necessary. A producer can't progress if there's no space left in the queue. A consumer can't take element from the queue if it is empty. For this exercise, you will need to implement enqueue and dequeue, using all the instance variables that are in the LockQueue class below. We strongly suggest you to look at await and signal (or signalAll) methods. You are not allowed to instantiate new locks or condition objects.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
import java.util.concurrent.locks.Condition;\r\nimport java.util.concurrent.locks.ReentrantLock;\r\n\r\npublic class LockQueue {\r\n\r\n public final static int SIZE = 100;\r\n\r\n private final ReentrantLock lock = new ReentrantLock();\r\n private final Condition notFull = lock.newCondition();\r\n private final Condition notEmpty = lock.newCondition();\r\n\r\n public int head = 0;\r\n public int tail = 0;\r\n public final Integer [] cells = new Integer[SIZE];\r\n public int count = 0;\r\n\r\n\r\n\r\n public Integer dequeue() {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public void enqueue(Integer i) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n public boolean full(){\r\n return this.count == SIZE;\r\n }\r\n\r\n public boolean empty(){\r\n return this.head == this.tail;\r\n }\r\n\r\n public int size() { return this.tail - this.head; }\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2664,7 +2668,7 @@
},
{
"title": "Queue with two stacks",
- "description": "In this short exercise we will ask you to implement a FIFO queue using\r\ntwo stacks (provided as two Java `Stack`). We need you to provide 4\r\nmethods : `enqueue`, `dequeue`, `peek`, `empty`. You can use the `Stack`\r\n[API](https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html) ,\r\nbut you can't instantiate a new `Stack`. Use `s1` and `s2` from the\r\n[MyQueue](https://inginious.info.ucl.ac.be/course/LEPL1402/QueueWithStacks/MyQueue.java) class below.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/QueueWithStacks/LEPL1402_QueueWithStacks.zip)\r\nthat contains few tests to help you.\r\n\r\n``` java\r\nimport java.util.Stack;\r\n\r\npublic class MyQueue {\r\n\r\n Stack s1;\r\n Stack s2;\r\n\r\n private E front;\r\n\r\n /*\r\n * Constructor\r\n */\r\n public MyQueue() {\r\n s1 = new Stack<>();\r\n s2 = new Stack<>();\r\n this.front = null;\r\n }\r\n\r\n /*\r\n * Push element x to the end of the queue (remember, a queue is FIFO)\r\n */\r\n public void enqueue(E elem) {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Removes the front element of this queue\r\n */\r\n public E dequeue() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Get the first element of this list but does not remove it\r\n */\r\n public E peek() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Tells if the queue is empty or not.\r\n */\r\n public boolean empty() {\r\n //TODO\r\n }\r\n}\r\n```\r\n",
+ "description": "
In this short exercise we will ask you to implement a FIFO queue using two stacks (provided as two Java Stack<E>). We need you to provide 4 methods : enqueue, dequeue, peek, empty. You can use the StackAPI , but you can't instantiate a new Stack. Use s1 and s2 from the MyQueue class below.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
import java.util.Stack;\r\n\r\npublic class MyQueue<E> {\r\n\r\n Stack<E> s1;\r\n Stack<E> s2;\r\n\r\n private E front;\r\n\r\n /*\r\n * Constructor\r\n */\r\n public MyQueue() {\r\n s1 = new Stack<>();\r\n s2 = new Stack<>();\r\n this.front = null;\r\n }\r\n\r\n /*\r\n * Push element x to the end of the queue (remember, a queue is FIFO)\r\n */\r\n public void enqueue(E elem) {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Removes the front element of this queue\r\n */\r\n public E dequeue() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Get the first element of this list but does not remove it\r\n */\r\n public E peek() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Tells if the queue is empty or not.\r\n */\r\n public boolean empty() {\r\n //TODO\r\n }\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2723,7 +2727,7 @@
},
{
"title": "Threads - Shared counter with monitors",
- "description": "In this task we will ask you to use monitors for a thread-shared\r\ncounter. When threads are executed concurrently and they share some\r\npiece of memory, unexpected/wrong results are very likely to happen. For\r\nexample, if you run four threads on the same counter, each thread\r\nincrementing ten thousands times the counter, you would of course expect\r\nthat the final value of the counter will be fourty thousands when all\r\nfour threads are done... But in practice, if there is no synchronization\r\nmechanism of any kind between threads, you will see that the final value\r\nwill certainly be different from what we expect. Your job for this task\r\nis thus to implement a synchronization mechanism for a counter using\r\nonly java's built-in monitors. We ask you to implement the three\r\nfollowing methods:\r\n\r\n> - void inc() : increment once the counter.\r\n> - void dec() : decrement the counter **if and only if** its current\r\n> value is positive. In fact, the counter we ask you to implement\r\n> must **always** be positive. If a thread wants to decrement the\r\n> counter but its value is 0, it has to wait.\r\n> - int get() : returns the current value of the counter.\r\n\r\nPay attention, you are not allowed to use `Lock` for this mission, only\r\nbuilt-in\r\n[monitors](https://www.artima.com/insidejvm/ed2/threadsynch.html). You\r\nmight also face a [deadlock](https://en.wikipedia.org/wiki/Deadlock)\r\nproblem.\r\n\r\n``` java\r\npublic class SharedCounter {\r\n\r\n private int counter = 0;\r\n\r\n // YOUR CODE HERE\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task we will ask you to use monitors for a thread-shared counter. When threads are executed concurrently and they share some piece of memory, unexpected/wrong results are very likely to happen. For example, if you run four threads on the same counter, each thread incrementing ten thousands times the counter, you would of course expect that the final value of the counter will be fourty thousands when all four threads are done... But in practice, if there is no synchronization mechanism of any kind between threads, you will see that the final value will certainly be different from what we expect. Your job for this task is thus to implement a synchronization mechanism for a counter using only java's built-in monitors. We ask you to implement the three following methods:
\r\n
\r\n
\r\n
void inc() : increment once the counter.
\r\n
void dec() : decrement the counter if and only if its current value is positive. In fact, the counter we ask you to implement must always be positive. If a thread wants to decrement the counter but its value is 0, it has to wait.
\r\n
int get() : returns the current value of the counter.
\r\n
\r\n
\r\n
Pay attention, you are not allowed to use Lock for this mission, only built-in monitors. You might also face a deadlock problem.
\r\n
public class SharedCounter {\r\n\r\n private int counter = 0;\r\n\r\n // YOUR CODE HERE\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2782,7 +2786,7 @@
},
{
"title": "Sieve of Eratosthenes Implementation",
- "description": "In this task you are asked to implement the method\r\n`numberOfPrime(int n)` that returns the number of prime numbers between\r\n0 and *n* using the [Eratosthene\r\nalgorithm](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes). To\r\nimplement this we force you to use a\r\n[BitSet](https://docs.oracle.com/javase/8/docs/api/java/util/BitSet.html),\r\nyou are not allowed to use an array: you must work with the `bits`\r\nvariable.\r\n\r\nThe goal of this exercise is to introduce you to the [java\r\ndocumentation](https://docs.oracle.com/javase/8/docs/api/) and to make\r\nsure that you are able to read, understand and use class that are\r\ndefined and documented in java.\r\n\r\n``` java\r\npublic static BitSet bits; //You should work on this BitSet\r\n\r\npublic static int numberOfPrime(int n){\r\n //TODO By Student\r\n}\r\n```\r\n",
+ "description": "
In this task you are asked to implement the method numberOfPrime(int n) that returns the number of prime numbers between 0 and n using the Eratosthene algorithm. To implement this we force you to use a BitSet, you are not allowed to use an array: you must work with the bits variable.
\r\n
The goal of this exercise is to introduce you to the java documentation and to make sure that you are able to read, understand and use class that are defined and documented in java.
\r\n
public static BitSet bits; //You should work on this BitSet\r\n\r\npublic static int numberOfPrime(int n){\r\n //TODO By Student\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2836,7 +2840,7 @@
},
{
"title": "MCQ Sieve of Eratosthenes",
- "description": "The following mcq will introduce you to the next exercise, we strongly\r\nrecommend you to answer and understand them before starting the exercise\r\nSieve Of Eratosthene implementation.\r\n\r\nThe sieve of Eratosthene is an algorithm that helps you determine how\r\nmany/which of the number are prime numbers in a set of integer from 0 to\r\n*n*.\r\n\r\nTo implement this algorithm we want you to use a\r\n[BitSet](https://docs.oracle.com/javase/8/docs/api/java/util/BitSet.html),\r\nthe idea here is to force you to read and understand the java\r\ndocumentation. Thus, we will ask you questions about the different\r\nmethod you might need in the implementation of the sieve.\r\n\r\nThe difficulty will increase each question and ask you to read the doc a\r\n*bit* more.\r\n",
+ "description": "
The following mcq will introduce you to the next exercise, we strongly recommend you to answer and understand them before starting the exercise Sieve Of Eratosthene implementation.
\r\n
The sieve of Eratosthene is an algorithm that helps you determine how many/which of the number are prime numbers in a set of integer from 0 to n.
\r\n
To implement this algorithm we want you to use a BitSet, the idea here is to force you to read and understand the java documentation. Thus, we will ask you questions about the different method you might need in the implementation of the sieve.
\r\n
The difficulty will increase each question and ask you to read the doc a bit more.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2885,7 +2889,7 @@
},
{
"title": "Stack with a Queue",
- "description": "In this short exercise we will ask you to implement a LIFO stack using a\r\nqueue (provided as a Java `LinkedList`). We need you to provide 4\r\nmethods : `push`, `pop`, `peek`, `empty`. You can't use the `LinkedList`\r\nAPI except for the methods listed below:\r\n\r\n- `add`\r\n- `remove`\r\n- `peek`\r\n- `isEmpty`\r\n- `size`\r\n\r\n(You can find the file\r\n[here](https://inginious.info.ucl.ac.be/course/LEPL1402/StackWithQueue/MyStack.java)). The challenge of\r\nthis exercise is to use **only** the queue that is provided as instance\r\nvariable: `queue`. In other words, you **can't** instantiate a new\r\n`LinkedList` anywhere.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/StackWithQueue/LEPL1402_StackWithQueue.zip)\r\nthat contains few tests to help you.\r\n\r\n``` java\r\nimport java.util.LinkedList;\r\n\r\npublic class MyStack {\r\n\r\n private LinkedList queue;\r\n\r\n /*\r\n * Constructor\r\n */\r\n public MyStack() {\r\n this.queue = new LinkedList<>();\r\n }\r\n\r\n /*\r\n * push an element at top (remember, a stack is \"Last In First Out\")\r\n */\r\n public void push(E elem) {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Return the top of the stack AND remove the retrieved element\r\n */\r\n public E pop() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Return the top element of the stack, without removing it\r\n */\r\n public E peek() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Tells if the stack is empty or not\r\n */\r\n public boolean empty() {\r\n //TODO\r\n }\r\n```\r\n",
+ "description": "
In this short exercise we will ask you to implement a LIFO stack using a queue (provided as a Java LinkedList<E>). We need you to provide 4 methods : push, pop, peek, empty. You can't use the LinkedList API except for the methods listed below:
\r\n
\r\n
add
\r\n
remove
\r\n
peek
\r\n
isEmpty
\r\n
size
\r\n
\r\n
(You can find the file here). The challenge of this exercise is to use only the queue that is provided as instance variable: queue. In other words, you can't instantiate a new LinkedList anywhere.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
import java.util.LinkedList;\r\n\r\npublic class MyStack<E> {\r\n\r\n private LinkedList<E> queue;\r\n\r\n /*\r\n * Constructor\r\n */\r\n public MyStack() {\r\n this.queue = new LinkedList<>();\r\n }\r\n\r\n /*\r\n * push an element at top (remember, a stack is "Last In First Out")\r\n */\r\n public void push(E elem) {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Return the top of the stack AND remove the retrieved element\r\n */\r\n public E pop() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Return the top element of the stack, without removing it\r\n */\r\n public E peek() {\r\n //TODO\r\n }\r\n\r\n /*\r\n * Tells if the stack is empty or not\r\n */\r\n public boolean empty() {\r\n //TODO\r\n }
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -2944,7 +2948,7 @@
},
{
"title": "Dealing with Streams",
- "description": "Given the [Student](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams/Student.java) class, You\r\nare asked to write the implementation of the\r\n[StudentFunctions](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams/StudentFunctions.java) class\r\n( that implements the\r\n[StudentStreamFunction](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams/StudentStreamFunction.java)\r\ninterface ) :\r\n\r\n``` java\r\nimport java.util.stream.Stream;\r\n\r\npublic interface StudentStreamFunction {\r\n\r\n // Find the N°2 and N°3 top students for the given course name in parameter\r\n public Stream findSecondAndThirdTopStudentForGivenCourse(\r\n Stream studentStream, String name);\r\n\r\n // Compute for each student in the given section their average grade result,\r\n // sorted by their result (ascending) as an array of array structured like that :\r\n // [ [\"Student FirstName1 LastName1\", 7.5], [\"Student FirstName2 LastName2\", 9.5] ]\r\n public Object[] computeAverageForStudentInSection(Stream studentStream,\r\n int section);\r\n\r\n // Give the number of students that success in all courses (> 10.0)\r\n public int getNumberOfSuccessfulStudents(Stream studentStream);\r\n\r\n // Find the student that is the last one in the lexicographic order\r\n // ( You must first compare students on their lastNames then on their firstNames )\r\n public Student findLastInLexicographicOrder(Stream studentStream);\r\n\r\n\r\n // Give the full sum of the grade obtained by all students\r\n public double getFullSum(Stream studentStream);\r\n\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams/LEPL1402_Streams.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
import java.util.stream.Stream;\r\n\r\npublic interface StudentStreamFunction {\r\n\r\n // Find the N°2 and N°3 top students for the given course name in parameter\r\n public Stream<Student> findSecondAndThirdTopStudentForGivenCourse(\r\n Stream<Student> studentStream, String name);\r\n\r\n // Compute for each student in the given section their average grade result,\r\n // sorted by their result (ascending) as an array of array structured like that :\r\n // [ ["Student FirstName1 LastName1", 7.5], ["Student FirstName2 LastName2", 9.5] ]\r\n public Object[] computeAverageForStudentInSection(Stream<Student> studentStream,\r\n int section);\r\n\r\n // Give the number of students that success in all courses (> 10.0)\r\n public int getNumberOfSuccessfulStudents(Stream<Student> studentStream);\r\n\r\n // Find the student that is the last one in the lexicographic order\r\n // ( You must first compare students on their lastNames then on their firstNames )\r\n public Student findLastInLexicographicOrder(Stream<Student> studentStream);\r\n\r\n\r\n // Give the full sum of the grade obtained by all students\r\n public double getFullSum(Stream<Student> studentStream);\r\n\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3003,7 +3007,7 @@
},
{
"title": "Dealing with Streams - 2",
- "description": "In order to understand why the Stream class could be useful for\r\ngenericity, we purpose you this small exercise that merged casting and\r\nstreams.\r\n\r\nGiven the [Student](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams2/Student.java) class, You\r\nare asked to write the implementation of the\r\n[StudentFunctions](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams/StudentFunctions.java) class\r\n( that implements the\r\n[StudentStreamFunction](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams2/StudentStreamFunction.java)\r\ninterface ) :\r\n\r\n``` java\r\nimport java.util.Map;\r\nimport java.util.function.Predicate;\r\nimport java.util.stream.Stream;\r\nimport java.util.Comparator;\r\n\r\npublic interface StudentStreamFunction {\r\n\r\n// In order to test efficiently your code, we use a Map>\r\n// structured like that :\r\n// Key : String that is one of the fields of Student\r\n// ( \"firstName\", \"lastName\", \"section\", \"courses_results\")\r\n// Value : Predicate bounded to the type of the field to perform a check condition\r\n//\r\n// For example :\r\n// Key: \"firstName\"\r\n// Value: Predicate\r\n\r\n\r\n// Returns a student if any match the given conditions\r\n// if it is not possible, you must return null\r\npublic Student findFirst(Stream studentsStream,\r\n Map> conditions);\r\n\r\n// Returns a array of student(s) that match the given conditions\r\npublic Student[] findAll(Stream studentsStream,\r\n Map> conditions);\r\n\r\n// Return true if we could find n student(s) that match the given condition\r\npublic boolean exists(Stream studentsStream,\r\n Map> conditions,\r\n int n);\r\n\r\n// Returns a ordered array of student(s) that match the given conditions,\r\n// depending of the given comparator\r\npublic Student[] filterThenSort(Stream studentsStream,\r\n Map> conditions,\r\n Comparator comparator);\r\n\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Streams2/LEPL1402_Streams2.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
In order to understand why the Stream class could be useful for genericity, we purpose you this small exercise that merged casting and streams.
import java.util.Map;\r\nimport java.util.function.Predicate;\r\nimport java.util.stream.Stream;\r\nimport java.util.Comparator;\r\n\r\npublic interface StudentStreamFunction {\r\n\r\n// In order to test efficiently your code, we use a Map<String, Predicate<?>>\r\n// structured like that :\r\n// Key : String that is one of the fields of Student\r\n// ( "firstName", "lastName", "section", "courses_results")\r\n// Value : Predicate bounded to the type of the field to perform a check condition\r\n//\r\n// For example :\r\n// Key: "firstName"\r\n// Value: Predicate<String>\r\n\r\n\r\n// Returns a student if any match the given conditions\r\n// if it is not possible, you must return null\r\npublic Student findFirst(Stream<Student> studentsStream,\r\n Map<String, Predicate<?>> conditions);\r\n\r\n// Returns a array of student(s) that match the given conditions\r\npublic Student[] findAll(Stream<Student> studentsStream,\r\n Map<String, Predicate<?>> conditions);\r\n\r\n// Return true if we could find n student(s) that match the given condition\r\npublic boolean exists(Stream<Student> studentsStream,\r\n Map<String, Predicate<?>> conditions,\r\n int n);\r\n\r\n// Returns a ordered array of student(s) that match the given conditions,\r\n// depending of the given comparator\r\npublic Student[] filterThenSort(Stream<Student> studentsStream,\r\n Map<String, Predicate<?>> conditions,\r\n Comparator<Student> comparator);\r\n\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3062,7 +3066,7 @@
},
{
"title": "Strings",
- "description": "In this task, we ask you to implement several common methods inspired\r\nfrom java's\r\n[String](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#subSequence-int-int-)\r\nAPI. The objective of this task is to get you used to String\r\nmanipulation in java. In order to succeed this task, you will have to\r\nimplement four different methods from a class we called `StringUtils` :\r\n\r\n- `split(String str, char marker)` : separate a String into fragments\r\n each time a specific character `marker` is encountered. Note that,\r\n for simplicity, marker is a `char` whereas in java's\r\n [String](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#subSequence-int-int-)\r\n it is a `String`. For example, calling your method with \"Here. I.\r\n Go.\" with marker '.' should return an array of size three with\r\n \"Here\", \"I\" and \"Go\" in its cells.\r\n- `indexOf(String str, String sub)` : returns the index of the first\r\n occurrence of the `String` sub in the `String` str. For example\r\n `indexOf(\"Hello\", \"ell\")` should return 1, `indexOf(\"Hello\", \"o\")`\r\n should return 4. If there is no occurrence of sub in str, return -1.\r\n- `toLowerCase(String str)` : returns a String with the same\r\n characters as 'str' except that all upper case characters have been\r\n replaced by their lower case equivalent.\r\n- `palindrome(String str)` : Returns true if the string 'str' is a\r\n palindrome : a string that reads the same from left to right AND\r\n from right to left (for example, \"kayak\"). Note that this method\r\n does not exist in java's\r\n [String](https://docs.oracle.com/javase/8/docs/api/java/lang/String.html#subSequence-int-int-)\r\n API because it's not very useful. But it is still a good exercise to\r\n train yourself to manipulate String objects in java.\r\n\r\nHere is the skeleton of the `StringUtils` (downloadable\r\n[here](https://inginious.info.ucl.ac.be/course/LEPL1402/StringUtils/StringUtils.java)):\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/StringUtils/LEPL1402_StringUtils.zip) that\r\ncontains few tests to help you.\r\n\r\n``` java\r\npublic class StringUtils {\r\n\r\n\r\n /*\r\n * Split the input string 'str' w.r.t the character 'marker' in an array of String\r\n * for example split(\"test-test\", '-') => {\"test\", \"test\"}\r\n * Must return null if there is no occurrence of 'marker' in 'str'\r\n */\r\n public static String [] split(String str, char marker){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Returns the index of the first occurrence of sub in str\r\n * or -1 if there is no occurrence of sub in str at all.\r\n * Be careful, we ask you to make CASE SENSITIVE comparison between str and sub.\r\n */\r\n public static int indexOf(String str, String sub){\r\n // YOUR CODE HERE\r\n }\r\n\r\n /*\r\n * Returns a String with the same characters as 'str' except that\r\n * all upper case characters have been replaced by their lower case equivalent.\r\n */\r\n public static String toLowerCase(String str){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Returns true if the string 'str' is a palindrome (a string that reads the same from\r\n * left to right AND from right to left).\r\n */\r\n public static boolean palindrome(String str){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task, we ask you to implement several common methods inspired from java's String API. The objective of this task is to get you used to String manipulation in java. In order to succeed this task, you will have to implement four different methods from a class we called StringUtils :
\r\n
\r\n
split(String str, char marker) : separate a String into fragments each time a specific character marker is encountered. Note that, for simplicity, marker is a char whereas in java's String it is a String. For example, calling your method with \"Here. I. Go.\" with marker '.' should return an array of size three with \"Here\", \"I\" and \"Go\" in its cells.
\r\n
indexOf(String str, String sub) : returns the index of the first occurrence of the String sub in the String str. For example indexOf(\"Hello\", \"ell\") should return 1, indexOf(\"Hello\", \"o\") should return 4. If there is no occurrence of sub in str, return -1.
\r\n
toLowerCase(String str) : returns a String with the same characters as 'str' except that all upper case characters have been replaced by their lower case equivalent.
\r\n
palindrome(String str) : Returns true if the string 'str' is a palindrome : a string that reads the same from left to right AND from right to left (for example, \"kayak\"). Note that this method does not exist in java's String API because it's not very useful. But it is still a good exercise to train yourself to manipulate String objects in java.
\r\n
\r\n
Here is the skeleton of the StringUtils (downloadable here):
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
public class StringUtils {\r\n\r\n\r\n /*\r\n * Split the input string 'str' w.r.t the character 'marker' in an array of String\r\n * for example split("test-test", '-') => {"test", "test"}\r\n * Must return null if there is no occurrence of 'marker' in 'str'\r\n */\r\n public static String [] split(String str, char marker){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Returns the index of the first occurrence of sub in str\r\n * or -1 if there is no occurrence of sub in str at all.\r\n * Be careful, we ask you to make CASE SENSITIVE comparison between str and sub.\r\n */\r\n public static int indexOf(String str, String sub){\r\n // YOUR CODE HERE\r\n }\r\n\r\n /*\r\n * Returns a String with the same characters as 'str' except that\r\n * all upper case characters have been replaced by their lower case equivalent.\r\n */\r\n public static String toLowerCase(String str){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n /*\r\n * Returns true if the string 'str' is a palindrome (a string that reads the same from\r\n * left to right AND from right to left).\r\n */\r\n public static boolean palindrome(String str){\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3121,7 +3125,7 @@
},
{
"title": "Small introduction to threads - Counters",
- "description": "In this task, we will ask you to implement the `init` method of this\r\n[Launcher](https://inginious.info.ucl.ac.be/course/LEPL1402/ThreadsIntroduction/Launcher.java) class :\r\n\r\n``` java\r\npublic class Launcher {\r\n\r\n /*\r\n * Instantiate and start each thread from \"t\" with its OWN Counter object,\r\n * then wait for all threads to finish and return the set of Counter objects\r\n * the threads ran on. Each thread must be named according to its index in the\r\n * \"t\" array.\r\n */\r\n public static Counter[] init(Thread [] t) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n}\r\n```\r\n\r\nIn Java, a thread needs an entry point to know where to start when we\r\nwant it to run : this entry point can be any object implementing the\r\n[Runnable](https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)\r\ninterface. For this exercise, we give you a small implementation of the\r\n[Runnable](https://docs.oracle.com/javase/8/docs/api/java/lang/Runnable.html)\r\ninterface :\r\n[Counter](https://inginious.info.ucl.ac.be/course/LEPL1402/ThreadsIntroduction/Counter.java), a small\r\nclass increasing an int variable `rnd` times.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/ThreadsIntroduction/LEPL1402_ThreadsIntroduction.zip)\r\nthat contains few tests to help you.\r\n\r\n``` java\r\npublic class Counter implements Runnable {\r\n\r\n private int count;\r\n private int rnd;\r\n\r\n public int getCount() {\r\n return count;\r\n }\r\n\r\n public int getRnd(){\r\n return rnd;\r\n }\r\n\r\n public Counter(){\r\n this.count = 0;\r\n this.rnd = (int) ( (Math.random()*100) + 1000);\r\n }\r\n\r\n @Override\r\n public void run() {\r\n for(int i=0; i< getRnd(); i++){\r\n count += 1;\r\n }\r\n }\r\n\r\n}\r\n```\r\n",
+ "description": "
In this task, we will ask you to implement the init method of this Launcher class :
\r\n
public class Launcher {\r\n\r\n /*\r\n * Instantiate and start each thread from "t" with its OWN Counter object,\r\n * then wait for all threads to finish and return the set of Counter objects\r\n * the threads ran on. Each thread must be named according to its index in the\r\n * "t" array.\r\n */\r\n public static Counter[] init(Thread [] t) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n}
\r\n
In Java, a thread needs an entry point to know where to start when we want it to run : this entry point can be any object implementing the Runnable interface. For this exercise, we give you a small implementation of the Runnable interface : Counter, a small class increasing an int variable rnd times.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n
public class Counter implements Runnable {\r\n\r\n private int count;\r\n private int rnd;\r\n\r\n public int getCount() {\r\n return count;\r\n }\r\n\r\n public int getRnd(){\r\n return rnd;\r\n }\r\n\r\n public Counter(){\r\n this.count = 0;\r\n this.rnd = (int) ( (Math.random()*100) + 1000);\r\n }\r\n\r\n @Override\r\n public void run() {\r\n for(int i=0; i< getRnd(); i++){\r\n count += 1;\r\n }\r\n }\r\n\r\n}
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3180,7 +3184,7 @@
},
{
"title": "Binary trees - combineWith",
- "description": "Write a method combineWith that could be added to the\r\n[Tree](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeCombineWith/Tree.java) class (Node class can\r\nbe found [here](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeCombineWith/Node.java)).\r\n\r\nThe method accepts another binary tree of integers as a parameter and\r\ncombines the two trees into a new third tree which is returned. The new\r\ntree's structure should be a union of the structures of the two original\r\ntrees.\r\n\r\nIt should have a node in any location where there was a node in either\r\nof the original trees (or both).\r\n\r\nThe nodes of the new tree should store an integer indicating the sum of\r\nthe values at that position of the original trees if possible. (else\r\nonly the value of the not null node)\r\n\r\nFor example, suppose Tree variables t1 and t2 have been initialized and\r\nstore the following trees:\r\n\r\n\r\n\r\n\r\n\r\nThen the following call:\r\n\r\n``` java\r\nTree t3 = t1.combineWith(t2);\r\n```\r\n\r\nWill return a reference to the following tree:\r\n\r\n\r\n\r\n\r\n\r\nYou may define private helper methods to solve this problem but in any\r\ncase, your method should not change the structure or contents of either\r\nof the two trees being compared.\r\n\r\n(This exercise was partialy inspired by this\r\n[source](https://practiceit.cs.washington.edu/problem/view/cs2/exams/finals/final4/combineWith))\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeCombineWith/LEPL1402_TreeCombineWith.zip)\r\nthat contains few tests to help you.\r\n",
+ "description": "
Write a method combineWith that could be added to the Tree class (Node class can be found here).
\r\n
The method accepts another binary tree of integers as a parameter and combines the two trees into a new third tree which is returned. The new tree's structure should be a union of the structures of the two original trees.
\r\n
It should have a node in any location where there was a node in either of the original trees (or both).
\r\n
The nodes of the new tree should store an integer indicating the sum of the values at that position of the original trees if possible. (else only the value of the not null node)
\r\n
For example, suppose Tree variables t1 and t2 have been initialized and store the following trees:
\r\n\r\n\r\n\r\n
Then the following call:
\r\n
Tree t3 = t1.combineWith(t2);
\r\n
Will return a reference to the following tree:
\r\n\r\n\r\n\r\n
You may define private helper methods to solve this problem but in any case, your method should not change the structure or contents of either of the two trees being compared.
\r\n
(This exercise was partialy inspired by this source)
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3239,7 +3243,7 @@
},
{
"title": "Binary trees - Inorder traversal",
- "description": "In this task, we ask you to implement two different version of an\r\n\"in-order\" tree traversal : a recursive version and an iterative\r\nversion. Both function will take a `Node` representing the root of the\r\ntree itself and a `List` that you have to fill with the tree\r\nnodes' `val` respecting the \"in-order\" traversal.\r\n\r\n**Example**: the following tree, when explored in an in-order fashion,\r\nwill give `A,B,C,D,E,F,G,H,I`. This type of tree traversal is thus very\r\nuseful to retrieve all nodes from a tree as an ordered list, provided\r\nthat the tree itself is \"sorted\", i.e, for each node, its left subtree\r\nonly contain \"smaller\" nodes and its right subtree only contain\r\n\"greater\" nodes (which is the case in the example, considering the\r\nalphabetical order).\r\n\r\n\r\n\r\nHere are the skeleton of the\r\n[Node](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/Node.java) and\r\n[Traversal](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/Traversal.java) classes:\r\n\r\n``` java\r\npublic class Node {\r\n\r\n public int val;\r\n\r\n public Node left;\r\n public Node right;\r\n\r\n public Node(int val){\r\n this.val = val;\r\n }\r\n\r\n public boolean isLeaf(){\r\n return this.left == null && this.right == null;\r\n }\r\n}\r\n\r\n\r\nimport java.util.List;\r\nimport java.util.Stack; // this should give you a hint for the iterative version\r\n\r\npublic class Traversal {\r\n\r\n public static void recursiveInorder(Node root, List res) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public static void iterativeInorder(Node root, List res){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/LEPL1402_TreeInorder.zip) that\r\ncontains few tests to help you.\r\n",
+ "description": "
In this task, we ask you to implement two different version of an \"in-order\" tree traversal : a recursive version and an iterative version. Both function will take a Node representing the root of the tree itself and a List<Integer> that you have to fill with the tree nodes' val respecting the \"in-order\" traversal.
\r\n
Example: the following tree, when explored in an in-order fashion, will give A,B,C,D,E,F,G,H,I. This type of tree traversal is thus very useful to retrieve all nodes from a tree as an ordered list, provided that the tree itself is \"sorted\", i.e, for each node, its left subtree only contain \"smaller\" nodes and its right subtree only contain \"greater\" nodes (which is the case in the example, considering the alphabetical order).
\r\n
\r\n
Here are the skeleton of the Node and Traversal classes:
\r\n
public class Node {\r\n\r\n public int val;\r\n\r\n public Node left;\r\n public Node right;\r\n\r\n public Node(int val){\r\n this.val = val;\r\n }\r\n\r\n public boolean isLeaf(){\r\n return this.left == null && this.right == null;\r\n }\r\n}\r\n\r\n\r\nimport java.util.List;\r\nimport java.util.Stack; // this should give you a hint for the iterative version\r\n\r\npublic class Traversal {\r\n\r\n public static void recursiveInorder(Node root, List<Integer> res) {\r\n // YOUR CODE HERE\r\n }\r\n\r\n\r\n public static void iterativeInorder(Node root, List<Integer> res){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3298,7 +3302,7 @@
},
{
"title": "Binary trees - equals",
- "description": "In this task, we will ask you to implement the mehtod `equals(Object o)`\r\nfor both classes [Tree](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeSame/Tree.java) and\r\n[Node](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeSame/Node.java). Two instances of `Tree` are\r\nconsidered equal when they both have the exact same structure (same\r\nnumber of nodes, each node at the same place in **both** trees) and when\r\nevery node has the same `val`. Here are the skeleton of both classes:\r\n\r\n``` java\r\npublic class Node {\r\n\r\n public int val;\r\n public Node left;\r\n public Node right;\r\n\r\n public Node(int val){\r\n this.val = val;\r\n }\r\n\r\n public boolean isLeaf(){\r\n return this.left == null && this.right == null;\r\n }\r\n\r\n @Override\r\n public boolean equals(Object o){\r\n // YOUR CODE HERE\r\n }\r\n}\r\n\r\npublic class Tree {\r\n\r\n public Node root;\r\n\r\n public Tree(Node root){\r\n this.root = root;\r\n }\r\n\r\n @Override\r\n public boolean equals(Object o){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeSame/LEPL1402_TreeSame.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
In this task, we will ask you to implement the mehtod equals(Object o) for both classes Tree and Node. Two instances of Tree are considered equal when they both have the exact same structure (same number of nodes, each node at the same place in both trees) and when every node has the same val. Here are the skeleton of both classes:
\r\n
public class Node {\r\n\r\n public int val;\r\n public Node left;\r\n public Node right;\r\n\r\n public Node(int val){\r\n this.val = val;\r\n }\r\n\r\n public boolean isLeaf(){\r\n return this.left == null && this.right == null;\r\n }\r\n\r\n @Override\r\n public boolean equals(Object o){\r\n // YOUR CODE HERE\r\n }\r\n}\r\n\r\npublic class Tree {\r\n\r\n public Node root;\r\n\r\n public Tree(Node root){\r\n this.root = root;\r\n }\r\n\r\n @Override\r\n public boolean equals(Object o){\r\n // YOUR CODE HERE\r\n }\r\n\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3357,7 +3361,7 @@
},
{
"title": "Longest Valley",
- "description": "A geologist is trying to find the deepest valley and the biggest\r\nmountain between 2 locations and he thinks you can help him! He'll give\r\nyou an array of integer like this one:\r\n\r\n\r\n\r\nThe negative values mean the slope is negative and the positive ones\r\nmean it's positive. Thus previous array looks like this:\r\n\r\n\r\n\r\nYour method will return an array containing the depth of the deepest\r\nvalley at index 0 and the biggest mountain at index 1. In this example,\r\nthe depth is 5 and the summit is at 3.\r\n\r\nWe can define a valley by saying it is sequence of negative number\r\nfollowed by a sequence of positive number with the same amount of\r\nnumbers. The depth is the length of the sequence.\r\n\r\nHere is the mathematical definition:\r\n\r\nGiven *A* an Array of integer ∀*i*, 0 ≤ *i* < |*A*|,*A*\\[*i*\\] ≠ 0,\r\nGiven *v* the length of the longest valley, ∃!*i*, *j* with\r\n0 ≤ *i* < *j* ≤ |*A*| so that ∀*m* , *i* ≤ *m* < (*j* − *i*)/2 ,\r\n*A*\\[*m*\\] < 0 and ∀*n* , (*j* − *i*)/2 < *m* ≤ *j* ,\r\n*A*\\[*n*\\] > 0 , *j* − *i* > *v* \\* 2\r\n\r\nWe can define a mountain by saying it is sequence of positive number\r\nfollowed by a sequence of negative number with the same amount of\r\nnumbers. The height is the length of the sequence.\r\n\r\nHere is the mathematical definition:\r\n\r\nGiven *A* an Array of integer ∀*i*, 0 ≤ *i* < |*A*|,*A*\\[*i*\\] ≠ 0,\r\nGiven *v* the length of the longest valley, ∃!*i*, *j* with\r\n0 ≤ *i* < *j* ≤ |*A*| so that ∀*m* , *i* ≤ *m* < (*j* − *i*)/2 ,\r\n*A*\\[*m*\\] > 0 and ∀*n* , (*j* − *i*)/2 < *m* ≤ *j* ,\r\n*A*\\[*n*\\] < 0 , *j* − *i* > *v* \\* 2\r\n\r\nConsider that the array is never gonna be empty and your method should\r\nhave a theta(n) complexity Here is the class you have to fill:\r\n\r\n``` java\r\npublic class Valley{\r\n /*\r\n * Example:\r\n * [1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1]\r\n * Should return\r\n * [5, 3]\r\n */\r\n\r\n public static int[] valley ( int[] array){\r\n //TODO By Student\r\n\r\n }\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/valley/LEPL1402_valley.zip) that contains few\r\ntests to help you.\r\n",
+ "description": "
A geologist is trying to find the deepest valley and the biggest mountain between 2 locations and he thinks you can help him! He'll give you an array of integer like this one:
\r\n
\r\n
The negative values mean the slope is negative and the positive ones mean it's positive. Thus previous array looks like this:
\r\n
\r\n
Your method will return an array containing the depth of the deepest valley at index 0 and the biggest mountain at index 1. In this example, the depth is 5 and the summit is at 3.
\r\n
We can define a valley by saying it is sequence of negative number followed by a sequence of positive number with the same amount of numbers. The depth is the length of the sequence.
\r\n
Here is the mathematical definition:
\r\n
Given A an Array of integer ∀i, 0 ≤ i < |A|,A[i] ≠ 0, Given v the length of the longest valley, ∃!i, j with 0 ≤ i < j ≤ |A| so that ∀m , i ≤ m < (j − i)/2 , A[m] < 0 and ∀n , (j − i)/2 < m ≤ j , A[n] > 0 , j − i > v * 2
\r\n
We can define a mountain by saying it is sequence of positive number followed by a sequence of negative number with the same amount of numbers. The height is the length of the sequence.
\r\n
Here is the mathematical definition:
\r\n
Given A an Array of integer ∀i, 0 ≤ i < |A|,A[i] ≠ 0, Given v the length of the longest valley, ∃!i, j with 0 ≤ i < j ≤ |A| so that ∀m , i ≤ m < (j − i)/2 , A[m] > 0 and ∀n , (j − i)/2 < m ≤ j , A[n] < 0 , j − i > v * 2
\r\n
Consider that the array is never gonna be empty and your method should have a theta(n) complexity Here is the class you have to fill:
\r\n
public class Valley{\r\n /*\r\n * Example:\r\n * [1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1]\r\n * Should return\r\n * [5, 3]\r\n */\r\n\r\n public static int[] valley ( int[] array){\r\n //TODO By Student\r\n\r\n }\r\n}
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3416,7 +3420,7 @@
},
{
"title": "Value Or Reference",
- "description": "Try to answer the following question without actually testing the shown\r\ncode on your computer.\r\n",
+ "description": "
Try to answer the following question without actually testing the shown code on your computer.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3470,7 +3474,7 @@
},
{
"title": "Visitor design pattern - Calculator",
- "description": "In this task, we will ask you to implement a basic calculator (+,-,\\*,/)\r\nusing the visitor design pattern. Every expression you will compute will\r\nbe represented as a tree. A tree contains at least one node and every\r\nnode of the tree is either :\r\n\r\n- a parent node containing two sub nodes (an operand)\r\n- a leaf (a value)\r\n\r\nHere is an example of how your code is supposed to run:\r\n\r\n``` java\r\nNode root = new Add( //((6-2)/(1+1))+(5*2)\r\n new Div( //(6-2)/(1+1)\r\n new Sub(new Leaf(6),new Leaf(2)) //6-2\r\n new Add(new Leaf(1), new Leaf(1))), //1+1\r\n new Mult(new Leaf(5), new Leaf(2))); //5*2\r\nVisitor calculator = new Evaluation();\r\n\r\ncalculator.visit((Add)root); // 12\r\n```\r\n\r\n**We provide you a set of class you have to complete**\r\n[here](https://inginious.info.ucl.ac.be/course/LEPL1402/Visitor/source.zip)\r\n\r\nThere are a lot of classes but please don't panick, this exercise\r\nshouldn't require more than 50ish lines of code from you.\r\n\r\nA special case needs you to throw an `IllegalArgumentException`.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/Visitor/LEPL1402_Visitor.zip) that contains\r\nfew tests to help you.\r\n",
+ "description": "
In this task, we will ask you to implement a basic calculator (+,-,*,/) using the visitor design pattern. Every expression you will compute will be represented as a tree. A tree contains at least one node and every node of the tree is either :
\r\n
\r\n
a parent node containing two sub nodes (an operand)
\r\n
a leaf (a value)
\r\n
\r\n
Here is an example of how your code is supposed to run:
\r\n
Node root = new Add( //((6-2)/(1+1))+(5*2)\r\n new Div( //(6-2)/(1+1)\r\n new Sub(new Leaf(6),new Leaf(2)) //6-2\r\n new Add(new Leaf(1), new Leaf(1))), //1+1\r\n new Mult(new Leaf(5), new Leaf(2))); //5*2\r\nVisitor calculator = new Evaluation();\r\n\r\ncalculator.visit((Add)root); // 12
\r\n
We provide you a set of class you have to completehere
\r\n
There are a lot of classes but please don't panick, this exercise shouldn't require more than 50ish lines of code from you.
\r\n
A special case needs you to throw an IllegalArgumentException.
\r\n
You can download the IntelliJ Project that contains few tests to help you.
\r\n",
"tags": [
{
"text": "INGINIOUS",
@@ -3529,7 +3533,7 @@
},
{
"title": "Visitor design pattern - List Filtering",
- "description": "In this task, we will ask you to implement a list filtering using the\r\nvisitor design pattern. More precisely, your visitor will need to\r\ntraverse a list full of objects of different kind. At the end of its\r\ntraversal, your observer should have a filtered list containing only\r\n`Integer` elements from the original list. To succeed this task, you'll\r\nhave to give us the implementation of these two classes :\r\n\r\n``` java\r\npublic class VisitorList extends Visitor {\r\n // YOUR CODE HERE\r\n}\r\n\r\npublic class VisitableList extends Visitable {\r\n // YOUR CODE HERE\r\n}\r\n```\r\n\r\nThese two classes must extends\r\n[Visitable](https://inginious.info.ucl.ac.be/course/LEPL1402/VisitorBasic/Visitable.java) and\r\n[Visitor](https://inginious.info.ucl.ac.be/course/LEPL1402/VisitorBasic/Visitor.java). These are\r\nabstract classes, pay attention to implement all abstract methods these\r\nclasses contain.\r\n\r\nHere is an example of how your code is supposed to run:\r\n\r\n``` java\r\nVisitor visitor = new VisitorList(Integer.class);\r\nVisitable visitable = new VisitableList(new Object[]{1, 2, 3, 3.1, 4, \"HELLO\"});\r\n\r\nvisitor.visit(visitable);\r\n\r\nList
![\"image\"](\"https://upload.wikimedia.org/wikipedia/commons/d/df/Circularly-linked-list.svg\")
![\"image\"](\"https://inginious.info.ucl.ac.be/course/LSINF1252/BST/bst.png\")
\r\n\r\nThis binary tree is composed of nodes implemented using the following\r\nstructure.\r\n\r\n``` c\r\n/*\r\n* Node has a value, @value, and two children, @left and @right.\r\n* All the children of @left and itself have a smaller value than the node and all the children of @right and itself have a larger value than node\r\n*/\r\ntypedef struct node{\r\n int value;\r\n struct node* left; // to smaller values\r\n struct node* right; // to larger values\r\n} node_t;\r\n```\r\n\r\nThe binary tree itself is defined as follows.\r\n\r\n``` c\r\ntypedef struct bt{\r\n struct node* root;\r\n} bt_t;\r\n```\r\n",
+ "description": "![\"image\"](\"https://inginious.info.ucl.ac.be/course/LSINF1252/PC/buffer.png\")
![\"image\"](\"https://upload.wikimedia.org/wikipedia/commons/b/b4/Lifo_stack.png\")
\r\n\r\n*Hints* :\r\n\r\n- `char *name` is also a pointer, memory must be allocated by using\r\n [malloc(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/malloc.3.html)\r\n to copy the string on the stack.\r\n- Other useful commands:\r\n [strncpy(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strncpy.3.html)\r\n and\r\n [strlen(3)](https://sites.uclouvain.be/SystInfo/manpages/man3/strlen.3.html).\r\n- Do not forget to free **all** the allocated space when popping one\r\n element.\r\n",
+ "description": "![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/AbstractClass/AbstractClass.jpg\")
\r\n![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/BoundedBuffer/BoundedBuffer.png\")
\r\n\r\nBefore submitting don't hesitate to create a producer and a consumer and\r\nto test your code.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/BoundedBuffer/LEPL1402_BoundedBuffer.zip):\r\n",
+ "description": "![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/CircularLL/CircularLinkedList.png\")
\r\n![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/CodeAccuracy2/quicksort-overview.png\")
\r\n![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/CodeAccuracy2/partitioning-overview.png\")
\r\n![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/complexityMCQ2/binaryTree.png\")
\r\n\r\nThe rest of the questions are harder question about the time complexity\r\nof operations on list and arrays. Some questions will be about simple\r\nlinked list, other about double linked list and some about circular\r\nlinked list.\r\n",
+ "description": "![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/Generics3/full-adder-circuit.png\")
\r\n![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/tower-of-hanoi.png\")
\r\n\r\nIn this exercise, you are asked to solve this puzzle for any size of\r\nstack by implementing this method and this method only! We are using\r\n[Stack](https://docs.oracle.com/javase/8/docs/api/java/util/Stack.html),\r\nto get the first element of a stack, use the method `pop`, and to add an\r\nelement use the method `push`. The object\r\n[Disk](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/Disk.java) is here to make sure you\r\nwill not solve the exercise by just creating another stack.\r\n\r\nHere is the class\r\n[TowerOfHanoi](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/TowerOfHanoi.java) you must\r\nimplement, you can create disk by yourself to test your method but it\r\nwill not compile on Inginious if you try to do it.\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/HanoiTower/LEPL1402_HanoiTower.zip) that\r\ncontains few tests to help you.\r\n\r\n**hint:** you can call `towerOfHanoi` inside itself\r\n",
+ "description": "![top-down](\"https://inginious.info.ucl.ac.be/course/LEPL1402/MergeSortImplementation/topdown.png\"){kind=link}
![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/MyArrayList/before.png\")
\r\n![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/MyArrayList/after.png\")
\r\n![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/TreeCombineWith/example-part1.png\")
\r\n![\"\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/TreeCombineWith/example-part2.png\")
\r\n![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/inorder.png\")
\r\n\r\nHere are the skeleton of the\r\n[Node](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/Node.java) and\r\n[Traversal](https://inginious.info.ucl.ac.be/course/LEPL1402/TreeInorder/Traversal.java) classes:\r\n\r\n``` java\r\npublic class Node {\r\n\r\n public int val;\r\n\r\n public Node left;\r\n public Node right;\r\n\r\n public Node(int val){\r\n this.val = val;\r\n }\r\n\r\n public boolean isLeaf(){\r\n return this.left == null && this.right == null;\r\n }\r\n}\r\n\r\n\r\nimport java.util.List;\r\nimport java.util.Stack; // this should give you a hint for the iterative version\r\n\r\npublic class Traversal {\r\n\r\n public static void recursiveInorder(Node root, List![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/valley/arraytest.png\")
\r\n\r\nThe negative values mean the slope is negative and the positive ones\r\nmean it's positive. Thus previous array looks like this:\r\n\r\n![\"image\"](\"https://inginious.info.ucl.ac.be/course/LEPL1402/valley/schema.png\")
\r\n\r\nYour method will return an array containing the depth of the deepest\r\nvalley at index 0 and the biggest mountain at index 1. In this example,\r\nthe depth is 5 and the summit is at 3.\r\n\r\nWe can define a valley by saying it is sequence of negative number\r\nfollowed by a sequence of positive number with the same amount of\r\nnumbers. The depth is the length of the sequence.\r\n\r\nHere is the mathematical definition:\r\n\r\nGiven *A* an Array of integer ∀*i*, 0 ≤ *i* < |*A*|,*A*\\[*i*\\] ≠ 0,\r\nGiven *v* the length of the longest valley, ∃!*i*, *j* with\r\n0 ≤ *i* < *j* ≤ |*A*| so that ∀*m* , *i* ≤ *m* < (*j* − *i*)/2 ,\r\n*A*\\[*m*\\] < 0 and ∀*n* , (*j* − *i*)/2 < *m* ≤ *j* ,\r\n*A*\\[*n*\\] > 0 , *j* − *i* > *v* \\* 2\r\n\r\nWe can define a mountain by saying it is sequence of positive number\r\nfollowed by a sequence of negative number with the same amount of\r\nnumbers. The height is the length of the sequence.\r\n\r\nHere is the mathematical definition:\r\n\r\nGiven *A* an Array of integer ∀*i*, 0 ≤ *i* < |*A*|,*A*\\[*i*\\] ≠ 0,\r\nGiven *v* the length of the longest valley, ∃!*i*, *j* with\r\n0 ≤ *i* < *j* ≤ |*A*| so that ∀*m* , *i* ≤ *m* < (*j* − *i*)/2 ,\r\n*A*\\[*m*\\] > 0 and ∀*n* , (*j* − *i*)/2 < *m* ≤ *j* ,\r\n*A*\\[*n*\\] < 0 , *j* − *i* > *v* \\* 2\r\n\r\nConsider that the array is never gonna be empty and your method should\r\nhave a theta(n) complexity Here is the class you have to fill:\r\n\r\n``` java\r\npublic class Valley{\r\n /*\r\n * Example:\r\n * [1, 1, 1, -1, -1, -1, -1, -1, 1, 1, 1, 1, 1, 1, -1, -1]\r\n * Should return\r\n * [5, 3]\r\n */\r\n\r\n public static int[] valley ( int[] array){\r\n //TODO By Student\r\n\r\n }\r\n}\r\n```\r\n\r\nYou can download the [IntelliJ\r\nProject](https://inginious.info.ucl.ac.be/course/LEPL1402/valley/LEPL1402_valley.zip) that contains few\r\ntests to help you.\r\n",
+ "description": "