Discussion :

[Jasmine80]

Code :

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

1
2
3
4
5
6
my $i;
my @tableau = sort map { $i++; "$_ : $i";} qw /jan fev mar avr mai jun  jui aou sep oct nov dec/;
 
print map { $_->[0] }
sort { $a->[1] <=> $b->[1] }
map {[$_, m/\w+ : (\d+)/]}@tableau;

C'est très simple, je crois que j'ai bien compris, je vais m'entrainer.
Merci pour votre aide et vos explications. Je reviendrai probablement ultérieurement avec des questions aux sujets de vos commentaires.

[cmcmc]

C'est très simple, je crois que j'ai bien compris, je vais m'entrainer.

, par exemple à extraire les points du plan représentés par la chaîne "abscisse:ordonnée" situés à une distance inférieure à 2 de l'origine, et triés par ordre de distance croissante à l'origine, pour la liste

Code :

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

qw(1:1 0:1 2:2 1:2)

[Lolo78]

C'est très simple, je crois que j'ai bien compris

C'est bien ce que je t'ai dit à plusieurs reprises: à première vue, ça peut paraître un peu compliqué, mais dès que l'on s'y met pour de vrai, on se rend compte que c'est finalement très facile.

Content que mon exercice t'ait aidé à saisir ce truc. Et bravo à toi de t'y être mise.

[Jasmine80]

, par exemple à extraire les points du plan représentés par la chaîne "abscisse:ordonnée" situés à une distance inférieure à 2 de l'origine, et triés par ordre de distance croissante à l'origine, pour la liste

Code :

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

qw(1:1 0:1 2:2 1:2)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
my @tableau = qw(1:1 0:1 2:2 1:2);
 
print map { $_->[0], "\n" }
sort {$a<=>$b} grep { sqrt($_->[2]*$_->[2] + $_->[1]*$_->[1]) < 2 }
map {[$_, m/(\d+):(\d+)/]}@tableau;
 
# OM =  rac (x2 + y2)
# vérif des valeurs obtenues
my $a = sqrt(0*0 + 1*1);
my $b = sqrt(1*1 + 1*1);
 
print "$a\t$b\n";

Comment faire en sorte que le tri s'applique au résultat du grep ? Merci.

[Philou67430]

Dans ton premier map (celui qui s'exécute en premier), tu calcules ta distance à l'origine. Et ce map retourne [$_, $distance].
Ensuite tu filtres (grep) sur $_->[1].
Puis tu fais un sort avec $a->[1] et $b->[1]
Et pour finir, tu écris le map final qui restitue $_->[0].

A toi de jouer

[cmcmc]

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
my @tableau = qw(1:1 0:1 2:2 1:2);
 
print map { $_->[0], "\n" }
sort {$a<=>$b} grep { sqrt($_->[2]*$_->[2] + $_->[1]*$_->[1]) < 2 }
map {[$_, m/(\d+):(\d+)/]}@tableau;
 
# OM =  rac (x2 + y2)
# vérif des valeurs obtenues
my $a = sqrt(0*0 + 1*1);
my $b = sqrt(1*1 + 1*1);
 
print "$a\t$b\n";

Comment faire en sorte que le tri s'applique au résultat du grep ? Merci.

Hé hé, j'ai réussi à t'embrouiller

Relis ce que j'ai écrit là, et cramponne toi à cette conviction : dans la transformée Schwartzienne c'est dans le map initial que tu fais le travail d'extraction des infos pertinentes. Le sort (ou grep) qui suivent doivent couler de source.

[Jasmine80]

Dans ton premier map (celui qui s'exécute en premier), tu calcules ta distance à l'origine. Et ce map retourne [$_, $distance].
Ensuite tu filtres (grep) sur $_->[1].
Puis tu fais un sort avec $a->[1] et $b->[1]
Et pour finir, tu écris le map final qui restitue $_->[0].

A toi de jouer

Merci pour tes conseils. Ca doit ressembler à ça ?

Code :

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

map {[$_, sqrt($_[1]*$_[1] + $_[2]*$_[2]) ] ;   m/(\d+):(\d+)/}@tableau;

Et pourquoi, mon code précédent ne fonctionne pas ?

[Jasmine80]

Hé hé, j'ai réussi à t'embrouiller

Ca c'est vraiment pas difficile c'est pas un exploit.

[Jasmine80]

Je crois que c'est mieux ainsi :

Code :

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

map {[$_, sqrt($_[1]*$_[1] + $_[2]*$_[2]) ]} split /:/, @tableau;

[cmcmc]

Merci pour tes conseils. Ca doit ressembler à ça ?

Code :

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

map {[$_, sqrt($_[1]*$_[1] + $_[2]*$_[2]) ] ;   m/(\d+):(\d+)/}@tableau;

Non. [ $_, $distance] doit être la dernière expression du bloc du map (c'est la valeur qu'il va retourner). Mais c'est un bloc, donc tu peux effectuer des calculs avant :

Code :

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

map { ... ; [$_, $distance] }

Et pourquoi, mon code précédent ne fonctionne pas ?

parce que tu ne véhicules pas les bonnes informations dans les tableaux intermédiaires [ $_, ... ]

[Jasmine80]

Code :

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

1
2
3
4
5
my @tableau = qw(1:1 0:1 2:2 1:2);
 
print map { $_->[0], "\n" }
sort {$a->[1]<=>$b->[1]} grep { $_->[1] < 2 }
map {my @t = split /:/ ; [$_, sqrt($t[1]*$t[1] + $t[0]*$t[0]) ]} @tableau;

Et voila ... donc, si je ne veux pas de @t, puis-je utiliser autre chose, comment ?

[cmcmc]

Code :

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

1
2
3
4
5
my @tableau = qw(1:1 0:1 2:2 1:2);
 
print map { $_->[0], "\n" }
sort {$a->[1]<=>$b->[1]} grep { $_->[1] < 2 }
map {my @t = split /:/ ; [$_, sqrt($t[1]*$t[1] + $t[0]*$t[0]) ]} @tableau;

Et voila ... donc, si je ne veux pas de @t, puis-je utiliser autre chose, comment ?

plusieurs possibilités :

Code :

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

map { m/(.*):(.*)/; [ $_, sqrt($1*$1 + $2*$2) ] }

ou bien si tu définis

Code :

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

sub distance { sqrt($_[0]*$_[0] + $_[1]*$_[1]) }

tu peux écrire ton map comme

Code :

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

... map { [ $_, distance(split /:/) ] } ...

ou

Code :

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

... map { [ $_, distance(m/(.*):(.*)/) ] } ...

Note également que puisque le corps du bloc se réduit alors à une simple expression, on peut utiliser la forme map EXPR => plutot que map BLOC :

Code :

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

... map [ $_, distance(split /:/) ] =>  ...

tu aurais pu également (je crois que tu as essayé de le faire) te ramener à un problème déjà résolu. On sait résoudre le problème posé si les points sont représentés par des tableaux [abscisse, ordonnée]:

Code :

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

1
2
3
4
5
6
7
8
Taisha:~/perl/forum $ perl -MData::Dump -E '
dd map $_->[0] =>
   sort { $a->[1] <=> $b->[1] }
   grep { $_->[1] < 2 }
   map [$_, sqrt($_->[0]*$_->[0] + $_->[1]*$_->[1])] =>
   [1, 1], [0, 1], [2, 2], [1, 2]'
([0, 1], [1, 1])
Taisha:~/perl/forum $

Il suffit d'ajouter un étage de décomposition au début et un étage de recomposition à la fin :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
Taisha:~/perl/forum $ perl -MData::Dump -E '
dd map { join ":", @$_ }
   map $_->[0] =>
   sort { $a->[1] <=> $b->[1] }
   grep { $_->[1] < 2 }
   map [$_, sqrt($_->[0]*$_->[0] + $_->[1]*$_->[1])] =>
   [1, 1], [0, 1], [2, 2], [1, 2]
   map [ split /:/ ] => 
   qw(1:1 0:1 2:2 1:2)'
("0:1", "1:1")
Taisha:~/perl/forum $

[cmcmc]

autre question (fais moi confiance, je ne te la pose pas gratuitement ou pour te torturer), on veut, toujours sur la même liste, extraire les points situés à une distance inférieure à 2 de l'origine, mais cette fois triés par ordre de distance croissante au point "2:1"

[Jasmine80]

Merci mais ca devient déjà plus compliqué ... je ne comprends pas la forme 'map EXPR =>' ... peux-tu l'expliquer, s'il te plait ? Merci.

et aussi le 'dd' que je ne comprends pas

[Jasmine80]

autre question (fais moi confiance, je ne te la pose pas gratuitement ou pour te torturer), on veut, toujours sur la même liste, extraire les points situés à une distance inférieure à 2 de l'origine, mais cette fois triés par ordre de distance croissante au point "2:1"

je laisse ça pour demain matin, quand mon cerveau sera bien reposer ^^

[cmcmc]

Merci mais ca devient déjà plus compliqué ... je ne comprends pas la forme 'map EXPR =>' ... peux-tu l'expliquer, s'il te plait ? Merci.

c'est tout bête. Si le corps du bloc se réduit à une simple expression, alors tu n'as pas besoin de mettre un bloc mais il faut ajouter une virgule (ou =>, qui est une sorte de virgule). Par exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
Taisha:~/perl/forum $ perl -MData::Dump -e '
  my @l = (0, 1, 2, 3, 4, 11, 20 .. 24);
  dd @l;
  dd map { 2*$_ } @l;
  dd map 2*$_ , @l;
  dd map 2*$_ => @l
'
(0 .. 4, 11, 20 .. 24)
(0, 2, 4, 6, 8, 22, 40, 42, 44, 46, 48)
(0, 2, 4, 6, 8, 22, 40, 42, 44, 46, 48)
(0, 2, 4, 6, 8, 22, 40, 42, 44, 46, 48)
Taisha:~/perl/forum $

on voit que les trois formes de map ci-dessus donnent le même résultat.

et aussi le 'dd' que je ne comprends pas

dd est une fonction fournie par le package Data::Dump qui est à mon avis plus facile d'utilisation et donne des résultats plus lisibles et plus compacts que Data::Dumper pour des impressions de test ou de debug. On voit ci-dessus qu'elle aggrège par exemple des élements de liste consécutifs comme 0, 1, 2, 3, 4 en un intervalle 0 .. 4. De plus pour l'impression de hashrefs elle trie automatiquement les clés :

Code :

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

1
2
3
4
5
6
Taisha:~/perl/forum $ perl -MData::Dump -e '
  my $hr = { qw(A noir E blanc I rouge U vert O bleu) }; 
  dd $hr
'
{ A => "noir", E => "blanc", I => "rouge", O => "bleu", U => "vert" }
Taisha:~/perl/forum $

On peut obtenir un résultat comparable avec Data::Dumper mais c'est fastidieux :

Code :

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

1
2
3
4
5
6
7
8
9
10
Taisha:~/perl/forum $ perl -MData::Dumper -e '
  my $hr = { qw(A noir E blanc I rouge U vert O bleu) };
  local $Data::Dumper::Sortkeys  = 1;
  local $Data::Dumper::Terse     = 1;
  local $Data::Dumper::Indent    = 0;
  local $Data::Dumper::Quotekeys = 0;
  print Dumper($hr), "\n"
'
{A => 'noir',E => 'blanc',I => 'rouge',O => 'bleu',U => 'vert'}
Taisha:~/perl/forum $

[Jasmine80]

autre question (fais moi confiance, je ne te la pose pas gratuitement ou pour te torturer), on veut, toujours sur la même liste, extraire les points situés à une distance inférieure à 2 de l'origine, mais cette fois triés par ordre de distance croissante au point "2:1"

Code :

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

1
2
3
4
5
6
7
8
9
 
my @tableau = qw(1:1 0:1 2:2 1:2);
 
sub distanceOO { sqrt($_[0]*$_[0] + $_[1]*$_[1]) }
sub distanceAB { sqrt( ($_[0] - 2)*($_[0] - 2) + ($_[1] - 1)*($_[1] - 1) ) }
 
print map { $_->[0], "\n" }
sort {$a->[2]<=>$b->[2]} grep { $_->[1] < 2 }
map { [ $_, distanceOO(split /:/),  distanceAB(split /:/)] } @tableau;

C'est même très amusant comme genre de problèmes

[cmcmc]

Code :

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

1
2
3
4
5
6
7
8
9
 
my @tableau = qw(1:1 0:1 2:2 1:2);
 
sub distanceOO { sqrt($_[0]*$_[0] + $_[1]*$_[1]) }
sub distanceAB { sqrt( ($_[0] - 2)*($_[0] - 2) + ($_[1] - 1)*($_[1] - 1) ) }
 
print map { $_->[0], "\n" }
sort {$a->[2]<=>$b->[2]} grep { $_->[1] < 2 }
map { [ $_, distanceOO(split /:/),  distanceAB(split /:/)] } @tableau;

C'est même très amusant comme genre de problèmes

L'important ici était de résister à la tentation de limiter le map initial à l'extraction des coordonnées, par exemple par map [$_, split /:/] => , pour faire les calculs de distance dans le grep ou le sort. Pour le grep, ça n'a pas d'importance mais pour le sort, étant donné qu'on a en moyenne O(N*log(N)) comparaisons à faire, les calculs dans le bloc du sort sont effectués O(N*log(N)) fois au lieu de N fois s'ils sont dans le map initial. Evidemment, quand on combine un sort et un grep comme ci-dessus, et si le grep ne laisse passer qu'un toute petite fraction des items initiaux, on peut peut-être discuter mais en général on a vraiment intérêt à effectuer tous les calculs avant de manière à avoir un code aussi simple que possible dans le sort.

Petite remarque : j'aurais plutôt écrit le map final map { "$_->[0]\n" } ce qui divise par deux le nombre d'arguments passés à print. Mais c'est un détail.

[Jasmine80]

L'important ici était de résister à la tentation de limiter le map initial à l'extraction des coordonnées, par exemple par map [$_, split /:/] => , pour faire les calculs de distance dans le grep ou le sort. Pour le grep, ça n'a pas d'importance mais pour le sort, étant donné qu'on a en moyenne O(N*log(N)) comparaisons à faire, les calculs dans le bloc du sort sont effectués O(N*log(N)) fois au lieu de N fois s'ils sont dans le map initial. Evidemment, quand on combine un sort et un grep comme ci-dessus, et si le grep ne laisse passer qu'un toute petite fraction des items initiaux, on peut peut-être discuter mais en général on a vraiment intérêt à effectuer tous les calculs avant de manière à avoir un code aussi simple que possible dans le sort.

A merci pour ces conseils, je vais en tenir compte à l'avenir.

J'aime beaucoup les subroutines ... ça allège le bloc du code de la transformation, c'est plus aéré et lisible ainsi, je trouve

Petite remarque : j'aurais plutôt écrit le map final map { "$_->[0]\n" } ce qui divise par deux le nombre d'arguments passés à print. Mais c'est un détail.

Ce n'est peut-être pas une bonne habitude, mais je sépare souvent mes variables de mon texte dans mes prints, car ainsi elles ressortent beaucoup mieux avec mon éditeur (Scite) ... vu que je cherche surtout un code compréhensible et pas spécialement optimal (surtout vu mes tout petit code), je préfère ainsi.