Prolog: How to generate simple math expressions? - prolog

Question

I need to write (not calculate) all the states of list of number that means :
Input:
Numbers: 1,2,3
Operators: +,-,/,*
Output:
1+2+3
1-2-3
1/2/3
1*2*3
1+2-3
1+2/3
1+2*3
1-2+3
1-2/3
1-2*3
1/2+3
1/2-3
1/2+3
1*2+3
1*2-3
1+2-3
in descend code just show 1+2+3
How can I develop them to all states?
list_sum([Item], Item).
list_sum([Item1,Item2 | Tail], Total) :-
list_sum([Item1+Item2|Tail], Total).

Answer 1

A variation of the nice solution posted by Carlo Capelli allows us to illustrate an useful programming idiom to better exploit first-argument indexing:
list_combine([N1| Ns], Os, Nt) :-
list_combine(Ns, N1, Os, Nt).
list_combine([], N, _, [N]).
list_combine([N2| Ns], N1, Os, [N1, O| Nt]) :-
member(O, Os),
list_combine(Ns, N2, Os, Nt).
The idea is to pass the list we want to walk by separating the list head from the tail and pass both as argument with the tail as first argument, as exemplified above.
In the original solution, the Prolog compiler will generally not distinguish between a list with just one element and a list with one or more elements. But it will distinguish between an empty list (an atom) and a list with at least one element (a compound term). Note also that the original version creates a spurious choice-point, for each recursive call, on the call to the list_combine/3 predicate in addition to the intended choice-point on the member/2 predicate call.

Answer 2

a simple recursion:
list_combine([N|Nr],Os,[N,O|Nt]) :-
member(O,Os),
list_combine(Nr,Os,Nt).
list_combine([N],_,[N]).
and now
?- forall(list_combine([1,2,3],[+,*],C),writeln(C)).
[1,+,2,+,3]
[1,+,2,*,3]
[1,*,2,+,3]
[1,*,2,*,3]
true.
here is a - maybe - more readable version
list_combine(Ns,Os,Cs) :-
[N|Nr] = Ns,
member(O,Os),
Cs = [N,O|Nt],
list_combine(Nr,Os,Nt).
Of course, use in alternative, just to better understand how unification acts in decomposing and composing arguments.

Answer 3

Using DCG with phrase/2 as a generator:
operator --> [+].
operator --> [-].
operator --> [*].
operator --> [/].
expr_trinary -->
[1],
operator,
[2],
operator,
[3].
expr(E) :-
phrase(expr_trinary,Expr_trinary),
atomics_to_string(Expr_trinary,E).
Example run:
?- expr(E).
E = "1+2+3" ;
E = "1+2-3" ;
E = "1+2*3" ;
E = "1+2/3" ;
E = "1-2+3" ;
E = "1-2-3" ;
E = "1-2*3" ;
E = "1-2/3" ;
E = "1*2+3" ;
E = "1*2-3" ;
E = "1*2*3" ;
E = "1*2/3" ;
E = "1/2+3" ;
E = "1/2-3" ;
E = "1/2*3" ;
E = "1/2/3".
Since your question works with list, a way to see DCG as list processing is to use listing/1 to convert it to regular Prolog.
?- listing(operator).
operator([+|A], A).
operator([-|A], A).
operator([*|A], A).
operator([/|A], A).
true.
?- listing(expr_trinary).
expr_trinary([1|A], B) :-
operator(A, C),
C=[2|D],
operator(D, E),
E=[3|B].
true.
which can be called as regular Prolog.
?- expr_trinary(E,[]).
E = [1, +, 2, +, 3] ;
E = [1, +, 2, -, 3] ;
E = [1, +, 2, *, 3] ;
E = [1, +, 2, /, 3] ;
E = [1, -, 2, +, 3] ;
E = [1, -, 2, -, 3] ;
E = [1, -, 2, *, 3] ;
E = [1, -, 2, /, 3] ;
E = [1, *, 2, +, 3] ;
E = [1, *, 2, -, 3] ;
E = [1, *, 2, *, 3] ;
E = [1, *, 2, /, 3] ;
E = [1, /, 2, +, 3] ;
E = [1, /, 2, -, 3] ;
E = [1, /, 2, *, 3] ;
E = [1, /, 2, /, 3].
An expanded solution using a number (1,2,3) in any position:
number --> [1].
number --> [2].
number --> [3].
operator --> [+].
operator --> [-].
operator --> [*].
operator --> [/].
expr_trinary -->
number,
operator,
number,
operator,
number.
expr(E) :-
phrase(expr_trinary,Expr_trinary),
atomics_to_string(Expr_trinary,E).
Example run:
?- expr(E).
E = "1+1+1" ;
E = "1+1+2" ;
E = "1+1+3" ;
E = "1+1-1" ;
E = "1+1-2" ;
E = "1+1-3" ;
...
For a explanation of how to generate with DCG see this Amzi section: Generating with Difference Lists
In comment for other answer you wrote:
its not work more than 3 element? can you develop it for more elements?
As the number of elements increases so does the combinatorial explosion.
To keep the combinatorial explosion down for the example run this will only use two numbers (1,2) and two operators (+,*), you can add more to your liking.
number(1) --> [1].
number(2) --> [2].
operator(+) --> [+].
operator(*) --> [*].
expr(N) --> number(N).
expr((E1,Op,E2)) --> operator(Op),expr(E1),expr(E2).
expr(E) :-
length(Expr,_),
phrase(expr(E),Expr).
Note that this uses length/2 for iterative deepening. Basically length/2 generates list of increasing length and then phrase/2 comes up with answers that are of that length.
?- length(Ls,N).
Ls = [],
N = 0 ;
Ls = [_870],
N = 1 ;
Ls = [_870, _876],
N = 2 ;
Ls = [_870, _876, _882],
N = 3 ;
Ls = [_870, _876, _882, _888],
N = 4 ;
Ls = [_870, _876, _882, _888, _894],
N = 5 ;
Ls = [_870, _876, _882, _888, _894, _900],
N = 6
...
So that generator works as expected the normal BNF and DCG, e.g.
<expr> ::= <expr> <op> <expr>
expr((E1,Op,E2)) --> expr(E1),operator(Op),expr(E2).
which is direct left recursive is converted to this
<expr> ::= <op> <expr> <expr>
expr((E1,Op,E2)) --> operator(Op),expr(E1),expr(E2).
Example run:
?- expr(E).
E = 1 ;
E = 2 ;
E = (1, (+), 1) ;
E = (1, (+), 2) ;
E = (2, (+), 1) ;
E = (2, (+), 2) ;
E = (1, (*), 1) ;
E = (1, (*), 2) ;
E = (2, (*), 1) ;
E = (2, (*), 2) ;
E = (1, (+), 1, (+), 1) ;
...
E = (1, (+), 2, (+), 2, (*), 1) ;
E = (1, (+), 2, (+), 2, (*), 2) ;
E = (1, (+), (1, (+), 1), (+), 1) ;
E = (1, (+), (1, (+), 1), (+), 2) ;
E = (1, (+), (1, (+), 2), (+), 1) ;
...

Answer 4

One way is
get_calcul([X], _, Temp, Calcul):-
append(Temp, [X], Calcul).
get_calcul([N|T], [Op|Top], Temp, Out) :-
append(Temp, [N, Op], Temp1),
get_calcul(T, Top, Temp1, Out).
all_operations(In, Out) :-
setof(Op, X^Ops^(permutation([+,-,*,/], X), get_calcul(In, X, [], Ops), atomic_list_concat(Ops, Op)), Out).
Result
?- all_operations([1,2,3], Out).
Out = ['1*2+3', '1*2-3', '1*2/3', '1+2*3', '1+2-3', '1+2/3', '1-2*3', '1-2+3', '1-2/3'|...].
Well, I solved my problem, not your's !
This can be done :
member_(In, X) :-
member(X, In).
get_calcul([N], _, Temp, Out) :-
append(Temp, [N], Out).
get_calcul([N|T], [Op|Top], Temp, Out) :-
append(Temp, [N, Op], Temp1),
get_calcul(T, Top, Temp1, Out).
all_operations(In, Out) :-
% if you have N numbers
length(In, Len),
% you need N-1 operators
LenOps is Len - 1,
length(LOps, LenOps),
setof(Op, LOps^Ops^(maplist(member_([+,-,*,/]), LOps),get_calcul(In, LOps, [], Ops), atomic_list_concat(Ops, Op)), Out).
For example :
?- all_operations([1,2,3], Out), maplist(writeln, Out).
1*2*3
1*2+3
1*2-3
1*2/3
1+2*3
1+2+3
1+2-3
1+2/3
1-2*3
1-2+3
1-2-3
1-2/3
1/2*3
1/2+3
1/2-3
1/2/3
Out = ['1*2*3', '1*2+3', '1*2-3', '1*2/3', '1+2*3', '1+2+3', '1+2-3', '1+2/3', '1-2*3'|...].

Answer 5

This my solution proposal, which I find to be very simple and straight forward, copy and paste below to notepad++ editor to get best readability.
* ________________________________________________ *
*|find_expression(NumsList,TargetValue,Expression)| *
**------------------------------------------------* *
* Expression is an arithmetic expression of the numbers in Numslist with *
* possible operators '+','-','*','/' and '(' and ')' between the numbers *
* in such a way that the expression evaluates to the TargetValue argument *
*****************************************************************************/%
/* a single element number list can evaluate only to itself */
find_expression([SingleNumber],SingleNumber,SingleNumber).
/* expression of a multypile number list */
find_expression(NumberList,Target,Expression):-
/* non-deterministically divide the number list
into 2 separate lists which include at least one number each*/
append([X|Xs],[Y|Ys], NumberList),
/* recursively find an expression for east list,
where the expression evaluates to itself */
find_expression([X|Xs],Exp1,Exp1),
find_expression([Y|Ys],Exp2,Exp2),
/* non-deterministically choose an operand from [+,-,*,division]
and compose Expression to be (Exp1 Operand Exp2) */
( member(Expression,[Exp1+Exp2,Exp1-Exp2,Exp1*Exp2])
; /* prevent zero divison */
(Val2 is Exp2, Val2 =\= 0, Expression = (Exp1/Exp2))), %/*
/* assure that final expression evaluates(matches) the target value
and convert value from integer to float if necessary */
( Target = Expression ; Target is Expression
; FloatTarget is Target*1.0, FloatTarget is Expression).