Question

我应该编写一个递归函数，它接受一个字符串列表或一个字符串列表列表，如果找到则返回没有元音的列表。这是我尝试解决它：

def noVow(seq):
    keys = ['a','i','e','o','u','u']
    if not seq or not isinstance(seq, list) :
        return 
    else:
        if seq[0]  in keys:
            del seq[0]
            return (noVow(seq[0:]))
        else:
            return (noVow(seq[1:]))


li = ["b", "c", "d","a"]
print (noVow(li))

我知道这个错误存在于我的基本情况中，但我无法提出正确的基础案例。

请注意，递归函数必须用纯函数编程编写，即不允许副作用。

Answer 1

返回相同列表，不带元音

呃，你在递归调用中切片原始列表，所以你有一个 copy 不是同一个列表。

更重要的是，您的代码确实有效，但由于您传递了列表的 slice ，因此切片中的元音项目（而不是原始列表）将被删除，原始文件将保持不变。

您可以改为使用非切片变体，该变体从原始列表的 start 移动到 end 索引：

 public static final boolean isBetweenValidTime(Date startTime, Date endTime, Date validateTime)
 {
        boolean validTimeFlag = false;

        if(endTime.compareTo(startTime) <= 0)
        {
            if(validateTime.compareTo(endTime) < 0 || validateTime.compareTo(startTime) >= 0)
            {
                 validTimeFlag = true;
            }
        }
        else if(validateTime.compareTo(endTime) < 0 && validateTime.compareTo(startTime) >= 0)
        {
             validTimeFlag = true;  
        }

        return validTimeFlag;
 }

最后，如果您要打印结果，则不应打印函数调用的输出（将为def no_vow(seq, index=0): keys = ['a','i','e','o','u'] if not seq or not isinstance(seq, list) or index >= len(seq): return else: if seq[index] in keys: del seq[index] return no_vow(seq, index) else: return no_vow(seq, index+1)），而是列表。

<强>试验：

None

Answer 2

def no_vowel(seq):
    if not isinstance(seq, list):
        raise ValueError('Expected list, got {}'.format(type(seq)))
    if not seq:
        return []
    head, *tail = seq
    if isinstance(head, list):
        return [[no_vowel(head)]] + no_vowel(tail)
    else:
        if head in 'aeiou':
            return no_vowel(tail)
        else:
            return [head] + novowel(tail)

列表的酷解包是Python 3功能，与功能编程模式匹配非常相似。

Answer 3

您的基本案例返回None。因此，无论何时传递空列表，都会向递送调用堆栈发送无。

此外，你不存储不是元音的字符，所以你的其他情况是错误的。

你能拥有的是这样的东西：

>>> def noVow(seq):
...     keys = ['a','i','e','o','u','u']
...     if not seq or not isinstance(seq, list) :
...         return []
...     else:
...         if seq[0] in keys:
...             return noVow(seq[1:])
...         else:
...             return [seq[0]] + noVow(seq[1:])

同样seq[0:]相当于seq。

Answer 4

要处理包含字符串和平面字符串列表的列表列表，您需要迭代序列，然后检查类型：

def noVow(seq):
    vowels = {'a', 'i', 'e', 'o', 'u', 'u'}
    for ele in seq:
        if isinstance(ele, list):
            # a list so recursively process
            yield [s for s in noVow(ele)]
        # else it has to be a string so just see if it is not a vowel
        elif ele not in vowels:
            yield ele

你可以像使用它一样：

In [39]: li
Out[39]: [['b', 'c'], ['d', 'a']]

In [40]: li[:] = noVow(li)

In [41]: print(li)
[['b', 'c'], ['d']]

In [42]: li = ["a","b","c","e"]

In [43]: li[:] = noVow(li)

In [44]: print(li)
['b', 'c']
In [10]: li = [["b", "c"], ["d", ["a"]]]
In [11]: li[:] = noVow(li)   
In [12]: li
Out[12]: [['b', 'c'], ['d', []]] # works for nested lists

如果你想要一个所有非元音的平面列表，你可以使用python3，你可以使用 yield ：

def noVow(seq):
    vowels = {'a', 'i', 'e', 'o', 'u', 'u'}
    for ele in seq:
        if isinstance(seq, list):
            yield from noVow(ele)
        elif ele not in vowels:
            yield ele

你以同样的方式使用它：

In [2]: li = [["b", "c"], ["d", "a"]]

In [3]: li[:] = noVow(li)

In [4]: li
Out[4]: ['b', 'c', 'd']

In [5]: li = ["a","b","c","e"]

In [6]: li[:] = noVow(li)

In [7]: li
Out[7]: ['b', 'c']

你可以用python2做同样的事情，你只需要另一个循环

Answer 5

我相信这个解决方案正确地实现了两个标准＆＃34;一个字符串列表或一个字符串列表列表＆＃34;和＆＃34;返回相同的列表＆＃34;没有任何外部协助：

def noVowels(sequence, index=0):
    if not (sequence and type(sequence) is list and index < len(sequence)):
        return 

    vowels = {'a','i','e','o','u'}

    if type(sequence[index]) is list:
        noVowels(sequence[index])
    elif sequence[index] in vowels:
        del sequence[index]
        index -= 1

    noVowels(sequence, index + 1)

    return sequence

<强> TEST

array = [['a', 'b', 'c', 'd', 'e'], 'f', 'g', 'h', 'i', ['l', 'm', ['n', 'o', 'p'], 'q'], 'r', 's', 't', 'u']

print(array)
print(id(array))
print(id(array[0]))

result = noVowels(array)

print(result)
print(id(result))
print(id(result[0]))

<强> RESULT

> python3 test.py
[['a', 'b', 'c', 'd', 'e'], 'f', 'g', 'h', 'i', ['l', 'm', ['n', 'o', 'p'], 'q'], 'r', 's', 't', 'u']
4315447624
4315344520
[['b', 'c', 'd'], 'f', 'g', 'h', ['l', 'm', ['n', 'p'], 'q'], 'r', 's', 't']
4315447624
4315344520
>

请注意，相同的列表和内部列表会根据其ID不变而保持不变。它处理列表列表。

我不相信它的功能性程序，因为它起副作用，但这种矛盾是OP问题描述中固有的。

如何编写一个递归函数，它接受一个列表并返回不带元音的相同列表？

5 个答案: