Pb de tableau

[jml263]

Bonsoir, j'ai pb avec mon prog perl et je n'arrive pas a trouver la solution. Si vous pouvez m'aider c'est sympa :
J'ai 2 tableaux : tab1 et tab2
tab1 :
A
B
C
D

tab2 :
XxxxxByyyy;123
XxxxxCzzzz;456

Il faut que je recherche les occurrences de toutes les valeurs de tab1 dans tab2 et lorsque je les ai trouvé je rajoute dans tab1 la valeur qui se trouve après le caractère ; de tab2 précédé de ;.
Autrement dit il faut que tab1 soit égal a :
tab1 :
A
B;123
C;456
D

Je précise que les valeurs contenues dans tab1 sont unique

Merci d'avance pour votre aide.
JM

[Lolo78]

Une solution classique possible qui devrait marcher avec n'importe quelle version de Perl 5.:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
use strict;
use warnings;
 
my @t1 = qw /A B C D/;
my @t2 = qw/ XxxxxByyyy;123 XxxxxCzzzz;456/;
my @t3; # je préfère mettre les résultats dans un troisième tableau, quitte, à la fin, à recopier @t3 dans @t1: @t1 = @t3
 
foreach my $item2 (@t2) {
	foreach (@t1) {
		if ($item2 =~ /$_\w+;(\d+)$/) {
			push @t3, "$_;$1";
		}
	}
}
print "@t3", "\n";

Ce qui imprime @t3:

Code :

B;123 C;456

Maintenant, si tu es en version 5.10 ou au-delà de Perl (surtout à partir de 5.14), l'utilisation de l'opérateur "smartmatch" ~~ peut "simplifier" le code. Bien que je ne sois pas sûr que ce soit vraiment plus simple, la sémantique de cet opérateur paraît pour le moins incertaine en 5.10 et 5.12 et ne semble se stabiliser qu'avec la 5.14. En fait, je ne connais pas du tout ces versions: au boulot, nous n'avions que des 5.8 jusqu'à très récemment, nous avons une 5.10 sur l'un de nos serveurs depuis deux jours seulement, pas du tout testé ces nouvelles possibilités. A la maison, j'ai une 5.10, mais je n'ai pas utilisé cette possibilité au-delà de quelques petits tests "pour voir".

[Philou67430]

Pour le fun :

Code :

1
2
3
4
5
6
7
use strict;
use warnings;
 
my @t1 = qw /A B C D/;
my @t2 = qw/ XxxxxByyyy;123 XxxxxCzzzz;456/;
 
foreach my $t1 (@t1) { say join ";", $t1, (map $_->[1], grep $_->[0] =~ /$t1/, map { [ split ";", $_ ] } @t2) }

(on peut aussi mettre le résultat dans @t3 en remplaçant "say" par push @t3).

Explication :
- on parcours le tableau @t1 et pour chaque entrée
- on découpe tous les éléments de @t2 en deux
- on filtre ces éléments selon que le premier sous-élément (le texte) contient la valeur de l'entrée de @t1
- on récupère le deuxième sous-élément (le nombre après ";") que l'on concatène après l'entrée de @t1 avec ";" comme séparateur

Avec ce code, si une entrée de @t1 est présente dans plusieurs entrées de @t2, chaque valeur numérique correspondante sera ajoutée après l'entrée de @t1.
Exemple (depuis cygwin) :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
$ perl -E 'use strict;
use warnings;
 
my @t1 = qw /A B C D/;
my @t2 = qw/ XxxxxByyyy;123 XxxxBxCzzzz;456/;
foreach my $t1 (@t1) {
  say join ";", $t1, (map $_->[1], grep $_->[0] =~ /$t1/, map { [ split ";", $_ ] } @t2)
};
'
A
B;123;456
C;456
D

Si les tableaux @t1 et @t2 sont gros, il peut être intéressant de pré-découper @t2 une seule fois à l'extérieure du foreach @t1 :

Code :

1
2
3
4
5
 
my @t2 = map { [ split ";", $_ ] } @t2;
foreach my $t1 (@t1) {
  say join ";", $t1, (map $_->[1], grep $_->[0] =~ /$t1/, @t2)
}

[jml263]

Merci à Lolo78 pour son début de réponse même s'il manque dans le tableau $t3 les valeurs A et B, je m'en suis inspiré pour trouvé une solution.

Mention spéciale à Philou67430 car ton code est vraiment optimisé !
Je vais sûrement l'utiliser dans mon code.

A+
JM

[Lolo78]

Envoyé par Philou67430

Pour le fun :

Code :

Ou comment faire du Lisp (ou du Scheme ou de l'Haskell) en Perl.

Beau morceau de bravoure, qui vaut bien la transformation de Schwarz pour le tri.

Très jolie construction, même si, personnellement, je suis assez peu habitué aux langages fonctionnels et ai un peu de mal à en décortiquer le fonctionnement, ce que je regrette. Mais je suis entièrement d'accord sur le fond avec la thèse de Mark-Jason Dominus dans son livre Higher Order Perl, le langage Perl possède depuis la version 5 la plupart des points forts des langages fonctionnels (fonctions de rappel, fermetures, currification, etc.) comme Common Lisp ou Scheme. Il est dommage que l'on ne s'en serve pas plus, il est des tas de domaine où les langages fonctionnels ont vraiment beaucoup à apporter.

Depuis une quinzaine d'années (et même un peu plus), la mode est plus à la programmation orientée objet, qui apporte beaucoup de choses, mais il est dommage à mon avis que cette mode (pas de connotation péjorative dans mon esprit quand j'emploie ici le terme mode) ait fait un peu passer au second plan la puissance de la programmation fonctionnelle, qui peut apporter une très grande expressivité sous une grande concision.

[Philou67430]

Oui, cette expression s'est bien entendu inspirée de la transformation de Schwartz, dont j'use et j'abuse

Un grand merci à Lolo pour la référence à ce bouquin (qui n'est pas donné, ni mince à lire), mais qu'il me tente franchement d'acquérir.
Et merci aussi pour ton commentaire qui m'a fait rechercher quelques définitions dont je connaissais l'usage mais pas le nom, comme la "curryfication".

Sinon, j'ai adoré bosser en Lisp (Lisp of Insipide et Stupid Parenthesis... que de souvenirs) dans mon enfance d'informaticien. J'avais codé à l'école un dérivateur/simplificateur formel qui j'avais ensuite re-codé en Prolog. C'était le bon vieux temps...

Pour ce qui est de l'objet, je vois les choses ainsi : le développement de la programmation objet s'est essentiellement fait sur la base des langages et des compilateurs, c'est à dire, l'intégration dans la sémantique des langages, d'une méthode de programmation.

Selon moi, à la base, la programmation objet est une méthodologie, un état d'esprit. Et certains langages sans sémantique objet (ni contrôle de compilateur en ce sens) permettent cependant d'implémenter facilement quelques notions de bases de la programmation objet (encapsulation notamment, parfois l'héritage). Certes, on ne dispose pas des facilités qu'offre un vrai langage objet, mais on peut définir des processus de développement (règles de codage par exemple) qui pallient au moins en partie à cela. La programmation objet, c'est avant tout un état d'esprit.

Mais au fil des ans, l'industrie de l'informatique en a fait une technologie, et je vois les langages objets comme des éléments, certes "sécurisant" pour des décideurs, mais aussi, très limitant (voir complexifiant, comme dans le cas de C++). Ils enferment les programmeurs dans des contraintes et des "motifs de programmation", qui brident la créativité, l'efficience, au profit (soit disant) de la réutilisabilité, de la sécurité... Je suis un peu déçu : j'ai choisi ce métier d'informaticien justement pour cet esprit inventif, mais l'industrialisation du métier force à intégrer des technologies de plus en plus haut niveau, et à rendre les programmeurs de plus en plus bêtes (et disciplinés).

Perl 5 a su intégrer une sémantique minimaliste de programmation objet, tout en gardant la flexibilité de ses fonctions avancées. C'est pour cela qu'aujourd'hui, si je dois factoriser un développement, je n'hésite pas une seconde à faire un module avec une interface objet, trouvant cette méthode bien plus facile à réaliser que la méthode fonctionnelle (avec Exporter par exemple).

Bon, c'est ma vision des choses, hein.