in reply to Help with sorting/randomizing?

Grandfather, is this the right direction?

while (<IN>) {
    if (/^(\d+)\.(\d+)\.(\d+)\.(\d+)/) {
        my $a = $1;
        my $b = $2;
        my $c = $3;    
        my $d = $4;
        my $ip = "$a.$b.$c.$d";
        my $classc = "$a.$b.$c";
        my $classb = "$a.$b";
        my $classa = "$a";
        push(@{$hash{$classa}{$classb}{$classc}}, $ip);
    }
}



for my $a ( keys %hash ) { 
    for my $b ( keys %{$hash{$a}} ) { 
        for my $c ( keys %{$hash{$a}{$b}} ) { 
            for my $ip ( @{$hash{$a}{$b}{$c}} ) { 
                print "$ip\n";
            } 
        } 
    } 
} 


use Data::Dumper; print Dumper \%hash;

[download]

Replies are listed 'Best First'.
Re^2: Help with sorting/randomizing?
by GrandFather (Saint) on Mar 26, 2012 at 05:40 UTC

    Yep, that's heading in the direction I had been thinking of. However that doesn't really generate the random picking that I think you want. Consider the following:

    use strict;
use warnings;

my %ips;

while (<DATA>) {
    next if ! /^(\d+)\.(\d+)\.(\d+)\.(\d+)/;
    push @{$ips{$1}{$2}{$3}}, $4;
}


my @selected;

while (my @picks = pickEm(\%ips)) {
    push @selected, @picks;
}

print join "\n", @selected;


sub pickEm {
    my ($root) = @_;

    return splice @$root, rand(@$root), 1 if 'ARRAY' eq ref $root;

    my @keys = keys %$root;

    while (@keys) {
        my $key = splice @keys, rand(@keys), 1;
        my $pick = pickEm($root->{$key});

        return "$key.$pick" if defined $pick;
        delete $root->{$key};
    }

    return;
}

__DATA__
#Group A
184.75.65.68

#Group B
184.75.122.146
184.75.122.147
184.75.122.148

#Group C
64.3.71.98
64.3.71.99
64.3.71.100
64.3.71.106

#Group D
64.3.73.17
64.3.73.18
64.3.73.19
64.3.73.20

#Group E
66.1.73.21
66.1.73.22
66.1.73.23

    [download]

    Prints (for one random run):

    66.1.73.22
64.3.71.106
184.75.122.146
184.75.65.68
64.3.71.100
64.3.71.98
66.1.73.23
66.1.73.21
184.75.122.148
64.3.71.99
64.3.73.18
64.3.73.17
184.75.122.147
64.3.73.20
64.3.73.19

    [download]
    True laziness is hard work
[reply]
[d/l]
[select]

      Thanks Grandfather. Yes, I know it doesn't generate anything yet. I am trying to work on it to provide random ranges.

      This is all greek to me. I am thinking maybe counting %hash and iterating over the items.

      Your code provides the randomness. However, it still have sequential Class-C ranges that I am trying to avoid:

      64.3.71.100
64.3.71.98
66.1.73.23
66.1.73.21

      [download]

      This script is for a firewall. It should not have consecutive Class-C's

      Best solution seems to be JavaFan's. If only I could shuffle Class-A's on that one

[reply]
[d/l]

        There is a vast difference between "random" and "meets some ordering criteria". If you have a constraint on the ordering that you want to meet (if possible, it may not be possible of course) you really need to tell us what that constraint is. Telling us about the bigger picture is often useful too so long as it makes the reason for the constraint clear - I can't imagine why somewhat random ordering is important in the context of a firewall.

        I'm having trouble judging your coding ability so I didn't ease up on the sample code. However you should ask about anything that doesn't make sense to you - we are about helping you learn after all, so if you understood everything your scope for learning is fairly limited!

        Here is one hint: pickEm is recursive and so, effectively, is %ips.

        True laziness is hard work
[reply]

In Section Seekers of Perl Wisdom