Donc , vous êtes donné une POSITIVE base 10 (décimal) nombre. Votre travail consiste à inverser les chiffres binaires et à renvoyer ce nombre base 10.

Exemples:

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)

Il s’agit d’un défi code-golf . La solution utilisant le moins d’octets gagne.

C'est A030101 dans l'OEIS.

Python , 29 octets

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

Essayez-le en ligne!

C'est une fonction anonyme, sans nom, qui renvoie le résultat.

Tout d'abord, bin(n)convertit l'argument en une chaîne binaire. Nous inverserions cela normalement avec la notation slice [::-1]. Ceci lit la chaîne avec un pas de -1 , c'est-à-dire en arrière. Cependant, les chaînes binaires en Python sont préfixées par un 0b, et nous donnons donc le second argument du slicing à 1 , indiquant à Python de lire à l'envers se terminant à l'index 1 , donc pas aux index 1 et 0 .

Maintenant que nous avons la chaîne binaire en arrière, nous la passons int(...)avec le deuxième argument sous la forme 2 . Ceci lit la chaîne comme un entier de base 2, qui est ensuite implicite renvoyé par l'expression lambda.

Python, 29 octets

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

Essayez-le en ligne

JavaScript (ES6), 30 28 octets

2 octets sauvés grâce à @Arnauld

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

Ceci calcule essentiellement l’inverse un bit à la fois: nous commençons avec q = 0 ; tant que n est positif, nous multiplions q par 2, coupons le dernier bit de n avec n>>1et ajoutons-le à q avec |n%2. Lorsque n atteint 0, le nombre a été inversé avec succès et nous renvoyons q .

Grâce aux longs noms intégrés de JS, la solution de facilité est 44 octets:

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

En utilisant la récursivité et une chaîne, vous pouvez obtenir une solution de 32 octets qui fait la même chose:

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

Java 8, 53 47 46 45 octets

• -4 octets grâce à Titus
• -1 octet grâce à Kevin Cruijssen

Il s'agit d'une expression lambda qui a le même principe que la réponse d'ETH (bien que la récursivité aurait été trop détaillée en Java, nous lançons donc en boucle):

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

Essayez-le en ligne!

Ceci peut être assigné avec IntFunction<Integer> f = ..., puis appelé avec f.apply(num). Développé, non-modifié et commenté, il ressemble à ceci:

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 octets

|.&.#:

|. sens inverse

&. en dessous de

#: base 2

Gelée , 3 octets

BUḄ

Essayez-le en ligne!

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

Mathematica, 19 octets

#~IntegerReverse~2&

Labyrinthe, 23 octets

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

Eh bien, c’est maladroit… cela renvoie le numéro BINARY inversé… Merci @Martin Ender d’avoir signalé à la fois mon bogue et mon erreur ID 10T. Donc, cela ne fonctionne pas, je vais devoir trouver une autre solution.

C, 48 44 43 42 octets

-1 octet grâce à gurka et -1 octet grâce à anatolyg:

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

Solution précédente de 44 octets:

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

Solution précédente de 48 octets:

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

Ungolfed et utilisation:

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 octets

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

"% b"% n formate l'entrée n en tant que chaîne binaire, inverse, puis reconverti en nombre

Usage / Cas de test:

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 octets

bRC

Essayez-le en ligne!

Java (OpenJDK) , 63 octets

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

Essayez-le en ligne!

Merci de chercher pour -12 octets et Cyoce pour -8 octets!

Perl 6 , 19 octets

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

Haskell, 36 octets

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

Même algorithme (et longueur!) Que la réponse JavaScript d' ETHproductions .

Utilitaires Bash / Unix, 24 23 octets

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

Essayez-le en ligne!

PHP, 33 octets

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

convertir en base2, chaîne inverse, convertir en décimal. Enregistrer dans un fichier et exécuter en tant que pipe avec -F.

pas de composants intégrés:

itératif, 41 octets

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

Pendant que l’entrée a défini des bits, extrayez-en un peu et transmettez-le à la sortie. Courez comme un tuyau avec -nR.

récursif, 52 octets

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

MATL , 4 octets

BPXB

Essayez-le en ligne!

Explication

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

Pyth, 6 octets

i_.BQ2

Suite de test disponible ici.

Explication

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

Japt , 5 octets

¢w n2

Essayez-le en ligne!

Scala, 40 octets

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

Usage:

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

Explication:

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 octets

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

Groovy, 46 octets

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

CJam , 8 octets

ri2bW%2b

Essayez-le en ligne!

Explication

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

Lot, 62 octets

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

Explication: Lors de la première passe, %1contient le paramètre d'entrée tandis que %2est vide. Nous évaluons donc ncomme moitié %1et rcomme +%1modulo 2 (l' %opérateur doit être doublé pour le citer). Si nn'est pas égal à zéro, nous nous appelons alors la queue récursivement passer net une expression qui est évaluée lors de la prochaine passe doublant à rchaque fois.

C #, 98 octets

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

R, 55 octets

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

Lit les entrées de stdin et utilise par conséquent la binfonction du miscFuncspackage pour convertir le vecteur décimal en un vecteur binaire.

Arrogant , 19 octets

Aucune conversion de base intégrée!

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

Essayez-le en ligne!

Pushy a deux piles, et cette réponse l’utilise beaucoup.

Il y a deux parties deux ce programme. Tout d'abord, $&2%v2/;Fconvertit le nombre en sa représentation binaire inverse:

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

Étant donné l'exemple 10, les piles apparaîtront comme suit à chaque itération:

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]

Nous pouvons voir qu'après l'itération finale, 0, 1, 0, 1a été créé sur la deuxième pile - les chiffres binaires inversés de 10,0b1010 .

La deuxième partie du code, L:vK2*;OS#est tirée de ma réponse précédente, qui convertit les données binaires en valeurs décimales . En utilisant la méthode décrite et expliquée dans cette réponse, il convertit les chiffres binaires de la pile en un entier de base 10 et affiche le résultat.

k, 18 octets

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

Exemple:

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

C #, 167 octets

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

Explication:

Ici, je vais itérer n valeurs et à chaque fois que la valeur entière itérée est convertie en valeur d'octet, puis inverser cette valeur d'octet et cette valeur d'octet est convertie en valeur entière.

c / c ++ 136 octets

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

Cela ne va pas gagner, mais je voulais adopter une approche différente en c / c ++ 120 octets dans la fonction

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

Pour préciser ce que je suis en train de faire, j’ai utilisé la fonction log pour déterminer le nombre de bits utilisés par l’entrée. Puis une série de trois bits décale gauche / droite, intérieur / extérieur, pair / impair qui renverse l’entier entier. Enfin, changez un peu pour décaler le nombre vers la droite. L'utilisation de décimales pour les décalages de bits au lieu d'hex est une tâche difficile, mais cela économise quelques octets.