Dado um número inteiro positivo n, produza as 2^nseqüências binárias de comprimento nclassificadas na seguinte ordem precisa.

Casos de teste:

0:

0 or 1 (defining this is a matter of debate)

1:

0
1

2:

00
01
10
11

3:

000
001
010
100
011
101
110
111

4:

0000
0001
0010
0100
1000
0011
0101
1001
0110
1010
1100
0111
1011
1101
1110
1111

etc.

Além disso, o padrão combinatório está relacionado ao triângulo de Pascal.

0:

1 (this is given regardless of the definition given to 2^0)

1:

1
1

2:

1
2
1

3:

1
3
3
1

4:

1
4
6
4
1

etc.

Haskell, 78 bytes

import Data.List
f n=sortOn(\x->sum x:reverse(map(1-)x))$mapM id$[0,1]<$[1..n]

Exemplo de uso: f 2-> [[0,0],[0,1],[1,0],[1,1]].

Como funciona:

         [0,1]<$[1..n]  -- make n copies of the list [0,1]
     mapM id            -- make all lists where the ith element is from the ith list.
                        -- that gives us all binary sequences
sortOn                  -- sort this list of list
    sum x               -- first by number of ones
      reverse(map(1-)x) -- then by the reversed list with bits flipped

Python 2, 146 bytes

from itertools import*
lambda i:sum([sorted({''.join(b)for b in permutations((i-n)*"0"+"1"*n)},key=lambda x:x[::-1])[::-1]for n in range(i+1)],[])

Ainda estou trabalhando nisso, embora todas as sugestões sejam muito apreciadas!

Ungolfed

i=input()   
import itertools
p=[]
for n in range(i+1):
    x=(i-n)*"0"+"1"*n
    t=[]
    for b in itertools.permutations(x):t+=[''.join(b)] if ''.join(b) not in t else []
    p.append(sorted(t, key=lambda x:x[::-1])[::-1])

p=sum(p,[])
print
for line in p:print line

Python 2, 122 120 102 98 bytes

18 bytes economizados graças ao Flp.Tkc

4 bytes salvos graças ao xnor

lambda x:sorted([bin(i)[2:].zfill(x)for i in range(2**x)],key=lambda x:(sorted(x),int(x[::-1],2)))

Explicação

Isso cria todas as cadeias binárias de comprimento x com:

[bin(i)[2:].xfill(x)for i in range(2**x)]

Eu os classifico de acordo com:

lambda x:(sorted(x),int(x[::-1],2))

sorted(x)prioriza o número de 1s enquanto int(x[::-1],2)prioriza a segunda condição

Por fim, estas são associadas a novas linhas e impressas.

Perl, 63 bytes

-4 graças a @Ton Hospel.
-2 graças a @Gabriel Benamy.

say~~reverse for sort{$b=~y/0//-$a=~y/0//||$b-$a}glob"{1,0}"x<>

Execute com -E(que habilita o recurso say):

perl -E 'say~~reverse for sort{$b=~y/0//-$a=~y/0//||$b-$a}glob"{1,0}"x<>' <<< 5

• "{1,0}"x$_cria uma sequência composta de $_tempos {1,0}( $_é a entrada). Por exemplo, com 3: {1,1}{1,0}{1,0}.
• Em seguida, globfaz alguma mágica e gera todas as combinações de um elemento de cada grupo de chaves (ou seja, todas as combinações que queremos imprimir).
• E então a classificação: $b=~y/1//c-$a=~y/1//ccompara o número de 1em cada sequência e, se eles tiverem o mesmo número, $b-$aserão classificados de acordo com a segunda regra.

Perl, 116 106 105 102 bytes

sub e{sprintf"%0$%b",@_}sub f{$_=e@_;/0*$/;$%*y/1//-$-[0]}map{say e$_}sort{f($a)<=>f$b}0..2**($%=<>)-1

Legível:

sub e{
    sprintf"%0$%b",@_
}
sub f{
    $_=e@_;/0*$/;$%*y/1//-$-[0]
}
map{
    say e$_
} sort {
    f($a)<=>f$b
} 0..2**($%=<>)-1

A subrotina econverte seu argumento em um valor binário, preenchido com zeros, para ser o comprimento da entrada (por exemplo, entrada de 5 blocos com zeros até os 5 caracteres). A sub f- rotina assume um valor binário e atribui um peso de classificação de acordo com a forma como deve ser processado.

O intervalo 0 .. [entrada] ² -1 é então submetido a uma classificação estável, ordenando pelo peso (aqui, "stable" significa que quando dois valores têm o mesmo peso, eles são retornados na mesma ordem em que aparecem no entrada) e, em seguida, são retornados à sub-rotina ee à saída.

Alguns de vocês podem ter visto minha postagem original, mas ontem li errado o problema e o excluí imediatamente depois que percebi.

Raquete 109 bytes

(let loop((s ""))(if(= n(string-length s))(displayln s)(for((i '("0" "1")))(loop(string-append s i)))))

Ungolfed:

(define (f n)
  (let loop ((s ""))
    (if (= n (string-length s))
        (displayln s)
        (for ((i '("0" "1")))
          (loop (string-append s i))))))

Teste:

(f 2)
(println "-------------")
(f 3)
(println "-------------")
(f 4)

Resultado:

00
01
10
11
"-------------"
000
001
010
011
100
101
110
111
"-------------"
0000
0001
0010
0011
0100
0101
0110
0111
1000
1001
1010
1011
1100
1101
1110
1111

Ruby 2.x, 129 bytes

f=->(n){z='0';p=n.bit_length;(0..n).map{|i|sprintf("%0#{p}d",i.to_s(2))}.sort{|a,b|a=a.delete(z).size-(b=b.delete(z).size)||b-a}}

PHP, 49 bytes

while($i<1<<$n=$argv[1])printf("%0${n}b\n",$i++);

Corra com -r.

MATLAB, 68 bytes

d=@(n)dec2bin(sortrows([sum(dec2bin(0:2^n-1)');0:2^n-1]')*~eye(2,1))

Bash, 65 bytes

Golfe

seq -f "obase=2;%g+2^$1-1" $[2**$1]|bc|cut -c2-|tr 0 ~|sort|tr ~ 0

Teste

>./binseq 4

0000
0001
0010
0100
1000
0011
0101
0110
1001
1010
1100
0111
1011
1101
1110
1111

Gelatina , 14 bytes

2Ḷṗ⁸TṪ$N$ÞSÞYȯ

Experimente online!

Surpreendeu que isso ainda não tivesse sido publicado.