Assignment 1

The primary objective of this assignment is to develop applied knowledge of recursive, sorting, and searching algorithms within the context of data structures. You are required to program algorithms to simulate a scenario involving submitting research papers to a conference and allocating these papers to different reviewers for review. Papers are submitted under a specific research theme\topic, with unique titles, contributed by one or more authors, representing different institutes, and contain an abstract, a defined number of pages, and references.

Part 1: Paper Distribution to Reviewers

Task: Design two algorithms (iterative and recursive) to assign research papers to reviewers for a conference. Each reviewer should receive a unique set of papers.
Input:
A list of papers (each with a title, abstract, research topic, authors, etc. )
A list of reviewers (each with their research topics of interest).
Functionality:
Each reviewer is assigned papers based on the following criteria:
The papers are distributed in two ways:
Expertise-Based Distribution: Papers are evenly assigned based on matching the research topic of the paper to the reviewer’s interests.
Sorted Distribution: Papers are sequentially assigned to reviewers after sorting papers based on the paper title.
Complexity Analysis: Provide a detailed analysis of the complexity of the distribution algorithms. Use T(n) for explaining the time complexity and O(n) for the Big O notation. You will need to provide plots indicating the time performance of your algorithms with different values of n. The n values are as follows: 1, 100, 500 and 1000. What are the best, average, and worst-case scenarios?
Part 2: Sorting Algorithms
Task: After assigning the papers to the reviewers, create two different lists of research papers:
Sorted by the name of the first author.
Sorted by the number of pages (length) of the paper.
Input: A list of research papers already distributed (you can choose the type of distribution to begin from Part 1).
Functionality: You need to use two different types of sorting algorithms, any two of your choice (including sorting algorithms we did not cover in class).

Scalability Analysis: Discuss the efficiency of the chosen algorithm if the number of papers and reviewers increases significantly.
Complexity Analysis: Provide a detailed analysis of the sorting algorithms you used. Use T(n) for explaining the time complexity and O(n) for the Big O notation. You will need to provide plots indicating the time performance of your algorithms with different values of n. As with Part 1, the n values are as follows: 1, 100, 500 and 1000. Make a comparison between the two algorithms you chose and identify which is the better algorithm. What are the best, average, and worst-case scenarios?

Part 3: Searching Algorithms

Task:Write a function to find the reviewer assigned to a paper with a specified author and number of pages. Of course, this needs to be a specific paper that was distributed in Part 1.
Assumption: The list of papers assigned to reviewers are already sorted by first author or length (which is the output of Part 2)
Test Cases: Provide test cases to assess your solution.
**Complexity Analysis: **Provide a detailed analysis of the complexity of the searching algorithms. Use T(n) for explaining the time complexity and O(n) for the Big O notation. As with Parts 1 and 2, the n values are as follows: 1, 100, 500 and 1000.
Submission Guidelines:
_**Submission Format: **_Add all your code, documentation, and analysis need be added to a single ipynb file on colab.
Before you begin work on the colab workbook, you need to create a shared link of this workbook and add it to the first textbox of the work book itself.
You will submit the pdf version of this colab workbook to Forum.
The instructor will click on the link in first text box to access the executable version of the file on colab.
The documentation added to text boxes of the colab workbook must be editable (images will not be accepted).
Documentation:
Comment on your code to explain the logic, especially in recursive functions and sorting logic.
Include text boxes in your colab workbook and explain your choice of algorithms, their efficiency, and the complexity analysis.
_**Source Code: **_The link to the shareable ipynb file should contain all the source code without any syntax errors
Sections expected in the ipynb File
Part 1, please include source code including test cases, a description of your algorithms and decisions, and the complexity analysis ( T(n) and O(n) )
Part 2, please include source code, including test cases, an explanation for scalability (what happens when the size of the input is large), justification for your choice of sorting algorithm, and the complexity analysis ( T(n) and O(n) ).
Part 3, please include source code, including test cases, a description of your algorithm and decisions, and the complexity analysis ( T(n) and O(n) ).
Note 1: Throughout the assignment T(n) refers to the actual time plot of an algorithm and NOT the recursion relationship of the algorithm.
Note 2: Throughout the assignment, the term “test cases” refers to the different values of n stated already (i.e. 1, 10, 100, 250, 500 and 1000.)
Evaluation Criteria:
Correctness and Efficiency of Algorithms: The algorithms should be correctly implemented and use an efficient approach for time and space complexity.
Code Clarity and Documentation: Code should be readable, well-organized, and properly documented.
Analysis and Justification: The report should justify the choices of algorithms and include a detailed complexity analysis
++**Learning Outcomes: **++
● #ComplexityAnalysis: Analyze the asymptotic behavior of an algorithm or algorithm solution to a problem using the appropriate Big-O, Big-Ω, or Big-Θ notations.
● #PythonProgramming: Write Python programs to implement, analyze, and compare algorithms and apply data structures. Produce Python code to plot and visualize meaningful performance metrics.

Assignment Information
Weight:
15%
LEARNING OUTCOMES ADDED
ComplexityAnalysis: Analyze the asymptotic behavior of an algorithm or algorithm solution to a problem using the appropriate Big-O, Big-Ω, or Big-Θ notations.
PythonProgramming: Write Python programs to implement, analyze, and compare algorithms and apply data structures. Produce Python code to plot and visualize meaningful performance metrics.

Last Completed Projects