Sélection dans un tableau non indexé en fonction d'un tableau indexé

**Jasmine80** · 29/04/2008, 16h44

Bonjour à tous,

Voici mes données de départ

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
my %H_Bact = (
                'Bact1' => [1, 2, 3, 4],
                'Bact2' => [5, 6],
                'Bact3' => [7, 8, 9, 10, 11],
                'Bact4' => [12],
                );
 
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5];
#  Recherche les numéros par bactérie en évitant les mauvaises combinaisons
#  Il faut favoriser les numéros des bactéries les moins représentées
#  par exemple, il faut aboslument garder n°12 qui est unique
# GARDER AU MOINS UN NUMERO PAR BACTERIE
# NE PAS OUBLIER LES CAS SANS SOLUTION OU CERTAINES BACTERIES NE PEUVENT PAS AVOIR DE NUMERO A CAUSE DE CONFLITS
 
# ici on doit trouver 12, 6, [7-8-10-11], 3

Algorithme:

# 1) On recherche la bactérie ayant le moins de combinaisons
# 2-3) On regarde dans la liste des mauvaises combinaisons les numéros à supprimer chez les autres bactéries dans %H_Bact
# 4) On retire ces mauvaises combinaisons de @A_MauvaisesCombinaisons

dans cet exemple :
# 1) on sélectionne Bact4
# 2) mauvaises combinaisons : 5-12 2-12 2-12
# 3) retirer 5 et 2 ches les bactéries correspondantes dans %H_Bact
# 4) on retire les mauvaises combianisons de @A_MauvaisesCombinaisons
# 1) on sélectionne Bact2 chez qui il ne reste que le numéro 6
# 2) mauvaises combinaisons : aucune
# 1) on sélectionne le numéro 1 de Bact1 (chez qui il reste 1, 3 et 4)
# 2) mauvaises combinaisons : 1-9 (1-5 ayant déjàé été enlevée)
# 3) retirer 9 dans %H_Bact
# 4) on retire la mauvaise combianison de @A_MauvaisesCombinaisons
# 1) ON NE SELECTIONNE PAS 3 DE BACT1 MAIS ON PASSE A BACT3
# - pour augmenter la probabilité d'avoir au moins un numéro par bactérie
# - après avoir faire tous le tour des bactéries, on revient aux numéros qui n'ont pas encore été testés
#...
# jusqu'à ce que @A_MauvaisesCombinaisons soit vide

Début de mon code

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
use strict;
use warnings;
use Statistics::Lite qw(:all);
 
 
my %H_Bact = (
                'Bact1' => [1, 2, 3, 4],
                'Bact2' => [5, 6],
                'Bact3' => [7, 8, 9, 10, 11],
                'Bact4' => [12],
                );
 
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5];
 
 
#while(@A_MauvaisesCombinaisons !=0)
for(my $i=0; $i<4; $i++)
{
        # 1) On recherche la bactérie ayant le moins de combinaisons
        #--------------------------------------------------------------
 
        # Creation d'un hash contenant la taille clé : taille array, valeur : bact (peu importe si on écrase une des bactéries)
        my %H_Tailles;
        # Creation d'un array contenant la liste des différentes tailles
        my @A_Tailles;
        foreach (keys %H_Bact)
        {
                $H_Tailles{@{$H_Bact{$_}}}=$_;
                push(@A_Tailles, @{$H_Bact{$_}});
        };
        # recherche de la taille la plus petite
        my $TailleArrayBact = min (@A_Tailles);
        # Bactérie dont le nombre de numéros est le plus petit
        my $Bact = $H_Tailles{$TailleArrayBact};
        # on prend le premier numéro de l'array
        my $NumBact = ${$H_Bact{$Bact }}[0];
 
        # 2) On regarde dans la liste des mauvaises combinaisons les numéros à supprimer chez les autres bactéries dans %H_Bact
        #-------------------------------------------------------------------------------------------------------------------------
 
        # Liste des numéros à supprimer
        my @A_SelectMauvCombi = grep { $_ =~ /^$NumBact-| $NumBact$/ } @A_MauvaisesCombinaisons;
        # Liste des numéros à garder (pour le cycle suivant)
        @A_MauvaisesCombinaisons = grep { $_ !~ /^$NumBact-| $NumBact$/ } @A_MauvaisesCombinaisons;
 
        print "$Bact\t$NumBact\n";
        map{print $_."\n";}@A_SelectMauvCombi;
}

Mon algorithme est-il correct?
Pourriez-vous m'aider à améliorer ce début de code?

J'ai aussi un problème avec le grep

Code :

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

1
2
3
4
my $NumBact = 12;
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5];
my @A_SelectMauvCombi = grep { $_ =~ /[ -]$NumBact[ -]/ } @A_MauvaisesCombinaisons;
map{print $_."\n";}@A_SelectMauvCombi;

Je voudrais sélectionner 5 et 2 qui sont associés à 12.

Merci pour votre aide,

Jasmine,

**iblis** · 30/04/2008, 01h45

A propos du grep.

Pour les mauvaises combinaisons à gauche (et symétriquement pour à droite) :

Code :

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

my @A_SelectMauvCombi = grep { s/-$NumBact// } @A_MauvaisesCombinaisons;

Pour avoir les deux (à droite et à gauche), tu peux faire un truc du genre :

Code :

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

1
2
3
 
my @A_SelectMauvCombi = map { $1 if /(\d+)-$NumBact/ or /$NumBact-(\d+)/ } 
                            grep { /$NumBact/ } @A_MauvaisesCombinaisons;

**Jasmine80** · 30/04/2008, 08h52

Merci pour ta réponse, je vais faire comme ça :

Code :

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

1
2
3
my @A_SelectMauvCombi = map { $1 if /(\d+)-$NumBact/ or /$NumBact-(\d+)/ }
                        grep { /$NumBact/ } @A_MauvaisesCombinaisons;
@A_MauvaisesCombinaisons = grep  { $_ !~  /-$NumBact/ or  /$NumBact-/ } @A_MauvaisesCombinaisons;

Jasmine,

**iblis** · 30/04/2008, 09h17

De rien.

Pour la question principale, je vois bien ce que fait l'algorithme mais je n'ai pas bien compris ce que tu veux précisément. Et donc comment améliorer.

Qu'entends-tu exactement par

Recherche les numéros par bactérie en évitant les mauvaises combinaisons

et

Code :

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

Il faut favoriser les numéros des bactéries les moins représentées

**Jasmine80** · 30/04/2008, 10h21

Merci beaucoup pour ton aide.

Je vais essayer d'expliquer concrètement.

Recherche les numéros par bactérie en évitant les mauvaises combinaisons

J'ai une liste de bactéries. A chaque bactérie est associée une série de fragments d'ADN. Je dois parmi ces fragments en sélectionner un groupe représentant l'ensemble de mes bactéries. Il faut donc au minimum retrouver 1 fragment par bactérie. L'ennui est que certains de ces fragments sont imcompatibles entre eux et je dois donc veiller à ne pas les retrouver associer ensemble dans ma sélection.
Chacun de mes fragments est associé à un numéro.

Il faut favoriser les numéros des bactéries les moins représentées

Je veux dire que je dois garder en priorité les fragments des bactéries n'ayant qu'un seul fragment. Dans mon exemple je ne dois pas supprimer le 12 sinon je perds la bactérie4. Je dois donc commencer par supprimer le 5 et le 2 qui sont imcompatibles avec le 12. Si j'avais commencé par supprimer ce qui est imcompatibles avec le 5, j'aurais perdu le 12 et donc la bactérie4.

Est-ce plus clair ainsi?

Voici quelques valeurs

# 843 mauvaises combinaisons pour 347 numéros au total repartis sur 82 bactéries
#
Nbr de fragments par bactérie => Nbr de bactéries ayant ce nombre de fragments
1 => 37
2 => 17
3 => 6
4 => 3
5 => 3
6 => 4
7 => 1
8 => 2
9 => 1
10 => 2
11 => 1
13 => 2
21 => 1
25 => 1
71 => 1

Donc, j'ai 37 bactéries n'étant représentées que par un seul fragment que je dois favoriser dans ma sélection. Par contre pour la bactérie ayant 71 fragments, je peux en supprimer jusqu'à 70.

Vu ces chiffres j'aimerais savoir si il est utile de créer un 'hash inversé' %H_Num ou vaut il mieux reparcourir à chaque fois %H_Bact:

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
my %H_Bact = (
                'Bact1' => [1, 2, 3, 4],
                'Bact2' => [5, 6],
                'Bact3' => [7, 8, 9, 10, 11],
                'Bact4' => [12],
                );
# création du ' hash inversé' de %H_Bact, les clés deviennent valeurs et les valeurs deviennent des clés
# => permet à partir d'une valeur de %H_Bact de rapidement retrouver sa clé sans devoir reparcourir tout ce hash.
# %H_Bact => clé : bactérie    valeur : liste des numéros correspondants
# %H_Num => clé : numéro    valeur : bactérie correspondante
 
my %H_Num;
 
foreach my $Bact (sort keys %H_Bact)
{
        foreach my $Num (@{$H_Bact{$Bact}})
        {
                $H_Num{$Num}= $Bact;
        }
}

Petit à petit, l'oiseau fait son nid

mon script progresse.

Merci,

Jasmine,

**iblis** · 30/04/2008, 11h27

Personnellement, j'aurais opté spontanément par un hash 'inversé' sur les fragments (comme tu le proposes dans ton dernier post).

D'un autre côté la question de la minimisation ne me paraît pas triviale.

(Pas sûr d'avoir vraiment fait avancer le schmilblick)

**Jasmine80** · 30/04/2008, 12h46

Voici mon script actuel.

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
#!/usr/local/bin/perl
 
use strict;
use warnings;
 
 
 
# %H_Bact => clé : bactérie    valeur : liste des numéros correspondants
my %H_Bact = (
                        Bact1 => [1, 2, 3, 4],
                        Bact2 => [5, 6],
                        Bact3 => [7, 8, 9, 10, 11],
                        Bact4 => [12],
                );
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5 2-6];
 
# création du ' hash inversé' de %H_Bact, les clés deviennent valeurs et les valeurs deviennent des clés
# => permet à partir d'une valeur de %H_Bact de rapidement retrouver sa clé sans devoir reparcourir tout ce hash.
 
# %H_Num => clé : numéro    valeur : bactérie correspondante
my %H_Num;
foreach my $Bact (sort keys %H_Bact)
{
        foreach my $Num (@{$H_Bact{$Bact}})
        {
                $H_Num{$Num}= $Bact;
        }
}
 
 
#while(@A_MauvaisesCombinaisons !=0)
for(my $i=0; $i<4; $i++)
{
        # 1) On recherche la bactérie ayant le moins de combinaisons
        #--------------------------------------------------------------
        # Creation d'un hash contenant la taille clé : taille array, valeur : bact (peu importe si on écrase une des bactéries)
        my %H_Tailles;
        # Creation d'un array contenant la liste des différentes tailles
        my @A_Tailles;
        foreach (keys %H_Bact)
        {
                $H_Tailles{@{$H_Bact{$_}}}=$_;
                push(@A_Tailles, @{$H_Bact{$_}});
        };
        # recherche de la taille la plus petite
        @A_Tailles = (sort {$a<=>$b} @A_Tailles);
        my $TailleArrayBact = $A_Tailles[0];
        # Bactérie dont le nombre de numéros est le plus petit
        my $Bact = $H_Tailles{$TailleArrayBact};
        # on prend le premier numéro de l'array
        my $NumBact = ${$H_Bact{$Bact }}[0];
 
        # 2) On regarde dans la liste des mauvaises combinaisons les numéros à supprimer chez les autres bactéries dans %H_Bact
        #-------------------------------------------------------------------------------------------------------------------------
 
        # Liste des numéros à supprimer
        my @A_SelectMauvCombi = map { $1 if /(\d+)-$NumBact/ or /$NumBact-(\d+)/ }
                        grep { /$NumBact/ } @A_MauvaisesCombinaisons;
        # Liste des numéros à garder (pour le cycle suivant)
        @A_MauvaisesCombinaisons = grep  { $_ !~  /-$NumBact/ or  /$NumBact-/ } @A_MauvaisesCombinaisons;
 
        # Suppression des numéros dans %H_Bact
        foreach my $NumIncompatible (@A_SelectMauvCombi)
        {
                my $BactIncompatible = $H_Num{$NumIncompatible};
                @{$H_Bact{$BactIncompatible}} = grep  { $_ !~  /$NumIncompatible/}@{$H_Bact{$BactIncompatible}};
 
                #On enlève de @A_MauvaisesCombinaisons les combinaisons contenant les numéros que l'on vient de supprimer
                @A_MauvaisesCombinaisons = grep  { $_ !~  /-$NumIncompatible/ or  /$NumIncompatible-/ } @A_MauvaisesCombinaisons;
 
        }
 
        print "Numéro à analyser\t$Bact\t$NumBact\n";
        print "Numéro incompatibles à supprimer\n";
        map{print $_."\n";}@A_SelectMauvCombi;
        print "\n\n";
}

L'ennui est qu'après le premier cycle, quand j'ai remis à jour @A_MauvaisesCombinaisons (retirer les combinaisons déjà traitées et celles qui n'ont plus lieu d'être car elles étaient associées à un numéro/fragment qui a été éliminé du lot), dans mon second cycle, c'est @A_MauvaisesCombinaisons de départ qui est repris.

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
i = 0	ANALYSE DE Bact4	12
Numéro incompatible à supprimer	Bact1	2
Mauvaises combinaisons restantes après le retrait de 2
	1-9
	4-5
	1-5
	2-6
Numéro incompatible à supprimer	Bact2	5
Mauvaises combinaisons restantes après le retrait de 5
	1-9
	2-6
 
i = 1	ANALYSE DE Bact2	6
Numéro incompatible à supprimer	Bact1	2
Mauvaises combinaisons restant après le retrait de 2
	1-9

Après le premier cycle, on retire le fragment 2 et le 5, dans @A_MauvaisesCombinaisons il ne reste plus que 1-9
...
car 2-12 5-12 supprimés car ils contiennent 12
4-5 1-5 supprimés car ils contiennent 5
2-6 supprimé car il contien 2
il ne reste plus que 1-9

Or au second cycle pour i = 1 ANALYSE DE Bact2 6
On retombe à nouveau sur 'Bact1 2' à supprimer.

Cela montre donc que les valeurs retirées de @A_MauvaisesCombinaisons, n'ont pas été prises en compte au second cycle.

Il y a eu il y a peu le même genre de problème posé sur ce forum, il avait fallu faire un sous programme qui remettait à jour les valeurs... mais je ne sais pas comment faire dans mon cas.

Désolée si ce n'est pas clair pose moi des questions, je fais de mon mieux afin d'expliquer.

Merci beaucoup,

Jasmine,

**iblis** · 30/04/2008, 12h53

[idée bête]

Et si tu faisais une copie de @A_MauvaisesCombinaisons à l'entrée de la boucle et travaillait dessus dans le corps de la boucle ?

Enfin, j'ai peut être mal compris, et juste là je n'ai pas le temps de tester.

Bon courage.

**Jasmine80** · 30/04/2008, 13h08

Une copie? Que veux-tu dire?
Je déclare @A_MauvaisesCombinaisons avant de commencer ma boucle
Puis au début de la boucle ? Comment faire une copie de mon nouveau @A_MauvaisesCombinaisons qui a changé au cours de la boucle?
J'ai essayé en 1ière ligne dans la boucle :

Code :

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

@A_MauvaisesCombinaisons = @A_MauvaisesCombinaisons;

mais cela ne fait rien.

J'ai essayé de réécrire des explications plus clairement

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
#  Recherche les numéros par bactérie en évitant les mauvaises combinaisons
#  Il faut favoriser les numéros des bactéries les moins représentées
#  par exemple, il faut aboslument garder n°12 qui est unique
# GARDER AU MOINS UN NUMERO PAR BACTERIE
# NE PAS OUBLIER LES CAS SANS SOLUTION OU CERTAINES BACTERIES NE PEUVENT PAS AVOIR DE NUMERO A CAUSE DE CONFLITS
 
=h
my %H_Bact = (
                        Bact1 => [1, 2, 3, 4],
                        Bact2 => [5, 6],
                        Bact3 => [7, 8, 9, 10, 11],
                        Bact4 => [12],
                );
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5 2-6];
=cut
# ici on doit trouver
#       Bact1 => 1, 3, 4,
#       Bact2 => 6
#       Bact3 7, 8, 10, 11,
#       Bact4 12
# 2, 5 et 9 ont été supprimés rendant tout le reste compatible
# 1) On recherche la bactérie ayant le moins de combinaisons et on choisi un numéro à garder
# 2a) On regarde dans @A_MauvaisesCombinaisons les combinaisons incompatibles avec ce numéro à garder
# 2b) On retire les mauvaises combinaisons de @A_MauvaisesCombinaisons qui contiennent ce numéro que l'on garde
# 3) On retire de %H_Bact ces numéros incompatibles
# 4) On retire de @A_MauvaisesCombinaisons les combinaisons qui contenait les numéros qui étaient associcés au numéro gardé et qui maintenant
# ne sont plus dans %H_Bact.
 
#dans cet exemple :
# 1) on sélectionne le numéro 12 de Bact4
# 2a) mauvaises combinaisons : 5-12 2-12 => à supprimer 5 et 2
# 2b) on retire 5-12 et 2-12 de @A_MauvaisesCombinaisons
# 3) retirer 5 et 2 chez les bactéries correspondantes dans %H_Bact
# 4) on retire de @A_MauvaisesCombinaisons les mauvaises combinaisons contenant 2 ou 5
#       => 4-5, 1-5 et 2-6   (il ne reste plus que 1-9 dans @A_MauvaisesCombinaisons)
# 1) on sélectionne Bact2 chez qui il ne reste que le numéro 6
# 2) mauvaises combinaisons : aucune car 2-6 a été supprimé au tour précédent
# 1) on sélectionne le numéro 1 de Bact1 (chez qui il reste 1, 3 et 4)
# 2a) mauvaises combinaisons : 1-9 => à supprimer 9
# 2b) on retire 1-9 de @A_MauvaisesCombinaisons
# 3) retirer 9 chez les bactéries correspondantes dans %H_Bact
# 4) on retire de @A_MauvaisesCombinaisons les mauvaises combinaisons contenant 1 ou 9
#       => aucune car @A_MauvaisesCombinaisons est vide
# Pas de tour suivant car @A_MauvaisesCombinaisons =0
#
# 1) ON NE SELECTIONNE PAS 3 DE BACT1 MAIS ON PASSE A BACT3
# - pour augmenter la probabilité d'avoir au moins un numéro par bactérie
# - après avoir faire tous le tour des bactéries, on revient aux numéros qui n'ont pas encore été testés
#...
# jusqu'à ce que @A_MauvaisesCombinaisons soit vide

Un grand merci,

Jasmine,

**Jasmine80** · 30/04/2008, 13h20

Je viens de me rendre compte que le problème est avant, c'est peut-être pas @A_MauvaisesCombinaisons.

i = 0 ANALYSE DE Bact4 12
Numéro incompatible à supprimer Bact1 2
Mauvaises combinaisons restantes après le retrait de 2
1-9
4-5
1-5
2-6
Numéro incompatible à supprimer Bact2 5
Mauvaises combinaisons restantes après le retrait de 5
1-9
2-6

Pour 5, 1-5 et 4-5 sont bien enlevés par contre, je ne sais pas pourquoi mais pour 2 2-6 n'est pas enlevé comme il le devrait ... il est donc normal qu'au second cycle, on retombe sur ce numéro 2 à enlever.

J'ai pourtant bien mis le tiret à gauche ou à droite :

Code :

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

@A_MauvaisesCombinaisons = grep  { $_ !~  /-$NumIncompatible/ or  /$NumIncompatible-/ } @A_MauvaisesCombinaisons;

Je dois peut-être mettre deux fois !~ ou utiliser des parenthèses afin de regrouper les //or//

Je vais reprendre des forces et m'aérer le cerveau et je m'y remets.

Merci,

Jasmine,

**iblis** · 30/04/2008, 13h30

Cela montre donc que les valeurs retirées de @A_MauvaisesCombinaisons, n'ont pas été prises en compte au second cycle.

Je disais juste que si tu veux travailler sur l'ensemble des valeurs à chaque cycle, tu peux faire une copie de @A_MauvaisesCombinaisons à l'entrée de la boucle et travailler dessus ensuite

Code :

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

1
2
3
4
5
6
7
8
 
for () {
    my @copy = @A_MauvaisesCombinaisons;
    # ...
    my @A_SelectMauvCombi = map { $1 if /(\d+)-$NumBact/ or /$NumBact-(\d+)/ } 
                            grep { /$NumBact/ } @A_MauvaisesCombinaisons;
    # ...
}

Mais en même temps, j'ai aussi l'impression que ton algo suppose qu'on ignore ces valeurs une fois pour toute.

Humm, pas sûr d'être très utile avec ces 2 derniers posts.

**Jasmine80** · 30/04/2008, 14h07

Humm, pas sûr d'être très utile avec ces 2 derniers posts.

Au moins, je ne me sens pas seule,

c'est bien gentil de ta part d'essayer de m'aider.

Je disais juste que si tu veux travailler sur l'ensemble des valeurs à chaque cycle

Non, justement, c'est ce que je ne veux pas! Sinon ça serait une boucle sans fin vu que le but est d'arriver à vider complètement @A_MauvaisesCombinaisons et à nettoyer %H_Bact. Quand mon programme sera au point, for(my $i=0; $i<4; $i++) sera d'ailleurs remplacé par while(@A_MauvaisesCombinaisons !=0).

Le problème est que quand $NumIncompatible est à droite du tiret il est supprimé et dans le cas contraire il ne l'est pas. C'est donc un petit truc qui manque dans le grep.

Code :

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

1
2
3
4
5
6
7
8
9
10
my $NumBact = 12;
my @A_MauvaisesCombinaisons = qw[5-12 1-9 2-12 4-5 1-5 12-8];
 
my @A_SelectMauvCombi = map { $1 if /(\d+)-$NumBact/ or /$NumBact-(\d+)/ }
                        grep { /$NumBact/ } @A_MauvaisesCombinaisons;
@A_MauvaisesCombinaisons = grep  { $_ !~  /-$NumBact/ or  /$NumBact-/ } @A_MauvaisesCombinaisons;
 
map{print $_."\n";}@A_SelectMauvCombi;
 
map{print $_."\n";}@A_MauvaisesCombinaisons;

12-8 devrait disparaitre de @A_MauvaisesCombinaisons car il contient 12 or seuls 5-12 et 2-12 sont supprimés.

En singeant ton premier post il faudrait quelque chose du genre

Code :

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

1
2
@A_MauvaisesCombinaisons = map { $1 unless /(\d+-$NumBact)/ or /($NumBact-\d+)/ }
                            grep { /$NumBact/ } @A_MauvaisesCombinaisons;

... mais qui fonctionne.
De plus $1 n'est pas utile vu que je veux tout récupérer et non une sous partie.

Merci,

Jasmine,

Sélection dans un tableau non indexé en fonction d'un tableau indexé

Langage Perl

Vue hybride

Discussions similaires

Partager

Partager