Teilen Sie die 95 druckbaren Zeichen in ASCII plus Zeilenvorschub in zwei gleich große 48 Zeichengruppen (im Folgenden Gruppe A und Gruppe B genannt) auf. Erstellen Sie eine Eins-zu-Eins-Zuordnung Ihrer Wahl zwischen den beiden Gruppen. Mit anderen Worten, Akann auf aund umgekehrt abgebildet werden, kann aber Aauch auf >und umgekehrt abgebildet werden, wenn Sie dies für Ihr Programm benötigen.

Wenn Sie ASCII in zwei Gruppen unterteilt haben, schreiben Sie zwei Programme und / oder Funktionen, wobei Sie jeweils nur die Zeichen in jeder Gruppe verwenden. Mit anderen Worten, schreiben Sie ein Programm / eine Funktion, die nur die Zeichen in Gruppe A verwendet, und ein anderes Programm / eine Funktion, die nur die Zeichen in Gruppe B verwendet.

Diese Programme müssen ein Zeichen als Eingabe empfangen können. Das Programm, das mit den Zeichen in Gruppe A geschrieben wurde, sollte das gleiche Zeichen ausgeben / zurückgeben, wenn die Eingabe ein Zeichen der Gruppe A war, und das zugeordnete Zeichen der Gruppe A, wenn es ein Zeichen der Gruppe B erhielt. Das Programm der Gruppe A sollte immer ein Zeichen der Gruppe A ausgeben. In ähnlicher Weise sollte das Programm der Gruppe B dasselbe Zeichen ausgeben, wenn es sich um ein Zeichen der Gruppe B handelt, und das zugeordnete Zeichen der Gruppe B, wenn es sich bei der Eingabe um ein Zeichen der Gruppe A handelt.

Das ist vielleicht nicht so klar, also hier ein Beispiel. Wenn Sie davon ausgehen, dass sich alle Großbuchstaben in Gruppe A und alle Kleinbuchstaben in Gruppe B befinden und Sie ausgewählt haben, dass Ihre Eins-zu-Eins-Zuordnung für diese Buchstaben von einem zum anderen ist, dann: dann sind hier einige Beispiel Ein- / Ausgänge:

Programm A:

Input    Output
A        A
D        D
a        A
q        Q

Programm B:

Input    Output
A        a
D        d
a        a
q        q

Andere Regeln:

• Die beiden Programme müssen nicht in derselben Sprache sein.
• Sie müssen nicht beide Programme oder beide Funktionen sein. Das eine könnte ein Programm sein, das andere eine Funktion, das ist in Ordnung.
• Sie müssen nicht auf die gleiche Weise arbeiten, von ähnlicher Länge sein, so etwas; Sie müssen einfach die anderen oben genannten Regeln erfüllen.
• Ja, nur eines Ihrer Programme darf Zeilenumbrüche und nur eines Leerzeichen verwenden (dies kann dasselbe oder ein anderes Programm sein).
• Sie müssen nicht alle 48 Zeichen in jedem Programm verwenden.

Standard-Schlupflöcher sind wie gewohnt verboten. Alle Programme müssen eigenständig sein, keine Dateien, die die von Ihnen gewählte Zuordnung enthalten.

Bewertungskriterien: Code-Golf . Insbesondere die Summe der Bytes des Texts der beiden Programme.

Bitte posten Sie Ihre Antwort so:

Sprache - # Bytes + Sprache - # Bytes = # Bytes

Eine eindeutige Beschreibung Ihres Mappings. Wenn es kompliziert ist, verwenden Sie ein Diagramm wie das folgende:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

Oder Sie können es einfach erklären (die ersten 48 Karten bis zu den letzten 48 in Folge), gefolgt von Ihrer normalen Antwort.

CJam - 11 Bytes + CJam - 25 Bytes = 36 Bytes

Zeichen werden in abwechselnden Gruppen von 16 ausgewählt:

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

Es ist cool, dass einige der Zuordnungen mit der Umschalttaste abgerufen werden können :)

Programm A:

lL,H-f&'o+c

Probieren Sie es online aus

Programm B:

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

Probieren Sie es online aus

Erläuterung:

Programm 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

Programm 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

Vielen Dank an Peter Taylor für das Golfen von 6 Bytes aus dem GolfScript-Programm (und den Weg für viele weitere.)

Vielen Dank an Dennis für das Golfen von 15 Bytes aus dem CJam-Programm und 4 Bytes aus dem GolfScript-Programm.

Gruppe A: alle Zeichen mit geradem Zeichencode.
Gruppe B: alle Zeichen mit ungeradem Zeichencode plus Zeilenvorschub.

Ich benutze die offensichtliche Zuordnung zwischen den beiden, dh paarweise die Zeichen, die sich nur im niedrigstwertigen Bit unterscheiden, sowie ~und \n. Hier ist die komplette Karte (die Spalten):

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

Programm A (CJam, hier testen ):

lX~f&"~"|X<

Programm B (GolfScript, hier testen ):

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

Erläuterung

Programm A

(Veraltet, wird morgen aktualisiert.)

Dieses Programm sollte ungerade Zeichencodes in gerade umwandeln, dh das niedrigstwertige Bit auf 0 setzen. Die naheliegende Methode hierfür ist bitweises UND mit 126 (oder 254 usw.), aber es ist kürzer, es auf 1 zu setzen (über bitweises ODER mit 1) stattdessen und dekrementiere dann das Ergebnis. Zuletzt müssen wir die Zeilenumbrüche manuell korrigieren:

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

Programm B

(Veraltet, wird morgen aktualisiert.)

Dieses Programm kann nun einfach das niedrigstwertige Bit durch bitweises ODER mit 1 auf 1 setzen. Es muss jedoch manuell nach (Zeichencode 0x0B) \vund <DEL>(Zeichencode 0xFF) suchen und ~stattdessen auf festlegen . In GolfScript hatte ich keinen Zugriff auf eval. Stattdessen können Sie einem Block eine Zeichenfolge hinzufügen (die dann Teil des Codes in diesem Block wird), die ich der Eingabe zuordnen konnte mit %:

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

Und was den generierten Code im Block betrifft:

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

Vielen Dank an @ durron597 für die Unterstützung beim Golfen von 1090 Bytes aus dem ersten Programm.

Beweise, dass es möglich ist, in einer Sprache zu arbeiten (und zwar als Nicht-Esolang).

Verwenden Sie den Unicode-Trick, um den ersten in alle Unicode-Zeichen zu konvertieren. Die zweite Methode verwendet Reflection, um auf System.out zuzugreifen und auf std zu drucken. aus. Das u konnte nicht verwendet werden, da es im ersten Programm verwendet wurde. Ich weiß, dass man mehr Golf spielen kann, aber ich wollte zuerst eine gültige Lösung veröffentlichen.

Die Gruppen sind ziemlich willkürlich zugeordnet, aber im Grunde genommen benötigte die erste nur u, \ und die hexadezimalen Ziffern (auf jeden Fall).

Die Gruppen:

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

Erstes Programm:

\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

Gleichwertig

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

Zweites Programm:

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

Probieren Sie sie hier aus: https://ideone.com/Q3gqmQ

FEST! Pyth - 23 Bytes + Pyth - 30 Bytes = 53 Bytes

oops Fixing error --- bitte haben sie etwas geduld

Gleiche ASCII-Aufteilung wie bei Martin:

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

Prog # 1: Online testen

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

Prog # 2: Online testen

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