SkillsUSA Districts Problem - Consecutive Coin Flips
Here goes the second take of my skillsUSA districts blog post. The SkillsUSA district competition was fun! I spent about 4 hours total between the two programming problems, and I will be going over one of the problems that I really enjoyed solving. I did my work for this problem in C#.
Our task was to make a program that would ask a user how many times they wanted to flip a coin, flip a coin that many times for heads or tails (with a 50/50 shot of either,) and record and output their longest streak of consecutive heads or tails flips. Additionally this program also needed to keep track of and output the longest consecutive heads or tails record between all rounds.
To flip a coin I knew I was going to use a random number generator to generate 2 values, use one of those for heads and one for tails. We will iterate through this however many times our user asks us to each round.
But consecutive streaks? How do you track those? Well, I thought, you really only need two main pieces of information to determine a consecutive streak of things. To determine if it has rained 2 days consecutively, you need to know if it is raining today AND if it rained yesterday. To know if it has rained 3 days, you just notice that it is still, in fact raining, and that we were previously on a count of 2 days, then you just add on from there. This kind of logic, when you catch yourself using numbers and words like “if” “and” and “then”, is usually pretty intuitive to implement into code.
So in our coin flip problem, we want a variable that keeps track of the flip we’re doing now, and a variable that has the value from the previous flip. We will probably call these flip and lastFlip. Our rounds could proceed as follows: We flip the coin for this iteration, we display the result, we check to see if our flip and lastFlip are the same, if they are, we add +1 to the relevant consecutive counter. If they aren’t we set our counters to zero.
Wait, but I need to store the consecutive streak somewhere before we reset it! So that we can keep track of the highest streak this round, not just the current ongoing streak. This will require 2 variables to store our highest heads and tails streaks during the round. These will be updated every time the current streak of heads or tails exceeds it.
Then, at the very end of the iteration, we will set our lastFlip equal to the flip value from this iteration. Because lastFlip won’t be updated until after it is compared to the next iteration’s flip value, you can use it to compare the coin flips across iterations. Of course, you then repeat this flip, compare, update process however many times as the user told the program to do it.
And to keep track of our records between rounds? Two more variables can hold the heads record and tails record and then be checked and updated after the completion of a round using our consecutive streak variables from inside the round.
So now that I had an idea of what this would look like, I started typing. I will go over each function I made, then review the Main Method last.
The idea here was to use the languages RNG to get a 1 or a 0 and have this function return (output) a true or false value depending on the result.
The most interesting thing here is the way the Random class works. You can see we are initializing a new object called ‘rand’ of the Random class. This object can be used, with the .Next(min, max) method to create a pseudorandom number within a given range.
It uses the exact date and time on the computer’s clock as a seed value in an algorithm that shoots out a pretty much random number between 0 - 0.999(repeating.) Then it uses that number, alongside a small amount of arithmetic, to give you a value from and including your min value all the way to but NOT including your max value. This is a “side effect” of using a seed that can be anywhere from 0 - 0.999(repeating) but not 1.
This function gets a random number, with a max value of 2 (so it will return a zero, or a one, but NOT a two.) If that number is 1, return the boolean value of true. Otherwise (when it is zero) return the value of false.
You might notice that there is no conditional statement (<. >. ==, etc) in our if( ) block. If you put a boolean variable in there without a conditional, it will just operate the if when the boolean is true and the else when it is false.
PlayGame(int rounds, out int consecHeads, out int consecTails)
This function will run through 1 round (n iterations, based on user input) of the coin flip game. Remember the steps “flip, display, update counters, store flip to last flip, repeat.” This will be the basis of this function.
First we set our consecutive counters to zero, just so we are making sure we start off with a clean slate. We declare our flip variables as well. lastFlip starts out as false, because the C# compiler wanted a value there. I commented on it though, so that fact wouldn’t confuse me later.
The meat of our program is a for loop that starts a counter at zero, runs our code, then adds one to that counter. The loop will stop once the counter reaches the number of rounds.
We store the result of a Flip() to our variable, named flip. You may notice in the code, I flipped the “update” and “display” steps around, this is okay I determined because the display step doesn’t change any data and the update step doesn’t change data the display step uses.
Anyways, we check if it is the first iteration, because if it is, we don’t want to run any operations that use lastFlip, because the value in there means nothing at the moment. The if (i != 0) statement makes sure our consecutive streak counting code is run on every iteration except the first.
This code adds 1 to the headsCount if it is already initialized, or greater than zero (we will get to that later,) and the current flip and last flip are both true. Adds to the tailCount if the same conditions are met but both flips are false. If the flips are not equal to each other, it resets the relevant streak counter.
We also have code that initializes the counts when either our counts have just been reset or it is the first iteration. These two if blocks will initialize either our heads or tails streak counter
Now, we update the largest consecutive heads and consecutive tails trackers if the streak we’re on is bigger than the streak in the tracker already.
Then display the result of the flip. Afterwards set the lastFlip = to the flip value. Then we iterate this process until we have done every iteration we were asked to do.
Afterwards display those largest streak trackers we were updating earlier.
Notice that we output the consecHeads and consecTails streaks. This is because we need to know them for other functions that track the highest streaks between each game the user plays.
UpdateHeads(int consecHeads, int headsRecord)
And UpdateTails(int consecTails, int tailsRecord)
These functions update our record by checking the consecHeads or tails value, comparing it to its record, and replacing that record if the value was higher. In retrospect, these are literally the same function. The variable names change but nothing else. This could just be one function.
DisplayRecords(int consecHeads, int consecTails, ref int headsRecord, ref int tailsRecord)
Here we display the changes to our record, and THEN we update them in memory using our Update functions from earlier. We pass the record variables by reference because we want to use and change their values in a scope beyond that of this particular function.
This method is mainly control structures and the “glue” that holds all the other functions together.
We declare our program wide variables at the top. These include gameRounds, consecHeads, consecTails, headsRecord, tailsRecord, validInput, playAgain, PlayAgainAnswer.
Our game happens in a do/while loop that uses the playAgainAnswer as a sentinel to break out of the loop.
We prompt our user, then use a do/while loop that validates their input. If you aren’t familiar with TryParse, it takes an input variable, returns a true boolean if it is a correct type and false if not, and sets the output variable to the input if it is the correct type and -1 if not.
Then we play the game, this will do as many iterations of coin flips as the user inputs. We display the records. Then we use a do/while loop to validate our users input on whether or not they want to play again, if they do, playAgainAnswer will be Y or y and the loop will repeat.
Here is what the program looks like in practice:
My code did the job, and was written with in the time-limit so I was satisfied but upon further review, there are definitely some redundancies that could be removed.
I had a lot of fun at the competition. Also, I won first place! These kind of things are important to remember and hold onto, because programming is hard and you will be discouraged. It's these kinds of achievements that can preserve your confidence through the harder challenges.
stormborns
izzy806
romaincrisis
origamiaround
turnnoffyourmind
snowghoul
dededos
