Entonces se le da un número POSITIVO de base 10 (decimal). Su trabajo es revertir los dígitos binarios y devolver ese número de base 10.

Ejemplos:

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)

Este es un desafío de código de golf , por lo que gana la solución que utiliza menos bytes.

Este es A030101 en el OEIS.

Python , 29 bytes

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

Pruébalo en línea!

Esta es una función anónima, sin nombre, que devuelve el resultado.

Primero, bin(n)convierte el argumento en una cadena binaria. Normalmente lo revertiríamos con la notación de corte [::-1]. Esto lee la cadena con un paso de -1 , es decir, hacia atrás. Sin embargo, las cadenas binarias en Python tienen el prefijo an 0by, por lo tanto, damos el segundo argumento de la división como 1 , diciéndole a Python que lea hacia atrás y termine en el índice 1 , por lo tanto, no lee los índices 1 y 0 .

Ahora que tenemos la cadena binaria hacia atrás, la pasamos int(...)con el segundo argumento como 2 . Esto lee la cadena como un entero de base 2, que luego es implícitamente devuelto por la expresión lambda.

Python, 29 bytes

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

Pruébalo en línea

JavaScript (ES6), 30 28 bytes

Guardado 2 bytes gracias a @Arnauld

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

Básicamente, esto calcula el reverso un bit a la vez: comenzamos con q = 0 ; mientras n es positivo, multiplicamos q por 2, separamos el último bit de n con n>>1y lo sumamos a q con |n%2. Cuando n llega a 0, el número se ha invertido con éxito y devolvemos q .

Gracias a los largos nombres integrados de JS, resolver este desafío de la manera más fácil requiere 44 bytes:

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

Usando recursividad y una cadena, puede obtener una solución de 32 bytes que hace lo mismo:

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

Java 8, 53 47 46 45 bytes

• -4 bytes gracias a Titus
• -1 byte gracias a Kevin Cruijssen

Esta es una expresión lambda que tiene el mismo principio que la respuesta de ETH (aunque la recursión habría sido demasiado detallada en Java, por lo que hacemos un bucle):

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

Pruébalo en línea!

Esto se puede asignar con IntFunction<Integer> f = ..., y luego llamar con f.apply(num). Ampliado, sin golf y comentado, se ve así:

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

|.&.#:

|. marcha atrás

&. debajo

#: base 2

Jalea , 3 bytes

BUḄ

Pruébalo en línea!

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

Mathematica, 19 bytes

#~IntegerReverse~2&

Laberinto, 23 bytes

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

Bueno, esto es incómodo ... esto devuelve el número BINARIO inverso ... Gracias @Martin Ender por señalar mi error y mi error ID 10T. Entonces esto no funciona, tendré que encontrar otra solución.

C, 48 44 43 42 bytes

-1 byte gracias a gurka y -1 byte gracias a anatolyg:

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

Solución anterior de 44 bytes:

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

Solución anterior de 48 bytes:

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

Sin golf y uso:

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 formatea la entrada n como una cadena binaria, invierte, luego vuelve a convertir a un número

Uso / casos de prueba:

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

Pruébalo en línea!

Java (OpenJDK) , 63 bytes

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

Pruébalo en línea!

¡Gracias a poke por -12 bytes y a Cyoce por -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)

Mismo algoritmo (¡y longitud!) Que la respuesta de JavaScript de ETHproductions .

Utilidades Bash / Unix, 24 23 bytes

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

Pruébalo en línea!

PHP, 33 bytes

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

convertir a base2, invertir cadena, convertir a decimal. Guardar en archivo y ejecutar como tubería con -F.

sin construcciones:

iterativo, 41 bytes

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

Mientras que la entrada ha establecido bits, saque un bit de la entrada y empújelo a la salida. Ejecutar como tubería con -nR.

recursivo, 52 bytes

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

MATL , 4 bytes

BPXB

Pruébalo en línea!

Explicación

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

Conjunto de pruebas disponible aquí.

Explicación

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

Japt , 5 bytes

¢w n2

Pruébalo en línea!

Scala, 40 bytes

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

Uso:

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

Explicación:

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

Pruébalo en línea!

Explicación

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

Lote, 62 bytes

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

Explicación: en la primera pasada, %1contiene el parámetro de entrada mientras %2está vacío. Por lo tanto, evaluamos ncomo la mitad de %1y rcomo +%1módulo 2 (el %operador debe duplicarse para citarlo). Si nno es cero, entonces nos llamamos cola recursivamente pasando ny una expresión que se evalúa en la próxima pasada efectivamente duplicando rcada vez.

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)

Lee la entrada de stdin y, en consecuencia, utiliza la binfunción del miscFuncspaquete para convertir de decimal a un vector binario.

Pushy , 19 bytes

¡Sin conversión de base integrada!

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

Pruébalo en línea!

Pushy tiene dos pilas, y esta respuesta hace uso de esto ampliamente.

Hay dos partes dos en este programa. Primero, $&2%v2/;Fconvierte el número a su representación binaria inversa:

            \ 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)

Dado el ejemplo 10, las pilas aparecerían de la siguiente manera en cada iteración:

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]

Podemos ver que después de la iteración final, 0, 1, 0, 1se ha creado en la segunda pila - los dígitos binarios inversas de 10, 0b1010.

La segunda parte del código, L:vK2*;OS#se toma de mi respuesta anterior que convierte binario a decimal . Usando el método descifrado y explicado en esa respuesta, convierte los dígitos binarios en la pila en un entero de base 10 e imprime el resultado.

k, 18 bytes

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

Ejemplo:

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

Explicación:

Aquí iteraré n valores y cada vez que el valor entero iterado se convierta en valor de byte, luego revertiré ese valor de byte y ese valor de byte se convertirá en valor entero.

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

No va a ganar, pero quería adoptar un enfoque diferente en c / c ++ 120 bytes en la función

#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;
}

Para explicar lo que estoy haciendo, utilicé la función de registro para determinar el número de bits utilizados por la entrada. Que una serie de cambios de tres bits hacia la izquierda / derecha, dentro / fuera, par / impar que voltea todo el entero. Finalmente, un poco de desplazamiento para cambiar el número de nuevo a la derecha. El uso de decimales para cambios de bits en lugar de hexadecimal es una molestia, pero ahorró algunos bytes.