Repartition decpu load "decoupe de rectangle", et C++

Repartition decpu load "decoupe de rectangle", et C++ - Algo - Programmation

Marsh Posté le 05-08-2005 à 02:01:12    

:hello: ,
j explique :
On donne un nombre P de processeurs
il y a NxM taches a partager.  
Le bute est de minimiser le total des tache que n importe quel pc recevra.  
Les contraintes sont :
- Chaque tache ne peus pas etre partage entre les pc.
- Toutes taches alouer a un pc doivent etre un sous rectangle de la matrix
 
 
http://img291.imageshack.us/img291/8534/exemple6km.png
 
Dans l example 1  
le max load est 12 ( 1 + 2 +3 + 1 + 2 +3 ) mais on vois bien que si on avait couper differement
1 2   et   3
1 2        3
1 2        3
 
on aurait eu 9 taches pour les 2 pc c etait parfait.
 
Ma question est vers quel algo regarder, je devrais peut etre choisir entre efficacite et reponses optimales.
Comment aborder le problem ? est ce un problem connu en algo ?
 
merci   :jap:


Message édité par xiluoc le 10-08-2005 à 00:24:08
Reply

Marsh Posté le 05-08-2005 à 02:01:12   

Reply

Marsh Posté le 06-08-2005 à 03:49:42    

up

Reply

Marsh Posté le 06-08-2005 à 10:01:08    

apperement cest un problem np, la solution parfaite prendrais un peu trop de temps. jai trouve pas mal d algo de partitionement pour les graphs mais la cest une matrice simple.

Reply

Marsh Posté le 07-08-2005 à 00:55:56    

:/

Reply

Marsh Posté le 08-08-2005 à 00:48:40    

a vot bon coeur

Reply

Marsh Posté le 08-08-2005 à 01:38:04    

J'aurais fait des rectangles de 1x1 [:dawa]
Ensuite le problème se ramène à sommer toutes les valeurs de la matrice, diviser par le nombre de procs et à tomber le plus près possible juste un peu au-delà de (total/p)
 
Si j'ai bien lu ton énoncé, y aucune contrainte pour répondre comme cela [:joce] (ou ta phrase "toutes taches ..." ne respecte aucune règle syntaxique en vigueur dans notre beau pays :o)

Reply

Marsh Posté le 08-08-2005 à 03:18:18    

Je connais pas grand chose à ce genre de problème, mais pourquoi pas appliquer "diviser pour régner" ? C'est peut-être simpliste, mais ça donne quand-même la solution optimale pour tous les exemples que tu as donné. Je l'ai testé sur des plus grosses matrices générées aléatoirement, et les résultats semblent pas trop mauvais...
 
En détail:
Si il y a qu'un seul processeur, c'est trivial
 
S'il y a deux processeurs, c'est facile: pour un matrice N x M, il n'y a que (N-1)+(M-1) partitionnements possibles, on peut les essayer tous. La meilleur répartition sera celle dont le rapport des charges sera la plus proche de 1.
 
S'il y a plus de 2 processeurs, on subdivise en deux comme pour le cas précédent, puis on résout chaque sous-problème avec la moitié des processeurs...
 
Une amélioration: si le nombre de processeur est impair (2n+1), un des sous-problème aura n processeurs et l'autre n+1; on peut donc viser un rapport de (n+1)/n pour le partitionnement au lieu de 1...
 
[edit]
petite correction, ça ne donne pas la solution optimale pour l'exemple 4, ça me donne 122, alors qu'il y a moyen de faire 120.


Message édité par dividee le 08-08-2005 à 05:13:07
Reply

Marsh Posté le 09-08-2005 à 05:53:34    

jai implementer le brute force pour 2 cpu, ca marche maintenant faut que jessaye le deivide and conqueer.
je trouve moncode un peu lourd quand meme, quelques critique ?
 

Code :
  1. //case 2 cpu
  2. int partA = 0;
  3. int partB = 0;
  4. double bestRatioSofar = 0;
  5. double Ratio = 0;
  6. int sum = 0;
  7. int curentCut = 1;
  8. int maxLoad = 0;
  9. int bestCutPosition = 0;
  10. //row = true col = false;
  11. bool colOrRowCut = true;
  13. // do  rows
  14. // m-1 possibilities of arrangement  
  15. for (int i =0; i < rowSize -1  ; i++)
  16. {
  17.  for (int k = 0; k < curentCut; k++)
  18.  {
  19.   //cout << "part A include row " << k << endl;
  20.   for (int j = 0; j < colSize; j ++)
  21.   {
  22.    sum += matrix[k][j];
  23.   }
  24.   partA = sum;
  25.  }
  26.  sum = 0;
  28.  for (int k = curentCut  ; k < rowSize ; k++)
  29.  {
  30.   //cout << "part B include row " << k << endl;
  31.   for (int j = 0; j < colSize; j ++)
  32.   {
  33.    sum += matrix[k][j];
  34.   }
  35.   partB = sum;
  36.  }
  38.  if (partA > partB) Ratio = (double)partA /  (double)partB;
  39.  else  Ratio = (double)partB /  (double)partA;
  40.  //update best ratiosofar
  41.  if (Ratio < bestRatioSofar || bestRatioSofar == 0)
  42.  {
  43.   bestRatioSofar = Ratio;
  44.   colOrRowCut = true;
  45.   bestCutPosition = curentCut;
  46.   if (partA > partB) maxLoad = partA;
  47.   else maxLoad = partB;
  48.  }
  50.  //cout << " part A : " << partA << " part B : " << partB << " ratio " << Ratio << endl;
  51.  partA = 0;
  52.  partB = 0;
  53.  sum = 0;
  54.  curentCut++;
  55. }
  56. curentCut = 1;
  57. // do cols
  58. //n-1 possibilities of arrangement  
  59. for (int i =0; i < colSize -1  ; i++)
  60. {
  61.  for (int k = 0; k < curentCut; k++)
  62.  {
  63.  // cout << "part A include col " << k << endl;
  64.   for (int j = 0; j < rowSize; j ++)
  65.   {
  66.    sum += matrix[j][k];
  67.   }
  68.   partA = sum;
  69.  }
  70.  sum = 0;
  72.  for (int k = curentCut  ; k < rowSize ; k++)
  73.  {
  74.  // cout << "part B include col " << k << endl;
  75.   for (int j = 0; j < rowSize; j ++)
  76.   {
  77.    sum += matrix[j][k];
  78.   }
  79.   partB = sum;
  80.  }
  82.  if (partA > partB) Ratio = (double)partA /  (double)partB;
  83.  else  Ratio = (double)partB /  (double)partA;
  84.  //update best ratiosofar
  85.  if (Ratio < bestRatioSofar || bestRatioSofar == 0)
  86.  {
  87.   bestRatioSofar = Ratio;
  88.   colOrRowCut = false;
  89.   bestCutPosition = curentCut;
  90.   if (partA > partB) maxLoad = partA;
  91.   else maxLoad = partB;
  92.  }
  93.  //cout << " part A : " << partA << " part B : " << partB << " ratio " << Ratio << endl;
  95.  partA = 0;
  96.  partB = 0;
  97.  sum = 0;
  98.  curentCut++;
  99. }
  100. cout << "The maximum load (first line) followed by/nthe  " <<procNbr << " regions selected are (top row, left column, bottom row, right column):" << endl;
  101. cout << maxLoad << endl;


 :jap:

Reply

Marsh Posté le 09-08-2005 à 15:00:51    

je pense avoir reussi a implementer divide and conquer pour un nombre pair de cpu , a lexemple 4 ma de coupe se fait de :
 
top row, left col, down row, right col
0 0 4 0
0 1 4 1
0 2 3 4
4 2 4 4
 
ton Algo trouve la meme chose ?
max load de 122
ca mas pris 200 lignes de code :/

Reply

Marsh Posté le 09-08-2005 à 21:13:09    

La solution précise trouvée dépend sûrement de petits détails d'implémentation, mais la qualité de cette solution devrait rester la même en moyenne...
 
Pour l'exemple 4 j'obtiens ceci (j'ai numéroté les lignes/colonnes en partant de 1):
1 1 2 5 load: 10
3 1 4 5 load: 10
5 1 5 2 load: 2
5 3 5 5 load: 122
 
J'ai implémenté l'algo en python; le C j'en fais plus que si je suis obligé ;)

Code :
  1. def solve(mat, n):
  2.     rects = []
  4.     def _solve(n, rect):
  5.         if n == 1:
  6.             rects.append(rect)
  7.         else:
  8.             if rect[2] == rect[0] and rect[3] == rect[1]:
  9.                 # more than 1 processor for a single task ?
  10.                 for i in xrange(n-1):
  11.                     rects.append((0,0,0,0)) # all processors are idle
  12.                 rects.append(rect) # except one
  13.             else:
  14.                 half_n = n/2
  15.                 ratio = float(n - half_n) / half_n
  16.                 r1, r2 = partition(rect, ratio)
  17.                 _solve(n-half_n, r1)
  18.                 _solve(half_n, r2)
  20.     def partition(rect, ratio):
  21.         best_diff = 1e100   # some big float
  22.         top, left, bottom, right = rect
  23.         whole_rect_sum = sum_rect(rect)
  24.         # split by lines
  25.         sum1 = 0
  26.         for split in xrange(top, bottom):
  27.             r1 = (top, left, split, right)
  28.             r2 = (split+1, left, bottom, right)
  29.             sum1 += sum_rect((split,left,split,right))
  30.             sum2 = whole_rect_sum - sum1
  31.             if sum1 < sum2:
  32.                 r1, r2 = r2, r1
  33.                 r = float(sum2)/sum1
  34.             else:
  35.                 r = float(sum1)/sum2
  36.             if abs(r-ratio) < best_diff:
  37.                 best_diff = abs(r-ratio)
  38.                 best_r1 = r1
  39.                 best_r2 = r2
  40.         # split by columns
  41.         sum1 = 0
  42.         for split in xrange(left, right):
  43.             r1 = (top, left, bottom, split)
  44.             r2 = (top, split+1, bottom, right)
  45.             sum1 += sum_rect((top,split,bottom,split))
  46.             sum2 = whole_rect_sum - sum1
  47.             if sum1 < sum2:
  48.                 r1, r2 = r2, r1
  49.                 r = float(sum2)/sum1
  50.             else:
  51.                 r = float(sum1)/sum2
  52.             if abs(r-ratio) < best_diff:
  53.                 best_diff = abs(r-ratio)
  54.                 best_r1 = r1
  55.                 best_r2 = r2
  56.         return (best_r1, best_r2)
  58.     def sum_rect(r):
  59.         top, left, bottom, right = r
  60.         return sum(sum(line[left-1:right]) for line in mat[top-1:bottom])
  61.            
  62.     _solve(n, (1,1, len(mat), len(mat[0])))
  63.     loads = [sum_rect(r) for r in rects]
  64.     response = zip(loads, rects)
  65.     response.sort(reverse=True) # highest load first
  66.     return response


 
66 lignes, moins si je n'avais pas fait qqes optimisations. J'ai malheureusement écrasé la version non optimisée, mais les optimisations ont surtout pour but d'appeler moins souvent sum_rect; tu peux remplacer les calculs de sum1 et sum2 dans les boucles for de la fonction partition par sum1=sum_rect(r1) et sum2=sum_rect(r2) pour comprendre comment ça marche sans te laisser distraire par les optimisations. Je suis pas certain à 100% que c'est "bug free", mais j'ai quand-même prévu le cas où il essayerait de partager une tâche entre plusieurs processeurs.
 
Moins de 20 secondes pour une matrice de 1000x1000 et 10000 processeurs, mais qui a autant de processeurs à disposition ?  
 
Je n'ai pas lu ton code C (pardon, C++, mais ça ressemble à du C :p), mais à priori tu aurais intérêt à modulariser un peu en découpant l'algo en plusieurs fonctions...
 
Les tests:

Code :
  1. mat1 = ((1,2,3),)*3
  2. mat2 = (((1,)*4),)*4
  3. mat3 = (((1,)*4),)*3 + ((1,120,1,1),)
  4. mat4 = (((1,)*5),)*4 + ((1,1,120,1,1),)
  5. mat5 = ((1,120,1), (1,1,1), (1,1,1))
  7. tests = [ # (matrix, num_processors)
  8.     (mat1, 2),
  9.     (mat2, 2),
  10.     (mat3, 3),
  11.     (mat4, 4),
  12.     (mat5, 2),
  13.     ]
  15. print
  16. for idx, test in enumerate(tests):
  17.     print "Example", idx+1
  18.     print solve(*test)
  20. print "\nA more complex example"
  21. from random import seed,randint
  22. seed(0)
  23. mat_size = 20
  24. nproc = 20
  25. mat = [[randint(1,99) for i in xrange(mat_size)] for i in xrange(mat_size)]
  26. for line in mat:
  27.     for col in line:
  28.         print "%2d " % col,
  29.     print
  30. print "number of processors: ", nproc
  31. perfect = float(sum(sum(x) for x in mat)) / nproc
  32. print "perfect load (without constraints):", perfect
  33. proc_rects = solve(mat, nproc)
  34. for p in proc_rects:
  35.     print p


Reply

Marsh Posté le 09-08-2005 à 21:13:09   

Reply

Marsh Posté le 09-08-2005 à 21:19:39    

et l'output des tests (il y a pour chaque CPU, d'abord sa charge puis le rectangle dont il s'occupe)

Example 1
[(9, (1, 3, 3, 3)), (9, (1, 1, 3, 2))]
Example 2
[(8, (3, 1, 4, 4)), (8, (1, 1, 2, 4))]
Example 3
[(121, (4, 1, 4, 2)), (12, (1, 1, 3, 4)), (2, (4, 3, 4, 4))]
Example 4
[(122, (5, 3, 5, 5)), (10, (3, 1, 4, 5)), (10, (1, 1, 2, 5)), (2, (5, 1, 5, 2))]
Example 5
[(122, (1, 1, 1, 3)), (6, (2, 1, 3, 3))]
 
A more complex example
84  76  42  26  51  41  78  31  48  58  90  50  28  75  62  25  91  98  81  90  
31  73  89  68  47  10  43  61  91  96  48  86  26  80  55   2  72  40  82  67  
 1  49  86  25  33  87  19  57  24  96  80  45   8  32  51  93  11  55  70  55  
81  54  96  60  59  45  60  39  57  29  19  19  61  66  48   9  76  87  92  84  
89  92  54  39  70  28  81  85  89  59  95  58  45  66  99  91  79   9  61  49  
63  84  25  73  12  22  79  33  81  10  15  70   5  57  91  53  68   3  63  61  
58  39  37  98   4   3  96  19  13  21  80  93   3  43  11  26  22  65  35  18  
50   4  10  98  20  36  73  83  91  17  67  96   6  67  84  34  25  60  44  18  
47  41  57  51  31  36  83  25  56   2  74  34   5  28  24  95  35  29  36  94  
63  62  71  39  42  65   1  20  34  24  64  38  87  57  42  40  70  42  66   5  
45  26  16  53  49  56  75  88  49  31  47  81  87  81  19  99  63   9  72  98  
40  68  32  22  72   1  82  53  10  12  65  87  28  97  10  85  40   9  28  45  
79  86  14  52  65  35  87  28   2   5  68  56  94  93  91   5  75  70  65  71  
90  64  37  54  21  59   1  15  34  79  72  34  62   5  17  98  29  40  55  30  
48  24   5  18  52   8  40  33  42  10  90  47  84  97  35  48  70  43  30  73  
89  92  63  38  97  64   7   9  75   7   1  39  52  45  49  58  68  42  37  98  
26  77  43  36   7  86  70  90  45  68  12  40  21   5  94  22  15  20  38  55  
15  98  98  15  41  68  87  50  91  32  50  50  67  20  61  22  34  96  90  81  
 4  15  26  78  84  58  72  80   7   9  87   4  23   5   2  84  33  16  15  65  
96  50  90  50  57  68  80  76  99  74  90  21  54  60  82  48  79  39  59  85  
number of processors:  20
perfect load (without constraints): 1027.6
(1122, (4, 15, 10, 17))
(1100, (1, 15, 3, 20))
(1099, (16, 1, 20, 4))
(1077, (1, 11, 5, 14))
(1066, (1, 7, 10, 8))
(1065, (16, 17, 20, 20))
(1062, (7, 1, 10, 6))
(1052, (16, 8, 20, 11))
(1046, (4, 1, 6, 6))
(1038, (11, 12, 12, 20))
(1028, (16, 12, 20, 16))
(1021, (4, 18, 10, 20))
(1015, (13, 1, 15, 8))
(996, (1, 9, 10, 10))
(992, (11, 1, 12, 11))
(989, (6, 11, 10, 14))
(974, (13, 9, 15, 14))
(946, (16, 5, 20, 7))
(945, (13, 15, 15, 20))
(919, (1, 1, 3, 6))

Reply

Marsh Posté le 10-08-2005 à 10:57:46    

convertion c++ reussi =) 200 lignes, vive python.
par contre 22.5 s en python
et 3 a peine en  c++ ?!
je comprend pas.
voila le code

Code :
  1. #include <iostream>
  2. #include <vector>
  3. #include <stdio.h>
  4. using namespace std;
  6. struct Rect {
  7.     int rowTop;
  8.     int colLeft;
  9.     int rowDown;
  10.     int colRight;
  11. };
  13. vector <Rect> subRectV;
  14. vector <Rect>::iterator it;
  16. void solve (int procNbr, int startRow, int startCol, int endRow, int endCol);
  17. void partition (Rect R , float ratio, Rect &  r1, Rect & r2);
  18. int sum_rect(Rect R);
  20. int **matrix = NULL;
  22. int main()
  23. {
  24. int procNbr, rowSize, colSize;
  25. //get the numbers of proccesors
  26. cout << "Enter the number of processors that need to share the load: ";
  27. ///cin >> procNbr;
  28. //get the size of the matrix
  29. cout << "Enter the number of rows and columns of the matrix of the loads: ";
  30. //cin >> rowSize >> colSize;  
  32. //create the matrix dynamicaly
  33. rowSize =1000;
  34. colSize = 1000;
  35. //Allocate an array of size rowSize.
  36. matrix = new int*[rowSize];
  37. //Loop through all integer pointers and allocate each one an array of size colSize.
  38. for (int i = 0; i < rowSize; i++)
  39.  matrix[i] = new int[colSize];
  41. //Input the values of the matrix
  42. cout << "\nEnter the load matrix (row by row, left to right): \n";
  43. //for (int i=0; i < rowSize; i++)
  44.  //for (int j=0; j < colSize; j++)
  45.   //cin >> matrix[i][j];
  47. //cout << "\nThe maximum load (first line) followed by\nthe 2 regions selected are (top row, left column, bottom row, right column):"<< endl;
  49. for (int i = 0; i < rowSize; i++) {
  50.  for (int j = 0; j < colSize; j++) {
  51.          matrix[i][j] = (rand()%999)+1;
  52.      }
  53.  
  54.     }
  55.     procNbr = 10000;
  56.     clock_t start, finish;
  57.  
  58.   long int duration;
  59.     start = clock ();
  60.    
  61.    
  62.     solve (procNbr, 1, 1, rowSize , colSize);
  63. int maxLoad = 0;
  64. cout << "The maximum load (first line) followed by\nthe  " << procNbr
  65. << " regions selected are (top row, left column, bottom row, right column):" << endl;
  67. for (it =  subRectV.begin() ; it !=  subRectV.end(); it++) {
  68.  int load =  sum_rect(*it);
  69.  if (load > maxLoad) { maxLoad = load; }
  70. } 
  71.  cout << maxLoad << endl;
  72.  finish = clock ();
  73.       duration = finish - start;
  74.       printf ("Actual:%ld\n", duration);
  75.       Rect r;
  76.      r.rowTop = 1;
  77.  r.colLeft = 1;
  78.  r.rowDown = rowSize;
  79.  r.colRight = colSize;
  80.       cout << "perfect : " << sum_rect(r)/procNbr << endl;
  81. //for (it =  subRectV.begin() ; it !=  subRectV.end(); it++) {
  82. // cout << it->rowTop -1 << " " << it->colLeft -1<< " " << it->rowDown -1<< " " << it->colRight -1 << endl;
  83. //}   
  84. //finish, free memory
  85. for (int i = 0; i < rowSize; i++)
  86.  delete[] matrix[i];
  88. delete[] matrix;
  89. matrix = NULL;
  90. return 0;
  91. }
  93. void solve (int procNbr, int startRow, int startCol, int endRow, int endCol)
  94. {
  95. if (procNbr == 1) {
  96.  Rect rTmp;
  97.  rTmp.rowTop = startRow;
  98.  rTmp.colLeft = startCol;
  99.  rTmp.rowDown = endRow;
  100.  rTmp.colRight = endCol;
  101.  subRectV.push_back(rTmp);
  102. }
  103. else {
  104.  int half_procNbr = procNbr / 2;
  105.  float ratio = (float)  (procNbr - half_procNbr) / half_procNbr;
  106.  Rect r1, r2;
  107.  Rect R;
  108.  R.rowTop = startRow;
  109.  R.colLeft = startCol;
  110.  R.rowDown = endRow;
  111.  R.colRight = endCol;
  112.  partition(R, ratio, r1, r2);
  113.  solve(procNbr - half_procNbr, r1.rowTop, r1.colLeft , r1.rowDown , r1.colRight);
  114.  solve(half_procNbr , r2.rowTop , r2.colLeft , r2.rowDown , r2.colRight );
  115. }
  116. }
  118. void partition (Rect R, float ratio, Rect & best_r1, Rect & best_r2)
  119. {
  120. float r;
  121. int sum1 = 0;
  122. int sum2 = 0;
  124. float best_diff = 1e100;  // some big float
  125. int top = R.rowTop;
  126. int left = R.colLeft;
  127. int bottom = R.rowDown;
  128. int right = R.colRight;
  129. int whole_rect_sum = sum_rect(R);
  131. // split by lines
  132. sum1 = 0;
  133. //n-1 rows of possible combinations
  134. for (int split = top ; split < bottom ; split++) {
  135.  Rect r1;
  136.  r1.rowTop = top;
  137.  r1.colLeft = left;
  138.  r1.rowDown = split;
  139.  r1.colRight = right;
  140.  Rect r2;
  141.  r2.rowTop = split+1;
  142.  r2.colLeft = left;
  143.  r2.rowDown = bottom;
  144.  r2.colRight = right;
  145.  Rect rTmp;
  146.  rTmp.rowTop = split;
  147.  rTmp.colLeft = left;
  148.  rTmp.rowDown = split;
  149.  rTmp.colRight = right;
  150.  sum1 += sum_rect(rTmp);
  151.  sum2 = whole_rect_sum - sum1;
  152.  if (sum1 < sum2) {
  153.    swap(r1, r2);
  154.    r = float(sum2)/sum1;
  155.  }
  156.  else {
  157.    r = float(sum1)/sum2;
  158.  }
  159.  if (abs(r-ratio) < best_diff) {
  160.   best_diff = abs(r-ratio);
  161.   best_r1 = r1;
  162.   best_r2 = r2;
  163.  }
  164. }
  165. // split by columns
  166. sum1 = 0;
  167. //m-1 cols of possible combinations
  168. for (int split = left ; split < right ; split++) {
  169.  Rect r1;
  170.  r1.rowTop = top;
  171.  r1.colLeft = left;
  172.  r1.rowDown = bottom;
  173.  r1.colRight = split;
  174.  Rect r2;
  175.  r2.rowTop = top;
  176.  r2.colLeft = split+1;
  177.  r2.rowDown = bottom;
  178.  r2.colRight = right;
  179.  Rect rTmp;
  180.  rTmp.rowTop = top;
  181.  rTmp.colLeft = split;
  182.  rTmp.rowDown = bottom;
  183.  rTmp.colRight = split;
  184.  sum1 += sum_rect(rTmp);
  185.  sum2 = whole_rect_sum - sum1;
  186.  if (sum1 < sum2) {
  187.    swap(r1, r2);
  188.    r = float(sum2)/sum1;
  189.  }
  190.  else {
  191.    r = float(sum1)/sum2;
  192.  }
  193.  if (abs(r-ratio) < best_diff) {
  194.   best_diff = abs(r-ratio);
  195.   best_r1 = r1;
  196.   best_r2 = r2;
  197.  }
  198. }
  199. }
  201. int sum_rect(Rect R)
  202. {
  203. int sum=0;
  204. int top = R.rowTop;
  205. int left = R.colLeft;
  206. int bottom = R.rowDown;
  207. int right = R.colRight;
  208. for (int i= top-1; i < bottom ; i++) {
  209.  for (int j= left-1; j < right ; j++) {
  210.   sum += matrix[i][j];
  211.  }
  212. }
  213. return sum;
  214. }


Message édité par xiluoc le 10-08-2005 à 10:58:29
Reply

Marsh Posté le 10-08-2005 à 21:11:10    

xiluoc a écrit :

convertion c++ reussi =) 200 lignes, vive python.
par contre 22.5 s en python
et 3 a peine en  c++ ?!
je comprend pas.


Qu'est-ce que ça a d'étonnant ? Entre un langage dynamiquement typé et essentiellement interprété, et un langage statiquement typé et compilé (et pour lequel les compilateurs ont une certaine maturité), ça me parait tout à fait crédible comme ordre de grandeur...

Reply

Sujets relatifs:

Leave a Replay

Make sure you enter the(*)required information where indicate.HTML code is not allowed