Szesnastkowy to podstawowy system liczenia 16, który przechodzi od 0do f. Twoim zadaniem jest stworzenie licznika, który wyświetli te liczby.

Przykład:

$ 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

Zasady:

• Liczby mogą być oddzielone spacjami, tabulatorami lub nowymi wierszami.
• Minimalna liczba, do której musisz się udać, to 30(48 miejsc po przecinku).
  • Możesz także sprawić, że program wydrukuje numery na zawsze, dopóki nie zostanie zatrzymany.
• Litery mogą być pisane wielkimi lub małymi literami ( Alub a).
• Niedozwolone są wbudowane funkcje (które bezpośrednio wpływają na konwersję / zliczanie szesnastkowe).
• Zera wiodące są dozwolone
• Może zaczynać się od 1lub0
• Najkrótszy kod wygrywa!

Pyth - 12 bajtów

Używa produktu kartezjańskiego i sortuje na końcu, aby uzyskać odpowiednią kolejność, a następnie łączy spacjami. Wydruki 00-ffwłącznie.

jdS^s+<G6UT2

Wypróbuj online tutaj .

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

Liczy od 0x0 do 0x3F:

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

Wypróbuj online!

CJam, 21 14 bajtów

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

Drukuje liczby od 00 do 9F.

Wypróbuj online w interpretatorze CJam .

Jak to działa

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'

Drukuje 00do 3F. Wykorzystuje fakt, że pierwsza cyfra ajest zawsze liczbą z tego zakresu. Pętle przechodzą przez cztery cykle drugiej cyfry b, zwiększając, ailekroć jest druga cyfra F.

Jest to o jeden znak krótszy niż bardziej bezpośredni

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

JavaScript (ES6), 57 bajtów

Takie samo podejście jak w Pythonie.

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

TI-Basic, 63 bajty

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

To 63 bajty, zgodnie z ekranem zarządzania pamięcią mojego kalkulatora, TI-84 +. Pamiętaj, aby uruchomić program z częściowo wypełnionym ekranem głównym!

Befunge-93, 57 bajtów

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

Drukuje liczby od 00do 8F. Jeśli wolisz, aby twoje programy działały wiecznie, poniższa wersja nie jest zakończona i będzie stale wyświetlać wszystkie liczby od 00do FF.

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

C, 78 75 bajtów

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

Definiujemy funkcję, f()która ma być wywoływana bez argumentów do drukowania, oraz funkcję pomocniczą x(int). To się psuje FF.

O dziwo, jest to jeden bajt krótszy niż bardziej oczywisty:

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

Ostrzeżenie: nie jest zalecane uruchamianie tego kodu poza środowiskiem debugowania ...

Testowanie:

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

Wynik:

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

Oczywiście, bardziej niezawodnym (i oszukańczym) podejściem jest ta 34-bajtowa funkcja:

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

Pyth, 17 bajtów

VJs++kUT<G6FYJ+NY

Wypróbuj tutaj

Jak to działa:

         <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 bajtów

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

J, 22 bajty

>{;~'0123456789abcdef'

Liczy się ff. Drukuje dodatkową linię nowego wiersza między każdym blokiem 0x10liczb, na przykład:

...
0d
0e
0f

10
11
...

Świnka - 65 bajtów

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

Nie ... Świnka jeszcze nie jest martwa! :-)

CJam, 22 bajty

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

Działa to wiecznie, a zatem prawdopodobnie jest to jeden z rzadkich czasów, w których dobrym pomysłem jest nie dodawanie bezpośredniego linku.

C64Mini i Commodore BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 używane bajty BASIC i tokenizowane

 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

Drukuje podwójną spację po numerze szesnastkowym, aby dobrze wyrównać drukowanie w 40/80 kolumnach, a także w 22 kolumnach na VIC-20.

pieprzenie mózgu , 2902 bajtów

Łatwy do outgolfa, ale warto spróbować

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

Wypróbuj online!

Python 2, 66 55 bajtów

To powinno być naprawdę najbardziej oczywiste podejście do mnie ...

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

Stare (66 bajtów) : Technicznie powoduje to błąd później FF, ale się nie osiąga 30.

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

Zakładałem, że formatowanie ciągów jest niedozwolone, ponieważ jestem prawie pewien, że przejdzie podstawową konwersję, ale gdyby było dozwolone, byłoby to 29 bajtów:

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

Java, 104 bajty

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

Jeśli i<99zostanie usunięty, nadal osiąga 30, ale ostatecznie ulega awarii. Nie jestem pewien, czy to dopuszczalne.

J, 47 bajtów

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

drukuje 00 na 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 bajtów

Najkrótszy, jaki mogę wymyślić, który nie korzysta z żadnej konwersji jest:

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

drukuje 00... FFodstępy rozdzielone w kolejności.
Jeśli chcesz więcej, możesz zamienić 2na większą liczbę.
(nie używaj liczby większej niż 4, ponieważ łączy ona wartości razem przed wysłaniem czegokolwiek, więc zużyłoby znaczną ilość pamięci RAM)

Najkrótszy, który nigdy nie przestanie zapisywać wartości szesnastkowych

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

Gdyby printfbyły dozwolone

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

Jeśli dozwolona jest podstawowa funkcja konwersji

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 znaków

(56-znakowy kod + 3-znakowa opcja wiersza poleceń).

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

Przykładowy przebieg:

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

Test on-line (Przekazanie -radresu URL nie jest obsługiwane - sam sprawdź Raw Output).

jq 1,5: 56 znaków

(53-znakowy kod + 3-znakowa opcja wiersza poleceń).

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

Daje to prawidłowe wyjście, jednak nie jest dokładnie licznikiem: nie generuje wartości w kolejności, po prostu je sortuje.

Test on-line (Przekazanie -radresu URL nie jest obsługiwane - sam sprawdź Raw Output).

Dyalog APL , 12 bajtów

       ∘.,⍨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 bajtów

Do ulepszenia ...

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

Wypróbuj online!

Zsh, 44 29 bajtów

-15 , za pośrednictwem GammaFunction   wypróbuj online!

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

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

PowerShell 6, 40 bajtów

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

Wypróbuj online!

Zaczyna się 00i liczy do FF.

8088 Montaż, IBM PC DOS, 34 bajty

Bajty xxd:

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

Niezmontowane:

        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

Samodzielny PC DOS z dokładnością, wyjście jest na konsolę i będzie wyświetlać aż do zatrzymania programu. Po prostu program do manipulacji ASCII tutaj. Po prostu nie ma wbudowanych ani wygodnych metod API x86 lub DOS / BIOS do konwersji wartości binarnych na ciągi wyjściowe.

Wynik:

MUMPS , 57 bajtów

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

Wynik

>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

Wyjaśnienie

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 bajty

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

Python 2 - 57 bajtów

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

Daje to od 00 do FF, ze spacjami pomiędzy.