Su tarea es enfrentar cada lado del teclado uno contra el otro y construir dos programas, en el mismo idioma, uno usando solo las teclas del lado izquierdo de un teclado estándar que sale Pollinium milk; plump pumpkin; lollipop?y otro usando las teclas del lado derecho que sale Weatherheaded sweetheart haberdasheress!.

Reglas

Las claves exactas permitidas para el programa de la izquierda son:

123456!@#$%^QWERTYqwertyasdfghASDFGH`zxcvb~ZXCVB

y para el programa de la derecha:

7890-=&*()_+uiop[]UIOP{}jkl;'\JKL:"|nm,./NM<>?

Hay cuatro teclas libres Esc( \x1b), Tab( \x09), Space( \x20) y Enter( \x0ay / o \x0d) que se pueden usar en cualquiera, ninguna o ambas soluciones.

Su puntaje será el recuento total de bytes para ambos programas. Si bien he usado el término program, sus envíos pueden ser programas completos o funciones como de costumbre, y ambos pueden ser de diferentes tipos (por ejemplo, un programa completo y una función).

Su resultado debe incluir el texto deseado, cualquier cantidad de espacios en blanco iniciales y finales está bien, siempre que el texto exacto aparezca dentro de él.

Las lagunas estándar están prohibidas .

Las soluciones más cortas en cada idioma ganan.

Perl 5 , 261 = 88 + 173 bytes

Este es un ejemplo donde "las opciones de idioma no cuentan" es un problema. La solución del lado rigt usa -p, el lado izquierdo no. Entonces, ¿cuenta como el mismo idioma o no? ¿Y las opciones deben provenir del conjunto de caracteres izquierdo / derecho?

Izquierda 88

use -M5.10.0(o -Edesde la línea de comandos) para activar sayDe nuevo discutible si esta opción debe contar como código y debe venir del lado izquierdo o si se encuentra en "opciones para configurar la versión del idioma no cuenta"

say eYYYYZYEYWYYYYYWQYEYQWQEYQYYZYWYYYYYQYQW^q%565504004w4052bw!504!w!04!204bw56550!6!h%

Pruébalo en línea!

Derecha 173

Ejecutar con la -popción (que también consta de caracteres correctos)

}{*_=\(uuuuuuuuuuuuuiuuuuuuuuuuiuuuuuuuuuuuuuui&Uiipjipjiijij0puiipjiipp0jijipjipjipipp7|Ouiujujjuiuuu0kouuujuiju0jijujuikjujukk7&"7oulio7iouloli77ooliou7liiu7o7lu7io7o77i")

Es casi seguro que esto se puede mejorar, pero por ahora fue bastante difícil hacer que algo funcione. No tener acceso a print, say, $_y sub{}hace que la producción complicado

Pruébalo en línea!

Espacio en blanco , 1175 1143 655 645 638 632 639 578 (293 + 285) bytes

Tenía que hacerse ..; p
Definitivamente se puede jugar al golf llenando la pila al revés e imprimiéndolo todo al final en algún tipo de bucle, pero este es solo mi segundo programa de espacios en blanco, así que todavía tengo que resolverlo .. EDITAR: Golf.

+7 bytes porque escribí mal pumpkincomo pumkin... (Gracias por notarlo, @ fəˈnɛtɪk .)

Las letras S(espacio), T(tabulación) y N(nueva línea) se agregan solo como resaltado.
[..._some_action]agregado solo como explicación.

Lado izquierdo Pollinium milk; plump pumpkin; lollipop?:

[S S T  T   S T T   T   T   N
_Push_-47_?][S S S T    S N
_Push_2_p][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_p][S S T  T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S T  S S T   N
_Copy_1st_l][S S T  T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   T   N
_Push_-3_k][S S S T S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S S T  S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S S T    S N
_Push_2_p][S S T    T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S N
_Push_-2_l][S S S T S N
_Push_2_p][S S T    T   S S T   T   T   S N
_Push_-78_space][S S T  T   T   S S T   T   N
_Push_-51_;][S S T  T   T   N
_Push_-3_k][S S T   T   S N
_Push_-2_l][S S T   T   S T N
_Push_-5_i][S S T   T   N
_Push_-1_m][S S T   T   S S T   T   T   S N
_Push_-78_space][S S T  T   N
_Push_-1_m][S S S T T   T   N
_Push_7_u][S S T    T   S T N
_Push_-5_i][S S S N
_Push_0_n][S S T    T   S T N
_Push_-5_i][S S T   T   S N
_Push_-2_l][S N
S _Duplicate_-2_l][S S S T  N
_Push_1_o][S S T    T   T   T   T   S N
_Push_-30_P][N
S S N
_Create_Label_LOOP][S S S T T   S T T   T   S N
_Push_110][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Lado derecho Weatherheaded sweetheart haberdasheress!:

[S S T  T   S S S T S S N
_Push_-68_!][S S S T    T   T   S N
_Push_14_s][S N
S _Duplicate_14_s][S S S N
_Push_0_e][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   S N
_Push_14_s][S S T   T   S S N
_Push_-4_a][S S T   T   N
_Push_-1_d][S S S T T   S T N
_Push_13_r][S S S N
_Push_0_e][S S T    T   T   N
_Push_-3_b][S S T   T   S S N
_Push_-4_a][S S S T T   N
_Push_3_h][S S T    T   S S S T S T N
_Push_-69_space][S S S T    T   T   T   N
_Push_15_t][S S S T T   S T N
_Push_13_r][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S S N
_Push_0_e][S N
S _Duplicate_0_e][S S S T   S S T   S N
_Push_18_w][S S S T T   T   S N
_Push_14_s][S S T   T   S S S T S T N
_Push_-69_space][S S T  T   N
_Push_-1_d][S S S N
_Push_0_e][S S T    T   N
_Push_-1_d][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   S T N
_Push_13_r][S S S N
_Push_0_e][S S S T  T   N
_Push_3_h][S S S T  T   T   T   N
_Push_15_t][S S T   T   S S N
_Push_-4_a][S S S N
_Push_0_e][S S T    T   T   T   S N
_Push_-14_W][N
S S N
_Create_Label_LOOP][S S S T T   S S T   S T N
_Push_101][T    S S S _Add][T   N
S S _Print_as_char][N
S N
N
_Jump_to_Label_LOOP]

Pruébelo en línea (solo con espacios en bruto, pestañas y nuevas líneas).

Explicación:

Primero construye la pila invertida. Empujar un número se realiza de la siguiente manera:

• S al principio: Habilite la manipulación de la pila
• S: Empuje lo que sigue como número a la pila
• S/ T: Bit de signo donde Ses positivo y Tnegativo
• Algunos Ty Sseguidos de un N: Ponga el número como binario en la pila ( T=1y S=0).

Luego recorrerá la pila invertida e imprimirá todo como caracteres. Hace esto de la siguiente manera:

1. Empuje 0 ( SSSN)
2. Presione todos los números que indican los caracteres invertidos como se explicó anteriormente
3. Crear un Label_0( NSSN)
   1. Duplicar la parte superior de la pila ( SNS)
   2. Si este valor es 0: salta a Label_1( NTSTN)
   3. De lo contrario: Pop e imprime la parte superior de la pila como personaje ( TNSS)
   4. Saltar a Label_0( NSNN)
4. Crear Label_1( NSSTN)

Este es el diseño predeterminado para ambos programas. Aquí está el registro de cambios para este diseño predeterminado que redujo aún más el recuento de bytes:

1. Todos los números se reducen en la misma cantidad ( en el primer programa y en el segundo) para disminuir los dígitos binarios utilizados para los números ahora más bajos, y entre los pasos 3.2 y 3.3 se agregan los siguientes dos subpasos:100 110102 101

   • Presione 110 ( SSSTTSTTTSN) en el programa 1 o 101 ( SSSTTSSTSTN) en el programa 2
   • Pop y agregue los dos valores superiores de la pila entre sí, y el resultado es la nueva parte superior de la pila ( TSSS)

2. También he utilizado SNSen algunos casos para duplicar la parte superior de la pila, que se utiliza para el campo ll, ll, eey ss.

3. Además, el paso 4 (crear Label_1) se eliminó por completo. Saldrá con un error, pero aún generará todo correctamente (lo cual está permitido según el meta ).

4. Es posible copiar un nvalor 'th desde la parte superior de la pila (con STS+ 0 indexado n), que en algunos casos es más corto que crear un nuevo número.
   En el primer programa para el que hice esto: el segundo pen pop( STSSTN(copia 1) es más corto que SSSTTSSN(crear número para 'p')), el segundo len lol( STSSTN(copia 1) es más corto que SSSTSSSN(crear número para 'l' )), el segundo pen p p( STSSTN(copia 1er) es más corto que SSSTTSSN(crear número para 'p')), el segundo pen pumlp( STSSTTN(copia 3ro) es más corto que SSSTTSSN(crear número para 'p')), el segundo pen pmup( STSSTSN( copia 2) es más corto queSSSTTSSN(cree el número para 'p')), el segundo men m m( STSSTN(copia 1) es más corto que SSSTSSTN(cree el número para 'm')), el segundo ien ini( STSSTN(copia 1) es más corto que SSSTSTN(cree el número para 'i') )
   En el segundo programa esto no se hace para ninguno. La distancia entre algunos es bastante corta, como ereo ded, pero crear el número para 'e' ( SSTTN) o 'd' ( SSTTSN) es más corto o de la misma longitud que la copia 1st ( STSSTN), por lo que no pude aplicar este truco en el segundo programa para guardar bytes. NOTA: Después del paso de golf 7, ya no se aplican todos estos.

5. En ambos programas, cambié el paso 1 del bucle de SSSN(Push 0) a SSN(Push error_value), y eliminé los pasos 3.1 ( SNSDuplicar) y 3.2 ( NTSTNSi 0: Salir). Ahora simplemente saldrá con un error que SSNes un valor desconocido tan pronto como intente acceder a él.

6. Se eliminó el SSN(error_value) completamente en ambos programas. Ahora se detendrá con el error " No se puede hacer Infix Plus " cuando intenta hacer la función Agregar sin dejar nada en la pila.

7. Cambió los valores constantes de 100y 102hacia 110y 101respectivamente. Aquí el programa Java solía generar la 110constante; y aquí el programa Java solía generar la 101constante. Tenga en cuenta que ahora se usa menos Copia que la descrita en el punto 4 anterior, porque los nuevos valores son en muchos casos más cortos que las copias, por lo que volver a empujarlos es más corto.

Lenguage, esta cantidad de bytes

El lado izquierdo es 65721878296123796350462639500449228197646164622176218219262161264085219054330862921130017235140285847450697804123168755463678390611789188813352602373675420824698785508893489685489807676509031860196742608788337382365939621331808044899882497347443262020486908162559376082705672994569868 repeticiones del acarácter, que es equivalente al siguiente programa Brainfuck:

-[--->+<]>-----.[--->+<]>-.---..---.+++++.-----.++++++++++++.--------.[->+++++<]>-.+[----->+<]>.----.+++.-.--[->+++<]>.+[-->+<]>++.[-->+++++++<]>.----.+++++++++.--------.+++.[------->++<]>.[-->+++++++<]>.+++++.--------.+++.-----.--.+++++.[-->+<]>++++.+[-->+<]>++.++[--->++<]>.+++.---..---.+++++++.-.+.[--->++++<]>-.

Pruébalo en línea!

El lado derecho es 636605880289050800007960838028215177632402180834140124157618258152393860687206680356620669530585999501769442445842690365640523699585001167392310123764258380235064746704898152544431842440556280249638840374132783257375880144623575829131522611446544303839106505176776161206935275549421170646618266717893044911373119804737614528140 repeticiones del pcarácter, que es equivalente al siguiente programa Brainfuck:

+[--->++<]>+.++[->++++<]>+.----.--[--->+<]>-.------------.---.+++++++++++++.----------.---.----.+++.+.-.-[--->+<]>-.---[->++++<]>-.++++.[->+++<]>..[--->+<]>---.------------.---.----.--[--->+<]>---.++.[---->+<]>+++.-[--->++<]>--.-------.+.+++.+++++++++++++.--------------.---.--[--->+<]>--.-----------.---.+++++++++++++.-------------.[--->+<]>----..+[-->+++++<]>-.

Pruébalo en línea!

CJam , 128 + 192 = 320 bytes

64G^c111c111Z^cT$111c6^111X^c1$116X^c111Y^c32c1$6$Y3#$111c4^56Z^c32c112c13$A$A$3$5$1$4$4$4$12$22$22$14$32c13$111c1$T$7$A$4$1$63c

Pruébalo en línea!

'U))'i(((('_))'u('i('i(((('p))'i('i(((('_))'_)))))'i(((('_)))))'&(((((('u(('u))'i(((('i(((('u('i('i(((('_))'p))'u('&(((((('i('_))'_)))'i(((('p))'_)))))'_))'u(('i('i(((('p))'i(((('u(('u(('&(((((

Pruébalo en línea!

Fisión , 958 + 752 = 1710 bytes

._.

Izquierda

D
z
^@$$$$$$$$$$$$$$$$$$$@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~@!!@~~~@!@$$$$$@!@~~~~~@!@$$$$$$$$$$$$@!@~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$@!@~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@~~~~@!@$$$$$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$$$@!@~~~~~~~~@!@$$$@!@~~~~~@!@~~@!@$$$$$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~@!@$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$@!@$$$@!@~~~@!!@~~~@!@$$$$$$$@!@~@!@$@!@~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@!V

Pruébalo en línea!

Correcto

                                           } \} \    } \      } \    } \   } \   } \    } \   } \       } \    } \   } \ } \       } \   } \                                           } \   } \    } \    } \   } \   } \   } \} \      } \    } \    } \                                           } \ } \ } \   } \    } \   } \   } \    } \   } \   } \   } \    } \      } \ 
O________________________________________I'/O\/O\__u'/O\____i'/O\++p'/O\___/O\_i'/O\__u'/O\___/O\_____i'/O\++p'/O\+++/O\+/O\_______/O\_i'/O\_________________________________________I'/O\_u'/O\++p'/O\____/O\___/O\_i'/O\_u'/O\/O\____i'/O\++u'/O\__u'/O\_________________________________________I'/O\_/O\+/O\+++/O\____/O\___/O\_i'/O\++p'/O\___/O\_i'/O\_u'/O\____/O\____i'/O\+++++++P'L

Pruébalo en línea!

OK, aquí estamos con suerte, en realidad ._.
La primera característica interesante de Fission es que tiene 4 comandos para crear punteros de comando, átomos de AKA: RLDUasí que tengo dos comandos para los grupos izquierdo y derecho.
El segundo amuleto de la suerte es de 2 comandos para la salida !y O, que se produce en diferentes grupos.
Tercera vez el encanto. Ambos comandos de salida generan el equivalente ASCII de la masa de los átomos. Entonces necesito cambiarlo de alguna manera. ¡Suerte la mía! Tanto + (+1 mass)y _ (-1 mass)están en un grupo y los tres necesarios $ (+1 energy), ~ (-1 energy), @ (swap mass and energy)están en otro grupo.

¡También hay espejos para controlar átomos en ambos grupos! Pero no los usé en el primer programa

Así que no hay nada que me detenga, pero no puede ser compacto, estableciendo masas paso a paso.

Primer programa

El primer programa consiste solo en Dz^@$~!V

D   create atom, going down
z   set its mass to ASCII code of 'z'
^   split atom in 2, dividing their mass. One goes left, second - right

El inicio puede ser más simple (solo R), pero el uso de dividir guarda algunos bytes para la primera letra.
Atom, eso va a la izquierda, se envuelve y se encuentra V, lo que lo hace bajar y envolverse indefinidamente, sin hacer nada.
El segundo átomo va derecho y encontrará un montón de patrones repetidos @...@!para cada letra que salga.

@   swap atom's mass and energy
... increament or decrement energy until it would match desired ASCII code
@   swap again
!   print character by atoms mass

Eventualmente se encontrará Vy compartirá el destino del primer átomo. No hay forma de destruirlos o detenerlos con la parte izquierda del teclado.

Segundo programa

El segundo viene con sus altibajos. Tengo comandos para cambiar la masa directamente, pero el comando de salida Odestruye los átomos, así que necesito preservarlos de alguna manera.
El programa comienza a la derecha desde el Látomo hacia la izquierda.

Patrón repetido:

} \
/O\...X'

'pone el siguiente código ASCII de char en la masa de los átomos, por lo que el código de algunos Xse almacena primero, que la masa se cambia por _y +al valor exacto.
A veces X'se omite, si es más corto de usar solo _y +.

El átomo viene de la izquierda, refleja dos veces y golpea }desde la izquierda. En este caso }funciona como clonador, enviando dos átomos idénticos hacia arriba y hacia abajo. El átomo de abajo se refleja en el espejo y se va hacia la izquierda. Envolturas de átomos, golpea el mismo espejo pero desde abajo y así se refleja bien, encuentro Oe impresión.
Al final, el último átomo se encuentra con el final Opara ser destruido.