FRQ and CB Reflection

[Krishiv111]

FRQ 1 (Arrays/Arraylists/2D Arrays)

• This FRQ tested the knowledge and application of principles such as 1d and 2d arrays, by iterating through them accessing the different elements ultimately to compare the diversity between two arrays . Although we ddint specifically use 2D arrays within our project the iteration part of the fry was aligned within the feature I made to compare the users to to see if they had similar classes together.

The List<Person> allPersons = repository.findAll();, allows to retrieve all users which starts the iteration process of going through each the 1D array of the users to find the similar classes as we had to iterate within the FRQ to find sums of the array along with checking the diversity of each array. Although we used different casses our PBL and CB FRQ both implement the same principle of using arrays and set up and iterate through different data.

FRQ 2 (Classes)

• This FRQ tested the ability to create a POJO and implement methods to create HiddenWord class which ultimately worked to match the key letters to a specific word with the symbols to indicate if the guess was accurate to reveal the hidden word. Within our project the POJO we created using the Person Class had the users roles, grade, email, and classes for their student profile.

  

• Below we have the POJO variables being initialized through its constructor along with the test data for each user set in static data below, with data set through a hash map for the specific classes.

  

• Classes are essential to PBL becuase they are the main structure with project which has helped especially in my FRQS on classes as it allows me to approach writing classes in similar ways I would if I was trying to create A POJO for my PBL which allows me to be more effiecne and fluent with these object s .

FRQ 3 (Method and Control Structures + 2D Arrays)

• This question was testing the principles of a Sparse array by using array list to add to that specific array with different values in an array that mostly contained 0 known as sparse. Within our PBL project we didn't exactly use a 2D array however through our data sent within a JSON file we can compare to a 2d array through its similar structure of the adding data by each date (similar to a column) to each period similar to a row).

{ "stats": { "2024-02-07": { "period1": "stats", "period2": "csa", "period3": "calcab", "period4": "apes", "period5": "bio" } } }

• Here that implementation is shown through the idea that on a given day this person has this class at this period which has a value of a specific class this can be used to sort people by classes such as ARTS, STEM to better connect others within the database. This is similar to having the sparse array and having to add data to to each row and column with a value such as the each day with each period and each class.

---

FRQ #4

• This FRQ main purpose was use inheritance within the which is something we have been working on in PBL since the being of this trimester with the likes of the sorting project. Ultimately this was seen in our project through the extends within our JPA.

  

• Here we use the extends method which is a parent to child relationship in java to inidacate that we are inheriting the specific fields and methods from the one class

• Implements rather focuses on providing implementations for all the methods declared in that interface. This is seen here within the PBL

  

FRQ REFLECTIONS

1. After Completing this frq it tested my understanding of the array parts in java which a key component I need to work on part a came easy to me but I needed some help on structure of syntax and formatting which is wheere I struggled. Part B was what I taught in trimester 1 on 2d arrays and traversing and accesing new elements and storing so there wasnt much trouble there. However I struggled on getting the Diverse array to work on part C becuase I was a bit confused by the instructions which left me with a lot of error testing to do. Overall advanced concepts within arrays is what I need to practice more on.
2. THis was where I found most of my suceses in and was the question I was most undrstood as it tested my ability to create a class with approprate fields and instance vairable, constructors that intialized my variables and methods that created the matching game, however I had to reference previous lessons to understand the implementation of a string builder to add the correct vairables to match up the guess
3. THis tested my knowlege of array lists and implements tation of how to append and traverse through an array list I struggled most at the part wher I had to test the data and see if my methods were actually working. I sturggled mostly on part B to get the actual value and remove it from the sparsed array.
4. For me this was the hardest FRQ, as it tested the advanced parts of java by testing the idea of polymorphism between the classses which truly made it hard for me having to make me spend time a lot and look at lessons and watch videos to completly understand.
5. PBL: I feel like PBL has taught me how to implement all these different java skills together into one additionally it has helped me understand the application of these classes and arrays where on the FRQ;s I need to work on integrating the syntax with my ideas.

[AniCricKet]

FRQs

FRQ 1: 0.9/0.9

• Part A: The code correctly makes the arraySum function and shows understanding of for loops.
• Part B: Shows understanding of using previously written methods and for loops, and indexing arrays.
• Part C: Uses nested for loops effectively to compare elements and determine if the array is diverse. Returns the correct value indicating diversity.
• Reflections: The reflections provide helpful insights into the problem and how it was approached, showing a strong understanding of the question overall.

FRQ 2: 1/0.9

• The choice of StringBuilder over conventional String manipulation methods is interesting, with a clear explanation provided.
• The HiddenWord class constructor is well-implemented, with appropriate instance variables and constructor arguments.
• Effective use of conditional statements to concatenate StringBuilder, demonstrating a solid understanding.
• Reflection: Insightful reflection on memory efficiency and the immutable nature of strings, along with an interesting suggestion to add interactivity to the program.

FRQ 3: 1/0.9

• The inclusion of the addEntry method aligns well with the example code, providing an insightful enhancement to the program.
• Part A: The for loop effectively locates the matching element in the entries ArrayList, with the conditional statement implemented insightfully.
• Part B: The addition of the toString method to SparseArrayEntry facilitates easy printing and testing, although in the context of the problem, it's advisable to refrain from altering the template code.
• Part B: The use of the iterator pattern to manipulate values within the entries ArrayList is commendable, meeting all requirements of the problem.
• Reflection: Insightful reflection on the challenges encountered during problem-solving adds depth to the discussion.

FRQ 4: 0.9/0.9

• Part A: Main initializes an IntegerList object, group1, with values [23, 21], then checks if 23 is present (returns true) and if 4 is present (returns false). IntegerList implements NumberGroup interface, overriding contains to check for number presence.
• Part B: Main instantiates a Range object, range1, with range -13 to 11, then checks containment of -23 (false), 2 (true), and 10 (true). Range implements NumberGroup, determining if a number falls within the range.
• Part C: Main creates a list of NumberGroup objects, adds three Range objects, then creates MultipleGroups object, multiple1, with these groups. multiple1.contains() checks if 6, 1, and 9 are within any of the ranges, returning results accordingly. MultipleGroups implements NumberGroup, iterating through groups to check containment.
• Reflection: The code effectively defines classes to check if a number is within certain ranges or lists of numbers, showing how to group numbers and check their presence efficiently.

Total: 3.8/3.6

Associations:

FRQ 1: 1/0.9 Showed a good example of Arrays being used in their project. Explains the code well.

FRQ 2: 1/0.9 Showed the Person class, and demonstrated the POJO in action. Explains the use of classes in PBL in detail.

FRQ 3: 0.9/1 Doesn't have a specific usage of a 2d sparse array in their project, but showed data sent within a JSON file we can compare to a 2d array through its similar structure of the adding data by each date.

FRQ 4: 0.9/0.9 Shows the implements and extends method and talks about what he learned from the FRQ.

Also wrote a full FRQ reflection talking about his observations as well as lessons that he's learned. Demonstrated a good understanding of the concepts and explained to me what he needs to spend more time on.

Overall Score: 3.8 + 3.9 = 7.6 / 7.2