% nacteni:
/* ['2.2_4.pl']. */

del(_,[],[]).
del(A,[A|T],V) :- del(A,T,V).
del(A,[H|T1],[H|T2]) :- A\=H, del(A,T1,T2).

del1(A,[A|T],T).
del1(A,[H|T1],[H|T2]) :- del1(A,T1,T2).

insert(A,L,[A|L]).
insert(A,[H|T1],[H|T2]):- insert(A,T1,T2).

insert1(X,List ,[X|List]).

% demonstracni vypis

  % abychom se vyhli varovanim "Redefined static procedure ..."
:- dynamic
       write_all_X/3,
       start/0.
       
write_all_X(Goal,X,Name):-
            call(Goal),write('  '),write(Name),write(' = '),write(X),nl,fail.
write_all_X(_,_,_).

write_all_XY(Goal,X,NameX,Y,NameY):-
            call(Goal),write('  '),write(NameX),write(' = '),write(X),write(','),write(NameY),write(' = '),write(Y),nl,fail.
write_all_XY(_,_,_,_,_).

start:- 
    write('Prace se seznamy - del a insert'),nl,
    write('-------------------------------'),nl, nl,
    write('predikat del(A,L,Vysl) smaze vsechny vyskyty prvku A ze seznamu L'),nl,    
    write('Vysledek volani "del (1,[1,2,1,1,2,3,1,1], L)":'),nl,
    write_all_X(del(1,[1,2,1,1,2,3,1,1], L), L, 'L'),nl,

    write('del1(A,L,Vysl) smaze vzdy jeden (podle poradi) vyskyt prvku A v seznamu L'),nl,
    write('Vysledek volani "del1(1,[1,2,1],L)":'),nl,
    write_all_X(del1(1,[1,2,1],L), L, 'L'),nl,

    write('del1 je mozne pouzit i vicesmerne - prochazeni seznamu v podobe deleni na jeden prvek a zbyvajici prvky'),nl,
    write('Vysledek volani "del1(X,[1,2,1],L)":'),nl,
    write_all_XY(del1(X,[1,2,1],L), X, 'X', L, 'L'),nl,

    write('insert(A,L,Vysl) vklada postupne (pri zadosti o dalsi reseni) na vsechny pozice seznamu L prvek A'),nl,
    write('Vysledek volani "insert(4,[2,3,1], L)":'),nl,
    write_all_X(insert(4,[2,3,1], L), L, 'L'),nl,

    write('insert1(A,L,Vysl) vlozi A na zacatek seznamu L'),nl,
    write('Vysledek volani "insert1(4,[2,3,1], L)":'),nl,
    write_all_X(insert1(4,[2,3,1], L), L, 'L').
?-start.

:- retractall(write_all_X/3).
:- retractall(start/0).

Prace se seznamy - del a insert
-------------------------------

predikat del(A,L,Vysl) smaze vsechny vyskyty prvku A ze seznamu L
Vysledek volani "del (1,[1,2,1,1,2,3,1,1], L)":
  L = [2,2,3]

del1(A,L,Vysl) smaze vzdy jeden (podle poradi) vyskyt prvku A v seznamu L
Vysledek volani "del1(1,[1,2,1],L)":
  L = [2,1]
  L = [1,2]

del1 je mozne pouzit i vicesmerne - prochazeni seznamu v podobe deleni na jeden prvek a zbyvajici prvky
Vysledek volani "del1(X,[1,2,1],L)":
  X = 1,L = [2,1]
  X = 2,L = [1,1]
  X = 1,L = [1,2]

insert(A,L,Vysl) vklada postupne (pri zadosti o dalsi reseni) na vsechny pozice seznamu L prvek A
Vysledek volani "insert(4,[2,3,1], L)":
  L = [4,2,3,1]
  L = [2,4,3,1]
  L = [2,3,4,1]
  L = [2,3,1,4]

insert1(A,L,Vysl) vlozi A na zacatek seznamu L
Vysledek volani "insert1(4,[2,3,1], L)":
  L = [4,2,3,1]

#!/usr/bin/env python
# encoding=utf-8 (pep 0263)

from linked_lists import LinkedList, Cons, Nil

def del_(x, ys):
    if ys == Nil:
        return Nil
    if x == ys.head:
        return del_(x, ys.tail)
    return Cons(ys.head, del_(x, ys.tail))

def del1(x, ys):
    if ys == Nil:
        return
    if x == ys.head:
        yield ys.tail
    for zs in del1(x, ys.tail):
        yield Cons(ys.head, zs)

def del1_anyX(ys):
    if ys == Nil:
        return
    yield (ys.head, ys.tail)
    for (z, zs) in del1_anyX(ys.tail):
        yield (z, Cons(ys.head, zs))

def insert(x, ys):
    yield Cons(x, ys)
    if not ys == Nil:
        for zs in insert(x, ys.tail):
            yield Cons(ys.head, zs)

def insert1(x, ys):
    return Cons(x, ys)

# demonstracni vypis
if __name__ == "__main__":
    print("Prace se seznamy - del a insert")
    print("-------------------------------\n")
    print("funkce del_(x, ys) smaze vsechny vyskyty prvku x ze seznamu ys")
    print("Vysledek volani del_(1, LinkedList([1, 2, 1, 1, 2, 3, 1, 1])):\n\t%s\n" % \
            del_(1, LinkedList([1, 2, 1, 1, 2, 3, 1, 1])))

    print("del1(x, ys) smaze vzdy jeden (podle poradi) vyskyt prvku x v seznamu ys")
    print("Vysledek volani del1(1, LinkedList([1, 2, 1])): \n\t%s\n" % \
            list(del1(1, LinkedList([1, 2, 1]))))

    print("del1_anyX prochazi seznam v podobe deleni na jeden prvek a zbyvajici prvky")
    print("Vysledek volani del1_anyX(LinkedList([1,2,1])): \n\t%s\n" % \
        list(del1_anyX(LinkedList([1,2,1]))))

    print("insert(x, ys) vklada postupne na vsechny pozice seznamu ys prvek x")
    print("Vysledek volani insert(4, LinkedList([2, 3, 1])): \n\t%s\n" % \
            list(insert(4, LinkedList([2, 3, 1]))))

    print("insert1(x, ys) vlozi x na zacatek seznamu ys")
    print("Vysledek volani insert1(4, LinkedList([2, 3, 1])): \n\t%s\n" % \
            insert1(4, LinkedList([2, 3, 1])))

Prace se seznamy - del a insert
-------------------------------

funkce del_(x, ys) smaze vsechny vyskyty prvku x ze seznamu ys
Vysledek volani del_(1, LinkedList([1, 2, 1, 1, 2, 3, 1, 1])):
	[2, 2, 3]

del1(x, ys) smaze vzdy jeden (podle poradi) vyskyt prvku x v seznamu ys
Vysledek volani del1(1, LinkedList([1, 2, 1])): 
	[[2, 1], [1, 2]]

del1_anyX prochazi seznam v podobe deleni na jeden prvek a zbyvajici prvky
Vysledek volani del1_anyX(LinkedList([1,2,1])): 
	[(1, [2, 1]), (2, [1, 1]), (1, [1, 2])]

insert(x, ys) vklada postupne na vsechny pozice seznamu ys prvek x
Vysledek volani insert(4, LinkedList([2, 3, 1])): 
	[[4, 2, 3, 1], [2, 4, 3, 1], [2, 3, 4, 1], [2, 3, 1, 4]]

insert1(x, ys) vlozi x na zacatek seznamu ys
Vysledek volani insert1(4, LinkedList([2, 3, 1])): 
	[4, 2, 3, 1]