¡Analicemos y procesemos Key-Language! Dada la entrada de una secuencia de pulsaciones de teclas del teclado y / o teclas especiales, escriba un programa, función, etc. que genere el producto cuando todas las acciones se procesen según el siguiente teclado:
+-------------------------------------------------------+
| ~ | ! | @ | # | $ | % | ^ | & | * | ( | ) | - | + | |
| ` | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 0 | _ | = |Del|
+-------------------------------------------------------+
|TAB| q | w | e | r | t | y | u | i | o | p | [ | ] | \ |
| | Q | W | E | R | T | Y | U | I | O | P | { | } | | |
+-------------------------------------------------------+
|CAPS | a | s | d | f | g | h | j | k | l | ; | ' | RET |
| | A | S | D | F | G | H | J | K | L | : | " | |
+-------------------------------------------------------+
| SHIFT | z | x | c | v | b | n | m | , | . | / | SHIFT |
| | Z | X | C | V | B | N | M | < | > | ? | |
+-------------------------------------------------------+
| |
| SPACEBAR |
+-------------------------------------------------------+
Las claves que los personajes reales de salida no que consta de espacios en blanco y son capaces de ser modificados por otras teclas serán conocidos como "teclas de caracteres", y los que modifican la producción de otras llaves o salida de los espacios en blanco serán conocidos como "claves especiales". Las teclas de caracteres del alfabeto, que se mostrarán en la entrada con letras mayúsculas, se pueden modificar con Shift
o Caps Lock
para producir letras mayúsculas, y el resto de las teclas de caracteres solo se pueden modificar Shift
para producir sus caracteres alternativos. Por lo tanto, A
en la entrada corresponde a la a A
tecla de caracteres, cuya salida normal es , que corresponde a la tecla de caracteres, tiene una salida normal de y una salida modificada dea
y cuya salida modificada, que se puede obtener con la tecla Shift
o Caps Lock
, es A
. Por otra parte,/
/ ?
/
?
obtenible solo con Shift
este tiempo.
Reglas
La entrada siempre será una cadena que consta de una secuencia de teclas de caracteres y teclas especiales. La asignación especial de clave a cadena para la entrada (es decir, el formato que se garantiza que estén en la entrada) y sus acciones / salidas correspondientes son las siguientes:
<DEL> -> Delete the previous character (including whitespace). If called when string is empty, nothing happens. If called 2 or more times in a row, 2 consecutive deletes happen. For instance, "RE<DEL><DEL>" should return an empty string ("") and also "R<RET><DEL><DEL>E" should return just "E".
<CAPS> -> Enable Caps Lock until <CAPS> appears again, upon which it is disabled, although it is not guaranteed to be disabled by the end of the input. Enabling this only modifies the upcoming alphabet keys resulting in them outputting only uppercase letters. For instance, "<CAPS>RE<CAPS>" results in the output "RE", but <CAPS>.<CAPS> would still result in a ".".
<RET> -> Add a new line.
<SPC> -> Add a single blank space.
<TAB> -> Add 4 spaces.
<SHFT> -> Shift is held down resulting in the alternate character of the upcoming keypress to be output, after which the key is released. For instance, "<SHFT>A" results in the output "A", "<SHFT>1" results in the output "!", and "<SHFT>1234" results in the output "!234" as only the first upcoming keypress is modified and nothing else. It is guaranteed that a character key will succeed a <SHFT>. Therefore, <SHFT><SPC> is not a possible input.
Una cadena vacía también es posible como entrada, para la cual la salida no debería ser nada.
- El uso de cualquier incorporado que resuelva este problema directamente no está permitido.
- No se permite el uso de lagunas estándar.
Casos de prueba
Presentado en el formato Actual String Input -> Actual String Output
seguido de una explicación para algunos.
1<SHFT>2<TAB><CAPS>R.KAP.<SPC><SHFT>123 -> 1@ R.KAP. !23
La salida se presiona sin presionar
1
la1
tecla, luego se mantiene presionada la2
tecla Mayús y se presiona la tecla, lo que da como resultado la@
salida. Luego se suelta la tecla Mayús y se presiona Tab, lo que resulta en una sangría de 4 espacios. Seguimiento, las tapas se pulsa la tecla de bloqueo, después de lo cual elR
,.
,K
,A
,P
, y.
se pulsan las teclas, lo que resulta en la salidaR.KAP.
. Finalmente, un único espacio se salida seguido por cambio resultante en!23
ser de salida cuando el1
,2
y3
se pulsan las teclas en el extremo.<SHFT>ABCDEFG<SHFT>HIJK<SHFT>1<SHFT>2<SHFT>3<SHFT>4567890 -> AbcdefgHijk!@#$567890
La tecla Shift se mantiene presionada seguida de la
A
tecla, lo que da como resultado la salidaA
seguida de la salidabcdefg
cuandoB-G
se presionan las teclas. Luego, la tecla Shift se mantiene presionada nuevamente por laH
tecla, después de lo cual se muestra la salidaH
, seguido deijk
cuandoI-K
se presionan las teclas. Finalmente, todas las1-4
teclas se modifican a medida que se mantiene presionada la tecla shift antes de cada pulsación de tecla, lo que da como resultado la salida!@#$
finalizada567890
cuando se5-0
presionan las teclas.<CAPS>THIS<SPC>IS<SPC>IN<SPC>ALL<SPC>CAPS<CAPS><SPC>NOW<SPC>THIS<SPC>IS<SPC>IN<SPC>ALL<SPC>LOWERCASE -> THIS IS IN ALL CAPS now this is in all lowercase
<TAB><SPC><TAB><SHFT>1 -> !
<CAPS>WWW<CAPS>.CODEGOLF.STACKEXCHANGE<SHFT>.COM -> WWW.codegolf.stackexchange>com
PROGRAMMING<CAPS><SPC>IS<SPC><CAPS>AWESOME -> programming IS awesome
<DEL><RET><DEL><RET><DEL> -> "" (Empty String)
La tecla Eliminar se presiona al principio, después de lo cual no sucede nada. Luego, se presiona la tecla Retorno, lo que da como resultado una nueva línea, que se elimina después de presionar nuevamente la tecla de retroceso. Finalmente, se repite la misma secuencia (nueva línea seguida de retroceso). Después de todo esto, la salida es una cadena vacía.
<SHFT>HI<SPC>HOW<SPC>ARE<SPC>YOU<SHFT>/<RET><SHFT>I<SPC><SHFT>AM<SPC>O<DEL><SHFT>GOOD<SHFT>1 -> Hi how are you?\nI Am Good!
<SHFT>,<CAPS>RET<CAPS><SHFT>. -> <RET>
La cadena
<RET>
debe ser la salida real de la cadena. Por lo tanto, esto no debería generar una nueva línea.<CAPS>67890,.;'[]<CAPS> -> 67890,.;'[]
<CAPS><SHFT>A -> A
RE<DEL><DEL> -> "" (Empty String)
U<RET><DEL><DEL>I -> i
<DEL><DEL><DEL>5<DEL> -> "" (Empty string)
"" (Empty String) -> "" (Empty String)
¡Esto es codegolf, por lo que gana el código más corto en bytes!
AbcdefgHijk!@#$567890
? Además, en la prueba # 8, se<SHFT>
encuentra al final de la cadena, pero las reglas establecen: "Se garantiza que una clave de caracteres tendrá éxito como <SHFT>".Respuestas:
Código de máquina x86 de 16 bits,
140139 bytesSe guardó 1 byte al reemplazar DL con DX en el penúltimo código de operación. También se corrigieron las compensaciones de salto en el desmontaje para que coincida con el volcado hexadecimal.
Dado que la naturaleza de la tarea requiere algunos datos preinicializados, y la respuesta no es un programa completo sino una función, supongo que hay una sección de datos en el programa y el vinculador actualiza rápidamente la dirección de los datos. El marcador de posición de la dirección se indica con '????'.
Esta es una representación hexadecimal del código. Los parámetros son puntero a la cadena de entrada en SI y puntero al búfer de salida en DI. Se supone que las cadenas están terminadas en NULL.
Contenido de la tabla de mapeo (25 bytes):
El recuento de bytes representa tanto el código como los datos.
Desmontaje
Para el conjunto de instrucciones de 32 bits, el código es absolutamente el mismo, excepto para la primera instrucción que es 2 bytes más larga debido al direccionamiento de 32 bits (8d1d ???????? lea ebx, ds: ??????? ?)
fuente
i
para el caso de pruebaU<RET><DEL><DEL>I
y una cadena vacía para la entradaRE<DEL><DEL>
? Aclaré un poco las reglas con respecto a la clave de eliminación, así que si esos 2 casos de prueba no funcionan, ¿podría actualizar también su código para que produzca la salida correcta para esos casos de prueba? ¡Gracias!Retina, 136 bytes
Probablemente se pueda jugar más al golf.
Verifique todos los casos de prueba. (Ligeramente modificado para ejecutar todos los casos de prueba a la vez).
fuente
Caps+Shift+A = A
. Hombre, mi teclado es raro ...JavaScript (ES6), 207
Actualizado para corregir el error con eliminaciones repetidas, incluso algunos bytes más cortos.
menos golf
Prueba
fuente
I
para el caso de pruebaU<RET><DEL><DEL>I
y una cadena vacía para la entradaRE<DEL><DEL>
? Aclaré un poco las reglas con respecto a la clave de eliminación, así que si esos 2 casos de prueba no funcionan, ¿podría actualizar también su código para que produzca la salida correcta para esos casos de prueba? ¡Gracias!U<RET><DEL>I
quei
no debería darI