Hexadécimal est un système de comptage en base 16 qui va de 0à f. Votre travail consiste à créer un compteur qui affichera ces chiffres.

Exemple:

$ 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

Règles:

• Les nombres peuvent être séparés par des espaces, des tabulations ou de nouvelles lignes.
• Le nombre minimum auquel vous devez vous rendre est 30(48 en décimal).
  • Vous pouvez également faire en sorte que le programme imprime les numéros pour toujours jusqu'à ce qu'il soit arrêté.
• Les lettres peuvent être en majuscules ou en minuscules ( Aou a).
• Aucune fonction intégrée n'est autorisée (qui affecte directement les conversions / comptages hexadécimaux).
• Les zéros en tête sont autorisés
• Cela peut commencer par 1ou0
• Le code le plus court gagne!

Pyth - 12 octets

Utilise le produit cartésien et trie à la fin pour obtenir le bon ordre, puis joint par des espaces. Impressions 00-ffincluses.

jdS^s+<G6UT2

Essayez-le en ligne ici .

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

Compte de 0x0 à 0x3F:

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

Essayez-le en ligne!

CJam, 21 14 octets

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

Imprime les chiffres 00 à 9F.

Essayez-le en ligne dans l' interpréteur CJam .

Comment ça fonctionne

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'

Imprime 00vers 3F. Profite du fait que le premier chiffre aest toujours un nombre dans cette plage. Boucle sur quatre cycles du deuxième chiffre b, incrémentant achaque fois que le deuxième chiffre l'est F.

C'est un caractère plus court que le plus direct

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

JavaScript (ES6), 57 octets

Même approche que celles de Python, je suppose.

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

TI-Basic, 63 octets

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

C'est 63 octets, selon l'écran de gestion de la mémoire de ma calculatrice, une TI-84 +. Assurez-vous de démarrer le programme avec un écran d'accueil partiellement rempli!

Befunge-93, 57 octets

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

Imprime les nombres de 00à 8F. Si vous préférez que vos programmes s'exécutent pour toujours, la version ci-dessous ne se termine pas et affichera continuellement tous les nombres de 00à FF.

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

C, 78 75 octets

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

Nous définissons une fonction f()à appeler sans arguments pour l'impression et une fonction d'aide x(int). Cela casse à FF.

Étonnamment, c'est un octet plus court que le plus évident:

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

Attention: il n'est pas recommandé d'exécuter ce code en dehors d'un environnement de débogage ...

Essai:

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

Production:

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

Bien sûr, l'approche la plus robuste (et tricheuse) est cette fonction de 34 octets:

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

Pyth, 17 octets

VJs++kUT<G6FYJ+NY

Essayez-le ici

Comment ça fonctionne:

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

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

J, 22 octets

>{;~'0123456789abcdef'

Compte pour ff. Imprime une nouvelle ligne supplémentaire entre chaque bloc de 0x10nombres, comme ceci:

...
0d
0e
0f

10
11
...

Oreillons - 65 octets

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

Non ... Les oreillons ne sont pas encore morts! :-)

CJam, 22 octets

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

Cela fonctionne pour toujours, et c'est donc probablement l'une des rares fois où c'est une bonne idée de ne pas inclure de permalien.

TheC64Mini et Commodore BASIC (C64 / 128, PET, VIC-20, C16 / + 4) - 164 octets BASIC et Tokenized utilisés

 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 double espace après le numéro hexadécimal pour aligner correctement l'impression sur 40/80 colonnes ainsi que sur les 22 colonnes du VIC-20.

brainfuck , 2902 octets

Facile à surfer, mais vaut la peine de donner un coup de feu

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

Essayez-le en ligne!

Python 2, 66 55 octets

Cela aurait vraiment dû être l'approche la plus évidente pour moi ..

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

Ancien (66 octets) : Techniquement, cela provoque une erreur après FF, mais il atteint 30.

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

J'ai supposé que le formatage des chaînes n'était pas autorisé car je suis sûr qu'il passerait par la conversion de base, mais s'il était autorisé, ce serait 29 octets:

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

Java, 104 octets

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

Si le i<99est supprimé, il atteint toujours 30, mais se bloque finalement. Je ne sais pas si c'est acceptable.

J, 47 octets

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

imprime de 00 à 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 octets

Le plus court que je puisse trouver qui n'utilise aucune sorte de conversion est:

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

impressions 00... FFespace séparé dans l'ordre.
Si vous en voulez plus, vous pouvez échanger 2contre un plus grand nombre.
(n'utilisez pas un nombre supérieur à 4 car il concatène les valeurs ensemble avant de sortir quoi que ce soit, il utiliserait donc une quantité importante de RAM)

Le plus court qui n'arrêtera jamais d'écrire des valeurs hexadécimales

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

Si printfétaient autorisés

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

Si une fonction de conversion de base était autorisée

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 caractères

(Code de 56 caractères + option de ligne de commande de 3 caractères.)

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

Exemple d'exécution:

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 en ligne (Réussite-rpar l'URL n'est pas pris en charge - vérifiez vous-même la sortie brute.)

jq 1.5: 56 caractères

(Code de 53 caractères + option de ligne de commande de 3 caractères.)

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

Cela produit une sortie correcte, mais n'est pas exactement un compteur: il ne génère pas les valeurs dans l'ordre, les trie juste après.

Test en ligne (le passage -rpar l'URL n'est pas pris en charge - vérifiez vous-même la sortie brute.)

Dyalog APL , 12 octets

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

Être amélioré...

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

Essayez-le en ligne!

Zsh, 44 29 octets

-15 , via GammaFunction   essayez-le en ligne!

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

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

PowerShell 6, 40 octets

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

Essayez-le en ligne!

Commence à 00et compte jusqu'à FF.

Assemblage 8088, IBM PC DOS, 34 octets

Octets xxd:

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

Non assemblé:

        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 autonome DOS exactable, la sortie est vers la console et continuera à s'afficher jusqu'à l'arrêt du programme. Juste un programme de manipulation ASCII à gratter ici. Il n'y a tout simplement pas de méthodes intégrées ou pratiques dans les API x86 ou DOS / BIOS pour convertir les valeurs binaires en chaînes pour la sortie.

Production:

MUMPS , 57 octets

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

Production

>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

Explication

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 octets

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

Python 2 - 57 octets

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

Cela délivre 00 à FF, avec des espaces entre.