Konwertuj liczbę na Szesnastkową

23

Wyzwanie

Oto prosty.

Napisz funkcję lub program, gdy otrzyma liczbę w bazie 10 jako dane wejściowe, zwróci lub wydrukuje wartość tej liczby w systemie szesnastkowym .

Przykłady

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

Zasady

  • Brak wbudowanych funkcji szesnastkowych
  • Litery mogą być małe lub wielkie
  • Będziesz musiał się tylko martwić o nieujemne liczby całkowite, bez negatywów i nieznośnych miejsc po przecinku
  • Powinien działać z dowolną dowolną dużą liczbą, aż do domyślnego limitu typu języka.
  • Newline nie jest obowiązkowy
  • Jak zwykle jest to , więc wygrywa najkrótszy kod mierzony w bajtach!
Losowa osoba
źródło
Pierwszy problem, mam nadzieję, że wam się spodoba!
Random Guy
5
Czy wyjściowe zera są dozwolone, np. Dla liczb 32-bitowych 000003E8?
nimi
Jakieś ograniczenie na wejściu?
Loovjo,
1
@nimi Tak, to jest dozwolone.
Random Guy
1
Ciekawostka: C ++ ma wbudowane hex.
Matthew Roh

Odpowiedzi:

4

APL (Dyalog APL) , 17 bajtów

Musi być uruchamiany z ⎕IO←0, co jest domyślne w wielu systemach APL.

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

Wypróbuj online!

(⎕D,⎕A)[]D igits połączone z alfabetem A , a następnie indeksowane przez…

16⊥⍣¯1  odwrotność 16-Base-to-Number, tj. Number-to-Base-16

 stosowane do

 wprowadzanie numeryczne

Adám
źródło
Czy to nie 17 znaków i około 23 bajtów?
Julie Pelletier,
1
@JuliePelletier Nie, Dyalog APL używa własnej 256-znakowej strony kodowej.
Adám,
O! Dobrze wiedzieć.
Julie Pelletier,
14

Kod maszynowy Turinga, 412 bajtów

Jak zwykle używam zdefiniowanej tutaj składni tabeli reguł . Możesz to przetestować na tej stronie lub, alternatywnie, za pomocą tej implementacji 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

Odlicza od wejścia w bazie 10, odliczając w górę od 0 w bazie 16. Po zmniejszeniu zera kasuje blok wejściowy i kończy działanie.

SuperJedi224
źródło
To jest naprawdę fajne, potrzeba 10*n + 33instrukcji do wykonania dla każdego dowolnego n. Nie rozumiem jednak kodu.
Magic Octopus Urn
@MagicOctopusUrn Tworzy nowy blok komórek po lewej stronie danych wejściowych, początkowo zawierający 0. Następnie wielokrotnie zmniejsza blok wejściowy w podstawie 10, jednocześnie zwiększając blok wyjściowy w podstawie 16, dopóki nie spróbuje zmniejszyć pustej komórki podczas cykl dekrementacji [który mówi mu, że blok wejściowy ma teraz wartość 0], w którym to momencie czyści taśmę (więc tylko wyjście pozostaje na taśmie) przed zatrzymaniem.
SuperJedi224,
@MagicOctopusUrn Również twoje równanie dla środowiska wykonawczego jest niepoprawne (nie wiem jednak, jakie jest poprawne ogólne równanie, po prostu to oczywiście nie jest to). Wypróbuj na przykład z wejściem 2.
SuperJedi224,
prawdopodobnie nie. Wydawało się, że jest bliski wysokim wartościom. Nic o tym nie wiem i próbowałem zobaczyć wzory.
Magic Octopus Urn
9

Java, 92 89 bajtów

String x(int v){String z="";for(;v>0;v/=16)z="0123456789ABCDEF".charAt(v%16)+z;return z;}
SuperJedi224
źródło
9

JavaScript, 49 43 bajtów.

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

6 bajtów zapisanych przez użytkownika 81655 .

Sprawdź to tutaj .

Ma dwa wiodące zera, co jest dozwolone przez reguły.

Oto wersja bez wiodących zer: (47 bajtów).

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

Sprawdź to tutaj .

Oba używają dokładnie tego samego podejścia, co moja odpowiedź w języku Python .

Loovjo
źródło
Użyj binarnego AND. i&15automatycznie zamieni się na liczbę całkowitą, usuwając miejsca po przecinku. Nie ma potrzeby~~
edc65
Zapisałem 3 bajty i jedno wiodące zero:h=i=>i&&h(i>>4)+"0123456789abcdef"[i&15]
Neil
8

CJam, 22 21 bajtów

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

Dzięki @ MartinBüttner za grę w golfa na 1 bajcie!

Wypróbuj online!

Jak to działa

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
źródło
5
Ta sama liczba bajtów:ri{Gmd_9>7*sc+\}h;]W%
Martin Ender
6

Pyth, 33 26 21 20 bajtów

To było zabawne.

sm@+jkUTGi_d2_c_.BQ4

Wypróbuj online.

Wyjaśnił:

                .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.
Luke
źródło
Czy możesz dodać wyjaśnienie?
TanMath,
Jasne, który jesteś zainteresowany?
Łukasz
Najbardziej interesująca odpowiedź! ;) to nie ma znaczenia ... Chociaż dobrze jest zamieszczać wyjaśnienia dla wszystkich
TanMath,
5

C (funkcja), 51

Funkcja rekurencyjna przyjmuje jako liczbę całkowitą wejściową parametr:

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

Kierowca testowy:

#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;
}
Cyfrowa trauma
źródło
5

Haskell, 59 58 43 41 39 bajtów

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

Przykład użycia: sequence(s<$s)!!) $ 1000-> "00000000000003E8".

Spowoduje to utworzenie listy wszystkich liczb szesnastkowych do 16 cyfr szesnastkowych. Na szczęście dzieje się to w porządku, więc możemy po prostu wybrać ten n.

Edycja: @ Mauris wycisnął 2 bajty. Dzięki!

nimi
źródło
Lista danych monad doe
Daenyth
@ Daenyth: Zmieniłem Monad na Functor
nimi
Co powiesz na tos="0123456789ABCDEF";(sequence(s<$s)!!)
Lynn
@Mauris: awesome!
nimi
4

dc, 37

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

Rekurencyjnie divmoduje przez 16, pchając resztę na stos, dopóki nic nie pozostało do podzielenia. Następnie wydrukuj każdy element stosu, używając divmod przez 10, aby uzyskać cyfry AF. Prawdopodobnie więcej szczegółów jutro ... (i mam nadzieję, że mniej bajtów).

Cyfrowa trauma
źródło
4

Python, 59 58 bajtów

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

1 bajt zapisany przez CarpetPython

Uruchom jako: print h(15)

Przetestuj tutaj (Ideone.com).

Wyjaśnienie:

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
źródło
1
Dobra robota. Możesz także zapisać kolejny bajt za pomocą h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16].
Logic Knight
Dobra robota, możesz uratować jeszcze dwa takie:h=lambda i:(i>15 and h(i/16)or'')+chr(48+i%16+i%16/10*7)
Willem,
4

C (gcc) , 45 44 bajtów

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

Wypróbuj online!

sufitowy
źródło
W ćwiczeniu jest wyrażenie „• Nowa linia nie jest obowiązkowa”, co oznacza, że ​​liczba musi kończyć się na „\ n”?
RosLuP,
3

Bash (funkcja), 62

Dzięki @manatwork za sugerowanie użycia rekurencji.

h()(x=({0..9} {A..F})
echo `(($1>15))&&h $[$1/16]`${x[$1%16]})
Cyfrowa trauma
źródło
Miły. Ale droga rekurencyjna wydaje się być krótsza:h(){ x=({0..9} {A..F});echo `(($1>15))&&h $[$1/16]`${x[$1%16]}; }
manatwork
1
@manatwork Nicea - dzięki! Z jakiegoś powodu zwykle zapominam o wypróbowaniu rekurencji w bashu, mimo że używam jej w innych odpowiedziach. Używanie ()zamiast { ;}funkcji ciała oszczędza jeszcze więcej :)
Digital Trauma
3

Perl 6 ,  53  48 bajtów

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

Tworzy to sekwencję wartości, które są podzielone na liczby całkowite ( div), dopóki wynik nie zostanie 0wykluczony 0z sekwencji

$_, * div 16 ...^ 0

Następnie przecina Xtę sekwencję za pomocą operatora modułu ( %) za pomocą16

(  ) X[%] 16

Używa tych wartości jako indeksów do spłaszczonej listy składającej się z dwóch zakresów 0..9i'A'..'Z'

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

Wreszcie konkatenuje je ( ~) za pomocą metaoperatora reverse ( R)

[R[~]] 

Jeśli wynikiem jest Fałszywa wartość (pusty ciąg), zwróć 0

 || 0

Stosowanie:

# (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
źródło
2

MATL , 27 bajtów

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

Używa wersji 5.1.0 języka / kompilatora, która jest wcześniejsza niż to wyzwanie.

Przykład

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

Wyjaśnienie

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
źródło
2

𝔼𝕊𝕄𝕚𝕟, 31 znaków / 62 bajty

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

Try it here (Firefox only).

Okej, wymyśliłem jeszcze kilka rzeczy, które sprawiły, że grałem w golfa.

Wyjaśnienie

Jest to zasadniczo to samo rozwiązanie, co rozwiązanie ES6 @ SuperJedi224 - ale z czymś innym.

Widzisz ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? To naprawdę fantazyjny sposób pisania "0123456789ABCDEF". ⩥Ḋtworzy zakres od 0 do 10, Ⓒª⩥⁽ṁṇ⸩tworzy zakres od 65 do 71 i konwertuje go na ciąg ASCII, Ā...⨝łączy dwa zakresy i łączy je w jeden ciąg. To była prawdopodobnie najfajniejsza część mojego rozwiązania.

Dodatkowa wersja niekonkurencyjna, 24 znaki / 45 bajtów

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

Postanowiłem dodać ciąg alfabetu, jak w Pyth.

Mama Fun Roll
źródło
2

sed, 341 bajtów

:
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*//

Nie jest to oczywisty język dla tego wyzwania, ale ma tę zaletę, że obsługuje liczby wejściowe do (w zależności od implementacji) od 4000 cyfr do limitu dostępnej (wirtualnej) pamięci systemu. Przekształciłem RSA-1024 na hex w około 0,6 sekundy, więc skaluje się dość dobrze.

Działa z wykorzystaniem sukcesywnego dzielenia przez dwa, gromadząc co 4 bity przeniesienia na cyfrę szesnastkową. Używamy znaków nieliterowych do reprezentowania naszego wyniku, dzięki czemu zawsze kumulujemy przenoszenie między danymi dziesiętnymi a danymi szesnastkowymi, a na samym końcu konwertujemy do konwencjonalnych znaków szesnastkowych.

Toby Speight
źródło
2

PHP, 65 66 64 + 1 62 59 bajtów

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

funkcja drukowania rekurencyjnego, drukuje wiodące zero (wstaw >16przed, &&aby je usunąć)


programy, 64 bajty +1 dla -R(uruchom jako potok z -nR)

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

wymaga PHP 5.6 lub nowszego (5.5 nie może indeksować literałów łańcuchowych)

lub

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

wymaga PHP 5.6 lub 7.0 (7.1 rozumie indeksy ciągów ujemnych)


Uruchom jako potok z -nRlub wypróbuj je online .

Tytus
źródło
1
Brakuje mi znaku plus echo+$sdla wejścia 0
Jörg Hülsermann
+znak odcina wynik przy pierwszej literze ... więc ...?:0
Tytus
1

Julia, 55 bajtów

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

Jest to podstawowa implementacja funkcji rekurencyjnej. Akceptuje liczbę całkowitą i zwraca ciąg znaków.

Jeśli wartość wejściowa jest mniejsza niż 15, podziel ją przez 16 i powtórz, w przeciwnym razie weź pusty łańcuch. Tackuj to z przodu odpowiednio wybranego znaku szesnastkowego.

Alex A.
źródło
1

Stos , 98 bajtów

Robienie tego w języku bez operatorów arytmetycznych było prawdopodobnie błędem.

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

Użyj w ten sposób:

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

Nie golfowany:

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
źródło
1

Ruby, 48 znaków

(Kopia Loovjo „s Python odpowiedź .)

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

Przykładowy przebieg:

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" 
człowiek w pracy
źródło
1

Poważnie, 35 bajtów

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

Hex Dump:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Wypróbuj online

Wyjaśnienie:

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

Zauważ, że ;7ªD+@9<7*+cjest to odpowiednik 4ª▀E, który zaoszczędziłby 8 bajtów, ale pomyślałem, że być może funkcja, która wypycha podstawowe cyfry b jako ciąg znaków, może być uważana za zbyt „wbudowaną heksadecymalnie”.

kwintopia
źródło
1

JavaScript ES6, 64 58 bajtów

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

Zaoszczędzono 6 bajtów dzięki ן nɟuɐɯɹɐ ן oɯ i user81655.

SuperJedi224
źródło
1
Użyj eval:v=>eval('for(z="";v;v=v/16|0)z="0123456789ABCDEF"[v%16]+z')
Mama Fun Roll
1
O tak, spróbuj użyć atob i btoa dla tego długiego łańcucha.
Mama Fun Roll
@ ן nɟuɐɯɹɐ ן oɯ Próbowałem v=>{for(z="";v>0;v=v/16|0)z=btoa``Ó]·ã»óÐ1``[v%16]+z;return z}(podwójne tyldy są pojedynczymi tyldami) ==> 64 znaków, 71 bajtów. Nie warty tego.
usandfriends
1
v=v/16|0to po prostu złożony sposób pisania v>>=4.
user81655,
1

Befunge-93, 58

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

Po raz pierwszy wykonując prawdziwe wyzwanie w golfa w Befunge, założę się, że jest tam jeden linijka, która jest krótsza, ponieważ wszystkie te pola na środku drugiej linii wydają się marnotrawstwem.

Możesz przejść przez to tutaj . Częściowe wyjaśnienie:

&: Weź wkład.

:88+%: Weź resztę modulo 16.

"0"+: Dodaj go do wartości ASCII równej 0.

:"9"`: Jeśli wynik jest większy niż wartość ASCII wynosząca 9 ...

7*+: Dodaj 7, aby przekształcić go w literę.

\: Zapisz wynikową postać na stosie.

8/2/: Podziel przez 16 zaokrąglając w dół.

:!#|_: Wyjdź z pętli, jeśli wynikiem jest 0.

#: W przeciwnym razie wróć do kroku modułu.

>:#,_@ (owijanie wokół): Po zakończeniu wyślij stos w kolejności LIFO.

histocrat
źródło
1

> <> , 46 + 3 = 49 bajtów

Byłoby to krótsze, gdyby> <> miałoby dzielenie liczb całkowitych, które teraz musimy naśladować, odejmując modulo 1. Mimo to myślę, że używa to całkiem fajnego owijania wokół sztuczek!

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

Wypróbuj online!

Wyjaśnienie

Pierwsza pętla

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

Pierwsza pętla wykonuje klasyczną konwersję do algorytmu szesnastkowego. Robi modulo 16 ( :f1+%) i sprawdza, czy wynik jest <10 ( :a(?). Jeśli tak nie jest, musimy dodać 7 ( 7+), aby przejść od miejsc po przecinku do dużego alfabetu w tabeli ASCII. W przeciwnym razie możemy kontynuować dodając wartość ASCII dla 0 ( "0"+) i przesuwając znak, który ma być wyprowadzany na dół stosu, ponieważ będziemy musieli wyprowadzać je w odwrotnej kolejności. Najwyższa wartość jest następnie zastępowana przez wynik dzielenia liczb całkowitych przez 16. Jest to emulowane przez obliczenie a / b - (a / b)% 1 ( f1+,:1%-). Po zakończeniu pętli stos zawiera znaki szesnastkowe w odwrotnej kolejności wyjściowej i 0.

Druga pętla

!?:r<ro;

Druga pętla odwraca listę i sprawdza, czy górny element ma wartość 0. Jeśli tak, wiemy, że wszystkie niezerowe zostały wydrukowane i powinniśmy zakończyć. W przeciwnym razie wypisujemy znak i ponownie odwracamy listę, aby przygotować się do następnej iteracji. :Przy wejściu do drugiej pętli powiela 0, co nie ma żadnego wpływu.

PidgeyUsedGust
źródło
0

SpecBAS - 110 bajtów

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$

Wykorzystuje algorytm znaleziony na WikiHow (2. metoda).

Ciągi znaków w SpecBAS są oparte na 1, stąd +1wybór właściwego elementu.

Brian
źródło
0

Rubinowy, 40 bajtów

Skradzione z inspiracji odpowiedzią manatwork, ale używając ciekawej luki, aby ją skrócić.

h=->n{(n>15?h[n/16]:'')+(n%16).to_s(17)}
GB
źródło
0

REXX, 80 78 bajtów

arg n
h=
do while n>0
  h=substr('0123456789ABCDEF',n//16+1,1)h
  n=n%16
  end
say h
idrougge
źródło
0

C, 48 bajtów

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

Nie jest to całkowicie oryginalne, ogoliłem 5 bajtów z wersji Digital Trauma.

Bijan
źródło
0

APL (NARS), znaki 34, bajty 68

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

test:

  g←{⍵≤0:,'0'⋄(∇⌊⍵÷16),(1+16∣⍵)⊃⎕D,⎕A}
  g 0
0
  g 100
064
  g 1000
03E8
  g 1
01
RosLuP
źródło