CODEWITHSUNDEEP
prolog
keont
keont

Reputation: 673

How to make an operation to every element of a list

I find myself narrowing a (very simple) problem more and more.

Let's say I have this operation: listsplit([H1,H2,H3|T], H1,H2,H3, T).

Which gives me the first three elements of a list. I want a program, cells, to travel an input list and make (at least that ONE operation!!) to every element of the list.

So I have something like:

cells(Input, Result):-
   cellsBody(Input, [], Result).

cellsBody([],Result,Result).
cellsBody([Head|Input], Acc, [Headd|Result]):-
   listsplit(Input,H1,H2,H3,_),
   cellsBody(Input, [OutputBody|Acc], Result).

I have that code because I have used many I've seen as examples that go like that to travel a list. They separate head from body and go on. I fail to see how this is done in prolog. I tried changing variable names, so that they would match (as I would do in other languages), and I've tried to make the problem as simple as possible.

So, how do I travel a list AND make operations to every element (that I choose to, starting with the first one, the head).

Edit: Examples of what I want to archieve:

I get an input list like oxo, oxxxo, oxoxo, so on. I then apply a rule to the first three elements, then the next three, and so on, and while I do that I add the result of the rule to another list that I return (which is why I am trying to use the accumulator).

Upvotes: 1

Views: 1395

Answers (1)

tas
tas

Reputation: 8140

You've almost got it. Keeping your predicate cells/2 as is, think about the special cases first: The lists [], [_], [_,_] haven't got three elements, so whatever operation you have in mind for those three elements, there's nothing to do in these cases. Otherwise you have a recursive rule to do what you intend to.

Looking at listsplit/5: you can do that directly in the head of the recursive rule, no need for an extra predicate. Then you have one or more goals for your intended operation. For the sake of an example let's say packaging the 3 head elements as a triplet. And of course the relation must hold for the tail T of the list too. Then your code might look something like that:

cellsBody([],Result,Result).
cellsBody([_],Result,Result).
cellsBody([_,_],Result,Result).
cellsBody([H1,H2,H3|T], Acc, Result):-   % the first 3 elements
   Triplet=(H1,H2,H3),                   % at least ONE operation with them
   cellsBody(T, [Triplet|Acc], Result).

Example queries:

   ?- cells([],Result).
Result = []
   ?- cells([1],Result).
Result = []
   ?- cells([1,2],Result).
Result = []
   ?- cells([1,2,3],Result).
Result = [(1,2,3)]
   ?- cells([1,2,3,4,5,6,7],Result).
Result = [(4,5,6),(1,2,3)]

Of course, if the intended operation is as simple as in the above example, you don't need an extra goal for it: You can do that directly in the recursive goal:

cellsBody([H1,H2,H3|T], Acc, Result):-
   cellsBody(T, [(H1,H2,H3)|Acc], Result).

Upvotes: 3

Related Questions