Dati i 95 caratteri stampabili in ASCII più newline, suddividili in due gruppi uguali di 48 caratteri (di seguito chiamati gruppo A e gruppo B). Crea un mapping uno a uno a tua scelta (hai totale discrezione) tra i due gruppi. In altre parole, Apotrebbe essere mappato ae viceversa, ma Apotrebbe anche mappare >e viceversa, se è quello che ti serve per il tuo programma.

Dopo aver suddiviso ASCII in due gruppi, scrivi due programmi e / o funzioni, usando solo i caratteri di ciascun gruppo, rispettivamente. In altre parole, scrivi un programma / funzione che utilizza solo i caratteri nel gruppo A e un altro programma / funzione che utilizza solo i caratteri nel gruppo B.

Questi programmi devono essere in grado di ricevere un carattere come input. Il programma scritto con i caratteri nel gruppo A dovrebbe generare / restituire lo stesso carattere se l'input era un carattere di gruppo A e il carattere di gruppo A mappato se riceveva un carattere di gruppo B; il programma Gruppo A dovrebbe sempre generare un carattere di gruppo A. Allo stesso modo, il programma Gruppo B dovrebbe generare lo stesso carattere se è un carattere di gruppo B e il carattere di gruppo B mappato se l'input è un carattere di gruppo A.

Potrebbe non essere così chiaro, quindi ecco un esempio. Se supponi che tutte le lettere maiuscole siano nel gruppo A, e tutte le lettere minuscole siano nel gruppo B, e hai scelto che il tuo mapping uno-a-uno per queste lettere sia dall'uno all'altro, quindi: ecco alcuni input / output di esempio:

Programma A:

Input    Output
A        A
D        D
a        A
q        Q

Programma B:

Input    Output
A        a
D        d
a        a
q        q

Altre regole:

• I due programmi non devono necessariamente essere nella stessa lingua.
• Non devono necessariamente essere entrambi programmi o entrambe le funzioni; uno potrebbe essere un programma, l'altro una funzione, va bene.
• Non hanno bisogno di lavorare allo stesso modo, avere una lunghezza simile, niente del genere; devono semplicemente soddisfare le altre regole sopra.
• Sì, solo uno dei tuoi programmi può utilizzare le nuove righe e solo uno può utilizzare gli spazi (potrebbe essere lo stesso o un programma diverso).
• Non è necessario utilizzare tutti e 48 i caratteri in ciascun programma.

Le scappatoie standard sono vietate, come di consueto. Tutti i programmi devono essere autonomi, nessun file contenente la mappatura scelta.

Criteri di punteggio: code-golf . In particolare, la somma dei byte del testo dei due programmi.

Invia la tua risposta in questo modo:

Lingua - # byte + Lingua - # byte = # byte

Una descrizione inequivocabile della tua mappatura. Se è complicato, usa un grafico come questo:

ABCDEFGHIJKLMNOPQRSTUVWXYZ (etc.)
zyxwvutsrpqonmlkjihgfedcba (etc.)

Oppure puoi semplicemente spiegarlo (dalle prime 48 mappe alle ultime 48 in sequenza), seguita dalla tua risposta normalmente.

CJam - 11 byte + CJam - 25 byte = 36 byte

I personaggi sono selezionati in gruppi alternati di 16:

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

È bello che alcune delle mappature possano essere ottenute con il tasto Maiusc :)

Programma A:

lL,H-f&'o+c

Provalo online

Programma B:

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

Provalo online

Spiegazione:

Programma 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

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

Grazie a Peter Taylor per aver giocato a golf a 6 byte dal programma GolfScript (e aver aperto la strada a molti altri.)

Grazie a Dennis per aver giocato a golf 15 byte fuori dal programma CJam e 4 byte fuori dal programma GolfScript.

Gruppo A: tutti i caratteri con codice carattere pari.
Gruppo B: tutti i caratteri con un codice dispari, più newline.

Sto usando l'ovvia mappatura tra i due, ovvero accoppiando quei caratteri che differiscono solo nel bit meno significativo, così come ~e \n. Ecco la mappa completa (le colonne):

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

Programma A (CJam, provalo qui ):

lX~f&"~"|X<

Programma B (GolfScript, provalo qui ):

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

Spiegazione

Programma A

(Non aggiornato, verrà aggiornato domani.)

Questo programma dovrebbe convertire i codici di caratteri dispari in numeri pari, ovvero impostare il bit meno significativo su 0. Il modo più ovvio per farlo è bit a bit E con 126 (o 254 ecc.), Ma è più breve impostarlo a 1 (via bit a bit O con 1) invece e quindi decrementa il risultato. Infine, dobbiamo correggere manualmente le nuove righe:

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

Programma B

(Non aggiornato, verrà aggiornato domani.)

Questo programma può semplicemente impostare il bit meno significativo su 1 tramite OR bit a bit con 1 ora. Ma deve controllare sia per \v(codice carattere 0x0B) che <DEL>(codice carattere 0xFF) e impostarli ~invece. In GolfScript non avevo accesso a eval, ma invece puoi aggiungere una stringa a un blocco (che diventa quindi parte del codice in quel blocco), che potrei mappare sull'input 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.

E per quanto riguarda il codice generato nel blocco:

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

Grazie a @ durron597 per l'aiuto nel golf di 1090 byte dal primo programma.

Prova che è possibile fare in una lingua (e un non-esolang in quello).

Usa il trucco unicode per convertire il primo in tutti i caratteri unicode. Il secondo usa la reflection per ottenere l'accesso a System.out per stampare su std. su. Non poteva usare l'U perché era usato nel primo programma. So che si può giocare a golf di più, ma prima volevo pubblicare una soluzione valida.

I gruppi sono mappati in modo abbastanza arbitrario, ma sostanzialmente il primo richiede solo u, \ e le cifre esadecimali (in ogni caso).

I gruppi:

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

Primo programma:

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

Secondo programma:

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

Provali qui: https://ideone.com/Q3gqmQ

FISSO! Pyth - 23 byte + Pyth - 30 byte = 53 byte

oops Errore di riparazione --- per favore sii paziente

stessa divisione ASCII di Martin:

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

Prog # 1: Test online

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

Prog # 2: Test online

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