Recursive function to replace integer in arthmetic expression - recursion

Question

I need to write recursive function Repl
takes as input an expression in e in Expr and returns an expression in Expr
wherein each number is replaced by the number 1.
For example, if e is the expression
((((9 + 5) ∗ 2) ∗ (2 + (4 ∗ 6))))
then Repl(e) is the expression
((((1 + 1) ∗ 1) ∗ (1 + (1 ∗ 1))))
Can anybody help me how to go about this?
Iterative one is easy to write but how to write it recursively?

Answer 1

It is not clear why you would want a recursive solution for this problem, but the solution is relatively straightforward. Here is pseudocode:
string replace(string s, bool seenDigit) {
if (s == "") {
// The string is empty : we are done
return "";
}
if (s[0] is digit) {
if (seenDigit) {
// This is a second, third, etc. digit in a multi-digit chain
// It has been replaced with "1" already, so we cut it out
return replace(s.substring(1), true);
} else {
// This is the first digit in a chain of one or more digits
// Replace it with "1", and tell the next level that we've
// done the replacement already
return "1"+replace(s.substring(1), true);
}
} else {
// Non-digits do not get replaced
return s[0] + replace(s.substring(1), false);
}
}
s[0] means the first character; string+string denotes concatenation.

Answer 2

Making #dasblinkenlight's solution tail recursive:
string replace(string sToGo, string sSoFar, bool inNumber) {
if (sToGo == "") {
return sSoFar;
}
if (sToGo[0] is digit) {
if (isNumber) {
return replace(sSoFar, sToGo.substring(1), true);
} else {
return replace(sSoFar+"1", sToGo.substring(1), true);
}
} else {
return replace(sSoFar+s[0], sToGo.substring(1), false);
}
}
Notice that every return is either a direct value (the base case) or directly returns what a recursive call gives back. This means the program doesn't need to keep track of the recursive calls, because there's nothing to do with the value being returned other than returning it up the chain, which means (if the interpreter takes advantage of it) that the primary downside to using recursion (the overhead of the stack) can be eliminated.