Hexadecimal is a base 16 counting system that goes from 0 to f. Your job is to make a counter that will display these numbers.

Example:

$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  Rules: • The numbers may be separated by spaces, tabs, or new lines. • The minimum number you must go to is 30 (48 in decimal). • You may also make the program print numbers forever until it is stopped. • Letters may be in uppercase or lowercase (A or a). • No built in functions allowed (that directly affect hexadecimal conversions/counting). • Leading zeros are allowed • It may start from 1 or 0 • Shortest code wins! • @Sp3000 How built in are they? Converting decimal to hex? – jado Jul 12, 2015 at 16:05 • How about general base conversion functions then? Jul 12, 2015 at 16:11 • @Sp3000 Sure (ignore this, 15 character limit) – jado Jul 12, 2015 at 16:13 • @Mauris Yes! That sure is going to be interesting... – jado Jul 13, 2015 at 17:29 • I was looking at the previous comments and it looked like you agreed to general base conversion functions when Sp3000 asked. Also does that include printf type functions? Jan 17, 2016 at 14:55 ## 39 Answers # Pure Bash, 26 Counts from 0x0 to 0x3F: echo {0..3}{{0..9},{A..F}}  Try it online! # CJam, 21 14 bytes A,_6,'Af++m*S*  Prints the numbers 00 to 9F. Try it online in the CJam interpreter. ### How it works 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.  # Pyth - 12 bytes Uses cartesian product, and sorts at the end to get in correct order, then joins by spaces. Prints 00-ff inclusive. jdS^s+<G6UT2  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  # Python 2, 52 a=0 for b in'0123456789ABCDEF'*4:printa+b;a+=b>'E'  Prints 00 to 3F. Takes advantage of the fact that the first digit a is always a number in this range. Loops through four cycles of the second digit b, incrementing a whenever the second digit is F. This is one char shorter than the more direct for a in'0123': for b in'0123456789ABCDEF':print a+b  • n ='0123' should save some chars Jul 13, 2015 at 13:45 • @Caridorc How exactly? – xnor Jul 13, 2015 at 20:10 • by writing thing in n + restofstring Jul 13, 2015 at 20:11 • @Caricord Not sure what you mean, it's longer to do n='0123' for a in n: for b in n+'456789ABCDEF':print a+b – xnor Jul 13, 2015 at 20:12 • @Caridorc A metal shortcut I use is that saving to a variable costs 4 chars, so it needs >4 chars of saving to compensate, so saving 4 chars for 0123 for something else isn't enough. – xnor Jul 13, 2015 at 20:15 ## JavaScript (ES6), 57 bytes Same approach as the Python ones I suppose. 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  This is 63 bytes, according to the memory management screen on my calculator, a TI-84+. Make sure to start the program with a partially filled home screen! • Did you remember to subtract the length of the 9-byte header and the program name from the code length? Jul 13, 2015 at 2:58 ## Befunge-93, 57 bytes <_v#-*44:+1,*84,g2:\,g2:\ ^ >$1+:9-!#@_0
0123456789ABCDEF


Prints numbers from 00to 8F. If you prefer your programs to run forever, the version below is non-terminating and will continually output all numbers from 00 to FF.

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:35*!*0 0123456789ABCDEF  • You can save a couple bytes in -98 with <_v#-f:+1, ',g2:\,g2:\. Can't see many improvements beyond that. Jul 13, 2015 at 17:05 • 0123456789ABCDEF01g::88+/2-0g,88+%0g,9,1+01p – Lynn Jul 13, 2015 at 17:29 • That's 44 bytes. It loops forever, like your second solution, and prints wrong results past the second 1F. It requires an implementation (such as the reference implementation bef.c) that silently ignores unknown commands (ABCDEF). – Lynn Jul 13, 2015 at 17:31 • (The OP mentions it's okay for a solution to "break" somewhere past hitting 30 -- this one will slowly overflow the stack, so I suppose there's some point of termination. Also, output is tab-separated; the OP said this was fine.) Oh, the Befunge implementation you use should also initialize the whole 80x25 torus with spaces (ASCII 0x20). – Lynn Jul 13, 2015 at 17:37 • @Mauris Regarding your comment about the implementation needing to instantiate the entire torus with spaces, would this affect the byte count for my code presented? I only counted the necessary characters rather than filling in the corners with spaces. – Sok Jul 14, 2015 at 8:16 # 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++)););}  We define a function f() to be called with no arguments for printing, and a helper function x(int). This breaks at FF. Amazingly, this is one byte shorter than the more obvious: char*s="0123456789ABCDEF";h(j){for(j=0;printf("%c%c ",s[j/16],s[15&j++]););}  Warning: it is not recommended to run this code outside of a debug environment... Testing: int main(int argc, char** argv) { f(); return 0; }  Output: 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 (...)  Of course, the more robust (and cheat-y) approach is this 34-byte function: g(i){for(i=0;printf("%x ",i++););}  • Started trying this but my answer was too similar. You can save several bytes by making the first %c into %d and omitting the function. It's only valid up to 9F then though. Jul 14, 2015 at 15:25 • return y+ could possibly be y+=. Aug 19, 2018 at 4:25 # Pyth, 17 bytes VJs++kUT<G6FYJ+NY  Try it here ## How it works:  <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  • jb^+jkUT<G6 2 uses the cartesian product to do the same thing, still seems golfable... Jul 12, 2015 at 19:42 # Javascript ES6, 67 62 bytes (x=''.replace.bind('0123456789ABCDEF',/./g))(n=>x(o=>' '+n+o))  # J, 22 bytes >{;~'0123456789abcdef'  Counts to ff. Prints an extra newline between each block of 0x10 numbers, like so: ... 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),!  Nope... Mumps ain't dead yet! :-) # CJam, 22 bytes 1{_GbA,6,'af++f=oNo)}h  This runs forever, and thus is probably one of the rare times where it's a good idea not to include a permalink. • oNo is the same as n in TIO. Apr 27, 2017 at 19:01 # TheC64Mini and Commodore BASIC (C64/128, PET, VIC-20, C16/+4) - 164 BASIC and Tokenized bytes used  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))
$e("0123456789abcdef",i#16+1) ; extract the nth character from the string, where n is i mod 16 + 1 ! ; crlf  # Python 2, 66 55 Bytes This should really have been the most obvious approach to me.. a='0123456789ABCDEF' for x in a: for y in a:print x+y  Old (66 Bytes): Technically this causes an error after FF, but it does reach 30. n=1;a='0123456789ABCDEF' while 1:print a[n/16]*(n>15)+a[n%16];n+=1  I assumed string formatting wasn't allowed since I'm pretty sure it would go through base conversion, but if it was allowed, this would be 29 bytes: 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]);}  If the i<99 is removed, it still reaches 30, but eventually crashes. I'm not sure if that's acceptable. ## J, 47 bytes '0123456789abcdef'{~([:|:2 256$(]#i.),256$i.)16  prints 00 to ff • A much shorter way: >{;~'0123456789abcdef' – Lynn Jul 13, 2015 at 16:43 • Wow, that's very good! But why didn't you post it as an answer, it's only 22 bytes! – gar Jul 14, 2015 at 14:17 # JavaScript 747265 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 The shortest that I can come up with that doesn't use any sort of conversion is: put [X~] (|(0..9),|('A'..'F'))xx 2 # 34 bytes  prints 00 ... FF space separated in order. If you want more you can swap 2 for a larger number. (don't use a number bigger than 4 as it concatenates the values together before outputting anything, so it would use a significant amount of RAM ) Shortest that will never stop writing hex values put [R~] (|(0..9),|('A'..'F'))[.polymod: 16 xx*]for 0..* # 56 bytes  If printf were allowed printf "%X ",$_ for 0..* # 24 bytes


If a base conversion function were allowed

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

• No, it's fine like it is. What compiler are you using? I get 'string' is not a member of 'std' with mine. Jan 17, 2016 at 19:11
• @Dennis That's a good point. I always forget that it requires including string as it's own. Fixed. Jan 17, 2016 at 19:28
• 1. I'm getting the same error for cout as well. I guess you need iostream too. 2. It prints the numbers without separation. The challenge requires spaces, tabs or newlines. 3. You should mention the required version of C++. Jan 17, 2016 at 22:11

# jq 1.5: 65 59 characters

(56 characters code + 3 characters command line option.)

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


Sample run:

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  On-line test (Passing -r through URL is not supported – check Raw Output yourself.) # jq 1.5: 56 characters (53 characters code + 3 characters command line option.) [[range(10)]+"a b c d e f"/" "|"\(.[])\(.[])"]|sort[]  This produces correct output, however is not exactly a counter: it not generates the values in order, just sorts them after. On-line test (Passing -r through URL is not supported – check Raw Output yourself.) • your link for jq doesn't work, and when I fixed it it says there isn't an index file on github :P – jado Jul 13, 2015 at 17:24 • Oops. Thank you @Phase. I was too concentrated on the character count. Jul 13, 2015 at 17:29 # 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  • For once, APL matches Pyth. – Adám Sep 3, 2015 at 13:34 # Zsh, 44 29 bytes -15, via GammaFunction try it online! h=({0..9} {a..f});echo$^h$^h  Original (44 bytes): g=0123456789abcdef;h=(${(s::)g});echo $^h$^h

• Instead of converting to array, you can start there: h=({0..9} {a..f}). 29 bytes Aug 13, 2019 at 3:21
• Thanks! zsh is very golfable :) Aug 13, 2019 at 3:53

# 8088 Assembly, IBM PC DOS, 34 bytes

Bytes xxd:

00000000: 43e8 0900 e806 00b0 20cd 10eb f3b1 04d2  C....... .......
00000010: c38a c324 0f3c 0a7c 0204 0704 30b4 0ecd  ...$.<.|....0... 00000020: 10c3  Unassembled:  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 exactable, output is to console and will keep displaying until program is stopped. Just a scratch ASCII manipulating program here. There are just no built-ins or convenience methods in x86 or DOS/BIOS APIs to convert binary values to strings for output. Output: # Pip -s, 8 bytes _TB16M,h  Try it online! ## Explanation _TB16M,h ,h range 0...99 M map using lambda: _TB16 convert to hexadecimal join with spaces(-s flag)  # Perl 5, 35 bytes //,map{say$',\$_}@,for@,=(0..9,a..f)
`

Try it online!