Отже, вам надається ПОЗИТИВНЕ базове 10 (десяткове) число. Ваше завдання - перевернути двійкові цифри та повернути базове 10 число.

Приклади:

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)

Це проблема з кодовим гольфом , тому рішення, що використовує найменше байт, виграє.

Це A030101 в OEIS.

Пітон , 29 байт

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

Спробуйте в Інтернеті!

Це анонімна неназвана функція, яка повертає результат.

Спочатку bin(n)перетворює аргумент у двійковий рядок. Зазвичай ми б це перетворили за допомогою позначення фрагмента [::-1]. Це читає рядок з кроком -1 , тобто назад. Однак бінарні рядки в Python мають префікс an 0b, і тому ми даємо другий аргумент нарізки як 1 , кажучи Python читати назад, що закінчується в індексі 1 , таким чином, не зчитуючи індекси 1 і 0 .

Тепер, коли ми маємо зворотний двійковий рядок, передаємо його int(...)з другим аргументом як 2 . Це читає рядок як ціле число базового 2, яке потім імплікація повертається лямбда-виразом.

Пітон, 29 байт

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

Спробуйте в Інтернеті

JavaScript (ES6), 30 28 байт

Збережено 2 байти завдяки @Arnauld

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

Це в основному обчислює зворотний один біт за один раз: Почнемо з q = 0 ; в той час як п позитивна, ми помножити д на 2, відсікти останній біт геть п з n>>1, і додати його в д з |n%2. Коли n досягає 0, число було успішно перетворено, і повертаємо q .

Завдяки довгим вбудованим іменам JS, вирішення цього завдання найпростішим способом займає 44 байти:

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

Використовуючи рекурсію та рядок, ви можете отримати 32-байтне рішення, яке робить те саме:

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

Java 8, 53 47 46 45 байт

• -4 байти завдяки Титу
• -1 байт завдяки Kevin Cruijssen

Це лямбда-вираз, який має той самий принцип, що і відповідь ETH (хоча рекурсія була б занадто багатослівною в Java, тому ми замість цього циклу):

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

Спробуйте в Інтернеті!

Це можна призначити за допомогою IntFunction<Integer> f = ..., а потім викликати за допомогою f.apply(num). Розгорнутий, неозорений та прокоментований, це виглядає приблизно так:

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 байт

|.&.#:

|. реверс

&. під

#: база 2

Желе , 3 байти

BUḄ

Спробуйте в Інтернеті!

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

Математика, 19 байт

#~IntegerReverse~2&

Лабіринт, 23 байти

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

Ну, це незручно ... це повертає зворотний БІНАРИЙ номер ... Дякую @Martin Ender за вказівку і на мою помилку, і на мою помилку 10T ID. Тож це не працює, мені доведеться знайти інше рішення.

C, 48 44 43 42 байт

-1 байт завдяки гурці та -1 байт завдяки анатолігу:

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

Попереднє рішення 44 байти:

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

Попереднє 48 байт рішення:

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

Безголовка та використання:

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

Рубі, 29 28 байт

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

"% b"% n форматує вхід n як двійковий рядок, обернеться назад, а потім перетворить назад у число

Використання / Тестові випадки:

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 байти

bRC

Спробуйте в Інтернеті!

Java (OpenJDK) , 63 байти

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

Спробуйте в Інтернеті!

Завдяки ткюку на -12 байт та Cyoce на -8 байт!

Perl 6 , 19 байт

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

Haskell, 36 байт

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

Той самий алгоритм (і довжина!), Як і відповідь JavaScript ETHproductions .

Утиліти Bash / Unix, 24 23 байти

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

Спробуйте в Інтернеті!

PHP, 33 байти

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

перетворити в base2, зворотний рядок, перетворити в десятковий. Збережіть у файл та запустіть як pipe -F.

немає вбудованих:

ітеративний, 41 байт

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

Поки для введення встановлено біти, вискочіть трохи з введення та натисніть на вихід. Запустити як труба -nR.

рекурсивна, 52 байти

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

MATL , 4 байти

BPXB

Спробуйте в Інтернеті!

Пояснення

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

Pyth, 6 байт

i_.BQ2

Тут ви знайдете тестовий набір.

Пояснення

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

Japt , 5 байт

¢w n2

Спробуйте в Інтернеті!

Scala, 40 байт

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

Використання:

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

Пояснення:

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
  )

Математика, 38 байт

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

Groovy, 46 байт

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

CJam , 8 байт

ri2bW%2b

Спробуйте в Інтернеті!

Пояснення

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

Пакетна, 62 байти

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

Пояснення: На першому проході %1містить вхідний параметр, поки %2він порожній. Тому ми оцінюємо nяк половину %1і rяк +%1модуль 2 ( %оператор повинен бути подвоєний, щоб процитувати це). Якщо nне дорівнює нулю, ми називаємо себе хвостом, який рекурсивно проходить, nі вираз, який оцінюється при наступному проході, ефективно подвоюється rкожного разу.

C #, 98 байт

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

R, 55 байт

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

Читає вхід з stdin і, отже, використовує binфункцію з miscFuncsпакету для перетворення з десяткового в двійковий вектор.

Пушистий , 19 байт

Немає вбудованої базової конверсії!

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

Спробуйте в Інтернеті!

У Pushy є два стеки, і ця відповідь широко використовує це.

У цій програмі є дві частини. По-перше, $&2%v2/;Fперетворює число у його зворотне бінарне подання:

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

З огляду на приклад 10, стеки виглядатимуть як наступні на кожній ітерації:

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]

Ми можемо бачити, що після остаточної ітерації 0, 1, 0, 1було створено другий стек - зворотні двійкові цифри 10 0b1010,.

Друга частина коду, L:vK2*;OS#взята з моєї попередньої відповіді, яка перетворює двійкове в десяткове . Використовуючи метод, розкритий і пояснений у цій відповіді, він перетворює двійкові цифри на стеку в ціле число базового 10 і друкує результат.

k, 18 байт

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

Приклад:

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

C #, 167 байт

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

Пояснення:

Тут я буду повторювати n значень, і кожен раз, коли ітераційне ціле число перетворюється на байтове значення, потім перевертає це байтове значення, і це байт перетворюється на ціле число.

c / c ++ 136 байт

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

Це не виграє, але я хотів застосувати інший підхід у c / c ++ 120 байтів у функції

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

Щоб детальніше розповісти про те, що я роблю, я використовував функцію журналу, щоб визначити кількість бітів, використаних вхідними даними. Чим є серія з трьох бітових зсувів вліво / вправо, всередині / зовні, парне / непарне, яке перевертає все ціле число. Нарешті трохи зсув, щоб перенести число назад вправо. Використання десяткових знаків для зсуву бітів замість шістнадцяткових - це біль, але це заощадило кілька байт.