Erlang - 元素和列表

发布于 2024-12-12 04:14:06 字数 590 浏览 0 评论 0原文

我是二郎新手。我想知道如何编写一个返回列表中前 N 个元素的函数？

我试过了：

    take([],_) -> [];
    take([H|T],N) when N > 0 -> take([H,hd(L)|tl(T)], N-1);
    take([H|T],N) when N == 0 -> ... (I'm stuck here...)

有什么提示吗？谢谢

更新：我知道有一个名为“sublist”的函数，但我需要弄清楚如何自己编写该函数。

我终于找到答案了：

-module(list).
-export([take/2]).

take(List,N) -> take(List,N,[]).
take([],_,[]) -> [];
take([],_,List) -> List;
take([H|T], N, List) when N > 0 -> take(T, N-1, lists:append(List,[H]));
take([H|T], N, List) when N == 0 -> List.

原文

I'm new to erlang. I wonder how to write a function which returns the first N elements in a list?

I've tried:

    take([],_) -> [];
    take([H|T],N) when N > 0 -> take([H,hd(L)|tl(T)], N-1);
    take([H|T],N) when N == 0 -> ... (I'm stuck here...)

Any hint? thx

Update: I know there's a function called "sublist" but I need to figure out how to write that function by my own.

I finally figured out the answer:

-module(list).
-export([take/2]).

take(List,N) -> take(List,N,[]).
take([],_,[]) -> [];
take([],_,List) -> List;
take([H|T], N, List) when N > 0 -> take(T, N-1, lists:append(List,[H]));
take([H|T], N, List) when N == 0 -> List.

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

她比我温柔 2024-12-19 04:14:06

在 Erlang 中，take 拼写为 lists:sublist：

L = [1, 2, 3, 4];
lists:sublist(L, 3).   % -> [1, 2, 3]

In Erlang, take is spelled lists:sublist:

L = [1, 2, 3, 4];
lists:sublist(L, 3).   % -> [1, 2, 3]

回复收藏 0 原文

羅雙樹 2024-12-19 04:14:06

一个简单的解决方案是：

take([H|T], N) when N > 0 ->
    [H|take(T, N-1)];
take(_, 0) -> [].

如果列表中没有足够的元素，这将生成错误。

当您像现在这样使用累加器时，通常不会将元素附加到其末尾，因为这是非常低效的（每次都会复制整个列表）。通常，您可以使用 [H|List] 将元素推入其中。然后它将按相反的顺序，但您随后执行 lists:reverse(List) 以按正确的顺序返回它们。

take(List, N) -> take(List, N, []).

take([H|T], N, Acc) when N > 0 ->
    take(T, N-1, [H|Acc]);
take(_, 0, Acc) -> lists:reverse(Acc).

累加器版本是尾递归，这是一件好事，但您需要进行额外的反向操作，这会消除一些好处。我认为第一个版本更清晰。两者都没有明确的案例。

A simple solution is:

take([H|T], N) when N > 0 ->
    [H|take(T, N-1)];
take(_, 0) -> [].

This will generate an error if there are not enough elements in the list.

When you use an accumulator as you are doing you do not usually append elements to the end of it as this is very inefficient (you copy the whole list each time). You would normally push elements on to it with [H|List]. It will then be in the reverse order but you then do a lists:reverse(List) to return them in the right order.

take(List, N) -> take(List, N, []).

take([H|T], N, Acc) when N > 0 ->
    take(T, N-1, [H|Acc]);
take(_, 0, Acc) -> lists:reverse(Acc).

The accumulator version is tail recursive which is a Good Thing but you need to do an extra reverse which removes some of the benefits. The first version I think is clearer. There is no clear case for either.

回复收藏 0 原文

~没有更多了~