# data[].attributes.body
A piece of documentation I would've liked to add is the instructions and ingredients to each recipe that is recommended at the end of the program. This would be used by the user and would be of great benefit and help for making the recipe.

# data[].attributes.body
Input:

User inputs what meal they would like a recipe for.

(function manipulates list based on answer)

Input:

User inputs what experience they have with cooking.

(function manipulates list based on answer)

Output:

A list of recommended food recipes based on input given.

# data[].attributes.body
The user interface of my program is mainly in the questions that are asked that prompt the user to input information to allow the code to give the desired output.

# data[].attributes.body
I tested my code by running different inputs to make sure my outputs corresponded to their inputs, and while creating my program I tested my list and printed it after every command that changed it, to make sure it was being manipulated correctly.

# data[].attributes.body
When I learned that our personal project should be about something we're passionate about or that interests us, and almost becoming an official college student, I knew right away that I wanted to do something that involves cooking or food, which is when I landed on my program idea. From there I developed a simple algorithm of what I wanted my program to do, and moved on to creating my code and making sure I met the requirements.

# data[].attributes.body
A potential user of my program is someone who wants to learn how to cook or a college student that needs ideas on something easy to cook. They can use my program to give them ideas on recipes they can cook based on their cooking experience.

# data[].attributes.body
The user is required to use their keyboard in order to input their budgets.

# data[].attributes.body
I tested the code by testing it after each new line of code to make sure it ran.

# data[].attributes.body
I started off the development by creating a custom function that would be able to take a number as an input then return a PC type that fit into the budget. I then created a code to ask the user for that budget and return parts of a list that corresponded to the recommended parts.

# data[].attributes.body
My program has a few different ways in which input and outputs are used. Some are as simple as a yes or no input by the user that can change output such as repeating a section, or changing options. Furthermore since it is a trivia game the user is intended to input their answer and the output will be wether they got it right or wrong and if they recieved a point

# data[].attributes.body
The purpose of my program was to create a fun little trivia game especially for basketball sport fans it involves different type of statistics that some may not even be familiar with so they can expand their knowledge or test it. It tallies points and allows them to have a sense of accomplishment by doing well.

# data[].attributes.body
The user for my program would be someone who enjoys basketball and loves the statistic aspect of the sport. My program is very easy to use and is very direct for anyone to use even with the smallest amount of computer knowledge being as simple of the press of a button or a few buttons.

# data[].attributes.body
The potential user would be someone who has a budget in mind but not an idea of what they want.

# data[].attributes.body
The program takes budget as an input and outputs a list of parts that it reccomends.

# data[].attributes.body
Picking out the parts can be difficult, so the program helps simplify the process.

# data[].attributes.body
The program would give those looking to purchase or build their own PC recommendations as to what they can get with their budget

# data[].attributes.body
Input: Type of pet, what information they want and if they want to go again

Output: Lists of foods the pet can eat and cant, emergency

Functions: pick_pet(), user_help(), emergency(), food_section(), unsafe(), options(), and again()

# data[].attributes.body
Depending on the input put the bunny. dog or cat the user will return information based on that pet.

# data[].attributes.body
One thing I could add was an option that could let the user input a type of food and see if their pet can eat it and how much they can eat from it.

# data[].attributes.body
I could add a piece of documentation to the first function. The users would be using it and they would be able to understand how the program works.

# data[].attributes.body
This function uses the input from selected genre to decide which list to take a game recommendation from, then uses random choice to get an item from said list and displays it along with the text.

# data[].attributes.body
The user interface first asks if you would like to play the program, if yes then it will explain the program and ask what genre you want, and depending if you like the suggestion or not you are asked if you want to reroll or end the program.

# data[].attributes.body
I tested my code by pretending that I was someone who had never used it and I tried as many inputs as I could think of to reduce errors.

# data[].attributes.body
I started with brainstorming the central idea for the program, then I took some time trying to figure out how I can include every requirement needed while making the code work, and lastly I fixed errors and polished the code.

# data[].attributes.body
The expected user of this program, “Happy Hikers Packing”, is  a person going hiking who is unsure of what to pack for their hike. This program accounts for the two most important factors contributing to a hike including, the time of the hike and the season. The user’s response to both of these questions customizes their recommendation.

# data[].attributes.body
The program is based on two key factors impacting hiking: asking the users how many hours they are hiking and what season. Since each one of these aspects has various subsections, it is best organized in functions per section.  Initially, it prints out a welcome statement from “Happy Hikers Packing,” the name of my program. Then the program prints out a question asking how many hours they are going hiking, gives a recommendation, and does the same for the season going hiking. The hiking recommendation function uses the user input parameter of their intended hike time to recommend how much water a hiker should take. Within the functions, there is a while loop only to accept inputs greater than zero and an if-else statement to create the various outputs based on user input, continuing to print again. Following the second function for the season intended to hike, the program prints a list of different recommended items based on what the user inputs. I tested the program by ensuring the output printed the intended information in order, according to the input.

# data[].attributes.body
My program helps users brainstorm what to pack on a hike. The program collects two crucial pieces of information from the user to create a packing recommendation, including the number of hours intended to go hiking and the season. Initially, it prints out a welcome statement from “Happy Hikers Packing,” the name of my program. Then the program prints out a question asking how many hours they are going hiking, gives a recommendation, and does the same for the season going hiking. Finally, the program thanks the user and wishes them a great hike.

# data[].attributes.body
I developed and tested my program by initially brainstorming ideas for a program many people could use. From here, I broke down the concept to test how its main components could work together. The program is based on two key factors impacting hiking: asking the users how many hours they are hiking and what season.  Since each one of these aspects has various subsections, which would be best organized in functions per section. I first tested the program by ensuring that the hiking recommendation function initially worked using the user input parameter of their intended hike time with only one recommendation to test if it worked. From there, I implemented a while loop and if else statement to create the various outputs based on user input, continuing to print again. I followed a similar process for the second function for the season intended to hike; my program prints a list of different recommended items based on what the user inputs. I tested the program by ensuring the output printed the intended information in order, according to the input.

# data[].attributes.body
One piece of documentation I could add to my program is a description of another one of the procedure like the "create_questions" procedure. Which can be used by me to be a reminder of how the procedure works specifically so I do not use it incorrectly.

# data[].attributes.body
Within the "make_topics" procedure, the user is required to input the number of topics and which topics they want. Which the number of topics is then outputed into a varible and the topics they picked are outputed into a list. Which is then used in the program to make questions and answer for each topic.

# data[].attributes.body
I developed my program by initially brainstorming ideas for a program many people could use. My program helps people brainstorm a hiking packing list based on two key factors impacting hiking: asking the users how many hours they are going hiking and what season. Each of these questions uses a function to hold various if statements for each possible answer. From here, after centralizing the main parts of the program into two functions, I put the additional print and list items, as well as variables, to store user input; that way, the functions are called. It was a trial and error process, ensuring the nested conditionals worked with print statements inside the function.

# data[].attributes.body
The user interface is quite basic with only prompts and a spot for the user to input.

# data[].attributes.body
I tested my code by inputing what the user was suppose to, which made sure my code was working as intended. Then I inputed things that the user was not suppose to input and added fail-safes to the areas that needed it.

# data[].attributes.body
The development process of the program started off with lots of different student made procedures and as time went on, the program simplified. For example, initially the program was to support an infinite amount of topics but was restricted to ten for the sake of simplicity. Then there was a ton of debugging and making sure there could be as minimal errors as possible.

# data[].attributes.body
A user of the program will be able to use the program to create their own study guide for themselves.

# data[].attributes.body
One thing that I could add to my program to make it shorter and more interactive for the user could be a shorter loop. I could ask the users the number of rounds they want to play and then set the loop to repeat that number of times. The reason I could add this program is to make it more enjoyable for the players as they might want to play fewer rounds than usual.

# data[].attributes.body
How my program uses input and output to operate by asking the users to enter a number between one and ten; after that, the program does a subtraction to determine which number is closer, and then it tells the user who received the point, The function of my program does the math equation, and then it uses if statement to determine who guessed closer. My program uses a loop to determine the number of rounds that will be played. Finally, the program also checks if any of the players have two rounds won, if they do the code tells the player who won and the code ends.

# data[].attributes.body
How the user interacts with the program by typing a number between one and ten so the program can do some operations and determine which player receives a point because they got it closer to a randomly generated number between one and ten. The program tells the user who won the point, the round, and the game.

# data[].attributes.body
The user inputs numbers, like when choosing the amount of topics, to get limited to whatever amount they chose. The user caqn also input prompts like questions and answers into the program to then be used in a study guide.

# data[].attributes.body
A piece of documentation I could add is why I have the choose random method. It could be confusing to understand why I have that at the end of my code. My intended audience could use it because it will help them understand that there is more than one movie recommendation the program can provide for each rating of the chosen genre.

# data[].attributes.body
The text my user inputs has to be about genre or rating depending on what the questions is asking. The genre or rating the user wants to input also has to be within the list of genre or ratings provided.

The output of the program is dependant on what specific genre and rating the user selected. If the user input a genre or rating not defined in the program, the program will return that it’s an invalid rating or genre and prompt them to input a valid answer.

The function of my code has parameters, genre and rating. Under this function is a list of 4 genres, horror, comedy, romance, and action. Within each of these variables is a total of 6 movies. The first two movies in each variable are PG, the following two are PG-13, and the last two are rated R. After all of these are listed, the code that follows are 2 while loops. These while loops are specific to the input the user enters. Before the procedure is called the program asks the user what genre and rating they want to choose. Therefore, before the procedure in the program can move onto the if statements it has to make sure that the input entered is valid, if not it will keep looping. Once they break the loop it will allow the program to continue. Then, the following if statements define the genre and rating. Depending on what genre the user entered it will assign the correct genre list to the variable movie_list. Then, depending on the choosen rating the program will use indexing to pull the two movies from the identified movie_list and assigns these two items in the list to the variable recommended_movie. Once recommended_movie is defined it will choose randomly from recommended_movie. And ultimately the function can now be called.

# data[].attributes.body
The purpose of the program is to help the user study what ever topic they choose up to 10 topics.

# data[].attributes.body
The user will interact with the code using their mouse and keyboard. They will click on the targets and type into their keyboard to continue executing the code. The rest of the calculations and functionality do not need the user to do anything.

# data[].attributes.body
Something that could be added to the program to enhance the personalization aspect would be to have code that would allow for users to be more broad in their input. Instead of replying with a simple "yes/no". For instance a question could be what are your hobbies and the user can type them out. Then a part of the code would be for example, if "reading" is in the users response then a point is added to a social media platform corresponding to that. The code can look out for specific keywords in the users response and continue from there. Anyone can use it who is wanting to try a new social media platform that is more tailored to their preferences specifically.

# data[].attributes.body
I could add another loop within my program to ask the user if they would like another recipe instead of having to restart the entire program. The new recipe would also be added to the pre-existing list.

# data[].attributes.body
The input is very simple, as it uses input and stores it within a variable titled user_name. The function is then called, and several lines are printed along with the user's name. The main portion of the program is a function called user_recipe, within this function, the user is prompted to input their desired recipe. Within this function, there is a While True loop. This loop is placed in case the user spells the recipe incorrectly.

# data[].attributes.body
The user can input different topics, questions, and answer into the program to supplement their needs for studying.

# data[].attributes.body
The function "media_helper" is made to offer a social media platform recommendations by taking a list of platforms and questions. There is user input as users engage by responding to a series of questions including interest in funny videos, sending pictures, real-time events, being artistic, etc. Based on their responses it will continue to the points system of the program. The program produces an output by printing the recommendation of the platform with the highest points and asks if they like it. The loop within the code continues until the user is okay with the suggestion.

# data[].attributes.body
The user will be shown steps and where they should enter the data. It is very clear for the user to see where they should enter their input.

# data[].attributes.body
I tested my code by inputting information and looking for any potential bugs. I then realized I should loop my function in case the user misspelled something.

# data[].attributes.body
The development of this program was a lot of trial and error,, as it needed to store a lot of information for the recipes. I ultimately decided to store the recipes in a dictionary which I could easily call from a function.

# data[].attributes.body
Anyone could be a potential user and it would be ideal for anyone who is looking for a quick and easy Mexican dessert.

# data[].attributes.body
The user is going to input their name and the recipe they intend to make. The output is going to be the needed ingredients and recipe for he selected dessert.

# data[].attributes.body
1. Input: The program has 2 major user inputs. The first is prompting the user to type "Ready" when they are prepared to continue to the next round. Additionally, during the rounds, the user will use their mouse to click on blocks that appear on the screen.

2. Output: The amount of blocks that are successfully clicked each round changes the accuracy value for that round. At the end of the code, it determines which DPI suggestion to recommend based on these values.

3. Function: The code functions by using payers accuracy values to compare how well they can perform on different mouse settings. It achieves this by testing the user's reflex precision, having them click on quickly disappearing targets. The suggestion is based on performance.

# data[].attributes.body
The program is simple where users are prompted a series of questions to understand their media preferences. Users respond and as they answer, points are assigned to social media platforms. After gathering input, the program calculates the one with the highest points to suggest it. Lastly the program allows users to provide feedback. If they are happy with the recommendation they can end it by responding "yes" otherwise, they can retry the questions for something else.

# data[].attributes.body
The user is going to input their name and then be greeted by the program. The user will then select a recipe and be shown a recipe based on their selection.

# data[].attributes.body
I began with finding out what makes each social media different so that I can make my questions. This is so that each one matches a specific social media platform. After this I began writing the code starting with user input as the code revolves around personalization. I continued with fulfilling the rest of the requirements fixing bugs I encountered along the way. Towards the end I discovered a big part of making the suggestion specific to the user would be by allowing them to say whether or not they liked the suggestion. To give the user the opportunity to retry the quiz I included a loop that will break if they do like it and continue otherwise if not.

# data[].attributes.body
The developmental process of my program consisted of identifying an intended user, functionality of my program (e.g. brainstorming lists, iteration, conditional statements, and etc.), and debugging. Brainstorming these key components of my program helped me come up with ideas for what I wanted my program to do. For instance, when I was coming up with how I would include if statements, it made me realize that I wanted to include a variety of genres and ratings, rather than just choosing randomly from a list of movies. I also encountered bugs in my program, especially when trying to make my code choose randomly from two movies in a list. However, I fixed it by creating two parameters in my function called genre and rating. Once, I established these parameters it made sense for me to define genre first and then define rating. Before, my parameter was my list of genres. However, I realized that making my genres my parameter would not work because I also wanted to incorporate ratings and calling my function would otherwise be more complex.

# data[].attributes.body
The user interface of the program is simple and consumed by questions that welcome the user and ask questions in relation to the programs functionality (e.g. about genre and rating).

# data[].attributes.body
A piece of documentation that I could add to my program would be a comment above the "spending" function that explains how it works and what each line of code does. People who are curious about the function and those who are stuck in their runthrough are people who could read it and use it as a guide for the game.

# data[].attributes.body
Initially, I had one function that took user input, subtracted the values and responded based on the value. I tried to add lists and iteration in that function but decided it'd be better to have a second function. I created another function that started with some lists and inputs. When I finished with those, I realized I needed more lists to make the program make sense.

# data[].attributes.body
A potential user of my program is someone who wants to budget their money prior to college. They can put how much money they're expecting to save or how much money they need to make.

# data[].attributes.body
The UI is just plaintext, nothing fancy. The text doesn't delete after a while either.

# data[].attributes.body
When I made a change to my program that added or edited something, I ran the program to see what the user would see. I tried every combination that I could think of as well. I also printed my lists in my main function to make sure they actually work how I want them too.

# data[].attributes.body
One input and output is when the program asks the user how much did they make in one month and how much did they spend in the same month. This makes the program subtract the numbers and give you a response based on if you have left over money or if you're in debt.

# data[].attributes.body
The purpose of my program is to help people keep track of their finances.

# data[].attributes.body
An expected user of my program is someone who needs help with their money. The program could make suggestions on what to stop buying to save money.

# data[].attributes.body
A potential user of my program would be a mouse and keyboard gamer who is looking to test which setting they are best on. They would start by typing "Ready" to begin the main program. They would go through the rounds clicking as many blocks as possible until the end of the 3 rounds, receiving a suggestion at the end.

# data[].attributes.body
The way I tested my code was by running the code every time I wrote something on it. I also tended to print all the variables to see if they stored the correct number and also when changed to see if the variable changed. In the end, I just ran the whole code to see if it was working.

# data[].attributes.body
Documentation for my program would be for the "spending" function would be:

The user would be asked about what it is that they want to spend it on, the function would then see if the user's input is in the "spending_items_list" to see if it matches one of the elements of the list, if so then the globals() and the get() function are there to translate the user's input and it's assigned variable for the value of how much that item costs. That amount gets subtracted from the budget that the user chose when they picked their difficulty. That then happens for 10 runs due to the for loop, at the end it returns their budget after they purchased all their items.

# data[].attributes.body
Documentation for my program including input, output, and function would be:

The function of the program is to shuffle a deck of cards. This is done by user input into the "shuffletype" and "howmany" variables, which are also the parameters of the procedure. Then, the procedure shuffles a list representing a deck of cards, which depends on the type and number of shuffles described with the user input into the parameters. Lastly, the "deck" or list is printed/outputted to represent a shuffled deck of cards. The topmost printed line would be the top card of the deck and the bottommost line would be the bottom card of the deck.

# data[].attributes.body
I tested it by inputting different values into the user input, and by printing the variables after they are used, so that I could figure out where the bugs I was looking for were.

# data[].attributes.body
The "empty_loop" function takes a variable and a string as it's parameters. The data in the variable is the user input. If the input was blank or just spaces, the loop will activate and will continuously ask the user to give a proper input. The function then outputs this new inputs to the list to be included in the organization. The reason for the function is to allow the user to input a proper response in case of a mistake.

# data[].attributes.body
First I worked on the user input, the lists in the program, and the random numbers, then I worked on the main function. After, I worked on the part that makes the program loop until the user tells it to stop.

# data[].attributes.body
I tested my code by acting like I did not know how it worked. So I would consistently input the wrong things to see if my code would prompt them to try again. then I would see what would happened if I spammed the input section and I did come upon some bugs and was able to fix them.

# data[].attributes.body
I created two variables to store each player's points when I started developing the code. After that, I made the function and program a list of numbers between one and ten. I created a loop that repeats a part of the function 9 times. I created another variable and stored a random item from a list. The program then asks for a number between one and ten to two users, then I subtract that number by the variable with the guess to see which one is closer. After that, I created if statements to define who gets the point, who gets the round, and who wins the whole game. I recalled the function two times and did an if statement (outside function) to see if the players were tied or if one of them already had two rounds won.

# data[].attributes.body
A potential user of my program is someone who wants to encrypt messages with an easy way to decrypt that doesn't require the recipient of the message to have the same program. They would use the program to send encrypted messages or to store messages for themselves.

# data[].attributes.body
The expected user of my program is a person going hiking who is unsure of what to pack for their hike. My program accounts for the two most important factors contributing to a hike including, the time of the hike and the season. The program collects two inputs from the user to customize their hiking recommendations including the amount of hiking time and the season.

# data[].attributes.body
The development process of this program was "ruff", I started with one function that would tell the user if there dog had eaten a certain amount of chocolate to go to the vet and then if it was too little they would just have to monitor them. I noticed soon into creating this function it would take way too long for me to complete my program. I scrapped that entire function but then used the idea of it to build the program I have now. I started out with creating a start function to keep me organized. This would prompt the user to pick a type of pet using the numbers 1, 2, and 3, I realized that this might confuse my users so changed it to them inputting the name of type of pet. After I had my start everything began to come together, I used basically the same layout for my first function for the rest of them.

# data[].attributes.body
The purpose of my program is to generate a traditional Mexican recipe based on user input. The user will be given various options to select from and will then be prompted to type in their selection. As a result, a recipe and instructions will be displayed.

# data[].attributes.body
I tested the functionality of my program by making sure that the input for the questions that prompted the user to choose a genre and rating displayed the correct movie after both genre and rating within the parameters were selected. For instance, if the user chose action for the genre and R for the rating, the program had to either recommend Deadpool or John Wick. If it displayed Beauty & the Beast I'd know that my program wasn't functioning properly because the user didn't input romance and PG.

# data[].attributes.body
This program collects user input through a series of questions that collect the calories and food that the user has eaten for the day. Then, the program outputs a series of phrases that describe the total amount of calories consumed that day and the various foods consumed that day.

# data[].attributes.body
The user interface of the program is that the whole program is text-based. The user will be prompted with text and will respond with text. The program will then respond with text depending on the user's input to the prompt.

# data[].attributes.body
The program collects two inputs from the user to customize their hiking recommendation including the amount of hiking time and the season. The user can put in a variety of hours, as long as it is a positive integer, if not the function repeats asking for input again. The recommendations are the outputs according to hours and season. For the number of hours the user types in, there are different recommendations for hikes less than or equal to three hours, 4 to 6 hours, and more than 6 hours. In the season input, there are different outputs as a list of items according to whether the user says winter, spring, summer, or fall.

# data[].attributes.body
The development process was very structured, with steps outlined at the start for the code. Implementing those steps, I worked on one thing at a time, gradually building the entirety of my code and testing each part individually and then in conjunction with the previous ones. At the end, I linked every individual step together until my code was finalized.

# data[].attributes.body
"The part where the user is asked whether they would like a recommendation or not is how the function is being called."

"Based on the user's response on if they would like breakfast, lunch or dinner which is contained as a variable called "time" determines which part of the function that is being used."

"The random number being generated determines what dish (output) the program will recommend."

# data[].attributes.body
I could add something about while loop. I would make a comment on how it keeps asking who made a point and how until you say end which then gives you the final winner of the game. The person who would use it would be the user or someone who uses/edits my code.

# data[].attributes.body
The user interface is sentences that I printed out onto the screen but then the user would be able to type out their desired option that they wanted for a specific question like their difficulty and the item they wanted to purchase. The sentences for the user would then continue on and the sentences and questions would reprint for this run of the program.

# data[].attributes.body
One expected user of this program is someone who likes music and wants some entertainment. My program meets the needs of this user because it allows them to be entertained using one of their interests. Since my code is a game it is designed to be entertaining, giving a score to the user, which makes it a good form of entertainment for the users.

# data[].attributes.body
The input of this program is when the user answers the question of whether they've ever cooked before and what meal they would like a recipe recommendation for. The output is the recipes that will be recommended to them.

# data[].attributes.body
One piece of documentation that I could add to my program would be a comment in my code detailing how the code works and how one would go about adding another song so that my program is more versatile. People would use this documentation if they don't know the two songs that I loaded in or if they wanted to memorize or practice a different song than on of the two that I loaded.

# data[].attributes.body
My code was test function after function that is, I would not implement new functions until the previous ones worked properly. I would test the code by using a test inputs that had a specified order to it, I would then check if the lists and different steps of the organization outputted the proper order of the list. This continued until all organization worked as intended.

# data[].attributes.body
When the user types "Team 1" or "team 1" it will register and add 1 point to the current variable/score.

# data[].attributes.body
The user is required to input "Ready" before the start of every round. Should they input anything else, the code asks the question again, avoiding continuing if the user is not ready. Additionally, the users will use their mouse to click on blocks that appear on the screen. After the 3 rounds, the "new_sensitivity" functions will recommend a DPI setting determined by the accuracy in each round. For example, if the user is most accurate in round 1 it will output a suggestion of 400 DPI. If the user is most accurate in round 2, the suggestion changes to 800 DPI.

# data[].attributes.body
I should add what the purpose of my program is. As it is, it's hard to figure out that the game the program was created for was 'Elden Ring', as the program could be applicable for similar games. By adding it, the user could know what the program is for, and how they should go about answering the questions.

# data[].attributes.body
The input of my program is text that the user types in, which is constrained to lowercase letters, spaces, and apostrophes, and a Y or N prompt of if the user wants to continue encrypting text. The output of the program is the encrypted version of the text that the user input. There are two keys and one is used for every other message. They are also output.

# data[].attributes.body
The user interface of the code is very basic, consisting of only text prompts. The user interface gives prompts and instruction for the type of input the user should give but nothing else.

# data[].attributes.body
The user interface would be when the user types the team who won and why the won. This gives them an output of the team who won in general and the list of actions they did to win.

# data[].attributes.body
I tested my code by running through it several times, if an error occurred I would trace it throughout the program find where I made a mistake, and then fix it. Then try that runthrough once more to make sure that the error was fixed. I did that for every difficulty and every item you could spend your money on. At the end of each run, I would either put "yes," "no," or anything else to see if it would work.

# data[].attributes.body
Something I could add to my program would be changing the set workouts for days into a second list. Instead of randomizing the amount of reps/sets. We could randomize the workouts as well. This could make the code more fun to use, especially if used consistently. They wouldn't have to input any other information with a second list. They'd automatically be given the workout and sets/reps. Keeping the Round 2 function.