Desafío

Recientemente me he metido en computadoras de 8 bits y estoy fascinado con el funcionamiento de ellas y otras personas por igual; por lo tanto, el objetivo de este código de golf es replicar una parte del monitor Woz, diseñado por Steve Wozniak para Apple I.

Debe almacenar una matriz de 22 valores hexadecimales con un ancho de dos bytes (valor mínimo $ 10 , valor máximo $ FF ) y luego tomar n-cantidad de entradas. (Normalmente dos; idiomas como Brainfuck podrían tener dificultades).
Las entradas se referirán a dónde en la matriz comenzar a imprimir y dónde parar; una entrada con comportamiento definido tendrá su valor inicial menor o igual al valor final. Su programa debe ser capaz de imprimir cada valor hexadecimal entre, e incluyendo , los hexadecimales ingresados.

Un ejemplo de esto:

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

Ahora, la parte interesante de este ejercicio es que puede usar lo que quiera para verificar los límites de la entrada de los usuarios. ¿Las entradas de personas helloy su programa tienen un comportamiento indefinido? Se cierra sin previo aviso? Ambos son validos.

Las únicas reglas son:

1. Debe incluir los valores de los 22 valores hexadecimales como parte de su programa antes de que comience (no puede pedirle entradas al usuario).
2. La salida de los valores hexadecimales debe seguir el formato exacto: los 00 FF 00 FF 00espacios finales, las pestañas o las líneas están bien. Los personajes no lo son.
3. El programa no tiene que pedir las entradas con un mensaje. Deje el "mensaje" en blanco si lo desea. Sin embargo, el usuario debe ingresar los límites hexadecimales.
4. Como con los valores de los 22 hexadecimales, usted debe decidir, debe hacer un programa que realmente recupere los valores del almacenamiento, en lugar de imitar un programa simplemente imprimiendo valores. (como una lista de $ 00 ).
5) n-cantidadp.ej. (Brainfuck requerirá dos entradas por hex, por lo que es cuatro para los dos). de entradas, se refiere a la cantidad de entradas requeridas para su idioma de elección para reconocer un hexadecimal de dos bytes de ancho.

Siéntase libre de comentar si necesita aclaraciones.

Este es el código de golf, por lo que la respuesta más corta en el número de bytes es el ganador.

Tabla de clasificación

Aquí hay una tabla de clasificación que genera fragmentos cortesía de Martin Ender .

Para asegurarse de que su respuesta se muestre, comience con un título, utilizando la siguiente plantilla de Markdown:

# Language Name, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

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

Jalea , 24 21 bytes

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

Valores elegidos: [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 segunda entrada es menor que la primera, genera la secuencia inversa.
El comportamiento fuera de los límites no está definido (por ejemplo, "foo", "14" devuelve 38 valores, la mayoría de los cuales ni siquiera están en la matriz y muchos de los cuales no son de longitud 2)

¿Cómo?

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

Guardado 1 byte gracias a ETHproductions

Valores elegidos:

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 el límite inferior, luego el límite superior (por ejemplo, 0x04/ 0x0f).
• Un límite inferior no válido se interpretará como 0x00(valor mínimo).
• Un límite superior no válido se interpretará como 0x15(valor máximo).
• No genera nada si el límite inferior es mayor que el límite superior.

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

Versión anterior (97 bytes)

Generando una lista pseudoaleatoria de valores hexadecimales 'verdaderos':

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

Secuencia:

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 elegidos:

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

Entradas:

• El formato de entrada es 0x14
• Si alguna entrada es negativa o la primera entrada es mayor que la segunda: InternalError: too much recursion
• Se imprimirá NaNfuera de los límites.

Soluciones 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, solución no válida (faltan 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 guardar gracias a @JonathanAllan
1 byte guardar de nuevo a @JonathanAllan

También cambió la base del código, mucho mejor ahora.

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

Valores elegidos: 00 para todo.

La misma idea que mi respuesta C. Esta vez, sin embargo, el código toma una sola entrada del usuario, que requiere un espacio entre ambos valores, dividirlos, convertirlos en valores hexadecimales e imprimir cada hexágono en la lmatriz, incluidos y entre los dos valores ingresados. Dado que Python tiene un magnífico sistema de captura de errores, no hay desbordamientos de búfer y, por lo tanto, el código es mucho más seguro. El programa está a salvo de comportamientos indefinidos. en el sentido de que no se ejecutará cuando se envíe un valor más alto antes de un valor más bajo.

Esto debería funcionar tanto en Python 2.xy 3.x; Corríjame si me equivoco, ya que no tengo acceso a ambos intérpretes debido a que mi sistema no los admite.

C ++, 98 95 93 bytes

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

Mis valores elegidos son todos 0

Perl, 79 45 41 bytes

"valor mínimo $ 10", el ejemplo tiene un mínimo de $ 00, ¿es un error tipográfico?

Aquí hay una respuesta perl bastante aburrida en 41 bytes (Era 46 y luego seguía viendo espacios, parentes que podía eludir). Toma entrada en dos líneas.

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

Los datos son una lista 04..1A

Antes era demasiado inteligente con empacar y desempacar. Sus bytes de entrada se ingresan a la vez juntos, por ejemplo, "020E" imprimirá las entradas 2a a 14a.

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

Podría intentar jugar más al golf usando todos los 0 substr, y printf'%*vX'... pues eso hace que mi respuesta sea más larga. 48 caracteres (usando una cadena de ascii '7', hexadecimal 37 como datos)

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

CJam, 22 bytes

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

Valores elegidos:

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

Pruébalo en línea

Scala, 45 bytes

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

Sin golf:

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

Usos 00a FFcomo valores, pero funciona hasta 2147483647.

C, 176 175 161 bytes

¡Ahorro de 1 byte gracias a @JonathanAllan
Ayuda masiva gracias a @Downvoter por salvarme 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++;}}

Pruébalo en línea!

Valores elegidos: 00 para todo.

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

El truco para esto es tomar dos entradas e intentar convertirlas en cadenas hexadecimales y luego convertirlas en enteros. Como no hay verificación de errores ni nada similar, comportamiento indefinido es simplemente arrojar errores y romper el programa. El usuario necesita ingresar dos entradas, sin embargo, mi compilador Eclipse CDT parece permitirme ingresar ambas en la misma línea con un espacio entre ellas.

Deben estar en el orden correcto, ya que solicitar un valor mayor antes de que un valor menor no ejecute el while bucle.

La cuestión es que tampoco hay protección contra el desbordamiento del búfer, por lo que simplemente puedo solicitar algo absurdo, como un rango de $ 0 a $ FFFF, y obtendré todo en la memoria de mi computadora desde el comienzo de la asignación de memoria para el a[44] matriz , hasta 65536 valores más tarde.

GNU sed, 209 + 1 (r flag) = 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

Pruébalo en línea!Un espacio principal está presente en la salida, espero que esté permitido.

Ejecute ejemplos:

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

Explicación: los 22 valores hexadecimales almacenados son los mismos que los del ejemplo del 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

Los índices de inicio y fin se leen en líneas separadas. La salida es una sola línea con los valores de la tabla en ese rango de índice (inclusive). La entrada no definida escribirá varias líneas de salida no vá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, 106105104 96 + 2 bytes

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

o

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

Correr con php -nr '<code>' <lowindex> <highindex>; escapar de las comillas simples en el código.
... o pruébalo en línea .

dechex interpreta la entrada como cadenas hexadecimales en la medida en que los caracteres son dígitos hexadecimales,
0 si la entrada comienza con otra cosa.

no imprime nada si el primer valor es mayor que el segundo.

valores elegidos:

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

(primeros 22 códigos ascii del código ejecutado)

o

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

con estos 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 

Conjunto 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

Desmontaje

  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

Forma una matriz en la memoria que se parece a la salida. Los valores elegidos son:

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

El usuario presiona cuatro teclas para configurar las entradas.