nalezy(E, [E|_]). % =member

nalezy(E,[_|T]):-
    nalezy(E,T).



polacz([],L,L).

polacz([H|T],L,[H|T1]):-
    polacz(T,L,T1).



%[...,E,...] = L (z tablicy)

%relacja nalezy z wykorzystaniem polacz
nalezy_polacz(E,L):-
    polacz(_,[E|_],L).



%element E1 znajduje sie wczesniej niz E2

wczesniej(E1,E2,L):-
    polacz(X,[E1|T],L),
    nalezy(E2,T).



dlugosc([],0).

dlugosc([H|T],N):-
    dlugosc(T,N1),
    N is N1+1.



it_dlugosc([],0).

it_dlugosc([H|T],N):-
    it_dlugosc(T,1,N).

it_dlugosc([],A,A).

it_dlugosc([H|T],A,N):-
    A1 is A+1,
    it_dlugosc(T,A1,N).



%mozna od kogos wziac na_poczatek i na_koniec



odwroc([],[]). %lista pusta

odwroc([X],[X]). %1-elementowa

odwroc([H|T],L):-
    odwroc(T,T1),
    polacz(T1,[H],L).



it_odwroc([],[]).

it_odwroc([X],[X]).

it_odwroc([H|T],L):-
    it_odwroc(T,[H],L).

it_odwroc([],A,A).

it_odwroc([H|T],A,L):-
    it_odwroc(T,[H|A],L).


usun(E,[],[]).

usun(E,[E|T],T1):-
    usun(E,T,T1).

usun(E,[H|T],[H|T1]):-
    usun(E,T,T1).



it_usun(E,[],[]).

it_usun(E,)

%3.6 na przyszlych zajeciach (jako wejsciowka)!!!
%przypomniec sobie algorytmy sortowania
%sprawdzian 25.03






%--------------------------------------------
%21.03
%--------------------------------------------

usun_wieksze_od_piec(E,[]).

usun_wieksze_od_piec([E|T],T1):-
    E>=5,
    usun(T,T1).

usun_wieksze_od_piec([H|T],[H|T1]):-
    H<5,
    usun(T,T1).

i_usun_wieksze_od_piec(E,[]).

i_usun_wieksze_od_piec([E|T],T).

i_usun_wieksze_od_piec(L1,L2):-
    i_usun(L1,[],L2).

i_usun_wieksze_od_piec([],A,A).

i_usun_wieksze_od_piec([E|T],A,L2):-
    E>=5,
    i_usun(T,A,L2).

i_usun_wieksze_od_piec([H|T],A,L2):-
    H<5,
    append(A,[H],A1),
    i_usun(T,A1,L2).

przesun_piatki(E,[]).

przesun_piatki([E|T],T1):-
    E==5,
    append([E],[T],T1),
    przesun_piatki(T,T1).

przesun_piatki([E|T],[E|T1]):-
    E\=5,
    przesun_piatki(T,T1).


sort_wstawianie([],[]).

sort_wstawianie([E],[E]).

sort_wstawianie([H|T],L):-
    sort_wstawianie(T,T1),
    wstaw(H,T1,L).

wstaw(E,[],[E]).

wstaw(E,[H|T],[E,H|T]):- %[E,H|T] lista [E,H,T,T,T...]
    E=<H.

wstaw(E,[H|T],[H|T1]):-
    E>H,
    wstaw(E,T,T1).

sort_wybieranie([],[]).

sort_wybieranie([E],[E]).

sort_wybieranie(L,[Min|T]):-
    najmniejszy(L,Min,L1),
    sort_wybieranie(L1,T).

najmniejszy([E],E,[]).

najmniejszy([H|T],M,[H|T1]):-
    najmniejszy(T,M,T1),
    M=<H.

najmniejszy([H|T],H,T):-
    najmniejszy(T,M,_),
    M>H.

quicksort([],[]).

quicksort([E],[E]).

quicksort([H|T],L):-
    rozdziel(T,H,T1,T2),
    quicksort(T1,T11),
    quicksort(T2,T22),
    append(T11,[H|T22],L).

rozdziel([],_,[],[]).

rozdziel([H|T],E,[H|T1],T2):-
    rozdziel(T,E,T1,T2),
    H=<E.

rozdziel([H|T],E,T1,[H|T2]):-
    rozdziel(T,E,T1,T2),
    H>E.

splec(L1,L2,L3):- %L1 i L2 sa uporzadkowane. Splec zwraca uporzadkowana liste skladajaca sie z L1, L2 i L3.

%wejsciowka metapredykaty sterujace + indywidualne zadanie