How to convert logic to pointer logic - c

Question

How to covert logic to pointer logic, so below i have it the way I understand to code, but I need this to be using pointer like it says in the TODO, please advise, TY :)
This is what is said in the TODO that is not helping me understand, (Hint: to avoid doing double pointer arithmatic, save a char* pointer
// to the active chunk[?] in the outer loop but before the inner loop.
// Then the inner loop is only concerned with a single array of
// characters rather than an array of strings.)
Loop over each string in the array of
// message chunks (strings) and print it. Do not print the first
// character in each string since it is only used to store the order of
// the chunks. (Hint: use pointer arithmetic to skip a character.)
////////////////////////////////////////////////////////////////////////////////
//INCLUDES
#include <stdio.h>
#include <string.h>
//macros: constants
#define CHUNK_LENGTH (20+1) //each chunk has twenty characters, we add 1 so
//there is space for the null terminator.
#define NUMBER_OF_CHUNKS 4 //the message is spread across 4 chunks.
#define DECRYPTION_SHIFT 5 //this is the ASCII table shift used for decryption.
//forward declarations
void sort_chunks();
void decrypt_chunks();
void display_chunks();
char chunks[NUMBER_OF_CHUNKS][CHUNK_LENGTH];
int main() {
//copy message into memory.
strcpy(chunks[0], "2i1%fsi%fs%jstwrtzx%");
strcpy(chunks[1], "1'H%nx%vznwp~1%kqf|j");
strcpy(chunks[2], "4R3%Wnyhmnj%%%%%%%%%");
strcpy(chunks[3], "3xzhhjxx3'%2%Ijssnx%");
//the format of a chunk is a single number indicating its order in overall
//message followed by twenty encrypted characters.
//reorder chunks in message by sorting them based on the first digital
//they contain. looking above, one can see they are currently in the order
//2, 1, 4, 3 but should be ordered 1, 2, 3, 4.
sort_chunks();
//shift the characters in the message to produce the original characters.
decrypt_chunks();
//display the decrypted message.
display_chunks();
return 0;
}
//given two strings, swaps their contents in memory.
void swap_strings(char* x, char* y) {
//create a temporary holding place for the data so we don't lose it.
char temp[CHUNK_LENGTH];
strcpy(temp, x);
strcpy(x, y);
strcpy(y, temp);
}
//sorts the strings the global chunks variable by the first character they contain.
void sort_chunks() {
//TODO: Implement sort_chunks(). Using your favorite sorting algorithm (we
// suggest selection sort), sort the array containing the message chunks.
// Sort based on the first character in the chunk - it will always be a
// number. We provide a swap_strings function that you may use. Example
// usage: swap_strings(chunks[0], chunks[1]) will swap the contents of
// the first and second string.
int i, j;
int lowest;
for (i = 0; i < NUM_OF_CHUNKS - 1; i++)
{
lowest = i;
for (j = i + 1; j < NUM_OF_CHUNKS; j++)
{
if (chunks[j][0] < chunks[lowest][0])
lowest = j;
}
swap_strings(chunks[i], chunks[lowest]);
}
}
//for each string in the global chunks variable, shifts the characters in it by
//DECRYPTION_SHIFT.
void decrypt_chunks() {
//TODO: Implement decrypt_chunks(). Loop over each string in the array
// and shift the characters in it by subtracting DECRYPTION_SHIFT value
// from them. Use pointer arithmetic to access individual characters but
// array access to the strings. Remember that C-style strings have a null
// terminator at the end. Do not apply the shift to the terminator.
// (Hint: to avoid doing double pointer arithmetic, save a char* pointer
// to the active chunk[?] in the outer loop but before the inner loop.
// Then the inner loop is only concerned with a single array of
// characters rather than an array of strings.)
int row, col;
for (row = 0; row < NUM_OF_CHUNKS; row++)
{
for (col = 0; col < CHUNK_LENGTH - 1; col++)
{
if (chunks[row][col] != '\0')
chunks[row][col] -= DECRYPTION_SHIFT;
}
}
}
//displays the strings in the global chunks variable
void display_chunks() {
//TODO: Implement display_chunks(). Loop over each string in the array of
// message chunks (strings) and print it. Do not print the first
// character in each string since it is only used to store the order of
// the chunks. (Hint: use pointer arithmetic to skip a character.)
int row, col;
for (row = 0; row < NUM_OF_CHUNKS; row++)
{
for (col = 1; col < CHUNK_LENGTH - 1; col++)
{
if (chunks[row][col] == '\0')
{
printf("\n");
return;
}
printf("%c", chunks[row][col]);
}
}
printf("\n");
}

Answer 1

Let's make this instructive. Let's use a simple preprocessor define WPOINTERS to allow your code to be compiled to use pointer or use the two loops in your original code:
//displays the strings in the global chunks variable
void display_chunks() {
//TODO: Implement display_chunks(). Loop over each string in the array of
// message chunks (strings) and print it. Do not print the first
// character in each string since it is only used to store the order of
// the chunks. (Hint: use pointer arithmetic to skip a character.)
int row;
for (row = 0; row < NUMBER_OF_CHUNKS; row++)
{
#ifdef WPOINTERS
char *p = chunks[row];
printf ("%s", p + 1);
#else
int col;
for (col = 1; col < CHUNK_LENGTH - 1; col++)
{
if (chunks[row][col] == '\0')
{
putchar ('\n');
return;
}
putchar (chunks[row][col]);
}
#endif
}
putchar ('\n');
}
If you specify -DWPOINTERS on the command line during compile, the following code is executed:
#ifdef WPOINTERS
char *p = chunks[row];
printf ("%s", p + 1);
otherwise, your original code is executed:
#else
int col;
for (col = 1; col < CHUNK_LENGTH - 1; col++)
{
if (chunks[row][col] == '\0')
{
putchar ('\n');
return;
}
putchar (chunks[row][col]);
}
In both cases you obtain:
$ ./bin/prnwptrsnew
"C is quirky, flawed, and an enormous success." - Dennis M. Ritchie
Example compile strings would be:
$ gcc -Wall -Wextra -pedantic -std=gnu11 -Ofast -DWPOINTERS -o bin/prnwptrsnew prnwptrs.c
or for your original code, just omit -DWPOINTERS:
$ gcc -Wall -Wextra -pedantic -std=gnu11 -Ofast -o bin/prnwptrsnew prnwptrs.c
If you are using cl.exe, the with/without -DWPOINTERS works the same.