my $places = 6;
for my $left (1..$places-1) {
    for my $right (0 .. $left -1) {
        printf "%0$places"."b\n", (1 << $left) | (1 << $right);
    }
}
[download]

Recursion:

use strict;
use warnings;

doShift (2, 5);
print "\n";
doShift (3, 6);
print "\n";


sub doShift {
    my ($ones, $bits, $pattern, $limit) = @_;
    
    --$ones;
    $limit ||= $bits;
    $pattern ||= 0;
    
    for my $right ($ones .. $limit - 1) {
        if ($ones) {
            doShift ($ones, $bits, $pattern | (1 << $right), $right);
        } else {
            printf "%0*b\n", $bits, $pattern | (1 << $right);
        }
    }
}
[download]

Prints:

00011
00101
00110
01001
01010
01100
10001
10010
10100
11000

000111
001011
001101
001110
010011
010101
010110
011001
011010
011100
100011
100101
100110
101001
101010
101100
110001
110010
110100
111000
[download]

---

DWIM is Perl's answer to Gödel

GrandFather spake it well; this question maps quite well into a recursive algorithm:

sub combinatoric($$); # prototype forward reference

sub combinatoric( $$ )
{
   my ( $zero, $one ) = @_;
 
   my @ret = ();
   if ( $one == 0 )
   {
      # no more ones left to select, the rest is zeroes.
      push @ret, scalar ( '0' x $zero );
   }
   elsif ( $zero == 0 )
   {
      # no more zeroes left to select, the rest is ones.
      push @ret, scalar ( '1' x $one );
   }
   else
   {
      # take a zero from the pile, and compute what's left
      push @ret, "0$_" foreach combinatoric( $zero-1, $one );
      # take a one from the pile, and compute what's left
      push @ret, "1$_" foreach combinatoric( $zero, $one-1 );
   }
   return @ret;
}

print "$_\n" foreach combinatoric( 10, 10 );
[download]

I was quite surprised to see how quickly the 10, 10 case started giving results, even on a lowly 2.4GHz Xeon...

That's nice, but it goes through the factorial of $ones+$zeroes, 5!=120.. 120 != 10.
i'm working with strings of 435 zeroes and 343 ones (for instance), where i'm in dought i'll live that long to see it finish.

i need this sub{} to play with the strings that contain that number of 1's and 0's, not the numbers that contain them.