Perl Récursivité et de Fonctions

Avoir entendu parler de Perl pour l'année, j'ai décidé de lui donner quelques heures de mon temps pour voir combien j'ai pu récupérer. J'ai eu à travers les notions de base de l'amende et puis à boucles. Comme un test, j'ai voulu voir si je pouvais construire un script récursif à travers toutes les valeurs alphanumériques jusqu'à 4 caractères. J'avais écrit un code PHP qui fait la même chose il y a quelques temps donc j'ai pris le même concept et à l'utiliser. Cependant lorsque je lance le script, il met "une" que les 3 premières valeurs et ensuite seulement les boucles à travers le dernier chiffre. Quelqu'un voit ce que je fais de mal?

#!/usr/local/bin/perl 

$chars = "abcdefghijklmnopqrstuvwxyz";
$chars .= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$chars .= "0123456789";

@charset = split(//, $chars);

$charset_length = scalar(@charset);

sub recurse
{
 ($width, $position, $base_string) = @_;

for ($i = 0; $i < $charset_length; ++$i) {
    $base = $base_string . $charset[$i];
    if ($position < $width - 1) {
        $pos = $position + 1;
        recurse($width, $pos, $base);
    }
    print $base;
    print "\n";
}
}

recurse(4, 0, '');

C'est ce que j'obtiens quand je le lance:

aaaa
aaab
aaac
aaad
aaae
aaaf
aaag
aaah
aaai
aaaj
aaak
aaal
aaam
aaan
aaao
aaap
aaaq
aaar
aaas
aaat
aaau
aaav
aaaw
aaax
aaay
aaaz
aaaA
aaaB
aaaC
aaaD
aaaE
aaaF
aaaG
aaaH
aaaI
aaaJ
aaaK
aaaL
aaaM
aaaN
aaaO
aaaP
aaaQ
aaaR
aaaS
aaaT
aaaU
aaaV
aaaW
aaaX
aaaY
aaaZ
aaa0
aaa1
aaa2
aaa3
aaa4
aaa5
aaa6
aaa7
aaa8
aaa9
aaa9
aaa9
aaa9

Vous passez 4 arguments sur la dernière ligne, mais n'utilisez que 3 dans le sous. Non pas que c'est la cause de votre erreur, mais juste sayin.
a toujours le même problème :/ j'ai corrigé le code ci-dessus.

OriginalL'auteur Chris | 2011-07-25

Vous avez été mordu par des non stricte délimitation de l'étendue, ce code fait ce qu'il doit (notez l'utilisation stricte en haut et l'utilisation ultérieure de mon pour garantir la variable de portée).

#!/usr/bin/env perl
use strict;
use warnings;

my $chars = "abcdefghijklmnopqrstuvwxyz";
$chars .= "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
$chars .= "0123456789";

my @charset = split(//, $chars);

my $charset_length = scalar(@charset);

sub recurse {
    my ($width, $position, $base_string) = @_;

    for (my $i = 0; $i < $charset_length; ++$i) {
        my $base = $base_string . $charset[$i];

        if ($position < $width - 1) {
            my $pos = $position + 1;
            recurse($width, $pos, $base);
        }

        print $base;
        print "\n";
    }
}

recurse(4, 0, '');

OriginalL'auteur JohnKlehm

Déjà bien répondu, mais un plus idiomatiques approche serait:

use strict;
use warnings;

sub recurse {
    my ($width, $base_string, $charset) = @_;

    if (length $base_string) {
        print "$base_string\n";
    }
    if (length($base_string) < $width) {
        $recurser->($base_string . $_) for @$charset;
    }
}

my @charset = ('a'..'z', 'A'..'Z', '0'..'9');
recurse(4, '', \@charset);

Il n'y a pas besoin de passer de la position; elle est implicite dans la largeur de la base de la chaîne de transmission. Le jeu de caractères, d'autre part, doit être passé plutôt que d'avoir une sous-routine d'utiliser une variable externe.

Sinon, étant donné que la largeur et le jeu de caractères constants, générer une fermeture qui y fait référence:

use strict;
use warnings;

sub make_recurser {
    my ($width, $charset) = @_;
    my $recurser;
    $recurser = sub {
        my ($base_string) = @_;

        if (length $base_string) {
            print "$base_string\n";
        }
        if (length($base_string) < $width) {
            $recurser->($base_string . $_) for @$charset;
        }
    }
}

my @charset = ('a'..'z', 'A'..'Z', '0'..'9');
my $recurser = make_recurser(4, \@charset);
$recurser->('');

Sinon, juste:

print "$_\n" for glob(('{' . join(',', 'a'..'z', 'A'..'Z', '0'..'9') . '}') x 4);

Cette réponse ne génère 4-combinaisons de caractères. JohnKlem réponse génère également des 1,2 et 3-les chaînes de caractères; par exemple, aaa, aa, etc..
merci, fixe je pense

OriginalL'auteur ysth

4

Il a à voir avec la portée des variables, vous êtes encore en train d'évoluer de la même vars lorsque vous êtes à l'appel de la récursivité. Le mot-clé " mon " déclare les variables locales à la sous-routine.
(http://perl.plover.com/FAQs/Namespaces.html)

J'ai toujours utiliser perl avec "use strict;" a déclaré, m'obligeant à me décider sur la portée des variables.
```
sub recurse {
  my ($width, $position, $base_string) = @_;
  for (my $i = 0; $i < $charset_length; ++$i) {
    my $base = $base_string . $charset[$i];
    if ($position < $width - 1) {
      my $pos = $position + 1;
      recurse($width, $pos, $base);
    }
    print $base;
    print " ";
  }
}
```
OriginalL'auteur PtPazuzu
4

Vous semblent être en cours d'exécution dans certains de délimitation de l'étendue des problèmes. Perl est très souple, donc il faut deviner ce que vous voulez parce que vous n'avez pas dit ce que vous voulez. Une des premières choses que vous allez apprendre à ajouter use strict; que pour votre première déclaration après le shebang. Il mettra en évidence les variables qui ne sont pas explicitement définies, ainsi que toutes les variables qui sont accessibles à l'avant en cours de création (aide à la mal orthographié variables, etc).

Si vous faites votre code ressemble à ceci, vous comprendrez pourquoi vous obtenez vos erreurs:
```
sub recurse {
    ($width, $position, $base_string) = @_;

    for ($i = 0; $i < $charset_length; ++$i) {
        $base = $base_string . $charset[$i];
        if ($position < $width - 1) {
            $pos = $position + 1;
            recurse($width, $pos, $base);
        }
        # print "$base\n";
    }
    print "$position\n";
}
```
Cela devrait sortie:
```
3
3
3
3
```
Parce que vous n'êtes pas à la portée $position correctement avec my, vous n'obtenez pas une nouvelle variable à chaque boucle, vous ré-utilisez le même. Jetez un use strict; là, et de corriger les erreurs que vous obtenez, et le code doit être bon.

OriginalL'auteur Jack M.
2

Je me rends compte que vous êtes tout simplement bricoler avec la récursivité. Mais aussi longtemps que vous êtes amusant de comparer les implémentations entre les deux langues, vous pouvez également voir comment le CPAN pouvez étendre votre outil.

Si vous n'avez pas de soins sur la commande, vous pouvez générer tous les 13,388,280 permutations de ( 'a'..'z', 'A..'Z', '0'..'9' ) pris quatre à la fois avec le module CPAN, Algorithme::Permuter

Voici un exemple de comment ce code peut regarder.
```
use strict;
use warnings;
use Algorithm::Permute;

my $p = Algorithm::Permute->new( 
    [ 'a' .. 'z', 'A' .. 'Z', '0' .. '9' ], # Set of...
    4 # <---- at a time.
);

while ( my @res = $p->next ) {
    print @res, "\n";
}
```
La new() méthode accepte un tableau ref qui énumère l'ensemble des caractères ou de la liste de ce que à permuter. Son deuxième argument est combien à l'heure à inclure dans la permutation. Donc, vous êtes essentiellement de la prise de 62 articles 4 à la fois. Ensuite, utilisez la next() méthode pour itérer sur les permutations. Le reste est juste de la poudre aux yeux.

La même chose pourrait être réduite à la suite de Perl one-liner:
```
perl -MAlgorithm::Permute -e '$p=Algorithm::Permute->new(["a".."z","A".."Z",0..9],4);print @r, "\n" while @r=$p->next;'
```
Il y a aussi une section sur la permutation, le long de avec d'autres exemples à perlfaq4. Il comprend plusieurs exemples et une liste de certains des modules supplémentaires qui gèrent les détails pour vous. L'un de Perl forces de l'est de la taille et de l'exhaustivité de la Comprehensive Perl Archive Network (CPAN).

il ne veut pas de permutation, si

OriginalL'auteur DavidO

Vous devez vous connecter pour publier un commentaire.