Le est intéressant à traiter en "Python" parce qu'il peut se résoudre en manipulant des objets (tableaux et ensembles). Le problème est d'ailleurs intéressant en soi parce qu'il porte sur la logique épistémique. 
Le but du problème est donc d'utiliser les connaissances qu'on a sur les connaissances de Polly et Sam pour savoir si on peut savoir quels sont "x" et "y".
Un Outil.
Pour se faciliter la suite, on va créer une fonction "Python" qui, à chaque somme "n", associe la liste des produits qui ont donné cette somme :
def prod(n):
 p=[]
 for k in range(2,n-2):
 p.append(k*(n-k))
 return p
Alors "prod(8)" donne la liste "[12, 15, 16, 15, 12]" parce que 8 peut s'écrire 2+6, 3+5, 4+4, 5+3 ou 6+2 et que les produits correspondants sont 12, 15 et 16 (certains apparaissant deux fois).
Première affirmation.
L'affirmation apporte une information : Le produit donné à Polly peut s'obtenir de plusieurs manières, sinon Polly connaîtrait les facteurs. Pour exploiter cette information, on va commencer par fabriquer l'énorme liste des produits possibles, puis ne garder que ceux qui apparaissent au moins deux fois dans la liste :
produits=[x*y for y in range(3,100) for x in range(2,y) if x+y<=100]
print(len(produits))
polly=[p for p in produits if produits.count(p)>=2]
print(len(polly))
Ceci dit, il en reste encore pas mal... 
Deuxième affirmation.
Si Sam sait que Polly ne sait pas, c'est parce que quelle que soit la décomposition en somme d'entiers de celui qu'on lui a dicté, le produit correspondant est dans la liste précédente. Sinon Polly aurait pu l'entendre et aurait alors su quels en sont les facteurs. Sam ne va donc garder que les sommes "n" pour lesquelles la liste "prod(n)" calculée avec la fonction ci-dessus ne contient que des éléments de la liste "polly", donc si leur intersection a une longueur maximale (soit "n-4") :
sam=[n for n in range(4,100) if len([p for p in prod(n) if p in polly])==n-4]
print(sam)
Mais le nombre 4 qui apparaît est une erreur, dûe à ce que la liste est vide, donc de longueur 4-4=0. Or 4 ne peut s'écrire que 2+2 et "x" et "y" sont supposés différents. Donc on va plutôt commencer par 5 :
sam=[n for n in range(5,100) if len([p for p in prod(n) if p in polly])==n-4]
print(sam)
On voit alors apparaître la liste des sommes que Sam a pu somme toute ouïr :
"[11, 17, 23, 27, 29, 35, 37, 41, 47, 53]"
Troisième affirmation.
La dernière affirmation de Sam lève toute ambigüité chez Polly. Mais quel genre d'ambiguïté peut-il y avoir encore? Par exemple, un des produits associés à 11 est 30 (car 11=6+5) et 30 est aussi un produit associé à 17 (car 17=15+2). Si le produit 30 avait été confié à Polly, l'ambiguïté en question resterait présente. Polly va donc enlever aux listes "prod(11)", "prod(17)" etc. les doublons. On va donc créer la liste des doublons avec
doublons=[]
for p in sam:
 for q in sam:
 if q<>p:
 doublons+=([r for r in prod(p) if r in prod(q)])
Puis on va enlever à chaque liste des produits (de 11, de 17 etc.) chaque doublon. Si Polly connaît la somme de Sam, c'est parce que dans la liste "sam", il ne restera qu'une liste de produits contenant exactement deux produits (formula_1 et formula_2). Il ne reste alors plus qu'à la chercher pour en savoir autant que Polly :
solutions=[p for p in sam if len([r for r in prod(p) if r not in doublons])==2]
print(solutions)
On connaît donc la somme de Sam.
Quatrième affirmation.
Puisque la somme de Sam vaut 17, on recommence l'étape précédente avec 17 seulement : Chercher la liste des produits de 17, doublons enlevés :
print([r for r in prod(17) if r not in doublons])
On connaît maintenant le produit de Polly.
Recherche de x et y.
Trouver deux nombres dont le produit est 52 et la somme 17 est un problème classique sur les équations du second degré. Mais "Python" permet aussi de les trouver avec une double boucle (puisqu'on sait que ces nombres sont entiers) :
print([(x,y) for y in range(100) for x in range(y) if x+y==17 and x*y==52])
La solution (x,y) apparaît alors entre crochets.

Mathématiques avec Python et Ruby/Freudenthal sous Ruby

Le problème de Freudenthal est intéressant à traiter en "Ruby" parce qu'il peut se résoudre en manipulant des tableaux et ensembles et que pour "Ruby", les tableaux peuvent se manipuler comme des ensembles et "vice-versa". Le problème est d'ailleurs intéressant en soi parce qu'il porte sur la logique épistémique. En voici l'énoncé traduit du Néerlandais à l'Anglais puis au Français:
Le but du problème est donc d'utiliser les connaissances qu'on a sur les connaissances de Polly et Sam pour savoir si on peut savoir quels sont "x" et "y".
Il y a de nombreuses méthodes pour y arriver, et "Ruby" est en quelque sorte un langage "multiparadigme" où chacun peut utiliser sa propre logique (épistémique ou non) pour aborder le problème.
Digression arithmétique.
Si on avait confié un nombre premier à Polly, elle n'aurait pas avoué son impuissance lors de sa première affirmation. Bien que ce ne soit nullement nécessaire pour résoudre ce problème, "Ruby" sait depuis la version 1.9 manipuler des nombres premiers. Avec 
puts(Prime.prime?(p))
on peut savoir si "p" est premier, et avec
puts(Prime.prime_division(n))
on décompose "n" en facteurs premiers.
Les produits à partir des sommes.
Plutôt que de manipuler des couples d'entiers "x" et "y" possibles, on va, comme dans la version Python, manipuler l'ensemble des produits possibles. Donc on aura besoin de l'outil permettant, à partir d'une somme "s" donnée à Sam, d'obtenir la liste "prod(s)" des produits donnés à Polly qui correspondent aux mêmes "x" et "y":
def prod(n)
 t=[]
 (2..n-2).each
Quatrième affirmation.
Puisque Sam sait aussi sa somme, on sait que sa somme est 17 et le produit de Polly, 52:
<syntaxhighlight lang="ruby">
puts(sam[1])
puts(prod(17)-doublons)
À la recherche des x et y perdus.
Maintenant qu'on connaît la somme et le produit de "x" et "y", il reste à déterminer ceux-ci, ce qui peut se faire en résolvant l'équation du second degré formula_1 ou par une double boucle:
Les inconnues "x" et "y" sont maintenant connues!

Mathématiques avec Python et Ruby/Analyse numérique en Python

Fonction.
Dans ce chapitre, on va effectuer des calculs sur la fonction formula_1; on va appeler cette fonction "f". Pour se faciliter la suite, on va créer cette fonction :
def f(x):
 return x**2-5
Résolution numérique d'une équation.
Pour résoudre l'équation "f(x)=0", on cherche un intervalle sur lequel on est certain que "f" s'annule. C'est le cas pour "[1;3]" parce que f(1) est négatif et f(3) est positif. La méthode de dichotomie vise à resserrer un tel intervalle. On constate ci-dessous que la fonction "f" est traitée comme une entrée de l'algorithme au même titre que les bornes "a" et "b" de l'intervalle :
def zero(f,a,b):
 if f(a)*f(b)>0:
 print('pas de solution entre '+str(a)+' et '+str(b)+'!')
 return 0
 while(abs(a-b)>1e-14):
 m=(a+b)/2.
 if f(m)*f(a)>0:
 a=m
 else:
 b=m
 print('la solution de f(x)=0 est '+str(m))
 return m
print(zero(f,1,3))
La résolution de l'équation formula_2 n'est pas terminée, puisque le script ci-dessus n'a donné qu'une seule des deux solutions de cette équation. Par ailleurs, la solution trouvée n'est affichée qu'à formula_3 près.
Calcul numérique de nombre dérivé.
Pour calculer le nombre dérivé de "f" en 5, on va utiliser l'approximation formula_4 :
def NDer(f,a):
 h=1e-10
 return (f(a+h)-f(a-h))/(2*h)
print(NDer(f,5))
Calcul numérique d'une intégrale.
La méthode des rectangles dit que formula_5 où formula_6 et "N" est suffisamment grand pour que "h" soit petit (ci-dessous N=1 000 000) :
def Int(f,a,b):
 h=(b-a)/1000000.0
 somme=0
 for n in range(1000000):
 somme+=h*f(a+n*h)
 return(somme)
print(Int(f,0,2))

Mathématiques avec Python et Ruby/Analyse numérique en Ruby