ท้าทาย

นี่คือหนึ่งที่เรียบง่าย

เขียนฟังก์ชั่นหรือโปรแกรมเมื่อได้รับตัวเลขในฐาน 10 เป็น input ก็จะกลับหรือพิมพ์ค่าตัวเลขนั้นในเลขฐานสิบหก

ตัวอย่าง

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

กฎระเบียบ

• ไม่มีเลขฐานสิบหกในตัวทำหน้าที่ใด ๆ
• ตัวอักษรอาจเป็นตัวพิมพ์เล็กหรือตัวพิมพ์ใหญ่
• คุณจะต้องกังวลเกี่ยวกับจำนวนเต็มที่ไม่เป็นลบไม่มีเชิงลบหรือทศนิยมที่น่ารำคาญ
• ควรทำงานกับจำนวนที่มากตามอำเภอใจจนถึงข้อ จำกัด ประเภทเริ่มต้นของภาษา
• ขึ้นบรรทัดใหม่ไม่บังคับ
• ตามปกตินี่คือcode-golfดังนั้นโค้ดที่สั้นที่สุดที่วัดเป็นไบต์จะเป็นผู้ชนะ!

APL (Dyalog APL)ขนาด 17 ไบต์

ต้องรันด้วย⎕IO←0ซึ่งเป็นค่าเริ่มต้นในระบบ APL จำนวนมาก

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

ลองออนไลน์!

(⎕D,⎕A)[... ] D igits ตัดแบ่งเพื่อlphabet จัดทำดัชนีแล้วโดย ...

 16⊥⍣¯1  ค่าผกผันของ 16-Base-to-Number เช่น Number-to-Base-16

 ⊢ นำไปใช้กับ

 ⎕ ใส่ตัวเลข

รหัสทัวริงเครื่อง 412 ไบต์

ตามปกติฉันใช้ไวยากรณ์ตารางกฎที่กำหนดไว้ที่นี่ คุณสามารถทดสอบบนไซต์นั้นหรือใช้การใช้จาวานี้

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

นับถอยหลังจากอินพุตในฐาน 10 ในขณะที่นับจาก 0 ในฐาน 16 เมื่อลดลงเป็นศูนย์มันจะลบบล็อกอินพุตและสิ้นสุด

Java, 92 89 ไบต์

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

Javascript, 49 43 ไบต์

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

6 ไบต์บันทึกไว้โดยuser81655

ทดสอบที่นี่

นี่เป็นศูนย์นำสองศูนย์ซึ่งอนุญาตโดยกฎ

นี่คือรุ่นที่ไม่มีศูนย์นำหน้า: (47 ไบต์)

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

ทดสอบที่นี่

ทั้งสองของการใช้งานเหล่านี้ว่าวิธีการเช่นเดียวกับฉันคำตอบหลาม

CJam, 22 21 ไบต์

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

ขอบคุณ @ MartinBüttnerสำหรับการลงเล่น 1 ไบต์!

ลองออนไลน์!

มันทำงานอย่างไร

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 ไบต์

นี่เป็นเรื่องสนุก

sm@+jkUTGi_d2_c_.BQ4

ลองออนไลน์

อธิบาย:

                .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 (ฟังก์ชั่น), 51

ฟังก์ชั่นแบบเรียกซ้ำใช้จำนวนเต็มเข้าเป็นพารามิเตอร์:

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

ไดรเวอร์ทดสอบ:

#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 ไบต์

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

ตัวอย่างการใช้งาน: ->sequence(s<$s)!!) $ 1000"00000000000003E8"

สิ่งนี้จะสร้างรายการเลขฐานสิบหกทั้งหมดสูงสุด 16 ฐานสิบหก โชคดีที่สิ่งนี้เกิดขึ้นตามลำดับดังนั้นเราสามารถเลือกnอันที่สองได้

แก้ไข: @Mauris บีบออก 2 ไบต์ ขอบคุณ!

dc, 37

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

หารซ้ำโดย 16 ผลักดันส่วนที่เหลือไปยังสแต็คจนกว่าจะไม่มีอะไรเหลือให้หาร จากนั้นพิมพ์แต่ละองค์ประกอบของสแต็กโดยใช้ divmod 10 เพื่อให้ได้ตัวเลข AF รายละเอียดเพิ่มเติมอาจเป็นไปได้ในวันพรุ่งนี้ ... (และหวังว่าจะน้อยกว่าไบต์)

Python ขนาด59 58 ไบต์

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

1 ไบต์บันทึกโดยCarpetPython

ทำงานเป็น: print h(15)

ทดสอบที่นี่ (Ideone.com)

คำอธิบาย:

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 ไบต์

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

ลองออนไลน์!

Bash (ฟังก์ชัน), 62

ขอบคุณ @manatwork สำหรับการแนะนำการใช้การเรียกซ้ำ

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

Perl 6 ,  53  48 ไบต์

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

สิ่งนี้จะสร้างลำดับของค่าที่ถูกแบ่งเป็นจำนวนเต็ม ( div) จนกว่าผลลัพธ์จะ0แยก0ออกจากลำดับ

$_, * div 16 ...^ 0

จากนั้นจะข้าม ( X) ลำดับนั้นโดยใช้ตัวดำเนินการโมดูลัส ( %) ด้วย16

( … ) X[%] 16

มันใช้ค่าเหล่านั้นเป็นดัชนีลงในรายการที่แบนซึ่งประกอบด้วยสองช่วง0..9และ'A'..'Z'

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

ในที่สุดมันเชื่อมต่อ ( ~) พวกเขาโดยใช้Rตัวดำเนินการเมตาย้อนกลับ ( )

[R[~]] …

หากผลลัพธ์นั้นเป็นค่าเท็จ (สตริงว่าง) ให้ส่งคืน 0

… || 0

การใช้งาน:

# (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 ไบต์

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

สิ่งนี้ใช้รีลีสภาษา / คอมไพเลอร์5.1.0ซึ่งเร็วกว่าความท้าทายนี้

ตัวอย่าง

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

คำอธิบาย

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 ตัวอักษร / 62 ไบต์

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

Try it here (Firefox only).

โอเคฉันคิดหาข้อมูลเพิ่มเติมบางอย่างที่ลงไป

คำอธิบาย

เป็นวิธีแก้ปัญหาเดียวกับโซลูชัน ES6 ของ @ SuperJedi224 - แต่มีความแตกต่าง

เห็น⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝ไหม นั่นเป็นวิธีการเขียนที่"0123456789ABCDEF"แปลกใหม่ ⩥Ḋสร้างช่วงจาก 0 ถึง 10 Ⓒª⩥⁽ṁṇ⸩สร้างช่วงจาก 65 ถึง 71 และแปลงเป็นสตริงของ ASCII และĀ...⨝เชื่อมสองช่วงและเชื่อมเข้าด้วยกันเป็นหนึ่งสตริง นี่อาจเป็นวิธีที่ยอดเยี่ยมที่สุดสำหรับโซลูชันของฉัน

โบนัสเวอร์ชันที่ไม่ใช่การแข่งขัน 24 ตัวอักษร / 45 ไบต์

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

ฉันตัดสินใจเพิ่มสตริงตัวอักษรเช่นเดียวกับใน Pyth

sed, 341 ไบต์

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

ไม่ใช่ภาษาที่ชัดเจนสำหรับความท้าทายนี้ แต่มีข้อได้เปรียบในการรองรับหมายเลขอินพุตสูงสุด (ขึ้นอยู่กับการใช้งานของคุณ) ระหว่าง 4,000 หลักและขีด จำกัด ของหน่วยความจำ (เสมือน) ที่มีอยู่ในระบบของคุณ ฉันแปลง RSA-1024 เป็น hex ในเวลาประมาณ 0.6 วินาทีดังนั้นมันจึงปรับขนาดได้ดีพอสมควร

มันทำงานโดยใช้การแบ่งอย่างต่อเนื่องโดยสองรวบรวมทุก 4 บิตของการดำเนินการเป็นเลขฐานสิบหก เราใช้อักขระที่ไม่ใช่ตัวอักษรเพื่อแสดงผลลัพธ์ของเราเพื่อให้เราสะสมไว้ระหว่างการป้อนทศนิยมและการแสดงผลเลขฐานสิบหกและแปลงเป็นเลขฐานสิบหกธรรมดาที่ส่วนท้ายที่สุด

PHP, 65 66 64 + 1 62 59 ไบต์

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

ฟังก์ชั่นการพิมพ์ซ้ำพิมพ์ศูนย์นำหน้า (ใส่>16ก่อน&&เพื่อลบ)

โปรแกรม 64 ไบต์ +1 สำหรับ-R(เรียกใช้เป็นไพพ์ด้วย-nR)

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

ต้องการ PHP 5.6 หรือใหม่กว่า (5.5 ไม่สามารถจัดทำดัชนีตัวอักษรสตริง)

หรือ

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

ต้องการ PHP 5.6 หรือ 7.0 (7.1 เข้าใจสตริงดัชนีเชิงลบ)

ทำงานเป็นท่อที่มี-nRหรือลองพวกเขาออนไลน์

Julia ขนาด 55 ไบต์

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

นี่คือการใช้งานฟังก์ชั่นซ้ำขั้นพื้นฐาน มันรับจำนวนเต็มและส่งกลับสตริง

หากอินพุตมีค่าน้อยกว่า 15 ให้แบ่งพื้นด้วย 16 และเรียกเก็บเงินคืนมิฉะนั้นใช้สตริงว่าง ตะปูตัวนี้ลงบนด้านหน้าของอักขระเลขฐานสิบหกที่เลือกอย่างเหมาะสม

Pyre , 98 ไบต์

การทำสิ่งนี้ในภาษาที่ไม่มีตัวดำเนินการทางคณิตศาสตร์อาจเป็นความผิดพลาด

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

ใช้แบบนี้:

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

Ungolfed:

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 ตัวอักษร

(สำเนาLoovjo 's คำตอบหลาม .)

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

วิ่งตัวอย่าง:

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" 

อย่างจริงจัง 35 ไบต์

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

ฐานสิบหก:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

ลองใช้ออนไลน์

คำอธิบาย:

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

โปรดทราบว่า;7ªD+@9<7*+cมีค่าเท่ากับ4ª▀Eซึ่งจะบันทึก 8 ไบต์ แต่ฉันคิดว่าบางทีฟังก์ชั่นที่กดตัวเลขฐาน b เป็นสตริงอาจถือได้ว่าเป็น "heaxadecimal ในตัวมากเกินไป"

Javascript ES6, 64 58 ไบต์

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

บันทึกแล้ว 6 ไบต์ขอบคุณןnɟuɐɯɹɐןoɯและ user81655

Befunge-93, 58

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

ครั้งแรกที่ทำสิ่งที่ท้าทายกอล์ฟใน Befunge ฉันเดิมพันว่ามีหนึ่งซับสำหรับสิ่งนี้ที่สั้นกว่าเนื่องจากพื้นที่ทั้งหมดที่อยู่ตรงกลางของบรรทัดที่สองดูสิ้นเปลือง

คุณสามารถก้าวผ่านมันนี่ คำอธิบายบางส่วน:

&: รับอินพุต

:88+%: ใช้โมดูโลส่วนที่เหลือ 16

"0"+: เพิ่มลงในค่า ASCII เป็น 0

:"9"`: หากผลลัพธ์มากกว่าค่า ASCII ของ 9 ...

7*+: เพิ่ม 7 เพื่อแปลงเป็นตัวอักษร

\: บันทึกอักขระผลลัพธ์บนสแต็ก

8/2/: หารด้วย 16 ปัดเศษลง

:!#|_: ออกจากลูปถ้าผลลัพธ์เป็น 0

#: มิฉะนั้นกลับไปที่ขั้นตอนมอดุลัส

>:#,_@ (ล้อมรอบ): เมื่อเสร็จแล้วให้ส่งสแต็กตามลำดับ LIFO

> <> , 46 + 3 = 49 ไบต์

มันจะสั้นกว่านี้ถ้า> <> มีการหารจำนวนเต็มซึ่งตอนนี้เราต้องเลียนแบบโดยการลบโมดูโล 1 ถึงกระนั้นฉันคิดว่านี่ใช้เทคนิคการพันรอบ ๆ อย่างประณีต!

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

ลองออนไลน์!

คำอธิบาย

วงแรก

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

การวนซ้ำครั้งแรกดำเนินการแปลงแบบคลาสสิคเป็นอัลกอริธึมฐานสิบหก มันเป็นแบบโมดูโล 16 ( :f1+%) และตรวจสอบว่าผลลัพธ์เป็น <10 ( :a(?) หรือไม่ หากไม่เป็นเช่นนั้นเราต้องเพิ่ม 7 ( 7+) เพื่อเปลี่ยนจากทศนิยมเป็นตัวอักษรพิมพ์ใหญ่ในตาราง ASCII ก่อนอื่นเราสามารถดำเนินการต่อโดยการเพิ่มค่า ASCII สำหรับ 0 ( "0"+) และเลื่อนอักขระที่จะส่งออกไปด้านล่างของสแต็คเพราะเราจะต้องส่งออกในลำดับย้อนกลับ จากนั้นค่าสูงสุดจะถูกแทนที่ด้วยผลลัพธ์ของการหารจำนวนเต็มด้วย 16 ซึ่งจำลองด้วยการคำนวณ a / b - (a / b)% 1 (f1+,:1%- ) เมื่อลูปเสร็จสิ้นสแต็กจะประกอบด้วยอักขระเลขฐานสิบหกในลำดับผลลัพธ์ที่กลับด้านและ 0

วงที่สอง

!?:r<ro;

วนรอบที่สองจะย้อนกลับรายการและตรวจสอบว่าองค์ประกอบอันดับต้น ๆ เป็น 0 หรือไม่ถ้าใช่เรารู้ว่าไม่ใช่ศูนย์ทั้งหมดที่ถูกพิมพ์และเราควรยุติ อย่างอื่นเราเอาท์พุทตัวละครและกลับรายการอีกครั้งเพื่อเตรียมพร้อมสำหรับการทำซ้ำครั้งต่อไป :เมื่อเข้าสู่วงที่สองจะซ้ำ 0 ซึ่งไม่มีผลกระทบ

SpecBAS - 110 ไบต์

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$

นี่ใช้อัลกอริทึมที่ฉันพบในWikiHow (วิธีที่ 2)

สตริงใน SpecBAS เป็นแบบ 1 ดังนั้นการ+1เลือกองค์ประกอบที่ถูกต้อง

C (เสียงดังกราว) , 83 ไบต์

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

ลองออนไลน์!

โซลูชันสำรองใน C.

Ruby, 40 ไบต์

ถูกขโมยมาจากแรงบันดาลใจจากคำตอบของการจัดการ แต่ใช้ช่องโหว่ที่น่าสนใจเพื่อทำให้สั้นลง

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

REXX, 80 78 ไบต์

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

C, 48 ไบต์

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

นี่ไม่ใช่ต้นฉบับอย่างสมบูรณ์ฉันโกน 5 ไบต์ออกจาก Digital Trauma ที่วางไว้

APL (NARS), ตัวอักษร 34, ไบต์ 68

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

ทดสอบ:

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