Syntax 帮我改进这个Erlang？

所以我对Erlang很感兴趣。我找不到借口用它来做任何大事，但我会时不时地用它来解决玩具问题

现在，我正在实现一个罗马数字翻译器。我现在只是在做“to”部分，我发现代码重复得太多了。它就像一个符咒，但是，好吧，看看它：

-module(roman).
-compile([export_all]).

toRoman(N) ->
    toRoman(N, []).

toRoman(0,Acc) ->
    lists:reverse(lists:flatten(Acc));

toRoman(N, Acc) when N >= 1000 ->
    toRoman(N-1000,["M"|Acc]);

toRoman(N,Acc) when N >= 900 ->
    toRoman(N-900,["CM" | Acc]);

toRoman(N,Acc) when N >= 500 ->
    toRoman(N-500,["D" | Acc]);

toRoman(N,Acc) when N >= 400 ->
    toRoman(N-400, ["CD" | Acc]);

toRoman(N,Acc) when N >= 100 ->
    toRoman(N-100, ["C" | Acc]);

toRoman(N,Acc) when N >= 90 ->
    toRoman(N-90, ["XC" | Acc]);

toRoman(N,Acc) when N >= 50 ->
    toRoman(N-50, ["L" | Acc]);

toRoman(N, Acc) when N >= 40 ->
    toRoman(N-40, ["XL" | Acc]);

toRoman(N, Acc) when N >= 10 ->
    toRoman(N-10, ["X" | Acc]);

toRoman(N, Acc) when N >= 9 ->
    toRoman(N-9, ["IX" | Acc]);

toRoman(N, Acc) when N >= 5 ->
    toRoman(N-5, ["V" | Acc]);

toRoman(N, Acc) when N >= 4 ->
    toRoman(N-4, ["IV" | Acc]);

toRoman(N, Acc) ->
    toRoman(N-1, ["I" | Acc]).

test() ->
    Test = fun(X) -> io:format("~p -> ~p~n", [X, toRoman(X)]) end,
    lists:map(Test, [0,1,3,6,23,43,75,87,13,23, 3999, 3998, 2531, 140]).

---

我觉得有一个更好的方法。有人能提供一些见解吗？

实际上，您的代码没有那么重复。它看起来就是这样，因为文本形成了一个重复的模式。但是您的每个子句都处理一个特定的情况，它们之间的逻辑重叠很少。您可以在switch语句中重新实现，但会得到类似的重复。罗马数字翻译的例子太多了，我认为你无法避免重复做出每一个决定的感觉。

使用查找表在任何语言中都应该使它更短更快

这不是重复，因为“逻辑”无论如何都必须实现。您可以做的一件事是使其非尾部递归，因为您不会有超过20-30个递归

-module(roman).
-compile([export_all]).

to_roman(N) when N >= 1000 -> "M"  ++ to_roman(N-1000);
to_roman(N) when N >=  900 -> "CM" ++ to_roman(N- 900);
...
to_roman(N) when N >=    4 -> "IV" ++ to_roman(N-   4);
to_roman(N) when N >=    1 -> "I"  ++ to_roman(N-   1);
to_roman(_) -> [].

通过定义宏，可以进一步保存一些字符。我确实讨厌宏，但你可能会喜欢它们：）

---

如果你不想重复，你可以从我的作品中得到启发

用erlang编写代码不是一种很好的推荐方法。宏是坏的。如果可以，避免它。调试很困难，它引入了热代码交换无法跟踪的模块间依赖关系，等等。如果您喜欢功能性更强的方法“代码就是数据，数据就是代码”，请看以下示例：

-module(roman).

-compile([export_all]).

toRoman(N) when is_integer(N), N >= 0 ->
    toRoman(N,
        [{1000, "M"}, {900, "CM"}, {500, "D"}, {400, "CD"},
         {100, "C"}, {90, "XC"}, {50, "L"}, {40, "XL"},
         {10, "X"}, {9, "IX"}, {5, "V"}, {4, "IV"}, {1, "I"}]).

toRoman(0, _) -> [];
toRoman(N, [{X, V} | _] = S) when N >= X ->
    [V | toRoman(N - X, S)];
toRoman(N, [_ | S]) -> toRoman(N, S).

test() ->
    F = fun (X) -> lists:flatten(toRoman(X)) end,
    "" = F(0),
    "I" = F(1),
    "III" = F(3),
    "VI" = F(6),
    "XXIII" = F(23),
    "XLIII" = F(43),
    "LXXV" = F(75),
    "LXXXVII" = F(87),
    "XIII" = F(13),
    "XXIII" = F(23),
    "MMMCMXCIX" = F(3999),
    "MMMCMXCVIII" = F(3998),
    "MMDXXXI" = F(2531),
    "CXL" = F(140),
    ok.

出于好奇，您的代码在字节码中比我的快5%，在本机中慢5%。它在Intel（R）Core（TM）2 Duo CPU T7500@2.20GHz上以1.2us字节码和370ns本机执行一次转换

编辑：我并没有使用尾部递归版本，因为递归的深度非常小。所以我很好奇是否有任何表现上的损失或从中获益。我无法用字节码衡量我的算法中的任何内容，即使是原生的，但有趣的事情发生在原始代码中。如果我以直接的方式编写原始算法（不针对尾部调用进行优化），它比我在本机代码中的速度快40%左右（一次转换大约需要250ns）。字节码之间没有可测量的差异。这是一个有趣的例子，尾部调用优化不值得做

toRoman(N) when N >= 1000 -> "M" ++ toRoman(N - 1000);
toRoman(N) when N >= 900 -> "CM" ++ toRoman(N - 900);
toRoman(N) when N >= 500 -> "D" ++ toRoman(N - 500);
toRoman(N) when N >= 400 -> "CD" ++ toRoman(N - 400);
toRoman(N) when N >= 100 -> "C" ++ toRoman(N - 100);
toRoman(N) when N >= 90 -> "XC" ++ toRoman(N - 90);
toRoman(N) when N >= 50 -> "L" ++ toRoman(N - 50);
toRoman(N) when N >= 40 -> "XL" ++ toRoman(N - 40);
toRoman(N) when N >= 10 -> "X" ++ toRoman(N - 10);
toRoman(N) when N >= 9 -> "IX" ++ toRoman(N - 9);
toRoman(N) when N >= 5 -> "V" ++ toRoman(N - 5);
toRoman(N) when N >= 4 -> "IV" ++ toRoman(N - 4);
toRoman(N) when N >= 1 -> "I" ++ toRoman(N - 1);
toRoman(0) -> [].

p.S.：对于Erlang代码，扁平化列表不是常见的行为。上述示例中的返回结构被称为

io_list

，通常在erlang io系统中被接受。您可以直接将其发送到套接字、端口等。例如，如果您想编写它，可以使用

io:put\u chars（IOList）

或

io:format（“Result:'~s'~n'，[IOList]）

EDIT2：如果有常量列表作为

++

运算符的左操作数，erlang编译器将为您优化列表串联，因此

[“string”| L]

对于速度来说不是必需的。结果代码更具可读性，结果更平坦，而不会造成性能损失。个人而言，如果我对性能感兴趣，我会使用这个版本，它有点重复，但是我所知道的最快的版本，在字节码中以310ns的速度执行一次转换，在本机中以210ns的速度执行一次转换

toRoman(N) when N >= 1000 -> "M" ++ toRoman(N - 1000);
toRoman(N) -> toRomanC(N div 100, N rem 100).

toRomanC(0, N) -> toRomanX(N);
toRomanC(1, N) -> "C" ++ toRomanX(N);
toRomanC(2, N) -> "CC" ++ toRomanX(N);
toRomanC(3, N) -> "CCC" ++ toRomanX(N);
toRomanC(4, N) -> "CD" ++ toRomanX(N);
toRomanC(5, N) -> "D" ++ toRomanX(N);
toRomanC(6, N) -> "DC" ++ toRomanX(N);
toRomanC(7, N) -> "DCC" ++ toRomanX(N);
toRomanC(8, N) -> "DCCC" ++ toRomanX(N);
toRomanC(9, N) -> "CM" ++ toRomanX(N).

toRomanX(N) -> toRomanX(N div 10, N rem 10).

toRomanX(0, N) -> toRomanI(N);
toRomanX(1, N) -> "X" ++ toRomanI(N);
toRomanX(2, N) -> "XX" ++ toRomanI(N);
toRomanX(3, N) -> "XXX" ++ toRomanI(N);
toRomanX(4, N) -> "XL" ++ toRomanI(N);
toRomanX(5, N) -> "L" ++ toRomanI(N);
toRomanX(6, N) -> "LX" ++ toRomanI(N);
toRomanX(7, N) -> "LXX" ++ toRomanI(N);
toRomanX(8, N) -> "LXXX" ++ toRomanI(N);
toRomanX(9, N) -> "XC" ++ toRomanI(N).

toRomanI(0) -> [];
toRomanI(1) -> "I";
toRomanI(2) -> "II";
toRomanI(3) -> "III";
toRomanI(4) -> "IV";
toRomanI(5) -> "V";
toRomanI(6) -> "VI";
toRomanI(7) -> "VII";
toRomanI(8) -> "VIII";
toRomanI(9) -> "IX".

---

重复部分是累加和函数调用。把它们搬到一个地方，事情就会好得多

%%% Roman numerals ruleset
r(N) when N >= 1000 -> {N-1000, "M"};
r(N) when N >= 900 -> {N-900, "CM"};
r(N) when N >= 500 -> {N-500, "D"};
r(N) when N >= 400 -> {N-400, "CD"};
r(N) when N >= 100 -> {N-100, "C"};
r(N) when N >= 90 -> {N-90, "XC"};
r(N) when N >= 50 -> {N-50, "L"};
r(N) when N >= 40 -> {N-40, "XL"};
r(N) when N >= 10 -> {N-10, "X"};
r(N) when N >= 9 -> {N-9, "IX"};
r(N) when N >= 5 -> {N-5, "V"};
r(N) when N >= 4 -> {N-4, "IV"};
r(N) when N > 0 -> {N-1, "I"}.

roman(N, Acc) ->
  case r(N) of
    {0, R} ->
      [R | Acc];
    {N2, R} ->
      roman(N2, [R | Acc])
  end.

roman(N) ->
  list_to_binary(lists:reverse(roman(N, ""))).

顺便说一句，4和6的结果相同：

8> [roman:toRoman(N) || N <- lists:seq(1,10)].   
["I","II","III","VI","V","VI","VII","VIII","XI","X"]

---

8>[roman:toRoman（N）| | N这个过程有三个部分，一个规则列表，其中哪些符号代表哪些数字，搜索这些规则以找到下一个符号，以及一个将数字减少到零的迭代。每个部分都有一个函数，我们有：

ruleset() -> [
    {1000, "M"},
    {900, "CM"},
    {500, "D"},
    {400, "CD"},
    {100, "C"},
    {90, "XC"},
    {50, "L"},
    {40, "XL"},
    {10, "X"},
    {9, "IX"},
    {5, "V"},
    {4, "IV"},
    {1, "I"}].

find_next(N) -> find_next(ruleset(), N).

find_next([{V, Symbol}|_], N) when N >= V -> {N - V, Symbol};
find_next([_|T], N) -> find_next(T, N).

roman(N, Acc) ->
    case find_next(N) of
          {0, R}  -> [R | Acc];
          {N2, R} -> roman(N2, [R | Acc])
    end.

roman(N) ->
    lists:append(lists:reverse(roman(N, ""))).

您可能可以使用lists:foldl/3进一步简化它。
如果您支持罗马数字的所有变体，例如
但基本上，您的代码仍然是一系列大小写/模式匹配头…
我之前已经添加了这一个，在这里重新发布。
我发现这个解决方案相当优雅

-module(roman).
-export([to_roman/1]).

to_roman(0) -> [];
to_roman(X) when X >= 1000 -> "M" ++ to_roman(X-1000);
to_roman(X) when X >= 100 -> digit(X div 100, $C,$D,$M) ++ to_roman(X rem 100);
to_roman(X) when X >= 10 -> digit(X div 10, $X,$L,$C) ++ to_roman(X rem 10);
to_roman(X) when X >= 1 -> digit(X, $I,$V,$X).

digit(1,X,_,_) -> [X];
digit(2,X,_,_) -> [X,X];
digit(3,X,_,_) -> [X,X,X];
digit(4,X,Y,_) -> [X,Y];
digit(5,_,Y,_) -> [Y];
digit(6,X,Y,_) -> [Y,X];
digit(7,X,Y,_) -> [Y,X,X];
digit(8,X,Y,_) -> [Y,X,X,X];
digit(9,X,_,Z) -> [X,Z].

老实说，在任何编程语言中，你都不会比你拥有的更好。对你的代码的一些评论：1）你的代码是错误的。当你建立一个颠倒的列表时，你的字符也应该颠倒，例如添加“VI”而不是“IV”对于4.2）来说，不必构建深度列表然后进行展平，您可以在一个步骤中连接。例如，如果您将list:reverse（list:flatten（Acc））更改为list:flatten（list:reverse（Acc）），则可以使用“IX”++Acc代替[“IX”+”Acc然后你就可以修复这个错误，而不必反转所有两个字符的数字。啊！是的，现场串联可能更明智，可以修复交换的两个字符的数字。这不是一对一的映射。他实际上必须比较大于或等于。这在查找表中要困难得多。我认为不会在这种情况下，ld绝对是优势。除非他为所有可能的数字生成一个包含4000个条目的查找表：）你确定吗？我不确定。你能给我们展示一下这个例子的基准测试结果吗？Doh。我当然可以将减法部分移出我的规则集，只返回应该减法的数字。然后我就可以重新计算urned常量。我当然支持我的选择，使用函数来表示规则，而不是使用查找表。：）我想不会，而且为了可读性和可维护性，在我编写生产罗马数字翻译代码的不太可能的情况下，我可能会这样做。（当然，修复了已经指出的错误。）哇，这个解决方案看起来很熟悉…：）很好，字节码的速度非常快（我的是2倍），与本机的直接方法相当（大约慢15%）。你甚至可以通过将尾部作为额外的
ruleset() -> [
    {1000, "M"},
    {900, "CM"},
    {500, "D"},
    {400, "CD"},
    {100, "C"},
    {90, "XC"},
    {50, "L"},
    {40, "XL"},
    {10, "X"},
    {9, "IX"},
    {5, "V"},
    {4, "IV"},
    {1, "I"}].

find_next(N) -> find_next(ruleset(), N).

find_next([{V, Symbol}|_], N) when N >= V -> {N - V, Symbol};
find_next([_|T], N) -> find_next(T, N).

roman(N, Acc) ->
    case find_next(N) of
          {0, R}  -> [R | Acc];
          {N2, R} -> roman(N2, [R | Acc])
    end.

roman(N) ->
    lists:append(lists:reverse(roman(N, ""))).

-module(roman).
-export([to_roman/1]).

to_roman(0) -> [];
to_roman(X) when X >= 1000 -> "M" ++ to_roman(X-1000);
to_roman(X) when X >= 100 -> digit(X div 100, $C,$D,$M) ++ to_roman(X rem 100);
to_roman(X) when X >= 10 -> digit(X div 10, $X,$L,$C) ++ to_roman(X rem 10);
to_roman(X) when X >= 1 -> digit(X, $I,$V,$X).

digit(1,X,_,_) -> [X];
digit(2,X,_,_) -> [X,X];
digit(3,X,_,_) -> [X,X,X];
digit(4,X,Y,_) -> [X,Y];
digit(5,_,Y,_) -> [Y];
digit(6,X,Y,_) -> [Y,X];
digit(7,X,Y,_) -> [Y,X,X];
digit(8,X,Y,_) -> [Y,X,X,X];
digit(9,X,_,Z) -> [X,Z].