[Perl] Pb boucle ?! ou de reference tableau ?!

Version imprimable

Bonjour , mon script créé deux suites et la fonction assembler suites doit les fussionné sans doublon de chiffre mais malheuresement j ai une erreur ma boucle ne fonctionne pas
je vous donne les trois fonctions principales que j uilise .. merci de votre aide .. :o
pour exemple :
@suite_assemblersuites = ( 1,2,3,4,5,6,7)
@suite_bis_assemblersuites = ( 5 , 6 , 7 , 8 , 9 , 10 )

je souhaite qu en resultat il y est dans @suites = (1,2,3,4,5,6,7,8,9,10)

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
################################
 
 sub assemblersuites
{
  my ($reference1,$reference2) = @_ ;
  my @suite_bis_assemblersuites = @{$reference1} ;
  my @suite_assemblersuites = @{$reference2} ;
  @suites= @suite_assemblersuites ; 
  $longueur_suites = $#suites ;
  $longueur_bis = $#suite_bis_assemblersuites ;
 
   for ( $cpt = 0 ; $cpt <= $longueur_bis; $cpt += 1 )
    {
      $add = &estdanssuite ($suite_bis_assemblersuites[$cpt],@suites) ;
      if ( $add != 1 )
       {
        $suites[$#suites+1] = $suite_bis_assemblersuites[$cpt]  ;
       }
    }
  return @suites
}

les autres fonctions precedentes .. ... je sais pas si ca peut vous servir mais on ne sait jamais ..

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
 
 
#################################
sub estdanssuite
{
  my ($chiffre_estdanssuite ,@suite_estdanssuite ) = @_ ;
  $estdanssuite = 0 ;
  $longueur = $#suite_estdanssuite ;
   for ( $cpt = 0 ; $cpt <= $longueur ; $cpt += 1)
    {
      if ( $chiffre_estdanssuite == $suite_estdanssuite[$cpt] )
       {
         $estdanssuite  = 1 ;
         print $estdanssuite ;
         sleep 2;
       }
     }
    return $estdanssuite ;
}
#################################
sub creersuite
{
  my ( $debut_creersuite , $longueur_creersuite , $ecart_creersuite ) = @_ ;
    for ( $cpt = 1 ; $cpt <= $longueur_creersuite ; $cpt += 1 )
     {
       $suite_creersuite[$cpt] = $debut_creersuite ;
       $debut_creersuite += $ecart_creersuite ;
      }
   return @suite_creersuite
}

Ci un diction existe en info c est "reste devant ton ecran et THINK !"

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
sub assemblersuites
{
  my ($reference1,$reference2) = @_ ;
  my @suite_bis_assemblersuites = @{$reference1} ;
  my @suite_assemblersuites = @{$reference2} ;
  @suites= ( @suite_assemblersuites , @suite_bis_assemblersuites )  ;
    for ( $cpt = 0 ; $cpt <= $#suites ; $cpt += 1 )
        {
 
            for ( $cpt_bis = $cpt+1 ; $cpt_bis <= $#suites ; $cpt_bis += 1 )
                {
                   if ( $suites[$cpt_bis] == $suites[$cpt])
                       {
                          @suites = (@suites[0..$cpt_bis-1], @suites[$cpt_bis+1..$#suites]);
                       }
                }
        }
  return @suites ;
}

19/01/2006, 18h49
Jedai
Plus rapide et plus simple :
Code:

1 2 3 4 5 6 7 8 sub assemblersuites { my %h; @h{@_} = (1) x @_; keys %h; }
Sauf si tu veux conserver l'ordre, il vaut mieux utiliser cette méthode (en O(n+m) au lieu de O(n*m)), si tu veux conserver l'ordre, une variante de cette méthode te donnera ce que tu veux.
(cette fonction ne prend pas de références, tu epux directement mettre les deux listes en paramètre)

--
Jedaï
19/01/2006, 20h36
needles94000

Merci et Bonjour,

J ai compris la fonction dans son but general , envoyé mes deux tableaux a la fonction assemblersuite , la fonction ensuite place les nombres de @_ dans les clefs d un Hash ... Mais il reste cette ligne que j aimerai bien comprendre plus en detail( si possible le plus detaillé possible ).

@h{@_} = (1) x @_;

quelqu un peut il me la commenter Merci de votre et de votre attention
19/01/2006, 21h32
Jedai
Code:

1 2 @h{@_} = (1) x @_;
C'est une tranche (slice) de hash (autrement dit un ensemble d'éléments de hash) auxquels j'affecte "1". Pour obtenir une tranche, on met un @ devant le nom de la variable (car on va obtenir une liste), et on passe la liste des indices à mettre dans la tranche. Ensuite le (1) est une liste à un élément, que je "multiplie" (recopie n fois) par @_, comme on est en contexte scalaire après un "x", ce tableau renvoie le nombre de ses éléments.
Autrement dit soit n le nombre d'éléments de @_, chaque élément de ce tableau sert de clé au hash %h, et j'affecte à la tranche constituée de ces n éléments une liste de n "1".
Voilà, c'est un idiôme simple (et efficace et concis) pour autovivifier (et affecter une valeur vrai, parfois ça a son importance) un ensemble d'indice dans un hash.

--
Jedaï