%% ZAMIEN_LAST_ELEM
zamien(X,List) →
L1=reverse(List),
[H|T] = L1,
L2 = [X|T],
reverse(L2).

%% WSTAW_EL_DO_POSORTOWANEJ_TABLICY
wstaw(Element,[]) -> [Element];
wstaw(Element,[H|T]) when Element < H -> [Element,H|T];
wstaw(Element,[H|T]) -> [H] ++ wstaw(Element,T).

%% ZAMIEN_LAST_EL_ITER
zamien_i(X,[H|T]) →
zamien_i(X,[H|T],[]).
zamien_i(X,[H|T], L) when T/=[] →
zamien_i(X,T,[H|L]);
zamien_i(X,[Y],L) →
reverse([X|L]).

%% NOTACJA_POLSKA
wynik(L) → [W] = wynik(L,[]), W.
wynik([], Stack) → Stack;
wynik([H|T], Stack) →
wynik(T, rpn, (H, Stack)).
rpn(p, [N1, N2|S]) → [N2+N1|S];
rpn(m, [N1, N2|S]) → [N2-N1|S];
rpn(X, Stack) → [X|Stack].

%% ENTY_EL_LISTY
nth(1,[H|_])-> H;
nth(N,[_|T]) when is_integer(N),
N>1 -> nth(N-1,T);

%% MEMBER
member(Element, [])-> false;
member(Element, [H|T]) ->
if
Element == H -> true;
Element =/= H -> member(Element,T)
end.

%% DŁUGOŚĆ
length([])->0;
length([H|T]) -> length(T) + 1.

%% ODWRÓĆ LISTE
reverse([]) -> [];
reverse([H | T]) -> reverse(T) ++ [H].

%% MAX_VALUE
max_value([H|T]) →
max(T, H).
max([], D) → D;
max([H|L], AC) →
if
H > AC → max(L, H);
true → max(L, AC),
end.

%% SUMA_ITER_DWOCH_LIST
suma(L1,L2) -> sum_unique(L1, L2, L1).
sum_unique(_, [] , AC) -> AC;
sum_unique(L, [H|T] , AC) -> VAR = member(L,H),
if
var -> sum_unique(L,T,AC);
true -> sum_unique(L,T,AC ++ [H])
end.

%% ZLICZ_EL < X
zlicz(X, []) →
zlicz(X, [H|T]) when X =< H →
zlicz(X, T);
zlicz(X, [H|T]) when X > H →
1 + zlicz(X, T).

%% ZLICZ_EL < X ITER
zlicz_i(X, [H|T]) →
zlicz_t(X, [H|T], 0).
zlicz_i(X,[], Y) → Y;
zlicz_i(X, [H|T], Y) when X > H →
zlicz_i(X,T, Y+1);
zlicz_i(X, [H|T], Y) when X <= H →
zlicz_i(X, T).

%% ILOCZYN_ITER
iloczynI([],E)->0;
iloczynI([H|T],E)->
iloczynI([H|T],E,[]).
iloczynI([],E,L2)->L2;
iloczynI([H|T],E,L2)->
iloczynI(T,E,L2++[H*E]).

%% ŚREDNIA
min_it([]) -> false;
min_it([H|T]) -> min_it(H, [H|T]).
min_it(A, []) -> A;
min_it(A, [H|T]) when H < A -> min_it(H, T);
min_it(A, [H|T]) -> min_it(A, T).

%% POZYCJA_PIERWSZEJ_UJEMNEJ
poz_ujemne([])->0;
poz_ujemne([H|T]) when H<0->
1 + poz_ujemne([]);
poz_ujemne([H|T])-> 1 + poz_ujemne(T).

%% NAJMNIEJSZA WARTOSC W LISCIE ITER
min([])->false;
min([H|T])->
min([H|T],H).
min([],A)->A;
min([H|T], A) when H < A ->
min(T, H);
min([H|T],A)->min(T,A).

%% ILOCZYN N Z KAŻDYM ELEMENTEM LISTY REKURENCYJNIE
iloczyn(_,[]) -> [];
iloczyn(N, [E]) -> [E*N];
iloczyn(N, [H|T]) ->
[N*H|iloczyn(N, T)].

%% ILOCZYN N Z KAŻDYM ELEMENTEM LISTY ITERACYJNIE
iloczyn_i(_, []) -> [];
iloczyn_i(N, L) -> iloczyn_i2(N, L, []).
iloczyn_i2(_, [], A) -> A;
iloczyn_i2(N, [H|T], A) ->
iloczyn_i2(N, T, A ++ [N*H]).


%% POZYCJA ELEMENTU W LIŚCIE ITER
pozycja_i(E,[])->0;
pozycja_i(E,L)->pozycja_i(E,1,L).
pozycja_i(E,P,[H|T])when H /= E -> pozycja_i(E,P+1,T);
pozycja_i(E,P,[H|T])when H == E -> P.

%% POZYCJA ELEMENTU W LIŚCIE
pozycja(E,[])->0;
pozycja(E,[H|T])when H /= E -> 1+pozycja(E,T);
pozycja(E,[H|T])when H == E -> 1.

%% MINIMALNA WARTOSC W LISCIE
min_i([])->false;
min_i([H|T])->min_i(H,T).
min_i(X,[H|T])when X >= H->min_i(H,T);
min_i(X,[H|T])when X < H->min_i(X,T);
min_i(X,[])->X.

%% DOPEŁNIENIE BRAKUJĄCYCH ELEMENTÓW
dom([])->[0,1,2,3,4,5,6,7,8,9];
dom(L)->dom(L, 0, []).
dom(L, P, A) when P < 10  ->	 case (member3(P,L))
                                 of true -> dom(L, P+1, A);
                                 false -> dom(L, P+1, A++[P])
                                 end;
dom(L, P, A) when P == 10 -> A.

%% USUWANIE ELEMENTU Z LISTY IT
delel([],E)->[];
delel([H|T],E) -> delel([H|T],E,[]).
delel([],E,M) -> M;
delel([H|T],E,M) when H == E -> delel(T,E,M);
delel([H|T],E,M) -> delel(T,E,M++[H]).

%% USUWANIE ELEMENTU Z LISTY REK
delelR([],_)->[];
delelR([H|T],E) when H /= E -> [H] ++ delelR(T,E);
delelR([H|T],E) -> delelR(T,E).

%% USUWANIE ELEMENTÓW POWYŻEJ PODANEJ WARTOŚCI
usun_n([],L)->[];
usun_n([H|T],E) when H=/=E ->
[H]++ usun_n(T,E);
usun_n([H|T],E)->[].