Erlang “如何加速”；使用两个堆栈排队”；在二郎

这是一个常见的编程问题，我用Python、Java等语言编写的，没有问题。下面的Erlang（我正在学习）运行得非常慢（10^5次操作的用户时间约为44秒），我不知道为什么

正如在HackerRank上所写的那样，该程序从stdin中取出一行，用一个整数表示后面的操作数。每个后续行应为

1 X

（排队X）、

2

（出列并丢弃）或

3

（查看并打印队列上的下一个值）

我是否错误地使用了

列表：反向/1

-module(two_stacks).
%% API exports
-export([main/1]).

enqueue(Num, F, B) ->
    {[Num | F], B}.
dequeue(F, []) ->
    [_|B] = lists:reverse(F),
    {[], B};
dequeue(F, [_|B]) -> 
    {F, B}.

peek(F, []) ->
    [H|T] = lists:reverse(F),
    io:format(H),
    {[], [H|T]};

peek(F, [H|T]) ->
    io:format(H),
    {F, [H|T]}.

dispatchOperation(_, {F, B}) ->
    [Code|Line] = io:get_line(""),

    case Code of
        49 -> 
            [_|Num] = Line,
            enqueue(Num, F, B);
        50 -> dequeue(F, B);
        51 -> peek(F, B)
    end.


main(_) ->
    {Count, _} = string:to_integer(io:get_line("")),
    _ = lists:foldl(fun dispatchOperation/2, {[], []}, lists:seq(1, Count)),
    erlang:halt(0).

您是否正在运行一个？如果是这种情况，您应该在那里添加一个

-mode（compile）。

，否则它将以解释模式运行脚本

---

此外，您可以将时间与使用模块（使用两个堆栈实现）进行比较。

问题在于我解析输入的方式。请参阅以进行讨论

因为所有的输入都是整数，所以我可以使用这里使用的相同技术。完成的代码是：

-module(solution).
-export([main/0]).

enqueue(Num, F, B) ->
    {[Num | F], B}.
dequeue(F, []) ->
    [_|B] = lists:reverse(F),
    {[], B};
dequeue(F, [_|B]) -> 
    {F, B}.

peek(F, []) ->
    [H|T] = lists:reverse(F),
    io:format("~B~n", [H]),
    {[], [H|T]};

peek(F, [H|T]) ->
    io:format("~B~n", [H]),
    {F, [H|T]}.

run(_, {F, B}) ->
    Line = io:get_line(""),
    [X| Y] = binary:split(Line, [<<$\s>>, <<$\n>>], [global]),
    Code = binary_to_integer(X),

    case Code of
        1 -> 
            Num = binary_to_integer(lists:nth(1, Y)),
            enqueue(Num, F, B);
        2 -> dequeue(F, B);
        3 -> peek(F, B)
    end.


main() ->
    ok = io:setopts(standard_io, [binary]),
    {Count, _} = string:to_integer(io:get_line("")),
    _ = lists:foldl(fun run/2, {[], []}, lists:seq(1, Count)),
    erlang:halt(0).

-模块（解决方案）。
-导出（[main/0]）。
排队（数量、F、B）->
{[Num | F]，B}。
出列（F，[]）->
[| B]=列表：反向（F），
{[]，B}；
出列（F，[[u124; B]）->
{F，B}。
peek（F，[]）->
[H | T]=列表：反向（F），
io:格式（“~B~n”，[H]），
{[]，[H|T]}；
peek（F[H|T]）->
io:格式（“~B~n”，[H]），
{F，[H|T]}。
运行（{F，B}）->
Line=io:get_Line（“”），
[X | Y]=二进制：拆分（行，[，]，[global]），
代码=二进制整数（X），
案件代码
1 -> 
Num=二进制到整数（列表：n（1，Y）），
排队（Num，F，B）；
2->退出队列（F、B）；
3->peek（F，B）
结束。
main（）->
ok=io:setopts（标准io，[二进制]），
{Count，{}=string:to_integer（io:get_line（“”）），
_=列表：foldl（有趣的跑步/2，{[]，[]}，列表：seq（1，Count）），
erlang:halt（0）。

感谢您提供的提示，它帮助我了解了实际问题。非常有趣的是，官方队列模块还使用了两个列表！