-module(kolo).
-export([silniaI/1, silniaR/1, parzysta/1, fibo/1, nalezy/2, polacz/2, zmniejsz/2,maxI/1, pozycja_w/2, suma/2, onp/1, onpMn/2, zlicz/2,zo/2,iloczyn/2,ujR/1,ujI/1,domkniecie/1,onpa/1,onpb/1]).

silniaI(N) ->
    silniaI(N,1).

silniaI(0,R) ->
    R;

silniaI(N,R) when N>0 ->
    Rn = R*N,
    silniaI(N-1,Rn).

silniaR(0) ->
    1;

silniaR(N) when N>0 ->
    N*silniaR(N-1).



parzysta(N) when N>1 ->
    parzysta(N-2);

parzysta(1) ->
    false;

parzysta(0) ->
    true.



fibo(N) when ((N==0) or (N==1)) ->
    1;

fibo(N) when N>1 ->
    fibo(N-2)+fibo(N-1).



nalezy(N,[N|Lt]) ->
    true;

nalezy(N,[Lh|Lt]) ->
    nalezy(N,Lt);

nalezy(N,[]) ->
    false.



polacz(A,B) ->
    A ++ B.



zmniejsz(L,N) ->
    zmniejsz(L,N,[]).

zmniejsz([Lh|Lt],N,O) ->
    OI = O ++ [(Lh - N)],
    zmniejsz(Lt,N,OI);

zmniejsz([],_,R) ->
    R.



maxI(L) ->
    maxI(L,L).

maxI(L,[Lh|_]) ->
    maxI(L,Lh);

maxI([Lh|Lt],R) when Lh>R ->
    Ri = Lh,
    maxI(Lt,Ri);

maxI([Lh|Lt],R) when Lh=<R ->
    maxI(Lt,R);

maxI([],R) ->
    R.



pozycja_w(E,L) ->
    pozycja_w(1,E,L).

pozycja_w(N,E,[Lh|_]) when Lh>E ->
    N;

pozycja_w(N,E,[Lh|Lt]) when Lh=<E ->
    pozycja_w(N+1,E,Lt);

pozycja_w(_,_,[]) ->
    0.



suma(L1,L2) ->
    suma(L1, L2, L1).

suma(L1, [L2h|L2t], R) ->
    Ex = lists:member(L2h, L1),
    if Ex ->
        suma(L1,L2t,R);
    true ->
        suma(L1,L2t,R++[L2h])
    end;

suma(_,[],R) ->
    R.



onpMn(L) ->
    onpMn(L,1).

onpMn([Lh|Lt],R) ->
    Ri = R*Lh,
    onpMn(Lt,Ri);

onpMn([],R) ->
    R.

onp(N) ->
    onp(N,[]).

onp([Nh|Nt],S) when ((Nh =/= 'p') and (Nh =/= 'r')) ->
    Si = S++[Nh],
    onp(Nt,Si);

onp([Nh|Nt],S) when (Nh == 'p') ->
    Si = lists:sum(S),
    onp(Nt,[Si]);

onp([Nh|Nt],S) when (Nh == 'r') ->
    Si = onpMn(S),
    onp(Nt,[Si]);

onp([],[S]) ->
    S.



zlicz(N,L) ->
    zlicz(N,L,0).

zlicz(N,[Lh|Lt],R) when Lh<N ->
    zlicz(N,Lt,R+1);

zlicz(N,[Lh|Lt],R) when Lh>=N ->
    zlicz(N,Lt,R);

zlicz(_,[],R) ->
    R.



zo(N, []) -> [];
zo(N, [L]) -> [N];
zo(N, [L|T]) -> [L|zo(N,T)].



iloczyn(L1,L2) ->
    iloczyn(L1,L2,[]).

iloczyn(L1,[],R) ->
    R;

iloczyn(L1, [L2h|L2t], R) ->
    Ex = (lists:member(L2h,L1) and (not(lists:member(L2h,R)))),
    if Ex ->
        iloczyn(L1,L2t,R++[L2h]);
    true ->
        iloczyn(L1,L2t,R)
    end.



ujI(L) ->
    ujI(L,1).

ujI([],_) -> 0;

ujI([Lh|Lt],P) when Lh<0 -> P;

ujI([Lh|Lt],P) when Lh>=0 ->
    ujI(Lt,P+1).



ujR([]) -> 0;

ujR([H|T]) when H<0 -> 1;

ujR([H|T]) when H>0 ->
    1+ujR(T).



domkniecie(L) ->
    domkniecie(L,[0,1,2,3,4,5,6,7,8,9]).

domkniecie([],N) -> N;

domkniecie([Lh|Lt],N) ->
    Ex = lists:member(Lh,N),
    if Ex ->
        domkniecie(Lt,N--[Lh]);
    true ->
        domkniecie(Lt,N)
    end.



onpa([L]) -> L;

onpa([La,Lb,'p'|Lt]) ->
    Li = La + Lb,
    onpa([Li]++Lt);

onpa([La,Lb,'r'|Lt]) ->
    Li = La * Lb,
    onpa([Li]++Lt).



onpb(L) ->
    onpb(L,[]).

onpb([],[S]) -> S;

onpb([Lh|Lt],[Sa,Sb]) when Lh == 'p' ->
    Si = Sa + Sb,
    onpb(Lt,[Si]);

onpb([Lh|Lt],[Sa,Sb]) when Lh == 'r' ->
    Si = Sa * Sb,
    onpb(Lt,[Si]);

onpb([Lh|Lt],S) ->
    onpb(Lt, S ++ [Lh]).