Implementation Working in Python But Not in C++ - c++

Question

So I made a program that takes in three strings, A, B, and C and determines whether or not C is a merge of A and B. A merge is defined as combination of the letters in A and B such that the ordering of the letters of A and B in relation to one another are preserved. So if A = "ab", B = "ba", and C = "abab", C is a valid merge of A and B since the first and last letters of C can be thought of as "from A" and the middle two from B. This combination of letters preserves their order in A and B and so C is a valid merge.
My program also capitalizes the letters in C that are "from A" meaning it outputs "AbaB".
I'm more comfortable with Python so I wrote out my implementation there first and then translated it to C++. But the really weird thing is that it works perfectly in Python but not in C++. I checked line by line and everything matches up perfectly but it's still giving the wrong output.
So for an example, for the input A == "ab", B = "ba", and C = "abab", my Python implementation correctly outputs "AbaB". But, my C++ implementation outputs "ABba".
The problem only seems to be with this part of the output. The C++ program seems to be able to correctly identify whether or not C is a valid merge of A and B.
Here's my Python program:
def findPath(array, A, B):
output = ""
M = len(A)
N = len(B)
i = M
j = N
while(j > 0):
print(i,j)
if(array[i][j-1]):
output = B[j-1] + output
j -= 1
else:
output = A[i-1].upper() + output
i -= 1
while(i > 0):
output = A[i-1].upper() + output
i -= 1
return output
def isInterleaved(A,B,C):
M = len(A)
N = len(B)
output = ""
array = [[False] * (N + 1) for i in range(M + 1)]
if(M +N != len(C)):
return False
for i in range(M+1):
for j in range(N+1):
if (i== 0 and j == 0):
array[i][j] = True
elif (i == 0):
if (B[j-1] == C[j-1]):
array[i][j] = array[i][j-1]
elif (j == 0):
if (A[i-1] == C[i-1]):
array[i][j] = array[i-1][j]
elif (A[i - 1] == C[i + j - 1] and B[j - 1] != C[i + j - 1]):
array[i][j] = array[i-1][j]
elif (A[i - 1] != C[i + j - 1] and B[j - 1] == C[i + j - 1]):
array[i][j] = array[i][j-1]
elif (A[i - 1] == C[i + j - 1] and B[j - 1] == C[i + j - 1]):
array[i][j] = (array[i - 1][j] or array[i][j - 1])
print(findPath(array, A,B))
return array[M][N]
print(isInterleaved("ab", "ba",
"abab"))
And here's my C++ program:
#include <iostream>
#include <fstream>
#include <string>
#include <vector>
using namespace std;
bool graph[1001][1001];
bool isInterleaved(string A, string B, string C)
{
int M = A.size();
int N = B.size();
if(M + N != C.size())
{
return false;
}
for (int i = 0; i < M + 1; i++)
{
for(int j = 0; j < N + 1; j++)
{
if (i == 0 and j == 0) { graph[i][j] = true; }
else if(i == 0)
{
if (B[j-1] == C[j-1])
{
graph[i][j] = graph[i][j-1];
}
}
else if(j == 0)
{
if (A[i-1] == C[i-1]) { graph[i][j] = graph[i-1][j];}
}
else if (A[i - 1] == C[i + j - 1] and B[j - 1] != C[i + j - 1])
{
graph[i][j] = graph[i-1][j];
}
else if (A[i - 1] != C[i + j - 1] and B[j - 1] == C[i + j - 1])
{
graph[i][j] = graph[i][j-1];
}
else if (A[i - 1] == C[i + j - 1] and B[j - 1] == C[i + j - 1])
{
graph[i][j] = (graph[i - 1][j] or graph[i][j - 1]);
}
}
}
return graph[M][N];
}
string findPath(string A, string B)
{
string output = "";
int M = A.size();
int N = B.size();
int i = M;
int j = N;
for(int k = 0; k < M; k++)
{
A[k] = toupper(A[k]);
}
while(j > 0)
{
if(graph[i][j-1])
{
output = B[j - 1] + output;
j -= 1;
}
else
{
output = A[i-1]+ output;
i -= 1;
}
}
cout << output << endl;
while(i > 0)
{
output = A[i-1] + output;
i -= 1;
}
return output;
}
int main()
{
string in;
string out;
cout << "Enter the name of input file: ";
cin >> in;
cout << "Enter the name of output file: ";
cin >> out;
ifstream myfile;
myfile.open(in);
ofstream outfile;
outfile.open(out);
string line;
vector<string> arguments;
int count = 0;
while(getline(myfile, line))
{
arguments.push_back(line);
count ++;
if(count == 3)
{
count = 0;
if(isInterleaved(arguments[0], arguments[1], arguments[2]))
{
outfile << findPath(arguments[0], arguments[1]) << "\n";
}
else
{
outfile << "*** NOT A MERGE ***" << "\n";
}
arguments.clear();
}
}
myfile.close();
outfile.close();
return 0;
}
For the C implementation, it takes in a list of test cases so that every block of three lines gives the parameters for a different test case. The first line gives the string A, the second, the string B, and the third, is C. It outputs the results into a text file giving the capitalized-A version of C when it's a valid merge and the string "*** NOT A MERGE ***" when it's not.
Any help with this would be greatly appreciated. I'm pretty sure it has to be something small like a method that's not giving me what I expect it to.

Answer 1

This is not really an answer, but sometimes when things don’t work it’s better to start over from an easily testable MWE. I’d suggest keeping it trivial, without file I/O clutter, focused only on the merger detection and without an arbitrary hard limit of 1000:
#include <iostream>
#include <set>
#include <string_view>
#include <tuple>
int main(int argc, const char *const *argv) {
if (argc != 4) return 3;
const std::string_view a{argv[1]}, b{argv[2]}, c{argv[3]};
const auto report{[a, b, c](bool result) {
std::cout << '\'' << c << "' is " << (result ? "" : "NOT ")
<< "a merger of '" << a << "' and '" << b << "'\n";
}};
std::set<std::tuple<size_t, size_t>> state{{0, 0}};
do {
const auto s{state.begin()};
const auto [pc, pa] = *s;
const size_t pb = pc - pa;
state.erase(s);
if (pc < c.size()) {
if (pa < a.size() && c[pc] == a[pa])
state.emplace_hint(state.end(), pc + 1, pa + 1);
if (pb < b.size() && c[pc] == b[pb])
state.emplace_hint(state.end(), pc + 1, pa);
} else if (pa == a.size() && pb == b.size()) {
report(true);
return 0;
}
} while (!state.empty());
report(false);
return 1;
}
What it does is (indeed) trivial: It records combinations of (position in merger candidate C, position in merger input A [explicit], position in merger input B [implicit]) achieved thus far. Obviously, (0, 0, 0) is a trivially satisfied starting point. Then it keeps trying to advance each already achieved position by one character. Ultimately it either reaches the ends of all of A, B and C at once, at which point C is confirmed to be a merger of A and B, or it exhausts all achieved positions recorded for future consideration, which means that one cannot merge A and B into C in any way.
(Presumably, you need to add an extra piece of data into the state if you want to also report a “merger recipe” together with a positive answer. It could also use an early check whether the string lengths add up.)
Now we can test that a bit (assuming that the binary is called merger):
#!/bin/bash
abc012=(abc012 ab0c12 ab01c2 ab012c a0bc12 a0b1c2 a0b12c a01bc2 a01b2c a012bc
0abc12 0ab1c2 0ab12c 0a1bc2 0a1b2c 0a12bc 01abc2 01ab2c 01a2bc 012abc)
acb012=(acb012 ac0b12 ac01b2 ac012b a0cb12 a0c1b2 a0c12b a01cb2 a01c2b a012cb
0acb12 0ac1b2 0ac12b 0a1cb2 0a1c2b 0a12cb 01acb2 01ac2b 01a2cb 012acb)
for m in "${abc012[#]}"; do
./merger abc 012 "$m" # …is a merger…
done
for m in "${acb012[#]}"; do
./merger abc 012 "$m" # …is NOT a merger…
done