aindreas/uni
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add CT331 Programming Paradigms

Browse Source
This commit is contained in:
Aindréas Ó hAodha
2023-12-07 01:33:53 +00:00
parent 38a012c323
commit 262614ce83
207 changed files with 4516 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/CT331 - Assignment 1 - C.pdf Normal file
View File

Binary file not shown.

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question1/a.out Executable file
View File

Binary file not shown.

15
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question1/question1.c Normal file
View File

@ -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));
}

8
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/.gitignore generated vendored Normal file
View File

@ -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

4
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/misc.xml generated Normal file
View File

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

8
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/modules.xml generated Normal file
View File

@ -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>

2
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/.idea/question2.iml generated Normal file
View File

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

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/a.out Executable file
View File

Binary file not shown.

8
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/assignment-1.c Normal file
View File

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

162
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/linkedList.c Normal file
View File

@ -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;
}

36
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/linkedList.h Normal file
View File

@ -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

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/linkedList.h.gch Normal file
View File

Binary file not shown.

57
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/tests.c Normal file
View File

@ -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");
}

6
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/tests.h Normal file
View File

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

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question2/tests.h.gch Normal file
View File

Binary file not shown.

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/a.out Executable file
View File

Binary file not shown.

8
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/assignment-1.c Normal file
View File

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

167
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/genericLinkedList.c Normal file
View File

@ -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;
}

35
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/genericLinkedList.h Normal file
View File

@ -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

79
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/tests.c Normal file
View File

@ -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");
}

6
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/tests.h Normal file
View File

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

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/code/question3/tests.h.gch Normal file
View File

Binary file not shown.

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/CT331-Assignment-1.pdf Normal file
View File

Binary file not shown.

343
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/CT331-Assignment-1.tex Normal file
View File

@ -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}

23
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/01FB34BA054D08BB613B65ED1AF6F70BC4B4C6667FA11090D38959FF1A0BC7D6.pygtex Normal file
View File

@ -0,0 +1,23 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// class to implement Method 3 }
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{class} \PYG{n+nc}{ReverseVSOriginal}\PYG{+w}{ }\PYG{k+kd}{implements}\PYG{+w}{ }\PYG{n}{PalindromeChecker}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// method 1 - reversed order String vs original String }
\PYG{+w}{ }\PYG{n+nd}{@Override}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n+nf}{checkPalindrome}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n}{reversedStr}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}\PYGZdq{}}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{0}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// looping through each character in the String, backwards}
\PYG{+w}{ }\PYG{c+c1}{// incrementing operations counter by 2, 1 for initialisating i, 1 for getting str.length()}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZgt{}}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{\PYGZhy{}\PYGZhy{}}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// for loop condition check & incrementing i}
\PYG{+w}{ }\PYG{n}{reversedStr}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{(}\PYG{n}{i}\PYG{o}{\PYGZhy{}}\PYG{l+m+mi}{1}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// returning true if the Strings are equal, false if not}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{();}\PYG{+w}{ }\PYG{c+c1}{// the equals method must loop through each character of the String to check that they are equal so it is O(n)}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{equals}\PYG{p}{(}\PYG{n}{reversedStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

23
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/110FEF529CAC0402197211A5AC192707C8E91FF50691E76D09A5C0CB438876B1.pygtex Normal file
View File

@ -0,0 +1,23 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// class to implement Method 2 }
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{class} \PYG{n+nc}{IVersusNMinusI}\PYG{+w}{ }\PYG{k+kd}{implements}\PYG{+w}{ }\PYG{n}{PalindromeChecker}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// method 2 - comparing each element at index i to the element at n - i where n is the last index}
\PYG{+w}{ }\PYG{n+nd}{@Override}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n+nf}{checkPalindrome}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// looping through the first half of the String }
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{1}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}}\PYG{+w}{ }\PYG{n}{Math}\PYG{p}{.}\PYG{n+na}{floor}\PYG{p}{(}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{()}\PYG{+w}{ }\PYG{o}{/}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{1}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// 1 for the getting str.length(), 1 for Math,floor, 1 for checking condition, 1 for incrementing}
\PYG{+w}{ }\PYG{c+c1}{// returning false if the digits don't match}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{1}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// 1 for str.charAt(i), 1 for ((str.lenght() -1) - 1), 1 for the other str.charAt(), 1 for checking the condition}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{(}\PYG{n}{i}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{((}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{()}\PYG{o}{\PYGZhy{}}\PYG{l+m+mi}{1}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZhy{}}\PYG{+w}{ }\PYG{n}{i}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{k+kc}{false}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// returning true as default}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{k+kc}{true}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

5
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/A10051ECA193D92A07799B5543A0B5BDE7AD8B6DAEFE71C89253B5BFC76F114A.pygtex Normal file
View File

@ -0,0 +1,5 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{interface} \PYG{n+nc}{PalindromeChecker}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n+nf}{checkPalindrome}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

31
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/A92BFD39C07FC71A735BA72ADA98DDACF6F90D82D91906018E344FAA4E89C742.pygtex Normal file
View File

@ -0,0 +1,31 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// class to implement method 4 }
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{class} \PYG{n+nc}{RecursiveReverse}\PYG{+w}{ }\PYG{k+kd}{implements}\PYG{+w}{ }\PYG{n}{PalindromeChecker}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// comparing the String reversed using recursion to the original String (essentially method 1 but with recursion)}
\PYG{+w}{ }\PYG{n+nd}{@Override}\PYG{+w}{ }
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n+nf}{checkPalindrome}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// returning true if the original String is equal to the reversed String, false if not}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{3}\PYG{o}{]++}\PYG{p}{;}\PYG{+w}{ }
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{equals}\PYG{p}{(}\PYG{n}{reverse}\PYG{p}{(}\PYG{n}{str}\PYG{p}{));}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// method to reverse the characters in a String using recursion }
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n+nf}{reverse}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// base case - returning an empty String if there is no character left in the String}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{3}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{()}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}\PYGZdq{}}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{k}{else}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kt}{char}\PYG{+w}{ }\PYG{n}{firstChar}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{(}\PYG{l+m+mi}{0}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{3}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n}{remainder}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{substring}\PYG{p}{(}\PYG{l+m+mi}{1}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{3}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// selecting the rest of the String, excluding the 0th character}
\PYG{+w}{ }\PYG{c+c1}{// recursing with what's left of the String}
\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n}{reversedRemainder}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{reverse}\PYG{p}{(}\PYG{n}{remainder}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{3}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// returning the reversed rest of String with the first character of the String appended}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{reversedRemainder}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{firstChar}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

50
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/B1725FBA276D1034088603A841B574D35C64737CB887A4F58DF95D863CBD2525.pygtex Normal file
View File

@ -0,0 +1,50 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// class to implement method 3 }
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{class} \PYG{n+nc}{StackVSQueue}\PYG{+w}{ }\PYG{k+kd}{implements}\PYG{+w}{ }\PYG{n}{PalindromeChecker}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// method 3 - using a stack and a queue to do, essentially, what method 2 does (compare the first index to the last index, etc.)}
\PYG{+w}{ }\PYG{n+nd}{@Override}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n+nf}{checkPalindrome}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{ArrayStack}\PYG{+w}{ }\PYG{n}{stack}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{ArrayStack}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{ArrayQueue}\PYG{+w}{ }\PYG{n}{queue}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{ArrayQueue}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// looping through each character in the String and adding the character to the stack & queue }
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{stack}\PYG{p}{.}\PYG{n+na}{push}\PYG{p}{(}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{(}\PYG{n}{i}\PYG{p}{));}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{queue}\PYG{p}{.}\PYG{n+na}{enqueue}\PYG{p}{(}\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{charAt}\PYG{p}{(}\PYG{n}{i}\PYG{p}{));}\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// looping through each character on the stack & queue and comparing them, returning false if they're different}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}}\PYG{+w}{ }\PYG{n}{str}\PYG{p}{.}\PYG{n+na}{length}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{!}\PYG{n}{stack}\PYG{p}{.}\PYG{n+na}{pop}\PYG{p}{().}\PYG{n+na}{equals}\PYG{p}{(}\PYG{n}{queue}\PYG{p}{.}\PYG{n+na}{front}\PYG{p}{()))}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{k+kc}{false}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// the complexity of ArrayQueue.dequeue() is 3n+2, where n is the number of items in the queue when dequeue() is called. }
\PYG{+w}{ }\PYG{c+c1}{// we need to determine the number of items in the queue so that we can determine the number of primitive operations performed when queue.dequeue() is called.}
\PYG{+w}{ }\PYG{c+c1}{// to do this, we'll loop through the queue, dequeuing each object and enqueueing it in another ArrayQueue. once complete, we'll reassign the variable queue to point to the new ArrayQueue containing all the objects}
\PYG{+w}{ }\PYG{n}{ArrayQueue}\PYG{+w}{ }\PYG{n}{newQueue}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{ArrayQueue}\PYG{p}{();}\PYG{+w}{ }\PYG{c+c1}{// not counting the operations for this as it's not part of the algorithm, it's part of the operations counting}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{n}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// n is the number of items in the ArrayQueue when dequeue() is called}
\PYG{+w}{ }\PYG{k}{while}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{!}\PYG{n}{queue}\PYG{p}{.}\PYG{n+na}{isEmpty}\PYG{p}{())}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{newQueue}\PYG{p}{.}\PYG{n+na}{enqueue}\PYG{p}{(}\PYG{n}{queue}\PYG{p}{.}\PYG{n+na}{dequeue}\PYG{p}{());}
\PYG{+w}{ }\PYG{n}{n}\PYG{o}{++}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }
\PYG{+w}{ }\PYG{n}{queue}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newQueue}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// setting queue to point to the newQueue, which is just the state that queue would have been in if we didn't do this to calculate the primitive operations}
\PYG{+w}{ }\PYG{n}{newQueue}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k+kc}{null}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// don't need the newQueue object reference anymore}
\PYG{+w}{ }
\PYG{+w}{ }\PYG{n}{NewPalindrome}\PYG{p}{.}\PYG{n+na}{operations}\PYG{o}{[}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{o}{*}\PYG{n}{n}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// complexity of dequeue is 3n+2}
\PYG{+w}{ }\PYG{n}{queue}\PYG{p}{.}\PYG{n+na}{dequeue}\PYG{p}{();}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{k+kc}{true}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

95
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/BABB4D329E8B745FA0512D40D64346FEDC92DEE6BF874602DF138C95667AD691.pygtex Normal file
View File

@ -0,0 +1,95 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kn}{import}\PYG{+w}{ }\PYG{n+nn}{java.io.*}\PYG{p}{;}
\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{class} \PYG{n+nc}{NewPalindrome}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{operations}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to contain the global operations count for each method }
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{decCount}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to hold the count of decimal palindromes found using each method}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{binCount}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to hold the count of binary palindromes found using each method}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{bothCount}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to hold the count of numbers that are palindromes in both decimal & binary found using each method}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{startTime}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to hold the start time of each method's test loop}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{totalTime}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{k+kt}{long}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// array to hold the total time of each method's test loop}
\PYG{+w}{ }\PYG{c+c1}{// array to hold all the String versions of the numbers so that they don't have to be generated for each method}
\PYG{+w}{ }\PYG{c+c1}{// 0th column will be decimal, 1st column will be binary}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{n}{String}\PYG{o}{[][]}\PYG{+w}{ }\PYG{n}{strings}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{String}\PYG{o}{[}\PYG{l+m+mi}{1\PYGZus{}000\PYGZus{}001}\PYG{o}{][}\PYG{l+m+mi}{2}\PYG{o}{]}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// array of StringBuilder objects used to hold the csv data (size of problem, number of operations) for each method}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{n}{StringBuilder}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{data}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{StringBuilder}\PYG{o}{[}\PYG{l+m+mi}{4}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }
\PYG{+w}{ }\PYG{c+c1}{// array of the four classes that will be tested}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{n}{PalindromeChecker}\PYG{o}{[]}\PYG{+w}{ }\PYG{n}{palindromeCheckers}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{k}{new}\PYG{+w}{ }\PYG{n}{ReverseVSOriginal}\PYG{p}{(),}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{IVersusNMinusI}\PYG{p}{(),}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{StackVSQueue}\PYG{p}{(),}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{RecursiveReverse}\PYG{p}{()\PYGZcb{};}\PYG{+w}{ }
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{main}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{args}\PYG{o}{[]}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// initialising the data array to StringBuilder objects}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}}\PYG{+w}{ }\PYG{l+m+mi}{4}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{data}\PYG{o}{[}\PYG{n}{i}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{StringBuilder}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}operations,size\PYGZbs{}n\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// filling up the strings array}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}=}\PYG{+w}{ }\PYG{l+m+mi}{1\PYGZus{}000\PYGZus{}000}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{strings}\PYG{o}{[}\PYG{n}{i}\PYG{o}{][}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{Integer}\PYG{p}{.}\PYG{n+na}{toString}\PYG{p}{(}\PYG{n}{i}\PYG{p}{,}\PYG{+w}{ }\PYG{l+m+mi}{10}\PYG{p}{);}\PYG{+w}{ }\PYG{c+c1}{// converting i to a String base 10}
\PYG{+w}{ }\PYG{n}{strings}\PYG{o}{[}\PYG{n}{i}\PYG{o}{][}\PYG{l+m+mi}{1}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{binary2string}\PYG{p}{(}\PYG{n}{strings}\PYG{o}{[}\PYG{n}{i}\PYG{o}{][}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }\PYG{c+c1}{// converting the decimal String to a binary String}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// looping through each PalindromeChecker object in the palindromeCheckers array}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{\PYGZlt{}}\PYG{+w}{ }\PYG{l+m+mi}{4}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{j}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// getting start time }
\PYG{+w}{ }\PYG{n}{startTime}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{currentTimeMillis}\PYG{p}{();}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// looping through the numbers 0 to 1,000,000 and checking if their binary & decimal representations are palindromic}
\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{for}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZlt{}=}\PYG{+w}{ }\PYG{l+m+mi}{1\PYGZus{}000\PYGZus{}000}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{i}\PYG{o}{++}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// incrementing the operations count by 2, 1 for the loop condition check and 1 for incrementing i}
\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// converting the number to a decimal or binary String and checking if is a palindrome}
\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n}{isDecPalindrome}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{palindromeCheckers}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{.}\PYG{n+na}{checkPalindrome}\PYG{p}{(}\PYG{n}{strings}\PYG{o}{[}\PYG{n}{i}\PYG{o}{][}\PYG{l+m+mi}{0}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]++}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{boolean}\PYG{+w}{ }\PYG{n}{isBinPalindrome}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{palindromeCheckers}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{.}\PYG{n+na}{checkPalindrome}\PYG{p}{(}\PYG{n}{strings}\PYG{o}{[}\PYG{n}{i}\PYG{o}{][}\PYG{l+m+mi}{1}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]++}\PYG{p}{;}\PYG{+w}{ }
\PYG{+w}{ }\PYG{c+c1}{// incrementing the appropriate counter if the number is a palindrome in that base}
\PYG{+w}{ }\PYG{n}{decCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{isDecPalindrome}\PYG{+w}{ }\PYG{o}{?}\PYG{+w}{ }\PYG{n}{decCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{:}\PYG{+w}{ }\PYG{n}{decCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// incremnting by 2, 1 for assignment, 1 for condition check}
\PYG{+w}{ }\PYG{n}{binCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{isBinPalindrome}\PYG{+w}{ }\PYG{o}{?}\PYG{+w}{ }\PYG{n}{binCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{:}\PYG{+w}{ }\PYG{n}{binCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{bothCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{isDecPalindrome}\PYG{+w}{ }\PYG{o}{\PYGZam{}\PYGZam{}}\PYG{+w}{ }\PYG{n}{isBinPalindrome}\PYG{+w}{ }\PYG{o}{?}\PYG{+w}{ }\PYG{n}{bothCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{:}\PYG{+w}{ }\PYG{n}{bothCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// 2 condition checks and one assignment, so incrementing by 3}
\PYG{+w}{ }\PYG{c+c1}{// appending to the data StringBuilder at intervals of 50,000 }
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{i}\PYG{+w}{ }\PYG{o}{\PYGZpc{}}\PYG{+w}{ }\PYG{l+m+mi}{50\PYGZus{}000}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{data}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{.}\PYG{n+na}{append}\PYG{p}{(}\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{},\PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{i}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}\PYGZbs{}n\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// calculating total time taken for method 1 and printing out the results}
\PYG{+w}{ }\PYG{n}{totalTime}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{currentTimeMillis}\PYG{p}{()}\PYG{+w}{ }\PYG{o}{\PYGZhy{}}\PYG{+w}{ }\PYG{n}{startTime}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{;}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+=}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{// incrementing by 2, 1 for getting current time and subtracting start time, 1 for assignment}
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Number of decimal palindromes found using Method \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}: \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{decCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Number of binary palindromes found using Method \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}: \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{binCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Number of palindromes in both decimal \PYGZam{} binary found using Method \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}: \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{bothCount}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{);}\PYG{+w}{ }
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Number of primitive operations taken in Method \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}: \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{operations}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Time taken for Method \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}: \PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{totalTime}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{} milliseconds\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{();}
\PYG{+w}{ }\PYG{c+c1}{// outputting the data to separate csv files}
\PYG{+w}{ }\PYG{k}{try}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n}{filename}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}method\PYGZdq{}}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{n}{j}\PYG{+w}{ }\PYG{o}{+}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}.csv\PYGZdq{}}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{File}\PYG{+w}{ }\PYG{n}{csv}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{File}\PYG{p}{(}\PYG{n}{filename}\PYG{p}{);}
\PYG{+w}{ }
\PYG{+w}{ }\PYG{c+c1}{// creating file if it doesn't already exist}
\PYG{+w}{ }\PYG{n}{csv}\PYG{p}{.}\PYG{n+na}{createNewFile}\PYG{p}{();}
\PYG{+w}{ }\PYG{n}{FileWriter}\PYG{+w}{ }\PYG{n}{writer}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{k}{new}\PYG{+w}{ }\PYG{n}{FileWriter}\PYG{p}{(}\PYG{n}{filename}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{writer}\PYG{p}{.}\PYG{n+na}{write}\PYG{p}{(}\PYG{n}{data}\PYG{o}{[}\PYG{n}{j}\PYG{o}{]}\PYG{p}{.}\PYG{n+na}{toString}\PYG{p}{());}
\PYG{+w}{ }\PYG{n}{writer}\PYG{p}{.}\PYG{n+na}{close}\PYG{p}{();}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}\PYG{+w}{ }\PYG{k}{catch}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{IOException}\PYG{+w}{ }\PYG{n}{e}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{out}\PYG{p}{.}\PYG{n+na}{println}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}IO Error occurred\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{e}\PYG{p}{.}\PYG{n+na}{printStackTrace}\PYG{p}{();}
\PYG{+w}{ }\PYG{n}{System}\PYG{p}{.}\PYG{n+na}{exit}\PYG{p}{(}\PYG{l+m+mi}{1}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// utility method to convert a decimal String to its equivalent binary String}
\PYG{+w}{ }\PYG{k+kd}{public}\PYG{+w}{ }\PYG{k+kd}{static}\PYG{+w}{ }\PYG{n}{String}\PYG{+w}{ }\PYG{n+nf}{binary2string}\PYG{p}{(}\PYG{n}{String}\PYG{+w}{ }\PYG{n}{decimalStr}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{Integer}\PYG{p}{.}\PYG{n+na}{toString}\PYG{p}{(}\PYG{n}{Integer}\PYG{p}{.}\PYG{n+na}{parseInt}\PYG{p}{(}\PYG{n}{decimalStr}\PYG{p}{),}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{);}\PYG{+w}{ }\PYG{c+c1}{// parsing the String to an int and then parsing that int to a binary String }
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

102
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-Assignment/default.pygstyle Normal file
View File

@ -0,0 +1,102 @@
\makeatletter
\def\PYG@reset{\let\PYG@it=\relax \let\PYG@bf=\relax%
\let\PYG@ul=\relax \let\PYG@tc=\relax%
\let\PYG@bc=\relax \let\PYG@ff=\relax}
\def\PYG@tok#1{\csname PYG@tok@#1\endcsname}
\def\PYG@toks#1+{\ifx\relax#1\empty\else%
\PYG@tok{#1}\expandafter\PYG@toks\fi}
\def\PYG@do#1{\PYG@bc{\PYG@tc{\PYG@ul{%
\PYG@it{\PYG@bf{\PYG@ff{#1}}}}}}}
\def\PYG#1#2{\PYG@reset\PYG@toks#1+\relax+\PYG@do{#2}}
\@namedef{PYG@tok@w}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
\@namedef{PYG@tok@c}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cp}{\def\PYG@tc##1{\textcolor[rgb]{0.61,0.40,0.00}{##1}}}
\@namedef{PYG@tok@k}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kp}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kt}{\def\PYG@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}}
\@namedef{PYG@tok@o}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ow}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
\@namedef{PYG@tok@nb}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@nf}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@nc}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@nn}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@ne}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.80,0.25,0.22}{##1}}}
\@namedef{PYG@tok@nv}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@no}{\def\PYG@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}}
\@namedef{PYG@tok@nl}{\def\PYG@tc##1{\textcolor[rgb]{0.46,0.46,0.00}{##1}}}
\@namedef{PYG@tok@ni}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.44,0.44,0.44}{##1}}}
\@namedef{PYG@tok@na}{\def\PYG@tc##1{\textcolor[rgb]{0.41,0.47,0.13}{##1}}}
\@namedef{PYG@tok@nt}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@nd}{\def\PYG@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
\@namedef{PYG@tok@s}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sd}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@si}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.64,0.35,0.47}{##1}}}
\@namedef{PYG@tok@se}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.67,0.36,0.12}{##1}}}
\@namedef{PYG@tok@sr}{\def\PYG@tc##1{\textcolor[rgb]{0.64,0.35,0.47}{##1}}}
\@namedef{PYG@tok@ss}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@sx}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@m}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@gh}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
\@namedef{PYG@tok@gu}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
\@namedef{PYG@tok@gd}{\def\PYG@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
\@namedef{PYG@tok@gi}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.52,0.00}{##1}}}
\@namedef{PYG@tok@gr}{\def\PYG@tc##1{\textcolor[rgb]{0.89,0.00,0.00}{##1}}}
\@namedef{PYG@tok@ge}{\let\PYG@it=\textit}
\@namedef{PYG@tok@gs}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@ges}{\let\PYG@bf=\textbf\let\PYG@it=\textit}
\@namedef{PYG@tok@gp}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
\@namedef{PYG@tok@go}{\def\PYG@tc##1{\textcolor[rgb]{0.44,0.44,0.44}{##1}}}
\@namedef{PYG@tok@gt}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}}
\@namedef{PYG@tok@err}{\def\PYG@bc##1{{\setlength{\fboxsep}{\string -\fboxrule}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}}
\@namedef{PYG@tok@kc}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kd}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kn}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kr}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@bp}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@fm}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@vc}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vg}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vi}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vm}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@sa}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sb}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sc}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@dl}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@s2}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sh}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@s1}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@mb}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mf}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mh}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mi}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@il}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mo}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ch}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cm}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cpf}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@c1}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cs}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\def\PYGZbs{\char`\\}
\def\PYGZus{\char`\_}
\def\PYGZob{\char`\{}
\def\PYGZcb{\char`\}}
\def\PYGZca{\char`\^}
\def\PYGZam{\char`\&}
\def\PYGZlt{\char`\<}
\def\PYGZgt{\char`\>}
\def\PYGZsh{\char`\#}
\def\PYGZpc{\char`\%}
\def\PYGZdl{\char`\$}
\def\PYGZhy{\char`\-}
\def\PYGZsq{\char`\'}
\def\PYGZdq{\char`\"}
\def\PYGZti{\char`\~}
% for compatibility with earlier versions
\def\PYGZat{@}
\def\PYGZlb{[}
\def\PYGZrb{]}
\makeatother

11
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/029678432C3357E17D8F67719336365C8036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,11 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{+w}{ }\PYG{c+c1}{// test length function}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// printf("%s\n", current->data);}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

81
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/1A95A9002C47C778754A89C6E2D5A94D1A36457761F954A859ACF098C72F31FE.pygtex Normal file
View File

@ -0,0 +1,81 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZlt{}stdio.h\PYGZgt{}}
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZdq{}tests.h\PYGZdq{}}
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZdq{}genericLinkedList.h\PYGZdq{}}
\PYG{c+c1}{// functions to print out different data types}
\PYG{c+c1}{// a more professional design might be to put these in the genericLinkedList header file but i only need these for testing purposes}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{printChar}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}\PYGZpc{}c}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{o}{*}\PYG{p}{(}\PYG{k+kt}{char}\PYG{o}{*}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{printStr}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}\PYGZpc{}s}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{p}{(}\PYG{k+kt}{char}\PYG{o}{*}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{printInt}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}\PYGZpc{}d}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{o}{*}\PYG{p}{(}\PYG{k+kt}{int}\PYG{o}{*}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{runTests}\PYG{p}{()\PYGZob{}}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Tests running...}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{l}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Test String (1).\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Test String (1).\PYGZdq{}}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{//printf(\PYGZdq{}\PYGZpc{}s\PYGZbs{}n\PYGZpc{}p\PYGZbs{}n\PYGZdq{}, l\PYGZhy{}\PYGZgt{}data, l\PYGZhy{}\PYGZgt{}next);}
\PYG{+w}{ }\PYG{c+c1}{//Test create and traverse}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{//Test insert after}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing insertAfter()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{l2}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{insertAfter}\PYG{p}{(}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}another string (2)\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}another string (2)\PYGZdq{}}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{insertAfter}\PYG{p}{(}\PYG{n}{l2}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}a final string (3)\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}a final string (3)\PYGZdq{}}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test length function}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing length()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{l\PYGZus{}length}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{length}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The length of l is \PYGZpc{}d}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{l\PYGZus{}length}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test push}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing push()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{push}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}yet another test string\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}yet another test string\PYGZdq{}}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test pop}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing pop()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{popped}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{pop}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// Test delete after}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing deleteAfter()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{deleteAfter}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test enqueue}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing enqueue()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{enqueue}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}enqueued test string\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}enqueued test string\PYGZdq{}}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printStr}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test dequeue}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing dequeue()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{dequeue}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing pushing different data types}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{myint}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{42}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{push}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{o}{\PYGZam{}}\PYG{n}{myint}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{myint}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printInt}\PYG{p}{);}
\PYG{+w}{ }\PYG{k+kt}{char}\PYG{+w}{ }\PYG{n}{mychar}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+s+sc}{\PYGZsq{}c\PYGZsq{}}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{push}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{o}{\PYGZam{}}\PYG{n}{mychar}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{mychar}\PYG{p}{),}\PYG{+w}{ }\PYG{n}{printChar}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{Tests complete.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

38
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/1F1491E7C9B6B58BBB12C114E8BC964B8036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,38 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{+w}{ }\PYG{c+c1}{// test length function}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing length()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{l\PYGZus{}length}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{length}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The length of l is \PYGZpc{}d}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{l\PYGZus{}length}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test push}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing push()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{push}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}yet another test string\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}yet another test string\PYGZdq{}}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test pop}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing pop()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{popped}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{pop}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// Test delete after}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing deleteAfter()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{deleteAfter}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test enqueue}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing enqueue()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{enqueue}\PYG{p}{(}\PYG{o}{\PYGZam{}}\PYG{n}{l}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}enqueued test string\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}enqueued test string\PYGZdq{}}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// test dequeue}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}Testing dequeue()}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{dequeue}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{traverse}\PYG{p}{(}\PYG{n}{l}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{Tests complete.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\end{Verbatim}

37
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/1FB0137737E0F3FCAF66A5D295DB0F53249AF62F0291B765A68674C7DFD57EF4.pygtex Normal file
View File

@ -0,0 +1,37 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{c+cp}{\PYGZsh{}ifndef CT331\PYGZus{}ASSIGNMENT\PYGZus{}LINKED\PYGZus{}LIST}
\PYG{c+cp}{\PYGZsh{}define CT331\PYGZus{}ASSIGNMENT\PYGZus{}LINKED\PYGZus{}LIST}
\PYG{k}{typedef}\PYG{+w}{ }\PYG{k}{struct}\PYG{+w}{ }\PYG{n+nc}{listElementStruct}\PYG{+w}{ }\PYG{n}{listElement}\PYG{p}{;}
\PYG{c+c1}{//Creates a new linked list element with given content of size}
\PYG{c+c1}{//Returns a pointer to the element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{createEl}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{//Prints out each element in the list}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{);}
\PYG{c+c1}{//Inserts a new element after the given el}
\PYG{c+c1}{//Returns the pointer to the new element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{insertAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{after}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{//Delete the element after the given el}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{deleteAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{after}\PYG{p}{);}
\PYG{c+c1}{// returns the number of elements in the list}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{length}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// push a new element onto the head of a list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{push}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{// pop an element from the head of a list and update the list reference using side effects}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{pop}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// enque a new element onto the head of the list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{enqueue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}\PYG{+w}{ }
\PYG{c+c1}{// dequeue an element from the tail of the list }
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{dequeue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}\PYG{+w}{ }
\PYG{c+cp}{\PYGZsh{}endif}
\end{Verbatim}

37
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/1FB0137737E0F3FCAF66A5D295DB0F53B607CDE1198E340A1D2D5D290427B540.pygtex Normal file
View File

@ -0,0 +1,37 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+cp}{\PYGZsh{}ifndef CT331_ASSIGNMENT_LINKED_LIST}
\PYG{c+cp}{#define CT331_ASSIGNMENT_LINKED_LIST}
\PYG{k}{typedef}\PYG{+w}{ }\PYG{k}{struct}\PYG{+w}{ }\PYG{n+nc}{listElementStruct}\PYG{+w}{ }\PYG{n}{listElement}\PYG{p}{;}
\PYG{c+c1}{//Creates a new linked list element with given content of size}
\PYG{c+c1}{//Returns a pointer to the element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{createEl}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{//Prints out each element in the list}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{);}
\PYG{c+c1}{//Inserts a new element after the given el}
\PYG{c+c1}{//Returns the pointer to the new element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{insertAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{after}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{//Delete the element after the given el}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{deleteAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{after}\PYG{p}{);}
\PYG{c+c1}{// returns the number of elements in the list}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{length}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// push a new element onto the head of a list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{push}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}
\PYG{c+c1}{// pop an element from the head of a list and update the list reference using side effects}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{pop}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// enque a new element onto the head of the list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{enqueue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{));}\PYG{+w}{ }
\PYG{c+c1}{// dequeue an element from the tail of the list }
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{dequeue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}\PYG{+w}{ }
\PYG{c+cp}{\PYGZsh{}endif}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/68B329DA9893E34099C7D8AD5CB9C9408036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\end{Verbatim}

16
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/7E9FFB85CF1323BABAFAED8087D01C788036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,16 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// returns the number of elements in the list}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{length}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// push a new element onto the head of a list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{push}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{char}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{);}
\PYG{c+c1}{// pop an element from the head of a list and update the list reference using side effects}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{pop}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\PYG{c+c1}{// enque a new element onto the head of the list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{enqueue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{char}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{);}
\PYG{c+c1}{// dequeue an element from the tail of the list}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{dequeue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{);}
\end{Verbatim}

103
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/B04351EF07D465836A8BAA204EC428288036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,103 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+c1}{// returns the number of elements in the list}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{length}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{length}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// traversing the list and counting each element}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{length}\PYG{o}{++}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{length}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// push a new element onto the head of a list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{push}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{char}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// create the new element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// handle malloc errors}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{fprintf}\PYG{p}{(}\PYG{n}{stderr}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}Memory allocation failed.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{exit}\PYG{p}{(}\PYG{n}{EXIT\PYGZus{}FAILURE}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// make the the new element point to the current head of the list}
\PYG{+w}{ }\PYG{n}{newElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the list reference to point to the new head element}
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// pop an element from the head of a list and update the list reference using side effects}
\PYG{c+c1}{// assuming that the desired return value here is the popped element, as is standard for POP operations}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{pop}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// don't bother if list is non existent}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// getting reference to the element to be popped}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the the second element the new head of the list -- this could be NULL, so the list would be NULL also}
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{list}\PYG{p}{)}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// detach the popped element from the list}
\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// enque a new element onto the head of the list and update the list reference using side effects}
\PYG{c+c1}{// essentially the same as push}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{enqueue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{char}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// create the new element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// handle malloc errors}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{fprintf}\PYG{p}{(}\PYG{n}{stderr}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}Memory allocation failed.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{exit}\PYG{p}{(}\PYG{n}{EXIT\PYGZus{}FAILURE}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// make the the new element point to the current head of the list}
\PYG{+w}{ }\PYG{n}{newElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the list reference to point to the new head element}
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// dequeue an element from the tail of the list by removing the element from the list via side effects, and returning the removed item}
\PYG{c+c1}{// 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}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{dequeue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// there are three cases that we must consider: a list with 0 elements, a list with 1 element, & a list with >=2 elements}
\PYG{+w}{ }\PYG{c+c1}{// don't bother if list is non existent}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// if there is only one element in the list, i.e. the head element is also the tail element, just returning this element}
\PYG{+w}{ }\PYG{c+c1}{// this means that the listElement pointer that was passed to this function won't be updated}
\PYG{+w}{ }\PYG{c+c1}{// 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}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{list}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// traversing the list to find the second-to-last element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// get reference to the element to be dequeued}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{dequeuedElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the penultimate element the tail by removing reference to the old tail}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

169
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/BA3CE221DBA6F673B9B4439DCB71334630934B80947DC8CA2F985E86714196E3.pygtex Normal file
View File

@ -0,0 +1,169 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZlt{}stdio.h\PYGZgt{}}
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZlt{}stdlib.h\PYGZgt{}}
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZlt{}string.h\PYGZgt{}}
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZdq{}genericLinkedList.h\PYGZdq{}}
\PYG{k}{typedef}\PYG{+w}{ }\PYG{k}{struct}\PYG{+w}{ }\PYG{n+nc}{listElementStruct}\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{);}
\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{struct}\PYG{+w}{ }\PYG{n+nc}{listElementStruct}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{next}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}\PYG{+w}{ }\PYG{n}{listElement}\PYG{p}{;}
\PYG{c+c1}{//Creates a new linked list element with given content of size}
\PYG{c+c1}{//Returns a pointer to the element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{createEl}\PYG{p}{(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{e}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{malloc}\PYG{p}{(}\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{listElement}\PYG{p}{));}
\PYG{+w}{ }\PYG{k}{if}\PYG{p}{(}\PYG{n}{e}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{//malloc has had an error}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{//return NULL to indicate an error.}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{dataPointer}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{malloc}\PYG{p}{(}\PYG{k}{sizeof}\PYG{p}{(}\PYG{k+kt}{void}\PYG{p}{)}\PYG{o}{*}\PYG{n}{size}\PYG{p}{);}
\PYG{+w}{ }\PYG{k}{if}\PYG{p}{(}\PYG{n}{dataPointer}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{//malloc has had an error}
\PYG{+w}{ }\PYG{n}{free}\PYG{p}{(}\PYG{n}{e}\PYG{p}{);}\PYG{+w}{ }\PYG{c+c1}{//release the previously allocated memory}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{c+c1}{//return NULL to indicate an error.}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{n}{strcpy}\PYG{p}{(}\PYG{n}{dataPointer}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{e}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{dataPointer}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{e}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{printFunction}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{e}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{size}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{e}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{e}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{//Prints out each element in the list}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// printf(\PYGZdq{}\PYGZpc{}s\PYGZbs{}n\PYGZdq{}, current\PYGZhy{}\PYGZgt{}data);}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{//Inserts a new element after the given el}
\PYG{c+c1}{//Returns the pointer to the new element}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{insertAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{el}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{))\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newEl}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{printFunction}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{el}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{newEl}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{el}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newEl}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{newEl}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{//Delete the element after the given el}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{deleteAfter}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{after}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{delete}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{after}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newNext}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{delete}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{after}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newNext}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{//need to free the memory because we used malloc}
\PYG{+w}{ }\PYG{n}{free}\PYG{p}{(}\PYG{n}{delete}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{free}\PYG{p}{(}\PYG{n}{delete}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// returns the number of elements in the list}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{length}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{length}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// traversing the list and counting each element}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{length}\PYG{o}{++}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{length}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// push a new element onto the head of a list and update the list reference using side effects}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{push}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// create the new element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{printFunction}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// handle malloc errors}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{fprintf}\PYG{p}{(}\PYG{n}{stderr}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}Memory allocation failed.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{exit}\PYG{p}{(}\PYG{n}{EXIT\PYGZus{}FAILURE}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// make the the new element point to the current head of the list}
\PYG{+w}{ }\PYG{n}{newElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the list reference to point to the new head element }
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// pop an element from the head of a list and update the list reference using side effects}
\PYG{c+c1}{// assuming that the desired return value here is the popped element, as is standard for POP operations}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{pop}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// don\PYGZsq{}t bother if list is non existent}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{;}\PYG{+w}{ }
\PYG{+w}{ }\PYG{c+c1}{// getting reference to the element to be popped}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the the second element the new head of the list \PYGZhy{}\PYGZhy{} this could be NULL, so the list would be NULL also}
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{list}\PYG{p}{)}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// detach the popped element from the list}
\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{poppedElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\PYG{c+c1}{// enque a new element onto the head of the list and update the list reference using side effects}
\PYG{c+c1}{// essentially the same as push}
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{enqueue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{**}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{size\PYGZus{}t}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{k+kt}{void}\PYG{+w}{ }\PYG{p}{(}\PYG{o}{*}\PYG{n}{printFunction}\PYG{p}{)(}\PYG{k+kt}{void}\PYG{o}{*}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// create the new element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{createEl}\PYG{p}{(}\PYG{n}{data}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{size}\PYG{p}{,}\PYG{+w}{ }\PYG{n}{printFunction}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// handle malloc errors}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{newElement}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{fprintf}\PYG{p}{(}\PYG{n}{stderr}\PYG{p}{,}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}Memory allocation failed.}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{exit}\PYG{p}{(}\PYG{n}{EXIT\PYGZus{}FAILURE}\PYG{p}{);}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// make the the new element point to the current head of the list}
\PYG{+w}{ }\PYG{n}{newElement}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the list reference to point to the new head element }
\PYG{+w}{ }\PYG{o}{*}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{newElement}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}\PYG{+w}{ }
\PYG{c+c1}{// dequeue an element from the tail of the list by removing the element from the list via side effects, and returning the removed item}
\PYG{c+c1}{// 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}
\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n+nf}{dequeue}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{c+c1}{// there are three cases that we must consider: a list with 0 elements, a list with 1 element, \PYGZam{} a list with \PYGZgt{}=2 elements}
\PYG{+w}{ }\PYG{c+c1}{// don\PYGZsq{}t bother if list is non existent}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{list}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// if there is only one element in the list, i.e. the head element is also the tail element, just returning this element}
\PYG{+w}{ }\PYG{c+c1}{// this means that the listElement pointer that was passed to this function won\PYGZsq{}t be updated}
\PYG{+w}{ }\PYG{c+c1}{// ideally, we would set it to NULL but we can\PYGZsq{}t do that since `list` is a pointer that has been passed by value, so we can\PYGZsq{}t update the pointer itself. we would need a pointer to a pointer to have been passed }
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{list}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// traversing the list to find the second\PYGZhy{}to\PYGZhy{}last element}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{c+c1}{// get reference to the element to be dequeued}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{dequeuedElement}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{c+c1}{// make the penultimate element the tail by removing reference to the old tail}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{return}\PYG{+w}{ }\PYG{n}{list}\PYG{p}{;}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

17
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/C18C4CDF79AC226A7A04309B6962B8D62071C0D8F387700F244E791134038122.pygtex Normal file
View File

@ -0,0 +1,17 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{c+cp}{\PYGZsh{}include}\PYG{+w}{ }\PYG{c+cpf}{\PYGZlt{}stdio.h>}
\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n+nf}{main}\PYG{p}{()}\PYG{+w}{ }\PYG{p}{\PYGZob{}}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{+w}{ }\PYG{n}{my\PYGZus{}int}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{int}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{my\PYGZus{}int\PYGZus{}pointer}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{long}\PYG{+w}{ }\PYG{n}{my\PYGZus{}long}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{double}\PYG{+w}{ }\PYG{o}{*}\PYG{+w}{ }\PYG{n}{my\PYGZus{}double\PYGZus{}pointer}\PYG{p}{;}
\PYG{+w}{ }\PYG{k+kt}{char}\PYG{+w}{ }\PYG{o}{**}\PYG{+w}{ }\PYG{n}{my\PYGZus{}char\PYGZus{}pointer\PYGZus{}pointer}\PYG{p}{;}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The size of my\PYGZus{}int is \PYGZpc{}lu bytes}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{my\PYGZus{}int}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The size of my\PYGZus{}int\PYGZus{}pointer is \PYGZpc{}lu bytes}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{my\PYGZus{}int\PYGZus{}pointer}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The size of my\PYGZus{}long is \PYGZpc{}lu bytes}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{my\PYGZus{}long}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The size of my\PYGZus{}double\PYGZus{}pointer is \PYGZpc{}lu bytes}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{my\PYGZus{}double\PYGZus{}pointer}\PYG{p}{));}
\PYG{+w}{ }\PYG{n}{printf}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}The size of my\PYGZus{}char\PYGZus{}pointer\PYGZus{}pointer is \PYGZpc{}lu bytes}\PYG{l+s+se}{\PYGZbs{}n}\PYG{l+s}{\PYGZdq{}}\PYG{p}{,}\PYG{+w}{ }\PYG{k}{sizeof}\PYG{p}{(}\PYG{n}{my\PYGZus{}char\PYGZus{}pointer\PYGZus{}pointer}\PYG{p}{));}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

10
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/DE3DE02B3699B2AD02A915E81DC231427ED3B9CF2466D9579DA5CFBB803383B4.pygtex Normal file
View File

@ -0,0 +1,10 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// printf(\PYGZdq{}\PYGZpc{}s\PYGZbs{}n\PYGZdq{}, current\PYGZhy{}\PYGZgt{}data);}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

10
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/DE3DE02B3699B2AD02A915E81DC231428036C43350D1B6692878CC2F1231127B.pygtex Normal file
View File

@ -0,0 +1,10 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{start}\PYG{p}{;}
\PYG{+w}{ }\PYG{k}{while}\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{!=}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{+w}{ }\PYG{c+c1}{// printf("%s\n", current->data);}
\PYG{+w}{ }\PYG{n}{current}\PYG{+w}{ }\PYG{o}{=}\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{;}
\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

7
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/EB991567A7D9034FBB3E85C83233F027E5CBDF67C53A811512DB313AC27C28B0.pygtex Normal file
View File

@ -0,0 +1,7 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{k+kt}{void}\PYG{+w}{ }\PYG{n+nf}{reverse\PYGZus{}traverse}\PYG{p}{(}\PYG{n}{listElement}\PYG{o}{*}\PYG{+w}{ }\PYG{n}{current}\PYG{p}{)\PYGZob{}}
\PYG{+w}{ }\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{current}\PYG{+w}{ }\PYG{o}{==}\PYG{+w}{ }\PYG{n+nb}{NULL}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{\PYGZob{}}\PYG{+w}{ }\PYG{k}{return}\PYG{p}{;}\PYG{+w}{ }\PYG{p}{\PYGZcb{}}
\PYG{+w}{ }\PYG{n}{reverse\PYGZus{}traverse}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{next}\PYG{p}{);}
\PYG{+w}{ }\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{printFunction}\PYG{p}{(}\PYG{n}{current}\PYG{o}{\PYGZhy{}\PYGZgt{}}\PYG{n}{data}\PYG{p}{);}
\PYG{p}{\PYGZcb{}}
\end{Verbatim}

102
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/_minted-CT331-Assignment-1/default.pygstyle Normal file
View File

@ -0,0 +1,102 @@
\makeatletter
\def\PYG@reset{\let\PYG@it=\relax \let\PYG@bf=\relax%
\let\PYG@ul=\relax \let\PYG@tc=\relax%
\let\PYG@bc=\relax \let\PYG@ff=\relax}
\def\PYG@tok#1{\csname PYG@tok@#1\endcsname}
\def\PYG@toks#1+{\ifx\relax#1\empty\else%
\PYG@tok{#1}\expandafter\PYG@toks\fi}
\def\PYG@do#1{\PYG@bc{\PYG@tc{\PYG@ul{%
\PYG@it{\PYG@bf{\PYG@ff{#1}}}}}}}
\def\PYG#1#2{\PYG@reset\PYG@toks#1+\relax+\PYG@do{#2}}
\@namedef{PYG@tok@w}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.73,0.73}{##1}}}
\@namedef{PYG@tok@c}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cp}{\def\PYG@tc##1{\textcolor[rgb]{0.61,0.40,0.00}{##1}}}
\@namedef{PYG@tok@k}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kp}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kt}{\def\PYG@tc##1{\textcolor[rgb]{0.69,0.00,0.25}{##1}}}
\@namedef{PYG@tok@o}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ow}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
\@namedef{PYG@tok@nb}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@nf}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@nc}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@nn}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@ne}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.80,0.25,0.22}{##1}}}
\@namedef{PYG@tok@nv}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@no}{\def\PYG@tc##1{\textcolor[rgb]{0.53,0.00,0.00}{##1}}}
\@namedef{PYG@tok@nl}{\def\PYG@tc##1{\textcolor[rgb]{0.46,0.46,0.00}{##1}}}
\@namedef{PYG@tok@ni}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.44,0.44,0.44}{##1}}}
\@namedef{PYG@tok@na}{\def\PYG@tc##1{\textcolor[rgb]{0.41,0.47,0.13}{##1}}}
\@namedef{PYG@tok@nt}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@nd}{\def\PYG@tc##1{\textcolor[rgb]{0.67,0.13,1.00}{##1}}}
\@namedef{PYG@tok@s}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sd}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@si}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.64,0.35,0.47}{##1}}}
\@namedef{PYG@tok@se}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.67,0.36,0.12}{##1}}}
\@namedef{PYG@tok@sr}{\def\PYG@tc##1{\textcolor[rgb]{0.64,0.35,0.47}{##1}}}
\@namedef{PYG@tok@ss}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@sx}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@m}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@gh}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
\@namedef{PYG@tok@gu}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.50,0.00,0.50}{##1}}}
\@namedef{PYG@tok@gd}{\def\PYG@tc##1{\textcolor[rgb]{0.63,0.00,0.00}{##1}}}
\@namedef{PYG@tok@gi}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.52,0.00}{##1}}}
\@namedef{PYG@tok@gr}{\def\PYG@tc##1{\textcolor[rgb]{0.89,0.00,0.00}{##1}}}
\@namedef{PYG@tok@ge}{\let\PYG@it=\textit}
\@namedef{PYG@tok@gs}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@ges}{\let\PYG@bf=\textbf\let\PYG@it=\textit}
\@namedef{PYG@tok@gp}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,0.50}{##1}}}
\@namedef{PYG@tok@go}{\def\PYG@tc##1{\textcolor[rgb]{0.44,0.44,0.44}{##1}}}
\@namedef{PYG@tok@gt}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.27,0.87}{##1}}}
\@namedef{PYG@tok@err}{\def\PYG@bc##1{{\setlength{\fboxsep}{\string -\fboxrule}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}}
\@namedef{PYG@tok@kc}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kd}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kn}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@kr}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@bp}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.50,0.00}{##1}}}
\@namedef{PYG@tok@fm}{\def\PYG@tc##1{\textcolor[rgb]{0.00,0.00,1.00}{##1}}}
\@namedef{PYG@tok@vc}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vg}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vi}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@vm}{\def\PYG@tc##1{\textcolor[rgb]{0.10,0.09,0.49}{##1}}}
\@namedef{PYG@tok@sa}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sb}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sc}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@dl}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@s2}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@sh}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@s1}{\def\PYG@tc##1{\textcolor[rgb]{0.73,0.13,0.13}{##1}}}
\@namedef{PYG@tok@mb}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mf}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mh}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mi}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@il}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@mo}{\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ch}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cm}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cpf}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@c1}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\@namedef{PYG@tok@cs}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.24,0.48,0.48}{##1}}}
\def\PYGZbs{\char`\\}
\def\PYGZus{\char`\_}
\def\PYGZob{\char`\{}
\def\PYGZcb{\char`\}}
\def\PYGZca{\char`\^}
\def\PYGZam{\char`\&}
\def\PYGZlt{\char`\<}
\def\PYGZgt{\char`\>}
\def\PYGZsh{\char`\#}
\def\PYGZpc{\char`\%}
\def\PYGZdl{\char`\$}
\def\PYGZhy{\char`\-}
\def\PYGZsq{\char`\'}
\def\PYGZdq{\char`\"}
\def\PYGZti{\char`\~}
% for compatibility with earlier versions
\def\PYGZat{@}
\def\PYGZlb{[}
\def\PYGZrb{]}
\makeatother

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/images/question1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 24 KiB

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/images/question2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 67 KiB

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/latex/images/question3.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 75 KiB

13
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question1/Question1.c Normal file
View File

@ -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;
}

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question1/a.out Executable file
View File

Binary file not shown.

8
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/assignment-1.c Normal file
View File

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

61
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/linkedList-1.c Normal file
View File

@ -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);
}

21
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/linkedList-1.h Normal file
View File

@ -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

25
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/tests.c Normal file
View File

@ -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");
}

6
third/semester1/CT331: Programming Paradigms/assignments/assignment1/provided/question2/tests.h Normal file
View File

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

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment2/CT331 - Assignment 2 - Scheme.pdf Normal file
View File

Binary file not shown.

22
third/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q1.rkt Normal file
View File

@ -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)))

93
third/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q2.rkt Normal file
View File

@ -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))
)
)
)

145
third/semester1/CT331: Programming Paradigms/assignments/assignment2/code/assignment_q3.rkt Normal file
View File

@ -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)
)
)

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/CT331-Assignment-2.pdf Normal file
View File

Binary file not shown.

142
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/CT331-Assignment-2.tex Normal file
View File

@ -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}

22
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/058814168EBBEDE27DD80B112E3D4715B1EA46D3ACCB13BB6D8D2A320AB6E534.pygtex Normal file
View File

@ -0,0 +1,22 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{o}{\PYGZsh{}}\PYG{n+nv}{lang}\PYG{+w}{ }\PYG{n+nv}{racket}
\PYG{c+c1}{;; a cons pair of two numbers}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{)}
\PYG{c+c1}{;; a list of 3 numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)))}\PYG{+w}{ }
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)))}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the list function}
\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{))}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the append function}
\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{((}\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)))}
\end{Verbatim}

22
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/058814168EBBEDE27DD80B112E3D4715C16DB9C5EE5FCF68F0B62390B5ABE044.pygtex Normal file
View File

@ -0,0 +1,22 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{err}{\PYGZsh{}}\PYG{n+nv}{lang}\PYG{+w}{ }\PYG{n+nv}{racket}
\PYG{c+c1}{;; a cons pair of two numbers}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{)}
\PYG{c+c1}{;; a list of 3 numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)))}\PYG{+w}{ }
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)))}\PYG{+w}{ }\PYG{n+nv}{empty}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the list function}
\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{))}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the append function}
\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+s}{\PYGZdq{}a string\PYGZdq{}}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{((}\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)))}
\end{Verbatim}

22
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/058814168EBBEDE27DD80B112E3D4715D25BB12A87696D8DE6ECCFBBA4014A5F.pygtex Normal file
View File

@ -0,0 +1,22 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{k+kn}{\PYGZsh{}lang }\PYG{n+nn}{racket}
\PYG{c+c1}{;; a cons pair of two numbers}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{)}
\PYG{c+c1}{;; a list of 3 numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)))}\PYG{+w}{ }
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)))}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the list function}
\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{))}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the append function}
\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{p}{(}\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)))}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/229E6C5D55F5C19D070D9C1B3EB6BAFA880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nb}{cons}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/26AB0DB90D72E28AD0BA1E22EE510510880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+m+mi}{2}
\end{Verbatim}

24
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/2B2C2C5067A5C85E076A998DEBE8BA662310CE7020B3E4C6B774EC9329C69276.pygtex Normal file
View File

@ -0,0 +1,24 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kn}{\PYGZsh{}lang }\PYG{n+nn}{racket}
\PYG{c+c1}{;; a cons pair of two numbers}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{p}{)}
\PYG{c+c1}{;; a list of 3 numbers using only the cons function}
\PYG{c+c1}{;; 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}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)))}\PYG{+w}{ }
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers using only the cons function}
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)))}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the list function}
\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{))}
\PYG{c+c1}{;; a list containing a string, a number, and a nested list of three numbers, using only the append function}
\PYG{c+c1}{;; using `'` as the arguments of the `append` function must be themselves lists}
\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{0}\PYG{p}{)}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{p}{(}\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)))}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/3DAE3C828242602421770A5CB1181E68880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+no}{\PYGZsh{}f}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/409E5B8F229BA1444F78DBE61235E7ED880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nb}{append}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/43BE2F60A6DB7BF23ED742E2B13AB659880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nb}{list}
\end{Verbatim}

28
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/4F731F09E1CEA031D270F0F3CD510B3F5F05F44EA61ED24E098FB0159115E6FF.pygtex Normal file
View File

@ -0,0 +1,28 @@
\begin{Verbatim}[commandchars=\\\{\},codes={\catcode`\$=3\catcode`\^=7\catcode`\_=8\relax}]
\PYG{k+kn}{\PYGZsh{}lang }\PYG{n+nn}{racket}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{ins\PYGZus{}beg}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{ins\PYGZus{}end}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{p}{)}
\PYG{c+c1}{;; function to insert an element at the beginning of a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{ins\PYGZus{}beg}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; assuming that the second element is always a list}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert an element at the end of a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{ins\PYGZus{}end}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; making el into a list if it isn't already}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{))}
\PYG{p}{)}
\PYG{c+c1}{;; function to count the number of top-level items in a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{c+c1}{;; return 0 if we've reached the end of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)))}\PYG{+w}{ }\PYG{c+c1}{;; return 1 plus the count_top_level of the second element of the cons pair (the rest of the list)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\end{Verbatim}

95
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/55815CE6861EE14CEEB1C1DE8C45BE9F157B6AA82AB25C06626F9D997338A3E2.pygtex Normal file
View File

@ -0,0 +1,95 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{k+kn}{\PYGZsh{}lang }\PYG{n+nn}{racket}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{ins\PYGZus{}beg}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{ins\PYGZus{}end}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{count\PYGZus{}instances}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{count\PYGZus{}instances\PYGZus{}tr}\PYG{p}{)}
\PYG{p}{(}\PYG{k}{provide}\PYG{+w}{ }\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{p}{)}
\PYG{c+c1}{;; function to insert an element at the beginning of a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{ins\PYGZus{}beg}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; assuming that the second element is always a list}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert an element at the end of a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{ins\PYGZus{}end}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; making el into a list if it isn\PYGZsq{}t already}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{append}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{n}{el}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{))}
\PYG{p}{)}
\PYG{c+c1}{;; function to count the number of top\PYGZhy{}level items in a list}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{c+c1}{;; return 0 if we\PYGZsq{}ve reached the end of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}top\PYGZus{}level}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)))}\PYG{+w}{ }\PYG{c+c1}{;; return 1 plus the count\PYGZus{}top\PYGZus{}level of the second element of the cons pair (the rest of the list)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; non\PYGZhy{}tail recursive function to count the number of times a given item occurs in a list (assuming items are atomic)}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{c+c1}{;; return 0 if at the end of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{equal?}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}
\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{c+c1}{;; if the item is equal to the first element of the list, add 1}
\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{+w}{ }\PYG{c+c1}{;; if the item is not equal to the first element of the list, add 0}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}\PYG{+w}{ }\PYG{c+c1}{;; recurse with the remainder of the list}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; helper function for count\PYGZus{}instances\PYGZus{}tr}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}tr\PYGZus{}helper}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{n}{cnt}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; return the count if the end of the list is reached (0 for empty list)}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{n}{cnt}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the first element of the list is equal to the item }
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{eq?}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{item}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; recurse with the remainder of the list and an incremented count}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}tr\PYGZus{}helper}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}\PYG{+w}{ }\PYG{n}{cnt}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the first element of the list is not equal to the item}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{else}
\PYG{+w}{ }\PYG{c+c1}{;; recurse with the remainder of the list and an unchanged count}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}tr\PYGZus{}helper}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{cnt}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; tail recursive function to count the number of times a given item occurs in a list (assuming items are atomic)}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}tr}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; calling helper function with the list and the count so far (0)}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}tr\PYGZus{}helper}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{l+m+mi}{0}\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to count the number of times an item occurs in a list and its sub\PYGZhy{}lists}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; return nothing if we\PYGZsq{}ve reached the end of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{l+m+mi}{0}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the first item is a list, recurse through the first element and then the rest and return the sum of the two results}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{pair?}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the first element is equal to the item, add 1 to the count and recurse with the rest of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{eq?}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}\PYG{+w}{ }\PYG{c+c1}{; If the first element is equal to the item, increment count}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{+}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; else if the first element is not equal to the item, recurse with the rest of the list}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{else}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{count\PYGZus{}instances\PYGZus{}deep}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/56553CEBB20C9B7F45351AA13B36DE78880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{))}
\end{Verbatim}

147
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/6B97E9BC9143A3C434CC5440AF0952CAF4B1E7A979809C631FAFC8B135DD56D6.pygtex Normal file
View File

@ -0,0 +1,147 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{k+kn}{\PYGZsh{}lang }\PYG{n+nn}{racket}
\PYG{c+c1}{;; function to display the contents of a binary search tree in sorted order}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{display\PYGZus{}contents}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; if the binary search tree is null, print an empty string (nothing)}
\PYG{+w}{ }\PYG{p}{[}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{display}\PYG{+w}{ }\PYG{l+s+s2}{\PYGZdq{}\PYGZdq{}}\PYG{p}{)]}
\PYG{+w}{ }\PYG{c+c1}{;; if the binary search tree has nodes}
\PYG{+w}{ }\PYG{p}{[}\PYG{k}{else}\PYG{+w}{ }
\PYG{+w}{ }\PYG{c+c1}{;; display the contents of the left sub\PYGZhy{}tree of the current node}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{display\PYGZus{}contents}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{c+c1}{;; display the current node}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{display}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{newline}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; display the contents of the right sub\PYGZhy{}tree of the current node}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{display\PYGZus{}contents}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{]}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to search a tree and tell whether a given item is presesnt in a given tree}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{search\PYGZus{}tree}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; return false if we\PYGZsq{}ve reached the end of the tree without finding a match}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}f}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; return true if the current node is equal to the item}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{equal?}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}t}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; else return whether the item was found in the left sub\PYGZhy{}tree or the right sub\PYGZhy{}tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{else}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{or}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{search\PYGZus{}tree}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}\PYG{+w}{ }\PYG{c+c1}{;; search left sub\PYGZhy{}tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{search\PYGZus{}tree}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}\PYG{+w}{ }\PYG{c+c1}{;; search right sub\PYGZhy{}tree}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert an item into a binary search tree}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; if there are no nodes in the tree, create a new tree with the item as the root}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{()}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{())}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the item is less than the current node, insert it into the left\PYGZhy{}hand side of the tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{\PYGZlt{}}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{c+c1}{;; create new bst with same root node, same right\PYGZhy{}hand side, but a left\PYGZhy{}hand side that has had the item inserted}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the item is greater than the current node, insert it into the right\PYGZhy{}hand side of the tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{\PYGZgt{}}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{c+c1}{;; create new bst with same root node, same left\PYGZhy{}hand side, but a right\PYGZhy{}hand side that has had the item inserted}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; else the item is equal to the current node, so do nothing}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{else}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert a list of items into a binary search tree}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}list}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the list is null, just return the bst with no changes}
\PYG{+w}{ }\PYG{n}{bst}
\PYG{+w}{ }\PYG{c+c1}{;; otherwise, recurse with the remainder of the list and the binary tree produced by inserting the first item of the list into bst}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}list}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}\PYG{+w}{ }
\PYG{p}{)}
\PYG{c+c1}{;; tree\PYGZhy{}sort function}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{tree\PYGZus{}sort}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; inserting the list into a tree structure to sort it and then displaying the contents of that tree }
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{display\PYGZus{}contents}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}list}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{()))}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert an item into a binary search tree based off a sorting function}
\PYG{c+c1}{;; 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}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item\PYGZus{}custom}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{n}{bst}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{cond}
\PYG{+w}{ }\PYG{c+c1}{;; if there are no nodes in the tree, create a new tree with the item as the root}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{()}\PYG{+w}{ }\PYG{o}{\PYGZsq{}}\PYG{p}{())}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the item is goes before the current node, insert it into the left\PYGZhy{}hand side of the tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n}{sorter}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{c+c1}{;; create new bst with same root node, same right\PYGZhy{}hand side, but a left\PYGZhy{}hand side that has had the item inserted}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item\PYGZus{}custom}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the item goes after the current node, insert it into the right\PYGZhy{}hand side of the tree}
\PYG{+w}{ }\PYG{p}{(}\PYG{p}{(}\PYG{n}{sorter}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{item}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; create new bst with same root node, same left\PYGZhy{}hand side, but a right\PYGZhy{}hand side that has had the item inserted}
\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cadr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item\PYGZus{}custom}\PYG{+w}{ }\PYG{n}{item}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{caddr}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{))}
\PYG{+w}{ }\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; else the item is equal to the current node, so do nothing}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{else}\PYG{+w}{ }\PYG{n}{bst}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; sorter function which states whether the two arguments were supplied in strictly ascending order (i.e., if item == item2, return false)}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{sort\PYGZus{}ascending}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{n}{item2}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{\PYGZlt{}}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{n}{item2}\PYG{p}{)}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}t}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}f}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; sorter function which states whether the two arguments were supplied in strictly descending order (i.e., if item == item2, return false)}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{sort\PYGZus{}descending}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{n}{item2}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{\PYGZgt{}}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{n}{item2}\PYG{p}{)}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}t}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}f}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; 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)}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{sort\PYGZus{}ascending\PYGZus{}last}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{n}{item2}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{\PYGZlt{}}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{modulo}\PYG{+w}{ }\PYG{n}{item1}\PYG{+w}{ }\PYG{l+m+mi}{10}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{modulo}\PYG{+w}{ }\PYG{n}{item2}\PYG{+w}{ }\PYG{l+m+mi}{10}\PYG{p}{))}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}t}
\PYG{+w}{ }\PYG{n+no}{\PYGZsh{}f}
\PYG{+w}{ }\PYG{p}{)}
\PYG{p}{)}
\PYG{c+c1}{;; function to insert a list of items into a binary search tree in the order determined by a sorting function}
\PYG{p}{(}\PYG{k}{define}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}list\PYGZus{}custom}\PYG{+w}{ }\PYG{n}{lst}\PYG{+w}{ }\PYG{n}{bst}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{(}\PYG{k}{if}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{null?}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}
\PYG{+w}{ }\PYG{c+c1}{;; if the list is null, just return the bst with no changes}
\PYG{+w}{ }\PYG{n}{bst}
\PYG{+w}{ }\PYG{c+c1}{;; otherwise, recurse with the remainder of the list and the binary tree produced by inserting the first item of the list into bst}
\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}list\PYGZus{}custom}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{cdr}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{p}{(}\PYG{n}{insert\PYGZus{}item\PYGZus{}custom}\PYG{+w}{ }\PYG{p}{(}\PYG{n+nb}{car}\PYG{+w}{ }\PYG{n}{lst}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{bst}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{)}\PYG{+w}{ }\PYG{n}{sorter}\PYG{p}{)}
\PYG{+w}{ }\PYG{p}{)}\PYG{+w}{ }
\PYG{p}{)}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/6E4C76A5D0FC144C79C45EB98C9F42C2880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n}{sort\PYGZus{}ascending\PYGZus{}last}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/7C5ABA41F53293B712FD86D08ED5B36E880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+m+mi}{9}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/84B40460F8374CCBDE4C353CC301F5FC880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nb}{empty}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/897316929176464EBC9AD085F31E7284880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+m+mi}{0}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/9186189AD87564FA1BC95857621CEC77880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+s+s2}{\PYGZdq{}a string\PYGZdq{}}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/A4B834CBA8DE0DBEA17A010BA488D71C880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{p}{(}\PYG{n+nb}{list}\PYG{+w}{ }\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/B026324C6904B2A9CB4B88D6D61C81D1880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+m+mi}{1}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/B68495714B0E1CAD8EBAA1599766A942880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+m+mi}{99}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/CC4A2CAA23E150F02F6BC7C82B0721A1880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{o}{\PYGZsq{}}\PYG{p}{(}\PYG{l+m+mi}{1}\PYG{+w}{ }\PYG{l+m+mi}{2}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{p}{)}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/D564968DB6FB606921AC34CBE764C1C2880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{p}{(}\PYG{n+nb}{cons}\PYG{+w}{ }\PYG{l+m+mi}{3}\PYG{+w}{ }\PYG{n+nb}{empty}\PYG{p}{)}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/DF252851E514430276CC670EB3D47E9D880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+no}{\PYGZsh{}t}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/FF4C069B4AA0247D474FD3B79FF08608880EBDDACD707E6538CFCB6EAACC28AF.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{o}{\PYGZsq{}}
\end{Verbatim}

76
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/_minted-CT331-Assignment-2/algol_nu.pygstyle Normal file
View File

@ -0,0 +1,76 @@
\makeatletter
\def\PYG@reset{\let\PYG@it=\relax \let\PYG@bf=\relax%
\let\PYG@ul=\relax \let\PYG@tc=\relax%
\let\PYG@bc=\relax \let\PYG@ff=\relax}
\def\PYG@tok#1{\csname PYG@tok@#1\endcsname}
\def\PYG@toks#1+{\ifx\relax#1\empty\else%
\PYG@tok{#1}\expandafter\PYG@toks\fi}
\def\PYG@do#1{\PYG@bc{\PYG@tc{\PYG@ul{%
\PYG@it{\PYG@bf{\PYG@ff{#1}}}}}}}
\def\PYG#1#2{\PYG@reset\PYG@toks#1+\relax+\PYG@do{#2}}
\@namedef{PYG@tok@c}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@cp}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@cs}{\let\PYG@bf=\textbf\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@k}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@kd}{\let\PYG@bf=\textbf\let\PYG@it=\textit}
\@namedef{PYG@tok@nb}{\let\PYG@bf=\textbf\let\PYG@it=\textit}
\@namedef{PYG@tok@bp}{\let\PYG@bf=\textbf\let\PYG@it=\textit}
\@namedef{PYG@tok@nn}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@nc}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@nf}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@nv}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@no}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ow}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@s}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@err}{\def\PYG@bc##1{{\setlength{\fboxsep}{\string -\fboxrule}\fcolorbox[rgb]{1.00,0.00,0.00}{1,1,1}{\strut ##1}}}}
\@namedef{PYG@tok@kc}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@kn}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@kp}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@kr}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@kt}{\let\PYG@bf=\textbf}
\@namedef{PYG@tok@fm}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@vc}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@vg}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@vi}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@vm}{\let\PYG@bf=\textbf\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sa}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sb}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sc}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@dl}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sd}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@s2}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@se}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sh}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@si}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sx}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@sr}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@s1}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ss}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.40,0.40,0.40}{##1}}}
\@namedef{PYG@tok@ch}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@cm}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@cpf}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\@namedef{PYG@tok@c1}{\let\PYG@it=\textit\def\PYG@tc##1{\textcolor[rgb]{0.53,0.53,0.53}{##1}}}
\def\PYGZbs{\char`\\}
\def\PYGZus{\char`\_}
\def\PYGZob{\char`\{}
\def\PYGZcb{\char`\}}
\def\PYGZca{\char`\^}
\def\PYGZam{\char`\&}
\def\PYGZlt{\char`\<}
\def\PYGZgt{\char`\>}
\def\PYGZsh{\char`\#}
\def\PYGZpc{\char`\%}
\def\PYGZdl{\char`\$}
\def\PYGZhy{\char`\-}
\def\PYGZsq{\char`\'}
\def\PYGZdq{\char`\"}
\def\PYGZti{\char`\~}
% for compatibility with earlier versions
\def\PYGZat{@}
\def\PYGZlb{[}
\def\PYGZrb{]}
\makeatother

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment2/latex/images/question1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 20 KiB

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment3/CT331 - Assignment 3 - Prolog.pdf Normal file
View File

Binary file not shown.

26
third/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question1.prolog Normal file
View File

@ -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]).

5
third/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question3.prolog Normal file
View File

@ -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).

16
third/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question4.prolog Normal file
View File

@ -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).

8
third/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question5.prolog Normal file
View File

@ -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).

8
third/semester1/CT331: Programming Paradigms/assignments/assignment3/code/question6.prolog Normal file
View File

@ -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).

34
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/.auctex-auto/CT331-Assignment-3.el Normal file
View File

@ -0,0 +1,34 @@
(TeX-add-style-hook
"CT331-Assignment-3"
(lambda ()
(TeX-add-to-alist 'LaTeX-provided-class-options
'(("article" "a4paper")))
(TeX-add-to-alist 'LaTeX-provided-package-options
'(("babel" "english") ("hyperref" "final" "colorlinks=false" "urlcolor=cyan") ("datetime" "yyyymmdd")))
(add-to-list 'LaTeX-verbatim-environments-local "minted")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "href")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "hyperimage")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "hyperbaseurl")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "nolinkurl")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "url")
(add-to-list 'LaTeX-verbatim-macros-with-braces-local "path")
(add-to-list 'LaTeX-verbatim-macros-with-delims-local "path")
(TeX-run-style-hooks
"latex2e"
"article"
"art10"
"microtype"
"babel"
"hyperref"
"changepage"
"fontspec"
"minted"
"xcolor"
"pgfplots"
"caption"
"datetime"
"titlesec")
(LaTeX-add-environments
"code"))
:latex)

BIN
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/CT331-Assignment-3.pdf Normal file
View File

Binary file not shown.

295
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/CT331-Assignment-3.tex Normal file
View File

@ -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}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/_minted-CT331-Assignment-3/0AA734D1CDA9F25BC66B89B202415F0B70E65A2BB389682C5F0235C03AA763AA.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nf}{insertInOrder}\PYG{p}{()}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/_minted-CT331-Assignment-3/1D489B7B77125E5D1F3A8CDDC149B84870E65A2BB389682C5F0235C03AA763AA.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{n+nf}{reverseList}\PYG{p}{()}
\end{Verbatim}

3
third/semester1/CT331: Programming Paradigms/assignments/assignment3/latex/_minted-CT331-Assignment-3/20370F93926DA9E4DB9A403F98FDE25E70E65A2BB389682C5F0235C03AA763AA.pygtex Normal file
View File

@ -0,0 +1,3 @@
\begin{Verbatim}[commandchars=\\\{\}]
\PYG{l+s+sAtom}{ct345}
\end{Verbatim}

Some files were not shown because too many files have changed in this diff Show More