erlang练习题(三)

题目一

查询列表A是否为列表B的前缀

解答

isPrefix([], List2) -> io:format("A is prefix of B ~n");

isPrefix([H1 | ListA], [H2 | ListB]) ->

 case H1 == H2 of

  true -> isPrefix(ListA, ListB);

  false -> io:format("A is not prefix of B ~n")

 end.
1
2
3
4
5
6
7
8
9
10
11

题目二

接受一个整数列表作为参数，返回一个新列表，其中的元素为原列表中所有出现至少两次的元素

解答

getTwice(List) ->

 getTwice(List, []).

getTwice([], Acc) -> Acc;

getTwice([Item | Rest], Acc) ->

 %% 当前元素在后面有重复出现，且在结果列表中没出现过，就加入

 case lists:member(Item, Rest) and not lists:member(Item, Acc) of

  true -> getTwice(Rest, [Item | Acc]);

  false -> getTwice(Rest, Acc)

 end.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

题目三

判断列表A是否在列表B中出现，出现则输出在B列表第几位开始（例如[3,5,7,3]在[8,3,5,3,5,7,3,9,3,5,6,3]的第4位出现

解答

find_sublist_pos(_, []) -> not_found;

find_sublist_pos(Sublist, B) ->

 find_sublist_pos(Sublist, B, 1).

 

find_sublist_pos(Sublist, RestB, Pos) when length(RestB) < length(Sublist) ->

 not_found;

find_sublist_pos(Sublist, RestB, Pos) ->

 case starts_with(Sublist, RestB) of

  true -> {found, Pos};

  false -> find_sublist_pos(Sublist, tl(RestB), Pos + 1) % tl获取列表的尾部集合（除了头元素的其他元素）

 end.

 

%% 第一个列表是否为第二列表的前缀

%% 空列表是任何列表的前缀

starts_with([], _) -> true;

starts_with(_, []) -> false;

starts_with([H1 | T1], [H2 | T2]) when H1 =:= H2 ->

 starts_with(T1, T2);

starts_with(_, _) -> false. %% 元素值不同，为false
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

题目四

在一个全部元素为{Key, Value}元组结构的元组或列表中，查找列表或元组中第一个

符合指定键的元素

例如：在[{a, 1}, {b, 2}, {c, 3}, {a, 4}] 如果查找第一个a为键的元素即输出 {a, 1}

解答

findfirstkey_a([]) -> false;


findfirstkey_a([Head | Rest]) ->

 {Key, Val} = Head,

 case Key == 'a' of

  true -> Head;

  false -> findfirstkey_a(Rest)

 end.
1
2
3
4
5
6
7
8
9
10
11
12
13
14

题目五

在一个全部元素为{Key, Value}元组结构的元组或列表中，用列表输出查找到的列表或元组中全部指定键的元素

例如：在[{a, 1}, {b, 2}, {c, 3}, {a, 4}] 如果查找全部a为键的元素即输出 [{a, 1}, {a, 4}]

解答

findkey_a(List) ->

 findkey_a(List, []).

 

findkey_a([], Acc) -> Acc;

findkey_a([Head | Rest], Acc) ->

 %io:format("Head = ~p~n Acc = ~p~n", [Head, Acc]),

 

 {Key, _} = Head,

 case Key == 'a' of

  true -> findkey_a(Rest, [Head | Acc]);

  false -> findkey_a(Rest, Acc)

 end.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

题目六

在一个全部元素为{Key, Value}元组结构的元组或列表中，删除列表或元组中第一个符合指定键的元素且输出时不改变顺序

例如：在[{a, 1}, {b, 2}, {c, 3}, {a, 4}] 如果删除第一个a为键的元素即输出 [{b, 2}, {c, 3}, {a, 4}]

解答

deletefirstkey_a(List) ->

deletefirstkey_a(List, [], false). % 第三个参数表示是否出现过了a

deletefirstkey_a([], Acc,_) -> Acc;

deletefirstkey_a([{Key, _} | Rest], Acc, false) when Key =:= a->

deletefirstkey_a(Rest, Acc, true);

deletefirstkey_a([Head | Rest], Acc, true) ->

deletefirstkey_a(Rest, [Head | Acc], true).

题目七

在一个全部元素为{Key, Value}元组结构的元组或列表中，替换列表或元组中第一个符合指定键的元素且输出时不改变顺序

例如：输入列表[{a, 1}, {b, 2}, {c, 3}, {a, 4}] 查找键为a，值替换为10

即输出[{a, 10}, {b, 2}, {c, 3}, {a, 4}] 46

解答

replacefirstkey_a(List) ->

replacefirstkey_a(List, [], 0). % 第三个参数表示是否出现过了a

replacefirstkey_a([], Acc,_) -> lists:reverse(Acc);

replacefirstkey_a([{Key, _} | Rest], Acc, 0) when Key =:= a->

replacefirstkey_a(Rest, [{Key, 10}|Acc], 1);

%% 第一次插入后，即便 Key为 a ，也不会再走上面的逻辑

replacefirstkey_a([Head | Rest], Acc, _) ->

replacefirstkey_a(Rest, [Head | Acc], 1).

题目八

生成含有指定数量元素的元组，每个元素为随机integer元素, 要求元素不能有重复的（可以使用API）

解答

gen_int(N) ->

gen_int(N, []).

gen_int(0, Acc) -> {tuple, lists:reverse(Acc)};

gen_int(N, Acc) ->

Random = rand:uniform(10000),

case lists:member(Random, Acc) of

true -> gen_int(N, Acc);

false -> gen_int(N - 1, [Random | Acc])

end.

题目九

在一个全部元素为{Key, Value}元组结构的元组或列表中，将列表中相同key的值进行合并

例如：[{a,1},{b,2},{c,3},{b,4},{b,5},{c,6},{d,7},{d,8}] 输出 [{a,1},{b,11},{c,9},{d,15}]

解答

mergekv(List) ->

mergekv(List, maps:new()).

mergekv([], AccMap) -> maps:to_list(AccMap);

mergekv([{Key, Value} | T], AccMap) ->

io:format(“{_p,p}~n”, [Key, Value]),

NewValue = case maps:is_key(Key, AccMap) of

​ true -> maps:get(Key, AccMap) + Value;

​ false -> Value

​ end,

NewAccMap = maps:put(Key, NewValue, AccMap), % 注意要用一个新的变量接受结果

mergekv(T, NewAccMap).

题目十

1、对相同类型的数据进行拼接，如：

binary：<<1,2>><<3,4>> 拼接后为 <<1,2,3,4>> 未完成

tuple：{a,b},{c} 拼接后为 {a,b,c}

list：[10],[20] 拼接后为 [10,20]

解答

%% 无法执行！！！

concat_binary(Binary1, Binary2) ->

Size1 = size(Binary1),

Size2 = size(Binary2),

NewSize = Size1 + Size2,

NewBinary = <<0:NewSize/unit:8>>,

NewBinary = binary_concat(Binary1, Binary2, NewBinary, 0, Size1),

NewBinary.

binary_concat(_, _, NewBinary, Size, Size) ->

NewBinary;

binary_concat(Binary1, Binary2, NewBinary, Index, Size1) when Index < size(Binary2) ->

Byte = binary_part(Binary2, Index, 1), % 从Binary2中从Index位置开始提取1长度的数据

UpdatedBinary = setelement(Size1 + Index + 1, NewBinary, Byte),

binary_concat(Binary1, Binary2, UpdatedBinary, Index + 1, Size1).

%% Tuple

concat_tuple(Tuple1, Tuple2) ->

concat_tuple(Tuple1, Tuple2, size(Tuple1), size(Tuple2), {}).

concat_tuple(Tuple1, Tuple2, 0, 0, AccTuple) ->

AccTuple;

%% 将Tuple1拼接到新元组中

concat_tuple(Tuple1, Tuple2, Index1, Index2, AccTuple) when Index1 > 0 ->

NewTuple = erlang:append_element(AccTuple, element(Index1, Tuple1)),

concat_tuple(Tuple1, Tuple2, Index1 - 1, Index2, NewTuple);

%% 将Tuple2拼接到新元组中

concat_tuple(Tuple1, Tuple2, 0, Index2, AccTuple) ->

NewTuple = erlang:append_element(AccTuple, element(Index2, Tuple2)),

concat_tuple(Tuple1, Tuple2, 0, Index2 -1, NewTuple).

%% 列表的拼接

concat_list(List1, List2) ->

concat_list(List1, List2, []).

concat_list([],[], Acc) -> lists:reverse(Acc);

concat_list([H | T], List2, Acc) ->

concat_list(T, List2, [H | Acc]);

concat_list([], [H | T], Acc) ->

concat_list([], T, [H | Acc]).