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!

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

Pure Bash , 26

Zählt von 0x0 bis 0x3F:

echo {0..3}{{0..9},{A..F}}

Probieren Sie es online aus!

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.

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

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)

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!

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

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

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

Javascript ES6, 67 62 Bytes

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

J, 22 Bytes

>{;~'0123456789abcdef'

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

...
0d
0e
0f

10
11
...

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! :-)

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.

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.

Brainfuck , 2902 Bytes

Leicht zu outgolf, aber einen Versuch wert

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

Probieren Sie es online aus!

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

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.

J, 47 Bytes

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

druckt 00 bis ff

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])

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

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

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

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 

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!

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

PowerShell 6, 40 Byte

($l=0..9+'A'..'F')|%{$1=$_;$l|%{"$1$_"}}

Probieren Sie es online aus!

Beginnt bei 00und zählt bis FF.

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:

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

Haskell, 52 Bytes

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

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.