Xcode gives different results every time I run C++ tests - c++

Question

I am working on a program that receives a char array. In that char array are numbers separated by spaces. The program is supposed to receive a number and add that number's palindrome to itself. If the result is not a palindrome, then we are supposed to add the result's palindrome to the result and so on until a result is a palindrome. For example, if the char array is "195", then 195 + 591 = 786. 786 is not a palindrome, so 786 + 687 = 1473. 1473 + 3741 = 5214. Finally 5214 + 4125 = 9339, which is a palindrome, so this is the answer. Then, the program should return the number of additions it ran to get the answer, followed by the answer. In this example, the program would return "4 9339".
My program works (as far as I can tell,) but for whatever reason, whenever I run Xcode, it returns different results. For example, one time I ran it everything was fine except for case 7. The next time I ran it, every single test failed. If I ran it again, every case would work except for 7 and 9. Does anybody know why this is happening? Below is all of my code, including the test cases that Xcode is running. I also tried commenting what is occurring in the program.
I would appreciate anybody's help! I am an amateur when it comes to C++, so it might be something trivial I am overlooking, or it could be something more advanced--I'm honestly not really sure. Thank you to everybody in advance!
EDIT: I have used Xcode's debugger and nothing fails or looks out of place when I do it that way, which makes it only more mysterious as to why it fails when I run the tests without debugging.
EDIT 2: Then test cases were provided by my professor, not myself.
#include <iostream>
#include <string>
using namespace std;
//returns the reverse of a number
unsigned long reverse(unsigned long n) {
unsigned long reverse = 0;
while(n != 0) {
unsigned long remainder = n%10;
reverse = reverse*10 + remainder;
n /= 10;
}
return reverse;
}
//return what the palindrome result is
string palindrome(string numberInString, int &counter) {
counter++;
//convert input, which is a string, to int
unsigned long number = std::stol(numberInString);
//reverse number and assign it to numberReversed
unsigned long numberReversed = reverse(number);
//add the number and its reverse
unsigned long result = number + numberReversed;
//reverse the result and assign it to resultReversed
unsigned long resultReversed = reverse(result);
//check to see if result and its reverse are equal; otherwise, keep going until they are
while (result != resultReversed) {
counter++;
//reassign number as result
number = result;
//reverse number and assign it to numberReversed
numberReversed = reverse(number);
//add the number and its reverse
result = number + numberReversed;
//reverse the result and assign it to resultReversed
resultReversed = reverse(result);
}
//return result
return std::to_string(result);
}
//the "main" method
char* find(const char* array) {
//instatntite counter, which will be used later
int counter = 0;
//instantiate result string, which is what we are returning
string result = "";
int i = 0;
//will be used to construct int being checked as a palindrome
string currentNumberConstruction = "";
//go through array until end of array
while (array[i] != '\0') {
//if find a space
if (array[i] == ' ') {
//call palindrome function and add it to result later on
string palindromeNumber = palindrome(currentNumberConstruction, counter);
result += std::to_string(counter);
//add to result how many cycles until palindrome found
result += " " + palindromeNumber + " ";
//reset counter (how many cycles until palindrome found)
counter = 0;
//reset currentNumberConstruction (int being checked as a palindrome)
currentNumberConstruction = "";
//continue through array
i++;
} else {
//add char checked to currentNumberConstruction (int being checked as a palindrome)
currentNumberConstruction += array[i];
//continue through array
i++;
}
}
if (currentNumberConstruction != "") {
string palindromeNumber = palindrome(currentNumberConstruction, counter);
result += std::to_string(counter);
result += " " + palindromeNumber;
counter = 0;
currentNumberConstruction = "";
i++;
}
//convert result from string to char*
char* realResult = new char[result.length()];
for (unsigned int j = 0; j < result.length(); j++) {
realResult[j] = result[j];
}
//return char* realResult
return realResult;
}
int main() {
const char* array = NULL;
const char* expected = 0;
for (int i = 0; i < 10; i++) {
switch (i) {
case 0:
array = "195 265 750";
expected = "4 9339 5 45254 3 6666";
break;
case 1:
array = "2 99 4000000000 20 100 1";
expected = "1 4 6 79497 1 4000000004 1 22 1 101 1 2";
break;
case 2:
array = "79 88 97 99";
expected = "6 44044 6 44044 6 44044 6 79497";
break;
case 3:
array = "157 158 166 167 175 188 193 197";
expected = "3 8888 3 11011 5 45254 11 88555588 4 9559 7 233332 8 233332 7 881188";
break;
case 4:
array = "266 273 274 292 365";
expected = "11 88555588 4 5115 4 9559 8 233332 11 88555588";
break;
case 5:
array = "1089 1091 1099";
expected = "4 79497 1 2992 2 11011";
break;
case 6:
array = "19991 2914560 12345678";
expected = "8 16699661 5 47977974 1 99999999";
break;
case 7:
array = "777";
expected = "4 23232";
break;
case 8:
array = "130031 9";
expected = "1 260062 2 99";
break;
case 9:
array = "1234567890123456789";
expected = "2 12222222211222222221";
break;
default:
cout << "we should never get here" << endl;
return -1;
}
char* actual = find(array);
bool equal = strcmp(expected, actual) == 0;
cout << "test " << (i + 1) << ": " << (equal ? "ok" : "failed");
if (!equal) {
cout << " expected [" << expected << "] but was [" << actual << "]";
}
cout << endl;
delete actual;
}
return EXIT_SUCCESS;
}

Answer 1

Your problem is here:
char* array = NULL;
You don't actually allocate any memory to store the array, you need to initialize this in a way that gives it some memory. Otherwise you are just picking random memory in the system and you will probably get a SegFault eventually.
This could be done like this:
char array[100];
or you could use std::string instead. This creates a character array with 100 characters to use, you can adjust the size to your need.

Answer 2

Not sure if it's the only mistake but you don't null terminate result:
char* realResult = new char[result.length()];
Should be:
char* realResult = new char[result.length()+1];
realResult [result.length()] = 0;
Otherwise the behaviour could be very random.