✎ en:dydaktyka:intro2ai:labs:lab_prolog3 [aiWiki]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== LAB: Working with lists in Prolog (part 2) ======

===== -. Problems to solve with lists =====

Using the knowledge gained in [[lab_prolog2|the previous lab]], solve the following problems:

  - Define a predicate that removes the last 3 elements from a list L, the results is list L1, use the ''list_merge'' predicate [[en:dydaktyka:intro2ai:labs:lab_prolog2#merging_lists|from the previous lab]].
  - Define a predicate that removes the first 3 elements from a list L, the results is list L1, use the ''list_merge'' predicate.
  - Define a predicate that removes the first 3 and the last 3 elements from a list L, the results is list L2, use the ''list_merge'' predicate.
  - Define a pair of predicates (complementary, i.e., one use the other) ''odd(L)'' and ''even(L)'', that check if theirs argument list as odd or even length.
    * is your predicate able to also **create** a list of even or odd length (we put a variable as the argument, not a constant)
  - Define a predicate ''palindrome(L)'', L is a palindrome, if it read backwards the same as forward, np. ''[a,l,a]'', ''[m,a,d,a,m]''. (hint: you can (but don't have to) use the predicate ''list_reverse''.)
  - Define a predicate ''list_shift(L1,L2)'', where L2, is like L1 shifted by one element, e.g.: <code prolog>
      ?- list_shift([1,2,3,4,5,6,7,8],X),list_shift(X,Y),list_shift(Y,Z).

      X = [2, 3, 4, 5, 6, 7, 8, 1]
      Y = [3, 4, 5, 6, 7, 8, 1, 2]
      Z = [4, 5, 6, 7, 8, 1, 2, 3]
</code>
  - Define a predicate ''list_translate(L1,L2)'', that translates a list of numbers (max. 0-9),to a list of words: <code prolog>
      ?- list_translate([1,4,7],X).

      X = [one, four, seven] ;

      ?- list_translate(A,[two,eight,zero]).

      A = [2, 8, 0] ; </code> using the facts: <code prolog>
      means(0,zero).   means(1,one).
      means(2,two).    means(3,three).
      means(4,four). means(5,five).
      means(6,six).  means(7,seven).
      means(8,eight).  means(9,nine).
</code> Hint: use recursion.
  - Define a predicate ''list_subset(L,Z)'', that checks if Z is a subset of L, and writes out all the possible subsets of L, if Z is z variable. <code prolog>
      ?- list_subset([a,b,c],[c]).

      Yes
      ?- list_subset([a,b,c],[a,c]).

      Yes
      ?- list_subset([a,b,c],X).

      X = [a, b, c] ;
      X = [a, b] ;
      X = [a, c] ;
      X = [a] ;
      X = [b, c] ;
      X = [b] ;
      X = [c] ;
      X = []
</code>
  - Define a predicate ''list_divide(L,L1,L2)'', that divides list L into 2 fragments, L1 and L2, more less the same length, e.g.: <code prolog>
      ?- list_divide([],X,Y).

      X = []
      Y = [] ;

      ?- list_divide([1],X,Y).

      X = [1]
      Y = [] ;

      ?- list_divide([1,2],X,Y).

      X = [1]
      Y = [2] ;

      ?- list_divide([1,2,3],X,Y).

      X = [1, 3]
      Y = [2] ;

      ?- list_divide([1,2,3,4],X,Y).

      X = [1, 3]
      Y = [2, 4] ;

      ?- list_divide([1,2,3,4,5],X,Y).

      X = [1, 3, 5]
      Y = [2, 4] ;

      ?- list_divide([1,2,3,4,5,6,7,8],X,Y).

      X = [1, 3, 5, 7]
      Y = [2, 4, 6, 8] ;
</code>
  - Define a predicate ''list_flatten'', that changes arbitrarily nestes list into a flat list (i.e, its elements are not lists) <code prolog>
      ?- list_flatten([[a],b,c],X).

      X = [a, b, c] 

      ?- list_flatten([[a],[b,[d]],c],X).

      X = [a, b, d, c] 

      ?- list_flatten([a,b,c],X).

      X = [a, b, c] 

      ?- list_flatten(a,X).

      X = [a]
</code>
  - Write a program that calculates the coins into which a given amount of money can be exchanged.
    * Define possible coins, e.g: ''coin(1), coin(2)'', ...
    * The predicate should have 2 arguments ''change_money/2'', where the first argument is the amount to be changed, and the second is the list of coin nominals.