Geben Sie bei einer positiven Ganzzahl ndie 2^nbinären Längenfolgen aus, ndie in der folgenden genauen Reihenfolge sortiert sind.

Testfälle:

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

usw.

Zusätzlich ist das Muster der Kombinatorik mit Pascals Dreieck verwandt.

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

usw.

Haskell, 78 Bytes

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

Anwendungsbeispiel: f 2-> [[0,0],[0,1],[1,0],[1,1]].

Wie es funktioniert:

         [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)],[])

Ich arbeite noch daran, aber alle Vorschläge wären sehr dankbar!

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 dank Flp.Tkc gespeichert

4 Bytes dank xnor gespeichert

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

Erläuterung

Dies macht alle binären Zeichenfolgen der Länge x mit:

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

Ich sortiere sie dann nach:

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

sorted(x)priorisiert die Anzahl von 1s, während int(x[::-1],2)die zweite Bedingung priorisiert wird

Zuletzt werden diese mit Zeilenumbrüchen verbunden und gedruckt.

Perl, 63 Bytes

-4 danke an @Ton Hospel.
-2 danke an @Gabriel Benamy.

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

Ausführen mit -E(wodurch die Funktion aktiviert wird say):

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

• "{1,0}"x$_Erstellt eine Zeichenfolge aus $_Zeiten {1,0}( $_ist die Eingabe). Zum Beispiel mit 3: {1,1}{1,0}{1,0}.
• Dann globzaubert man etwas und generiert alle Kombinationen eines Elements aus jeder Gruppe von Klammern (dh alle Kombinationen, die wir drucken möchten).
• Und dann die Sortierung: $b=~y/1//c-$a=~y/1//cvergleicht die Anzahl der 1Zeichenfolgen in jeder Zeichenfolge und $b-$asortiert nach der zweiten Regel , wenn sie dieselbe Nummer haben .

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

Lesbar:

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

Das Unterprogramm ekonvertiert sein Argument in einen mit Nullen aufgefüllten Binärwert als Eingabelänge (z. B. Eingabe von 5 Pads mit Nullen, bis es 5 Zeichen lang ist). Das Unterprogramm fnimmt einen solchen Binärwert und gibt ihm eine Sortiergewichtung entsprechend der Art und Weise, wie er verarbeitet werden soll.

Der Bereich 0 .. [Eingabe] ² -1 wird dann durch eine stabile Sortierung nach Gewicht sortiert (hier bedeutet "stabil", dass zwei Werte, die das gleiche Gewicht haben, in der Reihenfolge zurückgegeben werden, in der sie in der erscheinen Eingabe), und dann werden sie an das Unterprogramm zurückgeführt eund ausgegeben.

Einige von Ihnen haben vielleicht meinen ursprünglichen Beitrag gesehen, aber ich habe das Problem gestern völlig falsch verstanden und es sofort gelöscht, nachdem ich es erkannt habe.

Schläger 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))))))

Testen:

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

Ausgabe:

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++);

Laufen Sie mit -r.

MATLAB, 68 Bytes

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

Bash, 65 Bytes

Golf gespielt

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

Prüfung

>./binseq 4

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

Gelee , 14 Bytes

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

Probieren Sie es online aus!

Überrascht, dass dies noch nicht veröffentlicht wurde.