如何让这个 prolog 代码在合理的时间内运行？

Question

I encountered a maths puzzle recently which goes as follows:

Imagine 13 envelopes, each numbered from 1 to 13. Take 13 index cards, numbered from 528 to 540. Find a possible arrangement of cards in envelopes such that the number on each card can be divided by the containing envelope with no remainder.

I've solved this by hand, and found more than one solution. The manual technique I used was to list the divisors of each index card and find those with just one divisor. Then I cross off that divisor from other numbers and continued the process, looking for numbers with just 1 divisor. (Occasionally there were some with two, and this either resulted in deadends or resulted in multiple solutions)

I've no idea how to do this sensibly in prolog. I've only managed to do a brute-force, ie check every possible ordering

valid([], []).
valid([EHEAD|ETAIL], [CHEAD|CTAIL]) :- 0 is mod(EHEAD, CHEAD), valid(ETAIL, CTAIL).

numlist(1,13,Envelopes),
permutation(Contents, C), numlist(528, 540, C),
valid(Contents, Envelopes).

This solution doesn't run in sensible time so I can't verify it (but it looks about right). How can I force it to backtrack earlier, eg I know instinctively it's pointless to bother searching solutions which try to pair an odd number with any even number (and this generalises to all evelope-numbers) but don't know how to implement this.

Answer 1

Just use nondeterminism, here represented by select /3:

:- module(p13, [p13/1]).

p13(L) :-
    numlist(1,13,Envelopes),
    numlist(528,540,Cards),
    associate(Cards,Envelopes,L).

associate([],[],[]).
associate([Card|Cards],Envelopes,[Card/Env|Rest]) :-
    select(Env,Envelopes,Envelopes1),
    Card mod Env =:= 0,
    associate(Cards,Envelopes1,Rest).

yields

?- p13(L).
L = [528/4, 529/1, 530/10, 531/9, 532/7, 533/13, 534/6, 535/5, ... / ...|...] .

Answer 2

A typical option would be to use a Constraint Logic Programming over Finite Domains library, ie CLP(FD) for short. The specifics will depend on which Prolog you're using. With SWI-Prolog we could solve the problem like this:

:- use_module(library(clpfd)).

envelope(Num, envelope(Num, _)).

index(envelope(Num, Index), Index) :-
    Index in 528..540,
    Index rem Num #= 0.

solve(Envelopes) :-
    % Start by constructing a list of 13 `envelope(Number, Index)` structures.
    numlist(1, 13, Numbers),
    maplist(envelope, Numbers, Envelopes),
    % Constrain each index to be an integer in 528..540, and to be
    % divisible by the number of the envelope. Also collect the Index
    % variables into a list for use below.
    maplist(index, Envelopes, IndexVars),
    % Constrain all Index variables to have a different value.
    all_different(IndexVars),
    % Find values for the indices.
    label(IndexVars).

We can find a solution and print it in a human-readable form:

?- time(solve(Envelopes)), 
   forall(member(envelope(Num, Index), Envelopes), 
          format("Envelope ~d: ~d~n", [Num, Index])).
% 59,435 inferences, 0.000 CPU in 0.005 seconds (0% CPU, Infinite Lips)
Envelope 1: 529
Envelope 2: 538
Envelope 3: 537
Envelope 4: 528
Envelope 5: 535
Envelope 6: 534
Envelope 7: 532
Envelope 8: 536
Envelope 9: 531
Envelope 10: 530
Envelope 11: 539
Envelope 12: 540
Envelope 13: 533
Envelopes = ...