Méta-énigme : une solution

J’ai fini par résoudre ce problème en utilisant un ordinateur et un programme écrit en Pascal (pourquoi Pascal ? parce que je commence à connaître à force d’en enseigner les bases à mes élèves). Il faut, je pense, préciser l’énoncé en disant que Pierre et Sylvain savent autant que nous que les deux ages inconnus sont compris entre 2 et 100. Introduisons quelques notations : sera l’ensemble des couples d’entiers tels que  :

C’est un ensemble à éléments et la solution est l’un d’entre eux.

• Au début, Pierre, qui connaît le produit , dit ne pas pouvoir déterminer et . Cela signifie qu’il existe un couple , tel que et tel que . Notons l’ensemble des tels qu’il existe , différent de et vérifiant . Autrement dit, est l’ensemble des qui sont compatibles avec la première affirmation de Pierre :

  

  Attention : il ne suffit pas que et soient des nombres composés pour que appartienne à . Par exemple . @Pierre Lecomte : tu n’étais donc pas tout à fait dans le vrai 😉

• Ensuite, Sylvain, qui connaît , dit qu’il savait que Pierre ne pouvait pas déterminer et . Cela signifie que pour tout vérifiant , on a . On notera l’ensemble des couples compatibles avec cette déclaration de Sylvain (et avec la première affirmation de Pierre) :

  

• Pierre affirme ensuite connaître la solution. Comme précédemment, on introduit l’ensemble des couples compatibles avec cette information et les deux précédentes. Je ne détaille pas le raisonnement qui conduit à :

  

• Sylvain conclut en disant qu’il connaît aussi la solution. Notons l’ensemble des compatibles avec les quatre informations, c’est-à-dire l’ensemble des solutions du problème :

  

À présent, ce n’est pas difficile d’écrire un programme qui calcule les ensembles et qui trouve donc les solutions du problème (ce sont les éléments de ). Celui que j’ai écrit contient des fonctions nommées e (resp. e1,e2,e3,e4) qui prennent en entrée un couple et qui renvoient un booléen pour dire si le couple est un élément de l’ensemble (resp. ) ou pas. Je n’ai pas cherché à optimiser le programme, préférant un code plus court et plus lisible à un programme malin; par conséquent, mon code est parfois (très très) idiot, en particulier avec ses «boucles for» à 10000 itérations, toujours exécutées jusqu’au bout même lorsque la première itération fournit la réponse ! Il était demandé de trouver la solution, pas de trouver la solution rapidement 🙂
Voici ce que donne mon programme au bout de plusieurs secondes (voire plusieurs minutes) :

Comme prévu, est de cardinal un : il y a une unique solution. Je ne vais pas vous la donner, ce ne serait pas drôle. Voici juste le programme :

program enigme;
  const min=2;
  const max=100;
  var x,y,c,c1,c2,c3,c4:integer;

  function e(x,y:integer):boolean;
  begin
    e:=(min<=x) and (x<=y) and (y<=max);
  end;

  function e1(x,y:integer):boolean;
    var i,j:integer;
    var b:boolean;
  begin
    if not(e(x,y)) then e1:=false else
    begin
      b:=false;
      for i:=min to max do
      for j:=i to max do
      if (i*j=x*y) and (ix) then b:=true;
      e1:=b;
    end;
  end;

  function e2(x,y:integer):boolean;
    var i,j:integer;
    var b:boolean;
  begin
    if not(e1(x,y)) then e2:=false else
    begin
      b:=true;
      for i:=min to max do
      for j:=i to max do
      if (i+j=x+y) and not(e1(i,j)) then b:=false;
      e2:=b;
    end;
  end;

  function e3(x,y:integer):boolean;
    var i,j:integer;
    var b:boolean;
  begin
    if not(e2(x,y)) then e3:=false else
    begin
      b:=true;
      for i:=min to max do
      for j:=i to max do
      if (i*j=x*y) and e2(i,j) and (ix) then b:=false;
      e3:=b;
    end;
  end;

  function e4(x,y:integer):boolean;
    var i,j:integer;
    var b:boolean;
  begin
    if not(e3(x,y)) then e4:= false else
    begin
      b:=true;
      for i:=min to max do
      for j:=i to max do
      if (x+y=i+j) and e3(i,j) and (ix) then b:=false;
      e4:=b;
    end;
  end;

begin
  for x:=min to max do
  for y:=x to max do
  begin
    c:=c+1;
    if e1(x,y) then
    begin
      c1:=c1+1;
      if e2(x,y) then
      begin
        c2:=c2+1;
        if e3(x,y) then
        begin
          c3:=c3+1;
          if e4(x,y) then
          begin
            c4:=c4+1;
            writeln('Une solution : (',x,',',y,')');
          end;
        end;
      end;
    end;
  end;
  writeln('#E=',c,' #E1=',c1,' #E2=',c2,' #E3=',c3,' #E4=',c4);
end.

---

Pour exécuter ce programme, sous Linux, on crée un fichier, disons enigme.pas, qui contient le code, puis on compile enigme.pas grâce à la commande gpc (GNU Pascal Compiler) :

gpc -o enigme enigme.pas

On obtient un exécutable enigme que l’on peut lancer avec la commande :

./enigme

Et si vous n’avez pas installé gpc, vous pouvez le faire par la commande (sous Debian) :

apt-get install gpc

Comme pour toute installation, c’est l’utilisateur «root» qui doit lancer cette commande. Sous Ubuntu, on peut le faire depuis un compte utilisateur/administateur avec :

sudo apt-get install gpc