10

Convertissez un nombre hexadécimal (de n'importe quelle taille) en nombre binaire.

Entrez
un nombre hexadécimal POSITIF avec un 0xau début. Une entrée valide correspond toujours à l'expression rationnelle suivante: 0x[0-9a-fA-F]+. Si l'entrée n'est pas un nombre hexadécimal valide, c'est-à-dire tout ce qui ne correspond pas à cette expression régulière, la sortie doit être 0.

Sortie
L'hexadécimal converti en binaire.

Gagner les
règles originales du code de golf, le plus petit nombre de piqûres (bytes).

Exemples

IN: 0x12
OUT: 10010

IN: 0xFF
OUT: 11111111

IN: 0XFF
OUT: 0

IN: #0ac4
OUT: 0

IN: 0x00101011
OUT: 100000001000000010001

IN: 0x525600
OUT: 10100100101011000000000

IN: 0x58f70555118ec400
OUT: 101100011110111000001010101010100010001100011101100010000000000

IN: 0x6669795966AF3000
OUT: 110011001101001011110010101100101100110101011110011000000000000

IN: 0b018474
OUT: 0

IN: 9577383
OUT: 0

IN: -483355
OUT: 0

IN: -0xf9ad92
OUT: 0

code-golf base-conversion

— Hashim Kayani
source

7

Lorsque vous dites "si l'entrée n'est pas un nombre hexadécimal valide", quels types de choses peut-il s'agir? Un numéro dans une base différente? Un objet non numérique? Un objet fait pour planter le programme est évalué, peut-être de manière non capturable? Vraiment, j'aurais suggéré d'éviter du tout la validation des entrées; cela ressemble à un défi de caméléon .

— xnor

2

L'inférence de règles à partir de cas de test n'est pas correcte et mettra probablement fin au défi car il n'est pas clair. En plus de cela, les exemples ne sont pas clairs pour moi. "# 0ac4" donne l'impression que n'importe quel caractère supplémentaire peut être inclus.

— xnor

1

Je ne sais toujours pas après l'édition quelles entrées sont possibles. Est-ce #0ac4toujours un cas de test valide?

— xnor

5

Votre deuxième test ne correspond pas à votre expression régulière (le Xest en majuscule).

— Dada

1

Avons-nous besoin de prendre soin des zéros non significatifs? Pouvons-nous produire quelque chose comme00011010

— user41805

3

Pyth, 15 octets

.B&qr0<z2"0x"vz

Explication:

             vz  Evaluate the input as a literal, to get a number (casts to integer for hexadecimal input)
      <z2        Select the first two characters of (string) input
    r0           cast to lowercase (0X -> 0x)
   q     "0x"    check whether the text starts with "0x" or "0X" (negative numbers don't) 
  &              If it does, return the casted number
.B               and convert to binary string

Suite de tests

Avec une clarification des règles (qui 0xdoit être en minuscules) dans l'OP, vous pouvez supprimer r0pour 13 octets.

.B&q<z2"0x"vz

— Steven H.
source

7

Python 2, 67 62 60 59 octets

n=input()
try:print bin(int(n,n[1]<'x'))[2:]
except:print 0

Essayez-le en ligne!

Version contenant des erreurs sur une entrée non valide (27 octets):

lambda n:bin(int(n,16))[2:]

Essayez-le en ligne!

— accro aux mathématiques
source

2

05AB1E , 11 octets

Î2£„0xQi¹Hb

Essayez-le en ligne!

Explication

Î             # initialize stack with 0 and push input
 2£           # get the first 2 chars of input
   „0xQ       # compare to "0x"
       i      # if equal
        ¹H    # convert input from base-16 to base-10
          b   # convert to binary

— Emigna
source

Ne fonctionne pas avec le cas de test 0XFF.

— Okx

@Okx: Le regex et la section d'entrée de la question indiquent que l'entrée correcte commence par 0xdonc je dirais que le cas de test spécifique est faux.

— Emigna

1

Ah ouais, je n'ai pas remarqué ça.

— Okx

9 octets en utilisant le nouveauÅ? ou 10 octets en utilisant toujours l'héritage .

— Kevin Cruijssen

1

Lot, 402 octets

@echo off
set/ps=
set r=0
if not %s:~0,2%==0x goto g
if %s%==0x goto g
if %s:0=%==x goto g
set t=%s%
for %%h in (0 1 2 3 4 5 6 7 8 9 a b c d e f)do call set t=%%t:%%h=%%
if not %t%==x goto g
set s=%s:~2%
for %%h in (0.0000 1.0001 2.0010 3.0011 4.0100 5.0101 6.0110 7.0111 8.1000 9.1001 a.1010 b.1011 c.1100 d.1101 e.1110 f.1111)do call set s=%%s:%%~nh=%%~xh%%
set r=%s:.=%
:g
echo %r:*1=1%

Prend entrée sur STDIN. 8 lignes sont alors principalement gaspillées lors de la validation des entrées, donc les lignes intéressantes sont la ligne 11, qui remplace chaque chiffre hexadécimal par son équivalent binaire, mais en raison des limitations du lot, avec une .ligne principale 12, qui supprime tous les .s et la ligne 14 , ce qui supprime les premiers 0. Cependant, cela échoue pour les entrées comme 0x0"j'invalide" celles qui signifient que 0 est sorti à la place.

— Neil
source

1

PHP, 66 65 63 octets

<?=decbin(hexdec(preg_filter("#^0x([a-f\d]+$)#i","$1",$argn)));

courir comme tuyau avec -F.

Sans le 0x, le pire problème serait que les deux hexdecet base_convertsimplement ignorer les caractères qui ne sont pas hex; mais avec cela, il doit y avoir un contrôle de validité explicite de toute façon.

45 octets sans 0x:

<?=decbin(ctype_xdigit($argn)*hexdec($argn));

— Titus
source

echo stristr($a=$argn,"0X")==$a?decbin(hexdec(ltrim($a,Xx0))):0;Est-ce une belle alternative? Il devrait fonctionner pour les cas de test donnés

— Jörg Hülsermann

@ JörgHülsermann: C'est une bonne alternative, et elle fonctionne pour tous les cas de test donnés , mais elle ne vérifie pas la validité de la valeur hexadécimale (voir mon commentaire sur hexdecet base_convert).

— Titus

Je sais et je pense que la question est une blague avec les cas de test donnés.

— Jörg Hülsermann

1

echo decbin(hexdec(preg_filter("#^0x([a-f\d]+$)#i","$1",$argn)));

— Christoph

-2 octets au <?=lieu de echo avec l'option -F

— Jörg Hülsermann

0

JavaScript (ES6), 109 108 octets

Fonctionne pour n'importe quelle taille d'entrée.

s=>/1.*|0$/.exec((/^0x([\da-f]+)$/i.exec(s)||'_0')[1].replace(/./g,d=>(+`0x1${d}`).toString(2).slice(1)))[0]

Cas de test

Afficher l'extrait de code

let f =

s=>/1.*|0$/.exec((/^0x([\da-f]+)$/i.exec(s)||'_0')[1].replace(/./g,d=>(+`0x1${d}`).toString(2).slice(1)))[0]

console.log(f('0x12'));               // OUT: 10010
console.log(f('0XFF'));               // OUT: 11111111
console.log(f('#0ac4'));              // OUT: 0
console.log(f('0x00101011'));         // OUT: 100000001000000010001
console.log(f('0x525600'));           // OUT: 10100100101011000000000
console.log(f('0x58f70555118ec400')); // OUT: 101100011110111000001010101010100010001100011101100010000000000
console.log(f('0x6669795966AF3000')); // OUT: 110011001101001011110010101100101100110101011110011000000000000
console.log(f('0b018474'));           // OUT: 0
console.log(f('9577383'));            // OUT: 0
console.log(f('-483355'));            // OUT: 0
console.log(f('-0xf9ad92'));          // OUT: 0

Développer l'extrait

— Arnauld
source

Hmm ... 2 golfeurs expérimentés soumettant des solutions JS plus de deux fois aussi longtemps que le mien me demande si j'ai raté quelque chose dans le défi.

— Shaggy

@Shaggy Tout dépend de l'interprétation de la première ligne du défi. Je tenais pour acquis que «de n'importe quelle taille» était une exigence précise - tout comme Neil apparemment.

— Arnauld

@Shaggy Juste pour clarifier pour tout le monde: votre approche fonctionne jusqu'à 0x1fffffffffffff- aka Number.MAX_SAFE_INTEGER- et retourne des résultats arrondis au-delà. Par chance, les deux grands cas de test sont arrondis correctement.

— Arnauld

Huh, je ne savais pas que le code de @ Shaggy fonctionnait par accident; Je suppose que j'aurais dû compter la distance entre le premier et le dernier 1bits du résultat. Au fait, avez-vous besoin $de la première expression rationnelle?

— Neil

@Neil Je ne pense pas pouvoir m'en débarrasser $. L'idée est d'obtenir le zéro final s'il n'y a pas 1du tout dans le résultat.

— Arnauld

0

REXX, 45 octets

arg '0X' n
if n>'' then say x2b(n)
else say 0

— idrougge
source

0

Rétine , 149 octets

.
;$&
T`L`l
f
71
e
70
d
61
c
60
b
51
a
50
9
41
8
40
7
31
6
30
5
21
4
20
3
11
2
10
;(\d{4})
$1
;(\d{3})
0$1
;(\d\d)
00$1
;
000
^(?!0{7}x).*
0
0{7}x0*

(notez la nouvelle ligne de fin)

Essayez-le en ligne!

Voici une solution alternative au prix de 7 octets: Essayez-la!

— user41805
source

Légèrement golfé . Approche alternative .

— Neil

0

perl, 25

(code 24 + 1 drapeau -n)

printf"%8b",/^0x/i?hex:0

— Toto
source

0

JavaScript (ES6), 116 111 octets

f=
s=>/^0x[\da-f]+$/i.test(s)?s.replace(/./g,c=>parseInt(4+c,36).toString(2).slice(-4)).replace(/0+10*(.)/,'$1'):0

<input oninput=o.textContent=f(this.value)><pre id=o>0

Développer l'extrait

Pas limité à 53 bits de précision. Edit: économisé 5 octets en réécrivant ma conversion de chiffres, ce qui réduit également mes exigences linguistiques à ES6.

— Neil
source

Vous pouvez réduire la longueur de 13 octets en évaluant chaque caractère comme valeur hexadécimale. Essayez-le en ligne

— fəˈnɛtɪk

@ fəˈnɛtɪk Cela ne résout pas la question posée.

— Neil

Ici, j'ai supprimé les zéros non significatifs de la première conversion Essayez-le en ligne toujours 2 octets plus court.

— fəˈnɛtɪk

@ fəˈnɛtɪk Je l'ai combiné avec la réponse d'Arnauld et je suis descendu à 103: Essayez-le en ligne!

— Neil

@ fəˈnɛtɪk Attendez, cela ne fonctionne pas pour le cinquième cas de test 0x00101011, désolé.

— Neil

0

Code machine 8086 - 63 octets

Fonctionne pour n'importe quelle entrée jusqu'à 125 caractères (la longueur de ligne de commande maximale sous DOS)

00000000  be 82 00 bf 3f 01 89 fa  ad 3d 30 78 75 24 ac 3c  |....?....=0xu$.<|
00000010  0d 74 22 2c 30 3c 09 76  08 24 df 2c 07 3c 0f 77  |.t",0<.v.$.,.<.w|
00000020  11 b1 04 c1 e0 0c d0 e4  0f 92 c0 0c 30 aa e2 f6  |............0...|
00000030  eb dc ba 3d 01 b0 24 aa  b4 09 cd 21 c3 30 24     |...=..$....!.0$|
0000003f

— user5434231
source

0

JavaScript (ES6), 53 52 49 50 52 45 octets

(Non compétitif car il ne gère pas les entrées de toute taille; j'ai juste eu de la chance avec les entrées d'échantillon)

f=

h=>+/^0x[\da-f]+$/i.test(h)&&(+h).toString(2)

console.log(f`0x12`);
console.log(f`0XFF`);
console.log(f`#0ac4`);
console.log(f`0x00101011`);
console.log(f`0x525600`);
console.log(f`0x58f70555118ec400`);
console.log(f`0x6669795966AF3000`);
console.log(f`0b018474`);
console.log(f`9577383`);
console.log(f`-483355`);
console.log(f`-0xf9ad92`);

Développer l'extrait

— Hirsute
source

0

CJam , 24 octets

q2/("0x"={seu:~Gb2bo}&;0

Essayez-le en ligne!

Explication

q      e# Read the input
2/     e# Split it into 2-length segments
(      e# Pull out the first segment
"0x"=  e# Check if it equals "0x"
{      e# If it does, run this block:
 s     e#  Join the segments back together
 eu    e#  Make the string uppercase
 :~    e#  Eval each character (A-K are 10-20)
 Gb    e#  Convert from base 16 to base 10
 2b    e#  Convert to base 2
 o     e#  Output the binary number
}&     e# (end of block)
;0     e# Delete the top stack element and push 0. If the block was run, nothing is left
       e# on the stack, so the program terminates with an error before pushing 0.

— Chat d'affaires
source

0

JavaScript (ES6), 107 caractères

f=
b=>/0x[\da-f]+$/i.test(b)&&b.match(/[\da-f](?!x)/gi).map(x=>((+('0x1'+x)).toString(2)).slice(-4)).join('')||0

console.log(f('0x1f'))
console.log(f('0x6669795966AF3000'))

Développer l'extrait

— Tomas Langkaas
source

0

Perl 6 , 35 octets

{(m/^0x(.+)/&&:16(~$0)//0).base(2)}

— Sean
source

0

Javascript, 63 octets

f=
x=>0|/^0x[A-Fa-f0-9]+$/.test(x)&&Number.parseInt(x).toString(2)

— Steve Bennett
source

Hexadécimal en binaire

Pyth, 15 octets

Python 2, 67 62 60 59 octets

05AB1E , 11 octets

Lot, 402 octets

PHP, 66 65 63 octets

JavaScript (ES6), 109 108 octets

Cas de test

REXX, 45 octets

Rétine , 149 octets

perl, 25

JavaScript (ES6), 116 111 octets

Code machine 8086 - 63 octets

JavaScript (ES6), 53 52 49 50 52 45 octets

CJam , 24 octets

JavaScript (ES6), 107 caractères

Perl 6 , 35 octets

Javascript, 63 octets