Desafio

Recentemente, entrei em computadores de 8 bits e sou fascinado com o funcionamento deles e de outros; portanto, o objetivo desse código de golfe é replicar uma parte do Woz Monitor, projetada por Steve Wozniak para o Apple I.

Você deve armazenar uma matriz de 22 valores hexadecimais com uma largura de dois bytes (valor mínimo $ 10 , valor máximo $ FF ) e, em seguida, n- quantidade de entradas. (Normalmente dois; idiomas como Brainfuck podem ter dificuldade).
As entradas referem-se ao local da matriz para iniciar a impressão e para onde parar; uma entrada com comportamento definido terá seu valor inicial menor ou igual ao valor final. Seu programa deve ser capaz de imprimir todos os valores hexadecimais entre e incluindo os hexadecimais inseridos.

Um exemplo disso:

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

Agora, a parte interessante deste exercício é que você pode usar o que quiser para verificar os limites da entrada do usuário. Entradas de pessoas helloe seu programa tem comportamento indefinido? Desiste sem aviso prévio? Ambos são válidos.

As únicas regras são:

1. Você deve incluir os valores dos 22 valores hexadecimais como parte do seu programa antes de iniciar (não pode pedir entradas ao usuário).
2. A saída dos valores hexadecimais deve seguir o formato exato: 00 FF 00 FF 00Espaços, tabulações ou linhas à direita estão OK. Personagens não são.
3. O programa não precisa solicitar as entradas com uma mensagem. Deixe a "mensagem" em branco, se desejar. O usuário deve inserir os limites hexadecimais no entanto.
4. Como você decide com os valores dos 22 hexadecimais, você deve criar um programa que realmente busque os valores do armazenamento, em vez de imitar um programa simplesmente imprimindo valores. (como uma lista de US $ 00 ).
5) n-quantidade de entradas, refere-se à quantidade de entradas necessária para o seu idioma de escolha reconhecer um hexadecimal de dois bytes de largura. por exemplo. (O Brainfuck precisará de duas entradas por hexadecimal, tornando-a quatro para as duas).

Fique à vontade para comentar se precisar de esclarecimentos.

Isso é código de golfe, então a resposta mais curta no número de bytes é o vencedor.

Entre os melhores

Aqui está um cabeçalho de geração de snippet, cortesia de Martin Ender .

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

# 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éia , 24 21 bytes

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

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

TryItOnline

Se a segunda entrada for menor que a primeira, ela emitirá a sequência reversa.
O comportamento fora dos limites é indefinido (por exemplo, "foo", "14" retorna 38 valores, a maioria nem mesmo na matriz e muitos com o comprimento 2)

Quão?

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 bytes

Economizou 1 byte graças à ETHproductions

Valores escolhidos:

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

• Solicita o limite inferior e, em seguida, o limite superior (por exemplo, 0x04/ 0x0f).
• Um limite inferior inválido será interpretado como 0x00(valor mínimo).
• Um limite superior inválido será interpretado como 0x15(valor máximo).
• Não produz nada se o limite inferior for maior que o limite superior.

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

Versão anterior (97 bytes)

Gerando uma lista pseudo-aleatória de valores hexadecimais 'verdadeiros':

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

Seqüência:

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 bytes

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

Valores escolhidos:

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

Entradas:

• O formato de entrada é 0x14
• Se alguma entrada for negativa ou a 1ª entrada for maior que a 2ª: InternalError: too much recursion
• Imprimirá NaNfora dos limites.

Soluções anteriores:
152 bytes:

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 bytes, solução inválida (falta de entradas):

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 bytes

1 byte save graças a @JonathanAllan
1 byte save novamente a @JonathanAllan

Também mudou a base do código, muito melhor agora.

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

Valores escolhidos: 00para tudo.

Mesma ideia que a minha resposta C. Desta vez, no entanto, o código recebe uma única entrada do usuário, exigindo um espaço entre os dois valores, dividi-los, convertê-los em valores hexadecimais e imprimir todos os hexadecimais da lmatriz, incluindo e entre os dois valores inseridos. Como o Python possui um sistema magnífico de captura de erros, nenhum estouro de buffer está presente e, portanto, o código é muito mais seguro. O programa está protegido contra comportamentos indefinidos, no sentido de que não será executado quando um valor mais alto for submetido antes de um valor mais baixo.

Isso deve funcionar no Python 2.xe 3.x; Corrija-me se estiver errado, pois não tenho acesso aos dois intérpretes devido ao meu sistema não suportar os dois.

C ++, 98 95 93 bytes

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

Meus valores escolhidos são todos os 0s

Perl, 79 45 41 bytes

"valor mínimo de US $ 10" - o exemplo tem um mínimo de US $ 00 - é um erro de digitação?

Aqui está uma resposta perl bastante chata em 41 bytes (tinha 46 anos e eu continuava vendo espaços, parênteses que eu podia evitar). Recebe entrada em duas linhas.

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

Os dados são uma lista 04..1A

Antes eu estava sendo muito esperto em embalar e descompactar. Seus bytes de entrada são inseridos ao mesmo tempo juntos, por exemplo, "020E 'imprime as 2ª e 14ª entradas

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

Pode tentar jogar mais usando todos os zeros substr, e printf'%*vX'... não, isso está aumentando minha resposta. 48 caracteres (usando uma sequência de caracteres ascii '7', hex 37 como dados)

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

CJam, 22 bytes

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

Valores escolhidos:

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

Experimente online

Scala, 45 bytes

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

Ungolfed:

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

Usos 00para FFcomo valores, mas funciona até 2147483647.

C, 176 175 161 bytes

1 byte save graças a @ JonathanAllan
Ajuda maciça graças a @Downvoter por me salvar 14 bytes!

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++;}}

Experimente online!

Valores escolhidos: 00para tudo.

Resposta sem golfe:

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++;
    }
}

O truque é pegar duas entradas e tentar convertê-las em seqüências hexadecimais e depois converter em números inteiros. Como não há verificação de erros ou algo semelhante, o comportamento indefinido é simplesmente gerar erros e interromper o programa. O usuário precisa digitar duas entradas, no entanto, meu compilador Eclipse CDT parece permitir que eu insira ambas na mesma linha com um espaço entre elas.

Eles devem estar na ordem correta, pois solicitar um valor maior antes que um valor menor não execute o whileloop.

O problema é que também não há proteção contra buffer overflow; portanto, posso simplesmente solicitar algo absurdo, como um intervalo de US $ 0 a US $ FFFF, e receberei tudo na memória de meus computadores desde o início da alocação de memória para o a[44]array , até 65536 valores posteriormente.

GNU sed, 209 + 1 (sinalizador r) = 210 bytes

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

Experimente online! Um espaço principal está presente na saída, espero que seja permitido.

Execute exemplos:

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

Explicação: os 22 valores hexadecimais armazenados são os mesmos do exemplo do 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

Os índices inicial e final são lidos em linhas separadas. A saída é uma única linha com os valores da tabela nesse intervalo de índice (inclusive). A entrada indefinida gravará várias linhas de saída inválida.

# 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, 106 105 104 96 + 2 bytes

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

Corra com php -nr '<code>' <lowindex> <highindex>; escape das aspas simples no código.
... ou testá-lo online .

dechex interpreta a entrada como seqüências hexadecimais até os caracteres serem dígitos hexadecimais,
0 se a entrada começar com outra coisa.

imprime nada se o primeiro valor for maior que o segundo.

valores escolhidos:

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

(primeiros 22 códigos ASCII do código executado)

ou

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

com estes valores:

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 

Montagem do Apple II 6502, 75 bytes

Código de bytes:

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

Desmontagem:

  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

Ele forma uma matriz na memória que se parece com a saída. Os valores escolhidos são:

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

O usuário pressiona quatro teclas para definir as entradas.