Hexadezimaler Zähler

10

Bild der Hex-Umrechnungstabelle mit Zähler

Hexadezimal ist ein Basis-16-Zählsystem, das von 0bis geht f. Ihre Aufgabe ist es, einen Zähler zu erstellen, der diese Zahlen anzeigt.

Beispiel:

$ python counter.py
1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d 1e 1f 20 21 22 23 24 25 26 27 28 29 2a 2b 2c 2d 2e 2f 30

Regeln:

  • Die Zahlen können durch Leerzeichen, Tabulatoren oder neue Zeilen getrennt sein.
  • Die Mindestanzahl, zu der Sie gehen müssen, ist 30(48 in Dezimalzahl).
    • Sie können das Programm auch für immer drucken lassen, bis es gestoppt wird.
  • Buchstaben können in Groß- oder Kleinbuchstaben ( Aoder a) geschrieben sein.
  • Keine eingebauten Funktionen erlaubt (die sich direkt auf hexadezimale Konvertierungen / Zählungen auswirken).
  • Führende Nullen sind zulässig
  • Es kann von 1oder beginnen0
  • Der kürzeste Code gewinnt!
Phase
quelle
@ Sp3000 Wie eingebaut sind sie? Dezimal in Hex umwandeln?
Phase
@ Sp3000 Keine eingebauten Funktionen erlaubt!
Phase
4
Wie wäre es dann mit allgemeinen Basiskonvertierungsfunktionen?
Sp3000
1
@ Sp3000 Sicher (ignoriere dies, maximal 15 Zeichen)
Phase
1
@ Mauris Ja! Das wird sicher interessant ...
Phase

Antworten:

5

Pyth - 12 Bytes

Verwendet kartesisches Produkt und sortiert am Ende, um die richtige Reihenfolge zu erhalten. Anschließend werden Leerzeichen eingefügt. Drucke 00-ffinklusive.

jdS^s+<G6UT2

Probieren Sie es hier online aus .

jd             Join by spaces
 S             Sort lexiographically
  ^    2       Cartesian product repeat twice
   s+          Append then concatenate entire list
    <G6        First six of alphabet
    UT         Range 0-9
Maltysen
quelle
6

CJam, 21 14 Bytes

A,_6,'Af++m*S*

Druckt die Zahlen 00 bis 9F.

Probieren Sie es online im CJam-Interpreter aus .

Wie es funktioniert

A,             e# Push [0 ... 9].
  _            e# Push a copy.
   6,          e# Push [0 ... 5].
     'Af+      e# Add 'A' to each. This pushes "ABCDEF".
         +     e# Concatenate. This pushes [0 ... 9 'A' ... 'F'].
          m*   e# Cartesian product. This pushes [[0 0] ... [9 'F'].
            S* e# Join, separating by spaces.
Dennis
quelle
5

Python 2, 52

a=0
for b in'0123456789ABCDEF'*4:print`a`+b;a+=b>'E'

Druckt 00auf 3F. Nutzt die Tatsache, dass die erste Ziffer aimmer eine Zahl in diesem Bereich ist. Durchläuft vier Zyklen der zweiten Ziffer bund erhöht sich, awann immer die zweite Ziffer ist F.

Dies ist ein Zeichen kürzer als das direktere

for a in'0123':
 for b in'0123456789ABCDEF':print a+b
xnor
quelle
n ='0123'sollte einige Zeichen sparen
Caridorc
@Caridorc Wie genau?
xnor
durch Schreibenthing in n + restofstring
Caridorc
@ Caricord Nicht sicher, was du meinst, es ist länger zu tunn='0123' for a in n: for b in n+'456789ABCDEF':print a+b
xnor
2
@Caridorc Eine Metallverknüpfung, die ich verwende, ist, dass das Speichern in einer Variablen 4 Zeichen kostet. Zum Ausgleich sind also> 4 Zeichen erforderlich, sodass das Speichern von 4 Zeichen 0123für etwas anderes nicht ausreicht.
xnor
5

JavaScript (ES6), 57 Byte

Gleicher Ansatz wie bei Python, nehme ich an.

for(i of c='0123456789ABCDEF')for(j of c)console.log(i+j)
rink.attendant.6
quelle
4

TI-Basic, 63 Bytes

:For(I,0,4,16⁻¹
:Disp sub(" 0123456789ABCDEF",1+16fPart(I),2
:Output(7,1,int(I
:End

Dies sind 63 Bytes, laut dem Speicherverwaltungsbildschirm auf meinem Rechner, einem TI-84 +. Stellen Sie sicher, dass Sie das Programm mit einem teilweise ausgefüllten Startbildschirm starten!

gengkev
quelle
Haben Sie daran gedacht, die Länge des 9-Byte-Headers und den Programmnamen von der Codelänge zu subtrahieren?
Lirtosiast
4

Befunge-93, 57 Bytes

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:9-!#@_0
0123456789ABCDEF

Druckt Zahlen von 00bis 8F. Wenn Sie möchten, dass Ihre Programme für immer ausgeführt werden, wird die folgende Version nicht beendet und gibt kontinuierlich alle Nummern von 00bis aus FF.

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:35*`!*0
0123456789ABCDEF
Sok
quelle
Sie können ein paar Bytes in -98 mit <_v # -f: +1, ', g2: \, g2: \ speichern. Kann nicht viele Verbesserungen darüber hinaus sehen.
Jacob
0123456789ABCDEF01g::88+/2-0g,88+%0g,9,1+01p
Lynn
Das sind 44 Bytes. Es wird wie Ihre zweite Lösung für immer wiederholt und gibt nach dem zweiten 1F falsche Ergebnisse aus. Es erfordert eine Implementierung (wie die Referenzimplementierung bef.c), die unbekannte Befehle ( ABCDEF) stillschweigend ignoriert .
Lynn
(Das OP erwähnt, dass es in Ordnung ist, wenn eine Lösung irgendwo nach dem Schlagen "bricht" 30- diese Lösung wird den Stapel langsam überlaufen, also gibt es vermutlich einen Punkt der Beendigung. Außerdem ist die Ausgabe durch Tabulatoren getrennt; das OP sagte, dies sei in Ordnung. ) Oh, die Befunge-Implementierung, die Sie verwenden, sollte auch den gesamten 80x25-Torus mit Leerzeichen (ASCII 0x20) initialisieren .
Lynn
@Mauris Würde sich dies in Bezug auf Ihren Kommentar zur Implementierung, bei der der gesamte Torus mit Leerzeichen instanziiert werden muss, auf die Anzahl der Bytes für meinen dargestellten Code auswirken? Ich habe nur die notwendigen Zeichen gezählt, anstatt die Ecken mit Leerzeichen zu füllen.
Sok
2

C 78 75 Bytes

x(y){return y+48+y/10*7;}f(j){for(j=0;printf("%c%c ",x(j/16),x(15&j++)););}

Wir definieren eine Funktion f(), die ohne Argumente zum Drucken aufgerufen werden soll, und eine Hilfsfunktion x(int). Das bricht bei FF.

Erstaunlicherweise ist dies ein Byte kürzer als das offensichtlichere:

char*s="0123456789ABCDEF";h(j){for(j=0;printf("%c%c ",s[j/16],s[15&j++]););}

Warnung: Es wird nicht empfohlen, diesen Code außerhalb einer Debug-Umgebung auszuführen ...

Testen:

int main(int argc, char** argv) {
    f();
    return 0;
}

Ausgabe:

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15 16 17 18 19 1A 1B 1C 1D 1E 1F 20 21 22 23 24 25 26 27 28 29 2A 2B 2C 2D 2E 2F 30 31 32 33 34 35 36 (...)

Der robustere (und betrügerischere) Ansatz ist natürlich diese 34-Byte-Funktion:

g(i){for(i=0;printf("%x ",i++););}
BrainSteel
quelle
1
Ich habe angefangen, das zu versuchen, aber meine Antwort war zu ähnlich. Sie können mehrere Bytes speichern, indem Sie das erste% c in% d umwandeln und die Funktion weglassen. Es ist dann allerdings nur bis 9F gültig.
Alchymist
return y+könnte möglicherweise sein y+=.
Jonathan Frech
2

Pyth, 17 Bytes

VJs++kUT<G6FYJ+NY

Probieren Sie es hier aus

Wie es funktioniert:

         <G6         # "abcdef"
       UT            # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      k              # an empty string (so + means concatenation, not addition)
   s++               # join them all ("0123456789abcdef")
  J                  # call this J
 V                   # for each N in J...
            FYJ      # for each Y in J...
               +NY   # print N and Y
Ypnypn
quelle
jb^+jkUT<G6 2verwendet das kartesische Produkt, um das Gleiche zu tun, scheint immer noch golffähig zu sein ...
FryAmTheEggman
2

Javascript ES6, 67 62 Bytes

(x=''.replace.bind('0123456789ABCDEF',/./g))(n=>x(o=>' '+n+o))
George Reith
quelle
2

J, 22 Bytes

>{;~'0123456789abcdef'

Zählt zu ff. Druckt eine zusätzliche neue Zeile zwischen jedem Zahlenblock 0x10wie folgt :

...
0d
0e
0f

10
11
...
Lynn
quelle
2

Mumps - 65 Bytes

S Q="0123456789ABCDEF" F I=1:1:16 F J=1:1:16 W $E(Q,I),$E(Q,J),!

Nein ... Mumps sind noch nicht tot! :-)

zmerch
quelle
2

CJam, 22 Bytes

1{_GbA,6,'af++f=oNo)}h

Dies läuft für immer und ist daher wahrscheinlich eine der seltenen Situationen, in denen es eine gute Idee ist, keinen Permalink einzuschließen.

Sp3000
quelle
oNoist das gleiche wie nin TIO.
Esolanging Fruit
2

TheC64Mini und Commodore BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 BASIC- und Tokenized-Bytes werden verwendet

 0 fOd=.to255:n=d:fOi=1to.stE-1:h%(i)=n/(16^i):n=n-(h%(i)*(16^i)):nEi:h$=""
 1 fOi=1to.stE-1:ifh%(i)<10tHh$=h$+cH(48+h%(i))
 2 ifh%(i)>9tHh$=h$+cH(55+h%(i))
 3 nEi:?h$"  ";:nEd

Druckt ein doppeltes Leerzeichen nach der Hex-Nummer, um den Druck auf 40/80 Spalten sowie die 22 Spalten auf dem VIC-20 auszurichten.

Commodore Plus / 4 Hex Zähler innit

Shaun Bebbers
quelle
2

Brainfuck , 2902 Bytes

Leicht zu outgolf, aber einen Versuch wert

+>+[<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>[-]++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<<[-]++++++++++++++++++++++++++++++++++++++++++++++++>[-]<[>+<<+>-]<[>+<-]<]>+<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>.>.>>>++++++++++++++++++++++++++++++++.[-]<<[-]<<[>>+<<<+>-]<[>+<-]>>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<[<<<<+>>>>-]+>>[<<<<<<-<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[>>>>-<<<<[-]]>>>>>>[-]++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>>>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++<<[<<<<+>>>>-]+>>[<<<<<<-<+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[>>>>-<<<<[-]]>>>>>>[-]+++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<<[>>+<<<+>-]<[>+<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>+++++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]>++++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>++++<<[<<<<<+>+>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>+>>>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>-----<<<[-]>>>[<<<+<+>>>>-]<<<<[>>>>+<<<<-]>>>>+++++>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>+++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>>-----<<[-]>>[<<+<<+>>>>-]<<<<[>>>>+<<<<-]>>>>+++++>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>+>[-]++++++++++++++++++++++++++++++++++++++++++++++++>>>+<<<<<<<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>>>>>>>[-]<<<<<<]>+++++<<+<<[>>->+<<<-]>>>[<<<+>>>-]<[->+<<[>>>-<<+<-]>[<+>-]>>[<->[-]]<[<<<+>>>-]<]>>[-]<<<<[>>+>+<<<-]>>[<<+>>-]>[[-]>>>>[-]<[>+<<<+>>-]<<[>>+<<-]>>>[<<<<+>>>>-]+>[<<<<<-<+>>>>>>-]<<<<<<[>>>>>>+<<<<<<-]>[>>>>-<<<<[-]]>>>>>>++++++<<<<<<+>>>>[<<<<[-]<+>>>>>-]<<<<<[>>>>>+<<<<<-]>[<<<[-]>[-]>>>>>>>>[<<<<<<<<+>+>>>>>>>-]<<<<<<<[>>>>>>>+<<<<<<<-]>[-]]>>>>>>[-]<<<<<<]<<<[>>+>+<<<-]>>[<<+>>-]>[[-]<<<[-]>[-]>>]<<]

Probieren Sie es online aus!

Krzysztof Szewczyk
quelle
Dies wäre kürzer, wenn Sie nur die Zeichen generieren 0-Fund dann den Druck fest codieren würden. Wie hast du es geschafft, es so lange zu machen?
Jo King
@ JoKing möglicherweise, aber ich wollte nur Spaß haben
Krzysztof Szewczyk
Ist dieser Kommentar nicht ein Eingeständnis, dass diese Antwort kein ernstzunehmender Anwärter auf die Gewinnkriterien der Herausforderung ist?
pppery
1

Python 2, 66 55 Bytes

Dies hätte wirklich der offensichtlichste Ansatz für mich sein sollen.

a='0123456789ABCDEF'
for x in a:
 for y in a:print x+y

Alt (66 Bytes) : Technisch gesehen verursacht dies einen Fehler danach FF, aber es erreicht 30.

n=1;a='0123456789ABCDEF'
while 1:print a[n/16]*(n>15)+a[n%16];n+=1

Ich nahm an, dass die Formatierung von Zeichenfolgen nicht zulässig war, da ich mir ziemlich sicher bin, dass die Basiskonvertierung durchgeführt werden würde. Wenn dies jedoch zulässig wäre, wären dies 29 Byte:

n=1
while 1:print"%x"%n;n+=1
Kade
quelle
1

Java, 104 Bytes

char t[]="0123456789abcdef".toCharArray(),i;void f(){for(;i<99;)System.out.println(""+t[i/16]+t[i++%16]);}

Wenn das i<99entfernt wird, erreicht es immer noch 30, stürzt aber schließlich ab. Ich bin mir nicht sicher, ob das akzeptabel ist.

Ypnypn
quelle
1

J, 47 Bytes

'0123456789abcdef'{~([:|:2 256$(]#i.),256$i.)16

druckt 00 bis ff

gar
quelle
1
Ein viel kürzerer Weg:>{;~'0123456789abcdef'
Lynn
Wow, das ist sehr gut! Aber warum hast du es nicht als Antwort gepostet, es sind nur 22 Bytes!
Gar
1

JavaScript 74 72 65 60

//for(i=0,a="0123456789ABCDEF";i++<49;)console.log(a[i>>4]+a[i%16])
for(i=0;i++<48;)console.log((i>>4)+"0123456789ABCDEF"[i%16])

Wolfshammer
quelle
1

Perl 6 , 34 Bytes

Das kürzeste, das ich finden kann, das keine Konvertierung verwendet, ist:

put [X~] (|(0..9),|('A'..'F'))xx 2 # 34 bytes

druckt 00... FFLeerzeichen in der Reihenfolge getrennt.
Wenn Sie mehr wollen, können Sie 2gegen eine größere Anzahl tauschen .
(Verwenden Sie keine Zahl größer als 4, da die Werte vor der Ausgabe miteinander verknüpft werden, sodass eine erhebliche Menge an RAM benötigt wird.)


Das kürzeste, das niemals aufhört, Hex-Werte zu schreiben

put [R~] (|(0..9),|('A'..'F'))[.polymod: 16 xx*]for 0..* # 56 bytes

Wenn printferlaubt wäre

printf "%X ",$_ for 0..* # 24 bytes

Wenn eine Basiskonvertierungsfunktion zulässig wäre

put .base(16)for 0..* # 21 bytes
Brad Gilbert b2gills
quelle
1

C ++ 14 - 135

#include<string>
#include<iostream>
void f(){std::string a="0123",b="0123456789ABCDEF";for(char c:a)for(char d:b)std::cout<<c<<d<<" ";}
Yytsi
quelle
Nein, es ist gut so wie es ist. Welchen Compiler verwenden Sie? Ich komme 'string' is not a member of 'std'mit meinem.
Dennis
@ Tennis Das ist ein guter Punkt. Ich vergesse immer, dass es erforderlich ist, einen String als eigenen einzuschließen. Fest.
Yytsi
1. Ich erhalte auch den gleichen Fehler cout. Ich denke du brauchst es iostreamauch. 2. Es druckt die Zahlen ohne Trennung. Die Herausforderung erfordert Leerzeichen, Tabulatoren oder Zeilenumbrüche. 3. Sie sollten die erforderliche Version von C ++ erwähnen.
Dennis
1

jq 1,5: 65 59 Zeichen

(56 Zeichen Code + 3 Zeichen Befehlszeilenoption.)

[range(10)]+"a b c d e f"/" "|{a:.[],b:.}|"\(.a)\(.b[])"

Probelauf:

bash-4.3$ jq -n -r '[range(10)]+"a b c d e f"/" "|{a:.[],b:.}|"\(.a)\(.b[])"' | head
00
01
02
03
04
05
06
07
08
09

Online-Test (Das -rWeiterleiten von URLs wird nicht unterstützt - überprüfen Sie die Rohausgabe selbst.)

jq 1,5: 56 Zeichen

(53 Zeichen Code + 3 Zeichen Befehlszeilenoption.)

[[range(10)]+"a b c d e f"/" "|"\(.[])\(.[])"]|sort[]

Dies erzeugt eine korrekte Ausgabe, ist jedoch nicht genau ein Zähler: Es werden die Werte nicht in der richtigen Reihenfolge generiert, sondern nur nachher sortiert.

Online-Test (Das -rWeiterleiten von URLs wird nicht unterstützt - überprüfen Sie die Rohausgabe selbst.)

Mann bei der Arbeit
quelle
Ihr Link für jq funktioniert nicht, und als ich ihn repariert habe, heißt es, dass es keine Indexdatei auf github gibt: P
Phase
Hoppla. Vielen Dank, dass Sie @Phase. Ich war zu sehr auf die Anzahl der Charaktere konzentriert.
Manatwork
1

Dyalog APL , 12 Bytes

       ∘.,⍨16↑⎕D,⎕A
 00  01  02  03  04  05  06  07  08  09  0A  0B  0C  0D  0E  0F 
 10  11  12  13  14  15  16  17  18  19  1A  1B  1C  1D  1E  1F 
 20  21  22  23  24  25  26  27  28  29  2A  2B  2C  2D  2E  2F 
 30  31  32  33  34  35  36  37  38  39  3A  3B  3C  3D  3E  3F 
 40  41  42  43  44  45  46  47  48  49  4A  4B  4C  4D  4E  4F 
 50  51  52  53  54  55  56  57  58  59  5A  5B  5C  5D  5E  5F 
 60  61  62  63  64  65  66  67  68  69  6A  6B  6C  6D  6E  6F 
 70  71  72  73  74  75  76  77  78  79  7A  7B  7C  7D  7E  7F 
 80  81  82  83  84  85  86  87  88  89  8A  8B  8C  8D  8E  8F 
 90  91  92  93  94  95  96  97  98  99  9A  9B  9C  9D  9E  9F 
 A0  A1  A2  A3  A4  A5  A6  A7  A8  A9  AA  AB  AC  AD  AE  AF 
 B0  B1  B2  B3  B4  B5  B6  B7  B8  B9  BA  BB  BC  BD  BE  BF 
 C0  C1  C2  C3  C4  C5  C6  C7  C8  C9  CA  CB  CC  CD  CE  CF 
 D0  D1  D2  D3  D4  D5  D6  D7  D8  D9  DA  DB  DC  DD  DE  DF 
 E0  E1  E2  E3  E4  E5  E6  E7  E8  E9  EA  EB  EC  ED  EE  EF 
 F0  F1  F2  F3  F4  F5  F6  F7  F8  F9  FA  FB  FC  FD  FE  FF 
Adam
quelle
Ausnahmsweise stimmt APL mit Pyth überein.
Adám
1

Malbolge , 900 Bytes

Verbessert werden ...

D'``@"\7}|X9E1gwuR21=p(:9%IZYEg}eA/ya>O_)([Zvotm3qponmfN+Lbg`ed]\"CB^W\Uy<;WVONSLp3ONMLEDhH*)?>b%A@?87[;:9876/S3,P0/.-&J$)"'~D|{"y?}|utyr8potmrqpi/mfN+Lbg`e^$bDZ_^]VzZSXQVUTSLp3ONMLEDhH*)EDCB;@?8\6|:32V6v.32+O)o'&J*)i'&%|Bcb~w|u;yxwvutVrkj0nmfN+iKg`_%cE[`Y}@V[ZYXWPtT6LKJImM/KJIBAe(D=<A:98\[;{32V6v.-,P0).',%I)"!E%|#"y?w_{ts9Zvutsrkpi/mfNjihg`e^$b[Z~X]\[ZYRv98TSLKoO10FKDh+GFE>CB;_?>=}|49870/.R2+*Non&%I#"!&%${A!~}_u;yxqpo5mrqpoh.lkdibgf_%]\[!_XW{[ZYXQPt7SRQPOHGkKJIHAF?cC<;@?8\6;492V6v.-,P*p.'K+$j"'~D|#"y~wv<]yxqvutsrk1onmfN+cba`&d]#DZ_^]VzTSXQVOs65QJINGkE-IBAe(D=<A:98\654981Uv.32+*)M-,%k#(!E}$#"!x>v{t:xwputm3kpoh.fN+Lbg`ed]\"!Y^]VzZYXQVOsS54JImMFKJIHAe?>C<`@?87[;{32V05.-2+O)o-,+$H('&}Cdzy~wv<]sxqvonm3k1oQmf,jihgfeG]#a`_X|V[TxXQPUTMLp3ONMLEDhH*)ED=a;@?>76;4X816/43,P*).',%I#i!&}|Bcb~w|u;yxwputm3qSong-kjihgfH%]\a`_XW{UTYXQuUTMRKPOHlFKDhBAe?>=B;_9>=6Z:981Uv.32+*)M-,%k#(!E%$#c!x>|u;yxZpo5srqSi/z

Probieren Sie es online aus!

Krzysztof Szewczyk
quelle
1

Zsh, 44 29 Bytes

-15 , über GammaFunction   online ausprobieren!

h=({0..9} {a..f});echo $^h$^h

Original (44 Bytes): g=0123456789abcdef;h=(${(s::)g});echo $^h$^h

Roblogik
quelle
1
Anstatt in ein Array zu konvertieren, können Sie dort beginnen : h=({0..9} {a..f}). 29 Bytes
GammaFunction
Vielen Dank! zsh ist sehr golffähig :)
roblogic
1

8088 Assembly, IBM PC DOS, 34 Byte

Bytes xxd:

00000000: 43e8 0900 e806 00b0 20cd 10eb f3b1 04d2  C....... .......
00000010: c38a c324 0f3c 0a7c 0204 0704 30b4 0ecd  ...$.<.|....0...
00000020: 10c3

Nicht zusammengebaut:

        BYTE_LOOP: 
43          INC  BX             ; increment counter  
E8 0009     CALL HB             ; display high byte 
E8 0006     CALL HB             ; display low byte 
B0 20       MOV  AL, ' '        ; display space delimiter
CD 10       INT  10H            ; call BIOS, write char to console 
EB F3       JMP  BYTE_LOOP      ; keep looping forever
        HB PROC 
B1 04       MOV  CL, 4          ; set up bitshift for 4 bits 
D2 C3       ROL  BL, CL         ; shift counter left 4 bits 
8A C3       MOV  AL, BL         ; put counter into AL 
24 0F       AND  AL, 0FH        ; isolate nibble 
3C 0A       CMP  AL, 0AH        ; is nibble A-F? 
7C 02       JL   NOT_ALPHA      ; if not, skip adjustment 
04 07       ADD  AL, 'A'-'9'-1  ; adjust ASCII value to A-F 
        NOT_ALPHA: 
04 30       ADD  AL, '0'        ; decimal to binary convert
B4 0E       MOV  AH, 0EH        ; BIOS tty function
CD 10       INT  10H            ; call BIOS, write char to console 
C3          RET                 ; return to program
        HB ENDP

Standalone PC DOS genau, die Ausgabe erfolgt über die Konsole und wird so lange angezeigt, bis das Programm gestoppt wird. Nur ein Scratch-ASCII-Manipulationsprogramm hier. In x86- oder DOS / BIOS-APIs gibt es einfach keine integrierten oder praktischen Methoden zum Konvertieren von Binärwerten in Zeichenfolgen für die Ausgabe.

Ausgabe:

Geben Sie hier die Bildbeschreibung ein

640 KB
quelle
1

MUMPS , 57 Bytes

f i=1:1:48 w $tr(i\16,0),$e("0123456789abcdef",i#16+1),!

Ausgabe

>d ^xmsdgolf
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
11
..
28
29
2a
2b
2c
2d
2e
2f
30

Erläuterung

f i=1:1:48                     ; loop from 1 to 48
w $tr(i\16,0)                  ; print i div 16, and ditch any zeros
$e("0123456789abcdef",i#16+1)  ; extract the nth character from the string, where n is i mod 16 + 1
!                              ; crlf
Michael Donnelly
quelle
0

Haskell, 52 Bytes

a="0123456789abcdef";main=mapM putStrLn$mapM id[a,a]
Lynn
quelle
0

Python 2 - 57 Bytes

h='0123456789ABCDEF'
' '.join([i+j for i in h for j in h])

Dies gibt 00 bis FF mit Leerzeichen dazwischen aus.

Brian
quelle