Compte tenu des 95 caractères imprimables en ASCII plus de nouvelle ligne, séparez-le en deux groupes égaux de 48 caractères (ci-après appelés groupe A et groupe B). Créez un mappage individuel de votre choix (vous avez toute discrétion) entre les deux groupes. En d'autres termes, la Acarte peut correspondre à a, et vice versa, mais Apeut également correspondre à >et inversement, si c'est ce dont vous avez besoin pour votre programme.

Une fois que vous avez divisé l'ASCII en deux groupes, écrivez deux programmes et / ou fonctions en n'utilisant que les caractères de chaque groupe. En d'autres termes, écrivez un programme / fonction qui utilise uniquement les caractères du groupe A et un autre programme / fonction qui utilise uniquement les caractères du groupe B.

Ces programmes doivent pouvoir recevoir un caractère en entrée. Le programme écrit avec les caractères du groupe A doit sortir / retourner le même caractère s'il s'agit d'un caractère du groupe A et le caractère du groupe A mappé s'il a reçu un caractère du groupe B; le programme Groupe A doit toujours sortir un caractère du groupe A. De même, le programme du groupe B doit générer le même caractère s’il s’agit d’un caractère du groupe B et le caractère mappé du groupe B si l’entrée est un caractère du groupe A.

Cela peut ne pas être si clair, alors voici un exemple. Si vous supposez que toutes les lettres majuscules font partie du groupe A et que toutes les lettres minuscules appartiennent au groupe B et que vous avez choisi d'affecter votre correspondance un à un pour ces lettres, alors: en voici quelques unes: échantillon entrées / sorties:

Programme A:

Input    Output
A        A
D        D
a        A
q        Q

Programme B:

Input    Output
A        a
D        d
a        a
q        q

Autres règles:

• Les deux programmes n'ont pas besoin d'être dans la même langue.
• Ils n'ont pas besoin d'être les deux programmes ou les deux fonctions; l'un pourrait être un programme, l'autre une fonction, c'est bien.
• Ils n'ont pas besoin de travailler de la même manière, d'être de la même longueur, quoi que ce soit du genre; ils doivent simplement respecter les autres règles ci-dessus.
• Oui, un seul de vos programmes peut utiliser des nouvelles lignes et un seul peut utiliser des espaces (il peut s'agir du même programme ou d'un programme différent).
• Vous n'avez pas besoin d'utiliser les 48 caractères de chaque programme.

Les failles standard sont interdites, comme d'habitude. Tous les programmes doivent être autonomes, aucun fichier contenant le mappage que vous choisissez.

Critères de notation: code-golf . Plus précisément, la somme des octets du texte des deux programmes.

Merci de poster votre réponse comme ceci:

Langue - # octets + Langue - # octets = # octets

Une description non équivoque de votre cartographie. Si c'est compliqué, utilisez un tableau comme celui-ci:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

Ou bien, vous pouvez simplement l'expliquer (les 48 premières cartes sont classées en 48), suivies de votre réponse normalement.

CJam - 11 octets + CJam - 25 octets = 36 octets

Les caractères sont sélectionnés en groupes de 16:

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

C'est cool que quelques correspondances puissent être obtenues avec la touche Maj :)

Programme A:

lL,H-f&'o+c

Essayez-le en ligne

Programme B:

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

Essayez-le en ligne

Explication:

Programme 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

Programme 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 octets + GolfScript - 142 125 115 93 68 47 40 36 octets = 47 octets

Merci à Peter Taylor pour avoir joué 6 octets hors du programme GolfScript (et en avoir ouvert la voie à beaucoup d’autres).

Merci à Dennis d'avoir joué 15 octets hors du programme CJam et 4 octets hors du programme GolfScript.

Groupe A: tous les caractères avec un code de caractère pair.
Groupe B: tous les caractères avec un code de caractère impair, plus une nouvelle ligne.

J'utilise la correspondance évidente entre les deux, c'est-à-dire que je couple ces caractères qui ne diffèrent que par le bit le moins significatif, ainsi que ~et \n. Voici la carte complète (les colonnes):

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

Programme A (CJam, testez-le ici ):

lX~f&"~"|X<

Programme B (GolfScript, testez-le ici ):

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

Explication

Programme A

(Obsolète, sera mis à jour demain.)

Ce programme doit transformer les codes de caractère impairs en paires, c’est-à-dire mettre le bit le moins significatif à 0. La manière évidente de le faire est d’afficher AND avec 126 (ou 254 etc.), mais il est plus court de le mettre à 1 (via OR au niveau du bit avec 1) à la place, puis décrémentez le résultat. Enfin, nous devons corriger les nouvelles lignes manuellement:

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

Programme B

(Obsolète, sera mis à jour demain.)

Ce programme peut simplement définir le bit le moins significatif sur 1 via OU au niveau du bit avec 1 maintenant. Mais il doit vérifier manuellement \v(code de caractère 0x0B) et <DEL>(code de caractère 0xFF) et les définir à la ~place. Dans GolfScript, je n'avais pas accès à eval, mais vous pouvez plutôt ajouter une chaîne à un bloc (qui fait alors partie du code de ce bloc), que je pourrais mapper sur l'entrée avec %:

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

Et comme pour le code généré dans le bloc:

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 octets + Java - 1144 octets = 2232 octets

Merci à @ durron597 pour avoir aidé à jouer au golf 1090 octets du premier programme.

Preuve qu'il est possible de faire dans une langue (et un non-esolang en plus).

Utilisez l’astuce Unicode pour convertir le premier en tous les caractères Unicode. La seconde utilise la réflexion pour accéder à System.out afin d’imprimer sur std. en dehors. Il ne pouvait pas utiliser le u parce que c'était utilisé dans le premier programme. Je sais que cela peut être joué davantage au golf, mais je voulais tout d'abord publier une solution valable.

Les groupes sont mappés de façon assez arbitraire, mais au fond, le premier ne nécessitait que u, \ et les chiffres hexadécimaux (dans tous les cas).

Les groupes:

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

Premier programme:

\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

Équivalent à

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');}

Deuxième programme:

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

Essayez-les ici: https://ideone.com/Q3gqmQ

FIXÉ! Pyth - 23 octets + Pyth - 30 octets = 53 octets

oups erreur de fixation --- s'il vous plaît soyez patient

même code ASCII que celui de Martin:

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

Prog # 1: Test en ligne

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

Prog # 2: Test en ligne

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