Sie erhalten also eine POSITIVE Basis 10 (Dezimalzahl). Ihre Aufgabe ist es, die Binärziffern umzukehren und diese Basis-10-Zahl zurückzugeben.

Beispiele:

1 => 1 (1 => 1)
2 => 1 (10 => 01)
3 => 3 (11 => 11)
4 => 1 (100 => 001)
5 => 5 (101 => 101)
6 => 3 (110 => 011)
7 => 7 (111 => 111)
8 => 1 (1000 => 0001)
9 => 9 (1001 => 1001)
10 => 5 (1010 => 0101)

Dies ist eine Code-Golf- Herausforderung, daher gewinnt die Lösung, die die wenigsten Bytes verwendet.

Dies ist A030101 im OEIS.

Python , 29 Bytes

lambda n:int(bin(n)[:1:-1],2)

Probieren Sie es online!

Dies ist eine anonyme, unbenannte Funktion, die das Ergebnis zurückgibt.

Zuerst bin(n)wandelt das Argument in eine binäre Zeichenfolge. Normalerweise würden wir dies mit der Slice-Notation umkehren [::-1]. Dies liest den String mit einem Schritt von -1 , dh rückwärts. Binären Zeichenfolgen in Python wird jedoch ein vorangestellt 0b, und daher geben wir das zweite Argument des Slicings als 1 an . Dadurch wird Python angewiesen, rückwärts zu lesen und am Index 1 zu enden , sodass die Indizes 1 und 0 nicht gelesen werden .

Nachdem wir nun die rückwärts gerichtete Binärzeichenfolge haben, übergeben wir sie int(...)mit dem zweiten Argument als 2 . Dadurch wird die Zeichenfolge als Ganzzahl zur Basis 2 gelesen, die dann implizit vom Lambda-Ausdruck zurückgegeben wird.

Python, 29 Bytes

lambda n:int(bin(n)[:1:-1],2)

Probieren Sie es online aus

JavaScript (ES6), 30 28 Bytes

2 Bytes dank @Arnauld eingespart

f=(n,q)=>n?f(n>>1,q*2|n%2):q

Dies berechnet im Grunde genommen bitweise die Umkehrung: Wir beginnen mit q = 0 ; während n positiv ist, multiplizieren wir q mit 2, trennen das letzte Bit von n mit n>>1und addieren es zu q mit |n%2. Wenn n 0 erreicht, wurde die Zahl erfolgreich umgekehrt und wir geben q zurück .

Dank der langen integrierten Namen von JS sind für die Lösung dieser Herausforderung auf einfache Weise 44 Byte erforderlich:

n=>+[...n.toString(2),'0b'].reverse().join``

Wenn Sie eine Rekursion und eine Zeichenfolge verwenden, können Sie eine 32-Byte-Lösung erhalten, die dasselbe bewirkt:

f=(n,q='0b')=>n?f(n>>1,q+n%2):+q

Java 8, 53 47 46 45 Bytes

• -4 Bytes dank Titus
• -1 Byte dank Kevin Cruijssen

Dies ist ein Lambda-Ausdruck, der das gleiche Prinzip wie die Antwort der ETH hat (obwohl die Rekursion in Java zu ausführlich gewesen wäre, also schleifen wir stattdessen):

x->{int t=0;for(;x>0;x/=2)t+=t+x%2;return t;}

Probieren Sie es online!

Dies kann mit zugewiesen IntFunction<Integer> f = ...und dann mit aufgerufen werden f.apply(num). Erweitert, ungolfed und kommentiert sieht es so aus:

x -> { 
    int t = 0;           // Initialize result holder   
    while (x > 0) {      // While there are bits left in input:
        t <<= 1;         //   Add a 0 bit at the end of result
        t += x%2;        //   Set it to the last bit of x
        x >>= 1;         //   Hack off the last bit of x
    }              
    return t;            // Return the final result
};

J, 6 Bytes

|.&.#:

|. umkehren

&. unter

#: Basis 2

Gelee , 3 Bytes

BUḄ

Probieren Sie es online!

B   # convert to binary
 U  # reverse
  Ḅ # convert to decimal

Mathematica, 19 Bytes

#~IntegerReverse~2&

Labyrinth, 23 Bytes

?_";:_2
  :   %
 @/2_"!

Nun, das ist umständlich ... dies gibt die umgekehrte BINARY-Nummer zurück ... Vielen Dank an @Martin Ender, dass er sowohl auf meinen Fehler als auch auf meinen ID 10T-Fehler hingewiesen hat. Das funktioniert also nicht, ich muss eine andere Lösung finden.

C 48 44 43 42 Bytes

-1 Byte dank Gurka und -1 Byte dank Anatolyg:

r;f(n){for(r=n&1;n/=2;r+=r+n%2);return r;}

Vorherige 44-Byte-Lösung:

r;f(n){r=n&1;while(n/=2)r=2*r+n%2;return r;}

Vorherige 48-Byte-Lösung:

r;f(n){r=0;while(n)r=2*(r+n%2),n/=2;return r/2;}

Ungolfed und Nutzung:

r;
f(n){
 for(
  r=n&1;
  n/=2;
  r+=r+n%2
 );
 return r;}
}


main() {
#define P(x) printf("%d %d\n",x,f(x))
P(1);
P(2);
P(3);
P(4);
P(5);
P(6);
P(7);
P(8);
P(9);
P(10);
}

Ruby, 29 28 Bytes

->n{("%b"%n).reverse.to_i 2}

"% b"% n formatiert die Eingabe n als Binärzeichenfolge, kehrt sie um und konvertiert sie dann zurück in eine Zahl

Verwendung / Testfälle:

m=->n{("%b"%n).reverse.to_i 2}
m[1] #=> 1
m[2] #=> 1
m[3] #=> 3
m[4] #=> 1
m[5] #=> 5
m[6] #=> 3
m[7] #=> 7
m[8] #=> 1
m[9] #=> 9
m[10] #=> 5

05AB1E , 3 Bytes

bRC

Probieren Sie es online!

Java (OpenJDK) , 63 Byte

a->a.valueOf(new StringBuffer(a.toString(a,2)).reverse()+"",2);

Probieren Sie es online!

Danke an Poke für -12 Bytes und an Cyoce für -8 Bytes!

Perl 6 , 19 Bytes

{:2(.base(2).flip)}

Haskell, 36 Bytes

0!b=b
a!b=div a 2!(b+b+mod a 2)
(!0)

Gleicher Algorithmus (und Länge!) Wie die JavaScript- Antwort von ETHproductions .

Bash / Unix-Dienstprogramme, 24 bis 23 Byte

dc -e2i`dc -e2o?p|rev`p

Probieren Sie es online!

PHP, 33 Bytes

<?=bindec(strrev(decbin($argn)));

In base2 konvertieren, String umkehren, in dezimal konvertieren. In Datei speichern und als Pipe mit ausführen-F .

keine eingebauten:

iterativ 41 Bytes

for(;$n=&$argn;$n>>=1)$r+=$r+$n%2;echo$r;

Während die Eingabe gesetzte Bits hat, platzieren Sie ein Bit von der Eingabe und verschieben Sie es zur Ausgabe. Als Rohr mit laufen lassen-nR .

rekursiv, 52 Bytes

function r($n,$r=0){return$n?r($n>>1,$r*2+$n%2):$r;}

MATL , 4 Bytes

BPXB

Probieren Sie es online!

Erläuterung

B     % Input a number implicitly. Convert to binary array
P     % Reverse array
XB    % Convert from binary array to number. Display implicitly

Pyth, 6 Bytes

i_.BQ2

Test-Suite hier verfügbar.

Erläuterung

i_.BQ2
    Q     eval(input())
  .B      convert to binary
 _        reverse
i    2    convert from base 2 to base 10

Japt , 5 Bytes

¢w n2

Probieren Sie es online!

Scala, 40 Bytes

i=>BigInt(BigInt(i)toString 2 reverse,2)

Verwendung:

val f:(Int=>Any)=i=>BigInt(BigInt(i)toString 2 reverse,2)
f(10) //returns 5

Erläuterung:

i =>          // create an anonymous function with a parameter i
  BigInt(       //return a BigInt contructed from
    BigInt(i)     //i converted to a BigInt
    toString 2    //converted to a binary string
    reverse       //revered
    ,           
    2             //interpreted as a binary string
  )

Mathematica, 38 Bytes

#+##&~Fold~Reverse[#~IntegerDigits~2]&

Groovy, 46 Bytes

{0.parseInt(0.toBinaryString(it).reverse(),2)}

CJam , 8 Bytes

ri2bW%2b

Probieren Sie es online!

Erläuterung

ri          e# Read integer
  2b        e# Convert to binary array
    W%      e# Reverse array
      2b    e# Convert from binary array to number. Implicitly display

Batch, 62 Bytes

@set/an=%1/2,r=%2+%1%%2
@if %n% gtr 0 %0 %n% %r%*2
@echo %r%

Erläuterung: %1Enthält im ersten Durchgang den Eingabeparameter, solange dieser %2leer ist. Wir bewerten daher nals die Hälfte von %1und rals +%1Modulo 2 (der %Operator muss verdoppelt werden, um es zu zitieren). Wenn nnicht Null, rufen wir uns als rekursiv übergebenen Schwanz auf nund ein Ausdruck, der beim nächsten Durchgang ausgewertet wird, verdoppelt sich rjedes Mal.

C # 98 Bytes

using System.Linq;using b=System.Convert;a=>b.ToInt64(string.Concat(b.ToString(a,2).Reverse()),2);

R, 55 Bytes

sum(2^((length(y<-rev(miscFuncs::bin(scan()))):1)-1)*y)

Liest die Eingabe von stdin und verwendet folglich die binFunktion aus dem miscFuncsPaket, um von dezimal in einen binären Vektor zu konvertieren.

Aufdringlich , 19 Bytes

Keine eingebaute Basisumwandlung!

$&2%v2/;FL:vK2*;OS#

Probieren Sie es online!

Pushy hat zwei Stapel, und diese Antwort macht ausgiebig davon Gebrauch.

Dieses Programm besteht aus zwei Teilen. Zuerst wird $&2%v2/;F, wandelt die Zahl in ihrer umgekehrten Binärdarstellung:

            \ Implicit: Input is an integer on main stack.
$      ;    \ While i != 0:
 &2%v       \   Put i % 2 on auxiliary stack
     2/     \   i = i // 2 (integer division)
        F   \ Swap stacks (so result is on main stack)

In dem Beispiel 10 würden die Stapel bei jeder Iteration folgendermaßen aussehen:

1: [10]
2: []

1: [5]
2: [0]

1: [2]
2: [0, 1]

1: [1]
2: [0, 1, 0]

1: [0]
2: [0, 1, 0, 1]

Wir können sehen, dass nach der letzten Iteration 0, 1, 0, 1auf dem zweiten Stapel erstellt wurde - die umgekehrten Binärziffern von 10,0b1010 .

Der zweite Teil des Codes L:vK2*;OS#stammt aus meiner vorherigen Antwort, die Binär in Dezimal umwandelt . Mit der in dieser Antwort beschriebenen und erläuterten Methode werden die Binärziffern auf dem Stapel in eine Ganzzahl zur Basis 10 konvertiert und das Ergebnis ausgegeben.

k, 18 Bytes

{2/:|X@&|\X:0b\:x}

Beispiel:

k){2/:|X@&|\X:0b\:x}6
3

C #, 167 Bytes

 for(int i = 1; i <= 10; i++)
 {
 var bytes= Convert.ToString(i, 2);
 var value= Convert.ToInt32(byteValue.Reverse()); 
 console.WriteLine(value);
}

Erläuterung:

Hier werde ich n Werte iterieren und jedes Mal, wenn ein iterierter ganzzahliger Wert in einen Bytewert konvertiert wird, diesen Bytewert umkehren und diesen Bytewert in einen ganzzahligen Wert konvertieren.

c / c ++ 136 Bytes

uint8_t f(uint8_t n){int s=8*sizeof(n)-ceil(log2(n));n=(n&240)>>4|(n&15)<<4;n=(n&204)>>2|(n&51)<<2;n=(n&172)>>1|(n&85)<<1;return(n>>s);}

Es wird nicht gewinnen, aber ich wollte einen anderen Ansatz in c / c ++ 120 Bytes in der Funktion verfolgen

#include <math.h>
#include <stdio.h>
#include <stdint.h>

uint8_t f(uint8_t n){
    int s=8*sizeof(n)-ceil(log2(n));
    n=(n&240)>>4|(n&15)<<4;
    n=(n&204)>>2|(n&51)<<2;
    n=(n&172)>>1|(n&85)<<1;
    return (n>>s);
}

int main(){
    printf("%u\n",f(6));
    return 0;
}

Um zu erläutern, was ich tue, habe ich die Protokollfunktion verwendet, um die Anzahl der von der Eingabe verwendeten Bits zu bestimmen. Dann eine Reihe von drei Bitverschiebungen nach links / rechts, innen / außen, gerade / ungerade, die die gesamte Ganzzahl spiegeln. Zum Schluss noch ein bisschen verschieben, um die Zahl wieder nach rechts zu verschieben. Die Verwendung von Dezimalstellen für Bitverschiebungen anstelle von Hex ist ein Problem, spart jedoch einige Bytes.