Défi

Je suis récemment entré dans les ordinateurs 8 bits et suis fasciné par leur fonctionnement et celui des autres; ainsi l'objectif de ce code golf, est de répliquer une partie du Woz Monitor, conçu par Steve Wozniak pour l'Apple I.

Vous devez stocker un tableau de 22 valeurs hexadécimales avec une largeur de deux octets (valeur minimale 10 $ , valeur maximale $ FF ), puis prendre n- quantité d'entrées. (Normalement deux; les langues comme Brainfuck peuvent avoir du mal).
Les entrées feront référence à l'endroit où commencer à imprimer dans le tableau et où s'arrêter; une entrée avec un comportement défini aura sa valeur de départ inférieure ou égale à la valeur de fin. Votre programme doit alors être capable d'imprimer toutes les valeurs hexadécimales comprises entre et incluant les hexadécimaux entrés.

Un exemple de ceci:

Array
00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

Values
FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5

input first num:
04
input second num:
14
40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6

Maintenant, la partie intéressante de cet exercice est que vous pouvez utiliser ce que vous voulez pour vérifier les limites de l'entrée des utilisateurs. Entrées de personne helloet votre programme a un comportement indéfini? Il quitte sans préavis? Ils sont tous les deux valides.

Les seules règles sont:

1. Vous devez inclure les valeurs des 22 valeurs hexadécimales dans le cadre de votre programme avant qu'il ne démarre (vous ne pouvez pas demander de saisie à l'utilisateur).
2. La sortie des valeurs hexadécimales doit suivre le format exact: 00 FF 00 FF 00les espaces de fin, les tabulations ou les lignes sont OK. Les personnages ne le sont pas.
3. Le programme n'a pas à demander les entrées avec un message. Laissez le "message" vide si vous le souhaitez. L'utilisateur doit cependant saisir les limites hexadécimales.
4. Comme les valeurs des 22 hexadécimaux sont à vous de décider, vous devez créer un programme qui récupère réellement les valeurs du stockage, au lieu d' imiter un programme en imprimant simplement les valeurs. (comme une liste de 00 $ ).
5. n-quantité d'entrées, se réfère à la quantité d'entrées requises pour que la langue de votre choix reconnaisse une largeur hexadécimale de deux octets. par exemple. (Brainfuck nécessitera deux entrées par hex, ce qui en fait quatre pour les deux).

N'hésitez pas à commenter si vous avez besoin d'éclaircissements.

Il s'agit du code golf, donc la réponse la plus courte en nombre d'octets est le gagnant.

Classement

Voici un extrait de classement générant un courtoisie de Martin Ender .

Pour vous assurer que votre réponse s'affiche, veuillez commencer votre réponse avec un titre, en utilisant le modèle Markdown suivant:

# Language Name, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

# Ruby, <s>104</s> <s>101</s> 96 bytes

function answersUrl(e){return"http://api.stackexchange.com/2.2/questions/95080/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function getAnswers(){$.ajax({url:answersUrl(page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(e){answers.push.apply(answers,e.items);if(e.has_more)getAnswers();else process()}})}function shouldHaveHeading(e){var t=false;var n=e.body_markdown.split("\n");try{t|=/^#/.test(e.body_markdown);t|=["-","="].indexOf(n[1][0])>-1;t&=LANGUAGE_REG.test(e.body_markdown)}catch(r){}return t}function shouldHaveScore(e){var t=false;try{t|=SIZE_REG.test(e.body_markdown.split("\n")[0])}catch(n){}return t}function getAuthorName(e){return e.owner.display_name}function process(){answers=answers.filter(shouldHaveScore).filter(shouldHaveHeading);answers.sort(function(e,t){var n=+(e.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0],r=+(t.body_markdown.split("\n")[0].match(SIZE_REG)||[Infinity])[0];return n-r});var e={};var t=0,c=0,p=-1;answers.forEach(function(n){var r=n.body_markdown.split("\n")[0];var i=$("#answer-template").html();var s=r.match(NUMBER_REG)[0];var o=(r.match(SIZE_REG)||[0])[0];var u=r.match(LANGUAGE_REG)[1];var a=getAuthorName(n);t++;c=p==o?c:t;i=i.replace("{{PLACE}}",c+".").replace("{{NAME}}",a).replace("{{LANGUAGE}}",u).replace("{{SIZE}}",o).replace("{{LINK}}",n.share_link);i=$(i);p=o;$("#answers").append(i);e[u]=e[u]||{lang:u,user:a,size:o,link:n.share_link}});var n=[];for(var r in e)if(e.hasOwnProperty(r))n.push(e[r]);n.sort(function(e,t){if(e.lang>t.lang)return 1;if(e.lang<t.lang)return-1;return 0});for(var i=0;i<n.length;++i){var s=$("#language-template").html();var r=n[i];s=s.replace("{{LANGUAGE}}",r.lang).replace("{{NAME}}",r.user).replace("{{SIZE}}",r.size).replace("{{LINK}}",r.link);s=$(s);$("#languages").append(s)}}var QUESTION_ID=49042;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var answers=[],page=1;getAnswers();var SIZE_REG=/\d+(?=[^\d&]*(?:&lt;(?:s&gt;[^&]*&lt;\/s&gt;|[^&]+&gt;)[^\d&]*)*$)/;var NUMBER_REG=/\d+/;var LANGUAGE_REG=/^#*\s*([^,]+)/

body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}

<script src=https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js></script><link rel=stylesheet type=text/css href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b"><div id=answer-list><h2>Leaderboard</h2><table class=answer-list><thead><tr><td></td><td>Author<td>Language<td>Size<tbody id=answers></table></div><div id=language-list><h2>Winners by Language</h2><table class=language-list><thead><tr><td>Language<td>User<td>Score<tbody id=languages></table></div><table style=display:none><tbody id=answer-template><tr><td>{{PLACE}}</td><td>{{NAME}}<td>{{LANGUAGE}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table><table style=display:none><tbody id=language-template><tr><td>{{LANGUAGE}}<td>{{NAME}}<td>{{SIZE}}<td><a href={{LINK}}>Link</a></table>

Gelée , 24 21 octets

w@€ØHḅ⁴
ɠǵɠÇr@b⁴ịØHK

Valeurs choisies: [00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 1F 10 11 12 13 14 15]

TryItOnline

Si la deuxième entrée est inférieure à la première, elle sort la séquence inversée.
Le comportement hors limites n'est pas défini (par exemple, "foo", "14" renvoie 38 valeurs, dont la plupart ne sont même pas dans le tableau et beaucoup ne sont pas de longueur 2)

Comment?

w@€ØHḅ⁴ - Link 1, parse a string as a 1-based hex value e.g. "14"
w@€      - first index (1-based) of each character in
   ØH    - hex digits: "0123456789ABCDEF"                   [2,5]
     ḅ⁴ - convert from base 16                                 37

ɠǵɠÇr@b⁴ịØHK - Main link
ɠ  ɠ          - read a line from stdin               e.g. "04"  "14"
 Ç  Ç         - call the last link (1) as a monad          21    37
  µ           - monadic chain separation
     r@       - inclusive range, with reversed arguments  [   21,   22,...,   36,   37] 
       b⁴     - convert to base 16                        [[1,5],[1,6],...,[2,4],[2,5]]
         ị    - index into
          ØH  - hex digits: "0123456789ABCDEF"            [ "04", "05",..., "13", "14"]
            K - join with spaces

JavaScript (ES6), 118 115 112 102 82 81 octets

1 octet enregistré grâce à ETHproductions

Valeurs choisies:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
10 10 11 14 10 10 15 15 11 14 10 10 15 15 11 14 10 10 15 15 10 11

• Demande la borne inférieure, puis la borne supérieure (par exemple 0x04/ 0x0f).
• Une borne inférieure non valide sera interprétée comme 0x00(valeur minimale).
• Une limite supérieure non valide sera interprétée comme 0x15(valeur maximale).
• N'affiche rien si la limite inférieure est supérieure à la limite supérieure.

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v|10)+' ',p=prompt,b=p(a=p())))

Version précédente (97 octets)

Génération d'une liste pseudo-aléatoire de «vraies» valeurs hexadécimales:

alert((1/7+'789').replace(/./g,(v,i)=>i<a|i>b?'':(v*7|16).toString(16)+' ',p=prompt,a=p(),b=p()))

Séquence:

10 10 17 1c 1e 38 33 31 17 1c 1e 38 33 31 17 1c 1e 38 33 31 38 3f

JavaScript (ES6), 107 152 137 octets

p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

var
   p=prompt,f=(a=+p(),b=+p(),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())
;

//input 0x04 then 0x14 will print 40 to D6
//input 0x00 then 0x00 will print FF
//input 0x13 then 0x17 will print E7 D6 A5 NaN NaN

Valeurs choisies:

FF F4 B6 D7 40 20 11 A4 F0 D0 FF 3D 9C 21 65 C4 A2 28 90 E7 D6 A5

Contributions:

• Le format d'entrée est 0x14
• Si une entrée est négative ou si la 1ère entrée est supérieure à la 2ème: InternalError: too much recursion
• Imprime NaNpour hors limites.

Solutions précédentes:
152 octets:

i=parseInt,p=prompt,f=(a=i(p()),b=i(p()),[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'');alert(f())

107 octets, solution invalide (entrées manquantes):

f=(a,b,[x,y,...s]='FFF4B6D7402011A4F0D0FF3D9C2165C4A22890E7D6A5')=>a?f(a-1,b-1,s):x+y+' '+(b?f(a,b-1,s):'')

Python, 88 87 86 octets

1 octet de sauvegarde grâce à @JonathanAllan
1 octet de sauvegarde à nouveau à @JonathanAllan

A également changé la base du code, beaucoup plus agréable maintenant.

a,b=[int(x,16)for x in raw_input().split()];l=[0]*22
while a<=b:print"%02x"%l[a],;a+=1

Valeurs choisies: 00pour tout.

Même idée que ma réponse C. Cette fois, cependant, le code prend une seule entrée de l'utilisateur, nécessitant un espace entre les deux valeurs, les divise, les convertit en valeurs hexadécimales et imprime chaque hex du ltableau, y compris et entre les deux valeurs entrées. Puisque Python a un magnifique système de capture d'erreurs, aucun débordement de tampon n'est présent et le code est donc beaucoup plus sécurisé. Le programme est à l'abri d' un comportement indéfini en ce sens qu'il ne s'exécutera pas lorsqu'une valeur supérieure est soumise avant une valeur inférieure.

Cela devrait fonctionner sur Python 2.x et 3.x; Veuillez me corriger si je me trompe, car je n'ai pas accès aux deux interprètes car mon système ne prend pas en charge les deux.

C ++, 98 95 93 octets

#include <iostream>
int _[22],a,b;int main(){for(std::cin>>a>>b;b/a++;)printf("%02x ",_[a]);}

Mes valeurs choisies sont toutes des 0

Perl, 79 45 41 octets

"valeur min 10 $" - l'exemple a un minimum de 00 $ - est-ce une faute de frappe?

Voici une réponse perl plutôt ennuyeuse en 41 octets (était 46, puis j'ai continué à voir des espaces, des parens que je pouvais élider). Prend l'entrée sur deux lignes.

printf'%02X ',$_ for(4..26)[hex<>..hex<>]

Les données sont une liste 04..1A

Avant j'étais trop intelligent avec le pack & unpack. Ses octets d'entrée sont entrés immédiatement ensemble, par exemple, "020E" affichera les entrées du 14 au 14

printf'%02X ',$_ for sub{(4..26)[shift..shift]}->(unpack'CC',pack'H4',<>)

Pourrait essayer de jouer au golf plus en utilisant tous les 0 substr, et printf'%*vX'... non, ce qui rend ma réponse plus longue. 48 caractères (en utilisant une chaîne d'ascii '7', hex 37 comme données)

printf'%*vX',' ',substr 7x22,$s=hex<>,1+hex<>-$s

CJam, 22 octets

{r:~Gb}2*37m!s2/\)<>S*

Valeurs choisies:

00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15
-----------------------------------------------------------------
13 76 37 53 09 12 26 34 50 46 31 59 79 58 15 80 90 24 00 00 00 00

Essayez-le en ligne

Scala, 45 octets

(_:Int)to(_:Int)map(x=>f"$x%02X")mkString " "

Non golfé:

(a:Int,b:Int)=>a.to(b).map(x=>f"$x%02X").mkString(" ")

Utilise 00en FFtant que valeurs, mais fonctionne jusqu'à 2147483647.

C, 176 175 161 161 octets

1 octet de sauvegarde grâce à @JonathanAllan Aide
massive grâce à @Downvoter pour m'avoir sauvé 14 octets!

int main(){int a[44]={0};char s[2];scanf("%s",s);int b=(int)strtol(s,0,16);scanf("%s",s);int c=(int)strtol(s,0,16);while(b<=c){printf("%d%d ",a[b],a[b+1]);b++;}}

Essayez-le en ligne!

Valeurs choisies: 00pour tout.

Réponse sans golf:

int main() {
    int a[44] = {0};
    char s[2];
    scanf("%s", s);
    int b = (int) strtol(s, 0, 16);
    scanf("%s", s);
    int c = (int) strtol(s, 0, 16);
    while (b <= c) {
        printf("%d%d ", a[b], a[b+1]);
        b++;
    }
}

L'astuce consiste à saisir deux entrées et à tenter de les convertir en chaînes hexadécimales, puis de les convertir en entiers. Puisqu'il n'y a pas de vérification d'erreur ou quoi que ce soit de même, un comportement indéfini est simplement de lancer des erreurs et de casser le programme. L'utilisateur doit saisir deux entrées, mais mon compilateur Eclipse CDT semble me permettre de les saisir toutes les deux sur la même ligne avec un espace entre les deux.

Ils doivent être dans le bon ordre, car demander une valeur plus élevée avant qu'une valeur plus petite ne lance pas du whiletout la boucle.

Le fait est qu'il n'y a pas non plus de protection contre le débordement de tampon, donc je peux simplement demander quelque chose d'absurde comme une plage de 0 $ à $ FFFF, et j'obtiendrai tout dans la mémoire de mon ordinateur dès le début de l'allocation de mémoire pour le a[44]tableau. , jusqu'à 65536 valeurs plus tard.

GNU sed, 209 + 1 (drapeau r) = 210 octets

1{h
s:.*:,00 FF,01 F4,02 B6,03 D7,04 40,05 00,06 00,07 A4,08 F0,09 00,0A FF,0B 0D,0C 9C,0D 21,0E 65,0F C4,10 02,11 28,12 90,13 E7,14 D6,15 A5:
H;d}
G;s:\n(.*)\n.*(,\1.*):\n\2:
s:(.*)\n(.*,\1 ..).*:\2:
s:,..::g

Essayez-le en ligne! Un espace de tête est présent dans la sortie, j'espère qu'il est autorisé.

Exemples d'exécution:

me@LCARS:/PPCG$ echo -e "06\n0F" | sed -rf table_lookup.sed
 00 A4 F0 00 FF 0D 9C 21 65 C4
me@LCARS:/PPCG$ echo -e "13\n13" | sed -rf table_lookup.sed
 E7

Explication: les 22 valeurs hexadécimales enregistrées sont les mêmes que celles de l'exemple de l'OP

value | FF F4 B6 D7 40 00 00 A4 F0 00 FF 0D 9C 21 65 C4 02 28 90 E7 D6 A5
-------------------------------------------------------------------------
index | 00 01 02 03 04 05 06 07 08 09 0A 0B 0C 0D 0E 0F 10 11 12 13 14 15

Les index de début et de fin sont lus sur des lignes distinctes. La sortie est une seule ligne avec les valeurs de table dans cette plage d'index (inclus). Une entrée non définie écrira plusieurs lignes de sortie non valide.

# store START index in hold space
1{h
# generate the table
s:.*:,INDEX1 VALUE1,INDEX2 VALUE2,°°°:
# append table to hold space and delete pattern space
H;d}
# read END index, append hold space (pattern space format is: END\nSTART\nTABLE)
G
# delete table entries up to, but excluding, the START index (END\nTABLE')
s:\n(.*)\n.*(,\1.*):\n\2:
# delete table entries starting from, but excluding, the END index (TABLE'')
s:(.*)\n(.*,\1 ..).*:\2:
# remove the indexes and print (implicitly) the resulting values
s:,..::g

PHP, 106105104 96 + 2 octets

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);while($b<=$c)printf("%02X ",ord($s[$b++]));');

ou

eval($s='for($a=a;$a++<c;)$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

Courir avec php -nr '<code>' <lowindex> <highindex>; échapper aux guillemets simples dans le code.
... ou testez-le en ligne .

dechexinterprète l'entrée comme des chaînes hexadécimales dans la mesure où les caractères sont des chiffres hexadécimaux,
0si l'entrée commence par autre chose.

n'imprime rien si la première valeur est supérieure à la seconde.

valeurs choisies:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
66 6F 72 28 24 61 3D 61 3B 24 61 2B 2B 3C 63 3B 29 24 24 61 3D 68

(22 premiers codes ascii du code exécuté)

ou

for($a=a;$a++<c;)eval($s='$$a=hexdec($argv[++$i]);');while($b<=$c)printf("%02X ",ord($s[$b++]));

avec ces valeurs:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
24 24 61 3D 68 65 78 64 65 63 28 24 61 72 67 76 5B 2B 2B 24 69 5D 

Assemblage Apple II 6502, 75 octets

Code d'octet:

A9 46 85 36 A9 10 85 37 A0 00 98 20 DA FD A9 A0 
20 ED FD C0 42 D0 F3 20 93 FE A2 FC 20 1B FD 9D 
04 01 E8 D0 F7 86 31 A9 8D 8D 04 02 20 A7 FF B5 
3C 0A 75 3C 95 3C CA 10 F6 A6 3D BD 05 02 20 ED 
FD E8 E4 3C D0 F5 99 05 02 C8 60

Démontage:

  LDA    #<+
  STA    CSWL
  LDA    #>+
  STA    CSWH    ;redirect stdout
  LDY    #$00
- TYA
  JSR    PRBYTE  ;print number
  LDA    #$A0    ;space
  JSR    COUT    ;print space
  CPY    #$42    ;22*3
  BNE    -
  JSR    SETVID  ;restore stdout
  LDX    #$FC
- JSR    KEYIN   ;fetch a key
  STA    $0104,X ;store to $200+
  INX
  BNE    -       ;four keys
  STX    MODE    ;set internal flags
  LDA    #$8D
  STA    $0204   ;set key delimiter
  JSR    GETNUM  ;convert keys to hex values
- LDA    A1L,X   ;fetch value
  ASL
  ADC    A1L,X   ;multiply by 3
  STA    A1L,X   ;store value
  DEX
  BPL    -       ;both inputs
  LDX    A1H     ;first input
- LDA    $0205,X ;fetch from index
  JSR    COUT    ;print character
  INX
  CPX    A1L
  BNE    -       ;until second input
+ STA    $0205,Y ;fall through to save a byte
  INY
  RTS

Il forme un tableau en mémoire qui ressemble à la sortie. Les valeurs choisies sont:

00 01 02 03 04 05 06 07 08 09 0a 0b 0c 0d 0e 0f 10 11 12 13 14 15
-----------------------------------------------------------------
00 03 06 09 0C 0F 12 15 18 1B 1E 21 24 27 2A 2D 30 33 36 39 3C 3F

L'utilisateur appuie sur quatre touches pour définir les entrées.