I was doing the problem set2 for cs50x course, and while solving the caesar problem, i came across some unsual ouputs

Question

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

    int main(int argc,string argv[]){    

        if(argc==2)  //to make sure there's only one string after ./caesar
        {
        int digit=0,key=0;

            for(int i=0,n=strlen(argv[1]);i<n;i++)
            {
                if(argv[1][i]>='0' && argv[1][i]<='9')
                {
                digit= argv[1][i]-'0';
                key=key*10+digit;
                }

                else{
                    printf("Usage: ./caesar key\n");
                    return 1;
                }

        }

        string text=get_string("plainttext:  ");
        printf("ciphertext: ");


        key=key%26;

        for(int i=0,n=strlen(text);i<n;i++){

            if(islower(text[i]))
            {

            text[i]=text[i]+key;

                if(text[i]>'Z')
                {
                    text[i]=text[i]-26;
                }


                printf("%c",(char)text[i]);




            }

        else if(isupper(text[i]))
            {
                text[i]=text[i]+key;

                if(text[i]>'Z')
                {
                    text[i]=text[i]-26;
                }


                printf("%c",(char)text[i]);
            }

            else
            printf("%c",(char)text[i]);


        }

        printf("\n %i",key);




        return 0;

        }







    else{
            printf("Usage: ./caesar key\n");
            return 1;
        }
    }

Design and implement a program, caesar, that encrypts messages using Caesar’s cipher.

• Implement your program in a file called caesar.c in a directory called caesar.
• Your program must accept a single command-line argument, a non-negative integer. Let’s call it
• for the sake of discussion.
• If your program is executed without any command-line arguments or with more than one command-line argument, your program should print an error message of your choice (with printf) and return from main a value of 1 (which tends to signify an error) immediately.
• If any of the characters of the command-line argument is not a decimal digit, your program should print the message Usage: ./caesar key and return from main a value of 1.
• Do not assume that
• will be less than or equal to 26. Your program should work for all non-negative integral values of
• less than
• In other words, you don’t need to worry if your program eventually breaks if the user chooses a value for
• that’s too big or almost too big to fit in an int. (Recall that an int can overflow.) But, even if
• is greater than
• alphabetical characters in your program’s input should remain alphabetical characters in your program’s output. For instance, if
• is
• A should not become \ even though \ is
• positions away from A in ASCII, per asciitable.com; A should become B, since B is
• positions away from A, provided you wrap around from Z to A.
• Your program must output plaintext: (with two spaces but without a newline) and then prompt the user for a string of plaintext (using get_string).
• Your program must output ciphertext: (with one space but without a newline) followed by the plaintext’s corresponding ciphertext, with each alphabetical character in the plaintext “rotated” by k positions; non-alphabetical characters should be outputted unchanged.
• Your program must preserve case: capitalized letters, though rotated, must remain capitalized letters; lowercase letters, though rotated, must remain lowercase letters.
• After outputting ciphertext, you should print a newline. Your program should then exit by returning 0 from main.

https://cs50.harvard.edu/x/2024/psets/2/caesar/

this is the link to the problem

basically when I try "world, say hello" as my plaintext and 12 as key it doesn't act like it should, it gives out random output for w and y. like weird question marks in place of it`

Answer 1

In testing out your code, a couple of things cropped up which probably were leading you to your issue. In both instances, the block of code in question is within your lowercase testing of the cipher text.

if(islower(text[i]))
{

text[i]=text[i]+key;

    if(text[i]>'Z')
    {
        text[i]=text[i]-26;
    }


    printf("%c",(char)text[i]);

First off, testing should be done against the lower case 'z' and not the uppercase 'Z'.

Second, ASCII characters are in the range of 0 to 127, and possibly adding a large cipher amount to the entered character can blow by the value of 127 giving you the unpredictable results you got.

With that, following is one path of refactoring for lower case encryption where the value of the derived character is checked and is adjusted down first before applying the cipher key.

if(islower(text[i]))
{
    if((text[i] + key) > 'z')   /* Since the value can go past the ASCII range, check for that first    */
    {
        text[i]=text[i] - 26;
    }
    text[i] += key;
    printf("%c",text[i]);
}

Testing this out in the terminal using a similar phrase appears to output the desired result with the proper wrap-around.

craig@Vera:~/C_Programs/Console/caes/bin/Release$ ./caes 12
Plain text: world,hello
ciphertext: iadxp,tqxxa
12

The takeaway from this is to probably research some more "C" tutorials especially in regard to using and manipulating ASCII characters.