program logikwiz;
{       ========
Het is een kille regenachtige zondagmiddag. Vijf gezinnen besluiten hun
tijd gezellig samen rond de tafel door te brengen en ze halen daarom een
spel uit de kast. Welk gezin speelt welk spel met hoeveel personen en
hoe heet de winnaar.

1. Het gezin waartoe Roel behoort bestaat uit een even aantal personen.
   Dat aantal is 1 groter of 1 kleiner dan het aantal gezinsleden bij
   van Casteren.
2. Judith Maas is niet een van de twee personen, die samen een spelletje
   schaak spelen.
3. Het gezin waartoe Nora behoort bestaat uit 1 persoon meer dan het
   gezin waarin het spel Risk gespeeld wordt en uit 1 persoon minder
   dan het gezin Zenden.
4. Albert, die niet Weber heet, komt uit een gezin met een grootte die
   één persoon verschilt van de grootte van het gezin dat koos voor
   Monopoly.
5. Margaret had als eerste al haar mens-erger-je-niet pionnetjes op de
   goede plaats staan. Bij de familie Donkers werd met 2 personen meer
   of minder gespeeld.

---

van links naar rechts staat er in de puzzel dan:
-------------------------------------------------
Aantal:  |     Spel:              |  Winnaar:
-------------------------------------------------
Twee     |     Levensweg          |  Albert
Drie     |     Mens erger je niet |  Judith
Vier     |     Monopoly           |  Margaret
Vijf     |     Risk               |  Nora
Zes      |     Schaken            |  Roel

en van boven naar onder:
---------------------------------------------------
Achternaam:  |  Winnaar:  |     Spel:
---------------------------------------------------
van Casteren |  Albert    |     Levensweg
Donkers      |  Judith    |     Mens erger je niet
Maas         |  Margaret  |     Monopoly
Weber        |  Nora      |     Risk
Zenden       |  Roel      |     Schaken

(kon het niet voor je in een mooi plaatje maken, dus dan maar zo)

Groeten:
  Stefan.
}

type
  byte_row = array[1..5] of byte;
  word_row = array[1..5] of word;

const

{ Spel: }
  Levensweg : byte = 1;
  Mens_erger_je_niet : byte = 2;
  Monopoly : byte = 3;
  Risk : byte = 4;
  Schaken : byte = 5;

{ Winnaar: }
  Albert : byte = 1;
  Judith : byte = 2;
  Margaret : byte = 3;
  Nora : byte = 4;
  Roel : byte = 5;

{ Gezin / achternaam: }
  van_Casteren : byte = 1;
  Donkers : byte = 2;
  Maas : byte = 3;
  Weber : byte = 4;
  Zenden : byte = 5;

{ Aantal: }
  Twee : byte = 1;
  Drie : byte = 2;
  Vier : byte = 3;
  Vijf : byte = 4;
  Zes  : byte = 5;

var
  gezin_winnaar, winnaar_gezin : byte_row;
  gezin_aantal, aantal_gezin : byte_row;
  gezin_spel, spel_gezin : byte_row;
  winnaar_aantal, aantal_winnaar : byte_row;
  winnaar_spel, spel_winnaar : byte_row;
  aantal_spel, spel_aantal : byte_row;

  fac5, k1, k2, k3 : Longint;
  one, two, i : byte;
  goed : boolean;

procedure permut(L : Longint; n : byte; var r : byte_row);
{
*     Permutations of array r[n]
*     --------------------------
*     L = ordinal number (input)
*     n = number of entries in: (input)
*     r = row of permutations (output)
}
var
  h : Longint;
  k,p,q,s,m,t : byte;
begin
{ Init: }
  h:=1;
  for k := 1 to n do begin
    h:=h*k ; r[k]:=k;
  end;
{ Body: }
  for k := 1 to n do
  begin
    p:=n-k+1;
    h:=h div p;
    q:=(((L-1) div h) mod p)+1;
    if q=1 then Continue;
  { Rotate data: }
    s:=r[k+q-1];
    for m:=1 to q-1 do
    begin
      t:=k+q-m;
      r[t]:=r[t-1];
    end;
    r[k]:=s;
  end;
end;

procedure Oplossing;

type
  string_row = array[1..5] of string;

const
  Aantal : string_row = ('Twee   ','Drie   ','Vier   ','Vijf   ','Zes    ');
   Spel : string_row = (  'Levensweg           ','Mens erger je niet  ',
   'Monopoly            ','Risk                ','Schaken             ');
  Winnaar : string_row = ('Albert          ', 'Judith          ',
      'Margaret        ', 'Nora            ', 'Roel            ');
  Gezin : string_row = ('van Casteren    ', 'Donkers         ',
   'Maas            ',  'Weber           ', 'Zenden          ');

var
  uitkomst : text;

begin
  Assign(uitkomst,'uitkomst');
  Rewrite(uitkomst);
  Writeln;
  for i := 1 to 5 do
  begin
    Writeln(Gezin[i]
    , Aantal[aantal_gezin[i]],'    ',Spel[spel_gezin[i]]
    , Winnaar[winnaar_gezin[i]] );
    Writeln(uitkomst, Gezin[i]
    , Aantal[aantal_gezin[i]],'    ',Spel[spel_gezin[i]]
    , Winnaar[winnaar_gezin[i]] );
  end;
  Close(uitkomst);
end;

{ MAIN program }

begin
  fac5 := 1*2*3*4*5;

{ Het volgende is een absoluut
  toppunt van ondoelmatigheid! }

  for k1 := 1 to fac5 do
    { --------------- }
  begin
    permut(k1,5,gezin_winnaar);

    for i := 1 to 5 do
      winnaar_gezin[gezin_winnaar[i]] := i;

    for k2 := 1 to fac5 do
      { --------------- }
    begin
      permut(k2,5,winnaar_aantal);

      for i := 1 to 5 do
        aantal_winnaar[winnaar_aantal[i]] := i;
      for i := 1 to 5 do
        gezin_aantal[i] := gezin_winnaar[winnaar_aantal[i]];
      for i := 1 to 5 do
        aantal_gezin[gezin_aantal[i]] := i;

      for k3 := 1 to fac5 do
        { --------------- }
      begin
        permut(k3,5,aantal_spel);

        for i := 1 to 5 do
          spel_aantal[aantal_spel[i]] := i;
        for i := 1 to 5 do
          gezin_spel[i] := gezin_aantal[aantal_spel[i]];
        for i := 1 to 5 do
          spel_gezin[gezin_spel[i]] := i;
        for i := 1 to 5 do
          winnaar_spel[i] := winnaar_gezin[gezin_spel[i]];
        for i := 1 to 5 do
          spel_winnaar[winnaar_spel[i]] := i;

      { Hint 1: }
        one := aantal_gezin[gezin_winnaar[Roel]];
        two := aantal_gezin[van_Casteren];
        goed := ((one = Twee) or (one = Vier) or (one = Zes))
            and ((one = two + 1) or (one = two - 1));
        if not goed then Continue;

      { Hint 2: }
        goed := gezin_winnaar[Judith] = Maas;
        if not goed then Continue;
        goed := aantal_spel[Schaken] = Twee;
        if not goed then Continue;
        goed := gezin_spel[Schaken] <> Maas;
        if not goed then Continue;

      { Hint 3: }
        one := aantal_gezin[gezin_winnaar[Nora]];
        two := aantal_gezin[gezin_spel[Risk]];
        goed := (one = two + 1);
        two := aantal_gezin[Zenden];
        goed := goed and (one = two - 1);
        if not goed then Continue;

      { Hint 4: }
        goed := gezin_winnaar[Albert] <> Weber;
        if not goed then Continue;
        one := aantal_gezin[gezin_winnaar[Albert]];
        two := aantal_spel[Monopoly];
        goed := (one = two + 1) or (two = one + 1);
        if not goed then Continue;

      { Hint 4: }
        goed := winnaar_spel[Mens_erger_je_niet] = Margaret;
        if not goed then Continue;
        goed := gezin_winnaar[Margaret] <> Donkers;
        if not goed then Continue;
        one := aantal_winnaar[Margaret];
        two := aantal_gezin[Donkers];
        goed := (one = two + 2) or (two = one + 2);
        if not goed then Continue;

        Oplossing;
{       ---------
        van Casteren    Drie       Mens erger je niet  Margaret        
        Donkers         Vijf       Monopoly            Nora            
        Maas            Vier       Risk                Judith          
        Weber           Twee       Schaken             Roel            
        Zenden          Zes        Levensweg           Albert          
}
      end;
    end;
  end;
end.