도전

여기 간단한 것이 있습니다.

기수 10에 숫자를 입력으로 받으면 함수 또는 프로그램을 쓰십시오 . 16 진수로 해당 숫자의 값을 반환하거나 인쇄합니다 .

예

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

규칙

• 16 진 함수가 내장되어 있지 않습니다
• 문자는 소문자 또는 대문자 일 수 있습니다
• 음수가 아닌 정수, 음수 또는 성가신 소수 만 걱정하면됩니다.
• 언어의 기본 유형 한도까지 임의로 많은 수를 사용할 수 있습니다.
• 필수가 아닌 개행
• 평소와 같이 이것은 code-golf 이므로 바이트 단위로 측정 된 가장 짧은 코드가 승리합니다!

APL (Dyalog APL) , 17 바이트

⎕IO←0많은 APL 시스템에서 기본값 인 으로 실행해야합니다 .

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

온라인으로 사용해보십시오!

(⎕D,⎕A)[... ] D 에 연결된 igits lphabet는 다음에 의해 인덱싱 ...

 16⊥⍣¯1  16 대 숫자의 역수, 즉 숫자 대 16의 역수

 ⊢ 에 적용

 ⎕ 숫자 입력

튜링 머신 코드, 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의 입력에서 카운트 다운합니다. 0을 줄이면 입력 블록이 지워지고 종료됩니다.

자바, 92 89 바이트

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

자바 스크립트, 49 43 바이트

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

user81655가 6 바이트를 절약했습니다 .

여기에서 테스트 하십시오 .

여기에는 규칙에 의해 허용되는 두 개의 선행 0이 있습니다.

앞에 0이없는 버전은 다음과 같습니다 (47 바이트).

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

여기에서 테스트 하십시오 .

이 두 가지 모두 내 파이썬 답변 과 정확히 동일한 접근법을 사용합니다 .

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.

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

하스켈, 59 58 43 41 39 바이트

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

사용 예 : sequence(s<$s)!!) $ 1000-> "00000000000003E8".

최대 16 개의 16 진수까지 모든 16 진수 목록을 만듭니다. 운 좋게 이것은 순서대로 발생하므로 간단히 n하나만 선택할 수 있습니다 .

편집 : @Mauris는 2 바이트를 압착했습니다. 감사!

dc, 37

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

재귀 적으로 16만큼 divmods하고 남을 부분이 남을 때까지 나머지 부분을 스택으로 밀어 넣습니다. 그런 다음 divmod를 10 씩 사용하여 스택의 각 요소를 인쇄하여 AF 숫자를 얻습니다. 아마 내일 더 자세한 내용은 ... (그리고 희망적으로 더 적은 바이트).

파이썬, 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.

C (gcc) , 45 44 바이트

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

온라인으로 사용해보십시오!

배쉬 (기능), 62

재귀 사용을 제안하는 @manatwork에게 감사합니다.

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

펄 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[~]] …

그 결과 False 값 (빈 문자열)이 발생하면 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).

좋아, 나는 골프를 치는 더 많은 것들을 알아 냈다.

설명

본질적으로 @ SuperJedi224의 ES6 솔루션과 동일한 솔루션이지만 다른 점이 있습니다.

참조 ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? 정말 멋진 글쓰기 방법입니다 "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*//

이 문제에 대한 명확한 언어는 아니지만 4000 자리와 시스템의 사용 가능한 (가상) 메모리 제한 사이에서 (구현에 따라) 입력 번호를 지원하는 이점이 있습니다. 약 0.6 초 안에 RSA-1024를 16 진수로 변환 했으므로 확장 성이 합리적입니다.

연속적인 2 나누기를 사용하여 4 비트의 캐리를 16 진수로 누적합니다. 문자가 아닌 문자를 사용하여 출력을 나타내므로 항상 10 진수 입력과 16 진수 출력 사이에 캐리를 누적하고 맨 끝에 일반적인 16 진수로 변환합니다.

PHP, 65 66 64 + 1 62 59 바이트

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

재귀 인쇄 기능, >16앞에 오는 0을 인쇄합니다 ( &&제거 하기 전에 삽입 )

프로그램, 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하거나 온라인으로 사용해보십시오 .

줄리아, 55 바이트

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

이것이 기본 재귀 함수 구현입니다. 정수를 받아들이고 문자열을 반환합니다.

입력 값이 15보다 작 으면 플로어를 16으로 나누고 재귀하고 그렇지 않으면 빈 줄을 가져갑니다. 적절하게 선택한 16 진수 문자 앞에 이것을 붙입니다.

파이어 , 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

루비, 48 자

( Loovjo 의 Python 답변 사본 )

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ª▀E8 바이트를 절약 할 수있는,하지만 난 문자열이 너무 많이 "내장 heaxadecimal"의 간주 될 수 같은 숫자 나베이스를 못살게 굴지 아마도 기능을 생각했다.

자바 스크립트 ES6, 64 58 바이트

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

ן nɟuɐɯɹɐ ן oɯ 및 user81655 덕분에 6 바이트를 절약했습니다.

베 펀지 -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 진 알고리즘으로 클래식 변환을 수행합니다. 모듈로 16 ( :f1+%)을 수행하고 결과가 <10 ( :a(?) 인지 확인합니다 . 그렇지 않은 경우 7+ASCII 테이블의 10 진수에서 대문자로 이동하려면 7 ( ) 을 추가해야 합니다. 그렇지 않으면 0 ( "0"+)에 ASCII 값을 추가하고 출력 할 문자를 스택의 맨 아래로 이동하여 역순으로 출력해야하므로 계속 진행할 수 있습니다 . 그런 다음 최상위 값은 정수 나누기 결과를 16으로 바꿉니다. 이는 a / b-(a / b) % 1 ( f1+,:1%-) 을 계산 하여 에뮬레이션됩니다 . 루프가 끝나면 스택은 16 진 문자를 역순으로 출력하고 0을 포함합니다.

두 번째 루프

!?:r<ro;

두 번째 루프는 목록을 반대로 바꾸고 top 요소가 0인지 확인합니다. 만약 그렇다면 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의 대체 솔루션

루비, 40 바이트

도난에서 manatwork의 답변 에서 영감을 얻었지만 흥미로운 허점을 사용하여 더 짧게 만듭니다.

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

이것은 완전히 독창적이지는 않습니다. Digital Trauma가 올려 놓은 버전에서 5 바이트를 깎았습니다.

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