optimiser les scriptes suite3

Version imprimable

15/06/2007, 04h22
theblow_wind

fonction optimisation

voila le troisieme script A optimiser

le script

@ARGV=shift(@ARGV);
print " fichier << @ARGV >> :\n";
@fichier=<>;
.....
15/06/2007, 09h56
Arioch

Hum, et si tu mettais ton code entre les balises CODE ?
15/06/2007, 15h58
theblow_wind

je n'ai pas saisi qui ce que vous vouler dire par ca.
entout ca merci pour votre aide
ce que je veux c minimiser le nombre de ligne et garder le meme resultat du script.
merci
15/06/2007, 16h06
Jedai

Tu regardes ce que j'ai fait sur ton post "optimiser .. 1" et tu fais pareil sur ce post, en utilisant le bouton # avec le code sélectionné. Ca aiderait aussi si ton indentation était un peu plus propre... Pour cela "perltidy" pourrait t'aider, je te conseille de lire ce post et d'appliquer mes conseils, ça t'évitera beaucoup de problème par la suite.

--
Jedaï

Bon, après avoir bien examiné ton script (ce qui fut une épreuve) je crois avoir trouvé un solution beaucoup moins alambiquée, et qui a le mérite d'éviter de charger tout le fichier en mémoire.

Code:

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
#! /usr/bin/perl -w
use strict;
system("clear");
my $option = $ARGV[1];
 
if($option eq "-c")
{
    my ($gauche, $droite, $mot)= ("[", "]", "crochet");
}
elsif($option eq "-a")
{
    my ($gauche, $droite, $mot)= ("{", "}", "accolade");
}
elsif($option eq "-g")
{
    my ($gauche, $droite, $mot)= ("\"", "\"", "guillemet");
}
else
{
    print "option non valide.\n traite par défaut les parenthèses\n\n" if($option);
    my ($gauche, $droite, $mot)= ("(",")","parenthèse");
}
 
@ARGV = shift @ARGV;
print "fichier << @ARGV >>\n";
 
#on teste une fois pour toute si le signe ouvrant est égal au signe fermant
my $identic = ($gauche eq $droite);
 
my $cpt_parenthese = 0;
 
while(<>)
{
    my $ligne=$_;
#match de regex avec /g en contexte scalaire : reconnaissance itérative.
#c'est, à mon humble avis, l'approche la plus élégante du problème.
    while($ligne=~m/(\Q$gauche\E)|(\Q$droite\E)/g)
    {
#l'alternative, dans le dialecte regex de Perl, est ordonnée
#donc, si les signes sont identiques, ce sera toujours $1 qui sera défini
#sinon, soit $1 soit $2 sera défini, selon le cas.
         if($1)
         {
             $cpt_parenthese++;
         }
         else
         {
             $cpt_parenthese--;
         }
    }
#ici, on teste s'il y a une (ou plusieurs) parenthèse fermante de trop
    if($cpt_parenthese<0)
    {
#grâce à la variable $. pas besoin de compter les lignes
        print "ligne NO $. ==> $ligne\n";
        print "$mot fermante de trop détectée\n";
#et on interrompt la boucle le cas échéant.
        last;
#à vrai dire, on pourrait carrément interrompre le programme à ce stade
    }
}
$cpt_parenthese %= 2 if($identic);
 
if($cpt_parenthese>0)
{
#ici, je l'avoue, je m'amuse un peu avec l'opérateur ternaire
    print "il y manque $cpt_parenthese $mot".($identic?"\n":"fermante\n");
}
elsif($cpt_parenthese==0)
{
    print " tout est correct =====> fin\n";
}

Voilà, je pense que c'est correct, j'ai la flemme de tester pour tout dire, j'ai un coup de barre.
Quelques modifications assez simples permettraient d'avoir l'option immédiatement après l'appel du programme, ce qui est plus standard que le mettre après le fichier à traiter. On pourrait même, du coup, traiter plusieurs fichier à la fois, mais là ce serait un peu plus de boulot.

EDIT : j'avais oublié d'ajouter le pragma strict.

Citation:

Envoyé par Schmorgluck

Pas tellement plus de boulot, avec un peu de magie...

Code:

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
#! /usr/bin/perl
use strict;
use warnings;
 
my %options_list = (
    c       => [ '[', ']', '',  'crochet' ],
    a       => [ '{', '}', 'e', 'accolade' ],
    g       => [ '"', '"', '',  'guillemet' ],
    default => [ '(', ')', 'e', 'parenthese' ],
);
 
my $parens;
if ( $ARGV[0] =~ m/^-(\w)$/ ) {
    $parens = $1;
    shift;
}
else {
    $parens = 'default';
}
 
my @parens = @{ $options_list{$parens} or print_usage() };
 
my $same = ( $parens[0] eq $parens[1] );
my $rx = $same ? qr{(\Q$parens[0]\E)} : qr{(\Q$parens[0]\E|\Q$parens[1]\E)};
 
my ( $global_count, $global_order ) = ( 0, 0 );
while (<>) {
    my ( $line_count, $line_order ) = ( 0, 0 );
    while (m/$rx/g) {
        if ( $1 eq $parens[0] ) {
            ++$global_count;
            ++$line_count;
        }
        else {
            $global_order = 1 if --$global_count < 0;
            $line_order   = 1 if --$line_count < 0;
        }
    }
    $line_count %= 2 if $same;
    if ($line_count) {
        print "A la ligne $. de $ARGV, " . missing($line_count);
    }
    elsif ($line_order) {
        print "A la ligne $. de $ARGV, " . order($line_order);
    }
 
    if (eof) {
        $global_count %= 2 if $same;
        if ($global_count) {
            print "Globalement dans $ARGV, " . missing($global_count);
        }
        else {
            print "Globalement dans $ARGV, " . order($global_order);
        }
        print '-' x 60 . "\n";
        close ARGV;
        ( $global_count, $global_order ) = ( 0, 0 );
    }
}
 
sub missing {
    my $count = shift;
    my $plural = abs($count) > 1 ? 's' : '';
    return "il manque "
      . ( $plural ? abs($count) : "un$parens[2]" )
      . " $parens[3]$plural "
      . ( $count > 0 ? "fermant$parens[2]$plural" : "ouvrant$parens[2]$plural" )
      . ".\n";
}
 
sub order {
    my $order = shift;
    return "les quantites de $parens[3]s ouvrant$parens[2]s "
      . "et fermant$parens[2]s sont equilibrees"
      . ( $order ? " mais leur ordre est incorrect" : '' ) . ".\n";
}
 
sub print_usage {
    print <<EOU;
Usage : script.pl [-c|-a|-g] liste de fichiers
 
Verifie par defaut que les parentheses ouvrantes ou fermantes se 
correspondent bien sur chaque ligne.
 
-c Verifie les crochets plutot que les parentheses
-a les accolades
-g les guillemets
EOU
    exit(1);
}

C'est pas plus court (c'est 23 lignes plus long que l'original, mais je saute des lignes, j'étale mes instructions pour ne pas dépasser 80 colonnes, etc, etc), mais c'est nettement plus complet et robuste, le code est plus joli, plus facilement extensible... Avec un joli message d'erreur si on utilise une option incorrecte.
Code testé.

--
Jedaï

17/06/2007, 02h51
Jedai

Je signale par ailleurs que je n'ai même pas essayé de vraiment lire ou comprendre le code original... Etant donné que tu ne l'as toujours pas entouré de balise CODE, ça reste illisible et je ne ferais pas l'effort (tu pourrais faire ce minimum pour qu'on puisse lire tes messages, ça serait bien... :? ).
D'après le rapide coup d'oeil que j'y ai jeté j'ai tout de même l'impression que ce code est tordu et contient des erreurs, des bugs dans l'algorithme (ils y sont toujours dans la version de Schmorgluck apparemment). J'ai basé mon implémentation sur ce que j'ai compris de ton intention et pas sur ce que fait vraiment ton programme.

--
Jedaï