Recursive solution to finding patterns - algorithm

Question

I was solving a problem on recursion which is to count the total number of consecutive 8's in a number. For example:
input: 8801 output: 2
input: 801 output: 0
input: 888 output: 3
input: 88088018 output:4
I am unable to figure out the logic of passing the information to the next recursive call about whether the previous digit was an 8.
I do not want the code but I need help with the logic. For an iterative solution, I could have used a flag variable, but in recursion how do I do the work which flag variable does in an iterative solution. Also, it is not a part of any assignment. This just came to my mind because I am trying to practice coding using recursion.

Answer 1

A typical solution to this would be to add a new parameter to your function to pass along the "flag" state. This parameter is usually called an accumulator. If you're using a language that allows for nested functions, you often want to define an outer function that takes the actual parameters, then an inner, recursive function with an accumulator as a parameter. There's an example in Scheme here.

Answer 2

you can scan through your number digit by digit with this function
int totalConsecutive8(int digit, boolean last)
while boolean last indicate whether the last digit (which mean digit - 1) is 8 or not.
For example, in the last example 88088018, starting at digit 0, boolean last is false -> digit 1, as the last digit is 8, so last is true ...
Code in Java
public int numberOfConsecutive8(int val){
String number = "" + val;
return totalConsecutive8(number, 0, false, false);
}
public int totalConsecutive8(String number, int digit, boolean last, boolean first){
if(digit == number.length()){
return 0;
}
int result = 0;
if(number.charAt(digit) == '8'){
if(last){
if(first){
result += 2 + totalConsecutive8(number, digit + 1, true, false);
}else{
result += 1 + totalConsecutive8(number, digit + 1, true, false);
}
}else{
result += totalConsecutive8(number, digit + 1, true, true);
}
}else{
result += totalConsecutive8(number, digit + 1, false, false);
}
return result;
}
Barmar suggested approach:
int totalConsecutive8(int number, boolean last , boolean first){
if(number == 0){
return 0;
}
int result = 0;
if(number % 10 == 8){
if(last){
if(first){
result += 2 + totalConsecutive8(number/10, true , false){
}else{
result += 1 + totalConsecutive8(number/10, true , false){
}
} else{
result += totalConsecutive8(number/10, true , true){
}
}else{
result += totalConsecutive8(number/10, false , false){
}
return result;
}

Answer 3

here pseudo code for the above problem :-
int max = 0;
void cal_eight(char ch[],int i,int count) {
if(ch[i]=='\0') {
max = maximum(max,count);
}
else if(ch[i]=='8') {
cal_eight(ch,i+1,count+1);
}
else {
max = maximum(max,count);
cal_eight(ch,i+1,0);
}
}
call :- cal_eight(ch,0,0)

Answer 4

As you are focusing on recursion I'd mention that one of its specifics and benefits that there is no need at all to pass any additional parameter or count calls.
You perform call of your function from inside of its own with modified argument - say the string minus one digit which you check in your function - and then call it again until the string becomes empty.
May be multiple times - nested calls.
[UPDATE]
Below is the example in Python, verbose fore more readability.
We call our function with string, current chain of consecutive 8s which is flushed if the 1st char of current string is not '8' (which, and already known total cosecutive 8s
def f8_trace(s, chainlen=0, total=0, indent=0):
print ' '*indent, "invoked with s='%s', chainlen=%d, total=%d" % (s,chainlen, total)
if len(s) == 0:
if chainlen>1:
total += chainlen
retval = total
else:
if s[0] == '8':
chainlen += 1
else:
if chainlen>1:
total += chainlen
chainlen = 0
retval = f8_trace(s[1:],chainlen,total,indent+1)
print ' '*indent, 'returns %d' % (retval)
return retval
s = 'abc888d88e8f888'
print f8_trace( s )
Output:
invoked with s='abc888d88e8f888', chainlen=0, total=0
invoked with s='bc888d88e8f888', chainlen=0, total=0
invoked with s='c888d88e8f888', chainlen=0, total=0
invoked with s='888d88e8f888', chainlen=0, total=0
invoked with s='88d88e8f888', chainlen=1, total=0
invoked with s='8d88e8f888', chainlen=2, total=0
invoked with s='d88e8f888', chainlen=3, total=0
invoked with s='88e8f888', chainlen=0, total=3
invoked with s='8e8f888', chainlen=1, total=3
invoked with s='e8f888', chainlen=2, total=3
invoked with s='8f888', chainlen=0, total=5
invoked with s='f888', chainlen=1, total=5
invoked with s='888', chainlen=0, total=5
invoked with s='88', chainlen=1, total=5
invoked with s='8', chainlen=2, total=5
invoked with s='', chainlen=3, total=5
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
returns 8
8

Answer 5

Here's an example in Haskell, a language often associated with recursive approaches.
xxs stands for the string, x and xs loosely mean, "first item" and "the rest" (so after we check x, we pass xs, the rest of the string, to the next function call).
previous set as True means the previous digit was an 8. I hope the rest of the code may seem more straight forward and self-explanatory. The guards, |, are like imperative "if" clauses (e.g., if previous then ...).
f xxs first8 previous count
| null xxs = count
| previous = if x == 8
then f xs 0 True (count + first8 + 1)
else g
| otherwise = if x == 8
then f xs 1 True count
else g
where x:xs = xxs
g = f xs 0 False count
Output:
*Main> f [8,0,1] 0 False 0
0
*Main> f [8,8,8] 0 False 0
3
*Main> f [8,8,0,8,8,0,1,8] 0 False 0
4