Hệ thập lục phân là một hệ thống đếm 16 cơ sở đi từ 0đến f. Công việc của bạn là tạo ra một bộ đếm sẽ hiển thị những con số này.

Thí dụ:

$ 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

Quy tắc:

• Các số có thể được phân tách bằng dấu cách, tab hoặc dòng mới.
• Số lượng tối thiểu bạn phải đến là 30(48 trong số thập phân).
  • Bạn cũng có thể làm cho số chương trình in mãi mãi cho đến khi nó dừng lại.
• Chữ cái có thể viết hoa hoặc viết thường ( Ahoặc a).
• Không có chức năng tích hợp nào được phép (ảnh hưởng trực tiếp đến chuyển đổi / đếm thập lục phân).
• Số không hàng đầu được phép
• Nó có thể bắt đầu từ 1hoặc0
• Mã ngắn nhất sẽ thắng!

Pyth - 12 byte

Sử dụng sản phẩm cartesian và sắp xếp ở cuối để có thứ tự chính xác, sau đó tham gia theo khoảng trắng. Bao 00-ffgồm in .

jdS^s+<G6UT2

Hãy thử trực tuyến tại đây .

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

Bash thuần khiết , 26

Đếm từ 0x0 đến 0x3F:

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

Hãy thử trực tuyến!

CJam, 21 14 byte

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

In các số từ 00 đến 9F.

Hãy thử trực tuyến trong trình thông dịch CJam .

Làm thế nào nó hoạt động

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.

Con trăn 2, 52

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

In 00tới 3F. Lợi dụng thực tế là chữ số đầu tiên aluôn là một số trong phạm vi này. Vòng lặp qua bốn chu kỳ của chữ số thứ hai b, tăng abất cứ khi nào chữ số thứ hai là F.

Đây là một char ngắn hơn so với trực tiếp hơn

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

JavaScript (ES6), 57 byte

Cách tiếp cận tương tự như những người Python tôi cho là.

for(i of c='0123456789ABCDEF')for(j of c)console.log(i+j)

TI-Basic, 63 byte

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

Đây là 63 byte, theo màn hình quản lý bộ nhớ trên máy tính của tôi, TI-84 +. Hãy chắc chắn để bắt đầu chương trình với một màn hình chính được lấp đầy một phần!

Befunge-93, 57 byte

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

In số từ 00đến 8F. Nếu bạn thích các chương trình của mình chạy mãi mãi, phiên bản bên dưới sẽ không kết thúc và sẽ liên tục xuất tất cả các số từ 00sang FF.

<_v#-*44:+1,*84,g2:\,g2:\
^ >$1+:35*`!*0
0123456789ABCDEF

C, 78 75 byte

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

Chúng tôi xác định một hàm f()được gọi mà không có đối số để in và hàm trợ giúp x(int). Điều này phá vỡ tại FF.

Thật đáng ngạc nhiên, đây là một byte ngắn hơn rõ ràng hơn:

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

Cảnh báo: không nên chạy mã này ngoài môi trường gỡ lỗi ...

Kiểm tra:

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

Đầu ra:

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

Tất nhiên, cách tiếp cận mạnh mẽ hơn (và cheat-y) là hàm 34 byte này:

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

Bình thường, 17 byte

VJs++kUT<G6FYJ+NY

Hãy thử nó ở đây

Làm thế nào nó hoạt động:

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

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

J, 22 byte

>{;~'0123456789abcdef'

Đếm đến ff. In một dòng mới bổ sung giữa mỗi khối 0x10số, như vậy:

...
0d
0e
0f

10
11
...

Quai bị - 65 byte

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

Không ... Quai bị chưa chết! :-)

CJam, 22 byte

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

Điều này diễn ra mãi mãi, và do đó có lẽ là một trong những lần hiếm hoi mà không nên bao gồm một permalink.

The C64Mini và Commodore BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 byte BASIC và Tokenized được sử dụng

 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

In một không gian kép sau số hex để căn chỉnh việc in ấn ở 40/80 cột cũng như 22 cột trên VIC-20.

Brainfuck , 2902 byte

Dễ nổi giận, nhưng đáng để bắn

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

Hãy thử trực tuyến!

Python 2, 66 55 byte

Đây thực sự nên là cách tiếp cận rõ ràng nhất đối với tôi ..

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

Cũ (66 byte) : Về mặt kỹ thuật, điều này gây ra lỗi sau FF, nhưng nó đã đạt tới 30.

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

Tôi giả sử định dạng chuỗi không được phép vì tôi khá chắc chắn rằng nó sẽ trải qua chuyển đổi cơ sở, nhưng nếu được cho phép, đây sẽ là 29 byte:

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

Java, 104 byte

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

Nếu i<99được gỡ bỏ, nó vẫn đạt 30, nhưng cuối cùng bị hỏng. Tôi không chắc nếu điều đó được chấp nhận.

J, 47 byte

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

in 00 đến 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 byte

Thời gian ngắn nhất mà tôi có thể đưa ra mà không sử dụng bất kỳ loại chuyển đổi nào là:

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

in 00... FFkhông gian ngăn cách theo thứ tự.
Nếu bạn muốn nhiều hơn, bạn có thể trao đổi 2cho một số lượng lớn hơn.
(không sử dụng số lớn hơn 4 vì nó kết hợp các giá trị lại với nhau trước khi xuất ra bất cứ thứ gì, vì vậy nó sẽ sử dụng một lượng RAM đáng kể)

Ngắn nhất sẽ không bao giờ ngừng viết giá trị hex

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

Nếu printfđược phép

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

Nếu chức năng chuyển đổi cơ sở được cho phép

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 ký tự

(Mã 56 ký tự + tùy chọn dòng lệnh 3 ký tự.)

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

Chạy mẫu:

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

Kiểm tra trực tuyến (Chuyển -rqua URL không được hỗ trợ - hãy tự kiểm tra Đầu ra thô.)

jq 1,5: 56 ký tự

(Mã 53 ký tự + tùy chọn dòng lệnh 3 ký tự.)

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

Điều này tạo ra đầu ra chính xác, tuy nhiên không chính xác là một bộ đếm: nó không tạo ra các giá trị theo thứ tự, chỉ sắp xếp chúng sau.

Kiểm tra trực tuyến (Chuyển -rqua URL không được hỗ trợ - hãy tự kiểm tra Đầu ra thô.)

APL Dyalog , 12 byte

       ∘.,⍨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 byte

Được cải thiện...

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

Hãy thử trực tuyến!

Zsh, 44 29 byte

-15 , thông qua GammaFunction   hãy thử trực tuyến!

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

Bản gốc (44 byte): g=0123456789abcdef;h=(${(s::)g});echo $^h$^h

PowerShell 6, 40 byte

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

Hãy thử trực tuyến!

Bắt đầu 00và đếm đến FF.

8088 hội, IBM PC DOS, 34 byte

Byte xxd:

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

Chưa được lắp ráp:

        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 DOS độc lập có thể chính xác, đầu ra là trên bàn điều khiển và sẽ tiếp tục hiển thị cho đến khi chương trình dừng lại. Chỉ là một chương trình thao túng ASCII đầu ở đây. Không có phương thức tích hợp hoặc tiện lợi nào trong API x86 hoặc DOS / BIOS để chuyển đổi giá trị nhị phân thành chuỗi cho đầu ra.

Đầu ra:

MUMPS , 57 byte

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

Đầu ra

>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

Giải trình

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 byte

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

Python 2 - 57 byte

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

Điều này xuất ra 00 đến FF, với khoảng cách giữa.