在不使用内置函数的情况下在python中递归合并两个字符串

Question

Write a Python program, in a file called concat_strings.py , that includes the following functions:

orderedConcat , a recursive function that takes two alphabetically-ordered strings and merges them, leaving the letters in alphabetical order. Note that the strings may be different lengths.

A main method that inputs two ordered strings and calls the orderedConcat method to return a resulting merged, ordered string. Your main method should print the two input strings and the result.

Note: You may not use any of the built-in methods for string concatenation or ordering, but you may use the len() function and the slice operator (:). You may assume that the input strings are already ordered.

Sample input/output:

Enter the first ordered string: DEab
Enter the second ordered string: BFxz
First string: DEab
Second string: BFxz
Result: BDEFabxz

NOTE: I am completely new to programming and have a seriously difficult time figuring this out. Theoretically, the strings must be added together, but how do I sort them alphabetically? How do I deal with the uppercase and lowercase letters? Do I use a selection sort or merge sort? What should my base case and recursive case be? Any help would be greatly appreciated.

What I have tried so far( It's not much, but I tried whatever I could):

def orderedConcat(length):
    newString = string1 + string2
    length = len(newString)
    if length == 1 or length == "":
        return True
    elif length[0] <= length[1]:
        return orderedConcat(length[1:])
    else:
        return False

def main():
    string1 = "acdrt"
    string2 = "bdet"
    print("First string: ", string1)
    print("Second string: ", string2)
    print(newString)
main()

Answer 1

Let's go through this step by step. First off, our function takes in two strings, let's call them a and b :

def orderedConcat(a, b):

When writing recursive functions, we generally start off with the base case. In this case, there are two base cases:

1. a is empty, hence no merging is necessary and we can just return b (since b is sorted).
2. b is empty, follow the same logic as in case 1 and return a .

In code:

if len(a) == 0:
    return b
elif len(b) == 0:
    return a
else:
    # ...

Now, for the recursive case, we need to compare the first elements of both strings a[0] and b[0] . If a[0] < b[0] (Python implements < on strings for us already! Note that 'A' < 'a' ), then a[0] needs to be prepended to the output string. Otherwise, b[0] needs to be prepended.

if a[0] < b[0]:
    return a[0] + ...
else:
    return b[0] + ...

We still need to fill in the ... . When writing recursive functions, it's useful to pretend in your mind that you have already written a working function that you can make use of. In this case, think "The result of orderedConcat is the smaller of a[0] and b[0] prepended to the orderedConcat of the rest of a / b ."

Hence:

if a[0] < b[0]:
    return a[0] + orderedConcat(a[1:], b)
else:
    return b[0] + orderedConcat(a, b[1:])

Answer 2

I don't know how I'd deal with uppercase and lowercases recursively but this could be a quick work-around.

def orderedConcat(string1, string2):
    if len(string1 + string2) == 0:
        return ''
    elif (len(string1) > 0 and len(string2) == 0) or (len(string1) == 0 and len(string2) > 0):
        return string1 + string2
    else:
        if string1[0] < string2[0]:
            return string1[0] + orderedConcat(string1[1:], string2)
        elif string2[0] < string1[0]:
            return string2[0] + orderedConcat(string1, string2[1:])
        else: # if they're equal
            return string1[0] + string2[0] + \
                orderedConcat(string1[1:], string2[1:])


def main():
    string1 = "acdrt"
    string2 = "bdet"
    print("First string: ", string1)
    print("Second string: ", string2)
    print("Result : ", end=' ')
    print(orderedConcat("acdrt", "bdet"))


main()

Answer 3

Looking at your function:

def orderedConcat(length):
    newString = string1 + string2
    length = len(newString) #cut

First, you have to pass the strings into your function, not a length. So, start with the definition. And, to make this a bit simpler conceptually, let's declare a static variable, an empty string to hold the final concated, sorted result, using Python scope rules(global allows the string newString to persist and grow over multiple function calls, rather than being re-initialized on every call):

newString = ''          #outside of function
def oC(st1, st2):
    global newString    #scope modifier global

Second, the first step in any recursive problem is to identify the base case that will halt recursion so you don't recurse infinitely. Since we're dealing with strings, and will be chopping them up, the base case is going to be len-dependent. Also the strings are individually ordered, so whatever is left over (if one is longer than the other) is not a problem, we'll just slap that remainder onto our concat:

    if len(st1) == 0:
        newString += st2
        return
    elif len(st2) == 0:
        newString += st1
        return

Having sorted out the base case, the next step in any recursive problem is to shorten the problem sequentially - break it up into smaller and smaller pieces such that the base case will eventually be reached. Here we can use the slice operator to sequentially compare string elements, and to shorten strings to feed back into the function:

    elif st1[:1] <= st2[:1]:
        newString = newString + st1[:1]
        return oC(st1[1:], st2[:])  #shorten here
    else: 
        newString = newString + st2[:1]
        return oC(st1[:], st2[1:])

To call this, you have to say:

newString = ""
oC(st1, st2)

This is slightly inconvenient. See if you can figure out how to eliminate the need for the external concat string and the global in the function in this code.

Answer 4

Your example isn't doing alphabetical ordering but rather ASCIIbetical ordering. Which is fine, as it simplifies our problem. Rather than make the len() function an exception, let's not use it either:

def orderedConcat(a, b):
    if a:
        if b:
            if a[:1] < b[:1]:
                return a[:1] + orderedConcat(a[1:], b)

            return b[:1] + orderedConcat(a, b[1:])
        return a
    return b

print(orderedConcat('DEab', 'BFxz'))