Dinesman's multiple-dwelling problem: Difference between revisions

Line 1,304:

=={{header|D}}==

{{incorrect|D| The output is incorrect:

it has Fletcher on the bottom floor,

Baker on the top,

and Cooper and Fletcher adjacent. }}

This code uses the second lazy permutations function of '''[[Permutations#Lazy_version]]'''.

As for flexibility: the solve code works with an arbitrary number of people and predicates.

<syntaxhighlight lang="d">~~import std.stdio, std.math, std.algorithm, std.traits, permutations2;~~

import std.stdio, std.math, std.algorithm, std.traits, std.array, permutations2:permutations;

void main() {

enum Names { Baker, Cooper, Fletcher, Miller, Smith }

immutable(bool function(in Names[]) pure nothrow)[] predicates = [

s => s[Names.Baker] != s.~~length~~ - 1,

s => s.countUntil(Names.Baker) != 4 && s.countUntil(Names.Cooper) != 0,

s ~~=> s[~~Names.~~Cooper]~~ != 0,

s => s.countUntil(Names.Fletcher) != 4 && s.countUntil(Names.Fletcher) != 0,

s => s[Names.~~Fletcher]~~ ~~!= 0 &&~~ s[Names.~~Fletcher] != s.length-1~~,

s => s.countUntil(Names.Miller) > s.countUntil(Names.Cooper),

s => s[Names.~~Miller]~~ > s[Names.~~Cooper]~~,

s => abs(s.countUntil(Names.Smith) - s.countUntil(Names.Fletcher)) != 1,

s => abs(s[Names.~~Smith]~~ - s[Names.Fletcher]) != 1,

s => abs(s.countUntil(Names.Cooper) - s.countUntil(Names.Fletcher)) != 1

];

s => abs(s[Names.Cooper] - s[Names.Fletcher]) != 1];

permutations([EnumMembers!Names])

permutations([EnumMembers!Names]).filter!(solution => predicates.all!(pred => pred(solution)))

.filter!(solution => predicates.all!(pred => pred(solution)))

.writeln;

}</syntaxhighlight>