... Ah sorry, kein Popcorn hier, nur POPCNT.

Schreiben Sie das kürzeste Programm oder die kürzeste Funktion, die eine Zahl aufnimmt, nund geben Sie alle Ganzzahlen von 0 bis 2 ⁿ - 1 in aufsteigender Reihenfolge der Anzahl von 1 Bits in der binären Darstellung der Zahlen aus (Popcount) aus. Duplikate sind nicht erlaubt.

Die Reihenfolge der Nummern mit demselben Popcount ist implementierungsspezifisch.

Beispielsweise sind für n = 3alle diese Ausgaben gültig:

0, 1, 2, 4, 3, 5, 6, 7
[0, 4, 1, 2, 5, 3, 6, 7]
0 4 2 1 6 5 3 7 

Das Eingabe- und Ausgabeformat ist implementierungsdefiniert, um die Verwendung von Sprachfeatures zu ermöglichen, um den Code weiter zu verbessern. Die Ausgabe unterliegt einigen Einschränkungen:

• Die Zahlen müssen im Dezimalformat ausgegeben werden.

• Die Ausgabe muss ein angemessenes Trennzeichen zwischen den Zahlen enthalten (nachstehendes Trennzeichen zulässig, jedoch nicht führend).

  Zeilenvorschub ( \n), Register ( \t), Raum, ,, ., ;, |, -, _, /ist durchaus sinnvoll Separator. Ich mag keine zusätzlichen Leerzeichen für hübsches Drucken, benutze aber keine Buchstaben oder Ziffern als Trennzeichen.

• Die Zahlen und Separatoren können durch umgeben sein [ ], { }oder jede Anordnung oder Liste Notation.
• Drucken Sie nichts anderes, als oben angegeben.

Bonus

Multiplizieren Sie Ihre Punktzahl mit 0,5 wenn Ihre Lösung die Zahl im Handumdrehen erzeugen kann. Der Sinn dieses Bonus ist, dass, wenn Sie Ihre Drucklösung direkt in einen Generator umwandeln, der Generator nur höchstens O (n) Speicher verwendet, wobei n die oben definierte Anzahl von Bits ist. (Sie müssen Ihre Lösung nicht unbedingt auf Generator umstellen). Beachten Sie, dass, während ich n <= 28 auferlege, der zum Speichern aller Zahlen benötigte Speicher immer noch exponentiell wächst und eine naive Sortierlösung mindestens 4 GB Speicher bei n = 28 belegen würde.

Bitte erläutern Sie kurz, wie Ihre Lösung funktioniert, bevor Sie diesen Bonus in Anspruch nehmen.

Pyth, 9 Bytes

osjN2U^2Q

oDurch die sum der Basis 2 liegende Darstellung ( jN2) über den Bereich ( U) von 2 ^ Q.

( Q= eval(input())).

Probieren Sie es hier aus.

Python 2, 75 * 0,5 = 37,5

N=2**input()-1
v=N-~N
while v:t=1+(v|~-v);v=N&t|~-(t&-t)/(v&-v)/2;print v^N

vMit diesem Bit-Twiddling-Algorithmus wird wiederholt der nächsthöhere Wert mit demselben POPCOUNT generiert .

Tatsächlich stellte sich heraus, dass es einfacher war, sie in abnehmender Popanzahl zu generieren und dann das Komplement auszudrucken, um es zu vergrößern. Auf diese Weise entfernen wir bei vÜberläufen 2**neinfach alle bis auf nBits mit &NwhereN=2**n-1 , und das ergibt die kleinste Popcount-Nummer, die um eins niedriger ist. Auf diese Weise können wir nur eine Schleife machen. Es gibt wahrscheinlich eine bessere Lösung, die mit demselben POPCOUNT direkt die nächstniedrigere Nummer findet.

Aufgrund eines Zaunpfostenproblems müssen wir mit beginnen v=2**(n+1)-1 , dass die Operation v=N-1in der ersten Schleife ausgeführt wird.

Ausgabe für 4:

0
8
4
2
1
12
10
9
6
5
3
14
13
11
7
15

J, 19 Zeichen, kein Bonus.

[:(/:+/"1@#:)@i.2^]

• 2 ^ y- Zwei hoch y.
• i. 2 ^ y- die ganzen Zahlen von 0bis (2 ^ y) - 1.
• #: i. 2 ^ y - jede dieser ganzen Zahlen in der Basis zwei dargestellt.
• +/"1 #: i. 2 ^ y - die Beträge jeder Vertretung
• (i. 2 ^ y) /: +/"1 #: i. 2 ^ y- der Vektor i. 2 ^ ysortiert nach der Reihenfolge der Elemente des vorherigen Vektors, unserer Antwort.

Python, 63 Zeichen

F=lambda n:`sorted(range(1<<n),key=lambda x:bin(x).count('1'))`

>>> F(3)
'[0, 1, 2, 4, 3, 5, 6, 7]'

C 179 * 0,5 = 89,5

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(;n--;++i){for(o=0;o<m;++o){int bc=0,cb=28;for(;cb--;)bc+=o&(1<<cb)?1:0;if(bc==i)printf("%d ",o);}}printf("%d\n",m);return 0;}

EDIT: 157 * 0,5 = 78,5

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(++n;n--;++i){for(o=0;o<=m;++o){int bc=0,cb=28;for(;cb--;)bc+=o&(1<<cb)?1:0;if(bc==i)printf("%d ",o);}}}

EDIT: 132 * 0,5 = 66

main(){int n,i=0,m,o;scanf("%d",&n);m=~((~0)<<n);for(++n;n--;++i){for(o=0;o<=m;++o){if(__builtin_popcount(o)==i)printf("%d ",o);}}}

oder etwas besser formatiert:

main()
{
    int n, i = 0, m, o;
    scanf("%d", &n);
    m = ~((~0) << n);
    for(++n; n--; ++i)
    {
        for(o = 0; o <= m; ++o)
        {
            if (__builtin_popcount(o) == i)
                printf("%d ", o);
        }
    }
}

Was es macht?

m = ~((~0) << n);

berechnet die letzte anzuzeigende Zahl (pow (2, n) - 1)

    for(++n; n--; ++i)
    {
        for(o = 0; o <= m; ++o)
        {

Die äußere Schleife durchläuft die Anzahl der Bits (also 0 bis n-1), während die innere Schleife nur von 0 bis m zählt

            if (__builtin_popcount(o) == i)
                printf("%d ", o);

Auf x86 gibt es den POPCNT-Befehl, mit dem die gesetzten Bits gezählt werden können. GCC und kompatible Compiler unterstützen möglicherweise die Funktion __builtin_popcount, die im Wesentlichen für diese Anweisung kompiliert wird.

CJam, 13 Bytes

2ri#,{2b1b}$p

Ziemlich einfache Implementierung.

Wie es funktioniert :

2ri#,             "Get an array of 0 to 2^n - 1 integers, where n is the input";
     {    }$      "Sort by";
      2b1b        "Convert the number to binary, sum the digits";
            p     "Print the array";

Probieren Sie es hier online aus

Mathematica, 50 46

SortBy[Range[0,2^#-1],Tr@IntegerDigits[#,2]&]&

.

SortBy[Range[0,2^#-1],Tr@IntegerDigits[#,2]&]&

{0, 1, 2, 4, 8, 16, 3, 5, 6, 9, 10, 12, 17, 18, 20, 
24, 7, 11, 13, 14, 19, 21, 22, 25, 26, 28, 15, 
23, 27, 29, 30, 31}

JavaScript (ES6) 41 (82 * 0,5)

Der einfachste Weg, Golf zu spielen

F=b=>{
  for(l=0;l<=b;l++)
    for(i=1<<b;i;t||console.log(i))
      for(t=l,u=--i;u;--t)
        u&=u-1;
}

Ungolfed

F=b=>
{
  for (l = 0; l <= b; l++)
  {
    for (i = 1 << b; i > 0; )
    {
      --i;
      for (t = 0, u = i; u; ++t) // Counting bits set, Brian Kernighan's way
        u &= u - 1;
      if (t == l) console.log(i);
    }
  }
}

Test In der Firefox / FireBug-Konsole

F(4)

0
8
4
2
1
12
10
9
6
5
3
14
13
11
7
15

Bash + Coreutils, 66

Eines, um Ihnen den Einstieg zu erleichtern:

jot -w2o%dpc $[2**$1] 0|dc|tr -d 0|nl -ba -v0 -w9|sort -k2|cut -f1

Haskell, (87 × 0,5) = 43,5

f n=[0..n]>>=(\x->x#(n-x))
a#0=[2^a-1]
0#_=[0]
a#b=[1+2*x|x<-(a-1)#b]++[2*x|x<-a#(b-1)]

Verwendungsbeispiel:, f 4welches ausgibt[0,1,2,4,8,3,5,9,6,10,12,7,11,13,14,15]

So funktioniert es: Weder sortieren noch wiederholt über [0..2 ^ n-1] iterieren und nach Zahlen suchen, die i 1s enthalten.

Die #Hilfsfunktionen akzeptieren zwei Parameter aund berstellen eine Liste aller Zahlen, die aus aEinsen und bNullen bestehen. Die Hauptfunktion fverlangt #nach jeder Kombination vona und bwo a+bgleich ist n, beginnend mit einer 1 und einer n0, um die Zahlen in der richtigen Reihenfolge zu haben. Dank Haskells Faulheit müssen all diese Listen nicht vollständig im Speicher erstellt werden.

Ruby 47 Zeichen

Ähnlich wie beim Python von @KeithRandall:

f=->n{(0..1<<n).sort_by{|x|x.to_s(2).count ?1}}

Mathematica, 26

Tr/@(2^Subsets@Range@#/2)&

Beispiel:

Tr/@(2^Subsets@Range@#/2)&[4]

{0, 1, 2, 4, 8, 3, 5, 9, 6, 10, 12, 7, 11, 13, 14, 15}

Perl, 64/2 = 32

#!perl -ln
for$i(0..$_){$i-(sprintf"%b",$_)=~y/1//||print for 0..2**$_-1}

Einfach [0..2^n-1] n + 1mal über den Bereich iterieren . In jeder Iteration werden nur die Zahlen ausgegeben, deren Anzahl von 1 Bit der Iterationsvariablen ( $i) entspricht. Bits werden durch Zählen von 1s ( y/1//) in der Zahl gezählt, die mit in eine Binärzeichenfolge umgewandelt wurde sprintf.

Teste mich .

Perl, 63

Sortieransatz:

#!perl -l
print for sort{eval+(sprintf"%b-%b",$a,$b)=~y/0//dr}0..2**<>-1

Java 8, 205

public class S{public static void main(String[] n){java.util.stream.IntStream.range(0,1<<Integer.parseInt(n[0])).boxed().sorted((a,b)->Integer.bitCount(a)-Integer.bitCount(b)).forEach(System.out::print);}}

C ++ 11, 117 Zeichen:

using namespace std;int main(){ set<pair<int,int> > s;int b;cin>>b;int i=0;while(++i<pow(2,b))s.insert({bitset<32>(i).count(),i});for (auto it:s) cout <<it.second<<endl;}

Ungolfed:

using namespace std;
int main()
{
    set<pair<int,int> > s;
    int b;
    cin>>b;
    int i=0;
    while (++i<pow(2,b))  {
        s.insert({bitset<32>(i).count(),i});
    }
    for (auto it:s) {
        cout <<it.second<<endl;
    }
}

Erläuterung:

Erstellen Sie eine Reihe von int, int-Paaren. Das erste int ist die Anzahl der Bits, das zweite int ist die Anzahl. Paare vergleichen sich nach ihrem ersten Parameter, sodass die Menge nach der Anzahl der Bits sortiert wird.