How should I solve this cipher with pointer arithmetic? - c

Question

The question reads:
Solve the following cipher using Pointer Arithmetic. The given string is GKQTEHIN. Define a pointer and set it to the letter ‘T’ in this string. Traverse the string forward and backward. Add/subtract a single value (key) between 1 and 5 to each letter to solve this cipher and form a meaningful word. Hint: You will be using this as you solve it.
Hopefully this has been done correctly...
char given[]="GKQTEHIN";
char *pointer;
pointer=&given[3];
pointer-=3;
printf("%c", *pointer-4);
pointer+=1;
printf("%c", *pointer+4);
pointer+=1;
printf("%c", *pointer-4);
pointer+=1;
printf("%c", *pointer-4);
pointer+=1;
printf("%c", *pointer+4);
pointer+=1;
printf("%c", *pointer+4);
pointer+=1;
printf("%c", *pointer-4);
pointer+=1;
printf("%c\n\n", *pointer+4);
The word "COMPILER" is printed.

Answer 1

How do I "add/subtract a single value...to each alphabet"?
A computer only understands and works with numbers, since everything is a number (or can be considered a number) in a computer. This means letters are actually numbers internally. char in C uses ASCII encoding, which makes each letter correspond to a number. So you just add the key to the code representing that char. You can use char as a number with no problems.
char a = 'a';
a++;
printf("%c\n", a); // prints 'b'

Answer 2

To add some value to come char, use the following. You can do this for a whole string by looping over it.
int main()
{
char ch = 'a'; // or some other character
int x = 2; // or some other value
ch = (ch - 'a' + x) % 26 + 'a'; // make sure you have a value between 'a' and 'z'
printf("%c\n", ch); // prints 'c'
}

Answer 3

You need to apply two concepts here:
First, pointer is a variable that contains the address of one of the characters in given[].
If you add 1 to it, it will point to the next character. If you subtract 1 from it, it will point to the previous character.
But you need to keep it within the boundaries of the array. So pointer can never be less than &given[0] (or just given, which also evaluates to the address of the first element), and you should stop incrementing when it points to the null character (\0) at the end of the string. You can do this by creating a loop that increments pointer at each iteration, handles the boundary by resetting pointer to given when it points to the null character, and stops when it hits the T again.
Second, *pointer is the character that pointer points to.
You can change the character by adding to or subtracting from (*pointer). For example, you've initialized pointer to &given[3] (which is the same as given + 3), so it points to the letter T. So (*pointer) + 1 would be U, and (*pointer) - 2 would be R. If you want to save the new character, you can write
*pointer = (*pointer) - 2;
or just
(*pointer) -= 2;
You also need to worry about "falling off the end" of the alphabet. For example, (*pointer) + 7 would be the character after Z, but you probably want it to "wrap around" back to A. The simplest way to do this is to subtract 26 if *pointer > 'Z' (because there are 26 letters in the alphabet) or to add 26 if *pointer < 'A'. You can also use the modulus operator (%), but that's more complicated.
Putting that all together:
We know that we'll always be adding a constant value between -5 and 5.
We'll test each value by adding it to every character in the string and printing the result.
Here's an algorithm that will do that:
Create a loop with a variable, say key, that runs from -5 to 5.
Inside the loop, reset given to its initial string.
Also inside the loop, create a second loop that
initializes pointer to given + 3,
adds the value of key to the character at *pointer,
increments pointer during each iteration
wraps back to the beginning of the string when pointer hits the null character, and
stops when pointer gets back to given + 3 again.
I'll leave it to you to write the code. Feel free to update your question if you get stuck, and remember to add the code you've written!
Good luck!

Answer 4

You are basically traversing this, looking for a pattern:
-5 BFLO CDI
-4 CGMPADEJ
-3 DHNQBEFK
-2 EIORCFGL
-1 FJPSDGHM
+0 GKQTEHIN
+1 HLRUFIJO
+2 IMSVGJKP
+3 JNTWHKLQ
+4 KOUXILMR
+5 LPVYJMNS
but the instructions for traversal and key adding are clear as mud so you need to try each way (basically like a word search for an unknown word that spans the puzzle).
Forward and backward could mean all the way forward, then all the way back or forward and back simultaneously.
Adding a constant key (2, 3 or 4) would give you a row, but traversing rows forward and back from any point in a row appears to yield garbage, so that leaves the index (possibly with a constant) as a key variable, so you need to look at patterns like '//', '\', '/\', '/' backward and forward as well as from middle to end and end to middle, where the diagonal lines indicate direction.