Discussion :

[theblow_wind]

voila le troisieme script A optimiser

le script

@ARGV=shift(@ARGV);
print " fichier << @ARGV >> :\n";
@fichier=<>;
.....

[Arioch]

Hum, et si tu mettais ton code entre les balises CODE ?

[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

[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ï

[Schmorgluck]

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 :

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
#! /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.

[Jedai]

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.

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

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
#! /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ï