Herausforderung

Hier ist eine einfache.

Schreiben Sie eine Funktion oder ein Programm, wenn Sie eine Zahl in der Basis 10 als Eingabe eingeben, wird der Wert dieser Zahl in hexadezimaler Schreibweise zurückgegeben oder gedruckt .

Beispiele

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

Regeln

• Keine eingebauten Hexadezimalfunktionen
• Buchstaben können in Klein- oder Großbuchstaben geschrieben werden
• Sie müssen sich nur um nicht negative ganze Zahlen, keine negativen oder lästigen Dezimalzahlen kümmern
• Es sollte mit jeder beliebig großen Anzahl funktionieren, bis zum Limit des Standardtyps der Sprache.
• Zeilenumbruch nicht zwingend erforderlich
• Wie üblich ist dies Codegolf , also gewinnt der kürzeste in Bytes gemessene Code!

APL (Dyalog APL) , 17 Bytes

Muss mit ausgeführt werden ⎕IO←0, was bei vielen APL-Systemen standardmäßig der Fall ist.

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

Probieren Sie es online!

(⎕D,⎕A)[… ] D igits, die mit A lphabet verknüpft sind, dann indiziert von…

 16⊥⍣¯1  die Umkehrung von 16-Basis-zu-Zahl, dh Zahl-zu-Basis-16

 ⊢ angewendet

 ⎕ numerische Eingabe

Turing-Maschinencode, 412 Bytes

Wie üblich verwende ich die hier definierte Regeltabellensyntax. Sie können es auf dieser Site oder alternativ mit dieser Java-Implementierung testen .

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

Zählt von der Eingabe in Basis 10 abwärts, während von 0 in Basis 16 aufwärts gezählt wird. Wenn Null verringert wird, wird der Eingabeblock gelöscht und beendet.

Java, 92 89 Bytes

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

Javascript, 49 43 Bytes.

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

6 Bytes gespeichert von user81655 .

Teste es hier .

Dies hat zwei führende Nullen, was nach den Regeln zulässig ist.

Hier ist eine Version ohne führende Nullen: (47 Bytes).

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

Teste es hier .

Beide verwenden genau den gleichen Ansatz wie meine Python-Antwort .

CJam, 22 21 Bytes

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

Danke an @ MartinBüttner für das Golfen ab 1 Byte!

Probieren Sie es online!

Wie es funktioniert

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 Bytes

Dies war ein Spaß.

sm@+jkUTGi_d2_c_.BQ4

Probieren Sie es online aus.

Erklärt:

                .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 (Funktion), 51

Die rekursive Funktion verwendet eine Ganzzahl als Parameter:

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

Testfahrer:

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

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

Anwendungsbeispiel: sequence(s<$s)!!) $ 1000-> "00000000000003E8".

Dadurch wird eine Liste aller Hexadezimalzahlen mit bis zu 16 Hexadezimalstellen erstellt. Zum Glück geschieht dies in der richtigen Reihenfolge, so dass wir einfach die nrichtige auswählen können .

Edit: @ Mauris drückte 2 Bytes aus. Vielen Dank!

dc, 37

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

Dividiert rekursiv um 16 und schiebt den Rest auf den Stapel, bis sich nichts mehr teilen lässt. Drucken Sie dann jedes Element des Stapels mit divmod durch 10, um AF-Ziffern zu erhalten. Wahrscheinlich mehr Details morgen ... (und hoffentlich weniger Bytes).

Python, 59-58 Bytes

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

1 Byte von CarpetPython gespeichert

Rennen wie: print h(15)

Testen Sie es hier (Ideone.com).

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Bash (Funktion), 62

Vielen Dank an @manatwork für den Vorschlag, eine Rekursion zu verwenden.

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

Perl 6 ,  53  48 Bytes

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

Dadurch wird eine Folge von Werten erstellt, die durch ganze Zahlen geteilt werden ( div), bis das Ergebnis 0das 0von der Folge ausschließt

$_, * div 16 ...^ 0

Es kreuzt ( X) diese Sequenz mit dem Moduloperator ( %) mit16

( … ) X[%] 16

Diese Werte werden als Indizes in einer abgeflachten Liste verwendet, die aus zwei Bereichen 0..9und besteht'A'..'Z'

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

Schließlich verkettet ( ~) es sie mit dem reverse ( R) Meta-Operator

[R[~]] …

Wenn dies zu einem falschen Wert (leere Zeichenfolge) führt, geben Sie zurück 0

… || 0

Verwendung:

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

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

Hierbei wird Version 5.1.0 der Sprache / des Compilers verwendet, die älter als diese Herausforderung ist.

Beispiel

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

Erläuterung

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 Zeichen / 62 Bytes

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

Try it here (Firefox only).

Okay, ich habe mir noch ein paar Sachen ausgedacht, mit denen es besser ging.

Erläuterung

Es ist im Wesentlichen dieselbe Lösung wie die ES6-Lösung von @ SuperJedi224 - aber mit etwas anderem.

Seht ihr ⩥ḊĀⒸª⩥⁽ṁṇ⸩⨝? Das ist eine wirklich ausgefallene Art zu schreiben "0123456789ABCDEF". ⩥ḊErstellt einen Bereich von 0 bis 10, Ⓒª⩥⁽ṁṇ⸩erstellt einen Bereich von 65 bis 71 und konvertiert ihn in eine ASCII- Ā...⨝Zeichenfolge. Verkettet die beiden Bereiche und fügt sie zu einer Zeichenfolge zusammen. Dies war wahrscheinlich der coolste Teil meiner Lösung.

Bonus nicht wettbewerbsfähige Version, 24 Zeichen / 45 Bytes

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

Ich habe beschlossen, eine alphabetische Zeichenfolge hinzuzufügen, wie in Pyth.

sed, 341 bytes

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

Es ist nicht die offensichtliche Sprache für diese Herausforderung, hat jedoch den Vorteil, dass Eingabenummern (abhängig von Ihrer Implementierung) mit bis zu 4000 Stellen und der Begrenzung des verfügbaren (virtuellen) Speichers Ihres Systems unterstützt werden. Ich habe RSA-1024 in ca. 0,6 Sekunden in Hex konvertiert, sodass es recht gut skaliert.

Es funktioniert mit der sukzessiven Division durch zwei, wobei alle 4 Übertragsbits eine hexadezimale Zahl gebildet wird. Wir verwenden Nicht-Buchstaben-Zeichen, um unsere Ausgabe darzustellen, sodass wir immer einen Übertrag zwischen der Dezimaleingabe und der Hexadezimalausgabe akkumulieren und ganz am Ende in ein herkömmliches Hexadezimal umwandeln.

PHP, 65 66 64 + 1 62 59 Bytes

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

rekursive Druckfunktion, druckt eine führende Null ( >16vorher einfügen &&, um sie zu entfernen)

Programme, 64 Bytes +1 für -R(als Pipe mit ausführen -nR)

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

erfordert PHP 5.6 oder neuer (5.5 kann keine String-Literale indizieren)

oder

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

benötigt PHP 5.6 oder 7.0 (7.1 versteht negative String-Indizes)

Laufen Sie als Pipe mit -nRoder probieren Sie sie online aus .

Julia, 55 Bytes

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

Dies ist die grundlegende Implementierung einer rekursiven Funktion. Es akzeptiert eine Ganzzahl und gibt eine Zeichenfolge zurück.

Wenn die Eingabe kleiner als 15 ist, teilen Sie sie durch 16 und wiederholen Sie den Vorgang, andernfalls nehmen Sie die leere Zeichenfolge. Heften Sie dies auf die Vorderseite des entsprechend ausgewählten Hexadezimalzeichens.

Pyre , 98 Bytes

Dies in einer Sprache ohne arithmetische Operatoren zu tun, war wahrscheinlich ein Fehler.

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

Verwenden Sie wie folgt:

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 Zeichen

(Kopie des Loovjo ‚s Python Antwort .)

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

Probelauf:

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" 

Im Ernst, 35 Bytes

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

Hex Dump:

2c603b34a640252934a6405c60ce58ee204460403b37a6442b40393c372a2b632b606e

Probieren Sie es online

Erläuterung:

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

Beachten Sie, dass das ;7ªD+@9<7*+cäquivalent zu ist 4ª▀E, was 8 Bytes einspart, aber ich dachte, dass eine Funktion, die die Basis-B-Ziffern als Zeichenfolge überträgt, möglicherweise als zu viel eines "eingebauten Heaxadezimals" betrachtet wird.

Javascript ES6, 64 58 Bytes

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

6 Bytes gespart dank ן nןuɟ ן oן und user81655.

Befunge-93, 58

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

Ich wette, es gibt einen Einzeiler, der kürzer ist, da all diese Zwischenräume in der Mitte der zweiten Linie verschwenderisch erscheinen, wenn ich zum ersten Mal eine echte Golfherausforderung in Befunge mache.

Sie können es hier durchlaufen . Teilweise Erklärung:

&: Eingaben übernehmen.

:88+%: Nehmen Sie den Rest Modulo 16.

"0"+: Fügen Sie es dem ASCII-Wert 0 hinzu.

:"9"`: Wenn das Ergebnis größer als der ASCII-Wert von 9 ist ...

7*+: Addiere 7, um es in einen Buchstaben umzuwandeln.

\: Speichern Sie das resultierende Zeichen auf dem Stapel.

8/2/: Durch 16 abrunden.

:!#|_: Verlasse die Schleife, wenn das Ergebnis 0 ist.

#: Andernfalls kehren Sie zum Modul zurück.

>:#,_@ (Umwickeln): Wenn Sie fertig sind, geben Sie den Stapel in der LIFO-Reihenfolge aus.

> <> , 46 + 3 = 49 Bytes

Dies wäre kürzer gewesen, wenn> <> eine Ganzzahldivision gehabt hätte, die wir jetzt durch Subtrahieren von Modulo 1 emulieren müssen. Trotzdem denke ich, dass dies einige ziemlich ordentliche Tricks erfordert!

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

Probieren Sie es online!

Erläuterung

Erste Schleife

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

Die erste Schleife führt die klassische Umwandlung in einen Hex-Algorithmus durch. Es tut Modulo 16 ( :f1+%) und prüft, ob das Ergebnis <10 ( :a(?) ist. Wenn dies nicht 7+der Fall ist , müssen wir 7 ( ) hinzufügen , um von den Dezimalstellen zum Großbuchstaben in der ASCII-Tabelle zu gelangen. Andernfalls können wir fortfahren, indem wir den ASCII-Wert für 0 ( "0"+) hinzufügen und das auszugebende Zeichen an den unteren Rand des Stapels verschieben, da wir sie in umgekehrter Reihenfolge ausgeben müssen. Der oberste Wert wird dann durch das Ergebnis der Ganzzahldivision durch 16 ersetzt. Dies wird durch Berechnen von a / b - (a / b)% 1 (f1+,:1%- ) . Wenn die Schleife beendet ist, enthält der Stapel die Hexadezimalzeichen in umgekehrter Ausgabereihenfolge und eine 0.

Zweite Schleife

!?:r<ro;

Die zweite Schleife kehrt die Liste um und prüft, ob das oberste Element 0 ist. Wenn dies der Fall ist, wissen wir, dass alle Nicht-Nullen gedruckt wurden und wir sollten abbrechen. Ansonsten geben wir das Zeichen aus und kehren die Liste erneut um, um uns auf die nächste Iteration vorzubereiten. Die :beim Eintritt in die zweite Schleife wird die 0 duplizieren , die keine Wirkung.

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$

Dies verwendet einen Algorithmus, den ich in WikiHow gefunden habe (2. Methode).

Strings in SpecBAS basieren auf 1, daher +1das richtige Element auswählen.

C (clang) 83 Bytes

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

Probieren Sie es online!

Alternative Lösung in C

Ruby, 40 Bytes

Gestohlen von Inspiriert von der Antwort von manatwork, aber mit einer interessanten Lücke, um es kürzer zu machen.

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

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

C 48 Bytes

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

Dies ist nicht ganz original, ich habe 5 Bytes von der Version Digital Trauma entfernt.

APL (NARS), Zeichen 34, Bytes 68

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

Prüfung:

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