Thử thách

Đây là một đơn giản.

Viết hàm hoặc chương trình khi được cung cấp một số trong cơ sở 10 làm đầu vào, nó sẽ trả về hoặc in giá trị của số đó trong Hệ thập lục phân .

Ví dụ

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

Quy tắc

• Không có chức năng thập lục phân tích hợp nào
• Chữ cái có thể là chữ thường hoặc chữ hoa
• Bạn sẽ chỉ cần lo lắng về số nguyên không âm, không có số thập phân hoặc số thập phân pesky
• Nó sẽ hoạt động với bất kỳ số lượng lớn tùy ý đến giới hạn loại mặc định của ngôn ngữ.
• Dòng mới không bắt buộc
• Như thường lệ, đây là môn đánh gôn , vì vậy mã ngắn nhất được đo bằng byte sẽ thắng!

APL (Dyalog APL) , 17 byte

Phải được chạy với ⎕IO←0, mặc định trên nhiều hệ thống APL.

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

Hãy thử trực tuyến!

(⎕D,⎕A)[... ] D igits nối để Một lphabet, sau đó được lập chỉ mục bởi ...

 16⊥⍣¯1  nghịch đảo của 16-Base-to-Number, tức là Number-to-Base-16

 ⊢ áp dụng cho

 ⎕ đầu vào số

Mã máy Turing, 412 byte

Như thường lệ, tôi đang sử dụng cú pháp bảng quy tắc được xác định ở đây. Bạn có thể kiểm tra nó trên trang web đó hoặc, thay vào đó, bằng cách sử dụng triển khai java này.

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

Đếm ngược từ đầu vào trong cơ sở 10 trong khi đếm từ 0 trong cơ sở 16. Khi giảm 0, nó xóa khối đầu vào và chấm dứt.

Java, 92 89 byte

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

Javascript, 49 43 byte.

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

6 byte được lưu bởi user81655 .

Kiểm tra nó ở đây .

Điều này có hai số 0 đứng đầu, được cho phép bởi các quy tắc.

Đây là phiên bản không có số 0 đứng đầu: (47 byte).

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

Kiểm tra nó ở đây .

Cả hai đều sử dụng chính xác cách tiếp cận như câu trả lời Python của tôi .

CJam, 22 21 byte

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

Cảm ơn @ MartinBüttner vì đã chơi golf 1 byte!

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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 byte

Đây là một niềm vui.

sm@+jkUTGi_d2_c_.BQ4

Hãy thử trực tuyến.

Giải thích:

                .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 (chức năng), 51

Hàm đệ quy lấy số nguyên đầu vào làm tham số:

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

Lái thử:

#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 byte

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

Ví dụ sử dụng: sequence(s<$s)!!) $ 1000-> "00000000000003E8".

Điều này tạo ra một danh sách tất cả các số thập lục phân lên đến 16 chữ số hex. May mắn là điều này xảy ra theo thứ tự, vì vậy chúng ta chỉ cần chọn cái nthứ nhất.

Chỉnh sửa: @Mauris vắt ra 2 byte. Cảm ơn!

đc, 37

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

Đệ quy divmods bằng 16, đẩy phần còn lại vào ngăn xếp cho đến khi không còn gì để chia. Sau đó in từng phần tử của ngăn xếp, sử dụng divmod bằng 10 để đạt được các chữ số AF. Có lẽ chi tiết hơn vào ngày mai ... (và hy vọng ít byte hơn).

Python, 59 58 byte

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

1 byte được lưu bởi RugPython

Chạy như: print h(15)

Kiểm tra nó ở đây (Ideone.com).

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Bash (chức năng), 62

Cảm ơn @manatwork đã đề xuất sử dụng đệ quy.

h()(x=({0..9} {A..F})
echo `(($1>15))&&h $[$1/16]`${x[$1%16]})

Perl 6 ,  53  48 byte

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

Điều này tạo ra một chuỗi các giá trị được chia số nguyên ( div) cho đến khi kết quả 0loại trừ 0khỏi chuỗi

$_, * div 16 ...^ 0

Sau đó, nó vượt qua ( X) chuỗi đó bằng cách sử dụng toán tử mô đun ( %) với16

( … ) X[%] 16

Nó sử dụng các giá trị đó làm chỉ mục vào một danh sách dẹt gồm hai Phạm vi 0..9và'A'..'Z'

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

Cuối cùng, nó kết hợp ( ~) chúng bằng cách sử dụng Rtoán tử meta ( )

[R[~]] …

Nếu kết quả là giá trị Sai (chuỗi trống), hãy trả về 0

… || 0

Sử dụng:

# (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 byte

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

Điều này sử dụng bản phát hành 5.1.0 của ngôn ngữ / trình biên dịch, sớm hơn thử thách này.

Thí dụ

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

Giải trình

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 ký tự / 62 byte

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

Try it here (Firefox only).

Được rồi, tôi đã tìm ra một số thứ nữa đánh gôn xuống.

Giải trình

Về cơ bản, đây là giải pháp tương tự như giải pháp ES6 của @ SuperJedi224 - nhưng với một cái gì đó khác biệt.

Thấy ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝không Đó là một cách viết thực sự lạ mắt "0123456789ABCDEF". ⩥Ḋtạo một phạm vi từ 0 đến 10, Ⓒª⩥⁽ṁṇ⸩tạo một phạm vi từ 65 đến 71 và chuyển đổi nó thành một chuỗi ASCII và Ā...⨝nối hai phạm vi và nối chúng thành một chuỗi. Đây có lẽ là phần tuyệt vời nhất trong giải pháp của tôi.

Phiên bản thưởng không cạnh tranh, 24 ký tự / 45 byte

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

Tôi quyết định thêm một chuỗi bảng chữ cái, như trong Pyth.

sed, 341 byte

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

Đây không phải là ngôn ngữ rõ ràng cho thử thách này, nhưng nó có lợi thế là hỗ trợ các số đầu vào tối đa (tùy thuộc vào việc triển khai của bạn) giữa 4000 chữ số và giới hạn bộ nhớ khả dụng (ảo) của hệ thống. Tôi đã chuyển đổi RSA-1024 thành hex trong khoảng 0,6 giây, vì vậy nó có tỷ lệ hợp lý.

Nó hoạt động bằng cách sử dụng phép chia liên tiếp cho hai, tích lũy cứ sau 4 bit mang thành một chữ số hex. Chúng tôi sử dụng các ký tự không phải chữ cái để thể hiện đầu ra của mình, để chúng tôi luôn tích lũy mang giữa đầu vào thập phân và đầu ra hex và chuyển đổi thành thập lục phân thông thường ở cuối.

PHP, 65 66 64 + 1 62 59 byte

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

chức năng in đệ quy, in số 0 đứng đầu (chèn >16trước &&để loại bỏ nó)

các chương trình, 64 byte +1 cho -R(chạy như ống với -nR)

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

yêu cầu PHP 5.6 trở lên (5.5 không thể lập chỉ mục chuỗi ký tự)

hoặc là

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

yêu cầu PHP 5.6 hoặc 7.0 (7.1 hiểu các chỉ mục chuỗi âm)

Chạy như ống với -nRhoặc thử chúng trực tuyến .

Julia, 55 byte

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

Đây là thực hiện chức năng đệ quy cơ bản. Nó chấp nhận một số nguyên và trả về một chuỗi.

Nếu đầu vào nhỏ hơn 15, chia sàn cho 16 và lặp lại, nếu không hãy lấy chuỗi trống. Đặt cái này lên mặt trước của ký tự thập lục phân được chọn một cách thích hợp.

Bình thường , 98 byte

Làm điều này trong một ngôn ngữ mà không có toán tử số học có lẽ là một sai lầm.

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

Sử dụng như thế này:

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

Ung dung:

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 ký tự

(Bản sao Loovjo 's Python câu trả lời .)

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

Chạy mẫu:

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" 

Nghiêm túc, 35 byte

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

Bãi rác Hex:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Dùng thử trực tuyến

Giải trình:

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

Lưu ý rằng ;7ªD+@9<7*+ctương đương với 4ª▀E, sẽ tiết kiệm được 8 byte, nhưng tôi nghĩ rằng có lẽ một hàm đẩy các chữ số b cơ bản như một chuỗi có thể được coi là quá nhiều của "tích hợp sẵn".

Javascript ES6, 64 58 byte

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

Đã lưu 6 byte nhờ ן nɟuɐɯɹɐ oɯ và user81655.

Befunge-93, 58

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

Lần đầu tiên thực hiện một thử thách chơi gôn thực sự ở Befunge, tôi cá rằng có một lớp lót cho cái này ngắn hơn vì tất cả những khoảng trống ở giữa dòng thứ hai có vẻ lãng phí.

Bạn có thể bước qua nó ở đây . Giải thích một phần:

&: Lấy đầu vào.

:88+%: Lấy phần modulo còn lại 16.

"0"+: Thêm nó vào giá trị ASCII bằng 0.

:"9"`: Nếu kết quả lớn hơn giá trị ASCII là 9 ...

7*+: Thêm 7 để chuyển đổi nó thành một chữ cái.

\: Lưu ký tự kết quả trên ngăn xếp.

8/2/: Chia cho 16 làm tròn xuống.

:!#|_: Thoát khỏi vòng lặp nếu kết quả là 0.

#: Nếu không thì quay lại bước modulus.

>:#,_@ (quấn quanh): Sau khi hoàn thành, xuất ngăn xếp theo thứ tự LIFO.

> <> , 46 + 3 = 49 byte

Điều này sẽ ngắn hơn nếu> <> có phép chia số nguyên, mà bây giờ chúng ta phải mô phỏng bằng cách trừ modulo 1. Tuy nhiên, tôi nghĩ rằng điều này sử dụng một số cách gói gọn gàng xung quanh các thủ thuật!

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

Hãy thử trực tuyến!

Giải trình

Vòng lặp đầu tiên

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

Vòng lặp đầu tiên thực hiện chuyển đổi cổ điển sang thuật toán hex. Nó thực hiện modulo 16 ( :f1+%) và kiểm tra xem kết quả có <10 ( :a(?) không. Nếu không, chúng ta cần thêm 7 ( 7+) để đi từ số thập phân sang bảng chữ cái in hoa trong bảng ASCII. Khác, chúng ta có thể tiến hành bằng cách thêm giá trị ASCII cho 0 ( "0"+) và chuyển ký tự thành đầu ra xuống dưới cùng của ngăn xếp vì chúng ta sẽ phải xuất chúng theo thứ tự ngược lại. Giá trị hàng đầu sau đó được thay thế bằng kết quả của phép chia số nguyên bằng 16. Điều này được mô phỏng bằng cách tính a / b - (a / b)% 1 ( f1+,:1%-). Khi vòng lặp kết thúc, ngăn xếp chứa các ký tự thập lục phân theo thứ tự đầu ra đảo ngược và 0.

Vòng lặp thứ hai

!?:r<ro;

Vòng lặp thứ hai đảo ngược danh sách và kiểm tra xem phần tử trên có bằng 0. Nếu có, chúng ta biết tất cả các giá trị khác đã được in và chúng ta nên chấm dứt. Khác, chúng tôi xuất ký tự và đảo ngược danh sách một lần nữa để chuẩn bị cho lần lặp tiếp theo. Các :khi bước vào vòng thứ hai sẽ lặp lại trong 0 mà không có tác dụng.

SpecBAS - 110 byte

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$

Điều này sử dụng một thuật toán tôi tìm thấy trên WikiHow (phương pháp thứ 2).

Các chuỗi trong SpecBAS dựa trên 1, do đó +1phải chọn ra phần tử chính xác.

C (tiếng kêu) , 83 byte

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

Hãy thử trực tuyến!

Giải pháp thay thế trong C

Ruby, 40 byte

Bị đánh cắp từ Lấy cảm hứng từ câu trả lời của manatwork, nhưng sử dụng một lỗ hổng thú vị để làm cho nó ngắn hơn.

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

REXX, 80 78 byte

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

C, 48 byte

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

Đây không phải là hoàn toàn nguyên bản, tôi đã loại bỏ 5 byte của phiên bản Digital Trauma đưa lên.

APL (NARS), ký tự 34, byte 68

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

kiểm tra:

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