Discussion :

[valentin03]

Bonjour,
Voici une table de multiplication colorée qui en pur procédural prend plus de 200 lignes.
Quelqu'un aurait-il une idée pour en faire un algorithme ?

[vttman]

on peut avoir un extrait du pur procédural ?

[valentin03]

on peut avoir un extrait du pur procédural ?

Bah en pur procédural on génère et affiche les cases une par une avec quatre attributs de position et un attribut de couleur. Une case = Une ligne de code
Est-il envisageable de faire un algo se servant des variables de boucles, autant pour la localisation que pour les couleurs mises en tableau ?
Un seul algo et un seul passage.

[tbc92]

-1- J'imagine que tu veux faire cela en VBA, et colorier les premières lignes // Premières colonnes d'une feuille Excel.
-2- Logiquement, la cellule (a,b) et la cellule (b,a) devraient avoir la même couleur, et cette couleur ( color, ou colorindex ...) pourrait être le produit de la multiplication a*b ?
-3- Dans les colonnes, les n° vont de 1 à 9, mais tu as 18 colonnes ... c'est volontaire ? On gère les demi-entiers ?

Une fois ces points éclaircis, ça pourrait ressembler à ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
nb_couleurs_palette = 40
for lig = 2  to 11
  lig0 = lig-1 
  for col = 2 to 11 
      col0 = col-1
      multiplication = lig0 * col0
      color_index = mod( multiplication, nb_couleurs_palette) +1
      cells(lig,col)..colorindex = color_index
  next col
next lig

Et reste à traiter les lignes d'entête (ligne 1 et colonne 1).

[vttman]

En repassant et entre () ...
Bon la table est colorée mais pas vraiment au hasard
En regroupant les colonnes "paires" et "impaires" pour former des carrés
ça fait bien ressortir le coté symétrique

[anapurna]

salut

tu as combien de couleurs ?

donc on a 10 lignes et 20 colonnes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
 
 Pour Col de 0 a 9 Faire
   Pour Lig de 0 a 9 Faire
        Mult =  ((Col*2)+1)*(Lig+1)
        Coul =  Mod(Mult,NbColor) 
        Cellule[Lig,(Col*2)] = Coul
        // La deuxieme col
        Mult =  ((Col*2)+2)*(Lig+1)
        Coul =  Mod(Mult,NbColor) 
        Cellule[Lig,(Col*2)+1] = Coul
   FinPour   
 FinPour

[valentin03]

salut
tu as combien de couleurs ?
donc on a 10 lignes et 20 colonnes

@ tbc92: Le système de représentation oblige à considérer les chiffres de base sur deux digits, puisque les résultats peuvent êtres sur deux digits. Pas question de stocker les résultats (2 couleurs) dans une "palette", il faut qu'ils soient générés par l'algo.
@ anapurna: Il y a 10 couleurs. Tu propose de gérer chaque colonne séparément (un algo par colonne (ou par ligne, c'est équivalent))
Le challenge est de ne faire qu'un seul algo (bloucles imbriquées)
Le problème, c'est bien les ligne et colonne d'en-tête, mais qui doivent êtres gérables en maîtrisant les incrémentations (avec des retours arrières).
@ vttman: les couleurs ne sont pas disposées au hasard, c'est une table de multiplication, mais en approche Cobol, il faut s'attendre à tout.

[wiwaxia]

Bonsoir,

Vous avez sous les yeux une table de multiplication des entiers de 0 à 9, écrits sur deux cases horizontales (00, 01, 02, 03 ... 09), l'ensemble occupant une matrice rectangulaire à 10 lignes et 20 colonnes.
La correspondance entre chiffres et couleurs est donnée par la deuxième colonnes à gauche (j = 2):


J'incline à penser que l'auteur du programme est valentin03 . Mais ce qui m'étonne vraiment, c'est sa longueur !

... Voici une table de multiplication colorée qui en pur procédural prend plus de 200 lignes ...
... Quelqu'un aurait-il une idée pour en faire un algorithme ?

Je suis trop bon. Voici comment construire la matrice d'entiers, en recourant aux deux boucles imbriquées auxquelles valentin03 tient tant; vous êtres assez grands pour vous charger du coloriage .
L'utilisation d'Excell suggérée par Tbc92 est en soi intéressante, et j'aimerais connaître les instructions de coloration.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
  PROGRAM XXX;

  USES CRt;

  TYPE Tab1020 = ARRAY[0..9, 0..19] OF Byte;

  VAR Mat: Tab1020;

  PROCEDURE AffC;
    CONST CodeC: ARRAY [0..9] OF Word = (00, 04, 12, 06, 14,
                                         10, 11, 05, 08, 15);
    VAR c, i, j, y: Byte; Icoul: Word;
    BEGIN
      FOR i:= 0 TO 9 DO
        BEGIN
          y:= i + 30;       c:= Mat[i, 0]; Icoul:= CodeC[c];
          TextColor(Icoul); GotoXY(31, y); Write('Û');
          FOR j:= 1 TO 19 DO
            BEGIN
              c:= Mat[i, j];    Icoul:= CodeC[c];
              TextColor(Icoul); Write('Û')
            END
        END;
      ReadLn
    END;

  PROCEDURE AffM;
    VAR i, j, x, y: Byte;
    BEGIN
      TextColor(14); TextBackGround(1); ClrScr;
      FOR i:= 0 TO 9 DO
        BEGIN
          y:= 2 * i; Inc(y, 5);
          FOR j:= 0 TO 19 DO
            BEGIN
              x:= 3 * j; Inc(x, 10); GotoXY(x, y); Write(Mat[i, j]:3)
            END;
        END
    END;

  PROCEDURE InitM(VAR M_: Tab1020);
    VAR i, j, k, p, u, v: Byte;
    BEGIN
      FOR i:= 0 TO 9 DO
        FOR j:= 0 TO 9 DO
          BEGIN
            IF (i=0) THEN p:= j
                     ELSE IF (j=0) THEN p:= i
                                   ELSE p:= i * j;
            u:= p MOD 10; v:= p DIV 10;
            k:= 2 * j; M_[i, k]:= v; M_[i, k + 1]:= u;
          END
    END;

  BEGIN
    InitM(Mat); AffM; AffC;
  END.

Le résultat du programme:

La palette disponible sur le traitement de texte n'est pas emballante:

PS: il y a un piège numérique, dans lequel je suis tombé : les valeurs lues sur les premières ligne et double colonne ne sont pas des produits.

[anapurna]

salut

je viens de comprendre ce que voulais valentin
pas simple a dechiffrer c'est les deux digit qui mon mis sur la voie

votre table de multiplication est fausse ou ce n'est pas une multiplication pur

0*0 = 0
0*x = 0 donc toute la ligne et les deux premiere colone doivent etre noir ( 0)

9*9 = 81 => 8 et 1

	0	0	0	1	0	2	0	3	0	4	0	5	0	6	0	7	0	8	0	9
0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	0	1	0	2	0	3	0	4	0	5	0	6	0	7	0	8	0	9
2	0	0	0	2	0	4	0	6	0	8	1	0	1	2	1	4	1	6	1	8
3	0	0	0	3	0	6	0	9	1	2	1	5	1	8	2	1	2	4	2	7
4	0	0	0	4	0	8	1	2	1	6	2	0	2	4	2	8	3	2	3	6
5	0	0	0	5	1	0	1	5	2	0	2	5	3	0	3	5	4	0	4	5
6	0	0	0	6	1	2	1	8	2	4	3	0	3	6	4	2	4	8	5	4
7	0	0	0	7	1	4	2	1	2	8	3	5	4	2	4	9	5	6	6	3
8	0	0	0	8	1	6	2	4	3	2	4	0	4	8	5	6	6	4	7	2
9	0	0	0	9	1	8	2	7	3	6	4	5	5	4	6	3	7	2	8	1

voici la matrice sans les entete ni les numero de colone

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
  00 00 00 00 00 00 00 00 00 00
  00 01 02 03 04 05 06 07 08 09
  00 02 04 06 08 10 12 14 16 18  
  00 03 06 09 12 15 18 21 24 27
  00 04 08 12 16 20 24 28 32 36
  00 05 10 15 20 25 30 35 40 45 
  00 06 12 18 24 30 36 42 48 54
  00 07 14 21 28 35 42 49 56 63
  00 08 16 24 32 40 48 56 64 72
  00 09 18 27 36 45 54 63 72 81

un fois que l'on a compris la matrice que l'on veut obtenir le reste n'est qu'une formalité

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
Procedure rempliMatrice
const 
  NbColor = 10;
Begin
   For Col := 0 to 9 do
   begin
     For Lig := 0 to 9 do
     begin
        index  = Col*Lig
        Cellule[Lig,(Col*2)]     =  index DIV NbColor; // La division entiere      (max : 9*9 = 81 => 8)
        Cellule[Lig,(Col*2)+1]  =  index Mod NbColor;// Le reste de la division (max 9)
     end;
  end;
end;

[tbc92]

Bravo Anapurna.
J'arrivais à la même conclusion : La seule difficulté est de comprendre la question.
Et tu y es parvenu ! Bel effort.

[valentin03]

@: wiwaxia: C'est efficient mais il y a trois algos.
Je prends le dernier et vais tenter d'y intégrer les premières lignes-colonnes; je n'avais pas pensé au MOD qui est plus élégant que le traitement par chaîne (partie gauche-partie droite) dans lequel je m'étais lancé.
Pour la longueur de mon code: 10 x 20 = 200 + les accessoires...
Je ne pense pas que ton code soit du niveau CM2.

@: anapurna: Il n'y a pas de multiplications par zéro.
Mais ton truc est bien compact; je vais le bûcher aussi.[suspicion:ON] reste à savoir si la matrice est le fruit de l'algo [suspicion:OFF]
Merci à vous deux

@: tbc92: La difficulté est toujours de comprendre la question, tu le sais bien...
La question était: Est-il possible de faire la même chose avec un seul algo ?

[anapurna]

salut ,

bon reprenons
je site

Bonjour,
Voici une table de multiplication colorée qui en pur procédural prend plus de 200 lignes.
Quelqu'un aurait-il une idée pour en faire un algorithme ?

je regarde les abscisses et les ordonnées
que vois je 0 et tu me dis apres qu'il n'y as pas de multiplication par zero ???
chez moi 0*x = 0 et x * 0 = 0
donc ta première ligne et les deux premières colonnes devrais être à zéro
en regardant de plus prés on s’aperçoit que tu as ajouté la valeur de la ligne
ce n'est plus une table de multiplication
a priori pour les première colonne et ligne tu fait

(LIG*COL) + LIG

et/ou

(LIG*COL) + COL

mais le principe reste le même
tu calcul ton indice et ensuite tu cherche le diviseur entier et le reste afin de constituer les valeurs deux cellules contigu

[vttman]

...
@ vttman: les couleurs ne sont pas disposées au hasard, c'est une table de multiplication, mais en approche Cobol, il faut s'attendre à tout.

Je n'ai pas mis de -1 mais je n'en pense pas moins
En tout cas sujet intéressant ...

[wiwaxia]

@: wiwaxia: C'est efficient mais il y a trois algos ...

Le programme comporte trois procédures, dont la plus importante est l'initialisation de la matrice (InitM(Mat)); c'est là qu'intervient l'algorithme dont on discute.

L'affichage des éléments de la matrice numérique (AffM) permet de s'assurer du bon fonctionnement du code précédent.

Quant à l'affichage des couleurs (AffC), il est tout à fait anecdotique, et permet simplement de vérifier la conformité du résultat à l'image initiale que tu avais donnée. Il ne saurait rivaliser avec les logiciels graphiques.

[valentin03]

@: anapurna: En fait, je n'aurais pas dû mettre les chiffres arabes, les premières lignes-colonnes en tiennent lieu; mais je craignais que les "trous noirs" posent trop de questions.
La question qui était derrière la question, c'était: Comment gérer dans un seul algo la rupture de raisonnement entre les premières lignes-colonne et le reste; c'est pourquoi je n'ai pas tracé de lignes de séparation (qui dans une table conventionnelle y seraient)
Ta façon d'intégrer la première ligne dans la boucle va me laisser perplexe un bon moment, et ce n'est pas ton: "(LIG*COL) + LIG" qui me rassure.

[wiwaxia]

... Voici une table de multiplication colorée ...

... ce qui ne veut pas dire, au sens strict, que tous les termes sont des produits - j'ai fait initialement cette confusion.



Il n'y a pas de multiplication par zéro, qui aurait d'ailleurs entraîné la présence d'une marge noire inutile.
Ce qui induit en erreur, c'est la présence de '00' au coin supérieur gauche.

Il faut prendre le sujet tel qu'il est: un simple jeu algorithmique, le codage des couleurs d'une grille.

[anapurna]

Salut

@: anapurna: En fait, je n'aurais pas dû mettre les chiffres arabes, les premières lignes-colonnes en tiennent lieu; mais je craignais que les "trous noirs" posent trop de questions.
La question qui était derrière la question, c'était: Comment gérer dans un seul algo la rupture de raisonnement entre les premières lignes-colonne et le reste; c'est pourquoi je n'ai pas tracé de lignes de séparation (qui dans une table conventionnelle y seraient)
Ta façon d'intégrer la première ligne dans la boucle va me laisser perplexe un bon moment, et ce n'est pas ton: "(LIG*COL) + LIG" qui me rassure.

la formule complete que j'emplois c'est pour te faire comprendre le resultat final de la matrice
pour les ligne a 0 tu as (LIG*COL) + COL et pour la colonne a 0 c'est (LIG*COL) + LIG ce qui reviens au même que de dire
que pour la ligne 0 tu inscrit le COL en index et pour les colonne a 0 tu inscrit le LIG ... tout comme le préconise winamax dans son algo
en fait on dis tous la même chose depuis le début ... a quelque petit ajustement prés

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
    IF (i=0) THEN 
       p:= j // (i * j)+j
    ELSE 
    IF (j=0) THEN 
        p:= i  // (i * j)+i
    ELSE  
       p:= (i * j) ;

et nous somme tous bien loin des 200 lignes

[valentin03]

Et bien c'est tellement évident que je n'arrivais pas à capter; je suis bèèèèète.
Je mets Résolu.

[wiwaxia]

... tout comme le préconise winamax dans son algo ...

Non. wiwaxia, seulement