erlang练习题

-module(three).
-export([]).

%% 1、将列表中的integer,float,atom转成字符串并合并成一个字个字符串：[1,a,4.9,“sdfds”] 结果：“1a4.9sdfds”
one([])->[];
one([H|T])->
if is_list(H)->H++one(T);
true->lists:flatten(io_lib:format("~p", [H]))++one(T)
end.

%% 2、得到列表或无组中的指定位的元素 {a,g,c,e} 第1位a [a,g,c,e] 第1位a（尝试不使用APIerlang lists API实现）
two(L,X)->if is_list(L)->two(L,X,1);
true->two(tuple_to_list(L),X,1)
end.
two([],,)->[];
two([H|T],X,Y) ->
if X=:=Y ->H;
true->two(T,X,Y+1)
end.

%% 3、根据偶数奇数过淲列表或元组中的元素（尝试不使用API实现）
three(L)-> if is_list(L)->three(L,[]);
true->three(tuple_to_list(L),[])
end.

three([],A)->A;
three([H|T],A)-> %过滤偶数
if H rem 2=:=1 ->three(T,[H|A]);
true->three(T,A)
end.

%% 4、便用匿名函数对列表奇数或偶数过淲
four(L)->
lists:filter(fun(X)->X rem 2 =:=1 end,L). % 过滤偶数

%% 5、计算数字列表[1,2,3,4,5,6,7,8,9]索引N到M的和
five(M,N)->five([1,2,3,4,5,6,7,8,9],M,N,1,0).
five([],,,_,R)->R;
five([H|T],M,N,X,R)->
if X>=M,X=<N ->
five(T,M,N,X+1,H+R);
true->five(T,M,N,X+1,R)
end.

%% 6、查询List1是为List2的前缀（尝试不使用string API实现）
six([],[|])->true;
six([|],[])->false;
six([X1|T1],[X2|T2])->if X1=:=X2 ->six(T1,T2);
true->false
end.

%% 7、逆转列表或元组（尝试不使用lists API实现）
seven(L)->if is_list(L)->seven(L,[],0);
true->seven(tuple_to_list(L),[],1)
end.
seven([],L1,0)->L1;
seven([],L1,1)->list_to_tuple(L1);
seven([H|T],L1,Flag)->seven(T,[H|L1],Flag).

%% 8、对列表进行排序
qsort([])->[];
qsort([A|T])->qsort([X || X<-T,X<A]) % 快速排序
++[A]++
qsort([X || X<-T,X>=A]).

%% 9、对数字列表进行求和再除以指定的参数，得到商余
sum([],_)->io:format(“NO Number!”);
sum(L,X)->sum(L,X,0).
sum([],X,S)->{{sum,S},{shang,S div X},{yu,S rem X}};
sum([H|T],X,S)->sum(T,X,S+H).

%% 10、获得当前的堆栈

getHoop()->try exit(xp) catch % 使用exit抛出异常。捕获后打印堆栈
exit:xp->erlang:get_stacktrace()
end.

%% 11、获得列表或元组中的最大最小值（尝试不使用API实现）

min_max(L)->if is_list(L)->min_max(qsort(L),seven(qsort(L))); %先使第8题的快速排序，列表第一位是最小值。列表用第七题的反转之后，第一位是最大值。
is_tuple(L)->min_max(qsort(tuple_to_list(L)),seven(qsort(tuple_to_list(L))));
true->io:format(“bad ag”)
end.
min_max([H|T],[H1|T1])->{{min,H},{max,H1}}.

%% 12、查找元素在元组或列表中的位置

where(L,X)->if is_list(L)->where(L,X,1);
true->where(tuple_to_list(L),X,1)
end.
where([],_,Y)->io:format(“bad parameter!”);
where([H|T],X,Y) ->
if X=:=H ->Y;
true->where(T,X,Y+1)
end.

%% 13 无

%% 14、判断A列表（[3,5,7,3]）是否在B列表（[8,3,5,3,5,7,3,9,3,5,6,3]）中出现，出现则输出在B列表第几位开始

is_persent(L1,L2)->is_persent(L1,L2,1,erlang:length(L1)). % 通过每次从L2截取L1长度的列表和L1比较，L2从1依次往后截取

is_persent(,,X,Len) when X>Len ->false;
is_persent(L1,L2,X,Len)->
case is_equal(L1,lists:sublist(L2,X,Len)) of
true->X;
false->is_persent(L1,L2,X+1,Len)
end.

is_equal([],[])->true; % 比较两个列表是否相等
is_equal([H1|T1],[H2|T2])->
if H1=:=H2 ->
is_equal(T1,T2);
true->false
end.

%% 15、{8,5,2,9,6,4,3,7,1} 将此元组中的奇数进行求和后除3的商（得值A），并将偶数求和后剩3（得值B），然后求A+B结果
asumb(T)->
lists:sum([X||X<-T,X rem 2=:=1])/3+lists:sum([X||X<-T,X rem 2=:=0])*3.

%% 16、在shell中将unicode码显示为中文
format(S)->io:format(“test:_tsn”,[S]).

%% 17、传入列表L1=[K|]、L2=[V|]、L3=[{K,V}|_]，L1和L2一一对应，L1为键列表，L2为值列表，L3存在重复键，把L3对应键的值加到L2
updateL2(L1,L3)->lists:map(fun(X)->list_to_tuple(proplists:append_values(X,L3)) end,L1). %通过map把L1中的key作为proplists:append_values(X,L3)的参数，把L3中key相同的值追加。map返回的列表就是新的L2

%% 18、删除或查询元组中第N个位置的值等于Key的tuple（尝试不使用lists API实现）

search(T,Key)->search(tuple_to_list(T),Key,1). %查找
search([],,)->false;
search([H|T],Key,X)->if H=:=Key ->X;
true->search(T,Key,X+1)
end.

delete({},)->false; %删除
delete(T,Key)->delete(tuple_to_list(T),Key,[]).
delete([],,_)->false;
delete([H|T],Key,L)->if H=:=Key ->seven(L++T);
true->delete(T,Key,[H|L])
end.

%% 19、对一个字符串按指定符字劈分（尝试不使用string API实现）
cut(S,X)->cut(S,X,[],[]).
cut([],,L,)->lists:reverse(L);
cut([H|T],X,L,Temp)-> case H=:=$X of
true->cut(T,X,L++Temp,[]);
false->cut(T,X,L,[H|Temp])
end.

cut1(S,X)->string:tokens(S,X).

%% 20、合并多个列表或元组
my_merge(L)->my_merge(L,[]).
my_merge([],L)->L;
my_merge([H|T],L)->if is_tuple(H)->my_merge(T,L++tuple_to_list(H));
is_list(H)->my_merge(T,L++H);
true->my_merge(T,L++[H])
end.

%% 21、{5,1,8,7,3,9,2,6,4} 将偶数剩以它在此元组中的偶数位数，比如，8所在此元组中的偶数位数为1，2所在此元组中的偶数位数为2
ou(X)->ou(tuple_to_list(X),[],0).
ou([],L,N)->list_to_tuple(lists:reverse(L));
ou([H|T],L,N)->if(H rem 2 ==0)->ou(T,[H*(N+1)|L],N+1);
true->ou(T,[H|L],N)
end.

%% 22、排序[{“a”,5},{“b”,1},{“c”,8},{“d”,7},{“e”,3},{“f”,9},{“g”,2},{“h”,6},{“i”,4}], 以元组的值进行降序优先用API
tsort(L)->lists:reverse(lists:keysort(2, L)).

%% 23、{8,5,2,9,6,4,3,7,1} 将此元组中的奇数进行求和
jssum(T)->lists:sum([X||X<-tuple_to_list(T),X rem 2==1]).

%% 24、传入任意I1、I2、D、Tuple四个参数，检查元组Tuple在索引I1、I2位置的值V1、V2,如果V1等于V2则删除V1，把D插入V2前面，返回新元组,
%%如果V1不等于V2则把V2替换为V1，返回新元组
%%注意不能报异常，不能用try，不满足条件的，返回字符串提示

dos(I1,I2,D,Tuple)->
dos(I1,I2,D,tuple_to_list(Tuple),lists:sublist(tuple_to_list(Tuple),I1-1),lists:sublist(tuple_to_list(Tuple),I1+1,I2-1),lists:sublist(tuple_to_list(Tuple),I2,erlang:length(tuple_to_list(Tuple)))).
dos(I1,I2,D,T,L1,L2,L3)->case two(T,I1)=:=two(T,I2) of
true->L1++L2++[D|L3];
false->lists:sublist(T,I1)++L2++[two(T,I1)|lists:sublist(T,I2+1,erlang:length(T))]
end.

%% 25 : 删除列表或元组中全部符合指定键的元素
deleteSome(T,X)->
if is_list(T)->
proplists:delete(X,T);
true->
list_to_tuple(proplists:delete(X,tuple_to_list(T)))
end.

%% 26 ：替换列表或元组中第一个符合指定键的元素
replace(T,Key,Replace)->
if is_tuple(T)->
list_to_tuple(lists:keyreplace(Key,1,tuple_to_list(T),Replace));
true->
lists:keyreplace(Key,1,T,Replace)
end.

%% 27 : 将指定的元素插入到列表中指定的位置，列表中后面的元素依次向后挪动
insert(X,N,L)->
lists:sublist(L,N-1)++[X|lists:sublist(L,N,erlang:length(L)-N+1)].

%% 28：对[6,4,5,7,1,8,2,3,9]进行排序（降序–冒泡排序）或API排序
mp(L) when is_list(L) ->
lists:reverse(lists:sort(L)).

%% 29、将字符串"goods,143:6|money:15|rmb:100|money:100|goods,142:5"解析成[{money,115},{rmb,100},{goods,[{143,6},{142,5}]}]可以代码写定KEY进行匹配归类处理
jx(S)->jx1(string:tokens(S,"|")). % 思路：先用|分割字符串，再用，分割字符串。再用map将刚刚得到的列表元素进行判定，（将[K,v]列表转为元组，方便调api追加值）如果是goods就将value用:再分割将得到的value列表转为整数，K转为原子。
jx1(L)->proplists:append_values(goods,lists:map(
fun({X,Y})->case X=:=“goods” of
true->{list_to_atom(X),list_to_tuple(lists:map(fun(M)->list_to_integer(M),string:tokens(Y,"😊))};
false->{list_to_atom(X),list_to_integer(Y)}
end
end,
lists:map(fun(X)->list_to_tuple(string:tokens(X,",")) end,L))).

%% 30 : 移除元组或列表中指定位置的元素
remove(T,N)->if is_tuple(T)->erlang:delete_element(N,T);
true->tuple_to_list(erlang:delete_element(N,list_to_tuple(T)))
end.

%% 31 ：指定列表第几位之后的数据进行反转。如：指定[2,3,5,6,7,2]第3位后进行反转（尝试不使用API(lists:concat,lists:reverse等)、++、–方法）
xreverse(L,N)->xreverse(L,N,[],1).
xreverse([H|T],N,L1,X)->
if N==X->
doreverse([H|L1])++doreverse(T);
true->
xreverse(T,N,[H|L1],X+1)
end.
doreverse(L)->doreverse(L,[]). % 反转
doreverse([],L1)->L1;
doreverse([H|T],L1)->doreverse(T,[H|L1]).

%% 32、使用“匿名函数”检查列表的每个元素是否符合传入的最大最小值（都是闭区间）
check(L,Max,Min)->lists:map(fun(X)->X==Min end,L).

%% 33、获得列表或元组的最大最小值
max(T)->case is_list(T) of
true->lists:max(T);
false->lists:max(tuple_to_list(T))
end.
min(T)->case is_list(T) of
true->lists:min(T);
false->lists:min(tuple_to_list(T))
end.

%% 34、成生指定数量元组，每个元素为随机integer元素, 元素不能有相同的
produce(N)->produce(N,[],rand:uniform(10)).
produce(0,L,_)->list_to_tuple(L);
produce(N,L,X) ->
case lists:member(X,L) of
false->produce(N-1,[X|L],rand:uniform(10));
true->produce(N,L,rand:uniform(10))
end.

%% 35、对一个int进行位移操作，取出0到16位的数据，16到32位的数据，输出这两个数

%% 36、输入A(元子列表)，B(数值列表)两个相同长度的参数进行随机匹配(要求字母为Key,数值为Value),支持指定的Key和Value在一组
random_merge(L1,L2,M,N)->random_merge(lists:delete(M,L1),lists:delete(N,L2),[{M,N}],erlang:length(L2)-1,rand:uniform(erlang:length(L2)-1)). % 该模式支持指定key——value为一组
random_merge(L1,L2)->random_merge(L1,L2,[],erlang:length(L2),rand:uniform(erlang:length(L2))).
random_merge([H1|T1],[H2|T2],L3,1,_)->[{H1,H2}|L3];
random_merge([H|T],L2,L3,Len,X) when Len>1->random_merge(T,tuple_to_list(erlang:delete_element(X,list_to_tuple(L2))),[{H,lists:nth(X,L2)}|L3],Len-1,rand:uniform(Len-1)).
% 参数：[H|T]->列表一，L2->列表二，L3->结果列表, Len->列表二长度（判断长度为1时结束递归），X->随机位置

%% 37、对相同类型的数据进行拼接，如binary(<<1,2>><<3,4>> =<<1,2,3,4>>) tuple({a,b},{c} ={a,b,c}) list([10],[20] =[10,20])

list_compile(M,[])->lists:reverse(M); %列表
list_compile(M,[H|T])->list_compile([H|lists:reverse(M)],T).

tuple_compile(L,[])->list_to_tuple(L); %元组
tuple_compile(M,N)->tuple_compile2(tuple_to_list(M),tuple_to_list(N)).
tuple_compile2(M,[])->list_to_tuple(lists:reverse(M));
tuple_compile2(M,[H|T])->tuple_compile2([H|lists:reverse(M)],T).

%% 38、将列表中相同key的值进行合并，[{a,1},{b,2},{c,3},{b,4},{b,5},{c,6},{d,7},{d,8}]
appendvalues(L)->appendvalues(proplists:get_keys(L),L,[]). % 获取列表中所有的key，以便递归
appendvalues([],_,L3)->L3;
appendvalues([H|T],L2,L3)->appendvalues(T,L2,[H,list_to_tuple(proplists:append_values(H,L2))|L3]). % 递归每一个key，使用proplists:append_values将相同key的值追加