Geben Sie für jede positive 32-Bit-Ganzzahl ( 1 ≤ n ≤ 0xFFFFFFFF) die Anzahl der zur Darstellung dieser Ganzzahl erforderlichen Bits aus.

Testfälle

| n    | n in binary | bits needed |
|----------------------------------|
| 1    | 1           | 1           |
| 2    | 10          | 2           |
| 3    | 11          | 2           |
| 4    | 100         | 3           |
| 7    | 111         | 3           |
| 8    | 1000        | 4           |
| 15   | 1111        | 4           |
| 16   | 10000       | 5           |
| 128  | 10000000    | 8           |
| 341  | 101010101   | 9           |

4294967295 => 11111111111111111111111111111111 => 32

So f(16)würde drucken oder Rückkehr5

Das ist Code-Golf . Kürzester Code in Bytes gewinnt

05AB1E , 2 Bytes

bg

Probieren Sie es online!

JavaScript (ES6), 18 Byte

f=n=>n&&1+f(n>>>1)

<input type=number min=0 step=1 value=8 oninput="O.value=f(this.value)">
<input id=O value=4 disabled>

x86-Assembly, 4 Byte

Unter der Annahme konstant in EBX:

bsr eax,ebx
inc eax

EAX enthält die Anzahl der für Constant erforderlichen Bits.

Bytes: ☼¢├@

Hexadezimal: ['0xf', '0xbd', '0xc3', '0x40']

Python , 14 Bytes

int.bit_length

Probieren Sie es online!

Labyrinth , 13 12 Bytes

 ?
_:
2/#(!@

Probieren Sie es online!

Erläuterung

Das Programm teilt die Eingabe einfach wiederholt durch 2, bis sie Null ist. Die Anzahl der Schritte wird nachverfolgt, indem der Wert bei jedem Schritt dupliziert wird. Sobald es auf Null reduziert ist, drucken wir die Stapeltiefe (minus 1).

Das Programm startet bei dem, ?der die Eingabe liest. Die Hauptschleife ist dann der darunter liegende 2x2-Block gegen den Uhrzeigersinn:

:   Duplicate current value.
_2  Push 2.
/   Divide.

Sobald der Wert nach einer vollständigen Iteration Null ist, wird das lineare Bit am Ende ausgeführt:

#   Push stack depth.
(   Decrement.
!   Print.
@   Terminate.

C 31 Bytes

f(long n){return n?1+f(n/2):0;}

... Dann habe ich über Rekursion nachgedacht. Von dunkel zu offensichtlich und mit einem Viertel der Länge abgefallen.

Sehen Sie es live auf Coliru

C 43 Bytes

c;
#define f(v)({for(c=0;v>=1l<<c;++c);c;})

Das Aufrufen fmit einem vorzeichenlosen Wert (zB f(42u)) "gibt" seine Bitlänge zurück. Funktioniert sogar für 0u!

Ungolfed und erklärt: (Backslashes weggelassen)

c;
#define f(v)
    ({ // GCC statement-expression

        // Increment c until (1 << c) >= v, i.e
        // that's enough bits to contain v.
        // Note the `l` to force long
        // arithmetic that won't overflow.
        for(c = 0; v >= 1l << c; ++c)
            ; // Empty for body

        c; // Return value
    })

Sehen Sie es live auf Coliru

Mathematica, 9 Bytes

BitLength

Alternative:

Floor@Log2@#+1&
#~IntegerLength~2&

Perl 6 , 7 Bytes

*.msb+1

Versuch es

Erläuterung:

* macht es zu einem WhateverCode-Lambda und gibt an, wo die Eingabe erfolgen soll

.msb on an Int liefert den Index des höchstwertigen Bits (0-basiert)

+1wird mit dem Lambda kombiniert und addiert eins zum späteren Ergebnis des Aufrufs .msb.

C Präprozessor-Makro (mit gcc-Erweiterungen), 26

#define f 32-__builtin_clz

Verwendet die eingebauten führenden Nullen von GCC .

Rufen Sie dies als eine Funktion auf, z f(100).

Probieren Sie es online aus .

Retina , 56 37 Bytes

Diese Lösung funktioniert mit allen erforderlichen Eingabewerten.

Das größte Problem, mit dem Retina bei dieser Herausforderung konfrontiert ist, ist die Tatsache, dass die Zeichenfolgen eine maximale Länge von 2 ^ 30 Zeichen haben. Daher funktioniert die übliche Art des Umgangs mit Zahlen (unäre Darstellung) nicht mit Werten über 2 ^ 30.

Um dieses Problem zu lösen, habe ich einen anderen Ansatz gewählt, bei dem eine Art Dezimaldarstellung von Zahlen beibehalten wurde , bei der jedoch jede Ziffer unär geschrieben ist (ich bezeichne diese Darstellung als Digitunary ). Zum Beispiel würde die Nummer 341wie 111#1111#1#im Digitunary geschrieben werden. Mit dieser Darstellung können wir jetzt mit Zahlen bis zu 2^30/10Ziffern (~ 100 Millionen Ziffern) arbeiten. Es ist weniger praktisch als Standard für beliebige Arithmetik, aber mit ein wenig Aufwand können wir jede Art von Operation ausführen.

HINWEIS: Digitunary könnte theoretisch jede andere Basis verwenden (z. B. 110wäre Binär 1#1##in Base 2 Digitunary), aber da Retina über integrierte Funktionen zum Konvertieren zwischen Dezimal und Unär verfügt und keine direkte Möglichkeit besteht, mit anderen Basen umzugehen, ist Decimal wahrscheinlich die am besten handhabbare Basis.

Der Algorithmus, den ich verwendet habe, macht aufeinanderfolgende ganzzahlige Divisionen durch zwei, bis wir Null erreichen. Die Anzahl der Divisionen, die wir gemacht haben, ist die Anzahl der Bits, die zur Darstellung dieser Anzahl benötigt werden.

Also, wie teilen wir digital durch zwei? Hier ist das Retina-Snippet, das das macht:

(1*)(1?)\1#        We divide one digit, the first group captures the result, the second group captures the remainder
$1#$2$2$2$2$2      The result is put in place of the old number, the remainder passes to the next digit (so it is multiplied by 10) and is divided by two there -> 5 times the remainder goes to the next digit

Dieser Ersatz reicht aus, um eine digitale Zahl durch 2 zu teilen. Wenn die ursprüngliche Zahl ungerade war, müssen wir nur mögliche .5s vom Ende entfernen.

Also, hier ist der vollständige Code, wir teilen ihn durch zwei, bis die Zahl noch Ziffern enthält, und setzen nbei jeder Iteration ein Literal vor die Zeichenfolge: Die Zahl nam Ende ist das Ergebnis.

.                  |
$*1#               Convert to digitunary
{`^(.*1)           Loop:|
n$1                    add an 'n'
(1*)(1?)\1#            |
$1#$2$2$2$2$2          divide by 2
)`#1*$                 |
#                      erase leftovers
n                  Return the number of 'n's in the string

Probieren Sie es online!

Großes Refactoring mit vielen guten Ideen, die rund ein Drittel der Länge ausmachten, alles dank Martin Ender!

Die Hauptidee ist, _als unäres Symbol zu verwenden: Auf diese Weise können wir reguläre Ziffern in unserer Zeichenfolge verwenden, solange wir sie _bei Bedarf wieder in s konvertieren. Auf diese Weise können wir beim Teilen und beim Einfügen mehrerer Bytes viele Bytes einsparen Ziffern.

Hier ist der Code:

<empty line>    |
#               put a # before each digit and at the end of the string 
{`\d            Loop:|
$*_                 Replace each digit with the corrisponding number of _
1`_                 |
n_                  Add an 'n' before the first _
__                  |
1                   Division by 2 (two _s become a 1)
_#                  |
#5                  Wherever there is a remainder, add 5 to the next digit
}`5$                |
                    Remove the final 5 you get when you divide odd numbers
n               Return the number of 'n's in the string

Probieren Sie es online!

Ruby, 19 16 Bytes

->n{"%b"%n=~/$/}

Vielen Dank an Jordan, dass er 3 Bytes abgespielt hat

Jolf, 2 Bytes

lB

Einfach in Binär umwandeln und dann die Länge ermitteln.

Julia 0,4 , 14 Bytes

!n=log2(2n)÷1

Probieren Sie es online!

JavaScript ES6, 19 Byte

a=>32-Math.clz32(a)

Math.clz32Gibt die Anzahl der führenden Null-Bits in der 32-Bit-Binärdarstellung einer Zahl zurück. Um die Anzahl der benötigten Bits zu erhalten, müssen wir diese Zahl von 32 abziehen

f=
  a=>32-Math.clz32(a)
  

pre {
    display: inline;
}

<input id=x type="number" oninput="y.innerHTML = f(x.value)" value=128><br>
<pre>Bits needed: <pre id=y>8</pre></pre>

Bash / Unix-Tools, 16 Byte

dc<<<2o$1n|wc -c

Speichern Sie dies in einem Skript und übergeben Sie die Eingabe als Argument. Die Anzahl der Bits, die für die Darstellung dieser Zahl in Binärform erforderlich sind, wird gedruckt.

Hier ist eine Erklärung:

dc ist ein stapelbasierter Rechner. Seine Eingabe, die in Token zerlegt wird, lautet:

2 - Schieben Sie 2 auf den Stapel.

o - Entferne einen Wert vom Stack (das ist 2) und mache ihn zur Ausgabebasis (die Ausgabe ist jetzt binär).

Der Wert des Arguments an das Bash-Programm ($ 1) - Verschieben Sie dieses Argument auf den Stapel.

n - Entferne einen Wert vom Stack (das ist die Eingabe-Nummer) und drucke ihn (binär, weil das die Ausgabe-Basis ist) ohne nachfolgende Newline.

Der Befehl dc gibt die Zahl also binär aus.

Die Ausgabe von dc wird mit der Option -c an den Befehl wc weitergeleitet, der die Anzahl der Zeichen in seiner Eingabe ausgibt.

Das Endergebnis besteht darin, die Anzahl der Stellen in der Binärdarstellung des Arguments auszudrucken.

Google Sheets, 15 Bytes

Übernimmt die Eingabe von der Zelle A1und gibt sie an die Zelle aus, die die Formel enthält

=Len(Dec2Bin(A1

oder

=Int(1+Log(A1,2

oder

=Int(Log(2*A1,2

Excel, 17 Bytes

Wie oben, jedoch für MS Excel formatiert

=Len(Dec2Bin(A1))

oder

=Int(1+Log(A1,2))

oder

=Int(Log(2*A1,2))

Pyth, 3 Bytes

l.B

Test-Suite hier verfügbar.

Erläuterung

l.BQ    Q is implicitly appended
   Q    eval(input)
 .B     convert Q to binary string
l       len(.B(Q))

Gelee, 2 Bytes

BL

Wandelt in Binär um, findet Länge.

C #, 63 45 31 Bytes

Dank Loovjo und TuukkaX wurden 18 Byte gespeichert

14 Bytes gespart, dank Grax

 b=>1+(int)System.Math.Log(b,2);

Es wird verwendet, dass eine Dezimalzahl n ⌊log2 (n) ⌋ + 1 Bits hat, was auf dieser Seite beschrieben wird:

Anzahl der Bits in einer bestimmten Dezimalzahl

Eine positive ganze Zahl n hat b Bits, wenn 2 ^ (b-1) ≤ n ≤ 2 ^ b - 1 ist. Zum Beispiel:

• 29 hat 5 Bits, weil 16 ≤ 29 ≤ 31 oder 2 ^ 4 ≤ 29 ≤ 2 ^ 5 - 1
• 123 hat 7 Bits, weil 64 ≤ 123 ≤ 127 oder 2 ^ 6 ≤ 123 ≤ 2 ^ 7 - 1
• 967 hat 10 Bits, weil 512 ≤ 967 ≤ 1023 oder 2 ^ 9 ≤ 967 ≤ 2 ^ 10 - 1

Bei größeren Zahlen können Sie eine Tabelle mit Potenzen von zwei konsultieren, um die aufeinander folgenden Potenzen zu ermitteln, die Ihre Nummer enthalten.

Um zu sehen, warum dies funktioniert, denken Sie beispielsweise an die binären Darstellungen der ganzen Zahlen 2 ^ 4 bis 2 ^ 5 - 1. Es sind 10000 bis 11111, alle möglichen 5-Bit-Werte.

Logarithmen verwenden

Die obige Methode kann anders ausgedrückt werden: Die Anzahl der Bits ist der Exponent der kleinsten Zweierpotenz, die größer ist als Ihre Zahl. Sie können dies mathematisch wie folgt angeben:

bspec = ⌊log2 (n) ⌋ + 1

Diese Formel besteht aus drei Teilen:

• log2 (n) bedeutet den Logarithmus in der Basis 2 von n, der der Exponent ist, auf den 2 angehoben wird, um n zu erhalten. Zum Beispiel log2 (123) ≈ 6.9425145. Das Vorhandensein eines Bruchteils bedeutet, dass n zwischen Zweierpotenzen liegt.

• ⌊X⌋ ist der Boden von x, der der ganzzahlige Teil von x ist. Beispiel: ,6.9425145⌋ = 6. Sie können sich ⌊log2 (n) ⌋ als Exponenten der höchsten Zweierpotenz in der Binärdarstellung von n vorstellen.

• +1 bringt den Exponenten zur nächsthöheren Zweierpotenz. Sie können sich diesen Schritt so vorstellen, dass Sie die 2 ^ 0-Stelle Ihrer Binärzahl berücksichtigen, die dann die Gesamtzahl der Bits angibt. In unserem Beispiel ist das 6 + 1 = 7. Sie könnten versucht sein, die Deckenfunktion - ⌈x⌈, die die kleinste Ganzzahl größer oder gleich x ist - zu verwenden, um die Anzahl der Bits als solche zu berechnen:

bspec = ⌈log2 (n) ⌉

Dies schlägt jedoch fehl, wenn n eine Zweierpotenz ist.

C #, 32 Bytes

n=>Convert.ToString(n,2).Length;

Konvertiert den Parameter in eine Binärzeichenfolge und gibt die Länge der Zeichenfolge zurück.

Haskell, 20 Bytes

succ.floor.logBase 2

Verfasst eine Funktion, die die Logarithmusbasis 2, Fußböden und Addition 1 annimmt.

Befunge-93 , 23 21 Bytes

&>2# /# :_1>+#<\#1_.@

Befunge ist eine auf 2D-Rastern basierende Sprache (obwohl ich nur eine Zeile verwende).

&                      take integer input
 >2# /# :_             until the top of the stack is zero, halve and duplicate it
          1>+#<\#1_    find the length of the stack
                   .@  output that length as an integer and terminate the program

Probieren Sie es online!

Qualle , 4 Bytes

p#bi

Probieren Sie es online!

Print ( p), die Länge ( #) der Binärdarstellung ( b) der Eingabe ( i).

CJam , 5 Bytes

ri2b,

Probieren Sie es online!

Eingabe lesen ( r), in Ganzzahl konvertieren ( i), Binärdarstellung abrufen ( 2b), Länge abrufen ( ,).

Oktave , 19 Bytes

@(x)ceil(log2(x+1))

Anonyme Funktion, die 1 addiert, den binären Logarithmus berechnet und aufrundet.

Probieren Sie es online!

QBIC , 18 Bytes

:{~2^q>a|_Xq\q=q+1

Das ist unglaublich, Mike! Aber wie geht das?

:        Read input as integer 'a'
{        Start an infinite DO-LOOP
~2^q>a   If 2 to the power of q (which is 1 by default) is greater than a
|_Xq     Then quit, printing q
\q=q+1   Else, increment q
[LOOP is closed implicitly by QBIC]

Java 8, 34 27 Bytes

Für einmal hat Java einige nützliche eingebaute Funktionen! Jetzt brauchen wir nur noch ein paar kürzere Namen ...

x->x.toString(x,2).length()

Probieren Sie es online!

Natürlich können Sie dies auch ohne integrierte Funktionen tun ( siehe Schneemanns Antwort ), jedoch für eine höhere Byteanzahl .

Oktave, 19 Bytes

@(x)nnz(dec2bin(x))    % or
@(x)nnz(de2bi(x)+1)    % or
@(x)nnz(de2bi(x)<2)    % or
@(x)numel(de2bi(x))    % or
@(x)rows(de2bi(x'))

Octave hat zwei Funktionen zum Konvertieren von Dezimalzahlen in Binärzahlen.

dec2binkonvertiert eine Zahl in eine Zeichenkette 1und 0(ASCII-Werte 48und 49). Die Länge der Zeichenfolge entspricht der erforderlichen Anzahl von Bits, sofern nicht anders angegeben. Da die Zeichen 1und 0Nicht-Null sind, können wir verwenden , um nnzdie Anzahl der Elemente wie folgt zu finden: @(x)nnz(dec2bin(x)). Das sind 19 Bytes, also ist es mit Luis Mendos anderer Octave-Antwort verknüpft .

Können wir es besser machen de2bi?

de2biist eine Funktion, die die Binärzahlen als Vektor mit den Zahlen 1und 0als Ganzzahlen und nicht als Zeichen zurückgibt . de2biist offensichtlich zwei Bytes kürzer als dec2bin, aber wir können nicht mehr verwenden nnz. Wir können es verwenden, nnzwenn wir entweder 1zu allen Elementen hinzufügen oder es zu einem logischen Vektor mit nur trueWerten machen. @(x)nnz(de2bi(x)+1)und @(x)nnz(de2bi(x)<2)sind beide 19 Bytes. Wenn Sie verwenden numel, erhalten Sie auch 19 Byte @(x)numel(de2bi(x)).

rowsist ein Byte kürzer als numel, gibt aber de2bieinen horizontalen Vektor zurück, muss also transponiert werden. @(x)rows(de2bi(x)')Zufällig sind es auch 19 Bytes.

Pyke, 3 Bytes

b2l

Probieren Sie es hier aus!

Retina ,  44  23 Bytes

Benötigt zu viel Speicher für große Eingabewerte. Wandelt in Unary um und dividiert dann wiederholt durch 2, wobei gezählt wird, wie oft, bis Null erreicht wird. Die Anzahl der Bytes setzt die Kodierung nach ISO 8859-1 voraus.

.*
$*
+`^(1+)1?\1
$1_
.

Probieren Sie es online aus