DEV Community: Tommy

CS50 Week 6 - Readability in Python

Tommy — Thu, 18 Mar 2021 12:57:46 +0000

The Problem

The task here is to write some code in Python that will determine the "grade" (or reading level) of a passage of text using a calculation called the Cole-Liauman index.

The Solution

First things first, we're going to want to import the get_string function from cs50 and also import the library string from Python. This will be useful later.

from cs50 import get_string
import string

We want to get the user input and declare variables. Words is declared as one because we count spaces to find how many words there are in a passage of text, but of course it would be unusual to have a space before the first word so the amount of words in some text will be amount of spaces + 1, generally.

# Get user input
sentence = get_string("Text: ")

# Declare variables
letters = 0
words = 1
sentences = 0

To find how many sentences there are in our text we can just check to see if the current letter in the sentence is an exclamation mark, question mark or full stop.
If the letter is any other punctuation (such as a comma), we don't want to increment anything so we can just continue. We do this so that when it reaches the else block, our program won't count a comma as a letter.
To find the amount of words we can count the spaces as mentioned before.
Finally, the else block because anything else is going to be a letter.

# Loop through string, identifying each letter
for letter in sentence:
    if letter == "!" or letter == "?" or letter == ".":
        sentences += 1
    elif letter in string.punctuation:
        continue
    elif letter in string.whitespace:
        words += 1
    else:
        letters += 1

We first need to find the word factor before we do any calculations. This is important because it allows us to find how many letters and sentences there are per 100 words.
The Coleman-Liau index calculation is rounded to an integer.

# Calculations for liau index
wordFactor = words / 100
lettersPer100 = letters / wordFactor
sentencesPer100 = sentences / wordFactor
liauIndex = round((0.0588 * lettersPer100) - (0.296 * sentencesPer100) - 15.8)

Finally, we just have to print the grade based on what the Coleman-Liau index is! Above 16 we print "Grade 16+", below 1 is "Before Grade 1" and anything else is going to be whatever the grade is so we can just inject the Coleman-Liau value into a string that says "Grade {liauIndex}".

# Print correct grade based on liau indx
if liauIndex > 16:
    print("Grade 16+")
elif liauIndex < 1:
    print("Before Grade 1")
else:
    print(f"Grade {liauIndex}")

Jobs a goodun!

CS50 Week 6 - Cash in Python (Less Comfortable)

Tommy — Wed, 17 Mar 2021 12:58:27 +0000

The Problem

The user will input some amount of change and we have to take away the largest posssible coin (¢1, ¢5, ¢10, ¢25) until there is no change left and return how many coins it took to reach 0.

The Solution

Firstly we're going to need the get_float function from cs50.

from cs50 import get_float

Next, we need to make sure the number being input by the user is valid which we will need a variable for. We also need a variable to track how many coins have been used so I decided to declare these first

# Declare variables
change = 0
count = 0

To make sure the input is valid, I used a while loop to check if change is greater than 0. If not, simply re-assign the variable with another prompt. After the input I rounded the value and multiplied by 100.
This makes sure that the input is always possible to work with. If it was 0.00001 for example, multiplying this by 100 would give you 0.001 which is not a possible coin. Rounding it would round to 0 in this case.

# While change is NAN, prompt user
while change <= 0:
    change = get_float("Change owed: ")
    cents = round(change * 100)

Looking back I probably could've put the cents = round(change * 100) after the while loop because it's just making the computer do unnecessary work. Oh well ¯_(ツ)_/¯

All we need to do now is check if cents is greater than the coin values, if it is, take away the value from cents and increment the count.

while cents > 0:
    if cents >= 25:
        cents = cents - 25
        count = count + 1
    elif cents >= 10:
        cents = cents - 10
        count = count + 1
    elif cents >= 5:
        cents = cents - 5
        count = count + 1
    elif cents >= 1:
        cents = cents - 1
        count = count + 1

I'm 99% sure the order is important here. We want to check if the largest coin is possible FIRST before checking the others.

Once this is done we can simply print the number of coins!

print(count)

Full code:

from cs50 import get_float

# Declare variables
change = 0
count = 0

# While change is NAN, prompt user
while change <= 0:
    change = get_float("Change owed: ")
    cents = round(change * 100)

# While cents is greater than 0, take away largest coin possible  and increment count
while cents > 0:
    if cents >= 25:
        cents = cents - 25
        count = count + 1
    elif cents >= 10:
        cents = cents - 10
        count = count + 1
    elif cents >= 5:
        cents = cents - 5
        count = count + 1
    elif cents >= 1:
        cents = cents - 1
        count = count + 1

print(count)

CS50 Week 6 - Mario in Python (More Comfortable)

Tommy — Tue, 16 Mar 2021 20:44:01 +0000

I've been wanting to start writing how I solve problems for a while, and the best time to start was yesterday, the second best time is now. So here we go.

If you're familiar with CS50 and the Mario problem then you probably understand what I was trying to do, but here's a brief overview.

The Problem

The task was to print a pyramid of height specified by the user. The correct amount of whitespace, then the correct number of # blocks on each line, followed by a space, then the same amount of # blocks after the space creating something like this:

  # #
 ## ## 
### ###

The Solution

To tackle this problem, I first used the get_int function from the cs50 library. Save me having to typecast things. I like convenience!

from cs50 import get_int

Then we needed to make sure that the height is valid, and if it isn't we need to prompt the user again until a correct value is entered.

I decided to define the variable height first. Then I could check if the value was correct, and if not re-prompt the user.

height = 0
while height > 8 or height < 1:
    height = get_int("Height: ")

All good so far but the next part was the toughest. We now have the height of the pyramid that will reject non-numeric heights and re-prompt if the height is invalid. Now to print the correct pyramid.

I tried a few solutions but I landed on this one because it made the most sense to me.

First, we need to enter a loop for each row of the pyramid

for i in range(1, height + 1):

I started at 1 and ended at height + 1 so that the value of i is equal to the row number.

Then, enter another loop for each column.

for i in range(1, height + 1):
    for j in range(1, height + 1):

Now we need to print the correct amount of spaces before printing any #'s. I decided to do this by checking to see if j (the current column) is greater than the height - i (the current row number) and if it is, then Python knows it's time to start printing #'s instead of whitespace!
This logic works because on row i, we want i amount of hashtags and height - i amount of spaces.

# Loop through rows and then columns
for i in range(1, height + 1):
    for j in range(1, height + 1):
        # Start printing # after correct number of spaces
        if j > (height - i):
            print("#", end="")
        else:
            print(" ", end="")

end="" makes sure a new line isn't printed after each iteration.

Finally, we just need to print a space and the same amount of #'s after the space which is easily done.

# Print middle space and remaining #
        if j == height:
            print(" ", "#" * i, end="")

There's one key part I haven't mentioned. We need to print a new line after the column loops have finished so that a new row starts. Easily fixed, just print() after the j loop and we're done!

Full code:

from cs50 import get_int

height = 0
while height > 8 or height < 1:
    height = get_int("Height: ")

# Loop through rows and then columns
for i in range(1, height + 1):
    for j in range(1, height + 1):
        # Start printing # after correct number of spaces
        if j > (height - i):
            print("#", end="")
        else:
            print(" ", end="")
        # Print middle space and remaining #
        if j == height:
            print(" ", "#" * i, end="")
    print()

There you have it. On the way to Bowser's castle.