Recursion 滤波器最大值N

是否可以在FFL中写入一个版本的

filter

，该版本在第一次负匹配后停止过滤，即剩余项目被假定为正匹配？更一般地说，是一个过滤器

示例：

removeMaxOf1([1,2,3,4], value>=2)

预期结果：

removeMaxOf1([1,2,3,4], value>=2)

[1,3,4]

这似乎很难用纯粹的功能性风格来写。也许递归或

let

可以实现它

---

注意：这个问题的全部动机是关于微观优化的假设。因此，性能是非常相关的。我也在寻找一般适用于任何数据类型的东西，而不仅仅是

int

当然递归可以！：D

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        flatten([
                                l[0],
                                recurse(l[1:], f)
                        ])
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

这种风格失去了一些强大的类型安全性，但更接近尾部递归：

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        flatten(filterMaxOf1i(l, f))
where filterMaxOf1i = def
        ([int] l, function f) -> [any]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        [
                                l[0],
                                recurse(l[1:], f)
                        ]
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

def filterMaxOf1(list ls, function(list)->bool pred, list result=[]) ->list
base ls = []: result
base not pred(ls[0]): result + ls[1:]
recursive: filterMaxOf1(ls[1:], pred, result + [ls[0]])

filterMaxOf1（输入，目标）
其中filterMaxOf1=def
（[int]l，函数f）->[int]
展平（滤波器maxof1i（l，f））
其中filterMaxOf1i=def
（[int]l，函数f）->[any]
如果（尺寸（l）=0，
[],
如果（不是f（l[0]），
l[1:]，
[
l[0]，
递归（l[1:]，f）
]
)
)
其中输入=[
1, 2, 3, 4, ]
其中target=def
（int i）->bool
i<2

递归当然可以D

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        flatten([
                                l[0],
                                recurse(l[1:], f)
                        ])
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

这种风格失去了一些强大的类型安全性，但更接近尾部递归：

filterMaxOf1(input, target)
where filterMaxOf1 = def
        ([int] l, function f) -> [int]
        flatten(filterMaxOf1i(l, f))
where filterMaxOf1i = def
        ([int] l, function f) -> [any]
        if(size(l) = 0,
                [],
                if(not f(l[0]),
                        l[1:],
                        [
                                l[0],
                                recurse(l[1:], f)
                        ]
                )
        )
where input = [
        1, 2, 3, 4, ]
where target = def
        (int i) -> bool
        i < 2

def filterMaxOf1(list ls, function(list)->bool pred, list result=[]) ->list
base ls = []: result
base not pred(ls[0]): result + ls[1:]
recursive: filterMaxOf1(ls[1:], pred, result + [ls[0]])

filterMaxOf1（输入，目标）
其中filterMaxOf1=def
（[int]l，函数f）->[int]
展平（滤波器maxof1i（l，f））
其中filterMaxOf1i=def
（[int]l，函数f）->[any]
如果（尺寸（l）=0，
[],
如果（不是f（l[0]），
l[1:]，
[
l[0]，
递归（l[1:]，f）
]
)
)
其中输入=[
1, 2, 3, 4, ]
其中target=def
（int i）->bool
i<2

我最近在引擎中添加了

find_index

，这样可以轻松完成：

if(n = -1, [], list[:n] + list[n+1:])
where n = find_index(list, value<2)
where list = [1,2,3,4]

---

我最近在引擎中添加了

find_index

，可以轻松完成以下操作：

if(n = -1, [], list[:n] + list[n+1:])
where n = find_index(list, value<2)
where list = [1,2,3,4]

---

我问错了。对于该条件，应显示

值<2

。也许我应该将其命名为RemoveMaxO1，因为条件值>1我进一步编辑了-只需添加一个位置合适的

not

就可以开始处理一个或另一个问题。我注意到展平会进行深度展平，因此该算法不会普遍适用，例如，如果我的数据值是列表。我在问题中犯了一个错误。对于该条件，应显示

值<2

。也许我应该把它叫做removeMaxOf1，因为条件值>1我进一步编辑了-只需添加一个位置合适的

not

就可以开始处理一个或另一个问题。我注意到展平会进行深度展平，所以这个算法不会普遍适用，例如，如果我的数据值是列表。递归不会删除纯函数。递归并没有删除纯函数。还是真的？酷！但是它不应该是

list[：n]+list[n+1://code>而不是
list[n://code>？我对你的答案做了修改。很有启发性！但是对于
base not pred（ls[0]）：result+ls
不应该是
base not pred（ls[0]）：result+ls[1://code>？我对你的答案做了修改。这很好。请有人评论调试控制台友好版？酷！但是它不应该是
list[：n]+list[n+1://code>而不是
list[n://code>？我对你的答案做了修改。很有启发性！但是对于
base not pred（ls[0]）：result+ls
不应该是
base not pred（ls[0]）：result+ls[1://code>？我对你的答案做了修改。这很好。请有人评论调试控制台友好的版本？