Quel est le nombre de bits inverse (binaire)?

33

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 . La solution utilisant le moins d’octets gagne.

C'est A030101 dans l'OEIS.

JuniorRubyist
la source
2
Est-ce que "inverser les bits" signifie inverser ses chiffres binaires? Parfois, cela peut aussi vouloir dire inverser chaque bit .
ETHproductions
Oui. Désolé de ne pas être clair.
juniorRubyist
Ceci et cela sont très similaires.
Geobits
OEIS A030101 .
Orlp
1
"base 10" Pourquoi?
CalculatriceFeline

Réponses:

20

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.

FlipTack
la source
2
Vous battre par 9 secondes.
mbomb007
6
@ mbomb007 donc ma réponse est invalide parce que vous avez cliqué sur le bouton de publication 9 secondes avant l'heure? Ce n’est pas parce que nous atteignons le même golf en même temps que nous devons supprimer des réponses. Si quelque chose, blâmez la question 0 effort.
FlipTack
3
Non invalide, mais certainement inutile. Si j'avais été plus lent, je supprimerais simplement le mien et posterais un commentaire sur celui le plus rapide que je viens de trouver.
mbomb007
1
@steenbergh Qui se soucie? Même code, même score.
mbomb007
17

Python, 29 octets

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

Essayez-le en ligne

mbomb007
la source
1
C'est ce que j'aurais fait. ;)
juniorRubyist
13

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
ETHproductions
la source
f=(n,q)=>n?f(n>>1,q*2|n%2):qfonctionne presque. Mais malheureusement pas pour n=0.
Arnauld
@Arnauld OP n'a pas encore répondu si l'entrée sera toujours positive, mais si tel est le cas, il n'est pas nécessaire de traiter 0.
FlipTack
Il s’agit d’un suivi tardif, mais on sait maintenant que les commentaires sont toujours positifs.
Arnauld
@Arnauld Merci!
ETHproductions
10

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
};
FlipTack
la source
1
Économisez 3 octets avec t*2au lieu de (t<<1), un de plus en déplaçant ce calcul de la tête de boucle au corps de la boucle. Pouvez-vous utiliser xau lieu de x>0pour la condition?
Titus
2
@ Titus non sans casting explicite sur un booléen, mais merci pour les autres conseils! Je viens également de réaliser que cela x>>=1peut être remplacé par x/=2ce qui sera automatiquement une division entière.
FlipTack
45 octets (Modifié t=t*2+en t+=t+.)
Kevin Cruijssen
@KevinCruijssen nice one!
FlipTack
9

J, 6 octets

|.&.#:

|. sens inverse

&. en dessous de

#: base 2

Adam
la source
8

Gelée , 3 octets

BUḄ

Essayez-le en ligne!

B   # convert to binary
 U  # reverse
  Ḅ # convert to decimal
Riley
la source
7
C'est assez court, BUB
Cyoce
Hmm ... Est-ce vraiment 3 octets ?
aioobe
1
@aioobe Yep. La gelée utilise sa propre page de code où chacun de ces caractères est de 1 octet.
Riley
Cool merci! <pad>
aioobe
8

Mathematica, 19 octets

#~IntegerReverse~2&
ngenisis
la source
7

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 Anderson
la source
1
Bienvenue sur PPCG, et bon premier post! Compléter un défi dans une langue comme Labyrinth peut être très difficile. Ici, nous préfixons généralement la première ligne d'une réponse par un ou deux hachages, afin de la faire apparaître en-tête:# Labyrinth, 89 bytes
ETHproductions
1
Avez-vous accidentellement omis un espace de début de la deuxième ligne? Dans l'état actuel des choses, le programme ne ferait que rebondir sur la première ligne, car ils se _trouvent aux carrefours.
Martin Ender
Malheureusement, j'ai juste remarqué que cela n'était pas valable malgré tout, car le défi demandait la représentation en base 10 du nombre inversé, pas sa représentation binaire.
Martin Ender
6

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);
}
Karl Napf
la source
N'est-ce pas rdéjà initialisé à zéro ici r;f(n){r=0;, par exemple le r=0;est inutile? Egalement une faute de frappe mineure: "La solution précédente de 48 octets"
simon
1
@gurka La fonction doit être réutilisable.
Karl Napf
1
Je pense que les forboucles sont toujours au moins aussi courtes whileet souvent plus courtes.
Anatolyg
@anatolyg quelque chose comme: r;f(n){for(r=n&1;n/=2;r=2*r+n%2);return r;}? 1 octet plus court, mais je ne sais pas s'il est valide C (C99).
simon
Oui; aussi, tour =en +=pour le rendre plus court et plus obscurcie
anatolyg
5

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
Alexis Andersen
la source
@ Titus, je pense que vous avez mal compris la réponse. 2est la base vers laquelle il se convertit et nconstitue l’entrée. ->args{return value}est la syntaxe ruby ​​lambda
Cyoce
Pouvez-vous enlever les parenthèses .to_i(2)?
Cyoce
@Cyoce bien sûr, merci.
Alexis Andersen
4

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!

Pavel
la source
Même si les soumissions REPL sont autorisées, elles respectent néanmoins la règle selon laquelle vous ne pouvez pas supposer que l'entrée est dans des variables prédéfinies (comme adans ce contexte)
FlipTack
@ FlipTack Oops. C'était à l'origine une fonction avant que je me souvienne que le remplaçant existait
Pavel
1
Aussi, à l'avenir, utilisez printplutôt que printlnpour le golf :)
FlipTack
1
StringBufferenregistre un octetStringBuilder
Poke
1
Pourriez-vous faire +""au lieu de .toString()?
Cyoce
3

Perl 6 , 19 octets

{:2(.base(2).flip)}
Sean
la source
Où est l'entrée?
Titus
C'est une fonction qui prend un seul paramètre $_. Ce n'est pas mentionné nommément, mais la baseméthode est appelée dessus.
Sean
2
@Titus in Perl 6 a Block est un type de code, c'est-à-dire un objet appelable. Ce qui précède est une expression que vous pouvez utiliser et affecter à une variable telle qu'une fonction ou lambda dans une autre langue, ou appeler directement - {:2(.base(2).flip)}(10)le REPL en imprimera 5. Ainsi, elle répond aux critères standard code-golf d'une fonction.
Hobbs
3

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 .

Lynn
la source
3

Utilitaires Bash / Unix, 24 23 octets

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

Essayez-le en ligne!

Mitchell Spector
la source
Une prise courageuse sur Bash! 😉
juniorRubyist
@juniorRubyist - Merci!
Mitchell Spector
3

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;}
Titus
la source
@ JörgHülsermann Les 44 octets ont $r+=$r. Mais je ne me souviens pas vraiment pourquoi j’ai mis cela devant.
Tite
2

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
Luis Mendo
la source
2

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
Mike Bufardeci
la source
2

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
  )
corvus_192
la source
1

Mathematica, 38 octets

#+##&~Fold~Reverse[#~IntegerDigits~2]&
JungHwan Min
la source
1

Groovy, 46 octets

{0.parseInt(0.toBinaryString(it).reverse(),2)}
Urne Magique De Pieuvre
la source
Est-ce que cela prend des entrées?
Titus
1
@Titus itfait référence à l'argument donné à un bloc IIRC
Cyoce
J'aime la longueur de ma réponse Java - Java et groovy, unissez-vous!
FlipTack
1
@ FlipTack Je vais aller pleurer maintenant.
Magic Octopus Urn
1

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
Luis Mendo
la source
1

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.

Neil
la source
1

C #, 98 octets

using System.Linq;using b=System.Convert;a=>b.ToInt64(string.Concat(b.ToString(a,2).Reverse()),2);
Horváth Dávid
la source
1

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.

Billywob
la source
1

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.

FlipTack
la source
0

k, 18 octets

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

Exemple:

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

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.

Deepak
la source
1
Bienvenue sur le site! Je ne connais pas grand-chose à propos de C #, mais vous avez certainement beaucoup d'espaces supplémentaires à recommander. La manière dont les E / S sont traitées dans cette soumission n’est pas claire non plus. Il est standard d'écrire une fonction ou d'utiliser STDIN(je pense que c'est, console.Read()mais vous le sauriez probablement mieux que moi) et STDOUT. Quoi qu'il en soit, bienvenue sur le site si vous souhaitez des conseils plus expérimentés dans le domaine du golf C #, je vous recommanderais codegolf.stackexchange.com/questions/173/…
Wheat Wizard, le
J'ai voté contre cette réponse, parce que cela ne fonctionne pas du tout. .Reverse()returnes IEnumerable<char>. Comme il Convert.ToInt32n’ya pas de surcharge pour IEnumerable, il lève une exception. De plus, la réponse ne suit pas les règles pour le code golf: 1) Comme rien n'est spécifié, la soumission doit être un programme complet ou une fonction et pas seulement un extrait. 2) les usingdéclarations doivent être incluses dans le nombre d'octets
raznagul
0

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.

mreff555
la source
Vous devez inclure la déclaration de la fonction. Il s’agit donc de 163 octets . Toutefois, si vous supprimez les blancs superflus, vous pouvez les réduire à 136.
DJMcMayhem