The values might not be unique but the keys certainly are. Sort by value first and then by key - that will give you a deterministic order. This is essentially what you have aimed for in your "inelegant" solution. The downside there is that you are sorting all the keys when it is only those with identical values which actually need it. I'd prefer to use something like

Does this seem more elegant to you?

Similar to srand()?

Env var PERL_HASH_SEED would be the equivalent. Setting it will use the provided value as a seed.

$ demo() {
   perl -e'
      use v5.18;
      my %h;
      ++$h{ $_ } for "a".."z";
      say keys %h;
   '
}

$ demo
nylxbvceamuszdrotqfgpwikhj

$ demo
ahedybntzwgmpulqijkrsxfvoc

$ PERL_HASH_SEED=0 demo
udbaxqhcnmskzeiwryvlftojgp

$ PERL_HASH_SEED=0 demo
udbaxqhcnmskzeiwryvlftojgp

$ PERL_HASH_SEED=0x0123456789ABCDEf demo
lfojtgpzekwriyvchmnsuadbqx

$ PERL_HASH_SEED=0x0123456789ABCDEF demo
lfojtgpzekwriyvchmnsuadbqx
[download]

Even with PERL_HASH_SEED=0 (which is documented to remove the random perturbations), the order is obscure, and the order of the keys can change as you add new elements. But the order and changes to it will be the same every run (as long as the program is run on similar-enough builds of Perl).

Note that there are denial-of-service risks associated with removing the random perturbations when the keys are controlled by an external actor. This probably doesn't matter for your contest.

The env var needs to be set before perl starts, but you can use bootstrapping to achieve this if you can't control that aspect of the contest's environment.

BEGIN {
   return if exists( $ENV{ PERL_HASH_SEED } );

   $ENV{ PERL_HASH_SEED } = "0";
   exec( $^X, "--", $0, @ARGV )
      or die( "exec: $!" );
}
[download]

Thanks for all your replies and the many suggestions you gave, dear monks! I will keep them in mind for my next refactoring of the code.

All the best, Rata

You can use something that looks like a hash, but provides ordered results: Tie::IxHash

$ demo() {
   perl -e'
      use v5.18;
      use Tie::IxHash qw( );
      my %h;
      tie %h, Tie::IxHash:: if $ARGV[0];
      ++$h{ $_ } for "a".."z";
      say keys %h;
   ' -- "$1"
}

$ demo 0
lukphmweqsiorxvnbdfajyczgt

$ demo 0
dpbwuxlvticosyngmrzajefqkh

$ demo 1
abcdefghijklmnopqrstuvwxyz

$ demo 1
abcdefghijklmnopqrstuvwxyz
[download]

You'd have to tie not just %hash, but the hashes referenced by the values of %hash.

or Tree::RB::XS, which is faster than both Tie::IxHash and Hash::Ordered and can be used as either an object or a tied hash.

You can use a third-party dictionary or associative array implementation that provides deterministic orderings, such as Hash::Ordered.

$ demo() {
   perl -e'
      use v5.18;
      use Hash::Ordered qw( );
      my $h = Hash::Ordered->new();
      $h->set( $_, 1 ) for "a".."z";
      say $h->keys;
   '
}

$ demo
abcdefghijklmnopqrstuvwxyz

$ demo
abcdefghijklmnopqrstuvwxyz
[download]

You'd have to replace not just %hash, but the hashes referenced by the values of %hash.

Hashes are non-deterministic for security reasons. Deterministic hashtables allow attackers to do denial-of-service attacks:

• https://www.cvedetails.com/cve/CVE-2011-4885/
• Efficient Denial of Service Attacks on Web Application Platforms
• Technical Advisory – Hash Denial-of-Service Attack in Multiple QUIC Implementations
• etc...

If you need determistic ordering in hash tables, you should adapt the hash keys in a way that allows sort keys %hash to work.