Hexadecimal es un sistema de conteo de base 16 que va de 0a f. Su trabajo es hacer un contador que muestre estos números.

Ejemplo:

$ 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

Reglas:

• Los números pueden estar separados por espacios, tabulaciones o nuevas líneas.
• El número mínimo al que debe ir es 30(48 en decimal).
  • También puede hacer que el programa imprima números para siempre hasta que se detenga.
• Las letras pueden estar en mayúsculas o minúsculas ( Ao a).
• No se permiten funciones integradas (que afectan directamente las conversiones / conteos hexadecimales).
• Se permiten ceros a la izquierda
• Puede comenzar desde 1o0
• ¡El código más corto gana!

Pyth - 12 bytes

Utiliza productos cartesianos, y los ordena al final para obtener el orden correcto, luego se une por espacios. Impresiones 00-ffinclusivas.

jdS^s+<G6UT2

Pruébelo en línea aquí .

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

Cuenta de 0x0 a 0x3F:

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

Pruébalo en línea!

CJam, 21 14 bytes

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

Imprime los números del 00 al 9F.

Pruébelo en línea en el intérprete de CJam .

Cómo funciona

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.

Pitón 2, 52

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

Imprime 00a 3F. Aprovecha el hecho de que el primer dígito asiempre es un número en este rango. Recorre cuatro ciclos del segundo dígito b, incrementándose asiempre que sea el segundo dígito F.

Este es un char más corto que el más directo

for a in'0123':
 for b in'0123456789ABCDEF':print a+b

JavaScript (ES6), 57 bytes

El mismo enfoque que los de Python, supongo.

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

Esto es 63 bytes, según la pantalla de administración de memoria en mi calculadora, una TI-84 +. ¡Asegúrese de iniciar el programa con una pantalla de inicio parcialmente llena!

Befunge-93, 57 bytes

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

Imprime números del 00al 8F. Si prefiere que sus programas se ejecuten para siempre, la siguiente versión no finaliza y generará continuamente todos los números de 00a 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++)););}

Definimos una función f()que se llamará sin argumentos para imprimir, y una función auxiliar x(int). Esto se rompe a las FF.

Sorprendentemente, este es un byte más corto que el más obvio:

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

Advertencia: no se recomienda ejecutar este código fuera de un entorno de depuración ...

Pruebas:

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

Salida:

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

Por supuesto, el enfoque más robusto (y engañoso) es esta función de 34 bytes:

g(i){for(i=0;printf("%x ",i++););}

Pyth, 17 bytes

VJs++kUT<G6FYJ+NY

Pruébalo aquí

Cómo funciona:

         <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'

Cuenta para ff. Imprime una nueva línea adicional entre cada bloque de 0x10números, así:

...
0d
0e
0f

10
11
...

Paperas - 65 bytes

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

No ... ¡Las paperas aún no están muertas! :-)

CJam, 22 bytes

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

Esto funciona para siempre y, por lo tanto, es probablemente uno de los raros momentos en que es una buena idea no incluir un enlace permanente.

TheC64Mini y Commodore BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 bytes BASIC y Tokenizados utilizados

 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

Imprime un doble espacio después del número hexadecimal para alinear bien la impresión en 40/80 columnas, así como las 22 columnas en el VIC-20.

brainfuck , 2902 bytes

Fácil de superar, pero vale la pena intentarlo.

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

Pruébalo en línea!

Python 2, 66 55 bytes

Esto realmente debería haber sido el enfoque más obvio para mí ...

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

Antiguo (66 Bytes) : técnicamente esto causa un error después FF, pero alcanza 30.

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

Supuse que el formato de cadena no estaba permitido, ya que estoy bastante seguro de que pasaría por la conversión base, pero si se permitiera, sería de 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]);}

Si i<99se elimina, aún alcanza 30, pero finalmente se bloquea. No estoy seguro si eso es aceptable.

J, 47 bytes

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

imprime 00 a ff

JavaScript 74 72 sesenta y cinco 60 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

Lo más corto que se me ocurre que no utiliza ningún tipo de conversión es:

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

imprime 00... FFespacio separado en orden.
Si desea más, puede cambiar 2por un número mayor.
(no use un número mayor que 4, ya que concatena los valores juntos antes de generar cualquier cosa, por lo que usaría una cantidad significativa de RAM)

El más corto que nunca dejará de escribir valores hexadecimales

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

Si se printfles permitiera

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

Si se permitiera una función de conversión de base

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 caracteres

(Código de 56 caracteres + opción de línea de comando de 3 caracteres).

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

Ejecución de muestra:

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

Prueba en línea (aprobación-rno se admite el por la URL; compruebe usted mismo la salida sin formato).

jq 1.5: 56 caracteres

(Código de 53 caracteres + opción de línea de comando de 3 caracteres).

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

Esto produce una salida correcta, sin embargo, no es exactamente un contador: no genera los valores en orden, solo los ordena después.

Prueba en línea ( -rno se admite el paso por la URL; compruebe usted mismo la salida sin formato).

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

Ser mejorado...

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

Pruébalo en línea!

Zsh, 44 29 bytes

-15 , a través de GammaFunction ¡   pruébelo en línea!

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

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

PowerShell 6, 40 bytes

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

Pruébalo en línea!

Comienza en 00y cuenta hasta FF.

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

Desmontado:

        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

PC independiente independiente de DOS, la salida es a la consola y se seguirá mostrando hasta que se detenga el programa. Solo un programa de manipulación de scratch ASCII aquí. Simplemente no hay métodos integrados o convenientes en las API x86 o DOS / BIOS para convertir los valores binarios en cadenas para la salida.

Salida:

MUMPS , 57 bytes

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

Salida

>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

Explicación

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

Esto genera 00 a FF, con espacios entre ellos.