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 code-golf , donc le code le plus court mesuré en octets gagne!

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

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.

Java, 92 89 octets

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

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 .

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.

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.

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

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!

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

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.

C (gcc) , 45 44 octets

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

Essayez-le en ligne!

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

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

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)

𝔼𝕊𝕄𝕚𝕟, 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.

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.

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 .

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é.

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

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" 

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".

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.

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.

> <> , 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.

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.

C (clang) , 83 octets

f(n){char h[8]={0};int i=8;while(i>0){h[i-1]=n%16;n/=16;printf("%x",h[8-i]);i--;}}

Essayez-le en ligne!

Solution alternative en C

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

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

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.

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