Meydan okuma

İşte basit bir tane.

Temel 10'da bir sayı olarak giriş yapıldığında bir işlev veya program yazın, bu sayıyı Onaltılık olarak döndürür veya yazdırır .

Örnekler

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

kurallar

• Yerleşik onaltılı fonksiyon yok
• Harfler küçük veya büyük harf olabilir
• Yalnızca negatif olmayan tamsayılar, negatif veya sinir bozucu ondalık sayılar için endişelenmeniz gerekir.
• Dilin varsayılan türünün sınırına kadar isteğe bağlı olarak çok sayıda sayıda çalışmalıdır.
• Newline zorunlu değil
• Her zaman olduğu gibi, bu kod golf , bayt cinsinden ölçülen en kısa kod kazanır!

APL (Dyalog APL) , 17 bayt

⎕IO←0Birçok APL sisteminde varsayılan olan çalıştırılmalıdır .

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

Çevrimiçi deneyin!

(⎕D,⎕A)[... ] D için birleştirilmiş igits Bir lphabet, o sırada dizine ...

 16⊥⍣¯1  16-Baz-Sayının tersi, yani Sayı-Baz-16

 ⊢ uygulanan

 ⎕ sayısal giriş

Turing Makine Kodu, 412 bayt

Her zamanki gibi burada tanımlanan kural tablosu sözdizimini kullanıyorum . Bu sitede veya alternatif olarak bu java uygulamasını kullanarak test edebilirsiniz .

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 tabanındaki 0'dan sayılırken 10 tabanındaki girişten geri sayım yapar. 16 sıfıra düştüğünde, giriş bloğunu siler ve sonlandırır.

Java, 92 89 bayt

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

Javascript, 49 43 bayt.

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

User81655 tarafından kaydedilen 6 bayt .

Burada test et .

Bunun kuralların izin verdiği iki ana sıfır var.

İşte başında sıfır olmayan bir sürüm: (47 bayt).

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

Burada test et .

Bunların her ikisi de Python cevabımla tamamen aynı yaklaşımı kullanıyor .

CJam, 22 21 bayt

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

1 byte'lık golf için @ MartinBüttner'e teşekkürler!

Çevrimiçi deneyin!

Nasıl çalışır

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 bayt

Bu eğlenceli bir şeydi.

sm@+jkUTGi_d2_c_.BQ4

Çevrimiçi deneyin.

Açıklaması:

                .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 (işlev), 51

Özyinelemeli işlev giriş tamsayısını parametre olarak alır:

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

Test sürücüsü:

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

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

Kullanım örneği: sequence(s<$s)!!) $ 1000-> "00000000000003E8".

Bu, en fazla 16 onaltılık basamağa sahip onaltılık sayılardan oluşan bir liste oluşturur. Neyse ki bu sırayla gerçekleşir, bu yüzden sadece nbirini seçebiliriz .

Düzenleme: @Mauris 2 bayt sıktı. Teşekkürler!

dc, 37

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

Tekrarlayan bir şekilde 16'ya bölünerek geri kalanı bölmeye hiçbir şey kalmayıncaya kadar yığına iter. Ardından, AF basamakları elde etmek için divmod kullanarak 10'un her bir parçasını yazdırın. Muhtemelen yarın daha fazla ayrıntı ... (ve umarım daha az bayt).

Python, 59 58 bayt

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

CarpetPython tarafından kaydedilen 1 byte

Olarak çalıştırmak: print h(15)

Burada test edin (Ideone.com).

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Bash (fonksiyon), 62

Özyinelemeyi kullandığınız için @manatwork teşekkürler.

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

Perl 6 ,  53  48 bayt

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

Bu tamsayı (bölünmüş olan değerler bir dizi oluşturur divsonucu kadar) 0hariç 0dizisinden

$_, * div 16 ...^ 0

Daha sonra X( %) ile modulus operatörünü ( ) kullanarak bu sekansı geçiyor16

( … ) X[%] 16

Bu değerleri iki aralıktan oluşan düzleştirilmiş bir listeye indeks olarak kullanır 0..9ve'A'..'Z'

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

Sonunda ~reverse ( R) meta operatörünü kullanarak bunları birleştirir ( ).

[R[~]] …

Bu Yanlış bir değerle (boş dize) sonuçlanırsa, geri dönün 0

… || 0

Kullanımı:

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

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

Bu, bu zorluktan önceki dil / derleyicinin 5.1.0 sürümünü kullanır .

Örnek

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

açıklama

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 karakter / 62 bayt

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

Try it here (Firefox only).

Tamam, golf oynatan başka şeyler de buldum.

açıklama

Esasen @ SuperJedi224'ün ES6 çözümü ile aynı çözüm - ancak farklı bir şeyle.

Gördün ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝mü? Bu gerçekten güzel bir yazma biçimi "0123456789ABCDEF". ⩥Ḋ0 ile 10 Ⓒª⩥⁽ṁṇ⸩arasında bir aralık oluşturur, 65 ile 71 arasında bir aralık oluşturur ve bunu ASCII dizisine dönüştürür, veĀ...⨝ iki aralığı birleştirir ve bunları bir dizeye birleştirir. Bu muhtemelen çözümümün en havalı parçasıydı.

Bonus olmayan versiyonu, 24 karakter / 45 bayt

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

Pyth'deki gibi bir alfabe dizisi eklemeye karar verdim.

sed, 341 bayt

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

Bu zorluğun aşikar dili değil, ancak 4000 basamak ile sisteminizin kullanılabilir (sanal) belleğinin sınırı arasında (uygulamanıza bağlı olarak) giriş numaralarını destekleme avantajına sahiptir. RSA-1024'ü yaklaşık 0,6 saniyede hex'e dönüştürdüm, bu yüzden oldukça iyi ölçeklendi.

Her 4 bitlik taşıma için onaltılık bir basamağa toplanarak, art arda ikie bölünerek kullanılır. Çıktımızı temsil etmek için harf olmayan karakterleri kullanırız, böylece her zaman ondalık girişle onaltılık çıktı arasında taşıma biriktiririz ve en sonunda geleneksel onaltılık değere dönüştürürüz.

PHP, 65 66 64 + 1 62 59 bayt

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

özyinelemeli yazdırma işlevi, baştaki sıfırı basar ( >16çıkarmadan önce ekleyin &&)

programlar için 64 bayt +1 -R(ile birlikte çalıştır -nR)

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

PHP 5.6 veya üstünü gerektirir (5.5, string değişmezlerini indeksleyemez)

veya

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

PHP 5.6 veya 7.0 gerektirir (7.1 negatif dize dizinlerini anlar)

Pipe ile çalıştırın -nRveya çevrimiçi deneyin .

Julia, 55 bayt

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

Bu temel özyinelemeli fonksiyon uygulamasıdır. Bir tamsayı kabul eder ve bir dize döndürür.

Giriş 15'ten küçükse, zemin 16'ya bölün ve tekrar bağlayın, aksi takdirde boş ipi alın. Bunu uygun şekilde seçilmiş onaltılık karakterin önüne yerleştirin.

Pyre , 98 bayt

Bunu, aritmetik operatörler olmadan bir dilde yapmak muhtemelen bir hataydı.

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

Bunun gibi kullanın:

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

Yakut, 48 karakter

(Copy Loovjo 'in Python cevap .)

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

Örnek çalışma:

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" 

Cidden, 35 bayt

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

Hex Dump:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Çevrimiçi Deneyin

Açıklama:

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

Bunun 8 baytlık bir değere ;7ªD+@9<7*+ceşdeğer olduğunu unutmayın 4ª▀E, ancak temel b basamaklarını bir dize olarak iten bir fonksiyonun çok fazla bir "heaxadecimal yerleşik" değeri olarak kabul edilebileceğini düşündüm.

Javascript ES6, 64 58 bayt

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

ן nɟuɐɯɹɐ ן oɯ ve user81655 sayesinde 6 byte kurtarıldı.

Befunge-93, 58

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

Befunge'de ilk kez gerçek bir golf mücadelesi yaşarken, ikinci çizginin ortasındaki tüm alanlar boşa harcanmış gibi göründüğünden, bunun için daha kısa olan bir astar var.

Buradan geçebilirsiniz . Kısmi açıklama:

&: Giriş yapın.

:88+%: Kalan modülo 16'yı alın.

"0"+: 0 ASCII değerine ekleyin.

:"9"`: Sonuç 9 ASCII değerinden büyükse ...

7*+: Bir harfe dönüştürmek için 7 ekleyin.

\: Elde edilen karakteri yığına kaydet.

8/2/: Yuvarlama 16'ya bölün.

:!#|_: Sonuç 0 ise döngüden çıkın.

#: Aksi taktirde modül adımına geri dönün.

>:#,_@ (etrafına sarılır): İşlem bittikten sonra istifini LIFO sırasına göre verin.

> <> , 46 + 3 = 49 bayt

> <> Tamsayılı bir bölüme sahip olsaydı bu daha kısa olurdu, ki şu an modulo 1'i çıkartarak taklit etmemiz gerekiyor. Yine de, bunun hileler etrafında oldukça düzgün sarma kullandığını düşünüyorum!

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

Çevrimiçi deneyin!

açıklama

İlk döngü

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

İlk döngü klasik dönüştürme hex algoritmasına gerçekleştirir. Modulo 16 ( :f1+%) yapar ve sonucun <10 ( :a(?) olup olmadığını kontrol eder . Değilse 7+, ASCII tablosundaki ondalık sayılardan büyük harflere geçmek için 7 ( ) karakterini eklememiz gerekir . Aksi takdirde, ASCII değerini 0 ( "0"+) için ekleyerek ve karakterin yığının altına çıkarılması için karaktere geçirerek devam edebiliriz çünkü bunları ters sırayla çıkarmamız gerekir. Daha sonra en büyük değer tamsayı bölme sonucu 16 ile değiştirilir. Bu, a / b - (a / b)% 1 ( f1+,:1%-) değerini hesaplayarak öykünür . Döngü bittiğinde, yığın ters çıkış sırasındaki onaltılık karakterleri ve 0'ı içerir.

İkinci döngü

!?:r<ro;

İkinci döngü listeyi tersine çevirir ve üst öğenin 0 olup olmadığını kontrol eder. Öyleyse, sıfırdan farklı olanların basıldığını biliyoruz ve sonlandırmalıyız. Aksi takdirde, bir sonraki tekrarlamaya hazırlanmak için karakteri çıkarır ve listeyi tekrar tersine çeviririz. :İkinci döngü etkisi yoktur 0 çoğaltmak olacaktır girerken.

SpecBAS - 110 bayt

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$

Bu WikiHow'da bulduğum bir algoritmayı kullanıyor (2. yöntem).

SpecBAS'taki karakter dizileri 1-tabanlıdır, dolayısıyla +1doğru elemanı seçer.

C (clang) , 83 bayt

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

Çevrimiçi deneyin!

C alternatif çözüm

Yakut, 40 bayt

Manatwork'ün cevabından esinlenerek çalındı , ancak onu kısaltmak için ilginç bir boşluk kullanın.

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

REXX, 80 78 bayt

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

C, 48 bayt

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

Bu tamamen orijinal değil, Digital Trauma sürümünün 5 baytını tıraş ettim.

APL (NARS), karakter 34, bayt 68

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

Ölçek:

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