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

my_reverse(L, R) :-
    my_reverse_helper(L, R, []).

my_reverse_helper([], R, R).
my_reverse_helper([H|T], R, Acc) :-
    my_reverse_helper(T, R, [H|Acc]).

my_length([], 0).
my_length([_|T], Y) :-
    my_length(T, N),
    Y is N+1.

my_member(H, [H|_]).
my_member(_, []) :-
    false.
my_member(V, [_|T]) :-
    my_member(V, T).

my_subset(Relation, L, Y) :-
    my_subset_helper(Relation, L, Y, []).
my_subset_helper(_, [], Y, Acc) :-
    my_reverse(Acc, Y).
my_subset_helper(Relation, [H|T], Y, Acc) :-
    Temp=[H],
    Term=..[Relation|Temp],
    Term,
    my_subset_helper(Relation, T, Y, [H|Acc]).
my_subset_helper(Relation, [_|T], Y, Acc) :-
    my_subset_helper(Relation, T, Y, Acc).

my_intersect([], _, []).
my_intersect([H1|T1], Right, [H1|RT]) :-
    my_member(H1, Right),
    my_intersect(T1, Right, RT).
my_intersect([_|T1], Right, R) :-
    my_intersect(T1, Right, R).

compute_change(Value, Q, D, N, P) :-
    compute_change_helper(Value,
                          Q,
                          D,
                          N,
                          P,
                          0,
                          0,
                          0,
                          0).
compute_change_helper(0, Q, D, N, P, Q, D, N, P).
compute_change_helper(Value, Q, D, N, P, QAcc, DAcc, NAcc, PAcc) :-
    (   Value>=25
    ->  NextValue is Value-25,
        NextQ is QAcc+1,
        compute_change_helper(NextValue,
                              Q,
                              D,
                              N,
                              P,
                              NextQ,
                              DAcc,
                              NAcc,
                              PAcc)
    ;   Value>=10
    ->  NextValue is Value-10,
        NextD is DAcc+1,
        compute_change_helper(NextValue,
                              Q,
                              D,
                              N,
                              P,
                              QAcc,
                              NextD,
                              NAcc,
                              PAcc)
    ;   Value>=5
    ->  NextValue is Value-5,
        NextN is NAcc+1,
        compute_change_helper(NextValue,
                              Q,
                              D,
                              N,
                              P,
                              QAcc,
                              DAcc,
                              NextN,
                              PAcc)
    ;   Value>=1
    ->  NextValue is Value-1,
        NextP is PAcc+1,
        compute_change_helper(NextValue,
                              Q,
                              D,
                              N,
                              P,
                              QAcc,
                              DAcc,
                              NAcc,
                              NextP)
    ;   compute_change_helper(Value,
                              Q,
                              D,
                              N,
                              P,
                              QAcc,
                              DAcc,
                              NAcc,
                              PAcc)
    ).

compose(L, [], L).
compose([], L, L).
compose([H1|T1], [H2|T2], [H1, H2|RT]) :-
    compose(T1, T2, RT).

palindrome(L, R) :-
    my_reverse(L, Reversed),
    my_append(L, Reversed, R).