Dados os 95 caracteres imprimíveis em ASCII mais a nova linha, divida-os em dois grupos iguais de 48 caracteres (a seguir denominados grupo A e grupo B). Crie um mapeamento individual de sua escolha (você tem total discrição) entre os dois grupos. Em outras palavras, Apode mapear ae vice-versa, mas Atambém pode mapear >e vice-versa, se é isso que você precisa para o seu programa.

Depois de dividir o ASCII em dois grupos, escreva dois programas e / ou funções, usando apenas os caracteres de cada grupo, respectivamente. Em outras palavras, escreva um programa / função que use apenas os caracteres do grupo A e outro programa / função que use apenas os caracteres do grupo B.

Esses programas devem poder receber um caractere como entrada. O programa escrito com os caracteres do Grupo A deve gerar / retornar o mesmo caractere se a entrada for um caractere do grupo A e o caractere do grupo A mapeado se receber um caractere do grupo B; o programa do grupo A deve sempre gerar um caractere do grupo A. Da mesma forma, o programa do Grupo B deve exibir o mesmo caractere se for um caractere do grupo B e o caractere do grupo B mapeado se a entrada for um caractere do grupo A.

Isso pode não ser tão claro, então aqui está um exemplo. Se você presumir que todas as letras maiúsculas estão no grupo A e todas as letras minúsculas no grupo B e você escolheu que o mapeamento um para um dessas letras seja de uma para a outra, então: aqui estão alguns entradas / saídas de amostra:

Programa A:

Input    Output
A        A
D        D
a        A
q        Q

Programa B:

Input    Output
A        a
D        d
a        a
q        q

Outras regras:

• Os dois programas não precisam estar no mesmo idioma.
• Eles não precisam ser os dois programas ou as duas funções; um poderia ser um programa, o outro uma função, tudo bem.
• Eles não precisam trabalhar da mesma maneira, ter comprimento semelhante, algo assim; eles simplesmente precisam cumprir as outras regras acima.
• Sim, apenas um dos seus programas pode usar novas linhas e apenas um pode usar espaços (pode ser o mesmo ou um programa diferente).
• Você não precisa usar todos os 48 caracteres em cada programa.

As brechas padrão são proibidas, como de costume. Todos os programas devem ser independentes, sem arquivos que contenham o mapeamento escolhido.

Critérios de pontuação: código-golfe . Especificamente, a soma dos bytes do texto dos dois programas.

Poste sua resposta assim:

Idioma - # bytes + Idioma - # bytes = # bytes

Uma descrição inequívoca do seu mapeamento. Se for complicado, use um gráfico como este:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

Ou, você pode apenas explicá-lo (primeiros 48 mapas para os últimos 48 em sequência), seguido por sua resposta normalmente.

CJam - 11 bytes + CJam - 25 bytes = 36 bytes

Os caracteres são selecionados em grupos alternados de 16:

 !"#$%&'()*+,-./@ABCDEFGHIJKLMNO`abcdefghijklmno
0123456789:;<=>?PQRSTUVWXYZ[\]^_pqrstuvwxyz{|}~\n

É legal que alguns dos mapeamentos possam ser obtidos com a tecla shift :)

Programa A:

lL,H-f&'o+c

Experimente online

Programa B:

q_S<\_0=16|_127<\S0=42^??

Experimente online

Explicação:

Programa A:

l      read a line from the input, this is a 1-character string
        or the empty string if the input was a newline
L,     get the length of an empty string/array (0)
H-     subtract 17, obtaining -17 (~16)
f&     bitwise-"and" each character (based on the ASCII code) with -17
'o+    append the 'o' character
c      convert to (first) character
        the result is the "and"-ed character, or 'o' for newline

Programa B:

q_       read the whole input and duplicate it
S<\      compare with " " and move the result before the input
_0=      duplicate the input again, and get the first (only) character
16|      bitwise-"or" with 16 (based on the ASCII code)
_127<    duplicate and compare (its ASCII code) with 127
\        move the result before the "or"-ed character
S0=      get the space character (first character of the space string)
42^      xor with 42, obtaining a newline character
          stack: (input<" ") (input) ("or"-ed char<127) ("or"-ed char) (newline)
?        if the "or"-ed character is less than 127, use the "or"-ed character
          else use the newline character
?        if the input was smaller than space (i.e. it was a newline),
          use the input, else use the character from the previous step

CJam - 46 44 26 11 bytes + GolfScript - 142 125 115 93 68 47 40 36 bytes = 47 bytes

Agradecemos a Peter Taylor por jogar 6 bytes fora do programa GolfScript (e abrir caminho para muitos outros).

Agradecimentos a Dennis por jogar 15 bytes fora do programa CJam e 4 bytes fora do programa GolfScript.

Grupo A: todos os caracteres com código de caracteres pares.
Grupo B: todos os caracteres com código de caracteres ímpares, além de nova linha.

Estou usando o mapeamento óbvio entre os dois, ou seja, emparelhe os caracteres que diferem apenas no bit menos significativo, além de ~e \n. Aqui está o mapa completo (as colunas):

 "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

Programa A (CJam, teste aqui ):

lX~f&"~"|X<

Programa B (GolfScript, teste aqui ):

{1}'{-'{)}%'115)%11-[9)ie'9/{))}%++%

Explicação

Programa A

(Desatualizado, será atualizado amanhã.)

Este programa deve transformar códigos de caracteres ímpares em pares, ou seja, definir o bit menos significativo como 0. A maneira óbvia de fazer isso é AND bit a bit com 126 (ou 254 etc.), mas é mais curto configurá-lo como 1 (via OR bit a bit com 1) em vez disso e, em seguida, diminua o resultado. Por fim, precisamos corrigir as novas linhas manualmente:

"r"(  e# Push the string "r" and pull out the character.
(~    e# Decrement to q and eval to read input.
(     e# Pull out the character from the input string.
2(|(  e# (input OR (2-1))-1 == input AND 126
0$    e# Copy the result.
N&    e# Set intersection with a string containing a newline.
"~"   e# Push "~".
"@@"( e# Push "@@" and pull out one @.
(|    e# Decrement to ?, set union with the other string to give "@?".
~     e# Eval to select either the computed character or "~" if it was a newline.

Programa B

(Desatualizado, será atualizado amanhã.)

Este programa pode simplesmente definir o bit menos significativo como 1 via OR bit a bit com 1 agora. Mas ele deve verificar os dois \v(código de caractere 0x0B) e <DEL>(código de caractere 0xFF) manualmente e defini-los como ~alternativa. No GolfScript, eu não tinha acesso ao eval, mas você pode adicionar uma string a um bloco (que se torna parte do código desse bloco), que eu poderia mapear na entrada com %:

{1}    # Push this block without executing it.
'{--'  # Push this string.
{)}%   # Increment each character to get '|..'.
')1)7?=[11=+9)?ie'
       # Push another string...
7/     # Split it into chunks of 7: [')1)7?=[' '11=+9)?' 'ie']
{))}%  # For each chunk, split off the last character and increment it.
+      # Add the array to the string, flattening the array: '|..)1)7?=\11=+9)@if'
+      # Add it to the block: {1|..)1)7?=\11=+9)@if}
%      # Map the block onto the input, i.e. apply it to the single character.

E quanto ao código gerado no bloco:

1|..   # Bitwise OR with 1, make two copies.
)1)7?= # Check if the result is one less than 2^7 == 128 (i.e. if it's <DEL>).
\11=   # Check with the other copy if it's equal to 11 (i.e. if it's \v).
+      # Add them to get something truthy either way.
9)     # Push a 10 (i.e. \n).
@      # Pull up the original value.
if     # Select the correct result.

Java - 1088 bytes + Java - 1144 bytes = 2232 bytes

Obrigado a @ durron597 por ajudar a obter 1090 bytes de golfe a partir do primeiro programa.

Prova de que é possível fazer em um idioma (e não um esolang nesse idioma).

Use o truque unicode para converter o primeiro em todos os caracteres unicode. O segundo utiliza reflexão para obter acesso ao System.out para imprimir em std. Fora. Não foi possível usar o u porque foi usado no primeiro programa. Eu sei que isso pode ser mais eficaz, mas eu queria publicar uma solução válida primeiro.

Os grupos são mapeados de maneira arbitrária, mas basicamente o primeiro exigia apenas u, \ e os dígitos hexadecimais (em qualquer caso).

Os grupos:

!#7$&89'0123456>fB@UXZ\^AKCDEGH_JL`NOkQRxzVWYu~\n
 "%()*+,-./:;<=?FIMPST[]abcdeghijlmnopqrstvwy{|}

Primeiro programa:

\u0076\u006F\u0069\u0064
k\u0028\u0069\u006E\u0074
x\u0029\u007B\u0069\u006E\u0074\u005B\u005Du\u003D\u007B33\u002C33\u002C35\u002C35\u002C36\u002C55\u002C38\u002C39\u002C36\u002C38\u002C56\u002C57\u002C39\u002C48\u002C49\u002C50\u002C48\u002C49\u002C50\u002C51\u002C52\u002C53\u002C54\u002C55\u002C56\u002C57\u002C51\u002C52\u002C53\u002C54\u002C62\u002C62\u002C64\u002C65\u002C66\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C66\u002C74\u002C75\u002C76\u002C64\u002C78\u002C79\u002C85\u002C81\u002C82\u002C88\u002C90\u002C85\u002C86\u002C87\u002C88\u002C89\u002C90\u002C92\u002C92\u002C94\u002C94\u002C95\u002C96\u002C65\u002C75\u002C67\u002C68\u002C69\u002C102\u002C71\u002C72\u002C95\u002C74\u002C107\u002C76\u002C96\u002C78\u002C79\u002C107\u002C81\u002C82\u002C120\u002C122\u002C117\u002C86\u002C87\u002C120\u002C89\u002C122\u002C117\u002C126\u002C10\u002C126\u007D\u003B\u0053\u0079\u0073\u0074\u0065\u006D\u002E\u006Fu\u0074\u002E\u0070\u0072\u0069\u006E\u0074\u0028x>10\u003F\u0028\u0063\u0068\u0061\u0072\u0029u\u005Bx\u002D32\u005D\u003A'\u005C\u006E'\u0029\u003B\u007D

Equivalente a

void
k(int
x){int[]u={33,33,35,35,36,55,38,39,36,38,56,57,39,48,49,50,48,49,50,51,52,53,54,55,56,57,51,52,53,54,62,62,64,65,66,67,68,69,102,71,72,66,74,75,76,64,78,79,85,81,82,88,90,85,86,87,88,89,90,92,92,94,94,95,96,65,75,67,68,69,102,71,72,95,74,107,76,96,78,79,107,81,82,120,122,117,86,87,120,89,122,117,126,10,126};System.out.print(x>10?(char)u[x-32]:'\n');}

Segundo programa:

void n(int r)throws Throwable{int p=(int)Math.PI;int q=p/p;int t=p*p+q;int w=q+q;int[]g={t*p+w,t*p+w,t*p+q+p,t*p+q+p,t*(q+p),t*p+t-p,t*(q+p)+q,t*(q+p)+q+p,t*(q+p),t*(q+p)+q,t*(q+p)+w,t*(q+p)+p,t*(q+p)+q+p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(q+p)+p+w,t*(q+p)+p+p,t*(q+p)+t-p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*p+t-p,t*(q+p)+w,t*(q+p)+p,t*(p+w)+t-w,t*(p+w)+t-q,t*(p+p),t*(p+p)+q,t*(p+p)+p,t*(p+p)+p,t*(t-p)+t-p,t*(t-q)+t-p,t*(t-p)+p,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*(t-p)+p,t*t+p+p,t*(t-q)+t-w,t*t+t-w,t*(t-p)+t-p,t*(t+q),t*(t+q)+q,t*(t-w),t*(t+q)+p,t*(t+q)+q+p,t*(t-w)+p,t*(t-w)+q+p,t*(t-w),t*(t+q)+t-w,t*(t+q)+t-q,t*(t-w)+p,t*(t+w)+q,t*(t-w)+q+p,t*(t-q)+q,t*(t-q)+q,t*(t-q)+p,t*(t-q)+p,t*t+p+w,t*t+t-q,t*(t-q)+t-p,t*(t-q)+t-w,t*(t-q)+t-q,t*t,t*t+q,t*(t-p),t*t+p,t*t+q+p,t*t+p+w,t*t+p+p,t*(t+q)+w,t*t+t-w,t*t+t-q,t*(t+q),t*(t+q)+q,t*(t+q)+w,t*(t+q)+p,t*(t+q)+q+p,t*(t+q)+p+w,t*(t+q)+p+p,t*(t+w)+p,t*(t+q)+t-w,t*(t+q)+t-q,t*(t+q)+p+w,t*(t+w)+q,t*(t+q)+p+p,t*(t+w)+p,t*(t+w)+q+p,t*(t+w)+p+w,t*(t+w)+q+p};java.io.PrintStream o=(java.io.PrintStream)System.class.getFields()[p/p].get(p);o.print((r<=t)?"}":(char)g[r-t*p-w]);}

Experimente aqui: https://ideone.com/Q3gqmQ

FIXO! Pitão - 23 bytes + Pitão - 30 bytes = 53 bytes

oops Erro de correção --- seja paciente

mesma divisão ASCII que a de Martin:

1: "$&(*,.02468:<>@BDFHJLNPRTVXZ\^`bdfhjlnprtvxz|~
2:!#%')+-/13579;=?ACEGIKMOQSUWY[]_acegikmoqsuwy{}\n

Prog # 1: Teste on-line

.xhft<zT.Dr\¡b:Z140 2\~

Prog # 2: Teste on-line

C?%KCwy1K?qy5Ky5?qy+1y31Ky5+1K