El monitor de Woz

17

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

Finn Rayment
fuente
¿Estamos pidiendo al usuario dos entradas o n? ¿Elegimos cuáles son los 22 valores hexadecimales?
xnor
Sí, los 22 valores son tuyos para decidir. Los valores de entrada, pueden ser cualquier cantidad. Dije que ndebido a que Brainfuck no puede tomar una cadena de 2 caracteres, necesitará ingresar el primer byte, luego el segundo para el primer valor y luego volver a hacerlo para el segundo valor, 4 entradas en total. Pueden ser tantos como quieras.
Finn Rayment
Sin embargo, con los valores, no puede simplemente tenerlos todos como 00, y hacer que un programa imite lo que realmente leería las matrices. Actualizando la pregunta.
Finn Rayment
¿Debería ajustarse o leerse en reversa si la entrada 2 es menor que la entrada 1?
Jonathan Allan
@ JonathanAllan Eso depende totalmente de usted. Solo recuerde, asegurarse de que las entradas sean correctas puede hacer que su código sea más grande. Como está escrito justo arriba de las reglas, puede permitir cualquier forma de entrada (depende de usted), lo que lleva a un comportamiento indefinido o errores si lo desea.
Finn Rayment

Respuestas:

4

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
Jonathan Allan
fuente
Ah, perdóname. De hecho estabas en lo correcto. Bien hecho, y tener la posición de clasificación # 1. :)
Finn Rayment
1
Sí, simplemente me moví y cambié el valor de un desplazamiento (ahora 1F), lo que significa que no necesitaba interpretar "correctamente" las entradas hexadecimales o agregar 16 para darme dos dígitos hexadecimales para volver a convertir.
Jonathan Allan
4

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
Arnauld
fuente
"message": "SyntaxError no capturado: objetivo de asignación de desestructuración no válido"
Finn Rayment
@frayment - Esto es Chrome, ¿verdad? Eso es extraño porque no se queja [a,b]=prompt().split(' ')en la línea de comando. De todos modos, mi respuesta actualizada debería arreglar eso.
Arnauld
¡Bien hecho! Funciona ahora. Es raro que Chrome lo haga. Lo probé en su probador JS y en mi consola de desarrollador. Mismo error. Bienvenido a la tabla de clasificación.
Finn Rayment
Podría guardar algunos bytes con entradas como 0x04
Hedi
1
Amigo, no hay nada malo con tu alternativa, funciona bien aquí y está dentro de las reglas. Actualiza tu publicación! :)
Finn Rayment
3

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

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):'')
Hedi
fuente
1
¡Cerca! Pero debe poder pedirle al usuario su opinión. Aunque me gusta lo que hiciste console.log(...). ;)
Finn Rayment
@frayment var y el último ;no son parte de la respuesta. Es solo para el fragmento, es por eso que agregué linebreak. Editaré la respuesta.
Hedi
Mi mala @Hedi, perdón por eso.
Finn Rayment
2

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.

Finn Rayment
fuente
2

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

Fatih BAKIR
fuente
¡Bienvenido a Programming Puzzles & Code Golf! Esta es una respuesta bien desarrollada, pero no creo que cumpla con los requisitos del desafío. ¿Le importaría incluir sus 22 valores hexadecimales elegidos?
ETHproductions
¡Cerca de allí! El único problema es que cuando ingresé valores 04y 06solo recuperé dos valores. Sospecho que estos son los valores 05y 06. Debe proporcionar todos los valores entre e incluidos los valores ingresados.
Finn Rayment
1
@frayment, oh, es cierto, lo arregló!
Fatih BAKIR
1

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
Yary
fuente
1

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

Neorej
fuente
1

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.

corvus_192
fuente
error: ')' expected but string literal found.a lasa.to(b).map(
Finn Rayment
No sé si soy solo yo o qué. : / ¿En qué debería intentar ejecutarlo?
Finn Rayment
@frayment que probablemente se deba a la interpolación de cadenas, que se introdujo en Scala 2.10.0
corvus_192
Entonces, ¿en qué versión construiste esto? 2.9?
Finn Rayment
@frayment Usé el 2.11.7 REPL
corvus_192
1

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.

Finn Rayment
fuente
Un solo carácter de espacio en blanco en el formato de entrada coincide con cualquier cantidad de espacio en blanco en la secuencia de entrada, aunque la mayoría de los formatos scanf omiten espacios en blanco de todos modos, hablando de eso, ¿por qué no cortar el intermediario y usarlo %xdirectamente?
Neil
¿Por qué no usar en char s[2]lugar de las malloccosas? El mallocvalor de retorno de la conversión no es necesario en C de todos modos.
cadaniluk
@Neil Si está hablando de la printf("%d%d ", ...)parte, al reemplazar el formato con simplemente %xdevuelve 0's en lugar de 00' s, y no los espacia.
Finn Rayment
@Downvoter Muchas gracias! No pensé en eso. Editando respuesta ahora.
Finn Rayment
No, todavía estoy hablando de la scanf.
Neil
1

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
seshoumara
fuente
1

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 
Tito
fuente
¿Las respuestas normalmente incorporan el <?phpfragmento?
Finn Rayment el
@frayment no si lo usas -r. Y si necesito almacenarlo en un archivo, uso la etiqueta abierta corta <?.
Titus
Constantes a, zy ProgramingPuzles_CGolfson indefinidos. ¿De dónde ProgramingPuzles_CGolfvino de todos modos? : /
Finn Rayment
@frayment Esos son avisos. El redireccionamiento stderra /dev/nullsi no te gusta ellos. PHP evalúa las constantes indefinidas en cadenas.
Titus
Pero aparecen como errores de sintaxis, no puedo ejecutar el programa.
Finn Rayment
1

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.

Peter Ferrie
fuente
Oooo usando el código propio de las manzanas. Muy bien hecho.
Finn Rayment