Sua tarefa é posicionar cada lado do teclado um contra o outro e criar dois programas, no mesmo idioma, um usando apenas as teclas do lado esquerdo de um teclado padrão que sai Pollinium milk; plump pumpkin; lollipop?e outro usando as teclas do lado direito que sai Weatherheaded sweetheart haberdasheress!.

Regras

As chaves exatas permitidas para o programa do lado esquerdo são:

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

e para o programa da direita:

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

Existem quatro chaves livres Esc( \x1b), Tab( \x09), Space( \x20) e Enter( \x0ae / ou \x0d) que podem ser usadas em uma, nenhuma ou em ambas as soluções.

Sua pontuação será a contagem total de bytes para os dois programas. Embora eu tenha usado o termo program, seus envios podem ser programas completos ou funcionar normalmente, e ambos podem ser de tipos diferentes (por exemplo, um programa completo e uma função).

Seu resultado deve incluir o texto desejado, qualquer quantidade de espaço em branco à esquerda e à direita é boa, desde que o texto exato apareça nele.

As brechas padrão são proibidas .

As soluções mais curtas em cada idioma ganham.

Perl 5 , 261 = 88 + 173 bytes

Este é um exemplo em que "as opções de idioma não contam" é um problema. A solução do lado rígido usa -p, o lado esquerdo não. Então, conta como o mesmo idioma ou não? E as opções devem vir do conjunto de caracteres esquerdo / direito?

Esquerda 88

use -M5.10.0(ou a -Epartir da linha de comando) para ativar sayNovamente discutível se essa opção deve contar como código e deve vir do lado esquerdo ou se estiver em "opções para definir a versão do idioma, não conta"

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

Experimente online!

Direita 173

Execute com a -popção (que também consiste em caracteres corretos)

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

Isso quase certamente pode ser melhorado, mas por enquanto já era difícil o suficiente para fazer algo funcionar. Não ter acesso a print, say, $_e sub{}faz com que a saída complicada

Experimente online!

Espaço em branco , 1175 1143 655 645 638 632 639 578 (293 + 285) bytes

Tinha que ser feito ..; p
Definitivamente, você pode jogar golfe enchendo a pilha invertida e imprimindo tudo no final em algum tipo de loop, mas este é apenas o meu segundo programa de espaço em branco de todos os tempos, então ainda estou para descobrir .. Edição: Golfed.

+7 bytes porque eu escrevi incorretamente pumpkincomo pumkin.. (Obrigado por perceber, @ fəˈnɛtɪk .)

Letras S(espaço), T(tabulação) e N(nova linha) adicionadas apenas como destaque.
[..._some_action]adicionado apenas como explicação.

Lado esquerdo 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]

Experimente online (apenas com espaços brutos, guias e novas linhas).

Lado direito 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]

Experimente online (apenas com espaços brutos, guias e novas linhas).

Explicação:

Primeiro constrói a pilha invertida. O envio de um número é feito da seguinte maneira:

• S no início: ativar manipulação de pilha
• S: Empurre o que segue como número para a pilha
• S/ T: Bit de sinal onde Sé positivo e Té negativo
• Alguns Te Sseguidos de N: Coloque o número como binário na pilha ( T=1e S=0).

Em seguida, ele fará um loop sobre a pilha invertida e imprimirá tudo como caracteres. Faz o seguinte:

1. Pressione 0 ( SSSN)
2. Empurre todos os números indicando os caracteres invertidos, conforme explicado acima
3. Crie um Label_0( NSSN)
   1. Duplique a parte superior da pilha ( SNS)
   2. Se este valor for 0: Salte para Label_1( NTSTN)
   3. Caso contrário: pop e imprima a parte superior da pilha como caractere ( TNSS)
   4. Ir para Label_0( NSNN)
4. Criar Label_1( NSSTN)

Isso acima é o layout padrão para os dois programas. Aqui está o log de alterações para esse layout padrão que reduziu ainda mais a contagem de bytes:

1. Todos os números são reduzidos na mesma quantidade ( no primeiro programa e no segundo) para diminuir os dígitos binários usados ​​para os números agora mais baixos e, entre as etapas 3.2 e 3.3, as duas sub-etapas a seguir são adicionadas:100 110102 101

   • Pressione 110 ( SSSTTSTTTSN) no programa 1 ou 101 ( SSSTTSSTSTN) no programa 2
   • Pop e adicione os dois principais valores da pilha, e o resultado é o novo topo da pilha ( TSSS)

2. Eu também usado SNSem alguns casos para duplicar o topo da pilha, que é usado para golf o ll, ll, eee ss.

3. Além disso, a etapa 4 (criar Label_1) foi removida completamente. Ele sairá com um erro, mas ainda produzirá tudo corretamente (o que é permitido de acordo com a meta ).

4. É possível copiar um nvalor da parte superior da pilha (com o STSíndice 0 n), que é mais curto do que criar um novo número em alguns casos.
   No primeiro programa em que fiz isso: o segundo pem pop( STSSTN(cópia 1º) é mais curto que SSSTTSSN(crie o número para 'p')), o segundo lem lol( STSSTN(cópia 1º) é mais curto que SSSTSSSN(crie o número para 'l' )), o segundo pem p p( STSSTN(cópia 1) é menor que SSSTTSSN(criar número para 'p')), o segundo pem pumlp( STSSTTN(cópia 3) é menor que SSSTTSSN(criar número para 'p')), o segundo pem pmup( STSSTSN( cópia 2º) é menor queSSSTTSSN(criar número para 'p')), o segundo mem m m( STSSTN(cópia 1º) é menor que SSSTSSTN(criar número para 'm')), o segundo iem ini( STSSTN(cópia 1º) é menor que SSSTSTN(crie número para 'i') )
   No segundo programa, isso não é feito para nenhum. A distância entre alguns é bem curta, como ereou ded, mas criar o número para 'e' ( SSTTN) ou 'd' ( SSTTSN) é menor ou igual ao da cópia 1st ( STSSTN), portanto, não pude aplicar esse truque no segundo programa para salvar bytes. NOTA: Após o passo 7 do golfe, nem todos eles se aplicam mais.

5. Nos dois programas, alterei a etapa 1 do loop de SSSN(Push 0) para SSN(Push error_value) e removi as etapas 3.1 ( SNSDuplicate) e 3.2 ( NTSTNIf 0: Exit). Agora, ele simplesmente sairá com um erro que SSNé um valor desconhecido assim que tentar acessá-lo.

6. Removido SSNcompletamente (error_value) nos dois programas. Agora ele será interrompido com o erro " Impossível executar o Infix Plus " quando tentar executar a função Adicionar sem mais nada na pilha.

7. Alterados os valores constantes de 100e 102para 110e 101respectivamente. Aqui o programa Java costumava gerar a 110constante; e aqui o programa Java usado para gerar a 101constante. Observe que agora há menos cópias usadas do que as descritas no ponto 4 acima, porque os novos valores são, em muitos casos, mais curtos que as cópias, portanto, empurrá-los novamente é mais curto.

Linguagem, esses muitos bytes

O lado esquerdo é 65721878296123796350462639500449228197646164622176218219262161264085219054330862921130017235140285847450697804123168755463678390611789188813352602373675420824698785508893489685489807676509031860196742608788337382365939621331808044899882497347443262020486908162559376082705672994569868 repetições do apersonagem, que é equivalente ao seguinte programa Brainfuck:

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

Experimente online!

O lado direito é 636605880289050800007960838028215177632402180834140124157618258152393860687206680356620669530585999501769442445842690365640523699585001167392310123764258380235064746704898152544431842440556280249638840374132783257375880144623575829131522611446544303839106505176776161206935275549421170646618266717893044911373119804737614528140 repetições do ppersonagem, que é equivalente ao seguinte programa Brainfuck:

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

Experimente online!

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

Experimente online!

'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(('&(((((

Experimente online!

Fissão , 958 + 752 = 1710 bytes

._.

Esquerda

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

Experimente online!

Direita

                                           } \} \    } \      } \    } \   } \   } \    } \   } \       } \    } \   } \ } \       } \   } \                                           } \   } \    } \    } \   } \   } \   } \} \      } \    } \    } \                                           } \ } \ } \   } \    } \   } \   } \    } \   } \   } \   } \    } \      } \ 
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

Experimente online!

OK, aqui estamos com pura sorte, na verdade ._.
O primeiro recurso interessante do Fission é que ele possui 4 comandos para criar ponteiros de comando, átomos AKA:, RLDUentão eu tenho dois comandos para grupos esquerdo e direito.
O segundo amuleto da sorte são 2 comandos de saída !e O, o que ocorre em diferentes grupos.
Terceira vez o charme. Ambos os comandos de saída emitem o equivalente ASCII da massa dos átomos. Então, eu preciso mudar de alguma forma. Sorte minha! Ambos + (+1 mass)e _ (-1 mass)estão em um grupo e todos os necessários três $ (+1 energy), ~ (-1 energy), @ (swap mass and energy)estão em outro grupo.

Também existem espelhos para controlar átomos em ambos os grupos! Mas eu não os usei no primeiro programa

Portanto, não há nada para me impedir, mas não pode ser compacto, definindo massas passo a passo.

Primeiro programa

O primeiro programa consiste em apenas 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

O início pode ser mais simples (apenas R), mas o uso da divisão salva alguns bytes para a primeira letra.
Atom, que vai para a esquerda, envolve e encontra V, o que o faz cair e se enrolar indefinidamente, sem fazer nada.
O segundo átomo vai bem e encontrará vários padrões repetidos @...@!para cada letra a ser impressa.

@   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, ele encontrará Ve compartilhará o destino do primeiro átomo. Não há como destruí-los ou parar com a parte esquerda do teclado.

Segundo programa

O segundo vem com seus altos e baixos. Eu tenho comandos para alterar a massa diretamente, mas o comando de saída Odestrói átomos, então preciso preservá-los de alguma forma.
O programa inicia à direita Lcom o átomo indo para a esquerda.

Padrão repetido:

} \
/O\...X'

'puts próxima encoutered código ASCII do caractere em massa átomos, para que o código de algum Xé armazenado em primeiro lugar, que a massa é alterado pelo _e +para o valor exato.
Às vezes X'é ignorado, se for mais curto para usar apenas _e +.

Atom vem da esquerda, espelha duas vezes e acerta }da esquerda. Nesse caso, }funciona como clonador, enviando dois átomos idênticos para cima e para baixo. O átomo abaixo reflete pelo espelho e vai para a esquerda. O átomo se envolve, atinge o mesmo espelho, mas por baixo e, portanto, reflete direito, encontro Oe impressão.
No final, o último átomo encontra o final Oa ser destruído.