Discussion :

[abdou monta]

Bonsoir

Je veux remplir une matrice carrée "m" de n lignes/colonnes aléatoirement par o et 1, à condition que le nombre d’occurrences du "1" soit plus grande que celle du "0".

J'ai eu une idée mais pas tellement pratique : la méthode consiste à remplir une case avec "0" après le remplissage de trois cases avec "1", puis on permute aléatoirement toutes les cases de la matrice.

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
 
procedure permuter_case_map ( x, y : char );
var
  aux : char;
begin
  aux := x;
  x := y;
  y := aux;
end;
procedure randomize_map ( var m : map );
var
  i, x, y : byte;
begin
  randomize;
  i := 0;
  repeat
	permuter_case_map ( m[random(n), random(n)], m[random(n), random(n)]);
	i := i + 1;
  until	i = 150; 
end;
procedure init_map ( var m : map );
var
  l, c, o : byte;
begin
  o := 0; { conteur }
  for l := 1 to n do
	for c := 1 to n do
		begin
			o := o + 1;
			if o mod 3 = 0 then
				m[l, c] := '0'
			else
				m[l, c] := '1';
		end;
  randomize_map ( m );
end;

Que pensez-vous de cette méthode ?

[M.Dlb]

L'idée est pas mauvaise. Sinon, tu remplis ta matrice de "0", puis tu fais un random pour obtenir un nombre entre n*n/2 et n*n, qui représentera le nombre de "1", puis tu places ces "1" aléatoirement en testant si la case est un "0" ou pas.

[Dr.Who]

Il y a une technique plus simple en effet :

initialiser la matrice avec des 0 (si on veux mettre quelques 1) et inversement.
puis boucler avec un while sur un certain nombre de pourcentage du total de case de la matrice.


ici dans mon exemple on ne mettra qu'entre 10% et 50% de valeur :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
program Project2;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
 
const
  Depth = 50;
  Total = Depth * Depth;
 
type
  TMatrice = array[0..Depth-1] of array[0..Depth-1] of boolean;
 
procedure MatriceInitialize(var aMatrice: TMatrice; aValue: boolean);
var X,Y:integer;
begin
  for X := 0 to Depth-1 do
    for Y := 0 to Depth-1 do
      aMatrice[Y,X] := aValue;
end;
 
procedure MatriceRandom(var aMatrice: TMatrice; aValue: boolean);
var X, Y: integer;
    D : integer;
begin
  // (10% (0.1) minimum et 50% (0.5) maximum ) -1
  D := round(Total*0.1) + random(round(Total*0.4)) - 1;
  // alors pourquoi 0.4 : 0.5-0.1 = 0.4
  // -1 pour être < 50% 
 
  while D > 0 do
  begin
    X := random(Depth);
    Y := random(Depth);
    if aMatrice[Y,X] <> aValue then
    begin
      aMatrice[Y,X] := aValue;
      dec(D);
    end;
  end;
end;
 
function MatriceCheck(aMatrice: TMatrice; var aTrue, aFalse: integer; aValue: boolean): boolean;
var X,Y: integer;
begin
  aTrue := 0;
  aFalse:= 0;
  result := false;
 
  for X := 0 to Depth - 1 do
    for Y := 0 to Depth - 1 do
      if aMatrice[Y,X] then
        inc(aTrue)
      else
        inc(aFalse);
 
  if aValue then
    result := aTrue < aFalse
  else
    result := aFalse < aTrue;
end;
 
procedure MatriceShow(aMatrice: TMatrice);
var X,Y: integer;
const
  BTC: array[boolean] of char = ('0','1');
begin
  for X := 0 to Depth - 1 do
  begin
    for Y := 0 to Depth - 1 do
      write(BTC[aMatrice[Y,X]]);
    writeln('');
  end;
end;
 
 
var
  M : TMatrice;
  cT, cF: integer;
  cR: boolean;
begin
  Randomize;
 
  MatriceInitialize(M, false);
 
  MatriceRandom(M, true);
 
  MatriceShow(M);
 
  cR := MatriceCheck(M, cT, cF, true);
  if cR then
    writeln(format('Matrice Ok   :'#10'  0     = %d (%.2f%%)'#10'  1     = %d (%.2f%%)'#10'  Total = %d'#10,
                   [cF, cF/Total*100, cT, cT/Total*100, Total]))
  else
    writeln(format('Matrice Fail :'#10'  0     = %d (%.2f%%)'#10'  1     = %d (%.2f%%)'#10'  Total = %d'#10,
                   [cF, cF/Total*100, cT, cT/Total*100, Total]));
 
  readLn;
end.