| Reporting Category |
Student Score |
College Board Score |
Comments |
</tr>
| Program Purpose and Function |
1 |
1 |
The video shows a program that allows the user to input their choice of rock, paper, or scissors and the computer will randomly select one as well. The output will show the result of the match and give the user the option to play again. The program's purpose is to make a decision. |
| Data Abstraction |
0 |
0 |
Two code segments are shown, one storing data in a list named RPS, and the other does not access the data. The data stored in the list are the options that the computer can select as its input. |
| Managing Complexity |
0 |
0 |
The response explains that the program can be written without using a list by setting the variable "cpuPlay" using an if statement based on a random number, but it would not affect the complexity or ease of development/maintenance of the program. |
Procedural Abstraction |
0 |
0 |
The response includes a student-developed procedure, "rpsGame", which takes one parameter, "yourPlay" and uses it in a series of if-else statements to output a result based on both user's and computer's inputs. The procedure contributes to the overall program by allowing for smooth execution, but it does not specify how. |
| Algorithm Implementation |
1 |
1 |
The response explains that the student-developed algorithm within procedure, "rpsGame", includes sequencing, selection (if statement), and iteration through use of recursion. The algorithm randomly selects an item from a list, saves it in a variable "cpuPlay", displays the computer's choice, compares it with the user's input through a series of if-else statements, prints the result, and offers the user to play again. If the user inputs "Yes" the function is called again, if the user inputs "No" the computer prints "Goodbye". |
| Testing |
1 |
1 |
The response describes two calls to the procedure with different arguments, leading to different results. The conditions being tested for the two procedure calls are if the user's input is equal to "Rock" and the computer's input is "Paper" in the first case and if the user's input is equal to "Paper" and the computer's input is "Rock" in the second case. If the conditions are true, the function displays "You Lose!" in the first case and "You Win..." in the second case. |
| Reporting Category |
Student Score |
College Board Score |
Comments |
</tr>
| Program Purpose and Function |
1 |
1 |
The video shows a program that helps users recognize new words and expand their vocabulary. The user inputs letters into a text field, the program outputs the letter in the correct spot of the randomly generated word or reduces the number of lives if the letter is not found, and shows a winning screen if the word is completed. Input includes letters, numbers, symbols and multiple letters in a single guess. |
| Data Abstraction |
1 |
1 |
Two code segments are provided, the first one stores data in a list named letOfGuessWord, and the second one accesses the data from the list in a for loop. The list holds the individual letters of the word that the user is trying to guess. |
| Managing Complexity |
1 |
1 |
The response includes a code that uses a list to manage complexity by storing the letters of the word to be guessed. The list is scanned based on its length, which allows for implementation of longer words. The response explains that if the program were to run without the list, it would be inefficient and more complicated as it would require 5 new variables to store individual letters and a for loop to check for a match between the user's input and the word. |
Procedural Abstraction |
1 |
1 |
The response includes a student-developed procedure, "guessWords" which takes a parameter and uses it to compare the user's input to the letters of the randomly generated word. If the user's input matches the letter, it will display the letter in the correct spot and if the program does not find the letter in the word, it will take a life away from the user. The procedure contributes to the overall functionality of the program by doing the work of comparing the letters and determining the result. |
| Algorithm Implementation |
1 |
1 |
The student-developed algorithm within procedure, "guessWords", includes sequencing, selection (if statement), and iteration (for loop). The algorithm uses a for loop to loop through the entire list by the length of the word that the user is trying to guess, then uses an if statement to compare the letter that the user inputted to all of the letters in the randomly generated word. If the if statement condition is true, it sets the letter that the user inputted to the index of where the letter was found in the randomly generated word, sets a boolean "check" to true, and adds 1 to "count" to keep track of how many times the user has guessed a letter correctly. |
| Testing |
1 |
1 |
The response describes two different calls to a procedure that results in different code being executed. The user inputs the number "1" and the letter "h" when the word to be guessed is "hello". The conditions being tested are the number "1" not being found in "hello" and the letter "h" being found in "hello". The results of the two calls are false for the first call and true for the second call. |
| Reporting Category |
Student Score |
College Board Score |
Comments |
</tr>
| Program Purpose and Function |
1 |
1 |
The video shows an app that helps with memorization or learning something new by displaying general information, such as the state flag, area, and population, of a selected state from a drop-down list, and allowing the user to select more information. The input is the selected state and the chosen information, the output is the general information and the selected information displayed on the screen. |
| Data Abstraction |
0 |
0 |
Two code segments are provided, the second one shows data being stored in a list named stateList, containing all the information the user will see on the general information screen like State name, Flag, Population, Capital, and Population. However, the code fragment provided only shows the state name stored in the list. |
| Managing Complexity |
0 |
0 |
The response includes code that uses lists to manage complexity, but it does not explain how the code would be more complex or inefficient without them. The response states that it would take a long time and be inefficient without the use of a list. |
Procedural Abstraction |
0 |
0 |
The response includes a student-developed procedure "updateScreen" but it does not have any parameter and it is not called in the second code segment. The response describes the procedure inaccurately as it does not update the state screen but only sets an index and does not explain how it contributes to the overall functionality of the program. |
| Algorithm Implementation |
0 |
0 |
The response partially explains the algorithm in the procedure "updateScreen" which includes sequencing and selection using if/else statements, but does not include iteration. The algorithm uses else if statements to narrow down the user's selected state and sets the index value based on the match, but the response does not explain the specific value set for each U.S. state. |
| Testing |
0 |
0 |
The response describes two calls from the specified procedure, but it is not an implicit parameter, it is assigned after the call is made. It describes the two separate operations the user performs, not the conditions being tested by the given parameter. The response does not specify the results of the two calls, but the results that appear on the screen. |
| Reporting Category |
Student Score |
College Board Score |
Comments |
</tr>
| Program Purpose and Function |
1 |
1 |
The video demonstrates a program that allows the user to control a boat's movement and catch fish, with the purpose of lessening boredom. The input is the user pressing keys 'a' and 'd' and the output is the boat's left and right movement. The video also includes scorekeeping for total score and tracking the amount of each fish caught in time. |
| Data Abstraction |
1 |
1 |
The response explains that a list called fishtypes is used to store information about the types of fish caught, and the number of each type caught. The code also shows that this data is accessed in a for loop. |
| Managing Complexity |
1 |
1 |
The response includes a list of lists that manages complexity by storing fish data, including type and number caught. The response explains that the code can be written without lists by creating new variables for each added fish, but this would be less efficient and would require more changes to the program. |
Procedural Abstraction |
1 |
1 |
The response includes a student-developed procedure, "clone+movement+range," that uses five parameters. The procedure determines where a clone of a sprite spawns, how far it can move, and where it goes when it reaches the end of the screen. The procedure makes the game more challenging by causing each fish clone to spawn and move randomly at a range of speeds or height. |
| Algorithm Implementation |
1 |
1 |
The response describes a procedure called "clone+movement+range" which uses sequencing, selection, and iteration to determine the spawning, movement, and end positions of a clone sprite. The procedure starts by moving a newly spawned clone to a random x position within the screen and a random height within a range specified by the ‘y1’ and ‘y2’ parameters. Then, a loop begins until either the game ends or the clone touches the hook. Inside the loop, there is an if-else statement where if the clone touches the edge of the right side of the screen, the clone would teleport left to a position specified by the ‘rt state’ (return state) and to random height within a range specified by ‘y1’ and ‘y2’ parameters. |
| Testing |
0 |
0 |
The response does not specify the arguments passed to the procedure and how they affect the procedure's behavior. Instead, it explains alternative coding segments that could be used. The response describes conditions being tested, but it does not correspond to how the parameters are used in the program. The response also describes the code segments rather than the result of the procedure call. |