Блоги: заметки с тегом CS50

Scrabble in C

Daniel Sokolovskiy — Sun, 25 Feb 2024 18:38:13 +0500

In the second week of CS50, I was introduced to the notion of arrays and then given the following problem to solve as a practice:

In the game of Scrabble, players create words to score points, and the number of points is the sum of the point values of each letter in the word. For example, if we wanted to score the word “CODE”, we would note that the ‘C’ is worth 3 points, the ‘O’ is worth 1 point, the ‘D’ is worth 2 points, and the ‘E’ is worth 1 point. Summing these, we get that “CODE” is worth 7 points.

Implement a program in C that determines the winner of a short Scrabble-like game. Your program should prompt for input twice: once for “Player 1” to input their word and once for “Player 2” to input their word. Then, depending on which player scores the most points, your program should either print “Player 1 wins!”, “Player 2 wins!”, or “Tie!” (in the event the two players score equal points).

First, I outlined the general steps needed to solve this problem:

Get text inputs from the user;
Calculate the score of each input;
Show the winner.

For the first step, I’ll creat two variables named word1 and word2 respectively, and assign each to the value of the respective user input using the get_string function from the CS50 library:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Prompt the user for two words
    string word1 = get_string("Player 1: ");
    string word2 = get_string("Player 2: ");

    // Compute the score of each word

    // Print the winner
}

That was easy. The trickiest part here, of course, is the second step, which is to assign each letter of the alphabet its unique score points value.

Here are the values:

A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
1	3	3	2	1	4	2	4	1	8	5	1	3	1	1	3	10	1	1	1	1	4	4	8	4	10

Now that I know about arrays, I can create an array called points with a size of 26 and the type of integer, and assign values as follows:

#include <cs50.h>
#include <stdio.h>
#include <string.h>

int main(void)
{
    // Prompt the user for two words
    string word1 = get_string("Player 1: ");
    string word2 = get_string("Player 2: ");

    // Compute the score of each word
    int points[] = {1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10};

    // Print the winner
}

I don’t quite like the length of that like, but it seems there is not much to do about it since all values are set by the rules of the game.

Now that I know a little bit about functions too, I’ll create a separate function for computing the score. This should make the code more efficient and better designed, especially since I need to use it twice for calculating the score for each word.

I’ll call this function calculate_score, with one input parameter of the type of string, and output of integer. I can also straight away create a variable called score with the type of integer, as this is ultimately what I want to get from this function:

int calculate_score(string word)
{
    int score = 0;

    return score;
}

Now, the big question is how to assign each letter a corresponding score value. Well, turns out that every string is basically just an array of characters. Let’s take the word CODE as an example. We can imagine it as an array as follows, keeping in mind the zero-based indexing of arrays, i.e. starting counting from 0:

c word[i]
word[0] = C
word[1] = O
word[2] = D
word[3] = E

Knowing this, I can create a loop to ‘scan’ through the word character by character. For this loop to work, I would to know the length of the word, and luckily such a function already exists in the string.h library and is called strlen:

for (int i = 0; i < strlen(word); i++)
{
}

What I don’t quite like about this loop though, is that every time it works, it makes the function repeat that many times. To optimise this, let me create another variable called len with its value equal to the length of a word, and then use this variable as the condition of the loop:

for (int i = 0, len = strlen(word); i < len; i++)
{
}

Now, how to make the loop ‘know’ which score value corresponds to each letter? There is actually a trick that still blows my mind even after completing this task. Since every character has its numeric value in the ASCII code, we can use this information to ‘offset’ characters from one array to another and this way map them together.

Let’s take the capital letter ‘C’ from the word CODE as I used the example. Its numeric value in ASCII is 67, and the trick is to subtract the value of the letter A, which equals 65. Why A? Because it’s the first letter of the alphabet, and if we subtract it from another letter, we’ll know its place in the array. So 67 – 65 = 2, and that is exactly the index number we need from the points array.

To make it more visual, here is a similar exercise for all letters of the word CODE:

Letter	ASCII	Index	Points
C	67	67 – 65 = [2]	3
O	79	79 – 65 = [14]	1
D	68	68 – 65 = [3]	2
E	69	69 – 65 = [4]	1

... which means the word CODE gives the Scrabble score of 7 (as 3 + 1 + 2 +1), and that is indeed correct. It works like a charm!

To make array indexing a little more obvious, I’ll add it to the score table too:

Letter:	A	B	C	D	E	F	G	H	I	J	K	L	M	N	O	P	Q	R	S	T	U	V	W	X	Y	Z
Score:	1	3	3	2	1	4	2	4	1	8	5	1	3	1	1	3	10	1	1	1	1	4	4	8	4	10
Index:	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25

This system doesn’t quite work for the lowercase letters though, because the ASCII values of the lowercase letters are different from the capital letters. However, it simply means that we need to subtract the value of the lowercase letter ‘a’ instead of the capital ‘A’.

So it seems I need an if statement within the loop to calculate the score depending on the case of the letters using isupper and islower functions from the ctype.h library, which I’ll include in the header too:

int calculate_score(string word)
{
    // Keep track of the score
    int score = 0;

    // Compute the score for each character
    for (int i = 0, len = strlen(word); i < len; i++)
    {
        if (isupper(word[i]))
        {
            score += points[word[i] - 'A'];
        }
        else if (islower(word[i]))
        {
            score += points[word[i] - 'a'];
        }
    }
    return score;
}

Since I’m using the points array in this function, I need to move it out from the main’s local scope to the global scope. The rest is easy: all I need to do is to call the function calculate_score (twice, for each word) and then compare players’ scores to determine the winner.

And here is my final code:

#include <cs50.h>
#include <ctype.h>
#include <stdio.h>
#include <string.h>

// points assigned to each letter of the alphabet
int points[] = {1, 3, 3, 2, 1, 4, 2, 4, 1, 8, 5, 1, 3, 1, 1, 3, 10, 1, 1, 1, 1, 4, 4, 8, 4, 10};

int calculate_score(string word);

int main(void)
{
    // Prompt the user for two words
    string word1 = get_string("Player 1: ");
    string word2 = get_string("Player 2: ");

    // Compute the score of each word
    int score1 = calculate_score(word1);
    int score2 = calculate_score(word2);

    // Print the winner
    if (score1 > score2)
    {
        printf("Player 1 wins!\n");
    }
    else if (score1 < score2)
    {
        printf("Player 2 wins!\n");
    }
    else
    {
        printf("Tie!\n");
    }
}

int calculate_score(string word)
{
    // Keep track of the score
    int score = 0;

    // Compute the score for each character
    for (int i = 0, len = strlen(word); i < len; i++)
    {
        if (isupper(word[i]))
        {
            score += points[word[i] - 'A'];
        }
        else if (islower(word[i]))
        {
            score += points[word[i] - 'a'];
        }
    }
    return score;
}

Credit card validation in C

Daniel Sokolovskiy — Sun, 25 Feb 2024 14:25:23 +0500

Daniel Sokolovskiy:

I keep learning programming, and today I share my baby walkthrough of the second homework from the CS50 course titled Credit.

As a quick disclaimer, I used only tools I’ve learned from the two lessons I had so far.

Here is the problem to solve:

A credit (or debit) card, of course, is a plastic card with which you can pay for goods and services. Printed on that card is a number that’s also stored in a database somewhere, so that when your card is used to buy something, the creditor knows whom to bill. There are a lot of people with credit cards in this world, so those numbers are pretty long: American Express uses 15-digit numbers, MasterCard uses 16-digit numbers, and Visa uses 13- and 16-digit numbers. And those are decimal numbers (0 through 9), not binary, which means, for instance, that American Express could print as many as 10^15 = 1,000,000,000,000,000 unique cards! (That’s, um, a quadrillion.)

Actually, that’s a bit of an exaggeration, because credit card numbers actually have some structure to them. All American Express numbers start with 34 or 37; most MasterCard numbers start with 51, 52, 53, 54, or 55 (they also have some other potential starting numbers which we won’t concern ourselves with for this problem); and all Visa numbers start with 4. But credit card numbers also have a “checksum” built into them, a mathematical relationship between at least one number and others. That checksum enables computers (or humans who like math) to detect typos (e. g., transpositions), if not fraudulent numbers, without having to query a database, which can be slow. Of course, a dishonest mathematician could certainly craft a fake number that nonetheless respects the mathematical constraint, so a database lookup is still necessary for more rigorous checks.

Write a program that prompts the user for a credit card number and then reports (via printf) whether it is a valid American Express, MasterCard, or Visa card number, per the definitions of each’s format herein. So that we can automate some tests of your code, we ask that your program’s last line of output be AMEX\n or MASTERCARD\n or VISA\n or INVALID\n, nothing more, nothing less. For simplicity, you may assume that the user’s input will be entirely numeric (i.e., devoid of hyphens, as might be printed on an actual card) and that it won’t have leading zeroes. But do not assume that the user’s input will fit in an int! Best to use get_long from CS50’s library to get users’ input.

First, I’ll prompt a user to input a number using the get_long function from the CS50 library:

#include <cs50.h>
#include <stdio.h>

int main(void)
{
    long card_number = get_long("Number: ");
}

Next, I’ll do what seems to be the most challenging part of the problem, which is to calculate the checksum of a credit card. In the problem description, they provide additional information on Luhn’s Algorithm that determines the validity of a card as follows:

Multiply every other digit by 2, starting with the number’s second-to-last digit, and then add those products’ digits together.
Add the sum to the sum of the digits that weren’t multiplied by 2.
If the total’s last digit is 0, the number is valid!

Let’s take the card number 4003600000000014 as an example. For the sake of visibility, let me underline every other digit, starting with the number’s second-to-last digit:

4 0 0 3 6 0 0 0 0 0 0 0 0 0 1 4

How to extract those digits from a number in C? Turns out, in maths, there is a great operation that can give us the remainder after dividing one number by another, and it’s called modulo, or mod. You can totally start laughing here, but honestly, I never heard of it before. For example, 1234 % 10 = 4 (with modulo operation being expressed by the percent sign), since 4 is the last digit in the number 1234.

Okay, that was the last digit. But how to get to the second-to-last digit, and then get every other digit from there? This might be not as obvious (at least it wasn’t at first to me), but since we’re dealing with whole numbers, a simple division by 10 basically moves us to one character in a number at a time. For example, 1234 / 10 = 123,4, but since the integer numbers get truncated, the result is actually 123.

Pretty cool, huh? Now let’s try to get every second number using the combination of division and modulo operations in the code:

#include <cs50.h>
#include <stdio.h>

long card_number;
int main(void)
{
    // Prompting a user to input a credit card number
    card_number = get_long("Number: ");

    // Calculating checksum
    int last_digit;
    int second_to_last_digit;

    while (card_number > 0)
    {
        // Removing the last digit
        last_digit = card_number % 10;
        card_number /= 10;

        // Removing the second last digit
        second_to_last_digit = card_number % 10;
        card_number /= 10;
        printf("%i", second_to_last_digit);
    }
    printf("\n");
}

This code prints 10000604, which are exactly the digits we need from the card number 4003600000000014. Keep in mind it’s not a number ten million six hundred four, but individual digits printed one after another. The order of digits is reversed, though it’s irrelevant in this case.

Next, according to Luhn’s Algorithm, I need to multiply each digit by 2 and get the sum of all of them combined. And I haven’t found a better solution than again using the same modulo and division operations, but this time on the extracted digits:

#include <cs50.h>
#include <stdio.h>

long card_number;
int main(void)
{
    // Prompting a user to input a credit card number
    card_number = get_long("Number: ");

    // Calculating checksum
    int every_second_digit = 0;
    int last_digit;
    int second_to_last_digit;
    int digit1;
    int digit2;

    while (card_number > 0)
    {
        // Removing the last digit and adding to every_other_digit
        last_digit = card_number % 10;
        card_number /= 10;

        // Removing the second last digit
        second_to_last_digit = card_number % 10;
        card_number /= 10;

        // Mupliplying second last digit
        second_to_last_digit *= 2;

        // Adding digits together to get the sum of every_second_digit
        digit1 = second_to_last_digit % 10;
        digit2 = second_to_last_digit / 10;
        every_second_digit += digit1 + digit2;
    }
    printf("%i", every_second_digit);
    printf("\n");
}

I’m pretty sure it could be done more elegantly, but I’m using only the knowledge I have so far from the first week of introduction to programming. Importantly, this code works, providing the result of the number 13, as you would expect from the sum of digits 2 + 1 + 2 + 8. Yay!

Lastly, to finish off the checksum, I’m going to find every other digit, add them together, and then add both sums in the final checksum variable:

#include <cs50.h>
#include <stdio.h>

long card_number;
int main(void)
{
    // Prompting a user to input a credit card number
    card_number = get_long("Number: ");

    // Calculating checksum
    int every_second_digit = 0;
    int every_other_digit = 0;
    int checksum = 0;
    int last_digit;
    int second_to_last_digit;
    int digit1;
    int digit2;

    while (card_number > 0)
    {
        // Removing the last digit and adding to every_other_digit
        last_digit = card_number % 10;
        card_number /= 10;
        every_other_digit += last_digit;

        // Removing the second last digit
        second_to_last_digit = card_number % 10;
        card_number /= 10;

        // Mupliplying second last digit
        second_to_last_digit *= 2;

        // Adding digits together to get the sum of every_second_digit
        digit1 = second_to_last_digit % 10;
        digit2 = second_to_last_digit / 10;
        every_second_digit += digit1 + digit2;
    }

    // Getting checksum
    checksum = every_second_digit + every_other_digit;

    printf("%i\n", checksum);
}

This code now prints the number 20, which is exactly the kind of value I want from a valid credit card. The hardest part is done!

Next, I’ll calculate the number of digits in the card number using a simple loop:

// Counting the number of digits in the card number
    long n = card_number;
    int number_of_digits = 0;
    do
    {
        n /= 10;
        number_of_digits++;
    }
    while (n != 0);

To keep the value of that card_number intact, I added a new variable called n and assigned its value to card_number, so I can do the maths with the n instead. In plain English, that loop says the following: while the card number is not equal to zero, divide the card number by 10, and for every division increase the number of number_of_digits variable which I use as a counter by one.

For example, if I were to type in the number 1234, it would go as follows:

1234 / 10 = 123; the counter increases from 0 to 1;
123,4 / 10 = 12; the counter increases from 1 to 2;
12,34 / 10 = 1; the counter increases from 2 to 3;
1 / 0 = 10; the counter increases from 3 to 4;

Now the card number gets equal to zero, and the loop ends with the counter equal to 4, which is the correct number of digits in the number 1234.

Next, I’ll make another counter to get the first two digits of the card number using pretty much the same logic:

// Getting the first two digits of the card number
    int first_two_digits = 0;
    long i = card_number;
    while (i > 100)
    {
        i /= 10;
        first_two_digits = i;
    }

Lastly, I’ll check the validity of the checksum and then check what credit company the card belongs to based of the card number length and starting digits.

So here is my final code:

// A program in C that checks the validity of a given credit card number

#include <cs50.h>
#include <stdio.h>

long card_number;
int main(void)
{
    // Prompting a user to input a credit card number
    card_number = get_long("Number: ");

    // Counting the number of digits in the card number
    long n = card_number;
    int number_of_digits = 0;
    do
    {
        n /= 10;
        number_of_digits++;
    }
    while (n != 0);

    // Getting first two digits of the card number
    int first_two_digits = 0;
    long i = card_number;
    while (i > 100)
    {
        i /= 10;
        first_two_digits = i;
    }

    // Calculating checksum
    int every_second_digit = 0;
    int every_other_digit = 0;
    int checksum = 0;
    int last_digit;
    int second_to_last_digit;
    int digit1;
    int digit2;

    while (card_number > 0)
    {
        // Removing last digit and adding to every_other_digit
        last_digit = card_number % 10;
        card_number /= 10;
        every_other_digit += last_digit;

        // Removing the second last digit
        second_to_last_digit = card_number % 10;
        card_number /= 10;

        // Mupliplying the second last digit
        second_to_last_digit *= 2;

        // Adding digits together to get the sum of every_second_digit
        digit1 = second_to_last_digit % 10;
        digit2 = second_to_last_digit / 10;
        every_second_digit += digit1 + digit2;
    }

    // Getting checksum
    checksum = every_second_digit + every_other_digit;

    // Checking for the card validity
    int validity = checksum % 10;
    if (validity == 0)
    {
        if ((number_of_digits == 15) && (first_two_digits == 34 || first_two_digits == 37))
        {
            printf("AMEX\n");
        }
        else if ((number_of_digits == 16) && (first_two_digits >= 51 && first_two_digits <= 55))
        {
            printf("MASTERCARD\n");
        }
        else if ((number_of_digits == 16 || number_of_digits == 13) && (first_two_digits / 10 == 4))
        {
            printf("VISA\n");
        }
        else
        {
            printf("INVALID\n");
        }
    }
    else
    {
        printf("INVALID\n");
    }
}

Update

A week later after posting this solution, I decided to get back to this problem and see if I could improve the code, particularly focusing on the checksum part as it’s essentially the main part.

Here is my updated code for this function:

// Calculate checksum using Luhn's Algorithm
int calculate_checksum(long long number)
{
    int sum = 0;
    int digit;
    bool is_second_digit = false;

    while (number > 0)
    {
        digit = number % 10; // Get the last digit
        number /= 10; // Reduce the number by one digit

        if (is_second_digit)
        {
            digit *= 2;
            sum += digit % 10 + digit / 10; // Split double numbers into single digits, e.g. 12 into 1 and 2
        }
        else
        {
            sum += digit;
        }

        // Switch the boolean, alternating between odd and even digits
        is_second_digit = !is_second_digit;
    }

    return sum;
}