Identifying from a List of Lists Recursively - list

Question

currently learning about logic in computing as well as the foundations of Prolog. Please bear with me in my fumbling speech!
I've been faced with a problem where, given an query of a list of lists containing integers, one must devise a way to calculate the highest sum of all the lists using recursion.
For example:
?- getSum([[1,3,6],[9,5,2],[3,4,7]], X).
X = 16.
Should be the output.
I believe the correct way to find the sum of a list is:
sum([],0).
sum([Head|Body], Output) :- sum(Body, BodySum),
Output is Head + BodySum.
However I need to compare the sums before displaying the result, do I have to call to another conditional inside the sum recursion?
Thanks

Answer 1

Several comments first:
Naming: you probably want to name your predicate so that it is obvious what it does. And, Prolog prefers names_like_this to namesInCamelCase. So maybe, call it max_sublist_sum, maybe?
Implementation: in your question you say, "using recursion". Must you use recursion, or do you think that using recursion is your only choice? Since this is a trivial problem, it can be solved using library predicates and avoiding recursion altogether. For example, to find the sums of each sub-list:
maplist(sum_list, List_of_lists, Sums)
Now you have reduced your list of lists to a list of sums. You can find the largest of a list of numbers:
max_list(List_of_numbers, Max_number)
So, your problem becomes:
?- maplist(sum_list, [[1,3,6],[9,5,2],[3,4,7]], Sums),
max_list(Sums, Max_sum).
Sums = [10, 16, 14],
Max_sum = 16.
Now, it may seem as a good exercise to implement each of sum_list/2 and max_list/2, but a good starting point would be to look at the library implementation of these two. Same goes for the definition of maplist/3
You can also intertwine the two:
max_sublist_sum0([H|T], Max) :-
sum_list(H, Sum),
max_sublist_sum0_(T, Sum, Max).
max_sublist_sum0_([], Max, Max).
max_sublist_sum0_([H|T], M0, Max) :-
sum_list(H, Sum),
( Sum > M0
-> max_sublist_sum0_(T, Sum, Max)
; max_sublist_sum0_(T, M0, Max)
).
The helper predicate max_sublist_sum_/3 is in practice a fold:
max_sum(L, M0, M) :-
sum_list(L, Sum),
M is max(M0, Sum).
max_sublist_sum1([H|T], Max) :-
sum_list(H, Sum),
foldl(max_sum, T, Sum, Max).
However, this is still much more code than the original suggestion:
max_sublist_sum(L, M) :-
maplist(list_sum, L, S),
max_list(S, M).
Interestingly, on my computer this last version is also fastest for somewhat larger lists, and takes about the same time as the faster of the other two.

Answer 2

You don't need to call another condition inside the recursion, you have to decompose the problem into calculating the sum and the maximum. Following a classic implementation of a max predicate, where the second argument is the current maximum, this would be something like:
max([], X, X).
max([H|T], X, Y) :-
sum(H, S),
S < X,
max(T, X, Y).
max([H|T], X, Y) :-
sum(H, S),
S >= X,
max(T, S, Y).
getSum(L, X) :- max(L, 0, X).
You could make this code more efficient and elegant by using an if-construct or a cut, I leave this to you.