slight review of queens

Author: parmentelat

notebooks/tps/queens/.teacher/README-queens-corrige-nb.md

@@ -1,10 +1,6 @@
 ---
 jupytext:
-  cell_metadata_filter: all,-hidden,-heading_collapsed,-run_control,-trusted
   encoding: '# -*- coding: utf-8 -*-'
-  notebook_metadata_filter: all, -jupytext.text_representation.jupytext_version, -jupytext.text_representation.format_version,
-    -language_info.version, -language_info.codemirror_mode.version, -language_info.codemirror_mode,
-    -language_info.file_extension, -language_info.mimetype, -toc
   text_representation:
     extension: .md
     format_name: myst
@@ -70,24 +66,31 @@ test_rooks_and_queens.py ...                                                  [1
 ================================ 3 passed in 14.19s =================================
 ```
 
-mais bien sûr d'ici là, n'hésitez pas à lancer votre code interactivement et le debugger, soit dans ce notebook, soit dans ipython, etc..
+```{admonition} il faut débugger avant de tester !
+:class: important
+
+MAIS BIEN SÛR avant de lancer les tests, il est ***impératif** d'avoir d'abord lancé votre code interactivement, et de l'avoir débuggé - que soit dans le notebook ou dans ipython
+```
 
 +++
 
+````{admonition} l'autoreload
+:class: danger
+
 il y a toutefois une précaution à prendre si vous travaillez comme ceci  
-en effet l'import d'un module est **caché** par Python, ce qui fait que par défaut, les changements que vous faites dans fichier `rooks_and_queens.py` ne sont plus rechargés après le premier import
+en effet l'import d'un module est **caché** par Python, ce qui fait que par défaut, les changements que vous faites dans fichier `rooks_and_queens.py` ne sont **plus rechargés après le premier import**
 
 pour vous installer confortablement, voyez ce lien:  
-<https://flotpython-exos-python.readthedocs.io/en/main/README.html#note-on-autoreload-in-ipython-or-notebooks>
+https://ue12-p24-intro.readthedocs.io/en/main/1-01-installations-nb.html#configuration-de-l-autoreload
+````
 
 +++
 
 ## les tours
 
 +++
 
-on se place sur un échiquier de taille $n \times n$
-
+on se place sur un échiquier de taille $n \times n$  
 on cherche à écrire un générateur qui énumère **les positions de $n$ tours** qui ne se menacent pas les unes les autres
 
 +++
@@ -106,7 +109,7 @@ c'est ainsi qu'on va représenter une position, comme par exemple celle-ci
 :align: center
 ```
 
-par le tuple `(0, 4, 1, 2, 3)` qui donne les coordonnées en Y dans les colonnes successives (ici le dessin est fait avec matplotlib, du coup les Y sont descendants, l'orientation n'a pas d'importance)
+par le tuple `(0, 4, 1, 2, 3)` qui donne les coordonnées en Y dans les colonnes successives (ici le dessin est fait avec matplotlib, du coup les Y sont descendants, mais l'orientation n'a pas vraiment d'importance)
 
 ```{code-cell} ipython3
 # prune-cell
@@ -142,16 +145,16 @@ next(r3)
 ```
 
 ```{code-cell} ipython3
-# on a déjà consommé 3 des 6 positions :
-# si on fait une boucle for on ne voit plus que les 3 dernières
+# on a déjà consommé 3 des 6 positions; du coup ...
+# si maintenant on fait une boucle for on ne voit plus que les 3 dernières !
 
 for position in r3:
     print(position)    
 ```
 
 ### à quoi ça ressemble ?
 
-il ne vous aura pas échappé que le problème est équivalent à énumérer les permutations de $n$ (et c'est d'ailleurs pour ça qu'on peut se permettre de retourner une liste d'entiers, et non pas des tuples)
+il ne vous aura pas échappé que le problème est équivalent à énumérer les permutations de $n$ (et c'est d'ailleurs pour ça qu'on choisit de retourner une liste d'entiers, et non pas des tuples)
 
 donc du coup on pourrait faire tout simplement
 
@@ -202,21 +205,16 @@ for p in queens(6):
 #    ...
 ```
 
-+++ {"tags": ["level_intermediate"]}
-
-## pour les rapides
-
-cette partie est optionnelle
-
-+++
-
 ### calculer la taille (longueur) d'un générateur
 
 on ne peut pas utiliser `len()` sur un générateur (pourquoi ?)  
 comment feriez-vous pour calculer le nombre d'éléments dans un générateur ?
 
 ```{code-cell} ipython3
 # écrivez generator_size
+# ATTENTION quand même à NE PAS créer une liste dans ce code
+# car comme résultat on veut un entier hein
+# pas besoin de consommer toute la mémoire de l'ordi pour ça hein !
 
 from rooks_and_queens import generator_size
 generator_size(queens(8))
@@ -226,7 +224,7 @@ generator_size(queens(8))
 
 +++
 
-si vous avez fini avant tout le monde, dessinez les résultats avec numpy.imshow, ou autre outil de visualisation
+si vous avez fini avant tout le monde, dessinez les résultats avec `numpy.imshow`, (ou autre outil de visualisation de votre choix)
 
 ```{code-cell} ipython3
 %matplotlib inline
@@ -241,13 +239,32 @@ for p in queens(4):
 ```
 
 ```{code-cell} ipython3
+:scrolled: true
+
 for p in queens(6):
     draw_position(p)
 ```
 
++++ {"tags": []}
+
+## fin de la partie obligatoire
+
+jusqu'ici c'est plutôt facile - ou court en tous cas; pour info ma correction tient en
+
+- 7 lignes pour `rooks`
+- 7 lignes pour `queens`
+- 2 lignes pour `generator_size`
+- `draw_position` est - de manière contrintuitive - bien plus long
+  il faut dire que je suis passé par deux fonctions pour traduire entre les tuples d'entiers et le tableau numpy;
+  en fait une seule aurait suffi, mais pour la suite j'ai tiré profit des deux
+ 
+la partie qui suit est intéressante aussi, et pas tellement plus longue en fait (13 lignes pour `uniques` dans mon cas), n'hésitez pas à vous y essayer aussi.
+
++++
+
 ### éliminez les symétries
 
-plus dur, éliminez les symétries et rotations
+(un tout petit peu) plus dur, éliminez les symétries et rotations
 
 il y a plein de façons d'envisager la question, idéalement on doit pouvoir écrire un itérateur `uniques` qu'on pourra en quelque sorte chainer avec les deux algorithmes qu'on vient d'écrire
 
@@ -257,15 +274,16 @@ from rooks_and_queens import uniques
 ```
 
 ```{code-cell} ipython3
-# comme vous pouvez le voir plus haut, les solutions de queens(6)
-# sont toutes les mêmes mais tournées à chaque fois d'1/4 de tour
+# en fait les 4 solutions de queens(6) sont toutes les mêmes
 # aussi quand on passe par uniques() il n'en reste qu'une
+
 for p in uniques(queens(6)):
     draw_position(p)
 ```
 
 ```{code-cell} ipython3
 # en dimension 5 curieusement il y en a plus que pour n=6
+
 for p in uniques(queens(5)):
     draw_position(p)
 ```
@@ -277,3 +295,11 @@ for p in uniques(queens(5)):
 
 generator_size(uniques(rooks(5)))
 ```
+
+```{code-cell} ipython3
+# et dans le cas de l'échiquier "normal"
+# voici à peu près la performance que vous pouvez obtenir
+# sans trop chercher à optimiser...
+
+%timeit generator_size(uniques(rooks(8)))
+```

notebooks/tps/queens/.teacher/rooks_and_queens.py

@@ -0,0 +1 @@
+../rooks_and_queens.py

notebooks/tps/queens/ARTEFACTS-queens.zip

@@ -66,24 +66,31 @@ test_rooks_and_queens.py ...                                                  [1
 ================================ 3 passed in 14.19s =================================
 ```
 
-mais bien sûr d'ici là, n'hésitez pas à lancer votre code interactivement et le debugger, soit dans ce notebook, soit dans ipython, etc..
+```{admonition} il faut débugger avant de tester !
+:class: important
+
+MAIS BIEN SÛR avant de lancer les tests, il est ***impératif** d'avoir d'abord lancé votre code interactivement, et de l'avoir débuggé - que soit dans le notebook ou dans ipython
+```
 
 +++
 
+````{admonition} l'autoreload
+:class: danger
+
 il y a toutefois une précaution à prendre si vous travaillez comme ceci  
-en effet l'import d'un module est **caché** par Python, ce qui fait que par défaut, les changements que vous faites dans fichier `rooks_and_queens.py` ne sont plus rechargés après le premier import
+en effet l'import d'un module est **caché** par Python, ce qui fait que par défaut, les changements que vous faites dans fichier `rooks_and_queens.py` ne sont **plus rechargés après le premier import**
 
 pour vous installer confortablement, voyez ce lien:  
-<https://flotpython-exos-python.readthedocs.io/en/main/README.html#note-on-autoreload-in-ipython-or-notebooks>
+https://ue12-p24-intro.readthedocs.io/en/main/1-01-installations-nb.html#configuration-de-l-autoreload
+````
 
 +++
 
 ## les tours
 
 +++
 
-on se place sur un échiquier de taille $n \times n$
-
+on se place sur un échiquier de taille $n \times n$  
 on cherche à écrire un générateur qui énumère **les positions de $n$ tours** qui ne se menacent pas les unes les autres
 
 +++
@@ -102,7 +109,7 @@ c'est ainsi qu'on va représenter une position, comme par exemple celle-ci
 :align: center
 ```
 
-par le tuple `(0, 4, 1, 2, 3)` qui donne les coordonnées en Y dans les colonnes successives (ici le dessin est fait avec matplotlib, du coup les Y sont descendants, l'orientation n'a pas d'importance)
+par le tuple `(0, 4, 1, 2, 3)` qui donne les coordonnées en Y dans les colonnes successives (ici le dessin est fait avec matplotlib, du coup les Y sont descendants, mais l'orientation n'a pas vraiment d'importance)
 
 +++
 
@@ -133,16 +140,16 @@ next(r3)
 ```
 
 ```{code-cell} ipython3
-# on a déjà consommé 3 des 6 positions :
-# si on fait une boucle for on ne voit plus que les 3 dernières
+# on a déjà consommé 3 des 6 positions; du coup ...
+# si maintenant on fait une boucle for on ne voit plus que les 3 dernières !
 
 for position in r3:
     print(position)    
 ```
 
 ### à quoi ça ressemble ?
 
-il ne vous aura pas échappé que le problème est équivalent à énumérer les permutations de $n$ (et c'est d'ailleurs pour ça qu'on peut se permettre de retourner une liste d'entiers, et non pas des tuples)
+il ne vous aura pas échappé que le problème est équivalent à énumérer les permutations de $n$ (et c'est d'ailleurs pour ça qu'on choisit de retourner une liste d'entiers, et non pas des tuples)
 
 donc du coup on pourrait faire tout simplement
 
@@ -193,21 +200,16 @@ for p in queens(6):
 #    ...
 ```
 
-+++ {"tags": ["level_intermediate"]}
-
-## pour les rapides
-
-cette partie est optionnelle
-
-+++
-
 ### calculer la taille (longueur) d'un générateur
 
 on ne peut pas utiliser `len()` sur un générateur (pourquoi ?)  
 comment feriez-vous pour calculer le nombre d'éléments dans un générateur ?
 
 ```{code-cell} ipython3
 # écrivez generator_size
+# ATTENTION quand même à NE PAS créer une liste dans ce code
+# car comme résultat on veut un entier hein
+# pas besoin de consommer toute la mémoire de l'ordi pour ça hein !
 
 from rooks_and_queens import generator_size
 generator_size(queens(8))
@@ -217,7 +219,7 @@ generator_size(queens(8))
 
 +++
 
-si vous avez fini avant tout le monde, dessinez les résultats avec numpy.imshow, ou autre outil de visualisation
+si vous avez fini avant tout le monde, dessinez les résultats avec `numpy.imshow`, (ou autre outil de visualisation de votre choix)
 
 ```{code-cell} ipython3
 %matplotlib inline
@@ -232,13 +234,32 @@ for p in queens(4):
 ```
 
 ```{code-cell} ipython3
+:scrolled: true
+
 for p in queens(6):
     draw_position(p)
 ```
 
++++ {"tags": []}
+
+## fin de la partie obligatoire
+
+jusqu'ici c'est plutôt facile - ou court en tous cas; pour info ma correction tient en
+
+- 7 lignes pour `rooks`
+- 7 lignes pour `queens`
+- 2 lignes pour `generator_size`
+- `draw_position` est - de manière contrintuitive - bien plus long
+  il faut dire que je suis passé par deux fonctions pour traduire entre les tuples d'entiers et le tableau numpy;
+  en fait une seule aurait suffi, mais pour la suite j'ai tiré profit des deux
+ 
+la partie qui suit est intéressante aussi, et pas tellement plus longue en fait (13 lignes pour `uniques` dans mon cas), n'hésitez pas à vous y essayer aussi.
+
++++
+
 ### éliminez les symétries
 
-plus dur, éliminez les symétries et rotations
+(un tout petit peu) plus dur, éliminez les symétries et rotations
 
 il y a plein de façons d'envisager la question, idéalement on doit pouvoir écrire un itérateur `uniques` qu'on pourra en quelque sorte chainer avec les deux algorithmes qu'on vient d'écrire
 
@@ -248,15 +269,16 @@ from rooks_and_queens import uniques
 ```
 
 ```{code-cell} ipython3
-# comme vous pouvez le voir plus haut, les solutions de queens(6)
-# sont toutes les mêmes mais tournées à chaque fois d'1/4 de tour
+# en fait les 4 solutions de queens(6) sont toutes les mêmes
 # aussi quand on passe par uniques() il n'en reste qu'une
+
 for p in uniques(queens(6)):
     draw_position(p)
 ```
 
 ```{code-cell} ipython3
 # en dimension 5 curieusement il y en a plus que pour n=6
+
 for p in uniques(queens(5)):
     draw_position(p)
 ```
@@ -268,3 +290,11 @@ for p in uniques(queens(5)):
 
 generator_size(uniques(rooks(5)))
 ```
+
+```{code-cell} ipython3
+# et dans le cas de l'échiquier "normal"
+# voici à peu près la performance que vous pouvez obtenir
+# sans trop chercher à optimiser...
+
+%timeit generator_size(uniques(rooks(8)))
+```

notebooks/tps/queens/README-queens-nb.md

@@ -92,6 +92,9 @@ def generator_size(gen):
     return sum(1 for _ in gen)
 
 
+# in this part we call
+# - position a tuple of ints
+# - np a numpy array
 
 import numpy as np