Dados los 95 caracteres imprimibles en ASCII más nueva línea, sepárelos en dos grupos iguales de 48 caracteres (en adelante, el grupo A y el grupo B). Cree un mapeo uno a uno de su elección (tiene total discreción) entre los dos grupos. En otras palabras, Apodría mapear ay viceversa, pero Atambién podría mapear >y viceversa, si eso es lo que necesita para su programa.

Una vez que haya dividido ASCII en dos grupos, escriba dos programas y / o funciones, utilizando solo los caracteres de cada grupo, respectivamente. En otras palabras, escriba un programa / función que solo use los caracteres del grupo A, y otro programa / función que solo use los caracteres del grupo B.

Estos programas deben poder recibir un carácter como entrada. El programa escrito con los caracteres del Grupo A debería generar / devolver el mismo carácter si la entrada era un carácter del grupo A, y el carácter del grupo A asignado si recibió un carácter del grupo B; el programa del Grupo A siempre debe generar un carácter del grupo A. De manera similar, el programa del Grupo B debería generar el mismo carácter si es un carácter del grupo B, y el carácter del grupo B mapeado si la entrada es un carácter del grupo A.

Puede que no sea tan claro, así que aquí hay un ejemplo. Si asume que todas las letras mayúsculas están en el grupo A, y todas las letras minúsculas están en el grupo B, y ha elegido que su mapeo uno a uno para estas letras sea de una a la otra, entonces: entonces aquí hay algunas entradas / salidas de muestra:

Programa A

Input    Output
A        A
D        D
a        A
q        Q

Programa B:

Input    Output
A        a
D        d
a        a
q        q

Otras reglas:

• Los dos programas no necesitan estar en el mismo idioma.
• No necesitan ser ambos programas o ambas funciones; uno podría ser un programa, el otro una función, eso está bien.
• No necesitan trabajar de la misma manera, tener una longitud similar, nada de eso; simplemente deben cumplir con las otras reglas anteriores.
• Sí, solo uno de sus programas puede usar nuevas líneas, y solo uno puede usar espacios (esto podría ser el mismo o un programa diferente).
• No necesita utilizar los 48 caracteres en cada programa.

Las lagunas estándar están prohibidas, como es normal. Todos los programas deben ser independientes, sin archivos que contengan la asignación que elija.

Criterios de puntuación: código-golf . Específicamente, la suma de los bytes del texto de los dos programas.

Por favor, publique su respuesta de esta manera:

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

Una descripción inequívoca de su mapeo. Si es complicado, use un cuadro como este:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

O bien, puede explicarlo (los primeros 48 mapas a los últimos 48 en secuencia), seguido de su respuesta de manera normal.

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

Los personajes se seleccionan en grupos alternos de 16:

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

Es genial que algunas de las asignaciones se puedan obtener con la tecla Mayús :)

Programa A

lL,H-f&'o+c

Pruébalo en línea

Programa B:

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

Pruébalo en línea

Explicación:

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

Gracias a Peter Taylor por jugar golf a 6 bytes del programa GolfScript (y allanar el camino para muchos más).

Gracias a Dennis por jugar 15 bytes fuera del programa CJam y 4 bytes fuera del programa GolfScript.

Grupo A: todos los caracteres con código de caracteres par.
Grupo B: todos los caracteres con código de caracteres impares, más nueva línea.

Estoy usando el mapeo obvio entre los dos, es decir, emparejar aquellos caracteres que solo difieren en el bit menos significativo, así como ~y \n. Aquí está el mapa completo (las columnas):

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

Programa A (CJam, pruébalo aquí ):

lX~f&"~"|X<

Programa B (GolfScript, pruébelo aquí ):

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

Explicación

Programa A

(Anticuado, se actualizará mañana).

Este programa debe convertir los códigos de caracteres impares en pares, es decir, establecer el bit menos significativo en 0. La forma obvia de hacerlo es bit a bit Y con 126 (o 254, etc.), pero es más corto establecerlo en 1 (a través de bit a bit O con 1) en su lugar y luego disminuir el resultado. Finalmente, necesitamos arreglar las nuevas líneas 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

(Anticuado, se actualizará mañana).

Este programa simplemente puede establecer el bit menos significativo a 1 a través de bit a bit O con 1 ahora. Pero tiene que verificar ambos \v(código de caracteres 0x0B) y <DEL>(código de caracteres 0xFF) manualmente y configurarlos en su ~lugar. En GolfScript no tenía acceso a eval, pero en su lugar puede agregar una cadena a un bloque (que luego se convierte en parte del código en ese bloque), que podría asignar a la entrada con %:

{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.

Y en cuanto al código generado en el bloque:

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

Gracias a @ durron597 por ayudar a jugar golf 1090 bytes desde el primer programa.

Prueba de que es posible hacerlo en un idioma (y no en eso).

Usa el truco Unicode para convertir el primero a todos los caracteres Unicode. El segundo usa la reflexión para obtener acceso a System.out para imprimir en std. fuera. No podía usar la u porque se usó en el primer programa. Sé que esto se puede jugar más, pero primero quería publicar una solución válida.

Los grupos se asignan de manera bastante arbitraria, pero básicamente, el primero solo requiere u, \ y los dígitos hexadecimales (en cualquier caso).

Los grupos:

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

Primer 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]);}

Pruébelos aquí: https://ideone.com/Q3gqmQ

¡FIJO! Pyth - 23 bytes + Pyth - 30 bytes = 53 bytes

Uy error de fijación --- por favor sea paciente

misma división ASCII que la de Martin:

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

Prog # 1: Prueba en línea

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

Prog # 2: Prueba en línea

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