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 gra w golfa , więc wygrywa najkrótszy kod mierzony w bajtach!

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

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.

Java, 92 89 bajtów

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

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 .

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.

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.

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

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!

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

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.

C (gcc) , 45 44 bajtów

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

Wypróbuj online!

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

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

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)

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

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.

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 .

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.

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

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" 

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

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.

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.

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

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.

C (brzęk) , 83 bajty

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

Wypróbuj online!

Alternatywne rozwiązanie w C.

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

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

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.

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