使用递归查找字符串中的相邻字符对

Question

I have to write a program that uses a recursive function to count the number of pairs of repeated characters in a string, and pairs of characters cannot overlap.

Say, for instance, I input the string "Hello, Sabeena". I need the output to be "2", one for the pair of ls and one for the pair of es.

This is what I have tried, but there is no output.

message = input("Enter a message:\n")
pairs = 0
k = 0

if len(message) == k:
    return("Number of pairs:",pairs)
else:
    if message[k] == message[k+1]:
        pairs = pairs + 1
        k = k+1
    else:
        k = k+1

Ideally, the program should look like this:

Enter a message:
Hello, Sabeena
Number of pairs: 2

Can anybody suggest where I'm going wrong?

Answer 1

Put the recursive code in a function (it can't really be considered recursive until it is), and return a recursive call to the function if you haven't reached your base case ( k == len(message) - 1 ), incrementing k each time.

def find_adjacent(message, pairs, k):
  if k == len(message) - 1: #subtract one to avoid getting a string index out of range error
    return("Number of pairs:", pairs)
  else:
    return find_adjacent(message, pairs+1 if message[k]==message[k+1] else pairs, k+1)


if __name__ == "__main__":
  message = "message" # change to input("Enter a message:\n")
  pairs = 0
  k = 0
  m, p = find_adjacent(message, pairs, k)
  print m, p

The above prints

Number of pairs: 1

If you fancy it a bit less compact and quite a bit more readable:

def find_adjacent(message, pairs, k):
  if k == len(message)-1:
    return("Number of pairs:", pairs)
  elif message[k] == message[k+1]:
    if k == 0:
      return find_adjacent(message, pairs+1, k+1) # first letter of message, all good
    elif message[k] != message[k-1]:
      return find_adjacent(message, pairs+1, k+1) # not first letter, and this pair hasn't been counted before
    else:
      return find_adjacent(message, pairs, k+1) # this sequence has already been counted
  else:
    return find_adjacent(message, pairs, k+1)

Answer 2

Here's a recursive function that passes a new copy of the message, each time shorter.

This is what most recursive functions do: not memory-efficient but solving the problem in simpler ways than loop-based approaches. That's not the case here of course, but this is just an exercise.

def count_adj(message, adj, c):
    """Recursively counts the number of adjacent characters"""
    if len(message) < 1:
        return adj
    else:
        if c == message[0]:
            adj += 1
        return count_adj(message[1:], adj, message[0])


tests = ("Hello, Sabeeenaa", "Hi", "h", "HH", "HHH", "", " ", "  ")

for t in tests:
    print t, ":", count_adj(t, 0, '')

Results:

Hello, Sabeeenaa : 4
Hi : 0
h : 0
HH : 1
HHH : 2
 : 0
  : 0
   : 1