I decided after some time to take the plunge into the Credit activity. As I previously explained, the logic was all present and supplied. The goal was simply to manipulate the information given into actual code.
As many have said before, and a friend has reiterated to me before I decided to give it a go: “It’s one thing to have your brain process the information and understand how to get the result. It’s another to create a program with only your own understanding of the language within it.” It reminded me of Scratch from Week 0. With a heavy history of game editing in first party supplied editors for their own games, I thought my experience in Scratch would be a breeze. Instead I found myself frustrated with certain “basic” functions taking multiple steps because they are not the steps I normally used to taking. Instead, Scratch focused on a more simpler approach that required more to get a result while I was used to more advanced functions that would shorten the input necessary from the creator to get a result. So, I took the dive and realized quickly I was very unfamiliar with C still.
I struggled for a few days during my downtime after work to even grasp how I would process the meat of the project: Luhn’s algorithm. Checking for the validity of credit card being just digits? Breeze. Checking for length? Easy. Checking for beginning digits? Simple. But running an algorithm of all the digits? Oh boy. It took a few hours of processing and understanding an order, a repetition, and ways you could perform the formula, but eventually it stood out. I refused to go with a method I saw all too often in the CS50 Discord… creating a variable for every single digit. This created a rather massive block of code to acquire this information. In addition, it was not guaranteed to even have digits in some cases for some variables due to the varied length of cards. Some other cases used arrays, which would make more sense, however we have not been properly introduced to arrays so I did not want to “jump the gun”.
In the end I went with a pattern of “assume the first digit on the right is even”. While I did not enjoy the idea of assuming something, it felt like the right approach. I saved and added an even digit to an even total before removing that digit from the card. Then I saved and multiplied an odd digit by two (and added the digits separately) and added the total an an odd total before removing that digit from the card. The adding digits separately bit was part of Luhn’s algorithm. If the result was 12, for example, you add 1 and 2 to make 3. This took a shortcut as even 9 multiplied by 2 is still under 20, so it simply added “1” to the modulo 10 of the total, which returns the second digit. This repeated until there was no more digits, then the totals were added together (this was mostly done for testing, but I left it in. It could have been added all to a single variable at the same time.) After, I check if the total is divisible by ten by checking is the modulo 10 is zero, as in the second digit is zero. If so, then it checks for the card type to give a result. Overall, once I started to “move” with the activity, it turned out to be relatively simple, just took a bit to expand the mind to get to writing the code.
#include <cs50.h>
#include <stdio.h>
int lengthTotal;
int lengthCheck(void);
int startsWith(void);
long creditCard;
int main(void)
{
do
{
creditCard = get_long("Number: ");
}
while (creditCard < 0);
long workingNum;
int workingNumOdd;
int workingNumEven;
int workingSum = 0;
int workingOddTotal = 0;
int workingEvenTotal = 0;
int length;
workingNum = creditCard;
for (length = 0; workingNum > 0; length++)
{
// Consider the right most digit "Even" and take it and add to total.
workingNumEven = workingNum % 10;
workingEvenTotal = workingEvenTotal + workingNumEven;
// Remove the right most digit as the even digit process is complete.
workingNum = workingNum / 10;
// Now the right most digit is "Odd", single the digit out.
workingNumOdd = workingNum % 10;
// Now take the single digit and multiply it by 2, if greater than 9 split and add digits.
workingNumOdd = workingNumOdd * 2;
if (workingNumOdd > 9)
{
workingNumOdd = 1 + (workingNumOdd % 10);
}
// Continue adding to total of workingOddTotal
workingOddTotal = workingOddTotal + workingNumOdd;
// Remove the right most digit as the even digit process is complete.
workingNum = workingNum / 10;
}
// Now that the digits are processed, add the odd and even total together, verify divisible by 10.
workingSum = (workingEvenTotal + workingOddTotal) % 10;
// Verify that the total is divisible by ten to confirm the checksum.
if (workingSum == 0)
{
// If VALID, proceed through card type checks, begin with AMEX.
startsWith();
}
else
{
printf("INVALID\n");
}
}
// Get length of card
int lengthCheck(void)
{
int length = 0;
long workingNum = creditCard;
for (length = 0; workingNum > 0; length++)
{
workingNum = workingNum / 10;
}
return length;
}
int startsWith(void)
{
int i = 0;
long workingNum = creditCard;
lengthTotal = lengthCheck();
// Reduce credit card to first two digits
for (i = 0; workingNum > 99; i++)
{
workingNum = workingNum / 10;
}
// Check for American Express digits
if (workingNum == 34 || workingNum == 37)
{
// Check length for American Express
if (lengthTotal == 15)
{
printf("AMEX\n");
}
else
{
printf("INVALID\n");
}
}
// Check for Mastercard digits
else if (workingNum > 50 && workingNum < 56)
{
// Check length for Mastercard
if (lengthTotal == 16)
{
printf("MASTERCARD\n");
}
else
{
printf("INVALID\n");
}
}
else
// Reduce workingNum to 1 digit to check VISA
{
workingNum = workingNum / 10;
if (workingNum == 4)
{
// Check length for Visa
if (lengthTotal == 13 || lengthTotal == 16)
{
printf("VISA\n");
}
else
{
printf("INVALID\n");
}
}
else
{
printf("INVALID\n");
}
}
return 0;
}