3rd section of the 2nd week of the Functional Programming in Erlang from the University of Kent

joining.erl

-module(joining).
-export([join/2, concat/1]).

reverse([X|Xs]) -> reverse(Xs, [X]);
reverse([]) -> [].
reverse([X|Xs], ACC) -> reverse(Xs, [X | ACC]);
reverse([], ACC) -> ACC.

shunt([],Ys) ->
    Ys;
shunt([X|Xs],Ys) ->
    shunt(Xs,[X|Ys]).

join(A, B) ->
    shunt(reverse(A), B).

shunt([],Ys) ->
    Ys;
shunt([X|Xs],Ys) ->
    shunt(Xs,[X|Ys]).

concat(L) ->
    concat(L, []).
concat([X|Xs], ACC) ->
    concat(Xs, join(ACC, X));
concat([], ACC) ->
    ACC.

membership.erl

-module(membership).
-export([member/2]).

member(X, [X|_Xs]) ->
    true;
member(X, [_Y|Xs]) ->
    member(X, Xs);
member(_X, []) ->
    false.

permutations.erl

-module(permutations).
-export([perm/1]).

% Attempt of implementing Heap's algorithm: https://en.wikipedia.org/wiki/Heap%27s_algorithm

perms([]) -> [];
perms(A) ->
    permutations(length(A), A).

permutations(1, A) -> [A];
permutations(K, A) ->
    permutations(K-1, A) ++ permutations(K, A, 1).
permutations(K, A, K) ->
    L = perms_swap(A, K, K),
    permutations(K-1, L);
permutations(K, A, I) ->
    L = perms_swap(A, I, K),
    permutations(K, L, I+1) ++ permutations(K-1, L).

perms_swap(A, _I, K) when K rem 2 == 0 ->
    swap(A, 1, K);
perms_swap(A, I, K) ->
    swap(A, I, K).

swap(L, _I, _I) -> L;
swap(L, I, J) ->
    Min = min(I, J),
    Max = max(I, J),

    {First, [_|Rest]} = lists:split(Min-1, L),
    {Second, [_|Third]} = lists:split(Max-Min-1, Rest),

    First ++ [lists:nth(Max, L)|Second] ++ [lists:nth(Min, L)|Third].

sorting.erl

-module(sorting).
-export([mergeSort/1,quickSort/1,insertionSort/1]).

reverse([X|Xs]) -> reverse(Xs, [X]);
reverse([]) -> [].
reverse([X|Xs], ACC) -> reverse(Xs, [X | ACC]);
reverse([], ACC) -> ACC.

shunt([],Ys) ->
    Ys;
shunt([X|Xs],Ys) ->
    shunt(Xs,[X|Ys]).

mergeSort([]) -> [];
mergeSort([_X] = A) -> A;
mergeSort([X, Y]) when X < Y -> [X, Y];
mergeSort([X, Y]) -> [Y, X];
mergeSort(A) ->
    {B, C} = lists:split(length(A) div 2, A),
    mergeSort(mergeSort(B), mergeSort(C)).
mergeSort(B, C) ->
    mergeSort(B, C, []).
mergeSort([X|Xs], [Y|_Ys] = C, ACC) when X < Y ->
    mergeSort(Xs, C, [X|ACC]);
mergeSort([_X|_Xs] = B, [Y|Ys], ACC) ->
    mergeSort(B, Ys, [Y|ACC]);
mergeSort([X|Xs], [], ACC) ->
    mergeSort(Xs, [], [X|ACC]);
mergeSort([], [Y|Ys], ACC) ->
    mergeSort([], Ys, [Y|ACC]);
mergeSort([], [], ACC) ->
    reverse(ACC).

quickSort([]) -> [];
quickSort([X|Xs]) ->
    B = lists:filter(fun (Y) -> Y < X end, Xs),
    C = lists:filter(fun (Y) -> Y >= X end, Xs),

    quickSort(B) ++ [X|quickSort(C)].

insertionSort([]) -> [];
insertionSort([X|Xs]) ->
    insertionSort(X, insertionSort(Xs)).
insertionSort(X, Xs) ->
    insertionSort(X, Xs, []).
insertionSort(X, [Y|Ys], ACC) when X >= Y->
    insertionSort(X, Ys, [Y|ACC]);
insertionSort(X, L, ACC) ->
    shunt(ACC, [X|L]).