Forum

caloubugs

Zou, posté aussi.

Je n'ai pas fait ce qui était prévu (mais une partie qui prend beaucoup de place dans cet article et qui m'a pris pas mal de temps)... Surprise...

Cela dit, je m'attelle à la suite malgré tout pour proposer quelque chose de sympa sur cette reprise d'un vieux programme... (bon, sympa, pas sûr que j'y arrive quand même).

caloubugs

C.Ret a écrit :
bernouilli92 a écrit :Rien ne t'empêche d'initialiser ces registres au début de ton programme.
C'est ce que je fais dans le code suivant.
Après environ une 1/2 heure d'initialisation, 3401 nombres premiers sont mémorisés et utilisés pour tester rapidement(*) tout nombre entier jusqu'à 1'000'000'000

Joli ! En fait c'est la méthode du gros café en attendant que mémère soit prête, ensuite ça carbure...
Par contre c'est sur quelle bécane ? La 1211 ?

caloubugs

Zou, une version en langage machine sur HP71B (je sais, c'est pas du jeu, mais c'est quand même l'aboutissement...).

Rien inventé, c'est le programme PRIMLEX disponible sur les LIF files (bon je ne désespère pas arriver à le faire moi-même un jour.
Il utilise les optimisations prises ici.

Code : Tout sélectionner

        LEX    'PRIMLEX'
        ID     #71
        MSG    0
        POLL   0
POP1N   EQU    #0BD1C   Pop N à tester dans A
TST12A  EQU    #0D476   Teste 2 nombres à 12 chifres virgule flottante
DV2-12  EQU    #0C4A8   Divise ...
CLRFRC  EQU    #0C6F4   <=> INT et carry levé  si FP=0
FLTDH   EQU    #1B223   12 chifres décimal flottant -> HEXA dans A(A)
HDFLT   EQU    #1B31B   Le contraire, de A(A) dans A
MPY     EQU    #0ECBB   A*C en HEXA
HXDCW   EQU    #0ECB4   C(W) HEXA -> décimal
FLOAT   EQU    #1B322   Entier décimal cadré à droite -> 12 chiffres flottant dans A(W)
FNRTN1  EQU    #0F216   Retour
        ENTRY  PRM
        CHAR   #F
        KEY    'PRIM'
        TOKEN  30
        ENDTXT
        NIBHEX 811
PRM     GOSBVL POP1N
        R0=A            N sauvé en R0
        C=0    W        Prépare D, diviseur à tester
        R1=C            D -> R1
        P=     2        Divisible par 2 ?
        GOSUB  TEST
        P=     1        ... par 3 ?
        GOSUB  TEST
        P=     2        ... par 5 ?
        GOSUB  TEST
        P=     2        Etc ...
        GOSUB  TEST
BCL     A=R1            Début test primalité
        GOSBVL FLTDH
        C=0    W
        C=A    A        D en HEXA dans C(A) ...
        A=C    W        ... et A(A)
        SETHEX
        GOSBVL MPY      D^2
        GOSBVL HXDCW
        GOSBVL FLOAT    D^2 en décimal dans A pour le test
        C=R0            N -> C
        ?A=C   W        D^2=N ?
        GOYES  F3       ...oui : N carré parfait
        P=     4        Test >
        GOSBVL TST12A   D^2>N ?
        GOC    FIN2     ...oui : N premier
        P=     4        Boucle évitant les multiples de 2, 3 et 5 parmi les diviseurs
        GOSUB  TEST
        P=     2
        GOSUB  TEST
        P=     4
        GOSUB  TEST
        P=     2
        GOSUB  TEST
        P=     4
        GOSUB  TEST
        P=     6
        GOSUB  TEST
        P=     2
        GOSUB  TEST
        P=     6
        GOSUB  TEST     Fin boucle
        GOTO   BCL
F3      GOTO   FIN3     Saut intermédiaire ( GOC limité à 128 quartets dans chaque sens )
FIN2    C=R0            Retourne le premier ( gag interne... ) diviseur trouvé
        GOVLNG FNRTN1
TEST    C=0    W        Test de divisibilité
        C=P    0
        R2=C            P -> C(0)
        A=R1
        GOSBVL FLTDH    D -> HEXA
        C=A    A
        A=0    W
        A=C    A        Ancien D dans A(A)
        C=R2
        A=A+C  A        Nouveau D
        GOSBVL HDFLT    D en décimal flottant pour sauvegarde
        R1=A
        A=R0            N -> A
        C=R1            D -> C
        GOSBVL DV2-12   A/C et résultat en 15 chiffres sur A-B
        GOSBVL CLRFRC   Lève le carry s'il n'y a pas de FP
        RTNNC           Retour si FP#0 ( N non divisible par D )
FIN1    C=RSTK          Pop le GOSUB en attente
FIN3    C=R1            Retourne N, nombre premier
        GOVLNG FNRTN1
        END

Du coup le programme basic tient sur une seule ligne

Code : Tout sélectionner

INPUT N @ A=TIME @ G=PRIM(N) @ DISP TIME-A;G

Le programme à vide sans le calcul de G prend 0"03...

Du coup on obtient pour les calculs :
1231 : 0"12
71327 : 0"80
123679 : 0"96
1000003 : 3"01
8043509 : 7"69
10000019 : 9"72 (tiens, il aurait battu Bolt cette année)
31629593 : 17"56
998812807 : 1'43"19
999999937 : 1'43"25

Et pour une fois, le ratio sqr(n)/temps baisse avec le nombre (ça doit être la complexité de manipulation de ces nombres et leur stockage en nibbles).

caloubugs

zpalm a écrit : GTO.. compacte la mémoire programme.

Ok merci, le monde de la 41 est un monde à part

caloubugs

Sinon pour le fun

, mais c'est relatif, le programme suivant sur HP39gII :

Code : Tout sélectionner

EXPORT Premier()
BEGIN
INPUT(N);
0►F;RECT();INT(√N)►S;
2►D;IF irem(N,D)=0 THEN D►F; END;
3►D;IF irem(N,D)=0 AND F=0 THEN D►F; END;
5►D;IF irem(N,D)=0 AND F=0 THEN D►F; END;
7►D;IF irem(N,D)=0 AND F=0 THEN D►F; END;
WHILE D<S AND F=0 DO
4+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
2+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
4+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
2+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
4+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
6+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
2+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
6+D►D;IF irem(N,D)=0 THEN D►F;BREAK; END;
END;
IF F THEN
TEXTOUT_P(N,1,1);
TEXTOUT_P("est divisible par",1,15,1,1);
TEXTOUT_P(F,100,15);
ELSE
TEXTOUT_P(N,1,1);
TEXTOUT_P("est premier",1,15,1,1);
END;
FREEZE;
END;

Résultats :
10000019 : 1"5
31629593 : 2"5
999999937 : 11"5
Résultat : 999999937 en 11"5...

Et moins de 2 secondes pour le dernier si on utilise la fonction isprime() intégrée (mais on est hors du sujet

)

caloubugs

zpalm a écrit :
alain1261 a écrit : J'avais des résultats inconstants sur la HP41 (programme plus lent malgré certaines optimisations ) jusqu'à ce que je fasse un GTO.. systématiquement après chaque modification du programme dans la calculatrice.
C'est aussi ce que je fait après chaque modification

Gnééé ?

J'ai du mal à comprendre pourquoi un Goto remet tout en place, c'est sacrément étonnant quand même !

caloubugs

Zou, sur la Z-1GR en basic (me suis fait une frayeur : la bécane a tout d'un coup balancé plein de caractères bizarres à l'écran et n'a plus voulu démarrer. J'ai tout viré, piles et pile de sauvegarde, réinit et ouf ça repart. Du coup une question : un problème avec la mémoire ? ou autre chose ?)

Code : Tout sélectionner

10 INPUT N:TIMER=0:S=SQR(N)
20 D=2:IF N MOD D=0 THEN 100
21 D=3:IF N MOD D=0 THEN 100
22 D=5:IF N MOD D=0 THEN 100
23 D=7:IF N MOD D=0 THEN 100
30 D=D+4:IF N MOD D=0 THEN 100
31 D=D+2:IF N MOD D=0 THEN 100
32 D=D+4:IF N MOD D=0 THEN 100
33 D=D+2:IF N MOD D=0 THEN 100
34 D=D+4:IF N MOD D=0 THEN 100
35 D=D+6:IF N MOD D=0 THEN 100
36 D=D+2:IF N MOD D=0 THEN 100
37 D=D+6:IF N MOD D=0 THEN 100
38 IF D>S THEN D=N ELSE 30
100 PRINT D;TIMER/10

On dispose ici du salvateur Modulo qui fait ses preuves...
1231 : 0"1
71327 : 0"7
1000003 : 2"8
10000019 : 8"5
31629593 : 15"
999999937 : 1'24"4

Ensuite en C interprété, pas évident de repasser en structuré avec tous ces Goto...

Code : Tout sélectionner

main(){
double f,d,n,s;
scanf("%lf",&n);
f=0;s=sqrt(n);
d=2;if(n==d*(int)(n/d)){f=d;}
d=3;if((n==d*(int)(n/d))&&(f==0)){f=d;}
d=5;if((n==d*(int)(n/d))&&(f==0)){f=d;}
d=7;if((n==d*(int)(n/d))&&(f==0)){f=d;}
while((d<s)&&(f==0)){
  d+=4;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=4;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=4;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=6;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  d+=6;if((n==d*(int)(n/d))&&(f==0)){f=d;}
  }
if(f>0){printf("%lf est divisible par %lf",n,f);}
else{printf("%lf est premier",n);}
}

Y'a peut-être mieux, j'ai les neurones qui se touchent avec cette châleur...

Bon là, c'est dommage, j'ai pas le Timer du basic, alors faut se coltiner tout à la mimine :
1231 : <0"5
71327 : 1"
1000003 : 3"5
10000019 : 11"5
31629593 : 20"5
999999937 : 1'57"

Pas terrible, j'ai des problèmes de temps sûrement à cause des cast intempestifs, du coup, je tente en entier long :

Code : Tout sélectionner

main(){
long f,d,n,s;
scanf("%ld",&n);
f=0;s=(int)sqrt(n);
d=2;if(n==d*(n/d)){f=d;}
d=3;if((n==d*(n/d))&&(f==0)){f=d;}
d=5;if((n==d*(n/d))&&(f==0)){f=d;}
d=7;if((n==d*(n/d))&&(f==0)){f=d;}
while((d<s)&&(f==0)){
  d+=4;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=4;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=4;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=6;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=2;if((n==d*(n/d))&&(f==0)){f=d;}
  d+=6;if((n==d*(n/d))&&(f==0)){f=d;}
  }
if(f>0){printf("%ld est divisible par %ld",n,f);}
else{printf("%ld est premier",n);}
}

1231 : <0"5
71327 : <1"
1000003 : 1"5
10000019 : 5"
31629593 : 8"5
999999937 : 47"
Bon ça change tout !!! C'est bien là le problème en C !

D'ailleurs, certains BASIC permettent de définir une variable en entier (à voir, ça peut gagner aussi du temps !)

caloubugs

Pour la Canon X07, l'utilisation de sous-programmes intensifs coute aussi très cher (ça double le temps de réalisation aussi).
Du coup, je verrai pour refaire une version optimisée pour la TI95 (même si je trouve la machine décevante alors qu'on est censé n'avoir que du code machine non ?). Surtout face à la TI74 avec qui elle partage pas mal de hard.

Sympa ton tableau C.Ret, j'ai fait aussi une synthèse avec le ratio sqr(n)/temps dans mon message initial.
Une petite erreur pour la TI95 les 2'06" c'est pour la valeur suivante, elle a mis 1'11" pour 10000019 (mais bon, si je refais le code, ça devrait tomber).

Ca donne pour le X07 :
1231 : 1"
71327 : 3"
1000003 : 11"
10000019 : 36"
31629593 : 1'04"
999999937 : 6'15"

caloubugs

Ythunder a écrit : Vous voudriez pas juste 1 doigt d'abord ?

Oula, pour le dimanche matin... T'attaque fort

caloubugs

alain1261 a écrit :Sans surprise, en utilisant GOSUB, c'est deux fois plus lent.
On pert donc l'avantage de l'algorithme optimisé à cause de la lenteur du GOSUB !

Mouaip, les sauts dans les programmes, c'est pas top pour la rapidité. Dire que les sous-programmes sont faits pour gagner du temps c'est juste côté codage et aussi pour l'espace mémoire. Toute la difficulté sur ces machines est justement de jongler entre les gains horloge et les contraintes précédentes...

Mais 2 fois plus de temps par ce biais, ça fait quand même mal...

caloubugs

C.Ret a écrit : Pour HP-28S, j'avais pensé publier:

Code : Tout sélectionner

MRAs:
« « IF DUP2 MOD NOT THEN KILL END »  → TEST
  « 2 TEST EVAL  1 + TEST EVAL  2 + TEST EVAL  2 + TEST EVAL
    DO
       4 + TEST EVAL  2 + TEST EVAL  4 + TEST EVAL  2 + TEST EVAL  
       4 + TEST EVAL  6 + TEST EVAL  2 + TEST EVAL  6 + TEST EVAL
    UNTIL  DUP2 SQ <  END
    DROP  » »

C'est vrai que la disposition du modulo dans le langage est un sacré avantage et évite de faire une division et une extraction de valeur décimale tout en ayant un contrôle de test super simplifié.

Sinon, si tu t'occupes de la TI74, je m'attaque à la HP71B, la Casio Z-1GR, la PB1000 et le Canon X07 (pas tout en même temps !)

caloubugs

Tipoucet a écrit :Oui 3 doigts suffisent (en principe la touche du 5 est repérée par un petit picot qui dépasse). En effet l'idéal est de ne pas regarder le clavier (c'est très facile en fait, il faut juste "oser" la première fois), et la valeur à taper doit idéalement être cherchée par un coup d'oeil de côté plutôt que de face, le cerveau ne fait pas le même travail (à tester) ...

J'ai eu la chance d'apprendre la dactylo en 2nde au lycée (à l'époque en 1985, quand on prenait option informatique, c'était obligatoire...)
Et je confirme l'intérêt du picot sur le 5 qui permet de repérer la position du majeur sans regarder le clavier : le 1 4 7 c'est pour l'index, 2 5 8 le majeur et le 3 6 9 pour l'annulaire. Le 0 et le reste, ça dépend des machines.
Pour ça d'ailleurs, que je n'arrive pas à composer un numéro facilement sur un téléphone au boulot, tout est inversé (des pervers je vous dis...

)
Par contre, là où je me suis retrouvé le plus "performant", c'est sur les grosse caltos de comptable avec imprimante intégrée et un clavier avec des grosses touches.

Sinon, j'ai peur qu'on arrive à du keydestroygame avec votre défi...

caloubugs

Bon, pour la TI95, en cherchant l'optimisation de zpalm (qui limite le contrôle sur sqr(n) une seule fois par cycle principal, ça gagne 15% en gros !) et en faisant un maximum d'adressages directs sur les numéros de ligne (pas de label) :

Code : Tout sélectionner

000 CMS STO 000 SQR STO 001 2 SBR 068 
012 1 SBR 068 2 SBR 068 2 GTO 0045
024 4 SBR 068 2 SBR 068 4 SBR 068
036 6 SBR 068 2 SBR 068 6 SBR 068
048 4 SBR 068 2 SBR 068 RCL 002 IF> 001
062 GTO 0089 GTO 0024 ST+ 002 
071 RCL 000 / RCL 002 = STO 003 FRC
083 IF= T GTO 0102 RTN RCL 000 'Prime' 
097 COL 16 MRG = HLT RCL 000 / 
106 RCL 003 = 'Div' COL 16 MRG = HLT

Voici quelques temps et j'ai calculé le ratio sqr(n)/temps qui normalement doit converger...
1231 (premier) - 1"5 - r=23.4
71327 (premier) - 7" - r=38.2
123679 (337) - 8" - r=42.1 (je divise 337 par

.
1000003 (premier) - 23" - r=43.5
10000019 (premier) - 1'11" - r=44.5
31629593 (premier) - 2'06" - r=44.6
999999937 (premier) - 11'45" - r=44.9

J'ai constaté un petit temps de latence pour le démarrage d'environ 1/2 seconde au démarrage du programme, ce qui explique aussi l'amélioration progressive de la performance.
C'est quand même pas une bête de course... Je vais faire le test pour la TI74 qui normalement va un peu plus vite.

caloubugs

Et le bonjour à tous les ordipochosaurophiles (je sais c'est un peu capillotracté) !

Je vous propose une variante aux MPO, le MRA (qui pourra pourquoi pas, aboutir au MPROA qui serait la version la plus optimisée et rapide...).

Bref, c'est en tombant sur un article des PPX Exchange sur Texas Instrument (consultable ici) que m'est venue l'envie de vous proposer cela.

Bon, le sujet est d'une incroyable originalité et devrait passionner les foules (oui, j'ose parler de foule), à savoir la détermination de la primalité d'un nombre (oh non ! Encore un vieux truc éculé -> non, non, il n'y a pas de n dans le dernier mot

).

L'intérêt malgré tout de cette optimisation est quand on doit faire de nombreux traitements sur des nombres premiers (style défi Turing ou Projet Euler), et qu'on veut faire tourner nos algorithmes sur nos vieux tromblons, c'est que l'algo soit performant en temps de réalisation.
In fine, un gain parfois minime peut se transformer en plusieurs minutes de gagnées sur la machine.

Du coup, l'algorithme proposé dans l'article ci-dessus (et que j'ai aussi retrouvé dans le programme assembleur qui a été fait sur HP71B et qu'on trouve dans les Lif) s'appuie sur le principe suivant :
Rien de bien compliqué, on prend le crible d'Eratosthène (je ne sais plus où se met le h d'ailleurs) et on se limite aux trois premiers nombres premiers 2, 3 et 5. On regarde ensuite s'il n'y a pas une cyclicité dans le crible, et ô joie et avec grande surprise, elle apparait tous les 30 nombres (2*3*5).
En fait si on regarde bien, les nombres premiers sont toujours à regarder parmis les suivants : 30n-13, 30n-11, 30n-7, 30n-1, 30n+1, 30n+7, 30n+11, 30n+13 (ce qui fait 8 nombres à tester sur 30, après bien entendu avoir testé les nombres 2, 3, 5 et on démarre ensuite à 30n+7 avec n=0).

Enfin, pour tester un nombre x et voir s'il est premier, il faut donc vérifier s'il est divisible par 2, 3, 5 et par un des nombres de la précédente liste en s'arrêtant à sqr(x).
On retourne alors soit x si le nombre est premier ou le premier diviseur de x.

Je vous propose donc une course de vitesse, rien ne vous empêche d'améliorer l'algo proposé bien au contraire c'est bien le but du jeu (l'implémentation qui en est faite est d'ailleurs déjà largement améliorable, j'en proposerai une version sur TI95).
Le programme doit donc, à partir d'un nombre saisi, renvoyer soit ce nombre s'il est premier, soit son premier diviseur.

Le problème est bien sûr de comparer les perfs entre machines différentes, on pourra toujours faire un tableau des perfs (si en fait ça intéresse au moins quelqu'un, sinon snif, je repartirai tout seul bouder dans mon coin avec mon chrono). L'idéal aussi est d'utiliser, si disponible, les horloges internes (même si parfois, on n'est qu'à la seconde près). Ca pourrait donner aussi quelques benchmarks sympa pour nos machines (je ne dis pas que le sujet est forcément sympa là...

)

Bref, sortez vos montres au 1/100e (sauf pour la HP15c, à la minute près suffira

) et bonne optimisation...

Sommaire des MPO
-------------------------------
Résumé des perfs (en prenant le ratio le plus élevé sur les calculs effectués entre la racine carrée du nombre et le temps mis pour le déterminer premier) :

Code : Tout sélectionner

gege      - Casio Graph 85 : 562 (soit environ 150 tests de division / s)
          - PB700 : 13,1 (3,5)          *
          - PB100 : 71 (19)             **
C.Ret     - C128D : 381 (102)           **************************************
          - TI74 : 111 (30)             ***********
          - HP28S : 177 (47)            ******************
          - HP41C : 20,8 (5,5)          **
zpalm     - HP41CX : 24,8 (6,5)         **
          - HP29E : 11,5 (3)            *
          - HP15CLE : 810 (216)         *********************************************************************************
alain1261 - PB100 : 75 (20)             *******
          - Fx702p : 17,2 (4,5)         **
caloubugs - TI95 : 45 (12)              *****
          - X07 : 88 (23,5)             *********
          - Z-1GR Basic : 375 (100)     **************************************
          - Z-1GR C : 673 (179)         *******************************************************************
          - HP39gII : 2750 (733)        XXX
          - HP71B Assembleur : 333 (89) *********************************
          - PSION 5MX : 71870 (19200)   XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
          - PB-1000 : 95 (25)           **********
          - FX-880P : 126 (34)          *************
          - PC-1403 : 32 (9)            ***

caloubugs

Ben dites voir les gars, que de passion dans tout ça...

Perso, y'a deux choses importantes à mes yeux sur le choix d'un pocket/calto :
-> le bricolage limité : n'étant pas rompu aux charmes du fer à souder et aux réparations électroniques, j'ai laissé tomber les caltos à diodes et leurs accus qui coulent. Pourtant, je voulais une 58C... Du coup, j'ai enfin pu choper une Ti95 Procalc qui est plutôt marrante à utiliser (et là, c'est de la bonne LR03 en piles). J'y viendrai peut-être quand même, les TI5x, c'est un monument...
-> les possibilités de raccordement à un PC : si on veut bidouiller du code, c'est bien aussi de pouvoir le conserver, le sécuriser, voire le reprendre sur grand écran. On trouve de plus en plus de fondus de l'électronique et qui me laissent une admiration sans voix (sans compter ceux qui arrivent à décrypter les ROM pour en faire des émulateurs) qui vous montent des systèmes de raccordement (style Pilbox). Perso, taper du code sur des minis-claviers pour ensuite tout paumer pour faire autre chose, ça lasse aussi. Et les systèmes de sauvegardes vintage, c'est pas toujours évident de les choper, c'est souvent dédié à une machine, et je ne me revois pas faire des sauvegardes façon TRS80 du début des années 80 avec mon lecteur cassette et la HiSpeed à 1500 bauds (et le joli son qui va avec

). Bon ça a son charme dira-t-on, surtout quand la cassette se détériore dans le lecteur... Petite remarque d'ailleurs, mon TRS80 Model III, je l'ai depuis plus de 30 ans et il fonctionne toujours...

Mais bon, quand on a un coup de coeur, tout est bon pour l'obtenir...

Enfin, côté WAF, ma chère et tendre est plutôt au niveau 0... Mais elle préfère largement me voir passer du temps avec mes tromblons qu'elle ne m'a jamais vu acheter que de glandouiller sur un quelconque écran informatique (de l'acquisition obscure quoi !

Je vous parle pas du budget pour ma 71B, avec le module Assembleur/Forth et 3 modules de 32ko, elle en aurait fait une jaunisse. Hem, c'est l'avantage de tenir les comptes à la maison

).

D'ailleurs, ce que je retiens de la 71B et d'autres depuis : on a la machine et après, on se retrouve à chercher des extensions pour mettre dessus, de la mémoire en plus... C'est ça qui est sympa aussi, y'a pas que l'acquisition brute, y'a la suite !

Voilou, pour quelques retours d'un jeune collectionneur (jeune sur la durée de la collection, sinon...), ça fait 2 ans que je suis tombé dedans... Et plus ça vient...

Forum

433 résultats trouvés

Re: La Gazette n°6, c'est dans 2 semaines !

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Test d'habileté à la frappe d'additions

Re: Misez rapide, accélérez n°1

Re: Misez rapide, accélérez n°1

Re: Test d'habileté à la frappe d'additions

Re: Misez rapide, accélérez n°1

Misez rapide, accélérez n°1

Re: Commencer en pocket