Discussion :

[calimero642-fr]

Bonjour à tous,
Je me permets de vous demander de l'aide pour savoir par ou commencer pour réaliser un tri dans un tableau :

==========voici le contenu du tableau==================
002;0201;129;166;167;8;5;
002;0207;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0203;129;166;167;8;5;
=================================================
Le but étant de trier numériquement la colonne 2 dans laquelle il n'y a pas de doublon.


Voici le code j'ai testé mais qui me donne une erreur :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
while ($Ligne_Fichier_Masterconfig = <Fichier_Base_extraction_masterconfig_sans_virgule> )
	{
		push(@Tab_Fichier_Masterconfig,$Ligne_Fichier_Masterconfig);
	}
	print "\n@Tab_Fichier_Masterconfig\n";	
 
 
	@Tab_Fichier_Masterconfig_trie = sort { $a->[2] <=> $b->[2] } @Tab_Fichier_Masterconfig; 
	print "@$_\n" for @Tab_Fichier_Masterconfig_trie;

Je vous remercie d'avance pour votre aide ou piste.


A bientôt
Jules

[djibril]

Il faudrait stocker le tout dans un hash avec en clé la colonne 2 d'intérêt.

[Philou67430]

En partant de ton script (qui se base sur un tableau simple et non hash comme suggéré par djibril), il faut corriger au moins deux choses :
- lors de la construction du tableau, chaque ligne est lue, mais pas découpée en colonnes :

Code :

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

1
2
3
4
while ($Ligne_Fichier_Masterconfig = <Fichier_Base_extraction_masterconfig_sans_virgule> )
	{
		push @Tab_Fichier_Masterconfig, [ split /;/, $Ligne_Fichier_Masterconfig ];
	}

- lors du tri, tu testes l'élément d'indice 2. Or la deuxième colonne se trouve à l'indice 1.

En corrigeant ces deux erreurs, le script devrait fonctionner un peu mieux.
L'alternative de djibril est intéressante si les clés sont uniques (et uniquement dans ce cas).

[djibril]

L'alternative de djibril est intéressante si les clés sont uniques (et uniquement dans ce cas).

Le but étant de trier numériquement la colonne 2 dans laquelle il n'y a pas de doublon.

[Philou67430]

J'avais bien lu cette remarque
J'ai simplement souhaité élargir le contexte.

Je propose ici deux autres alternatives :
1- celle de djibril, basée sur les hash
2- celle utilisant la transformée Schwartzienne

que je vais comparer en terme de performance avec DProf :

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
#!/usr/bin/perl
 
my @table = <DATA>;
 
sub hashage {
  my %table;
  foreach (@table) {
    my (undef, $key) = split /;/;
    $table{$key} = $_;
  }
  return map $table{$_}, sort keys %table;
}
 
sub schwarz {
  return map $_->[1], sort { $a->[0] <=> $b->[0] }
    map { my (undef, $key) = split /;/; [ $key, $_ ] } @table;
}
 
sub ToT {
  my @Tab_Fichier_Masterconfig;
  foreach my $Ligne_Fichier_Masterconfig ( @table )
    {
      push @Tab_Fichier_Masterconfig, [ split /;/, $Ligne_Fichier_Masterconfig ];
    }
  return map { join ";", @$_ } sort { $a->[1] <=> $b->[1] } @Tab_Fichier_Masterconfig;
}
 
print "Table initiale:\n", @table;
print "Méthode hashage:\n", hashage;
print "Méthode schwartzienne:\n", schwarz;
print "Méthode table de table:\n", ToT;
foreach (2 .. 10000) {
  hashage;
  schwarz;
  ToT;
}
 
__DATA__
002;0201;129;166;167;8;5;
002;0207;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0203;129;166;167;8;5;

Résultats :

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
$ perl -d:DProf tri.pl && dprofpp
Table initiale:
002;0201;129;166;167;8;5;
002;0207;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0203;129;166;167;8;5;
Méthode hashage:
002;0201;129;166;167;8;5;
002;0203;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0207;129;166;167;8;5;
Méthode schwartzienne:
002;0201;129;166;167;8;5;
002;0203;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0207;129;166;167;8;5;
Méthode table de table:
002;0201;129;166;167;8;5;
002;0203;129;166;167;8;5;
002;0204;129;166;167;8;5;
002;0205;129;166;167;8;5;
002;0207;129;166;167;8;5;
Total Elapsed Time = 1.687981 Seconds
  User+System Time = 1.596981 Seconds
Exclusive Times
%Time ExclSec CumulS #Calls sec/call Csec/c  Name
 57.4   0.917  0.917  10000   0.0001 0.0001  main::ToT
 25.9   0.414  0.414  10000   0.0000 0.0000  main::hashage
 23.9   0.382  0.382  10000   0.0000 0.0000  main::schwarz

Un deuxième essai montre des valeurs un peu différentes :

Code :

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

1
2
3
4
5
6
7
Total Elapsed Time = 1.727987 Seconds
  User+System Time = 1.684987 Seconds
Exclusive Times
%Time ExclSec CumulS #Calls sec/call Csec/c  Name
 49.7   0.839  0.839  10000   0.0001 0.0001  main::ToT
 30.8   0.519  0.519  10000   0.0001 0.0001  main::schwarz
 25.0   0.422  0.422  10000   0.0000 0.0000  main::hashage

En gros, la méthode Schwartzienne et par table de hashage se valent, et sont grosso-modo deux fois plus efficaces que l'algorithme initial optimisé.

[djibril]