Image of Hex Conversion Table w/ counter

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!

phase

Posted 2015-07-12T16:02:31.040

Reputation: 2 540

@Sp3000 How built in are they? Converting decimal to hex? – phase – 2015-07-12T16:05:54.753

@Sp3000 No built in functions allowed! – phase – 2015-07-12T16:09:57.533

@manatwork uppercase is fine – phase – 2015-07-12T16:10:20.387

4How about general base conversion functions then? – Sp3000 – 2015-07-12T16:11:06.153

1@Sp3000 Sure (ignore this, 15 character limit) – phase – 2015-07-12T16:13:28.400

If the program prints things repeatedly, but breaks at some point beyond 30, (say, at FF) is that okay? – BrainSteel – 2015-07-12T16:16:13.897

@BrainSteel Yes, as long as it gets to 30 – phase – 2015-07-12T16:16:51.480

A couple of questions I'd rather have answered now than later: 1. Can the count start from zero? 2. Are leading zeroes allowed? – Dennis – 2015-07-12T16:46:40.857

@Dennis Yes and yes! – phase – 2015-07-12T16:50:48.843

Is it OK if my solution prints an exta newline between 0F and 10, and 1F and 20, ...? – Lynn – 2015-07-13T16:38:32.697

@Mauris yes . . . – phase – 2015-07-13T17:26:34.217

Cool! What about tab-separated output? – Lynn – 2015-07-13T17:28:34.380

1@Mauris Yes! That sure is going to be interesting... – phase – 2015-07-13T17:29:09.903

Can I use a format string that converts parameters to hex inside a string? It's not a function. – mbomb007 – 2015-07-24T17:02:06.903

@mbomb007 Do you mean Regex? There's Retina for that. – phase – 2015-07-24T22:43:15.520

No, a Python format string containing %x. – mbomb007 – 2015-07-25T02:30:51.677

So if a language has a built-in that only converts to hex it isn't allowed, but a general one such as 5.base(16) is allowed? – Brad Gilbert b2gills – 2016-01-15T19:08:21.280

@BradGilbertb2gills That isn't allowed either. – phase – 2016-01-17T05:21:21.353

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? – Brad Gilbert b2gills – 2016-01-17T14:55:36.600

Answers

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

Try it online here.

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

Posted 2015-07-12T16:02:31.040

Reputation: 25 023

Pure Bash, 26

Counts from 0x0 to 0x3F:

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

Try it online!

Digital Trauma

Posted 2015-07-12T16:02:31.040

Reputation: 64 644

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.

Dennis

Posted 2015-07-12T16:02:31.040

Reputation: 196 637

Python 2, 52

a=0
for b in'0123456789ABCDEF'*4:print`a`+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

xnor

Posted 2015-07-12T16:02:31.040

Reputation: 115 687

n ='0123' should save some chars – Caridorc – 2015-07-13T13:45:08.687

@Caridorc How exactly? – xnor – 2015-07-13T20:10:15.907

by writing thing in n + restofstring – Caridorc – 2015-07-13T20:11:26.167

@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 – 2015-07-13T20:12:40.140

sorry I had to do some more precise counting :) – Caridorc – 2015-07-13T20:13:21.467

2@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 – 2015-07-13T20:15:47.300

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)

rink.attendant.6

Posted 2015-07-12T16:02:31.040

Reputation: 2 776

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!

gengkev

Posted 2015-07-12T16:02:31.040

Reputation: 141

Did you remember to subtract the length of the 9-byte header and the program name from the code length? – lirtosiast – 2015-07-13T02:58:17.423

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

Sok

Posted 2015-07-12T16:02:31.040

Reputation: 5 592

You can save a couple bytes in -98 with <_v#-f:+1, ',g2:,g2:. Can't see many improvements beyond that. – Jacob – 2015-07-13T17:05:18.023

0123456789ABCDEF01g::88+/2-0g,88+%0g,9,1+01p – Lynn – 2015-07-13T17:29:06.590

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 – 2015-07-13T17:31:00.550

(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 – 2015-07-13T17:37:08.583

@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 – 2015-07-14T08:16:34.947

@Jacob In -98 doesn't the f command push 15? If so, the loop would break on 14, i.e. once it has printed E, though I suppose that could be fixed by changing the minus for a backtick... – Sok – 2015-07-14T08:18:24.813

@Sok Well, I was talking about my solution; I don't know if yours relies on that. The reference implementation does this, so it should be pretty standard behavior. I don't think you should count the corners you didn't fill in!

– Lynn – 2015-07-14T08:28:50.447

@Sok you're right. I was thinking it pushed 16 for some reason... – Jacob – 2015-07-14T16:26:11.133

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))
 3 nEi:?h$"  ";:nEd

Prints a double-space after the hex number to nicely align the printing at 40/80 columns as well as the 22 columns on the VIC-20.

Shaun Bebbers

Posted 2015-07-12T16:02:31.040

Reputation: 1 814

brainfuck, 2902 bytes

Easy to outgolf, but worth giving a shot

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

Try it online!

Krzysztof Szewczyk

Posted 2015-07-12T16:02:31.040

Reputation: 3 819

This would be shorter if you just generated the characters 0-F and then hardcoded the printing. How did you manage to make it so long? – Jo King – 2019-08-13T03:40:20.827

@JoKing possibly, but I just wanted to have fun – Krzysztof Szewczyk – 2019-08-13T09:47:53.273

Is that comment not an admission that this answer is not a serious contender for the winning criteria of the challenge? – pppery – 2019-09-09T19:36:21.203

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.

Sp3000

Posted 2015-07-12T16:02:31.040

Reputation: 58 729

oNo is the same as n in TIO. – Esolanging Fruit – 2017-04-27T19:01:53.490

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

BrainSteel

Posted 2015-07-12T16:02:31.040

Reputation: 5 132

1Started 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. – Alchymist – 2015-07-14T15:25:02.140

return y+ could possibly be y+=. – Jonathan Frech – 2018-08-19T04:25:10.133

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

Ypnypn

Posted 2015-07-12T16:02:31.040

Reputation: 10 485

jb^+jkUT<G6 2 uses the cartesian product to do the same thing, still seems golfable... – FryAmTheEggman – 2015-07-12T19:42:55.920

Javascript ES6, 67 62 bytes

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

George Reith

Posted 2015-07-12T16:02:31.040

Reputation: 2 424

J, 22 bytes

>{;~'0123456789abcdef'

Counts to ff. Prints an extra newline between each block of 0x10 numbers, like so:

...
0d
0e
0f

10
11
...

Lynn

Posted 2015-07-12T16:02:31.040

Reputation: 55 648

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

zmerch

Posted 2015-07-12T16:02:31.040

Reputation: 541

Malbolge, 900 bytes

To be improved...

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

Try it online!

Krzysztof Szewczyk

Posted 2015-07-12T16:02:31.040

Reputation: 3 819

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

roblogic

Posted 2015-07-12T16:02:31.040

Reputation: 554

Instead of converting to array, you can start there: h=({0..9} {a..f}). 29 bytes

– GammaFunction – 2019-08-13T03:21:28.653

Thanks! zsh is very golfable :) – roblogic – 2019-08-13T03:53:16.363

PowerShell 6, 40 bytes

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

Try it online!

Starts at 00 and counts up to FF.

mazzy

Posted 2015-07-12T16:02:31.040

Reputation: 4 832

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:

640KB

Posted 2015-07-12T16:02:31.040

Reputation: 7 149

MUMPS, 57 bytes

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

Output

>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

Explanation

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

Posted 2015-07-12T16:02:31.040

Reputation: 11

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

Kade

Posted 2015-07-12T16:02:31.040

Reputation: 7 463

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.

Ypnypn

Posted 2015-07-12T16:02:31.040

Reputation: 10 485

J, 47 bytes

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

prints 00 to ff

gar

Posted 2015-07-12T16:02:31.040

Reputation: 161

1A much shorter way: >{;~'0123456789abcdef' – Lynn – 2015-07-13T16:43:06.593

Wow, that's very good! But why didn't you post it as an answer, it's only 22 bytes! – gar – 2015-07-14T14:17:13.493

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

wolfhammer

Posted 2015-07-12T16:02:31.040

Reputation: 1 219

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

manatwork

Posted 2015-07-12T16:02:31.040

Reputation: 17 865

your link for jq doesn't work, and when I fixed it it says there isn't an index file on github :P – phase – 2015-07-13T17:24:33.620

Oops. Thank you @Phase. I was too concentrated on the character count. – manatwork – 2015-07-13T17:29:33.003

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

Adám

Posted 2015-07-12T16:02:31.040

Reputation: 37 779

For once, APL matches Pyth. – Adám – 2015-09-03T13:34:17.507

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

Brad Gilbert b2gills

Posted 2015-07-12T16:02:31.040

Reputation: 12 713

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

Posted 2015-07-12T16:02:31.040

Reputation: 3 582

No, it's fine like it is. What compiler are you using? I get 'string' is not a member of 'std' with mine. – Dennis – 2016-01-17T19:11:32.243

@Dennis That's a good point. I always forget that it requires including string as it's own. Fixed. – Yytsi – 2016-01-17T19:28:42.363

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

< – Dennis – 2016-01-17T22:11:01.653

GFortran, 93 bytes

Prints 00 through ff

character(16)H;H='0123456789abcdef'
do i=1,16;do j=1,16;print*,H(i:i)//H(j:j)
enddo;enddo;end

Try it online!

roblogic

Posted 2015-07-12T16:02:31.040

Reputation: 554

Ahead, 42 bytes

Prints hex numbers starting at 0 forever. Will eventually overflow, though.

>t>:16;r
Cvn:/61\<
 >$>:10/7*v
^oNndo++0'<

Try it online!

snail_

Posted 2015-07-12T16:02:31.040

Reputation: 1 982

Scala, 84 bytes

val l=(0 to 9)++"A,B,C,D,E,F".split(",")
l.foreach(x=>l.foreach(y=>println(x+""+y)))

Slightly better built version, using what you could call a cartesian product. Try it online! Output goes with leading 0s and a trailing newline. Starts at 00 and counts up to FF (255 in base 10).

Scala, 89 bytes

for(x<-1 to 48)println(if(x%16>9)x/16+"a,b,c,d,e,f".split(",")(x%16-10)else x/16+""+x%16)

First answer, because why not, I like its hacks. Try it online! Output goes with leading 0s and a trailing newline. Starts at 01 and counts up to 30 (48 in base 10).

V. Courtois

Posted 2015-07-12T16:02:31.040

Reputation: 868

Haskell, 52 bytes

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

Lynn

Posted 2015-07-12T16:02:31.040

Reputation: 55 648

Python 2 - 57 bytes

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

This outputs 00 to FF, with spaces between.

Brian

Posted 2015-07-12T16:02:31.040

Reputation: 1 209

Ruby, 64 bytes

h='0123456789abcdef'.split //;h.each{|i|h.each{|j|print i,j,?\s}}

Explanation:

h = '0123456789abcdef'.split // # Split string of hex chars at
                                # matches of //, returns array
                                # splits array by characters 
h.each { |i|                    # loop 1
  h.each { |j|                  # loop 2
    print i,j,?\s               # print() can take multiple params,
                                # and it is the same as printing
                                # each one using a separate print().
                                # ?x is the same as 'x', so ?\s is
                                # the same as "\s", which is " ".
  }
}

clap

Posted 2015-07-12T16:02:31.040

Reputation: 834

Python 3, 157 bytes

As far as I can tell, this is the only submission so far that can keep counting upwards forever. (Of course, I can't read Haskell or Mumps, but they all seem to be doing a two-character loop...) EDIT: Okay, not the only one, but perhaps the only one in a non-golfy language?

n=bytearray(b'0')
while 1:
 print(repr(n)[12:-2]);p,o=len(n),1
 while o:
  p-=1;m=n[p];n[p]={57:65,70:48}.get(m,m+1);o=m==70
  if o and p==0:p=1;n[:0]+=b'0'

Proof of correctness (wraps the above in a function, changing only print to yield, and then loops as high as you like):

def golfed_code():
 n=bytearray(b'0')
 while 1:
  yield(repr(n)[12:-2]);p,o=len(n),1
  while o:
   p-=1;m=n[p];n[p]={57:65,70:48}.get(m,m+1);o=m==70
   if o and p==0:p=1;n[:0]+=b'0'

TEST_LIMIT = 100000

for n, h in enumerate(golfed_code()):
 assert hex(n).upper()=='0X'+h,'{} != {}'.format(hex(n).upper(),'0X'+h)
 if n == TEST_LIMIT:
  break

(Thanks to Sp3000 for saving me 3 bytes.)

Tim Pederick

Posted 2015-07-12T16:02:31.040

Reputation: 1 411

@Sp3000: Not that I could find (though that doesn't mean one doesn't exist). Everything I tried took more characters, usually because I was constructing a new bytearray (and that's a big word). Also: fine, it's the only endless counter in a non-golfy language. ;-) – Tim Pederick – 2015-07-16T09:55:27.290

@Sp3000: I missed that first one (everything else I tried with b'' literals left me with a bytes, not a bytearray). But the second one means a is modified right along with n. – Tim Pederick – 2015-07-16T10:10:48.803

Right, thought they were immutable for some reason. I'm not sure why you're using bytearrays though, surely division/modulo + string building is shorter? – Sp3000 – 2015-07-16T10:15:08.180

@Sp3000: Because their string representation automatically ASCIIfies them. I think if I found an approach other than bytearray, I'd make it a new answer anyway; it'd be too much like "chuck it out and start over" to edit into this one. – Tim Pederick – 2015-07-16T10:18:03.943

It's now not the only example of an endless counter from a non-golf language put [R~] (|(0..9),|('A'..'F'))[.polymod: 16 xx*]for 0..* in Perl 6 – Brad Gilbert b2gills – 2016-01-17T15:57:24.280

Matlab: 47 bytes

q=[48:57,97:102,''];fliplr(char(combvec(q,q)'))

I don't know if it would be considered as counter. The code generates vector of hex numbers from 00 to ff. q is a string '0123456789abcdef' in double format. Combvec generates all possible pairs between q and q. Char converts it to string format and fliplr flips the columns to get:

00
01
...
08
09
0a
0b
0c
0d
0e
0f
10
11
...
fd
fe
ff

brainkz

Posted 2015-07-12T16:02:31.040

Reputation: 349

Hexadecimal Counter

Answers

Pyth - 12 bytes

Pure Bash, 26

CJam, 21 14 bytes

How it works

Python 2, 52

JavaScript (ES6), 57 bytes

TI-Basic, 63 bytes

Befunge-93, 57 bytes

TheC64Mini and Commodore BASIC (C64/128, PET, VIC-20, C16/+4) - 164 BASIC and Tokenized bytes used

brainfuck, 2902 bytes

CJam, 22 bytes

C, 78 75 bytes

Pyth, 17 bytes

How it works:

Javascript ES6, 67 62 bytes

J, 22 bytes

Mumps - 65 bytes

Malbolge, 900 bytes

Zsh, 44 29 bytes

PowerShell 6, 40 bytes

8088 Assembly, IBM PC DOS, 34 bytes

MUMPS, 57 bytes

Python 2, 66 55 Bytes

Java, 104 bytes

J, 47 bytes

JavaScript 74 72 65 60

jq 1.5: 65 59 characters

jq 1.5: 56 characters

Dyalog APL, 12 bytes

Perl 6, 34 bytes

C++14 - 135

GFortran, 93 bytes

Ahead, 42 bytes

Scala, 84 bytes

Scala, 89 bytes

Haskell, 52 bytes

Python 2 - 57 bytes

Ruby, 64 bytes

Python 3, 157 bytes

Matlab: 47 bytes