Come scrisse George Orwell nel 1984 :

La guerra è pace La
libertà è schiavitù L'
ignoranza è forza

Scrivi un programma o una funzione che riprenda una delle sei parole principali dalla citazione di Orwell e ne generi la controparte.

In particolare:

[input] -> [output]
war -> peace
peace -> war
freedom -> slavery
slavery -> freedom
ignorance -> strength
strength -> ignorance

Non sono richieste altre coppie input / output.

Dovresti supporre che le parole siano sempre in minuscolo, come sopra. In alternativa, è possibile assumere le parole sono sempre pienamente maiuscole: WAR -> PEACE, PEACE -> WAR, etc.

Vince il codice più breve in byte.

05AB1E , 30 byte

05AB1E utilizza CP-1252 .

“ignorance¤í‡î—™šÔÃÒry“#DIk1^è

Provalo online! o come una suite di test

Spiegazione

L'approccio diretto

• Spingi la corda ignorance strength war peace freedom slavery
• Dividi sugli spazi
• Ottieni l'indice dell'input nell'elenco
• XOR l'indice con 1
• Ottieni l'elemento nell'elenco in quell'indice

JavaScript (ES6), 80 byte

s=>'freedom,,war,,strength,,slavery,peace,ignorance'.split`,`[s.charCodeAt(1)%9]

Come funziona

Usiamo una piccola tabella di ricerca basata sul codice ASCII del 2o carattere di ogni parola, che restituisce l'indice della sua controparte.

Word      | 2nd char. | ASCII code | MOD 9
----------+-----------+------------+------
war       | a         | 97         | 7
peace     | e         | 101        | 2
freedom   | r         | 114        | 6
slavery   | l         | 108        | 0
ignorance | g         | 103        | 4
strength  | t         | 116        | 8

Come nota war PEACE FREEDOM slavery IGNORANCE strengtha margine , se fosse consentito il caso misto, l'uso con il modulo 6 porterebbe a un hash perfetto.

Test

let f =

s=>'freedom,,war,,strength,,slavery,peace,ignorance'.split`,`[s.charCodeAt(1)%9]

console.log('war', '->', f('war'))
console.log('peace', '->', f('peace'))
console.log('freedom', '->', f('freedom'))
console.log('slavery', '->', f('slavery'))
console.log('ignorance', '->', f('ignorance'))
console.log('strength', '->', f('strength'))

Gelatina , 24 byte

“Ñ=ƘḊ¹ƥ¹Ƙ⁷ṅ8cøGị»Ḳµiɠ^1ị

Provalo online!

Come funziona

Innanzitutto, il token

“Ñ=ƘḊ¹ƥ¹Ƙ⁷ṅ8cøGị»

si indicizza nel dizionario di Jelly per creare la stringa

strength war peace freedom slavery ignorance

che si Ḳdivide in spazi per produrre l'array di stringhe

["strength", "war", "peace", "freedom", "slavery", "ignorance"]

µ inizia una nuova catena monadica, con quella matrice di stringhe come argomento, che è anche il valore di ritorno corrente.

ɠlegge una riga di input da STDIN e itrova il suo indice del valore di ritorno precedente, ovvero l'array di stringhe generato.

Ora ^1prende l'XOR bit a bit di quell'indice e 1 . Per indice pari - ricordare che gli indici di gelatina sono 1 sede e modulare, così la forza ha indice 1 e ignoranza ha indice 6 / 0 - questo incrementa l'indice; per gli indici dispari, li diminuisce.

Infine, ịrecupera la stringa in quell'indice dall'argomento della catena.

Mathematica, 84 byte

(x="war""peace")(y="freedom""slavery")(z="ignorance""strength")/#/.x->1/.y->1/.z->1&

Spiegazione

Più "aritmetica" con le stringhe! Come nella risposta collegata, ciò si basa sul fatto che è possibile "moltiplicare" stringhe in Mathematica che le lasceranno non valutate (simile alla moltiplicazione di due variabili non assegnate x*y), ma che Mathematica applicherà semplificazioni di base, come la cancellazione di fattori in una divisione.

Dunque iniziamo memorizzando le tre coppie come prodotti x, y, z, rispettivamente, e li moltiplichiamo insieme:

(x="war""peace")(y="freedom""slavery")(z="ignorance""strength")

Questo valuta

"freedom" "ignorance" "peace" "slavery" "strength" "war"

(Mathematica ordina automaticamente i fattori, ma non ci interessa l'ordine.)

Dividiamo questo per l'input per rimuovere la parola con cui non vogliamo .../#, poiché Mathematica annulla i fattori. Ad esempio, se l'input fosse "peace", finiremmo con:

"freedom" "ignorance" "slavery" "strength" "war"

Infine, ci liberiamo delle coppie che non ti interessa, sostituendo ciascuna x, ye zcon 1. Ancora una volta, la semplificazione di Mathematica inizia 1*asempre a. Questa parte è fatta con:

/.x->1/.y->1/.z->1

La cosa bella è che Mathematica sa che la moltiplicazione è Orderlessquindi questo troverà i due fattori indipendentemente dal fatto che siano adiacenti nel prodotto o meno. Solo la parola opposta all'input non è più accoppiata nel prodotto, in modo che non venga rimossa e rimanga come unica uscita.

Vim, 60 byte

D3iwar freedom ignorance peace slavery strength <esc>2?<C-r>"
3wdwVp

Provalo online! nell'interprete V compatibile all'indietro.

Naturalmente, se dovessimo passare a V, potremmo salvare un byte utilizzando un metodo di input più conveniente. Ma poiché questa è una differenza così piccola, preferirei usare la versione non golf.

Spiegazione:

D                       " Delete this whole line
 3i...<esc>             " Insert the text three times
           2?           " Search backwards twice
             <C-r>"     " For the words we deleted
3w                      " Move three words forward
  dw                    " Delete a word
    V                   " Select this whole line
     p                  " And paste the word we deleted over it

C (gcc) , 120 107 byte

f(long*s){long r[2]={0};strcpy(r,s);s=*r>>40?*r>>56?"\n":"":"CE";*r^=*s;r[1]^=69;puts(r);}

Abuso massimo del puntatore! Richiede una macchina little-endian e long a 64 bit.

Il codice contiene alcuni non stampabili, ma il copia e incolla dovrebbe ancora funzionare.

Provalo online!

Python, 81 byte

l='war peace freedom slavery ignorance strength'.split()
lambda s:l[l.index(s)^1]

Oppure, stessa lunghezza:

l='war slavery ignorance strength freedom peace'.split()
dict(zip(l,l[::-1])).get

Perl 6 , 61 byte

Con i caratteri non stampabili mostrati come (poiché StackExchange li spoglia altrimenti):

{first {s/^\w+<(\0*$//},["���ce","�������","���
����e"X~^$_]}

Ecco una xxddiscarica esadecimale:

00000000: 7b66 6972 7374 207b 732f 5e5c 772b 3c28  {first {s/^\w+<(
00000010: 5c30 2a24 2f2f 7d2c 5b22 0704 1363 6522  \0*$//},["...ce"
00000020: 2c22 151e 0413 011d 1422 2c22 1a13 1c0a  ,".......","....
00000030: 1c06 1a0b 6522 587e 5e24 5f5d 7d0a       ....e"X~^$_]}.

Versione estesa (caratteri non stampabili sostituiti con sequenze di escape e spazi bianchi e commenti aggiunti):

{    # A Lambda.
    first {                   # Return first element which:
        s/ ^ \w+ <( \0* $ //  #   after stripping \0 has only word characters left.
    },
    [                                                  # The array to search:
        "\x[7]\x[4]\x[13]ce",                          #   "war" xor "peace"
        "\x[15]\x[1e]\x[4]\x[13]\x[1]\x[1d]\x[14]",    #   "freedom" xor "slavery"
        "\x[1a]\x[13]\x[1c]\n\x[1c]\x[6]\x[1a]\x[b]e"  #   "ignorance" xor "strength"
        X~^ $_                                         #   each xor'ed with the input.
    ]
}

Bash , 100 87 86 78 byte

a=peace;e=war;r=slavery;l=freedom;g=strength;t=ignorance;x=${1:1:1};echo ${!x}

Provalo online!

La seconda lettera di ogni parola identifica in modo univoco quella parola, quindi uso quel carattere come nome di variabile; il valore di quella variabile è l'altra parola corrispondente.

Ad esempio, la seconda lettera di peaceè ee la parola corrispondente peaceè è war, quindi ho impostato e=war.

Data una stringa di input, il secondo carattere di quella stringa viene usato come nome di variabile per richiamare la parola corrispondente desiderata, usando l'espansione indiretta dei parametri di bash.

TI-Basic, 103 84 77 byte

Riducendo a un liner si sono risparmiati molti byte! Haha, quanto ironica è stata questa affermazione ...

inString("EALRGT",sub(Ans,2,1
sub("WAR  PEACE FREEDOMSLAVERY STRENGTH IGNORANCE ",9Ans+1,4+Ans

Perl , 63 byte

62 byte + -pflag.

$_=(slavery,freedom,ignorance,strength,war,peace)[(ord)%6+/h/]

Provalo online!

ordrestituisce il codice char del primo carattere della parola di input.
Dopo il%6 , abbiamo:

- libertà => ord = 102 =>% 6 = 0  
- schiavitù => ord = 115 =>% 6 = 1  
- ignoranza => ord = 105 =>% 6 = 3  
- forza => ord = 115 =>% 6 = 1  
- war => ord = 119 =>% 6 = 5  
- pace => ord = 112 =>% 6 = 4  

Quindi abbiamo entrambi slaverye strengthrestituiamo 1 (poiché entrambi iniziano con la stessa lettera) e nessuno restituisce 2. Quindi, aggiungiamo 1per strength(è l'unica parola che corrisponderà /h/) e abbiamo ogni parola mappata su un indice da 0 a 5.

R, 86 87 92 byte

Modificato in una funzione senza nome e gsubin subper pochi byte. I grepdetermina quale dei 3 stringhe viene utilizzato e l'ingresso viene rimosso da tale stringa con sub.

function(v)sub(v,'',(l=c("warpeace","freedomslavery","ignorancestrength"))[grep(v,l)])

PHP, 70 byte

<?=[ignorance,peace,slavery,strength,freedom,war][md5("^$argv[1]")%7];

Befunge, 89 88 byte

<>_00g1v2+%7~%2~"slavery"0"war"0"freedom"0"ignorance"0"strength"0"peace"
 |p00:-<
@>:#,_

Provalo online!

Spiegazione

Iniziamo spingendo tutte le possibili stringhe di output nello stack, null terminato. Questa sequenza viene eseguita da destra a sinistra, quindi i valori vengono spinti al contrario, poiché questo è l'ordine in cui i caratteri saranno necessari quando alla fine verranno emessi.
Quindi leggiamo i primi due caratteri da stdin, che è tutto ciò che serve per identificare la stringa di input. Se prendiamo il valore ASCII della prima lettera mod 2, più la seconda lettera mod 7, otteniamo un numero univoco nell'intervallo da 2 a 7.

Input         ASCII      %2 %7   Sum
[fr]eedom     102 114    0  2    2
[pe]ace       112 101    0  3    3
[sl]avery     115 108    1  3    4
[st]rength    115 116    1  4    5
[ig]norance   105 103    1  5    6
[wa]r         119 97     1  6    7

Questo numero può quindi essere utilizzato come una specie di indice nell'elenco di stringhe nello stack. Decrementiamo iterativamente l'indice (la prima volta di 2) e per ogni iterazione cancelliamo una stringa dallo stack con la sequenza >_.
Quando l'indice raggiunge lo zero, ci resta la stringa di output corretta nella parte superiore dello stack, quindi utilizziamo una semplice sequenza di output della stringa per scrivere il risultato su stdout.

Pyke, 29 byte

.d⻌૽ɦڷࠛ⯤dci@1.^iR@

Provalo qui!

.d⻌૽ɦڷࠛ⯤           -     "war peace freedom slavery ignorance strength"
         dc         -     ^.split(" ")
           i        -    i=^
            @       -   ^.find(input)
             1.^    -  ^ xor 1
                iR@ - input[^]

C, 93

@ La risposta di Arnauld trasferita su C

#define F(w)(char*[]){"freedom",0,"war",0,"strength",0,"slavery","peace","ignorance"}[w[1]%9]

C (gcc) , 113 108 byte

f(char*s){char*t="5WAR\0+PEACE\09FREEDOM\0'SLAVERY\0;IGNORANCE\0%STRENGTH";while(strcmp(s,++t));puts(t+*--t-47);}

Tutte le istanze di \0possono essere sostituite con byte NUL effettivi ai fini del calcolo del punteggio.

t+*--t-47è un comportamento indefinito; questo potrebbe / non funzionerà con altri compilatori.

Provalo online!

JavaScript (ES6), 71 78

Tanto noioso della risposta di Arnauld, ma anche più breve.

Ora ho aggiunto la codifica con btoa. Nella stringa codificata ci sono 4 byte che non posso pubblicare su questo sito, anche se sono caratteri validi in una stringa javascript. Quindi ho usato una fuga esadecimale nella forma \xHH. Ognuna di queste uscite viene conteggiata come 1 byte.

La stringa codificata è strength0ignorance0peace0war0slavery0freedom

x=>(w=btoa`²ÚÞ\x9e\x0baÒ('¢¶§qí)y§\x1eÓ\x06«ÒÉZ½êòÑúÞyÚ&`.split(0))[w.indexOf(x)^1]

Questo è 82 e non fa distinzione tra maiuscole e minuscole

x=>',,strength,,slavery,war,,,ignorance,peace,freedom'.split`,`[parseInt(x,36)%15]

Test

F=
x=>(w=btoa`²ÚÞ\x9e\x0baÒ('¢¶§qí)y§\x1eÓ\x06«ÒÉZ½êòÑúÞyÚ&`.split(0))[w.indexOf(x)^1]

;['freedom','slavery','war','peace','ignorance','strength']
.forEach(w=>console.log(w + ' -> ' + F(w)))

CJam, 52 (solo ASCII)

"/.|Mv
DO'y    EK{ {:nBct'Pt}d4sE"144b26b'af+'j/_ra#1^=

Provalo online

Nota: le cose dall'aspetto spaziale sono caratteri di tabulazione (uno prima e uno dopo "EK {")

Spiegazione:

La parte fino a "+" sta decomprimendo la stringa "slaveryjfreedomjwarjpeacejignorancejstrength", usando la conversione di base:
stringa (trattata come matrice di codici carattere) → (base 144) numero → (base 26) matrice di numeri → (aggiungendo 'a' a ciascuno numero) stringa

'j/    split around 'j' characters
_      duplicate the resulting word array
ra     read the input and wrap in array
#      find the index of the input in the word array
1^     XOR with 1
=      get the word at the new index

> <> (Pesce), 84 78 byte

0i~ia%.
v'raw'
>ol?!;
^'htgnerts'
^'yrevals'

^'ecnarongi'
^'ecaep'
^'modeerf'

Provalo online!

Iniziamo a nuotare in alto a sinistra, andando a destra. Prima cariciamo lo stack con uno 0. Quindi leggiamo la prima lettera di input ( i), la scartiamo ( ~), leggiamo la seconda lettera ( i) e riduciamo il suo valore ASCII modulo 10 ( a%). Questo mappa a, e, r, l, g et da 7, 1, 4, 8, 3 e 6, rispettivamente: chiamiamo questo numero N.. apre due valori dallo stack — N e 0 — e salta a riga N, carattere 0.

Dopo un salto, il pesce procede con un tick prima di eseguire le istruzioni, quindi ignora il primo carattere e nuota attraverso la linea N, che carica la parola corrispondente sulla pila. Finalmente andiamo alla linea 2, che produce l'intero stack ed esce.

• Hai salvato sei byte usando un salto, invece della modifica automatica del codice che ho usato prima. Oh bene.

JavaScript, 78 byte

w=>(a="war slavery ignorance strength freedom peace".split` `)[5-a.indexOf(w)]

Questa è una specie di porta della mia risposta Python . Conserviamo le parole in una stringa in cui ognuna è nella posizione opposta alla sua controparte. Troviamo l'indice della parola data we otteniamo quell'indice dalla fine per restituire il risultato.

Snippet di prova:

f = w=>(a="war slavery ignorance strength freedom peace".split` `)[5-a.indexOf(w)]

console.log(f("peace"))
console.log(f("ignorance"))
console.log(f("war"))

Pari / GP, 86 byte

Pari / GP è un interprete interattivo, non abbiamo bisogno di un "print" -cmd per l'output; tuttavia, l'utilità Try-It_Online ha bisogno di un "print" -cmd, quindi l'ho separato dal "footer".
Definiamo una "funzione oggetto" (la lettera O mi ricorda la funzione Orwell ... ;-)):

x.O=s=[war,freedom,ignorance,strength,slavery,peace];for(k=1,6,if(x==s[k],i=7-k));s[i]

Dopodiché, chiama

print(war.O)   \\ input to Pari/GP with the O-rwell-member of "war"
       peace   \\ output by Pari/GP

Provalo online!

(Nota che in Pari / GP i token forniti qui non sono stringhe ma nomi di variabili legali! A tali variabili non dovrebbe mai essere assegnato alcun valore)

Impilato, 70 byte

@x'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#

Provalo qui! Prende l'input sullo stack e lascia l'output sullo stack. Per esempio:

'war'

@x'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#

out

Questo codice è abbastanza autoesplicativo. Leggermente modificato per eseguire tutti i casi di test:

('war' 'slavery' 'ignorance')
{x:'war
strength
freedom
slavery
ignorance
peace'LF split:x index\rev\#x\,}"!
disp

Jolf, 35 byte

.γG"ΞΠΞ¦ΞpΞsΞΈΞ3I"-5 iγ

Ci sono molti non stampabili. Ecco un hexdump, anche se non farà molto bene:

00000000: 2ece b347 22ce 9e07 cea0 c28e ce9e 07c2  ...G"...........
00000010: 8ac2 a6ce 9e06 c28e 70ce 9e07 73c2 8fce  ........p...s...
00000020: 9e06 ce88 c280 ce9e 0133 4922 052d 3520  .........3I".-5
00000030: 69ce b3                                  i..

Ecco un link online.

Fondamentalmente, il codice appare come:

.γG"..."♣-5 iγ
  G"..."♣        split uncompressed string on spaces
 γ               set gamma to this
            iγ   index of the input in gamma
.γ       -5      and get 5 - this from gamma

In realtà , 56 byte

' "war peace freedom slavery ignorance strength"s;)í1^@E

Provalo online!

Sfortunatamente, senza alcun builtin di compressione, è più breve non comprimere la stringa e decomprimerla manualmente.

Spiegazione:

' "war peace freedom slavery ignorance strength"s;)í1^@E
' "war peace freedom slavery ignorance strength"s         split the string on spaces
                                                 ;)       make a copy, push it to the bottom of the stack
                                                   í      index of input in list
                                                    1^    XOR with 1
                                                      @E  that element in the list

Haskell, 104 111 byte

data O=WAR|FREEDOM|IGNORANCE|PEACE|SLAVERY|STRENGTH deriving(Show,Enum)
f s=toEnum$mod(3+fromEnum s)6::O

Idea:

• Enumera le parole chiave in modo tale che la loro controparte sia a 3 posizioni di distanza
• Prendi la parola chiave, ottieni la sua posizione fromEnum, sposta 3 passaggi a destra (modulo 6) e converti indietro in parola chiave
• Il ::Oè necessario perché l'inferenza di tipo ha qualche problema. Dare funa firma f :: O -> Oavrebbe lo stesso effetto ma non è così breve.

Modificare:

sostituito

f s=toEnum$mod(3+fromEnum s)6

di

f=toEnum.(`mod`6).(+3).fromEnum

grazie a @Laikoni.

Dyalog APL , 66 byte

Uno di questi:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞utilizza questo metodo (richiede ⎕IO←0che è predefinito su molti sistemi).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ esegue una ricerca, quindi seleziona l'elemento corrispondente dall'elenco invertito.

Qbasic, 138 99 byte

D$="ignorancefreedom  peace    strength slavery  war      ":INPUT A$:?MID$(D$+D$,INSTR(D$,A$)+27,9)

D$memorizza tutte le parole dal lato sinistro del mantra, quindi tutte quelle del lato destro. Ogni parola è riempita con spazi esattamente di 9 lettere per parola.D$quindi viene aggiunto a se stesso.

Quindi instrviene utilizzato per trovare l'indice della parola inserita dall'utente. L'altra parte del mantra viene sempre memorizzata esattamente 9 * 3 posizioni nella stringa, quindi stampiamo una sottostringa che inizia in quella posizione, prendendo 9 caratteri.

SmileBASIC, 92 byte

A$="PEACE
E$="WAR
R$="SLAVERY
L$="FREEDOM
G$="STRENGTH
T$="IGNORANCE
INPUT I$?VAR(I$[1]+"$")

Pitone , 80 byte

In qualche modo superato xnor!

Questa è una funzione lambda senza nome, che restituisce il risultato.

lambda w,a="war slavery ignorance strength freedom peace".split():a[~a.index(w)]

Provalo online!

L'elenco di parole è organizzato in modo tale che ciascuno sia nella posizione opposta rispetto alla sua controparte. Data la parola w, troviamo il suo indice nell'elenco delle parole, quindi NON bit a bit ( ~). Questo lancia tutti i bit, che viene calcolaton => -n-1 . A causa dell'indicizzazione negativa di Python, ottiene l'indice opposto nell'elenco.

Come una sorta di bonus involontario, puoi passare qualsiasi elenco di parole di opposti a questa funzione come secondo argomento.