Sprint Challenge

Sprint Challenge Overview

This sprint challenge will test your understanding of Lists, Big O notation, and object comparison/sorting in Java. You will apply concepts learned throughout the sprint to solve problems involving ArrayList operations, algorithm analysis, and implementing both Comparable and Comparator interfaces.

Key Learning Objectives

This challenge covers the following learning objectives from the modules:

Module 1: Lists

• Implement code to iterate over the elements of a List
• Add and remove objects from a List
• Access elements by index from an ArrayList
• Understand ArrayList's runtime complexity for different operations

Module 2: Big O

• Analyze algorithm time and space complexity using Big-O notation
• Identify and explain constant, linear, and polynomial complexity
• Compare algorithms based on their time and space complexities

Module 3: Comparable

• Design and implement the Comparable interface for natural ordering
• Create a consistent implementation between equals() and compareTo()
• Use a type's natural comparison method to compare objects

Module 4: Comparators and Using sort()

• Implement Comparators for custom ordering strategies
• Choose between Comparable and Comparator for different scenarios
• Use Java's sort implementations to sort collections

Preparation Tips

Review Core Concepts

• ArrayList Operations: Make sure you understand how to iterate, add, remove, and access elements in ArrayLists
• Big O Analysis: Practice analyzing time and space complexity for various algorithms
• Comparable vs. Comparator: Understand when to use each and how to implement them correctly
• Sorting: Review different sorting approaches and when to use Collections.sort() vs Arrays.sort()

Practical Advice

• Read through all the requirements before starting so you understand the full scope
• Write tests for your implementations to verify they work as expected
• Focus on correctness first, then optimize for time and space complexity
• Document your code with clear, concise comments explaining your approach
• Use the provided resources and module materials as references

Common Pitfalls to Avoid

• Inconsistency between equals() and compareTo() implementations
• Forgetting to handle edge cases (null values, empty collections)
• Incorrect implementation of sort logic leading to unexpected ordering
• Misunderstanding the requirements or expected outputs

Mastery Tasks

Mastery Task 4: Inevitable

Change is inevitable, and it's time to bring a big change to the Missing Promise CLI. You'll redesign the PromiseDao to support multiple clients and implement an OrderFulfillmentServiceClient class.

Milestones:

1. Redesign the PromiseDao to support multiple clients, including the OFS client and future clients
2. Implement your OrderFulfillmentServiceClient class following the pattern of other service clients
3. Update the PromiseDao to match your design and retrieve the packaging promise from your client

Exit Checklist:

• Create mastery-task4.txt in the src/resources folder
• Implement OrderFulfillmentServiceClient
• Update the PromiseDao to retrieve the packaging promise from OFS
• Ensure all tests pass locally
• Push your code and verify TCTs are passing in CodeGrade

Mastery Task 5: Devil in the Details

Enhance the Missing Promise CLI to display promises for each item in an order and implement sorting to make it easier for CS representatives to use the tool.

Milestones:

1. Modify the code to return the promise(s) for each item in an order
2. Implement sorting so that item promises are sorted alphabetically by their ASINs
3. Create a PromiseAsinComparator in a new package

Exit Checklist:

• Modify code to return promises for each item in an order
• Implement PromiseAsinComparator for sorting promises by ASIN
• Write unit tests to ensure proper functionality
• Ensure all tests pass locally
• Push your code and verify TCTs are passing in CodeGrade

Important: Use the same forked repository from Sprint 5 to complete these Mastery Tasks.