在不使用內置函數的情況下在python中遞歸合並兩個字符串

Question

在名為concat_strings.py的文件中編寫 Python 程序，其中包含以下函數：

orderedConcat ，一個遞歸函數，它接受兩個按字母順序排列的字符串並合並它們，讓字母按字母順序排列。 請注意，字符串的長度可能不同。

輸入兩個有序字符串並調用orderedConcat方法以返回結果合並的有序字符串的主要方法。 您的主要方法應該打印兩個輸入字符串和結果。

注意：您不能使用任何內置方法進行字符串連接或排序，但可以使用len()函數和切片運算符 (:)。 您可以假設輸入字符串已經排序。

示例輸入/輸出：

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

注意：我對編程完全陌生，並且很難弄清楚這一點。 理論上，字符串必須加在一起，但我如何按字母順序對它們進行排序？ 如何處理大寫和小寫字母？ 我使用選擇排序還是歸並排序？ 我的基本情況和遞歸情況應該是什么？ 任何幫助將不勝感激。

到目前為止我嘗試過的東西（不多，但我盡我所能）：

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

讓我們一步一步來。 首先，我們的函數接受兩個字符串，我們稱它們為a和b ：

def orderedConcat(a, b):

在編寫遞歸函數時，我們通常從基本情況開始。 在這種情況下，有兩種基本情況：

1. a是空的，因此不需要合並，我們可以只返回b （因為b已排序）。
2. b為空，遵循與案例 1 相同的邏輯並返回a 。

在代碼中：

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

現在，對於遞歸情況，我們需要比較字符串a[0]和b[0]的第一個元素。 如果a[0] < b[0] （Python 已經為我們在字符串上實現了< ！注意'A' < 'a' ），那么a[0]需要被添加到輸出字符串之前。 否則，需要預先添加b[0] 。

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

我們仍然需要填寫... . 在編寫遞歸函數時，在腦海中假裝已經編寫了一個可以使用的工作函數是很有用的。 在這種情況下，請考慮“ orderedConcat的結果是a[0]和b[0]較小的a[0] ， orderedConcat到a / b其余部分的orderedConcat之前。

因此：

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

Answer 2

我不知道如何遞歸處理大寫和小寫，但這可能是一個快速的解決方法。

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

看看你的功能：

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

首先，您必須將字符串傳遞到您的函數中，而不是長度。 所以，從定義開始。 而且，為了在概念上更簡單一些，讓我們聲明一個靜態變量，一個空字符串來保存最終的連接，排序結果，使用 Python 范圍規則（全局允許字符串newString在多個函數調用中持久化和增長，而不是被在每次調用時重新初始化）：

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

其次，任何遞歸問題的第一步是確定將停止遞歸的基本情況，這樣您就不會無限遞歸。 由於我們正在處理字符串，並且會將它們切碎，因此基本情況將取決於 len。 此外，字符串是單獨排序的，所以剩下的任何東西（如果一個比另一個長）都不是問題，我們只需將剩余的部分放在我們的 concat 上：

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

整理出基本情況后，任何遞歸問題的下一步都是按順序縮短問題 - 將其分解成越來越小的部分，以便最終達到基本情況。 這里我們可以使用切片操作符順序比較字符串元素，並縮短字符串以反饋給函數：

    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:])

要調用它，您必須說：

newString = ""
oC(st1, st2)

這有點不方便。 看看您是否可以弄清楚如何消除此代碼中函數中的外部 concat 字符串和 global 的需要。

Answer 4

您的示例不是按字母順序排序，而是按ASCIIbetical排序。 這很好，因為它簡化了我們的問題。 與其讓len()函數成為例外，我們也不要使用它：

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'))