Rename year directories to allow natural ordering

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question1/question1.c

@@ -0,0 +1,15 @@
+#include <stdio.h>
+
+int main() {
+    int my_int;
+    int* my_int_pointer;
+    long my_long;
+    double * my_double_pointer;
+    char ** my_char_pointer_pointer;
+
+    printf("The size of my_int is %lu bytes\n", sizeof(my_int));
+    printf("The size of my_int_pointer is %lu bytes\n", sizeof(my_int_pointer));
+    printf("The size of my_long is %lu bytes\n", sizeof(my_long));
+    printf("The size of my_double_pointer is %lu bytes\n", sizeof(my_double_pointer));
+    printf("The size of my_char_pointer_pointer is %lu bytes\n", sizeof(my_char_pointer_pointer));
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CMakeWorkspace" PROJECT_DIR="$PROJECT_DIR$" />
+</project>

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/question2.iml" filepath="$PROJECT_DIR$/.idea/question2.iml" />
+    </modules>
+  </component>
+</project>

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/question2.iml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module classpath="CMake" type="CPP_MODULE" version="4" />

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/assignment-1.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include "linkedList.h"
+#include "tests.h"
+
+int main(int argc, char* argv[]){
+  runTests();
+  return 0;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/linkedList.c

@@ -0,0 +1,162 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "linkedList.h"
+
+typedef struct listElementStruct{
+  char* data;
+  size_t size;
+  struct listElementStruct* next;
+} listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(char* data, size_t size){
+  listElement* e = malloc(sizeof(listElement));
+  if(e == NULL){
+    //malloc has had an error
+    return NULL; //return NULL to indicate an error.
+  }
+  char* dataPointer = malloc(sizeof(char)*size);
+  if(dataPointer == NULL){
+    //malloc has had an error
+    free(e); //release the previously allocated memory
+    return NULL; //return NULL to indicate an error.
+  }
+  strcpy(dataPointer, data);
+  e->data = dataPointer;
+  e->size = size;
+  e->next = NULL;
+  return e;
+}
+
+//Prints out each element in the list
+void traverse(listElement* start){
+  listElement* current = start;
+  while(current != NULL){
+    printf("%s\n", current->data);
+    current = current->next;
+  }
+}
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* el, char* data, size_t size){
+  listElement* newEl = createEl(data, size);
+  listElement* next = el->next;
+  newEl->next = next;
+  el->next = newEl;
+  return newEl;
+}
+
+//Delete the element after the given el
+void deleteAfter(listElement* after){
+  listElement* delete = after->next;
+  listElement* newNext = delete->next;
+  after->next = newNext;
+  //need to free the memory because we used malloc
+  free(delete->data);
+  free(delete);
+}
+
+// returns the number of elements in the list
+int length(listElement* list) {
+    int length = 0;
+    listElement* current = list;
+
+    // traversing the list and counting each element
+    while(current != NULL){
+        length++;
+        current = current->next;
+    }
+
+    return length;
+}
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, char* data, size_t size) {
+    // create the new element
+    listElement* newElement = createEl(data, size);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+}
+
+
+// pop an element from the head of a list and update the list reference using side effects
+// assuming that the desired return value here is the popped element, as is standard for POP operations
+listElement* pop(listElement** list) {
+    // don't bother if list is non existent
+    if (*list == NULL) { return NULL; }
+;  
+    // getting reference to the element to be popped
+    listElement* poppedElement = *list;
+
+    // make the the second element the new head of the list -- this could be NULL, so the list would be NULL also
+    *list = (*list)->next;
+
+    // detach the popped element from the list
+    poppedElement->next = NULL;
+
+    return poppedElement;
+}
+
+
+// enque a new element onto the head of the list and update the list reference using side effects
+// essentially the same as push
+void enqueue(listElement** list, char* data, size_t size) {
+    // create the new element
+    listElement* newElement = createEl(data, size);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+} 
+
+
+// dequeue an element from the tail of the list by removing the element from the list via side effects, and returning the removed item
+// assuming that we want to return the dequeued element rather than the list itself, as enqueue returns nothing and uses side effects, so dequeue should also use side effects
+listElement* dequeue(listElement* list) {
+    // there are three cases that we must consider: a list with 0 elements, a list with 1 element, & a list with >=2 elements
+
+    // don't bother if list is non existent
+    if (list == NULL) { return NULL; }
+
+    // if there is only one element in the list, i.e. the head element is also the tail element, just returning this element
+    // this means that the listElement pointer that was passed to this function won't be updated
+    // ideally, we would set it to NULL but we can't do that since `list` is a pointer that has been passed by value, so we can't update the pointer itself. we would need a pointer to a pointer to have been passed 
+    if (list->next == NULL) {
+        return list;
+    }
+
+    // traversing the list to find the second-to-last element
+    listElement* current = list;
+    while (current->next->next != NULL) {
+        current = current->next;
+    }
+
+    // get reference to the element to be dequeued
+    listElement* dequeuedElement = current->next;
+
+    // make the penultimate element the tail by removing reference to the old tail
+    current->next = NULL;
+
+    return list;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/linkedList.h

@@ -0,0 +1,36 @@
+#ifndef CT331_ASSIGNMENT_LINKED_LIST
+#define CT331_ASSIGNMENT_LINKED_LIST
+
+typedef struct listElementStruct listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(char* data, size_t size);
+
+//Prints out each element in the list
+void traverse(listElement* start);
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* after, char* data, size_t size);
+
+//Delete the element after the given el
+void deleteAfter(listElement* after);
+
+
+// returns the number of elements in the list
+int length(listElement* list);
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, char* data, size_t size);
+
+// pop an element from the head of a list and update the list reference using side effects
+listElement* pop(listElement** list);
+
+// enque a new element onto the head of the list and update the list reference using side effects
+void enqueue(listElement** list, char* data, size_t size);  
+
+// dequeue an element from the tail of the list  
+listElement* dequeue(listElement* list);  
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/tests.c

@@ -0,0 +1,57 @@
+#include <stdio.h>
+#include "tests.h"
+#include "linkedList.h"
+
+void runTests(){
+    printf("Tests running...\n");
+
+    listElement* l = createEl("Test String (1).", sizeof("Test String (1)."));
+    //printf("%s\n%p\n", l->data, l->next);
+    //Test create and traverse
+    traverse(l);
+    printf("\n");
+
+    //Test insert after
+    printf("Testing insertAfter()\n");
+    listElement* l2 = insertAfter(l, "another string (2)", sizeof("another test string(2)"));
+    insertAfter(l2, "a final string (3)", sizeof("a final string(3)"));
+    traverse(l);
+    printf("\n");
+
+    // test length function
+    printf("Testing length()\n");
+    int l_length = length(l);
+    printf("The length of l is %d\n\n", l_length);
+
+    // test push
+    printf("Testing push()\n");
+    push(&l, "yet another test string", sizeof("yet another test string"));
+    traverse(l);
+    printf("\n\n");
+
+    // test pop
+    printf("Testing pop()\n");
+    listElement* popped = pop(&l);
+    traverse(l);
+    printf("\n\n");
+
+    // Test delete after
+    printf("Testing deleteAfter()\n");
+    deleteAfter(l);
+    traverse(l);
+    printf("\n");
+
+    // test enqueue
+    printf("Testing enqueue()\n");
+    enqueue(&l, "enqueued test string", sizeof("enqueued test string"));
+    traverse(l);
+    printf("\n");
+
+    // test dequeue
+    printf("Testing dequeue()\n");
+    dequeue(l);
+    traverse(l);
+    printf("\n");
+
+    printf("\nTests complete.\n");
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/tests.h

@@ -0,0 +1,6 @@
+#ifndef CT331_ASSIGNMENT_TESTS
+#define CT331_ASSIGNMENT_TESTS
+
+void runTests();
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/assignment-1.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include "genericLinkedList.h"
+#include "tests.h"
+
+int main(int argc, char* argv[]){
+  runTests();
+  return 0;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/genericLinkedList.c

@@ -0,0 +1,167 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "genericLinkedList.h"
+
+typedef struct listElementStruct{
+    void* data;
+    void (*printFunction)(void*);
+    size_t size;
+    struct listElementStruct* next;
+} listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(void* data, size_t size, void (*printFunction)(void*)) {
+    listElement* e = malloc(sizeof(listElement));
+    if(e == NULL){
+        //malloc has had an error
+        return NULL; //return NULL to indicate an error.
+    }
+    void* dataPointer = malloc(sizeof(void)*size);
+    if(dataPointer == NULL){
+        //malloc has had an error
+        free(e); //release the previously allocated memory
+        return NULL; //return NULL to indicate an error.
+    }
+    strcpy(dataPointer, data);
+    e->data = dataPointer;
+
+    e->printFunction = printFunction;
+
+    e->size = size;
+    e->next = NULL;
+    return e;
+}
+
+//Prints out each element in the list
+void traverse(listElement* start){
+    listElement* current = start;
+    while(current != NULL){
+        current->printFunction(current->data);
+        // printf("%s\n", current->data);
+        current = current->next;
+    }
+}
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* el, void* data, size_t size, void (*printFunction)(void*)){
+  listElement* newEl = createEl(data, size, printFunction);
+  listElement* next = el->next;
+  newEl->next = next;
+  el->next = newEl;
+  return newEl;
+}
+
+//Delete the element after the given el
+void deleteAfter(listElement* after){
+  listElement* delete = after->next;
+  listElement* newNext = delete->next;
+  after->next = newNext;
+  //need to free the memory because we used malloc
+  free(delete->data);
+  free(delete);
+}
+
+// returns the number of elements in the list
+int length(listElement* list) {
+    int length = 0;
+    listElement* current = list;
+
+    // traversing the list and counting each element
+    while(current != NULL){
+        length++;
+        current = current->next;
+    }
+
+    return length;
+}
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, void* data, size_t size, void (*printFunction)(void*)) {
+    // create the new element
+    listElement* newElement = createEl(data, size, printFunction);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+}
+
+
+// pop an element from the head of a list and update the list reference using side effects
+// assuming that the desired return value here is the popped element, as is standard for POP operations
+listElement* pop(listElement** list) {
+    // don't bother if list is non existent
+    if (*list == NULL) { return NULL; }
+;  
+    // getting reference to the element to be popped
+    listElement* poppedElement = *list;
+
+    // make the the second element the new head of the list -- this could be NULL, so the list would be NULL also
+    *list = (*list)->next;
+
+    // detach the popped element from the list
+    poppedElement->next = NULL;
+
+    return poppedElement;
+}
+
+
+// enque a new element onto the head of the list and update the list reference using side effects
+// essentially the same as push
+void enqueue(listElement** list, void* data, size_t size, void (*printFunction)(void*)) {
+    // create the new element
+    listElement* newElement = createEl(data, size, printFunction);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+} 
+
+
+// dequeue an element from the tail of the list by removing the element from the list via side effects, and returning the removed item
+// assuming that we want to return the dequeued element rather than the list itself, as enqueue returns nothing and uses side effects, so dequeue should also use side effects
+listElement* dequeue(listElement* list) {
+    // there are three cases that we must consider: a list with 0 elements, a list with 1 element, & a list with >=2 elements
+
+    // don't bother if list is non existent
+    if (list == NULL) { return NULL; }
+
+    // if there is only one element in the list, i.e. the head element is also the tail element, just returning this element
+    // this means that the listElement pointer that was passed to this function won't be updated
+    // ideally, we would set it to NULL but we can't do that since `list` is a pointer that has been passed by value, so we can't update the pointer itself. we would need a pointer to a pointer to have been passed 
+    if (list->next == NULL) {
+        return list;
+    }
+
+    // traversing the list to find the second-to-last element
+    listElement* current = list;
+    while (current->next->next != NULL) {
+        current = current->next;
+    }
+
+    // get reference to the element to be dequeued
+    listElement* dequeuedElement = current->next;
+
+    // make the penultimate element the tail by removing reference to the old tail
+    current->next = NULL;
+
+    return list;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/genericLinkedList.h

@@ -0,0 +1,35 @@
+#ifndef CT331_ASSIGNMENT_LINKED_LIST
+#define CT331_ASSIGNMENT_LINKED_LIST
+
+typedef struct listElementStruct listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(void* data, size_t size, void (*printFunction)(void*));
+
+//Prints out each element in the list
+void traverse(listElement* start);
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* after, void* data, size_t size, void (*printFunction)(void*));
+
+//Delete the element after the given el
+void deleteAfter(listElement* after);
+
+// returns the number of elements in the list
+int length(listElement* list);
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, void* data, size_t size, void (*printFunction)(void*));
+
+// pop an element from the head of a list and update the list reference using side effects
+listElement* pop(listElement** list);
+
+// enque a new element onto the head of the list and update the list reference using side effects
+void enqueue(listElement** list, void* data, size_t size, void (*printFunction)(void*));  
+
+// dequeue an element from the tail of the list  
+listElement* dequeue(listElement* list);  
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/tests.c

@@ -0,0 +1,79 @@
+#include <stdio.h>
+#include "tests.h"
+#include "genericLinkedList.h"
+
+// functions to print out different data types
+// a more professional design might be to put these in the genericLinkedList header file but i only need these for testing purposes
+void printChar(void* data) {
+    printf("%c\n", *(char*) data);
+}
+
+void printStr(void* data) {
+    printf("%s\n", (char*) data);
+}
+
+void printInt(void* data) {
+    printf("%d\n", *(int*) data);
+}
+
+void runTests(){
+    printf("Tests running...\n");
+
+    listElement* l = createEl("Test String (1).", sizeof("Test String (1)."), printStr);
+    //printf("%s\n%p\n", l->data, l->next);
+    //Test create and traverse
+    traverse(l);
+    printf("\n");
+
+    //Test insert after
+    printf("Testing insertAfter()\n");
+    listElement* l2 = insertAfter(l, "another string (2)", sizeof("another string (2)"), printStr);
+    insertAfter(l2, "a final string (3)", sizeof("a final string (3)"), printStr);
+    traverse(l);
+    printf("\n");
+
+    // test length function
+    printf("Testing length()\n");
+    int l_length = length(l);
+    printf("The length of l is %d\n\n", l_length);
+
+    // test push
+    printf("Testing push()\n");
+    push(&l, "yet another test string", sizeof("yet another test string"), printStr);
+    traverse(l);
+    printf("\n\n");
+
+    // test pop
+    printf("Testing pop()\n");
+    listElement* popped = pop(&l);
+    traverse(l);
+    printf("\n\n");
+
+    // Test delete after
+    printf("Testing deleteAfter()\n");
+    deleteAfter(l);
+    traverse(l);
+    printf("\n");
+
+    // test enqueue
+    printf("Testing enqueue()\n");
+    enqueue(&l, "enqueued test string", sizeof("enqueued test string"), printStr);
+    traverse(l);
+    printf("\n");
+
+    // test dequeue
+    printf("Testing dequeue()\n");
+    dequeue(l);
+    traverse(l);
+    printf("\n");
+
+    printf("Testing pushing different data types\n");
+    int myint = 42;
+    push(&l, &myint, sizeof(myint), printInt);
+    char mychar = 'c';
+    push(&l, &mychar, sizeof(mychar), printChar);
+    traverse(l);
+    printf("\n\n");
+
+    printf("\nTests complete.\n");
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/tests.h

@@ -0,0 +1,6 @@
+#ifndef CT331_ASSIGNMENT_TESTS
+#define CT331_ASSIGNMENT_TESTS
+
+void runTests();
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/CT331-Assignment-1.tex

@@ -0,0 +1,343 @@
+%! TeX program = lualatex
+\documentclass[a4paper]{article} 
+
+% packages
+\usepackage{microtype}      % Slightly tweak font spacing for aesthetics
+\usepackage[english]{babel} % Language hyphenation and typographical rules
+\usepackage[final, colorlinks = false, urlcolor = cyan]{hyperref} 
+\usepackage{changepage}     % adjust margins on the fly
+\usepackage{fontspec}
+
+\usepackage{minted}
+\usepackage{xcolor}
+
+\usepackage{pgfplots}
+\pgfplotsset{width=\textwidth,compat=1.9}
+
+\usepackage{caption}
+\newenvironment{code}{\captionsetup{type=listing, skip=0pt}}{}
+% \captionsetup{skip=0pt}
+% \setlength{\abovecaptionskip}{3pt}
+% \setlength{\belowcaptionskip}{5pt}
+
+\usepackage[yyyymmdd]{datetime}
+\renewcommand{\dateseparator}{--}
+\setmainfont{EB Garamond}
+\setmonofont[Scale=MatchLowercase]{Deja Vu Sans Mono}
+
+\usepackage{titlesec}
+% \titleformat{\section}{\LARGE\bfseries}{}{}{}[\titlerule]
+% \titleformat{\subsection}{\Large\bfseries}{}{0em}{}
+% \titlespacing{\subsection}{0em}{-0.7em}{0em}
+%
+% \titleformat{\subsubsection}{\large\bfseries}{}{0em}{$\bullet$ }
+% \titlespacing{\subsubsection}{1em}{-0.7em}{0em}
+
+% margins
+\addtolength{\hoffset}{-2.25cm}
+\addtolength{\textwidth}{4.5cm}
+\addtolength{\voffset}{-3.25cm}
+\addtolength{\textheight}{5cm}
+\setlength{\parskip}{0pt}
+\setlength{\parindent}{0in}
+% \setcounter{secnumdepth}{0}
+
+\begin{document}
+\hrule \medskip
+\begin{minipage}{0.295\textwidth} 
+    \raggedright
+    \footnotesize 
+    Name: Andrew Hayes \\
+    E-mail: \href{mailto://a.hayes18@universityofgalway.ie}{\texttt{a.hayes18@universityofgalway.ie}}  \hfill\\   
+    ID: 21321503 \hfill
+\end{minipage}
+\begin{minipage}{0.4\textwidth} 
+    \centering 
+    \vspace{0.4em}
+    \Large 
+    \textbf{CT331} \\ 
+\end{minipage}
+\begin{minipage}{0.295\textwidth} 
+    \raggedleft
+    \today
+\end{minipage}
+\medskip\hrule 
+\begin{center}
+    \normalsize
+    Assignment 1: Procedural Programming with C
+\end{center}
+\hrule
+
+\section{Question 1}
+\subsection{Part (A): Code}
+
+\begin{code}
+\inputminted[texcl, mathescape, linenos, breaklines, frame=single]{C}{../code/question1/question1.c}
+\caption{\texttt{question1.c}}
+\end{code}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.8\textwidth]{./images/question1.png}
+    \caption{Console Output of \texttt{question1.c}}
+\end{figure}
+
+\subsection{Part (B): Comments}
+The amount of memory allocated to variables of different types in C is determined at compile-time, and is dependent on the architecture of 
+the machine for which it is being compiled and the compiler used.
+\begin{itemize}
+    \item   On my machine, using GCC, an \verb|int| is allocated 4 bytes. This is the usual amount allocated on both 32-bit and 64-bit systems (my machine being of the 
+            latter kind), although older 32-bit systems used 2 bytes for an \verb|int| (the same amount as for a \verb|short|). 
+            4 bytes is used even on 64-bit machines to maintain backwards compatibility with older 32-bit architectures.
+    \item   An \verb|int*| (a pointer to a variable of type \verb|int|) is allocated 8 bytes on my machine.
+            This is because that my machine has a 64-bit architecture, and therefore an address in memory is represented using 64 bits (8 bytes).
+            If this were compiled for a 32-bit machine, the size of an pointer would be 4 bytes since addresses are 32-bit.
+    \item   A \verb|long| is allocated 8 bytes on my machine. This is because my machine is 64-bit and a \verb|long| is typically 8 bytes in length on such machines.
+            On 32-bit machines, a \verb|long| is typically 4 bytes.
+    \item   The size of a pointer to a \verb|double| is the same as the size of any other pointer on the same machine; on 64-bit machines, pointers are 8 bytes, and on
+            32-bit machines, they are 4 bytes. 
+            The type of data to which a pointer points has no effect on the size of the pointer, as the pointer is just a memory address.
+    \item   A pointer to a \verb|char| pointer is the same size as any other pointer: 8 bytes on a 64-bit machine and 4 bytes on a 32-bit machine.
+            Note: it might be more intuitive to refer to a ``character pointer pointer'' as a pointer to a string in certain situations, as strings are character arrays,
+            and an array variable acts as a pointer to the first element in the array. 
+\end{itemize}
+
+\section{Question 2}
+\begin{code}
+\begin{minted}[texcl, mathescape, linenos, breaklines, frame=single]{C}
+// returns the number of elements in the list
+int length(listElement* list);
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, char* data, size_t size);
+
+// pop an element from the head of a list and update the list reference using side effects
+listElement* pop(listElement** list);
+
+// enque a new element onto the head of the list and update the list reference using side effects
+void enqueue(listElement** list, char* data, size_t size);  
+
+// dequeue an element from the tail of the list  
+listElement* dequeue(listElement* list);  
+\end{minted}
+\caption{My Additions to \texttt{linkedList.h}}
+\end{code}
+
+\begin{code}
+\begin{minted}[texcl, mathescape, linenos, breaklines, frame=single]{C}
+// returns the number of elements in the list
+int length(listElement* list) {
+    int length = 0;
+    listElement* current = list;
+
+    // traversing the list and counting each element
+    while(current != NULL){
+        length++;
+        current = current->next;
+    }
+
+    return length;
+}
+
+// push a new element onto the head of a list and update the list reference using side effects
+void push(listElement** list, char* data, size_t size) {
+    // create the new element
+    listElement* newElement = createEl(data, size);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+}
+
+
+// pop an element from the head of a list and update the list reference using side effects
+// assuming that the desired return value here is the popped element, as is standard for POP operations
+listElement* pop(listElement** list) {
+    // don't bother if list is non existent
+    if (*list == NULL) { return NULL; }
+;  
+    // getting reference to the element to be popped
+    listElement* poppedElement = *list;
+
+    // make the the second element the new head of the list -- this could be NULL, so the list would be NULL also
+    *list = (*list)->next;
+
+    // detach the popped element from the list
+    poppedElement->next = NULL;
+
+    return poppedElement;
+}
+
+
+// enque a new element onto the head of the list and update the list reference using side effects
+// essentially the same as push
+void enqueue(listElement** list, char* data, size_t size) {
+    // create the new element
+    listElement* newElement = createEl(data, size);
+
+    // handle malloc errors
+    if (newElement == NULL) {
+        fprintf(stderr, "Memory allocation failed.\n");
+        exit(EXIT_FAILURE);
+    }
+
+    // make the the new element point to the current head of the list
+    newElement->next = *list;
+
+    // make the list reference to point to the new head element 
+    *list = newElement;
+} 
+
+
+// dequeue an element from the tail of the list by removing the element from the list via side effects, and returning the removed item
+// assuming that we want to return the dequeued element rather than the list itself, as enqueue returns nothing and uses side effects, so dequeue should also use side effects
+listElement* dequeue(listElement* list) {
+    // there are three cases that we must consider: a list with 0 elements, a list with 1 element, & a list with >=2 elements
+
+    // don't bother if list is non existent
+    if (list == NULL) { return NULL; }
+
+    // if there is only one element in the list, i.e. the head element is also the tail element, just returning this element
+    // this means that the listElement pointer that was passed to this function won't be updated
+    // ideally, we would set it to NULL but we can't do that since `list` is a pointer that has been passed by value, so we can't update the pointer itself. we would need a pointer to a pointer to have been passed 
+    if (list->next == NULL) {
+        return list;
+    }
+
+    // traversing the list to find the second-to-last element
+    listElement* current = list;
+    while (current->next->next != NULL) {
+        current = current->next;
+    }
+
+    // get reference to the element to be dequeued
+    listElement* dequeuedElement = current->next;
+
+    // make the penultimate element the tail by removing reference to the old tail
+    current->next = NULL;
+
+    return list;
+}
+\end{minted}
+\caption{My Additions to \texttt{linkedList.c}}
+\end{code}
+
+\begin{code}
+\begin{minted}[texcl, mathescape, linenos, breaklines, frame=single]{C}
+    // test length function
+    printf("Testing length()\n");
+    int l_length = length(l);
+    printf("The length of l is %d\n\n", l_length);
+
+    // test push
+    printf("Testing push()\n");
+    push(&l, "yet another test string", sizeof("yet another test string"));
+    traverse(l);
+    printf("\n\n");
+
+    // test pop
+    printf("Testing pop()\n");
+    listElement* popped = pop(&l);
+    traverse(l);
+    printf("\n\n");
+
+    // Test delete after
+    printf("Testing deleteAfter()\n");
+    deleteAfter(l);
+    traverse(l);
+    printf("\n");
+
+    // test enqueue
+    printf("Testing enqueue()\n");
+    enqueue(&l, "enqueued test string", sizeof("enqueued test string"));
+    traverse(l);
+    printf("\n");
+
+    // test dequeue
+    printf("Testing dequeue()\n");
+    dequeue(l);
+    traverse(l);
+    printf("\n");
+
+    printf("\nTests complete.\n");
+\end{minted}
+\caption{My Additions to \texttt{tests.c}}
+\end{code}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.9\textwidth]{./images/question2.png}
+    \caption{Console Output for Question 2}
+\end{figure}
+
+\section{Question 3}
+\begin{code}
+\inputminted[linenos, breaklines, frame=single]{C}{../code/question3/genericLinkedList.h}
+\caption{\texttt{genericLinkedList.h}}
+\end{code}
+
+\begin{code}
+\inputminted[linenos, breaklines, frame=single]{C}{../code/question3/genericLinkedList.c}
+\caption{\texttt{genericLinkedList.c}}
+\end{code}
+
+\begin{code}
+\inputminted[linenos, breaklines, frame=single]{C}{../code/question3/tests.c}
+\caption{\texttt{tests.c}}
+\end{code}
+
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=0.9\textwidth]{./images/question3.png}
+    \caption{Console Output for Question 3}
+\end{figure}
+
+\section{Question 4}
+\subsection{Part 1}
+Any algorithm for traversing a singly linked list in reverse will always first require traversing the list forwards, and will therefore be \emph{at least} somewhat
+less efficient than a forwards traversal.
+One of the simplest ways to traverse a linked list in reverse is to use a recursive function.
+\begin{code}
+\begin{minted}[linenos, breaklines, frame=single]{C}
+void reverse_traverse(listElement* current){
+    if (current == NULL) { return; }
+    reverse_traverse(current->next);
+    current->printFunction(current->data);
+}
+\end{minted}
+\caption{Recursive Function to Traverse a Singly Linked List in Reverse}
+\end{code}
+
+This is quite inefficient as it requires that the function call for each node persists on the stack until the last node is reached, using a lot of stack memory.
+Another approach would be to iteratively reverse the linked list, by making some kind of data structure, linked list or otherwise, that contains the data of the 
+original linked list but in reverse, and then iterating over that forwards.  
+This would likely be more efficient in terms of memory \& computation.
+\\\\
+Because traversing a linked list in reverse always requires traversing it forwards first, any reverse algorithm will take at least twice as much memory \& computation
+as traversing it forwards, which is $O(n)$.
+It will also require that some way of storing the data in reverse in memory, either explicitly with a data, like in the iterative approach, or in the same manner 
+as the recursive approach, wherein the data is stored in reverse by the nested structure of the function calls: as each function call returns, the call structure 
+is iterated through in reverse.
+Therefore, we also have at least $O(n)$ memory usage, as we have to store some sort of reverse data structure.
+
+\subsection{Part 2}
+The simplest way in which the structure of a linked list could be changed to make backwards traversal less intensive is to change it from a singly linked list to a 
+doubly linked list, i.e. instead of each node in the list containing a pointer to just the next node, make each node contain a pointer to both the next node \& the 
+previous node.
+The backwards traversal of a doubly linked list is no more intensive than the forwards traversal of a linked list.
+The drawback of using a doubly linked list is that it requires slightly more memory per node than a singly linked list, as you're storing an additional pointer 
+for every node.
+
+
+
+
+
+\end{document}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question1/Question1.c

@@ -0,0 +1,13 @@
+#include <stdio.h>
+
+int main(int arg, char* argc[]){
+    printf("Hello assignment1.\n");
+
+    int my_integer;
+    int* my_integer_pointer; 
+    long my_long;
+    double *my_double_pointer;
+    char **my_char_pointer_pointer;
+
+    return 0;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/assignment-1.c

@@ -0,0 +1,8 @@
+#include <stdio.h>
+#include "linkedList.h"
+#include "tests.h"
+
+int main(int arg, char* argc[]){
+  runTests();
+  return 0;
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/linkedList-1.c

@@ -0,0 +1,61 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "linkedList.h"
+
+typedef struct listElementStruct{
+  char* data;
+  size_t size;
+  struct listElementStruct* next;
+} listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(char* data, size_t size){
+  listElement* e = malloc(sizeof(listElement));
+  if(e == NULL){
+    //malloc has had an error
+    return NULL; //return NULL to indicate an error.
+  }
+  char* dataPointer = malloc(sizeof(char)*size);
+  if(dataPointer == NULL){
+    //malloc has had an error
+    free(e); //release the previously allocated memory
+    return NULL; //return NULL to indicate an error.
+  }
+  strcpy(dataPointer, data);
+  e->data = dataPointer;
+  e->size = size;
+  e->next = NULL;
+  return e;
+}
+
+//Prints out each element in the list
+void traverse(listElement* start){
+  listElement* current = start;
+  while(current != NULL){
+    printf("%s\n", current->data);
+    current = current->next;
+  }
+}
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* el, char* data, size_t size){
+  listElement* newEl = createEl(data, size);
+  listElement* next = el->next;
+  newEl->next = next;
+  el->next = newEl;
+  return newEl;
+}
+
+
+//Delete the element after the given el
+void deleteAfter(listElement* after){
+  listElement* delete = after->next;
+  listElement* newNext = delete->next;
+  after->next = newNext;
+  //need to free the memory because we used malloc
+  free(delete->data);
+  free(delete);
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/linkedList-1.h

@@ -0,0 +1,21 @@
+#ifndef CT331_ASSIGNMENT_LINKED_LIST
+#define CT331_ASSIGNMENT_LINKED_LIST
+
+typedef struct listElementStruct listElement;
+
+//Creates a new linked list element with given content of size
+//Returns a pointer to the element
+listElement* createEl(char* data, size_t size);
+
+//Prints out each element in the list
+void traverse(listElement* start);
+
+//Inserts a new element after the given el
+//Returns the pointer to the new element
+listElement* insertAfter(listElement* after, char* data, size_t size);
+
+//Delete the element after the given el
+void deleteAfter(listElement* after);
+
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/tests.c

@@ -0,0 +1,25 @@
+#include <stdio.h>
+#include "tests.h"
+#include "linkedList.h"
+
+void runTests(){
+  printf("Tests running...\n");
+  listElement* l = createEl("Test String (1).", 30);
+  //printf("%s\n%p\n", l->data, l->next);
+  //Test create and traverse
+  traverse(l);
+  printf("\n");
+
+  //Test insert after
+  listElement* l2 = insertAfter(l, "another string (2)", 30);
+  insertAfter(l2, "a final string (3)", 30);
+  traverse(l);
+  printf("\n");
+
+  // Test delete after
+  deleteAfter(l);
+  traverse(l);
+  printf("\n");
+
+  printf("\nTests complete.\n");
+}

year3/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/tests.h

@@ -0,0 +1,6 @@
+#ifndef CT331_ASSIGNMENT_TESTS
+#define CT331_ASSIGNMENT_TESTS
+
+void runTests();
+
+#endif

year3/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q1.rkt

@@ -0,0 +1,22 @@
+#lang racket
+
+;; a cons pair of two numbers
+(cons 1 2)
+
+;; a list of 3 numbers using only the cons function
+;; this could be more easily done using the single quote `'` (i.e., `'(1 2 3)`) but i don't use it as it seemed against the spirit of the question
+(cons 1 (cons 2 (cons 3 empty)))   
+
+;; a list containing a string, a number, and a nested list of three numbers using only the cons function
+(cons "a string"
+    (cons 0 
+        (cons (cons 1 (cons 2 (cons 3 empty))) empty)
+    )
+)
+
+;; a list containing a string, a number, and a nested list of three numbers, using only the list function
+(list "a string" 0 (list 1 2 3))
+
+;; a list containing a string, a number, and a nested list of three numbers, using only the append function
+;; using `'` as the arguments of the `append` function must be themselves lists
+(append '("a string") '(0) '((1 2 3)))

year3/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q2.rkt

@@ -0,0 +1,93 @@
+#lang racket
+
+(provide ins_beg)
+(provide ins_end)
+(provide count_top_level)
+(provide count_instances)
+(provide count_instances_tr)
+(provide count_instances_deep)
+
+;; function to insert an element at the beginning of a list
+(define (ins_beg el lst)
+    ;; assuming that the second element is always a list
+    (cons el lst)
+)
+
+;; function to insert an element at the end of a list
+(define (ins_end el lst)
+    ;; making el into a list if it isn't already
+    (append lst (cons el empty))
+)
+
+;; function to count the number of top-level items in a list
+(define (count_top_level lst)
+    (if (null? lst)
+        0                                   ;; return 0 if we've reached the end of the list
+        (+ 1 (count_top_level (cdr lst)))   ;; return 1 plus the count_top_level of the second element of the cons pair (the rest of the list)
+    )
+)
+
+;; non-tail recursive function to count the number of times a given item occurs in a list (assuming items are atomic)
+(define (count_instances item lst)
+    (if (null? lst)
+        0   ;; return 0 if at the end of the list
+        (+
+            (if (equal? item (car lst))
+                1   ;; if the item is equal to the first element of the list, add 1
+                0   ;; if the item is not equal to the first element of the list, add 0
+            )
+            (count_instances item (cdr lst))    ;; recurse with the remainder of the list
+        )
+    )
+)
+
+;; helper function for count_instances_tr
+(define (count_instances_tr_helper item lst cnt)
+    (cond
+        ;; return the count if the end of the list is reached (0 for empty list)
+        ((null? lst)
+            cnt
+        )
+        ;; if the first element of the list is equal to the item 
+        ((eq? (car lst) item)
+            ;; recurse with the remainder of the list and an incremented count
+            (count_instances_tr_helper item (cdr lst) (+ cnt 1))
+        )
+        ;; if the first element of the list is not equal to the item
+        (else
+            ;; recurse with the remainder of the list and an unchanged count
+            (count_instances_tr_helper item (cdr lst) cnt)
+        )
+    )
+)
+
+;; tail recursive function to count the number of times a given item occurs in a list (assuming items are atomic)
+(define (count_instances_tr item lst)
+    ;; calling helper function with the list and the count so far (0)
+    (count_instances_tr_helper item lst 0)
+)
+
+;; function to count the number of times an item occurs in a list and its sub-lists
+(define (count_instances_deep item lst)
+    (cond
+        ;; return nothing if we've reached the end of the list
+        ((null? lst)
+            0
+        )
+
+        ;; if the first item is a list, recurse through the first element and then the rest and return the sum of the two results
+        ((pair? (car lst))
+            (+ (count_instances_deep item (car lst)) (count_instances_deep item (cdr lst)))
+        )
+
+        ;; if the first element is equal to the item, add 1 to the count and recurse with the rest of the list
+        ((eq? item (car lst)) ; If the first element is equal to the item, increment count
+            (+ 1 (count_instances_deep item (cdr lst)))
+        )
+
+        ;; else if the first element is not equal to the item, recurse with the rest of the list
+        (else
+            (count_instances_deep item (cdr lst))
+        )
+    )
+)

year3/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q3.rkt

@@ -0,0 +1,145 @@
+#lang racket
+
+;; function to display the contents of a binary search tree in sorted order
+(define (display_contents bst)
+    (cond
+        ;; if the binary search tree is null, print an empty string (nothing)
+        [(null? bst) (display "")]
+
+        ;; if the binary search tree has nodes
+        [else 
+            ;; display the contents of the left sub-tree of the current node
+            (display_contents (cadr bst))
+
+            ;; display the current node
+            (display (car bst))
+            (newline)
+
+            ;; display the contents of the right sub-tree of the current node
+            (display_contents (caddr bst))
+        ]
+    )
+)
+
+;; function to search a tree and tell whether a given item is presesnt in a given tree
+(define (search_tree item bst)
+    (cond
+        ;; return false if we've reached the end of the tree without finding a match
+        ((null? bst) #f)
+
+        ;; return true if the current node is equal to the item
+        ((equal? item (car bst)) #t)
+
+        ;; else return whether the item was found in the left sub-tree or the right sub-tree
+        (else
+            (or
+                (search_tree item (cadr bst))   ;; search left sub-tree
+                (search_tree item (caddr bst))  ;; search right sub-tree
+            )
+        )
+    )
+)
+
+;; function to insert an item into a binary search tree
+(define (insert_item item bst)
+    (cond
+        ;; if there are no nodes in the tree, create a new tree with the item as the root
+        ((null? bst)
+            (list item '() '())
+        )
+
+        ;; if the item is less than the current node, insert it into the left-hand side of the tree
+        ((< item (car bst))
+            ;; create new bst with same root node, same right-hand side, but a left-hand side that has had the item inserted
+            (list (car bst) (insert_item item (cadr bst)) (caddr bst))
+        )
+
+        ;; if the item is greater than the current node, insert it into the right-hand side of the tree
+        ((> item (car bst))
+            ;; create new bst with same root node, same left-hand side, but a right-hand side that has had the item inserted
+            (list (car bst) (cadr bst) (insert_item item (caddr bst)))
+        )
+
+        ;; else the item is equal to the current node, so do nothing
+        (else bst)
+    )
+)
+
+;; function to insert a list of items into a binary search tree
+(define (insert_list lst bst)
+    (if (null? lst)
+        ;; if the list is null, just return the bst with no changes
+        bst
+
+        ;; otherwise, recurse with the remainder of the list and the binary tree produced by inserting the first item of the list into bst
+        (insert_list (cdr lst) (insert_item (car lst) bst))
+    ) 
+)
+
+;; tree-sort function
+(define (tree_sort lst)
+    ;; inserting the list into a tree structure to sort it and then displaying the contents of that tree 
+    (display_contents (insert_list lst '()))
+)
+
+;; function to insert an item into a binary search tree based off a sorting function
+;; the sorting function should return accept two items and arguments, and return true if they were passed in order, and false otherwise or if they are equal
+(define (insert_item_custom item bst sorter)
+    (cond
+        ;; if there are no nodes in the tree, create a new tree with the item as the root
+        ((null? bst)
+            (list item '() '())
+        )
+
+        ;; if the item is goes before the current node, insert it into the left-hand side of the tree
+        ((sorter item (car bst))
+            ;; create new bst with same root node, same right-hand side, but a left-hand side that has had the item inserted
+            (list (car bst) (insert_item_custom item (cadr bst) sorter) (caddr bst))
+        )
+
+        ;; if the item goes after the current node, insert it into the right-hand side of the tree
+        ((sorter (car bst) item)
+            ;; create new bst with same root node, same left-hand side, but a right-hand side that has had the item inserted
+            (list (car bst) (cadr bst) (insert_item_custom item (caddr bst) sorter))
+        )
+
+        ;; else the item is equal to the current node, so do nothing
+        (else bst)
+    )
+)
+
+;; sorter function which states whether the two arguments were supplied in strictly ascending order (i.e., if item == item2, return false)
+(define (sort_ascending item1 item2)
+    (if (< item1 item2)
+        #t
+        #f
+    )
+)
+
+
+;; sorter function which states whether the two arguments were supplied in strictly descending order (i.e., if item == item2, return false)
+(define (sort_descending item1 item2)
+    (if (> item1 item2)
+        #t
+        #f
+    )
+)
+
+;; sorter function which states whether the two arguments were supplied in strictly ascending order based on the final digit (i.e., if item == item2, return false)
+(define (sort_ascending_last item1 item2)
+    (if (< (modulo item1 10) (modulo item2 10))
+        #t
+        #f
+    )
+)
+
+;; function to insert a list of items into a binary search tree in the order determined by a sorting function
+(define (insert_list_custom lst bst sorter)
+    (if (null? lst)
+        ;; if the list is null, just return the bst with no changes
+        bst
+
+        ;; otherwise, recurse with the remainder of the list and the binary tree produced by inserting the first item of the list into bst
+        (insert_list_custom (cdr lst) (insert_item_custom (car lst) bst sorter) sorter)
+    ) 
+)

year3/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/CT331-Assignment-2.tex

@@ -0,0 +1,142 @@
+%! TeX program = lualatex
+\documentclass[a4paper]{article} 
+
+% packages
+\usepackage{microtype}      % Slightly tweak font spacing for aesthetics
+\usepackage[english]{babel} % Language hyphenation and typographical rules
+\usepackage[final, colorlinks = false, urlcolor = cyan]{hyperref} 
+\usepackage{changepage}     % adjust margins on the fly
+\usepackage{fontspec}
+
+\usepackage{minted}
+\usemintedstyle{algol_nu}
+\usepackage{xcolor}
+
+\usepackage{pgfplots}
+\pgfplotsset{width=\textwidth,compat=1.9}
+
+\usepackage{caption}
+\newenvironment{code}{\captionsetup{type=listing}}{}
+\captionsetup[listing]{skip=0pt}
+\setlength{\abovecaptionskip}{5pt}
+\setlength{\belowcaptionskip}{5pt}
+
+\usepackage[yyyymmdd]{datetime}
+\renewcommand{\dateseparator}{--}
+\setmainfont{EB Garamond}
+\setmonofont[Scale=MatchLowercase]{Deja Vu Sans Mono}
+
+\usepackage{titlesec}
+% \titleformat{\section}{\LARGE\bfseries}{}{}{}[\titlerule]
+% \titleformat{\subsection}{\Large\bfseries}{}{0em}{}
+% \titlespacing{\subsection}{0em}{-0.7em}{0em}
+%
+% \titleformat{\subsubsection}{\large\bfseries}{}{0em}{$\bullet$ }
+% \titlespacing{\subsubsection}{1em}{-0.7em}{0em}
+
+% margins
+\addtolength{\hoffset}{-2.25cm}
+\addtolength{\textwidth}{4.5cm}
+\addtolength{\voffset}{-3.25cm}
+\addtolength{\textheight}{5cm}
+\setlength{\parskip}{0pt}
+\setlength{\parindent}{0in}
+% \setcounter{secnumdepth}{0}
+
+\begin{document}
+\hrule \medskip
+\begin{minipage}{0.295\textwidth} 
+    \raggedright
+    \footnotesize 
+    Name: Andrew Hayes \\
+    E-mail: \href{mailto://a.hayes18@universityofgalway.ie}{\texttt{a.hayes18@universityofgalway.ie}}  \hfill\\   
+    ID: 21321503 \hfill
+\end{minipage}
+\begin{minipage}{0.4\textwidth} 
+    \centering 
+    \vspace{0.4em}
+    \Large 
+    \textbf{CT331} \\ 
+\end{minipage}
+\begin{minipage}{0.295\textwidth} 
+    \raggedleft
+    \today
+\end{minipage}
+\medskip\hrule 
+\begin{center}
+    \normalsize
+    Assignment 2: Functional Programming with Scheme
+\end{center}
+\hrule
+
+\section{Question 1}
+\subsection{Part (A): Code}
+\begin{code}
+\inputminted[texcl, mathescape, breaklines, frame=single]{racket}{../code/assignment_q1.rkt}
+\caption{\texttt{assignment\_q1.rkt}}
+\end{code}
+
+\subsection{Part (B): Comments}
+\begin{figure}[H]
+    \centering
+    \includegraphics[width=\textwidth]{./images/question1.png}
+    \caption{Output of \texttt{assignment\_q1.rkt}}
+\end{figure}
+
+Comments on each line of output:
+\begin{enumerate}
+    \item   The \mintinline{racket}{cons} function creates a \mintinline{racket}{cons} pair, which is not always a ``list''. 
+            A list is a \mintinline{racket}{cons} pair in which the second element is another itself another list or is \mintinline{racket}{empty}.
+            When a \mintinline{racket}{cons} pair that is not a list is printed, its elements are delimited by a ``\verb|.|'', as can be seen from the first line of
+            output.
+
+    \item   The second section of code produces a list of three numbers using only the \mintinline{racket}{cons} function: 
+            first we create a one-element list with \mintinline{racket}{(cons 3 empty)}, then we create a two-element list by making a \mintinline{racket}{cons} pair
+            of \mintinline{racket}{2} and the already-created one-element list, and finally we create a three-element list by making a \mintinline{racket}{cons} pair
+            of \mintinline{racket}{1} and the two-element list.
+            This could of course be achieved far more simply by just using \mintinline{racket}{(cons 1 '(2 3))} or even justs \mintinline{racket}{'(1 2 3)} but I
+            felt that this would be against the spirit of the exercise.
+    
+    \item   To create a nested list using only \mintinline{racket}{cons} in the third section of code, we make the \mintinline{racket}{'(1 2 3)} as previously, 
+            \mintinline{racket}{cons} it with \mintinline{racket}{empty} to make a nested list, and then \mintinline{racket}{cons} it with \mintinline{racket}{0}, and 
+            \mintinline{racket}{cons} that with a string literal.
+
+    \item   Like \mintinline{racket}{cons}, \mintinline{racket}{list} can take either atomics or lists as arguments.
+            To create the list using only the \mintinline{racket}{list} function, we can simply make a list of \mintinline{racket}{(list 1 2 3)}, and then create a 
+            list consisting of \mintinline{racket}{"a string"}, \mintinline{racket}{0}, \& the aforementioned list.
+            This is much simpler than using \mintinline{racket}{cons} because \mintinline{racket}{list} can take as many arguments as we want, while 
+            \mintinline{racket}{cons} can only take two arguments.
+
+    \item   Although I opted not to make use of the ``\mintinline{racket}{'}'' operator to create lists for the previous exercises, I make use of it here as there is 
+            no other way to create a list using only \mintinline{racket}{append} and nothing else, as \mintinline{racket}{append} only accepts lists as arguments. 
+            We make a list consisting of only one element (\mintinline{racket}{"a string"}), another list consisting of only one element (\mintinline{racket}{0}), 
+            and finally a list consisting of three elements \mintinline{racket}{'(1 2 3)} and append them into one to create the desired list.
+\end{enumerate}
+
+\section{Question 2}
+\begin{code}
+    \inputminted[breaklines, frame=single]{racket}{../code/assignment_q2.rkt}
+    \caption{\texttt{assignment\_q2.rkt}}
+\end{code}
+
+\section{Question 3}
+\begin{code}
+    \inputminted[breaklines, frame=single]{racket}{../code/assignment_q3.rkt}
+    \caption{\texttt{assignment\_q3.rkt}}
+\end{code}
+
+It is worth noting here that the function \mintinline{racket}{sort_ascending_last} operates in a manner that may be undesirable. 
+The function determines whether the two numbers passed to it as arguments were passed in strictly ascending order based on the final 
+digit, i.e. it returns \mintinline{racket}{#t} if the final digit of the first argument is less than the final digit of the second 
+argument, and \mintinline{racket}{#f} otherwise.
+Because this function considers only the final digit of the numbers, it considers two numbers to be equal if they share a final digit, 
+e.g. it considers the numbers \mintinline{racket}{99} \& \mintinline{racket}{9} to be the same.
+Therefore, if one attempts to insert those two values into the binary search tree using this function as the ``sorter'', only the 
+former value will get inserted, as binary search trees do not allow duplicate values, and the \mintinline{racket}{sort_ascending_last} function
+considers those two values to be equal.
+However, I thought it would be incorrect for the function to consider the $n-1$\textsuperscript{th} digits in the case of the $n$\textsuperscript{th} digits being identical, as
+a) the assignment did not ask for that and b) that would really just be no different to sorting the numbers in ascending order.
+
+
+
+\end{document}

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question1.prolog

@@ -0,0 +1,26 @@
+takes(tom, ct331). 
+takes(mary, ct331). 
+takes(joe, ct331). 
+takes(tom, ct345). 
+takes(mary, ct345). 
+instructs(bob, ct331). 
+instructs(ann, ct345).  
+
+% 1. rule that returns true if a given instructor teaches a given student
+teaches(Instructor, Student) :- instructs(Instructor, Course), takes(Student, Course).
+
+% 2. query that uses the `teaches` rule to show all students instructed by bob
+?- teaches(bob, Student).
+?- findall(Student, teaches(bob, Student), Students).
+
+% 3. query that uses the `teaches` rule to show all instructors that instruct mary
+?- teaches(Instructor, mary).
+?- findall(Instructor, teaches(Instructor, mary), Instructors).
+
+% 5. rule that returns true if two students take the same course
+takesSameCourse(Student1, Student2) :- takes(Student1, Course), takes(Student2, Course).
+
+contains1(Element, [Element | Tail]).
+
+
+contains2(Sublist, [Head | Sublist]).

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question3.prolog

@@ -0,0 +1,5 @@
+% base case: any element is not in an empty list
+isNotElementInList(_, []).
+
+% return true if Element is not the Head of the list and it's not found recursively searching the rest of the list
+isNotElementInList(Element, [Head | Tail]) :- Element \= Head, isNotElementInList(Element, Tail).

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question4.prolog

@@ -0,0 +1,16 @@
+% predicate to merge two lists
+% base case: if the first list is empty, just return the second
+mergeTwoLists([], List, List).
+
+% recursive predicate to merge two lists
+% split the first list into head and tail, and recurse with its tail and the second list until the first list is empty (base case)
+% then merge the original head of the first list with the resulting tail
+mergeTwoLists([Head | Tail], List2, [Head | ResultTail]) :- mergeTwoLists(Tail, List2, ResultTail).
+
+% predicate to merge 3 lists 
+% base case: merging an empty list and two others is the same as merging two lists
+mergeLists([], List2, List3, Merged) :- mergeTwoLists(List2, List3, Merged).
+
+% split the first list into head and tail, and recurse with its tail and the other two lists until the first list is empty (base case)
+mergeLists([Head1 | Tail1], List2, List3, [Head1 | MergedTail]) :- mergeLists(Tail1, List2, List3, MergedTail).
+

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question5.prolog

@@ -0,0 +1,8 @@
+% call the helper predicate with the list to be reversed and an empty Accumulator to build up
+reverseList(List, Reversed) :- reverseListHelper(List, [], Reversed).
+
+% base case fact: when the list to reverse is empty, the accumulator is the reversed list
+reverseListHelper([], Accumulator, Accumulator).
+
+% recurse with the tail after prepending the head to the accumulator
+reverseListHelper([Head | Tail], Accumulator, Reversed) :- reverseListHelper(Tail, [Head | Accumulator], Reversed).

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question6.prolog

@@ -0,0 +1,8 @@
+% base fact: if the list is empty, the list to be returned is just the element
+insertInOrder(Element, [], [Element]).
+
+% if the element to be inserted is <= the head of the list, insert it at the head of the list
+insertInOrder(Element, [Head | Tail], [Element, Head | Tail]) :- Element =< Head.
+
+% if the element to be inserted is greater than the head of the list, recurse with the tail of the list until 
+insertInOrder(Element, [Head | Tail], [Head | NewTail]) :- Element > Head, insertInOrder(Element, Tail, NewTail).

year3/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/CT331-Assignment-3.tex

@@ -0,0 +1,295 @@
+%! TeX program = lualatex
+\documentclass[a4paper]{article} 
+
+% packages
+\usepackage{microtype}      % Slightly tweak font spacing for aesthetics
+\usepackage[english]{babel} % Language hyphenation and typographical rules
+\usepackage[final, colorlinks = false, urlcolor = cyan]{hyperref} 
+\usepackage{changepage}     % adjust margins on the fly
+\usepackage{fontspec}
+
+\usepackage{minted}
+% \usemintedstyle{algol_nu}
+\usepackage{xcolor}
+
+\usepackage{pgfplots}
+\pgfplotsset{width=\textwidth,compat=1.9}
+
+\usepackage{caption}
+\newenvironment{code}{\captionsetup{type=listing}}{}
+\captionsetup[listing]{skip=0pt}
+\setlength{\abovecaptionskip}{5pt}
+\setlength{\belowcaptionskip}{5pt}
+
+\usepackage[yyyymmdd]{datetime}
+\renewcommand{\dateseparator}{--}
+\setmainfont{EB Garamond}
+\setmonofont[Scale=MatchLowercase]{Deja Vu Sans Mono}
+
+\usepackage{titlesec}
+% \titleformat{\section}{\LARGE\bfseries}{}{}{}[\titlerule]
+% \titleformat{\subsection}{\Large\bfseries}{}{0em}{}
+% \titlespacing{\subsection}{0em}{-0.7em}{0em}
+%
+% \titleformat{\subsubsection}{\large\bfseries}{}{0em}{$\bullet$ }
+% \titlespacing{\subsubsection}{1em}{-0.7em}{0em}
+
+% margins
+\addtolength{\hoffset}{-2.25cm}
+\addtolength{\textwidth}{4.5cm}
+\addtolength{\voffset}{-3.25cm}
+\addtolength{\textheight}{5cm}
+\setlength{\parskip}{0pt}
+\setlength{\parindent}{0in}
+% \setcounter{secnumdepth}{0}
+
+\begin{document}
+\hrule \medskip
+\begin{minipage}{0.295\textwidth} 
+    \raggedright
+    \footnotesize 
+    Name: Andrew Hayes \\
+    E-mail: \href{mailto://a.hayes18@universityofgalway.ie}{\texttt{a.hayes18@universityofgalway.ie}}  \hfill\\   
+    ID: 21321503 \hfill
+\end{minipage}
+\begin{minipage}{0.4\textwidth} 
+    \centering 
+    \vspace{0.4em}
+    \Large 
+    \textbf{CT331} \\ 
+\end{minipage}
+\begin{minipage}{0.295\textwidth} 
+    \raggedleft
+    \today
+\end{minipage}
+\medskip\hrule 
+\begin{center}
+    \normalsize
+    Assignment 3: Declarative Programming with Prolog
+\end{center}
+\hrule
+
+\section{Question 1}
+\subsection{Rule that returns true if a given instructor teaches a given student}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+teaches(Instructor, Student) :- instructs(Instructor, Course), takes(Student, Course).
+\end{minted}
+
+\subsection{Query that uses the \mintinline{prolog}{teaches} rule to show all students instructed by \mintinline{prolog}{bob}}
+For this, I wasn't sure if the desired answer was a query that returned a student instructed by \mintinline{prolog}{bob}, followed by 
+a couple semi-colons to get every student instructed by \mintinline{prolog}{bob}, or if the desired answer was a single query that 
+returned a list of students taught by \mintinline{prolog}{bob}, so I did both.
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- teaches(bob, Student).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1.2.png}
+    \caption{Using the \mintinline{prolog}{teaches} rule to show all students instructed by \mintinline{prolog}{bob}}
+\end{figure}
+
+Alternatively, this could be done using the \mintinline{prolog}{findall()} predicate:
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- findall(Student, teaches(bob, Student), Students).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1_2_findall.png}
+    \caption{Using the \mintinline{prolog}{teaches} rule \& the \mintinline{prolog}{findall} predicate to show all students instructed by \mintinline{prolog}{bob}}
+\end{figure}
+
+\subsection{Query that uses the \mintinline{prolog}{teaches} rule to show all instructors that instruct \mintinline{prolog}{mary}}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- teaches(Instructor, mary).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1_3.png}
+    \caption{Using the \mintinline{prolog}{teaches} rule to show all instructors that instruct \mintinline{prolog}{mary}}
+\end{figure}
+
+Alternatively, this could be done using the \mintinline{prolog}{findall()} predicate:
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- findall(Instructor, teaches(Instructor, mary), Instructors).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1_3_findall.png}
+    \caption{Using the \mintinline{prolog}{teaches()} rule \& the \mintinline{prolog}{findall()} predicate to show all instructors that instruct \mintinline{prolog}{mary}}
+\end{figure}
+
+\subsection{Result of query \mintinline{prolog}{teaches(ann,joe).}}
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1_4.png}
+    \caption{Result of query \mintinline{prolog}{teaches(ann,joe).}}
+\end{figure}
+
+The result of the query \mintinline{prolog}{teaches(ann,joe).} is \mintinline{prolog}{false.} because \mintinline{prolog}{ann}
+only instructs \mintinline{prolog}{ct345} and \mintinline{prolog}{joe} only takes \mintinline{prolog}{ct331}, and therefore 
+\mintinline{prolog}{ann} does not teach \mintinline{prolog}{joe} because \mintinline{prolog}{ann} does not teach a course
+that \mintinline{prolog}{joe} takes.
+
+\subsection{Rule that returns \mintinline{prolog}{true} if two students take the same course}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+takesSameCourse(Student1, Student2) :- takes(Student1, Course), takes(Student2, Course).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q1_5.png}
+    \caption{Queries to test \mintinline{prolog}{takesSameCourse()}}
+\end{figure}
+
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- takesSameCourse(tom,mary).
+?- takesSameCourse(joe,mary).
+?- takesSameCourse(joe,tom).
+?- takesSameCourse(bob, mary).
+\end{minted}
+
+\section{Question 2}
+\subsection{Query that displays the head \& tail of a list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- [Head | Tail] = [1,2,3].
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q2_1.png}
+    \caption{Query to display the head \& tail of the list \mintinline{prolog}{[1,2,3]}}
+\end{figure}
+
+\subsection{Display the head of a list, the head of the tail of the list, \& the tail of the tail of the list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- [Head | [HeadOfTail | TailOfTail]] = [1,2,3,4,5].
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q2_2.png}
+    \caption{Query to display the head of the list, the head of the tail of the list, \& the tail of the tail of the list \mintinline{prolog}{[1,2,3,4,5]}}
+\end{figure}
+
+\subsection{Rule that returns \mintinline{prolog}{true} if a given element is the first element of a given list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+contains1(Element, [Element | Tail]).
+
+?- contains1(1, [1,2,3,4]).
+?- contains1(3, [1,2,3,4]).
+?- contains1(1, [2,3,4]).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q2_3.png}
+    \caption{\mintinline{prolog}{contains1()} testing}
+\end{figure}
+
+\subsection{Rule that returns \mintinline{prolog}{true} if a given list is the same as the tail of another given list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+contains2(Sublist, [Head | Sublist]).
+
+?- contains2([2,3,4], [1,2,3,4]).
+?- contains2([2,3,4], [1,2,3,4,5]).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q2_4.png}
+    \caption{\mintinline{prolog}{contains2()} testing}
+\end{figure}
+
+\subsection{Query to display the first element of a given list using \mintinline{prolog}{contains1()}}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+?- contains1(FirstElement, [1,2,3,4,5]).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q2_5.png}
+    \caption{Query to display the first element of a given list using \mintinline{prolog}{contains1()}}
+\end{figure}
+
+\section{Determine if a given element is not in a given list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+% base case: any element is not in an empty list
+isNotElementInList(_, []).
+
+% return true if Element is not the Head of the list and it's not found recursively searching the rest of the list
+isNotElementInList(Element, [Head | Tail]) :- Element \= Head, isNotElementInList(Element, Tail).
+
+% testing
+isNotElementInList(1, []).  
+isNotElementInList(1, [1]). 
+isNotElementInList(1, [2]).  
+isNotElementInList(2, [1, 2, 3]).  
+isNotElementInList(7, [1, 2, 9, 4, 5]). 
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q3.png}
+    \caption{Testing \mintinline{prolog}{isNotElementInList()}}
+\end{figure}
+
+\section{Facts \& rules to merge three lists}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+% predicate to merge two lists
+% base case: if the first list is empty, just return the second
+mergeTwoLists([], List, List).
+
+% recursive predicate to merge two lists
+% split the first list into head and tail, and recurse with its tail and the second list until the first list is empty (base case)
+% then merge the original head of the first list with the resulting tail
+mergeTwoLists([Head | Tail], List2, [Head | ResultTail]) :- mergeTwoLists(Tail, List2, ResultTail).
+
+% predicate to merge 3 lists 
+% base case: merging an empty list and two others is the same as merging two lists
+mergeLists([], List2, List3, Merged) :- mergeTwoLists(List2, List3, Merged).
+
+% split the first list into head and tail, and recurse with its tail and the other two lists until the first list is empty (base case)
+mergeLists([Head1 | Tail1], List2, List3, [Head1 | MergedTail]) :- mergeLists(Tail1, List2, List3, MergedTail).
+
+?- mergeLists([7],[1,2,3],[6,7,8], X).
+?- mergeLists([2], [1], [0], X).
+?- mergeLists([1], [], [], X).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q4.png}
+    \caption{Testing \mintinline{prolog}{mergeLists()}}
+\end{figure}
+
+\section{Facts \& rules to reverse a given list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+% call the helper predicate with the list to be reversed and an empty Accumulator to build up
+reverseList(List, Reversed) :- reverseListHelper(List, [], Reversed).
+
+% base case fact: when the list to reverse is empty, the accumulator is the reversed list
+reverseListHelper([], Accumulator, Accumulator).
+
+% recurse with the tail after prepending the head to the accumulator
+reverseListHelper([Head | Tail], Accumulator, Reversed) :- reverseListHelper(Tail, [Head | Accumulator], Reversed).
+
+?- reverseList([1,2,3], X).  
+?- reverseList([1], X).  
+?- reverseList([], X).  
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q5.png}
+    \caption{Testing \mintinline{prolog}{reverseList()}}
+\end{figure}
+
+\section{Facts \& rules to insert an element into its correct position in a given list}
+\begin{minted}[linenos, breaklines, frame=single]{prolog}
+% base fact: if the list is empty, the list to be returned is just the element
+insertInOrder(Element, [], [Element]).
+
+% if the element to be inserted is <= the head of the list, insert it at the head of the list
+insertInOrder(Element, [Head | Tail], [Element, Head | Tail]) :- Element =< Head.
+
+% if the element to be inserted is greater than the head of the list, recurse with the tail of the list until 
+insertInOrder(Element, [Head | Tail], [Head | NewTail]) :- Element > Head, insertInOrder(Element, Tail, NewTail).
+\end{minted}
+
+\begin{figure}[H]
+    \includegraphics[width=\textwidth]{./images/q6.png}
+    \caption{Testing \mintinline{prolog}{insertInOrder()}}
+\end{figure}
+
+
+\end{document}