update : you said 'random' so that means it could result in no change.

And, if you do that a lot, there's this alternative for your consideration:

sub inplace_shuffle { @_[keys @_] = shuffle @_ }

inplace_shuffle (values %foo);
[download]

The functionality of keys operating on an array to return the indices of the array (see similarily values, each) was added with Perl version 5.12. The following will work with any Perl 5 version:
    sub inplace_shuffle { @_[ 0 .. $#_ ] = shuffle @_ }


---

Give a man a fish:  <%-{-{-{-<

use List::Util qw(shuffle);
use List::MoreUtils qw(zip);

%hash = zip @{[shuffle keys %hash]}, @{[values %hash]};
[download]

++

cormanaz: The syntax on the left is a slice, FYI

Just a random funny observation having done it myself a few times, taking a fully comprehensive "slice" of a hash like this sounds linguistically silly to me even though it's perfectly valid in the Perl language. Hmm... which is the better analogy? Is it like cutting a personal pizza in to slices and then proceeding to eat them all in one sitting, or more like just folding your one slice (the entire pizza) up like a calzone to eat it? After all, in the latter case you don't even need to get your pizza cutter dirty, that's just efficiency in practice. :-)

I wonder if there is a word in the English language for when a word that's technically correct is also simultaneously nonsensical, like here with the "slice" in fact being "the entire thing". Oxymoron or misnomer don't seem quite right, because strictly speaking there aren't any contradictory terms involved and "slice" is still the correct name. Are there any logophile Monks with suggestions? (I cross posted on Stack Exchange since it's admittedly a bit off topic here)

Just another Perl hooker - Working on the corner... corner conditions that is.

Perl hashes have no guarantee of key ordering. See keys and Algorithmic Complexity Attacks. You might be able to randomize the order of the keys by changing the internal parameters used by Perl.

A better solution is to do something like @randomized_keys = List::Util::shuffle(keys %hash) and then accessing the corresponding values with something like @corresponding_values = @hash{@randomized_keys} (untested).

Hello cormanaz,

Another approach could be:

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;

my %hash = ( "a" => 1,
         "b" => 2,
         "c" => 3,
         "d" => 4
    );

# Export keys from the hash
my @keys = keys %hash;

# Export values from the hash
my @values = values %hash;

my %new_hash;
for ( 0 .. $#keys ) {
    $new_hash{splice @keys, rand @keys, 1} = splice @values, rand @val
+ues, 1;
}

print Dumper \%new_hash;

__DATA__

$ perl test.pl
$VAR1 = {
          'a' => 1,
          'b' => 2,
          'c' => 3,
          'd' => 4
        };
[download]

Update:in case that someone is interested in speed simple foreach element loop is always faster. Sample of code:

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dumper;
use Benchmark::Forking qw( cmpthese );

my %hash = ( "a" => 1,
         "b" => 2,
         "c" => 3,
         "d" => 4
    );

# Export keys from the hash
my @keys = keys %hash;

# Export values from the hash
my @values = values %hash;

my %new_hash_1;
my %new_hash_2;

cmpthese(100000000, {
    'loop indices' => sub {
    for ( 0 .. $#keys ) {
        $new_hash_1{splice @keys, rand @keys, 1} = splice @values, ran
+d @values, 1;
                }
    },
    'loop elements' => sub {
        for ( @keys ) {
        $new_hash_2{splice @keys, rand @keys, 1} = splice @values, ran
+d @values, 1;
        }
},
     });

__DATA__

$ perl test.pl
                    Rate  loop indices loop elements
loop indices   5211047/s            --          -58%
loop elements 12531328/s          140%
[download]

Hope this helps.

Is this the sort of thing you're after (uses rand and map). Note that it'll reuse values from the hash. Not every one is guaranteed to be re-input into the new hash:

use warnings;
use strict;

use Data::Dumper;

my %h = (
    a => 1,
    b => 2,
    c => 3,
    d => 4,
);

my @vals = values %h;

my %new = map {$_ => $vals[int(rand(@vals))]} keys %h;

print Dumper \%new;
[download]

Output:

$VAR1 = {
          'c' => 2,
          'a' => 4,
          'd' => 3,
          'b' => 1
        };
[download]

G'day cormanaz,

"I can imagine how to do that in an inelegant way, but was wondering if there is an elegant way."

How about:

@hash{sort keys %hash} = values %hash;
[download]

That uses the inherent randomness of both keys and values. The documentation for both of those functions includes the same sentence:

"Hash entries are returned in an apparently random order."

I ran a quick test from the command line:

$ perl -MData::Dump -e 'my %x = qw{a 1 b 2 c 3}; dd \%x; @x{sort keys 
+%x} = values %x; dd \%x'
[download]

As you would expect, all tests output this as the first line:

{ a => 1, b => 2, c => 3 }
[download]

Here's the second line from three runs:

{ a => 1, b => 2, c => 3 }
{ a => 1, b => 3, c => 2 }
{ a => 2, b => 3, c => 1 }
[download]

By the way, I also tried just:

@hash{keys %hash} = values %hash;
[download]

However, that doesn't change anything. The documentation for both keys and values also contains this same sentence:

"So long as a given hash is unmodified you may rely on keys, values and each to repeatedly return the same order as each other."

use strict;
use warnings;
use List::Util qw(shuffle);
use Data::Dumper;
my %hash = (
   "a" => 1,
   "b" => 2,
   "c" => 3,
   "d" => 4
);
@hash{ keys %hash } = shuffle values %hash;

print Dumper(\%hash);

OUTPUT:
$VAR1 = {
          'a' => 3,
          'c' => 2,
          'b' => 4,
          'd' => 1
        };
[download]

I am curious why you want to do this.