2015 FRQ --> PBL | Final Review

[rohinsood]

FRQ 1 (1D & 2D Arraylists) | Link

• This FRQ revolved around manipulating 1D & 2D arrays of integers.
• For the final project, I worked on creating roles for users, being a student, teacher, or admin, would warrant different permissions and routes on the site. In a Java Spring backend, a many-to-many relationship is often implemented using the @ManyToMany annotation, which involves two entities, such as User and Role. In this scenario, a user can have multiple roles, and a role can be associated with multiple users. The relationship is managed through an intermediate table, and an ArrayList is commonly used to store user roles dynamically. For instance, the List roles field in the User entity allows for easy manipulation of roles, like adding or removing dynamically. This ArrayList represents a practical implementation of a many-to-many relationship.

  
  @ManyToMany(fetch = EAGER)
  private Collection<PersonRole> roles = new ArrayList<>();

@JdbcTypeCode(SqlTypes.JSON) @Column(columnDefinition = "jsonb") private Map<String,Map<String, Object>> stats = new HashMap<>();

Manipulating the array

repository.addRoleToPerson(person.getEmail(), "ROLE_STUDENT");

# FRQ 2 (Classes) | [Link](https://rohinsood.github.io/csa/2024/02/25/2015-FRQ-2_IPYNB_2_.html)
- This FRQ revolved around using features of a class to most efficiently write code. Some topics include accessing static methods within the same class, iteration, and other methods.
- The provided Java code defines a class named `PersonRole` that appears to serve as a blueprint for creating objects representing roles in a system. The class encapsulates attributes such as an automatically generated ID, a unique name for the role, and various constructors for instantiation. The use of the `@Entity` annotation indicates that instances of this class can be persisted in a database. Moreover, the `init()` method showcases the concept of class methods creating instances, where three predefined roles (`ROLE_STUDENT`, `ROLE_TEACHER`, and `ROLE_ADMIN`) are initialized and stored in an array. This implementation reflects the object-oriented programming paradigm, treating the class `PersonRole` as a template or blueprint for creating individual role objects. This connection between class definitions and object instantiation aligns with the fundamental concept of classes as blueprints for objects, a concept commonly tested in Free Response Questions (FRQs) that assess understanding of object-oriented principles in programming courses.

```java
@Data
@NoArgsConstructor
@AllArgsConstructor
@Entity
public class PersonRole {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    @Column(unique=true)
    private String name;

    public PersonRole(String name) {
        this.name = name;
    }

    public static PersonRole[] init() {
        PersonRole student = new PersonRole("ROLE_STUDENT");
        PersonRole teacher = new PersonRole("ROLE_TEACHER");
        PersonRole admin = new PersonRole("ROLE_ADMIN");
        PersonRole[] initArray = {student, teacher, admin};
        return initArray;
    }
}

FRQ 3 (Arrays) Link

• This FRQ revolved around manipulating arrays of characters.
• In my project for allocating roles to different users, there was a use of an array to store the initial amount of arrays. The init() method in the provided Java code exemplifies the creation and initialization of an array of PersonRole objects. This use of an array is analogous to a scenario often presented in Advanced Placement Computer Science A (AP CSA) exam questions that involve manipulating arrays. The method initializes three distinct roles (ROLE_STUDENT, ROLE_TEACHER, and ROLE_ADMIN) as instances of the PersonRole class and stores them in an array named initArray. This array can be seen as a structured data container, mirroring the array manipulation skills tested in AP CSA exam questions. Students may encounter problems requiring the creation, population, or manipulation of arrays, and the presented code segment serves as a practical illustration of how arrays can be employed to organize and manage multiple objects efficiently. Understanding such array-related concepts is crucial for success in addressing questions related to data structures and manipulation in the AP CSA exam.

  public static PersonRole[] init() {
  PersonRole student = new PersonRole("ROLE_STUDENT");
  PersonRole teacher = new PersonRole("ROLE_TEACHER");
  PersonRole admin = new PersonRole("ROLE_ADMIN");
  PersonRole[] initArray = {student, teacher, admin};
  return initArray;
  }

FRQ 4 (Interfaces) | Link

• This question revolved around creating two different implementations of an interface after stating its base functionality in the original question
• In my project, I used an interface to abstract the JPA repository for accessing roles. The Java code features an interface named PersonRoleJpaRepository that extends the JpaRepository interface from Spring Data JPA, aligning with the abstraction concept commonly assessed in Advanced Placement Computer Science A (AP CSA) exams. The interface declares a method, findByName, representing a standardized query for retrieving a PersonRole by its name. Interfaces provide a contract without specifying implementation details, allowing concrete classes to adhere to the defined structure. This example illustrates the practical application of interfaces in Spring Data JPA, emphasizing their role in code organization and abstraction, concepts frequently examined in AP CSA questions.

  
  package com.nighthawk.spring_portfolio.mvc.person;

import org.springframework.data.jpa.repository.JpaRepository;

public interface PersonRoleJpaRepository extends JpaRepository<PersonRole, Long> { PersonRole findByName(String name); }

# FRQ Reflection
- **FRQ 1:**
  - Simple implementation, not challenging.
  - Emphasized using for-loops to iterate, update, or sum array values.
  - Noted syntax familiarity, but highlighted the need to remember array instantiation.

- **FRQ 2:**
  - Slightly harder than the first FRQ but manageable.
  - Utilized a for-loop to iterate over a provided string.
  - Recognized the importance of sequential order in checking correctness, specifically for position and character existence.

- **FRQ 3:**
  - Deemed the most challenging FRQ due to the implementation.
  - Used a for-loop to iterate over and delete array elements, considered unconventional.
  - Overcame issues by copying indices into an ArrayList and iterated over that to delete elements.
  - Acknowledged that a while loop and checking for the existence of the next element could have provided a cleaner solution.

- **FRQ 4:**
  - Considered the easiest FRQ.
  - Task involved creating an interface and demonstrating usage.
  - Used the @Override annotation to define methods for classes implementing the interface.

[STG-7]

FRQ 1 (Arrays & ArrayLists)

FRQ - 0.95/0.9

• Correctly implements the required methods according to the provided specifications.
• Code efficiently iterates through the arrays, using a loop for both arraySum and rowSums methods.
• Variables like totalSum are well-named and scoped appropriately. They are initialized outside the loop and used to accumulate the sums, maintaining clarity and readability of the code.

  Association - 0.95/0.9

• He uses an ArrayList to store user roles allows for dynamic assignment and manipulation of roles. This means that roles can be easily added or removed from a user without complex database operations. For instance, when a user's role needs to be updated, it can be done by simply adding or removing elements from this ArrayList.
• Adding a role to a user is straightforward and intuitive, as seen in the example repository.addRoleToPerson(person.getEmail(), "ROLE_STUDENT");. This line clearly indicates that a role is being added to a user, enhancing the readability of the codebase.

FRQ 2 (Classes)

FRQ - 1/0.9

• Efficiently compares characters between the input and the hidden word. By iterating through each character in the input string and checking it against the corresponding character in the hidden word, it accurately determines matches, mismatches, and characters present elsewhere in the hidden word.
• The code is logically structured, making it easy to understand the flow of operations. The getHint method follows a clear sequence: checking for exact matches, then for characters present elsewhere, and finally denoting characters not found with "*".

Association - 1/0.9

• In addition to the annotations, the PersonRole class defines a parameterized constructor public PersonRole(String name) to create PersonRole objects with a given name. This constructor is used in the init method to create three PersonRole objects: ROLE_STUDENT, ROLE_TEACHER, and ROLE_ADMIN.

FRQ 3 (Arrays)

FRQ - 0.95/0.9

• effectively used a for loop to iterate through the entries list in the getValueAt method, efficiently checking for a matching entry at the specified row and column, returning the value if found, or 0 if not found.
• In the removeColumn method, he correctly utilized an ArrayList called indicesToRemove to keep track of indices that need to be removed from the entries list, ensuring the removal process is efficient and maintains the integrity of the sparse array.

  Association - 0.95/0.9

• The code effectively demonstrates the use of an array named initArray to store and initialize three distinct roles (ROLE_STUDENT, ROLE_TEACHER, and ROLE_ADMIN) as instances of the PersonRole class.

FRQ 4 (Interfaces)

FRQ - 1/0.9

• The code effectively implements the MultipleGroups class as a container for a collection of NumberGroup objects, demonstrating proper use of encapsulation and abstraction by handling a list of NumberGroup instances within groupList.

Association - 1/0.9

• The code effectively utilizes an interface, PersonRoleJpaRepository, to abstract the JPA repository for accessing roles