Thread: When is a pointer a pointer but not a pointer but then a pointer

well how on earth am i supposed to add numbers like 15946249379839316505 and 50561393897394264951 accurately the result is too big for a unsigned long long and too many digits for a double to be accurate (more than 17)

atoi takes a string, i.e., a character array that has a '\0' in it to indicate the end of the active string data. You are trying to pass it single characters (but as a pointer, which actually indicates the beginning of a string). To just be a single character, the character right after the character you are trying to pass must be '\0'. Perhaps the best way to do this is:

Code:

char tmp[2] = {0};
tmp[0] = Numx[i];
int x = atoi(tmp);
tmp[0] = Numy[i];
int y = atoi(tmp);

However, there is no reason to use atoi here. We usually just do this:

Code:

int x = Numx[i] - '0';
int y = Numy[i] - '0';

And instead of

Code:

        sprintf( &Result[i], "%d", Answer );

just do this

Code:

        Result[i] = Answer + '0';

So it might be written something like this:

Code:

void AddStrings( char *Numx, char *Numy, char *Result )
{
    //it is assumed that numx and numy have the same number of digits
    for ( int Answer = 0, i = strlen( Numx ) - 1; i >= 0; i-- )
    {
        int x = Numx[i] - '0';
        int y = Numy[i] - '0';
        Answer += x + y;
        Result[i] = Answer % 10 + '0';
        Answer /= 10;
    }
}

But note that this will not be able to add, e.g., 999 + 399 = 1398 since you are writing the answer characters to the same position in result so the initial 1 in the answer would need to go 1 before the beginning of result.
It's also obviously a problem that the input numbers need to have the same number of digits.

To do this kind of thing it's easier to put the numbers into the strings "backwards" so that way things line up better. You just need to write input and output routines to reverse the strings.

to solve the input and carry issues i was going to write a function that prepends the relevant number to the string ie 312 + 4321 becomes 0312 + 4321

The final object of the problem was to take numbers 1 through 9999 and reverse each number and add them together and see if they are palindromic or can be made to be by taking the result and reversing that up to 50 times

i was trying this and when i tested 9999 as a maximum after 32 iterations it got to the above number hence i was side tracked onto this

They will be re-initialised (filled with zeros) each time around the loop.

Aside from the initialisation cost, there is nothing else really to worry about.
You're not going to be using up huge amounts of memory just by doing it.

The initialization costs are entirely self-imposed as there is no need to initialize them at all (as long as the functions ReverseString and AddStrings are properly written to zero terminate the strings they make, which at the moment they aren't).

It doesn't make much sense that the AddStrings function doesn't do all the work of adding the strings but offloads the task of prepending the final carry. It's easy enough to put it in the AddStrings function.

I also happened to notice that there is some non-standard whitespace in the code, e.g., non-breaking spaces (UTF-8 C2 A0).
Also, aaaaaaaaaaaaaaaaaaaaaaaaaaa?

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void prependDigit( char *str, unsigned digit )
{
    memmove(str + 1, str, strlen(str) + 1); // strlen + 1 to include '\0'
    *str = digit % 10 + '0'; // % 10 to ensure single digit
}
 
// Assumes numx and numy have the same number of digits.
void addStrings( const char *numx, const char *numy, char *result )
{
    int answer = 0, i = strlen( numx );
 
    result[i] = '\0'; // 0-terminate result string 
 
    while ( i-- > 0 )
    {
        answer += (numx[i] - '0') + (numy[i] - '0');
        result[i] = answer % 10 + '0';
        answer /= 10;
    }
 
    if ( answer )
        prependDigit( result, answer );
}
 
void reverseString( const char *source, char *result )
{
    result += strlen( source );
    *result = '\0'; // properly 0-terminate string
    while ( *source )
        *--result = *source++;
}
 
int isPalindrome( const char *str )
{
    for ( const char *end = str + strlen(str) - 1; str < end; )
        if ( *end-- != *str++ ) return 0;
    return 1;
}
 
int main()
{
    int lychrelNum = 0;
 
    for ( int n = 1; n < 10000; ++n )
    {
        char num[64], result[64], reversed[64];
 
        sprintf( num, "%d", n );
        reverseString( num, reversed );
        addStrings( num, reversed, result );
 
        int i = 1;
        for ( ; !isPalindrome( result ) && i < 50; ++i )
        {
            strcpy( num, result );
            reverseString( num, reversed );
            addStrings( num, reversed, result );
        }
 
        if ( i == 50 ) ++lychrelNum;
    }
 
    printf( "%d\n", lychrelNum );
 
    return 0;
}

i have just realised on my code in function prependstring i have a string of a's being passed to strlen rather than the variable name. this must of happened when i was cutting and pasting using control a to select all i will correct that now. Not sure what you mean by the non standard white space though .

it wont let me edit the code sorry

You have to be careful when you have --, ++ and * all in the same expression.
You have to be really careful when using them right next to each other (not separated by the variable).

They occupy the same level in the precedence table.
C Operator Precedence - cppreference.com

Code:

$ cat foo.c
#include <stdio.h>

int main(void) {
    char test[] = "02468";
    char *p = test;
    
    char c1 = *p++;
    printf("C=%c, p now points to %c\n", c1, *p);
    
    char c2 = ++*p;  // this changes the data, not the pointer
    printf("C=%c, p now points to %c\n", c2, *p);

    char c3 = *++p;
    printf("C=%c, p now points to %c\n", c3, *p);
    
    printf("test=%s\n", test);
    return 0;
}
$ gcc -g -Wall foo.c
$ ./a.out 
C=0, p now points to 2
C=3, p now points to 3
C=4, p now points to 4
test=03468

and then you or someone else does exactly what i tried and it works

Obviously you did not try "exactly" what I did.

but surly *end-- would decrement the value end is pointing to not the address

Why so surly (bad-tempered) ?
It decrements end, not *end, due to precedence rules.

strlen(strprepend) + 1 isn't needed or isn't out of bounds.

strlen(str) + 1 is the location of the '\0'.
I wanted to move it along with the rest of the string data.

i assume that doing what i have done would mess up the other variable.

As long as the underlying char array is large enough there is no problem.
In modern code we would always pass the total size of the underlying char array to a function to ensure we don't overrun it.

The thing that is wrong with your version of PrependString (besides it misleading name since it is prepending a digit character, not a general string) is that it does not properly zero-terminate the string. It would be more correct to start i at strlen(str), not strlen(str)-1, so that the '\0' is also moved.

I feel you are confused about the difference between a string and a char array.
A char array is the underlying data structure within which a string is held.
A string is a sequence of non-zero bytes followed by a zero byte, indicating the end of the "active" data in the string.

Code:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
void prependDigit(char *str, size_t size, int x) {
    size_t len = strlen(str);
    if (len + 2 > size) {
        fprintf(stderr, "prependDigit: string overflow\n");
        exit(EXIT_FAILURE);
    }
    for (size_t i = len; i-- > 0; ) str[i + 1] = str[i];
    str[0] = x % 10 + '0';
}
 
int main() {
    char num[32] = "12345"; // if size was only 6 it would overflow
    prependDigit(num, sizeof num, 0);
    printf("%s\n", num);
    return 0;
}

Note that since size_t is unsigned you cannot say:

Code:

    for (size_t i = len; i >= 0; --i)

i will always be >= 0 and will simply wrap-around to its highest value if it is decremented when it is 0.