23

これは簡単なものです。

# 例

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

# ルール

• 組み込みの16進関数は一切ありません
• 文字は小文字でも大文字でもかまいません
• あなたは非負の整数だけを心配する必要があり、負の数や厄介な小数はありません
• 言語のデフォルトタイプの制限までの任意の大きな数で動作するはずです。
• 改行は必須ではありません
• いつものように、これはなので、バイト単位で測定された最短コードが勝ちです！

ランダムガイ

5

nimi

Loovjo

1
@nimiはい、許可されています。
ランダムガイ

1

マシュー盧

4

# 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

`⊢` に適用されます

`⎕` 数値入力

これは17文字で約23バイトではありませんか？
ジュリーペレティエ

1
@JuliePelletierいいえ、Dyalog APLは独自の256文字のコードページを使用します。
アダム

ああ！知っておくといい。
ジュリーペレティエ

14

# チューリング機械コード、412バイト

いつものように、ここで定義されているルールテーブルの構文を使用しています。そのサイトでテストするか、この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
``````

ベース16の0からカウントアップしながら、ベース10の入力からカウントダウンします。ゼロをデクリメントすると、入力ブロックを消去して終了します。

これは本当にクールです。`10*n + 33`任意のを完了するには指示が必要`n`です。私はコードを理解していません。

@MagicOctopusUrn入力の左側にセルの新しいブロックを作成します。最初は0を含みます。その後、ベース10の入力ブロックを繰り返しデクリメントし、ベース16の出力ブロックをインクリメントします。デクリメントサイクル[入力ブロックが現在0であることを通知する]。この時点で、停止する前にテープをクリーンアップします（したがって、出力のみがテープに残ります）。
SuperJedi224

@MagicOctopusUrnまた、ランタイムの方程式が間違っています（ただし、正しい一般的な方程式が何であるかはわかりませんが、明らかにそうではありません）。たとえば、2の入力で試してください。
SuperJedi224

おそらくない。ただし、高い値には近いようです。私はそれについて何も知らず、パターンを見ようとしました。

9

# Java、92 89バイト

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

9

# Javascript、49 43バイト。

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

user81655によって6バイトが保存されました

ここでテストしてください

これには、2つの先行ゼロがあり、これはルールで許可されています。

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

ここでテストしてください

これらの両方は、私のPythonの答えとまったく同じアプローチを使用します

バイナリANDを使用します。`i&15`自動的に整数に変換され、小数が削除されます。必要はありません`~~`
edc65

3バイトと先行ゼロを1つ保存し`h=i=>i&&h(i>>4)+"0123456789abcdef"[i&15]`
ニール

8

# CJam、22 21バイト

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

1バイトのゴルフをしてくれた@MartinBüttnerに感謝します！

オンラインでお試しください！

### 使い方

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

5

Martin Ender

6

# 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.
``````

TanMath

ルーク

TanMath

5

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

5

## Haskell、59 58 43 41 39バイト

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

これにより、16桁までのすべての16進数のリストが作成されます。幸いなことに、これは順番に行われるため、単純に`n` 1番目をます。

Datリストモナドdoe
デニス

@Daenyth：私はモナドからのFunctorに切り替えた
nimi

どうですか`s="0123456789ABCDEF";(sequence(s<\$s)!!)`
リン

@モーリス：すごい！
nimi

4

# dc、37

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

4

# Python、59 58バイト

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

CarpetPythonで 1バイト保存

として実行： `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.
``````

1
よくやった。で別のバイトを保存することもできます`h=lambda i:(i>15 and h(i/16)or'')+"0123456789abcdef"[i%16]`
ロジックナイト

ウィレム

4

# C（gcc）、45 44バイト

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

オンラインでお試しください！

RosLuP

3

# Bash（関数）、62

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

いいね しかし、再帰的な方法はまだ短いようです：`h(){ x=({0..9} {A..F});echo `((\$1>15))&&h \$[\$1/16]`\${x[\$1%16]}; }`
manatwork

1
@manatworkニース-ありがとう！何らかの理由で、他の答えで再帰を使用しているにもかかわらず、bashで再帰を試みることを通常忘れます。関数本体の`()`代わりに使用すると`{ ;}`、さらに節約できます:)
デジタル外傷

3

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

これらの値を、2つのRange `0..9``'A'..'Z'`

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

``[R[~]] …``

``… || 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``````

2

# 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)
``````

2

# 𝔼𝕊𝕄𝕚𝕟、31文字/ 62バイト

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

Try it here (Firefox only).

さて、私はそれをゴルフで落としたものをさらに見つけました。

# 説明

@ SuperJedi224のES6ソリューションと本質的に同じソリューションですが、異なる点があります。

# ボーナス非競争バージョン、24文字/ 45バイト

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

Pythのように、アルファベット文字列を追加することにしました。

2

# sed、341バイト

``````:
s/\b/_/2
s//&;/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*//
``````

これはこの課題の明白な言語ではありませんが、4000桁からシステムの使用可能な（仮想）メモリの制限まで（実装に応じて）入力数をサポートできるという利点があります。約0.6秒でRSA-1024を16進数に変換したため、適切にスケーリングできます。

2の連続した除算を使用して動作し、4ビットごとに16進数の桁上げを行います。非文字文字を使用して出力を表すため、10進入力と16進出力の間のキャリーを常に蓄積し、最後に従来の16進に変換します。

2

# PHP、65 66 64 + 1 62 59バイト

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

プログラム、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`、オンラインで試してください

1

イェルクHülsermann

`+`記号は、最初の文字で出力をカットします... ..`?:0`
Titus

1

# ジュリア、55バイト

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

これは、基本的な再帰関数の実装です。整数を受け入れ、文字列を返します。

1

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

ゴルフをしていない：

``````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
``````

1

# Ruby, 48 characters

(Copy of Loovjo's Python answer.)

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

Sample run:

``````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
=> "f"
2.1.5 :003 > h
=> "3e8"
2.1.5 :004 > h
=> "100"
``````

1

## Seriously, 35 bytes

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

Hex Dump:

``````2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e
``````

Try It Online

Explanation:

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

Note that the `;7ªD+@9<7*+c` is equivalent to `4ª▀E`, which would save 8 bytes, but I thought that perhaps a function that pushes the base b digits as a string might be considered too much of a "heaxadecimal built-in".

1

# Javascript ES6, 64 58 bytes

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

Saved 6 bytes thanks to ןnɟuɐɯɹɐןoɯ and user81655.

1
Use eval: `v=>eval('for(z="";v;v=v/16|0)z="0123456789ABCDEF"[v%16]+z')`
Mama Fun Roll

1
Oh yeah, try using atob and btoa for that long string.
Mama Fun Roll

@ןnɟuɐɯɹɐןoɯ Tried `v=>{for(z="";v>0;v=v/16|0)z=btoa``Ó]·ã»óÐ1``[v%16]+z;return z}` (The double tildes are single tildes) ==> 64 chars, 71 bytes. Not worth it.
usandfriends

1
`v=v/16|0` is just a complex way of writing `v>>=4`.
user81655

1

# Befunge-93, 58

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

First time doing a real golfing challenge in Befunge, I bet there's a one-liner for this that's shorter since all those spaces in the middle of the second line seem wasteful.

You can step through it here. Partial explanation:

`&`: Take input.

`:88+%`: Take the remainder modulo 16.

`"0"+`: Add it to the ASCII value of 0.

`:"9"``: If the result is greater than the ASCII value of 9...

`7*+`: Add 7 to convert it to a letter.

`\`: Save the resulting character on the stack.

`8/2/`: Divide by 16 rounding down.

`:!#|_`: Exit the loop if the result is 0.

`#`: Otherwise go back to the modulus step.

`>:#,_@` (wrapping around): Once finished, output the stack in LIFO order.

1

# ><>, 46 + 3 = 49 bytes

This would have been shorter if ><> had integer division, which we now have to emulate by subtracting modulo 1. Still, I think this uses some pretty neat wrapping around tricks!

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

Try it online!

## Explanation

First loop

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

The first loop performs the classic converting to hex algorithm. It does modulo 16 (`:f1+%`) and checks if the result is < 10 (`:a(?`). If it's not, we need to add 7 (`7+`) in order to go from the decimals to the capital alphabet in the ASCII table. Else, we can proceed by adding the ASCII value for 0 (`"0"+`) and shifting the character to be output to the bottom of the stack because we'll have to output them in reverse order. The top value is then replaced by its result of integer division by 16. This is emulated by computing a/b - (a/b)%1 (`f1+,:1%-`). When the loop is finished, the stack contains the hexadecimal characters in reversed output order and a 0.

Second loop

``````!?:r<ro;
``````

The second loop reverses the list and checks if top element is 0. If it is, we know all nonzero were printed and we should terminate. Else, we output the character and reverse the list again to prepare for the next iteration. The `:` when entering the second loop will duplicate the 0 which has no effect.

0

# SpecBAS - 110 bytes

``````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\$
``````

This uses an algorithm I found on WikiHow (2nd method).

Strings in SpecBAS are 1-based, hence the `+1` to pick out the correct element.

0

# C (clang), 83 bytes

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

Try it online!

Alternate solution in C

0

# Ruby, 40 bytes

Stolen from Inspired by manatwork's answer, but using an interesting loophole to make it shorter.

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

0

## REXX, 80 78 bytes

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

0

# C, 48 bytes

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

This is not completely original, I shaved 5 bytes off of the version Digital Trauma put up.

0

# APL(NARS), chars 34, bytes 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
``````

Licensed under cc by-sa 3.0 with attribution required.