Question

关于大写和小写的比较的问题。我可以在我的排序函数中做到这一点。任何想法？

Ex：输入文件：“我很开心！”

OUTPUTFILE：

Happy!
I
am

这就是我的计划会发生什么，但我希望如此：

am
I
Happy

我的代码：

-module(wp)
-compile([export_all]). % Open the File

sortFile(File1,File2) ->
    {ok, File_Read} = file:read_file(File1),
    % making a list
    Liste = string:tokens(binary_to_list(File_Read), "\n "),
    % isort List
    Sort_List = isort(Liste),
    ISort = string:join(Sort_List,"\n"),
    %Written in the File.
    {ok,Datei_Schreiben} = file:open(File2, write),
    file:write(File_Write, Isort),
    file:close(File_Write).

isort([]) -> [];
isort([X|XS])-> insert(X, isort(XS)).

insert(Elem, []) -> [Elem];
insert(Elem, [X|XS]) when Elem= [Elem,X|XS];
insert(Elem, [X|XS]) -> [X|insert(Elem,XS)].

Answer 1

这样的事情怎么样：

qsort1([]) -> [];
qsort1([H|T]) -> 
     qsort1([X || X <- T, string:to_lower(X) < string:to_lower(H)]) 
     ++ [H] 
     ++ qsort1([X || X <- T, string:to_lower(X) >= string:to_lower(H)]).


7> qsort1(["I", "am","Happy"]).
   ["am","Happy","I"]

我认为“快乐”的排序低于“我”

8> "happy" < "i".
true

这就是为什么我的排序顺序与您的原始帖子略有不同。

Answer 2

如果在排序中至少进行N*log2(N)次比较，则无需进行N*log2(N)，只需进行N个案例转换。（几乎所有的perl开发人员都知道这个技巧。）

{ok, Bin} = file:read_file(?INPUT_FILE),
Toks = string:tokens(binary_to_list(Bin),"\n "),
Result = [[X,$\n] || {_,X} <- lists:sort([{string:to_lower(X), X} || X<-Toks])],
file:write_file(?OUTPUT_FILE, Result).

BTW lists:sort/1合并排序已授予N*log2(N)，并且与简洁但效率较低的快速排序实施相反，效率非常高。更糟糕的是，快速排序有N^2最坏的情况。

Answer 3

你必须比较排序函数中的低限额：

(nitrogen@127.0.0.1)25> F= fun(X,Y) -> string:to_lower(X) < string:to_lower(Y) end.
#Fun<erl_eval.12.111823515>
(nitrogen@127.0.0.1)26> lists:sort(F,["I","am","Happy"]).                          
["am","Happy","I"]
(nitrogen@127.0.0.1)27>

编辑：

在您的代码中，允许对列表进行排序的功能是运算符＆gt;和＆lt; （如果你想看到复制的字符串，其中一个应该包含=，否则你会做一个usort）。如果您想使用不同的比较，您可以在普通或匿名函数中定义它，然后在快速排序中使用它：

mycompare(X,Y) ->
    string:to_lower(X) < string:to_lower(Y).

quicksort  ([])->[];
           ([X|XS])-> quicksort([Y||Y<-XS,mycompare(X,Y)])++[X]++quicksort([Y||Y<-XS,mycompare(X,Y) == false]).

Answer 4

现在，根据您是Windows还是Unix/Linux，文件中的行将以不同的字符结束。让我们使用通常为\r\n的窗口。现在假设输入文件不是太大，我们可以立即将它们读入二进制文件。我们得到的数据流必须分成几行，然后每行分成单词（空格）。如果输入文件很大并且无法放入内存中，那么你必须逐行读取它，在这种情况下你可能需要一个IN-Memory缓冲区来保存所有准备好排序的单词，这需要{{ 1}}，或ETS Table（我不会在这里说明一个选项）。

让我们写代码

-module(sick_sort).
-compile(export_all).
-define(INPUT_FILE,"C:/SICK_SORT/input.txt").
-define(OUTPUT_FILE_PATH,"C:/SICK_SORT/").
-define(OUTPUT_FILENAME,"output.txt").

start()->
    case file:read_file(?INPUT_FILE) of
        {ok,Binary} ->
            %% input file read
            AllLines = string:tokens(binary_to_list(Binary),"\r\n"),
            SortedText = lists:flatten([XX ++ "\r\n" || XX <- lists:sort(string:tokens(AllLines," "))]),
            EndFile = filename:join(?OUTPUT_FILE_PATH,?OUTPUT_FILENAME),
            file:write_file(EndFile,SortedText),
            ok;
        Error -> {error,Error}
    end.

这应该工作。更改源文件中的宏以适合您的设置，然后运行Memcached

Erlang大写和小写排序

4 个答案: