Question

您如何简单地从本示例末尾删除20个？

[46, 238, 64, 30, 105, 136, 98, 75, 23, 157, 11, 20]

Answer 1

我所知道的@mudasobwa最快的解决方案
解决方案1 ：

x |> Enum.reverse() |> tl() |> Enum.reverse()

其他一些解决方案：
解决方案2 ：

[k] = Enum.chunk(x, length(x)-1)

解决方案3 ：

List.delete_at(x, length(x)-1)

解决方案4 ：

x |> List.to_tuple() |> Tuple.delete_at(length(x)-1) |> Tuple.to_list

一个更有趣的问题是，如何最快地做到这一点？让我们对其进行基准测试！

我使用Benchee得到了以下结果，每个解决方案被计算了50000次，并且我使用了Enum.to_list(1..10_000)创建的列表

Name                                  ips        average  deviation         median         99th %
mudasobwa's solution              14.80 K       67.57 μs    ±34.17%          79 μs          91 μs
solution 1                        14.79 K       67.59 μs    ±33.96%          79 μs          91 μs
solution 4                        10.71 K       93.38 μs    ±32.67%          81 μs         201 μs
Roman Rabinovich's solution        8.45 K      118.33 μs    ±18.27%         118 μs         171 μs
OneSneakyMofo's solution           5.07 K      197.34 μs    ±13.60%         193 μs         331 μs
dawner's solution                  4.57 K      219.00 μs    ±11.87%         216 μs      256.23 μs
solution 3                         3.41 K      292.91 μs    ±20.01%         290 μs      506.64 μs
solution 2                         0.83 K     1205.52 μs    ±22.25%        1105 μs     2061.77 μs

Comparison: 
mudasobwa's solution              14.80 K
solution 1                        14.79 K - 1.00x slower
solution 4                        10.71 K - 1.38x slower
Roman Rabinovich's solution        8.45 K - 1.75x slower
OneSneakyMofo's solution           5.07 K - 2.92x slower
dawner's solution                  4.57 K - 3.24x slower
solution 3                         3.41 K - 4.33x slower
solution 2                         0.83 K - 17.84x slower

Answer 2

您可以这样做：

List.pop_at(x, -1)
{20, [46, 238, 64, 30, 105, 136, 98, 75, 23, 157, 11]}

Answer 3

有很多方法可以做到这一点。这是另一个：

[46, 238, 64, 30, 105, 136, 98, 75, 23, 157, 11, 20]
|> Enum.reject(&(&1 == 20)

Answer 4

尽管内森·里普特（Nathan Rawrt）给出的解决方案已经足够好，但它并不是最快。

Enum.reverse/1是通过reduce传递的通用功能。

纯erlang :lists.reverse/1应该更快（非常轻微）：

x |> :lists.reverse(x) |> tl() |> :lists.reverse()

从Elixir中的列表中删除最后一个元素？

4 个答案: