Convertir un nombre en hexadécimal

23

Défi

En voici une simple.

Écrivez une fonction ou un programme lorsque vous lui donnez un nombre en base 10 en entrée, il retournera ou imprimera la valeur de ce nombre en hexadécimal .

Exemples

15 -> F
1000 -> 3E8
256 -> 100

Règles

  • Aucune fonction hexadécimale intégrée
  • Les lettres peuvent être en minuscules ou en majuscules
  • Vous n'aurez qu'à vous soucier des entiers non négatifs, pas de négatifs ou de décimales embêtantes
  • Il devrait fonctionner avec n'importe quel nombre arbitrairement grand jusqu'à la limite du type par défaut de la langue.
  • Newline non obligatoire
  • Comme d'habitude, c'est le , donc le code le plus court mesuré en octets gagne!
Type au hasard
la source
Premier problème, j'espère que vous apprécierez!
Random Guy
5
Les zéros non significatifs sont-ils autorisés dans la sortie, par exemple pour les nombres 32 bits 000003E8?
nimi
Une limite sur l'entrée?
Loovjo
1
@nimi Oui, c'est permis.
Random Guy
1
Fait amusant: C ++ a un hex intégré.
Matthew Roh

Réponses:

4

APL (Dyalog APL) , 17 octets

Doit être exécuté avec ⎕IO←0, ce qui est par défaut sur de nombreux systèmes APL.

(⎕D,⎕A)[16⊥⍣¯1⊢⎕]

Essayez-le en ligne!

(⎕D,⎕A)[... ]D igits concaténer A lphabet, puis indexés par ...

16⊥⍣¯1  l'inverse de 16-Base-to-Number, c'est-à-dire Number-to-Base-16

 appliqué à

 entrée numérique

Adam
la source
N'est-ce pas 17 caractères et environ 23 octets?
Julie Pelletier
1
@JuliePelletier Non, Dyalog APL utilise sa propre page de code de 256 caractères.
Adám
Oh! Bon à savoir.
Julie Pelletier
14

Code machine de Turing, 412 octets

Comme d'habitude, j'utilise la syntaxe de table de règles définie ici. Vous pouvez le tester sur ce site ou, en variante, en utilisant cette implémentation java.

0 * * l B
B * * l C
C * 0 r D
D * * r E
E * * r A
A _ * l 1
A * * r *
1 0 9 l 1
1 1 0 l 2
1 2 1 l 2
1 3 2 l 2
1 4 3 l 2
1 5 4 l 2
1 6 5 l 2
1 7 6 l 2
1 8 7 l 2
1 9 8 l 2
1 _ * r Y
Y * * * X
X * _ r X
X _ _ * halt
2 * * l 2
2 _ _ l 3
3 * 1 r 4
3 1 2 r 4
3 2 3 r 4
3 3 4 r 4
3 4 5 r 4
3 5 6 r 4
3 6 7 r 4
3 7 8 r 4
3 8 9 r 4
3 9 A r 4
3 A B r 4
3 B C r 4
3 C D r 4
3 D E r 4
3 E F r 4
3 F 0 l 3
4 * * r 4
4 _ _ r A

Compte à rebours à partir de l'entrée en base 10 en comptant à partir de 0 en base 16. En décrémentant zéro, il efface le bloc d'entrée et se termine.

SuperJedi224
la source
C'est vraiment cool, il faut des 10*n + 33instructions à remplir pour tout arbitraire n. Je ne comprends pas le code cependant.
Magic Octopus Urn
@MagicOctopusUrn Il crée un nouveau bloc de cellules à gauche de l'entrée, contenant initialement un 0. Ensuite, il décrémente à plusieurs reprises le bloc d'entrée en base 10 tout en incrémentant le bloc de sortie en base 16, jusqu'à ce qu'il tente de décrémenter une cellule vide pendant le cycle de décrémentation [qui lui indique que le bloc d'entrée est maintenant à 0], moment auquel il nettoie la bande (de sorte que seule la sortie reste sur la bande) avant de s'arrêter.
SuperJedi224
@MagicOctopusUrn De plus, votre équation pour l'exécution est incorrecte (je ne sais pas quelle est l'équation générale correcte, juste que ce n'est clairement pas le cas). Essayez-le avec une entrée de 2, par exemple.
SuperJedi224
probablement pas. Semblait proche pour des valeurs élevées. Je n'en sais rien et essayais de voir des schémas.
Urne de poulpe magique
9

Java, 92 89 octets

String x(int v){String z="";for(;v>0;v/=16)z="0123456789ABCDEF".charAt(v%16)+z;return z;}
SuperJedi224
la source
9

Javascript, 49 43 octets.

h=i=>(i?h(i>>4):0)+"0123456789abcdef"[i%16]

6 octets enregistrés par user81655 .

Testez-le ici .

Cela comporte deux zéros non significatifs, ce qui est autorisé par les règles.

Voici une version sans zéros non significatifs: (47 octets).

h=i=>(i>15?h(i>>4):"")+"0123456789abcdef"[i%16]

Testez-le ici .

Ces deux utilisent exactement la même approche que ma réponse Python .

Loovjo
la source
Utilisez AND binaire. i&15sera automatiquement converti en entier, en supprimant les décimales. Pas besoin de~~
edc65
J'ai économisé 3 octets et un zéro de tête:h=i=>i&&h(i>>4)+"0123456789abcdef"[i&15]
Neil
8

CJam, 22 21 octets

ri{Gmd_A<70s=+\}h;]W%

Merci à @ MartinBüttner pour avoir joué au golf sur 1 octet!

Essayez-le en ligne!

Comment ça marche

ri                      e# Read an integer from STDIN.
  {             }h      e# Do:
   Gmd                  e#   Push qotient and residue of the division by 16.
      _A<               e#   Check if the residue is less than 10.
         70s            e#   Push "70".
            =           e#   Select the character that corresponds to the Boolean.
             +          e#   Add the character to the digit.
                        e#   This way, 10 -> 'A', etc.
               \        e#   Swap the quotient on top of the stack.
                        e# While the quotient is non-zero, repeat the loop.
                  ;     e# Pop the last quotient.
                   ]W%  e# Reverse the stack.
Dennis
la source
5
Même nombre d'octets:ri{Gmd_9>7*sc+\}h;]W%
Martin Ender
6

Pyth, 33 26 21 20 octets

C'était amusant.

sm@+jkUTGi_d2_c_.BQ4

Essayez-le en ligne.

Expliqué:

                .BQ      Convert input to a binary string, e.g. 26 -> '11010'
             _c_   4     Reverse, chop into chunks of 4, and reverse again. We reverse 
                         because chop gives a shorter last element, and we want a shorter
                         first element: ['1', '0101']
                         Reversing three times is still shorter than using .[d4 to pad the
                         binary string to a multiple of 4 with spaces.
 m                       Map across this list:
         i_d2                Take the value of the reversed string in binary,
  @                          and use it as an index into the string:
   +jkUTG                    '0123456789abcdefghijklmnopqrstuvwxyz'
                             (The alphabet appended to the range 0 to 10)
s                        Concatenate to create the final string.
Luc
la source
Pouvez-vous ajouter une explication?
TanMath
Bien sûr, lequel êtes-vous intéressé?
Luke
La réponse la plus intéressante! ;) cela n'a pas d'importance ... Bien que ce soit une bonne idée de publier des explications pour chacun d'eux
TanMath
5

C (fonction), 51

La fonction récursive prend un entier en entrée comme paramètre:

f(n){n>>4?f(n>>4):0;n&=15;n+=n>9?55:48;putchar(n);}

Pilote de test:

#include <stdio.h>

f(n){if(n>>4)f(n>>4);n&=15;n+=n<10?48:55;putchar(n);}

int main (int argc, char **argv) {

    f(15);puts("");
    f(1000);puts("");
    f(256);puts("");
    f(0);puts("");

    return 0;
}
Traumatisme numérique
la source
5

Haskell, 59 58 43 41 39 octets

s="0123456789ABCDEF"
(sequence(s<$s)!!)

Exemple d'utilisation: sequence(s<$s)!!) $ 1000-> "00000000000003E8".

Cela crée une liste de tous les nombres hexadécimaux jusqu'à 16 chiffres hexadécimaux. Heureusement, cela se passe dans l'ordre, nous pouvons donc simplement choisir le ne.

Edit: @Mauris a pressé 2 octets. Merci!

nimi
la source
Liste des données
monad
@Daenyth: Je suis passé de Monad à Functor
nimi
Que diriez-vouss="0123456789ABCDEF";(sequence(s<$s)!!)
Lynn
@Mauris: génial!
nimi
4

dc, 37

?[16~rd0<m]dsmxk[A~r17*+48+Pz0<p]dspx

Divmod récursivement par 16, poussant le reste dans la pile jusqu'à ce qu'il ne reste plus rien à diviser. Imprimez ensuite chaque élément de la pile, en utilisant divmod par 10 pour obtenir des chiffres AF. Probablement plus de détails demain ... (et, espérons-le, moins d'octets).

Traumatisme numérique
la source
4

Python, 59 58 octets

h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16]

1 octet enregistré par CarpetPython

Courir comme: print h(15)

Testez-le ici (Ideone.com).

Explication:

h=lambda i:                                                 # Define h as a function that takes two arguments
           (i>15 and h(i/16)or'')                           # Evaluate h(i/16) if i > 15, else, give ''
                                 +"0123456789abcdef"[i%16]  # Append (i%16)'th hexadecimal number.
Loovjo
la source
1
Bon travail. Vous pouvez également enregistrer un autre octet avec h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16].
Logic Knight
Beau travail en effet, vous pouvez en sauver deux autres comme ceci:h=lambda i:(i>15 and h(i/16)or'')+chr(48+i%16+i%16/10*7)
Willem
4

C (gcc) , 45 44 octets

f(n){n&&f(n/16);n%=16;putchar(n+48+n/10*7);}

Essayez-le en ligne!

plafond
la source
Dans l'exercice, il y a la phrase «• La nouvelle ligne n'est pas obligatoire», cela signifie que le numéro doit se terminer par «\ n»?
RosLuP
3

Bash (fonction), 62

Merci à @manatwork d'avoir suggéré d'utiliser la récursivité.

h()(x=({0..9} {A..F})
echo `(($1>15))&&h $[$1/16]`${x[$1%16]})
Traumatisme numérique
la source
Agréable. Mais la voie récursive semble encore plus courte:h(){ x=({0..9} {A..F});echo `(($1>15))&&h $[$1/16]`${x[$1%16]}; }
manatwork
1
@manatwork Nice - merci! Pour une raison quelconque, j'oublie généralement d'essayer la récursivité dans bash, même si je l'utilise dans d'autres réponses. Utiliser ()au lieu de { ;}contourner le corps de la fonction permet d'économiser encore plus :)
Digital Trauma
3

Perl 6 ,  53  48 octets

{[R~] (0..9,'A'..'F').flat[($_,*div 16...^0)X%16]||0}
{[R~] (0..9,'A'..'F').flat[.polymod(16 xx*)]||0}

Cela crée une séquence de valeurs divisées en entier ( div), jusqu'à ce que le résultat 0exclue le 0de la séquence.

$_, * div 16 ...^ 0

Il traverse ensuite ( X) cette séquence en utilisant l'opérateur de module ( %) avec16

(  ) X[%] 16

Il utilise ces valeurs comme index dans une liste aplatie composée de deux plages 0..9et'A'..'Z'

( 0 .. 9, 'A' .. 'Z' ).flat[  ]

Enfin, il les concatène ( ~) en utilisant l' Ropérateur méta reverse ( )

[R[~]] 

Si cela se traduit par une valeur False (chaîne vide), retournez 0

 || 0

Usage:

# (optional) give it a lexical name for ease of use
my &code = {  }

say <15 1000 256 0>.map: &code;
# (F 3E8 100 0)

say code 10¹⁰⁰;
# 1249AD2594C37CEB0B2784C4CE0BF38ACE408E211A7CAAB24308A82E8F10000000000000000000000000
Brad Gilbert b2gills
la source
2

MATL , 27 octets

i`16H#\wt9>?7+]wt]xN$hP48+c

Cela utilise la version 5.1.0 du langage / compilateur, qui est antérieure à ce défi.

Exemple

>> matl
 > i`16H#\wt9>?7+]wt]xN$hP48+c
 >
> 1000
3E8

Explication

i              % input number
`              % do...
  16H#\        % remainder and quotient of division by 16
  w            % move remainder to top of stack
  t9>          % does it exceed 9?
  ?            % if so
    7+         % add 7 (for letter ASCII code)
  ]            % end if
  w            % move quotient back to the top
  t            % duplicate 
]              % ...while (duplicated) quotient is not zero
x              % delete last quotient (zero)
N$h            % create vector of all remainders 
P              % flip vector
48+c           % add 48 and convert to char (will be implicitly displayed)
Luis Mendo
la source
2

𝔼𝕊𝕄𝕚𝕟, 31 caractères / 62 octets

↺a=⬯;ï;ï≫4@a=⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝[ï%Ḑ]+a

Try it here (Firefox only).

D'accord, j'ai trouvé d'autres trucs qui ont joué un rôle.

Explication

C'est essentiellement la même solution que la solution ES6 de @ SuperJedi224 - mais avec quelque chose de différent.

Tu vois ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? C'est une façon d'écrire vraiment fantaisiste "0123456789ABCDEF". ⩥Ḋcrée une plage de 0 à 10,Ⓒª⩥⁽ṁṇ⸩ crée une plage de 65 à 71 et la convertit en une chaîne ASCII, et Ā...⨝concatène les deux plages et les joint en une seule chaîne. C'était probablement la partie la plus cool de ma solution.

Version bonus non compétitive, 24 caractères / 45 octets

↺;ï;ï≫4@ᵴ=(⩥Ḋ⨝+ᶐ)[ï%Ḑ]+ᵴ

J'ai décidé d'ajouter une chaîne d'alphabet, comme en Pyth.

Mama Fun Roll
la source
2

sed, 341 octets

:
s/\b/_/2
s/[13579]/&;/g
y/123456789/011223344/
s/;0/5/g
s/;1/6/g
s/;2/7/g
s/;3/8/g
s/;4/9/g
s/;_;_;_;_/=/
s/;_;_;__/+/
s/;_;__;_/:/
s/;_;___/>/
s/;__;_;_/</
s/;__;__/?/
s/;___;_/(/
s/;____/*/
s/_;_;_;_/-/
s/_;_;__/^/
s/_;__;_/%/
s/_;___/$/
s/__;_;_/#/
s/__;__/@/
s/___;_/!/
s/____/)/
/[1-9_]/b
y/)!@#$%^-*(?<>:+=/0123456789ABCDEF/
s/^0*//

Ce n'est pas le langage évident pour ce défi, mais il a l'avantage de prendre en charge des numéros d'entrée allant jusqu'à (selon votre implémentation) entre 4000 chiffres et la limite de la mémoire (virtuelle) disponible de votre système. J'ai converti RSA-1024 en hexadécimal en environ 0,6 seconde, donc il évolue assez bien.

Il fonctionne par division successive par deux, accumulant tous les 4 bits de report en un chiffre hexadécimal. Nous utilisons des caractères non alphabétiques pour représenter notre sortie, de sorte que nous accumulons toujours le report entre l'entrée décimale et la sortie hexadécimale, et nous convertissons en hexadécimal conventionnel à la toute fin.

Toby Speight
la source
2

PHP, 65 66 64 + 1 62 59 octets

function h($n){$n&&h($n>>4);echo"0123456789abcdef"[$n&15];}

fonction d'impression récursive, imprime un zéro non significatif (insérer >16avant &&pour le supprimer)


programmes, 64 octets +1 pour -R(exécuter en tant que canal avec -nR)

for(;$n=&$argn;$n>>=4)$s="0123456789abcdef"[$n&15].$s;echo$s?:0;

nécessite PHP 5.6 ou version ultérieure (5.5 ne peut pas indexer les littéraux de chaîne)

ou

for(;$n=&$argn;$n>>=4)$s=(abcdef[$n%16-10]?:$n%16).$s;echo$s?:0;

nécessite PHP 5.6 ou 7.0 (7.1 comprend les index de chaîne négatifs)


Exécuter en tant que pipe avec -nRou essayer en ligne .

Titus
la source
1
Il me manque un signe plus echo+$spour l'entrée 0
Jörg Hülsermann
+signe coupe la sortie à la première lettre ... alors ..?:0
Titus
1

Julia, 55 octets

h(n)=(n>15?h(n÷16):"")"0123456789ABCDEF"[(i=n%16+1):i]

Il s'agit de l'implémentation de la fonction récursive de base. Il accepte un entier et renvoie une chaîne.

Si l'entrée est inférieure à 15, étage divisez-la par 16 et répétez, sinon prenez la chaîne vide. Fixez-le sur le devant du caractère hexadécimal correctement sélectionné.

Alex A.
la source
1

Pyre , 98 octets

Faire cela dans une langue sans opérateurs arithmétiques était probablement une erreur.

let h=def (n)(if n.gt(15)h(n.div(16).int!)else "").concat("0123456789abcdef".list!.get(n.mod(16)))

Utilisez comme ceci:

do
  let h = ...
  print(h(15))
end

Non golfé:

let h = def (n) do
    if n.gt(15) 
        let x = h(n.div(16).int!)
    else 
        let x = ""
    x.concat("0123456789abcdef".list!.get(n.mod(16)))
end
Tuomas Laakkonen
la source
1

Ruby, 48 caractères

(Copie de la réponse Python de Loovjo .)

h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}

Exemple d'exécution:

2.1.5 :001 > h=->n{(n>15?h[n/16]:'')+[*?0..?9,*?a..?f][n%16]}
 => #<Proc:0x00000001404a38@(irb):1 (lambda)> 
2.1.5 :002 > h[15]
 => "f" 
2.1.5 :003 > h[1000]
 => "3e8" 
2.1.5 :004 > h[256]
 => "100" 
homme au travail
la source
1

Sérieusement, 35 octets

,`;4ª@%)4ª@\`╬Xε D`@;7ªD+@9<7*+c+`n

Vidage hexadécimal:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Essayez-le en ligne

Explication:

,                                    Get evaluated input
 `          `╬                       Repeat the quoted function until top of stack is 0
  ;4ª@%                              Make a copy of the number mod 16
       )                             Send it to bottom of stack
        4ª@\                         Integer divide the original copy by 16
              X                      Delete the leftover zero. At this point the stack is 
                                     the "digits" of the hex number from LSD to MSD
               ε                     Push empty string
                 D`              `n  Essentially fold the quoted function over the stack.
                   @;                Roll up the next lowest digit, make a copy
                     7ªD+            Add 48
                         @           Bring up the other copy
                          9<         1 if it's at least 10, else 0
                            7*       Multiply with 7. 
                              +      Add. This will shift 58->65 and so on.
                               c     Convert to character.
                                +    Prepend to current string.

Notez que le ;7ªD+@9<7*+cest équivalent à 4ª▀E, ce qui permettrait d'économiser 8 octets, mais je pensais qu'une fonction qui pousse les chiffres de base b en tant que chaîne pourrait être considérée trop comme un "intégré heaxadécimal".

quintopie
la source
1

Javascript ES6, 64 58 octets

v=>eval('for(z="";v;v>>=4)z="0123456789ABCDEF"[v%16]+z')

6 octets enregistrés grâce à ן nɟuɐɯɹɐ ן oɯ et user81655.

SuperJedi224
la source
1
Utilisez eval:v=>eval('for(z="";v;v=v/16|0)z="0123456789ABCDEF"[v%16]+z')
Mama Fun Roll
1
Oh ouais, essayez d'utiliser atob et btoa pour cette longue chaîne.
Mama Fun Roll
@ ן nɟuɐɯɹɐ ן oɯ Tried v=>{for(z="";v>0;v=v/16|0)z=btoa``Ó]·ã»óÐ1``[v%16]+z;return z}(Les doubles tildes sont des tildes simples) ==> 64 caractères, 71 octets. Pas la peine.
usandfriends
1
v=v/16|0est juste une façon complexe d'écrire v>>=4.
user81655
1

Befunge-93, 58

&:88+%"0"+:"9"`7*+\8/2/:!#|_#
,_@                       >:#

La première fois que vous faites un vrai défi de golf à Befunge, je parie qu'il y a une doublure pour cela qui est plus courte car tous ces espaces au milieu de la deuxième ligne semblent inutiles.

Vous pouvez le parcourir ici . Explication partielle:

&: Prendre une entrée.

:88+%: Prenez le reste modulo 16.

"0"+: Ajoutez-le à la valeur ASCII de 0.

:"9"`: Si le résultat est supérieur à la valeur ASCII de 9 ...

7*+: Ajoutez 7 pour le convertir en lettre.

\: Enregistrez le personnage résultant sur la pile.

8/2/: Divisez par 16 en arrondissant.

:!#|_: Quittez la boucle si le résultat est 0.

#: Sinon, revenez à l'étape du module.

>:#,_@ (enroulement): Une fois terminé, sortez la pile dans l'ordre LIFO.

histocrate
la source
1

> <> , 46 + 3 = 49 octets

Cela aurait été plus court si> <> avait une division entière, que nous devons maintenant émuler en soustrayant le modulo 1. Pourtant, je pense que cela utilise un habillage assez soigné autour des astuces!

>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<
!?:r/ro;

Essayez-le en ligne!

Explication

Première boucle

>:?!v:f1+%:a(?v  v
\-%1:,+1f}+"0"<+7<

La première boucle effectue l'algorithme classique de conversion en hexadécimal. Il fait modulo 16 ( :f1+%) et vérifie si le résultat est <10 ( :a(?). Si ce n'est pas le cas, nous devons ajouter 7 ( 7+) afin de passer des décimales à l'alphabet majuscule dans le tableau ASCII. Sinon, nous pouvons procéder en ajoutant la valeur ASCII pour 0 ( "0"+) et en déplaçant le caractère à afficher au bas de la pile, car nous devrons les sortir dans l'ordre inverse. La valeur supérieure est alors remplacée par son résultat de division entière par 16. Ceci est émulé en calculant a / b - (a / b)% 1 ( f1+,:1%-). Une fois la boucle terminée, la pile contient les caractères hexadécimaux dans l'ordre de sortie inversé et un 0.

Deuxième boucle

!?:r<ro;

La deuxième boucle inverse la liste et vérifie si l'élément supérieur est 0. Si tel est le cas, nous savons que tous les éléments non nuls ont été imprimés et nous devons terminer. Sinon, nous sortons le caractère et inversons à nouveau la liste pour préparer la prochaine itération. L' :entrée dans la deuxième boucle dupliquera le 0 qui n'a aucun effet.

PidgeyUsedGust
la source
0

SpecBAS - 110 octets

1 h$="0123456789ABCDEF",r$=""
2 INPUT d
4 q=INT(d/16),r=d-(q*16),r$=h$(r+1)+r$,d=q
5 IF q>15 THEN 4
6  ?h$(q+1)+r$

Cela utilise un algorithme que j'ai trouvé sur WikiHow (2ème méthode).

Les chaînes dans SpecBAS sont basées sur 1, d'où la +1sélection de l'élément correct.

Brian
la source
0

Rubis, 40 octets

Volé à Inspired by manatwork's answer, mais en utilisant une faille intéressante pour la raccourcir.

h=->n{(n>15?h[n/16]:'')+(n%16).to_s(17)}
GB
la source
0

REXX, 80 78 octets

arg n
h=
do while n>0
  h=substr('0123456789ABCDEF',n//16+1,1)h
  n=n%16
  end
say h
idrougge
la source
0

C, 48 octets

h(x){x/16&&h(x/16);x%=16;putchar(x+=48+x/10*7);}

Ce n'est pas complètement original, j'ai rasé 5 octets de la version Digital Trauma mise en place.

Bijan
la source
0

APL (NARS), caractères 34, octets 68

{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}

tester:

  g←{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}
  g 0
0
  g 100
064
  g 1000
03E8
  g 1
01
RosLuP
la source