un problème algo

Version imprimable

un problème algo

Bonjour,
J'ai des éléments et je dois faire en sorte que ceux-ci ne se recouvrent pas. J'entend par là que :

Si des éléments ont la même position de début, alors je dois prendre le plus grand
Exemple : toto20 8 10 et toto 8 18 On garde toto 8 18
Si des éléments ont la même position de fin, alors je dois prendre le plus grand.
Exemple toto79 98 110 et toto79 100 110 et toto79 105 110 On garde toto 98 110
Si on a des élément qui sont inclus dans l'un des plus grand ci-dessus on ne le garde pas
Exemple : toto20 5 15 on ne le garde pas car est inclus dans toto20 8 18 de même que toto 8 10

Citation:

type de fichier
toto79 3 110 . 7 14
toto79 3 110 . 98 110
toto20 5 50 . 8 18
toto20 5 50 . 8 10
toto79 3 110 . 100 110
toto79 3 110 . 28 78
toto20 5 50 . 30 40
toto79 3 110 . 105 110

Citation:

Résultat attendus
toto20 5 50 . 8 18
toto20 5 50 . 30 40
toto79 3 110 . 28 78
toto79 3 110 . 7 14
toto79 3 110 . 98 110
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 my %test=(); while(my $ligne = <IN>){ chomp $ligne; my ($f0,$f01,$f02,$f03, $f2,$f3)= (split /\t/, $ligne); my $all="$f2"."\t"."$f3"; #même début, mais fin différente if ( !exists $test{$all} or (($test{$f2}{'deb'} == $f2 and $test{$f2}{'fin'} > $f3)) ){ $test{$f2}{'deb'}=$f2; $test{$f2}{'fin'} = $f3; $test{$f2}{'element'}=$f1; } #même fin, mais début différente } close(IN); foreach my $val (keys %test){ print "$test{$val}{'element'}\t$test{$val}{'deb'}\t$test{$val}{'fin'}\n"; }
Quelqu'un peux aider?

23/01/2017, 19h14
Lolo78

Bonjour,

dans ton explication tu as toujours 2 valeurs, mais dans ton exemple 5. Comment faut-il comprendre?

Perso, je verrais bien un hash contenant une liste de de paires. Ensuite, on trie les paires, par exemple par valeurs de début croissantes, et on examine les bons appariements. Et on recommence avec les valeurs de fin.
25/01/2017, 13h23
pontarose

Bonjour,

MERCI
Ah oui désolé, dans mon exemple j'ai 5 valeurs mais en fait les colonnes 2,3 et 4 ne m'intéresse pas.Seul les colonnes 1 (identifiant), colonnes 5 (début) et 6 (fin), m'intéresse.

Je suis désolé mais quand tu dis "je verrais bien un hash contenant une liste de de paires", donc d'après mon exemple qu'est ce qui va constituer ma clé et ma valeur?
toto79 3 110 . 7 14 => PAIRE 1
toto79 3 110 . 98 110 => PAIRE 2

"on examine les bons appariements", en fait je veux éliminer les éléments qui se chevauchent

OK une ou deux étapes préliminaires qui devraient te mettre sur la voie et te permettre de démarrer (note: j'élimine les colonnes intermédiaires pour simplifier l'exemple, il est facile de les garder.

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
 
use strict;
use warnings;
use Data::Dumper;
 
my %data;
 
 
while (my $line = <DATA>) {
	chomp $line;
	my ($id, undef, undef, undef, $debut, $fin) = split /\s+/, $line;
	push @{$data{$id}}, [$debut, $fin];
}
 
for my $id (keys %data) {
    my @array = @{$data{$id}};
	@array = sort {$a->[0] <=> $b->[0]} @array;
	$data{$id} = \@array;
}
print Dumper \%data
 
__DATA__
toto79 3 110 . 7 14
toto79 3 110 . 98 110
toto20 5 50 . 8 18
toto20 5 50 . 8 10
toto79 3 110 . 100 110
toto79 3 110 . 28 78
toto20 5 50 . 30 40
toto79 3 110 . 105 110

Ce qui donne les valeurs triées pour chaque identifiant:

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
 
$VAR1 = {
          'toto79' => [
                        [
                          7,
                          '14'
                        ],
                        [
                          28,
                          '78'
                        ],
                        [
                          98,
                          '110'
                        ],
                        [
                          100,
                          '110'
                        ],
                        [
                          105,
                          '110'
                        ]
                      ],
          'toto20' => [
                        [
                          8,
                          '18'
                        ],
                        [
                          8,
                          '10'
                        ],
                        [
                          30,
                          '40'
                        ]
                      ]
        };

Avec les valeurs triées, il devrait être assez facile de choisir les enregistrements à garder pour ta première règle.

Il suffit ensuite de recommencer le tri sur la fin pour ta deuxième règle,.

Bonjour,

Je suis dessus mais je bloque complètement!!

J'essaye de traiter ce cas là (même début, mais fin différente)
ensg20 5 50 exon4 8 18
ensg20 5 50 exon4 8 10

J'obtiens à la fin
gene:ensg20 deb : 8 fin:10

Là je travaille sur une liste de liste, le seul moyen que j'ai trouvé pour afficher les éléments de la paire sont $$e[0] et $$e[1] (je ne sais pas si il est bon d'utiliser cette annotation!) .
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 my %data; my %test=(); while (my $line = <DATA>) { chomp $line; my ($id, undef, undef, undef, $debut, $fin) = split /\t/, $line; push @{$data{$id}}, [$debut, $fin]; } for my $id (keys %data) { my @array = @{$data{$id}}; @array = sort {$a->[0] <=> $b->[0]} @array; $data{$id} = \@array; print Dumper(@array); foreach my $e (@array){ #même début, mais fin différente if( (!exists $test{@{$data{$id}[0]}}) or (($test{$id}{'deb'} == $$e[0] and $test{$id}{'fin'} < $$e[1])) ){ $test{$id}{'deb'} = $$e[0]; $test{$id}{'fin'} = $$e[1]; } } print "\nRESULTATs\n\n"; foreach my $gene (keys %test){ print "gene:$gene\tdeb : $test{$gene}{'deb'}\tfin:$test{$gene}{'fin'}\n"; }

06/02/2017, 18h53
Lolo78

Bonjour,

je regarderai ton code plus tard quand je serai sur un ordi avec Perl (là, je suis sur une tablette), mais je te conseille un peu de lecture sur le débogage en Perl: https://perl.developpez.com/faq/perl...gage-sous-Perl.
06/02/2017, 19h58
Lolo78
Citation:

Envoyé par pontarose

Là je travaille sur une liste de liste, le seul moyen que j'ai trouvé pour afficher les éléments de la paire sont $$e[0] et $$e[1] (je ne sais pas si il est bon d'utiliser cette annotation!) .

Oui, c'est OK d'utiliser cette syntaxe, mais tu peux aussi utiliser:
Code:

1 2 $e->[0]
si tu préfères.

Bonsoir,

bon, un peu d'aide pour traiter uniquement ton cas (même début, mais fin différente):

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
 
use strict;
use warnings;
use Data::Dumper;
 
my %data;
 
 
while (my $line = <DATA>) {
	chomp $line;
	my ($id, undef, undef, undef, $debut, $fin) = split /\s+/, $line;
	push @{$data{$id}}, [$debut, $fin];
}
 
for my $id (keys %data) {
    my @array = @{$data{$id}};
	@array = sort {$a->[0] <=> $b->[0] || $b->[1] <=> $a->[1]} @array;
	$data{$id} = \@array;
}
# print Dumper \%data;
 
for my $id (keys %data) {
    my $debut = -1;
    my @array = @{$data{$id}};
    for my $pair (@array) {
        print "$id, @$pair \n" if $pair->[0] != $debut;
        $debut = $pair->[0]
    }  
}
 
__DATA__
toto79 3 110 . 7 14
toto79 3 110 . 98 110
toto20 5 50 . 8 18
toto20 5 50 . 8 10
toto79 3 110 . 100 110
toto79 3 110 . 28 78
toto20 5 50 . 30 40
toto79 3 110 . 105 110

Explication: par rapport à mon post d'il y a quelques jours, j'ai changé le tri des sous-tableaux:

Code:

1
2
 
@array = sort {$a->[0] <=> $b->[0] || $b->[1] <=> $a->[1]} @array;

Avec ce tri, je trie les paires selon le début (ordre ascendant), mais si j'ai deux paires avec le même début, je les trie dans l'ordre inverse (descendant) sur la fin, en sorte que si j'ai deux paires ayant le même début, la paire ayant la plus grande fin vienne en premier. Pour toto20, j'obtiens la structure suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
          'toto20' => [
                        [
                          8,
                          18
                        ],
                        [
                          8,
                          10
                        ],
                        [
                          30,
                          '40'
                        ]
                      ]
        };

Du coup, quand je relie le tableau de paires d'un identifiant dans la nouvelle boucle for, je ne garde (ici, j'imprime directement, mais tu peux stocker dans un nouveau tableau ou modifier le tableau existant en place) que les paires dont le début n'a pas été vu précédemment.

Résultat:

Code:

1
2
3
4
5
6
7
8
 
toto79, 7 14
toto79, 28 78
toto79, 98 110
toto79, 100 110
toto79, 105 110
toto20, 8 18
toto20, 30 40

Pour toto20, j'ai bien gardé la paire (8 18) et éliminé la paire (8 10).

Bon, j'ai pitié, un peu d'aide complémentaire. Voici une modification complémentaire de la dernière boucle for qui permet de modifier ta structure de données en place.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
for my $id (keys %data) {
    my $debut = -1;
    my @array = @{$data{$id}};
    my @new_array;
    for my $pair (@array) {
        push @new_array, $pair if $pair->[0] != $debut;
        $debut = $pair->[0]
    }  
    $data{$id} = [@new_array];
}
print Dumper \%data;

Maintenant, la paire (8, 10) de l'id toto20 a été éliminée du hash de tableau %hash:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
          'toto20' => [
                        [
                          8,
                          18
                        ],
                        [
                          30,
                          '40'
                        ]
                      ]
        };

Il suffit de recommencer l'opération pour tes autres cas de figure (même fin, etc.).

Bonsoir,

Merci pour ton aide Lolo78

J'ai identifié des cas particulier qui me pose problème. En effet, je dois prendre en compte le fait que certains élements puissent se chevaucher! Du coup je ne peux tester l'existence de ma paire car elle est unique et je ne vois comment lui dire de ne pas tout m'assembler.
Quelqu'un peux t-il m'aider

Voilà ou j'en suis après l'aide Lolo78

Citation:

fichier départ
toto . . . 8 18
toto . . . 8 10
toto . . . 30 40
toto . . . 98 110
toto . . . 105 110
toto . . . 100 110
toto . . . 449 763
toto . . . 583 763
toto . . . 449 476
toto . . . 674 763
toto . . . 964 1255
toto . . . 1108 1400

Citation:

fichier attendu
toto . . . 8 18
toto . . . 30 40
toto . . . 98 110
toto . . . 449 763
toto . . . 964 1400

A l'heure actuellle en plus de ces résultats j'obtiens 2 lignes en plus dans mon fichier
toto . . . 583 763
toto . . . 964 1255
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 my %data; while (my $line = <DATA>) { chomp $line; my ($id, undef,undef, undef, $debut, $fin) = split /\t/, $line; push @{$data{$id}}, [$debut, $fin]; } for my $id (keys %data) { my @array = @{$data{$id}}; @array = sort {$a->[0] <=> $b->[0] || $b->[1] <=> $a->[1]} @array; $data{$id} = \@array; } #print Dumper \%data; for my $id (keys %data) { my $debut = -1; my $fin = -1; my @array = @{$data{$id}}; my @new_array; for my $pair (@array) { #si pas même position de début et si pas même position de fin if ($pair->[0] != $debut && $pair->[1] != $fin){ push @new_array,$pair; #position de début et fin inclus if ($pair->[0] > $debut && $pair->[1] < $fin){ pop @new_array; } } $debut = $pair->[0]; $fin = $pair->[1]; =pod my @final_array; for my $pair (@new_array){ print "$id\t$pair->[0]\t$pair->[1]\n"; if(){ } =cut } $data{$id} = [@new_array]; print Dumper @new_array; }
Merci

24/02/2017, 00h28
Lolo78

Bonsoir,

Brève réponse, vite fait, pas le temps d’approfondir maintenant.

Le code que je t'ai proposé ne traite que la première de tes règles de gestion (même début, mais fin différente):

Citation:

Si des éléments ont la même position de début, alors je dois prendre le plus grand

Il faut le copier et l'adapter pour une autre passe avec la règle de gestion suivante.

Ici, l'anomalie que tu soulèves concerne une autre de tes règles de gestion, correspondant à des éléments ayant même position de fin.

Bonjour,

A priori j'arrive au bout, j'obtiens ce message d'erreur " Can't use string ("964 1400") as an ARRAY ref while "strict refs" "
Cela vient à priori du fait que j'ajoute un nouvel élément dans ma liste mais que celui-ci n'est pas pris en compte comme pair dans le parcours de ma liste dans for my $pair (@new_array){}
J'ai tenté @{$pair} ="$pair->[0]"." "."$pair->[1]"; mais cela ne fonctionne pas non plus!!!!

qu'est ce qui ne va pas?

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
 
while (my $line = <DATA>) {
	chomp $line;
	my ($id, undef,undef, undef, $debut, $fin) = split /\t/, $line;
	push @{$data{$id}}, [$debut, $fin];
}
for my $id (keys %data) {
	my @array = @{$data{$id}};
 
	@array = sort {$a->[0] <=> $b->[0] || $b->[1] <=> $a->[1]} @array;
	$data{$id} = \@array;
}
print Dumper \%data;
 
 
 
 
for my $id (keys %data) {
	#print "- $id\tpaire: @{$data{$id}[0]}\n";
	my @array = @{$data{$id}};
 
	#print Dumper @array;
	@array = sort {$a->[0] <=> $b->[0] || $b->[1] <=> $a->[1]} @array;
	$data{$id} = \@array;
}
#print Dumper \%data;
 
 
for my $id (keys %data) {
 
	print "--$id\t\n";
 
	my $debut = -1;
	my $fin = -1;
	my @array = @{$data{$id}};
	my @new_array;
 
 
 
	for my $pair (@array) {
		my $j =0;
		if ($pair->[0] != $debut){
			$j++;
		}
 
		if( $pair->[1] != $fin){
			$j++;
		}
		if($j==2){
			push @new_array,$pair;
 
			my $deb_previous = -1;
			my $fin_previous = -1;
			for my $pair (@new_array){
				if($pair->[0] < $fin_previous && $pair->[1] == $fin_previous ){
					pop @new_array;
				}
				if($pair->[0] < $fin_previous && $pair->[1] > $fin_previous ){
 
					my $keep = "$deb_previous"." "."$pair->[1]"; #on garde 
 
					$pair->[0]=$deb_previous;
					$pair->[1]=$pair->[1];
 
					splice @new_array,4,1;  # Supprimera définitivement l'avant dernier élement
 
					push @new_array,$keep; # ajoute élément ($deb_previous\t$pair->[1])
				}
				$deb_previous = $pair->[0];
				$fin_previous = $pair->[1];
				@{$pair} ="$pair->[0]"." "."$pair->[1]";
			}
		}
		$debut = $pair->[0];
		$fin = $pair->[1];
	} 
	$data{$id} = [@new_array]; 
	#print Dumper @new_array;
 
	for my $pair (@new_array){
		print "$id\t$pair->[0]\t$pair->[1]\n";
	}
}

24/02/2017, 17h42
Lolo78

C'est sur quelle ligne de code que tu as cette anomalie?

Sur la ligne correspondant à mon print final
Code:

1 2 3 4 for my $pair (@new_array){ print "$id\t$pair->[0]\t$pair->[1]\n"; ####ICI }