删除Elixir列表中的最后一个元素？ [重复]

Question

这个问题在这里已有答案：

• elixir - how to get all elements except last in the list? 6个答案

你如何从这个例子的末尾删除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 Ripert给出的解决方案足够好，但并不是最快的。

Enum.reverse/1是一个贯穿reduce的通用功能。

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

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