Wie George Orwell 1984 schrieb :

Krieg ist Frieden
Freiheit ist Sklaverei
Unwissenheit ist Stärke

Schreiben Sie ein Programm oder eine Funktion, die eines der sechs Hauptwörter aus dem Orwell-Zitat aufnimmt und dessen Gegenstück ausgibt.

Speziell:

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

Es sind keine weiteren Ein- / Ausgangspaare erforderlich.

Sie sollten davon ausgehen, dass die Wörter wie oben immer vollständig in Kleinbuchstaben geschrieben sind. Alternativ können Sie die Wörter übernehmen immer vollständig groß geschrieben: WAR -> PEACE, PEACE -> WARusw.

Der kürzeste Code in Bytes gewinnt.

05AB1E , 30 Bytes

05AB1E verwendet CP-1252 .

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

Probieren Sie es online! oder als Testsuite

Erläuterung

Der direkte Ansatz

• Schieben Sie die Schnur ignorance strength war peace freedom slavery
• Auf Leerzeichen aufteilen
• Ruft den Index der Eingabe in der Liste ab
• XOR den Index mit 1
• Ruft das Element in der Liste an diesem Index ab

JavaScript (ES6), 80 Byte

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

Wie es funktioniert

Wir verwenden eine kleine Nachschlagetabelle, die auf dem ASCII-Code des zweiten Zeichens jedes Wortes basiert und den Index seines Gegenstücks zurückgibt.

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

Als Randnotiz, wenn gemischte Groß- und Kleinschreibung erlaubt wäre, würde die Verwendung war PEACE FREEDOM slavery IGNORANCE strengthvon Modulo 6 zu einem perfekten Hash führen.

Prüfung

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

Gelee , 24 Bytes

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

Probieren Sie es online!

Wie es funktioniert

Erstens das Token

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

Indexiert in Jellys Wörterbuch, um die Zeichenfolge zu erstellen

strength war peace freedom slavery ignorance

das Ḳsich an Leerzeichen aufteilt, um das String-Array zu erhalten

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

µ beginnt eine neue, monadische Kette mit diesem String-Array als Argument, das auch der aktuelle Rückgabewert ist.

ɠLiest eine Eingabezeile von STDIN und ifindet den Index des vorherigen Rückgabewerts, dh des generierten String-Arrays.

Nimmt nun ^1das bitweise XOR dieses Index und 1 . Für eine noch Indizes - denken Sie daran , dass Jelly Indizes 1 -Basis und modular, so Kraft hat den Index 1 und Ignoranz hat den Index 6 / 0 - das erhöht den Index; Für ungerade Indizes werden sie dekrementiert.

Ruft ịabschließend die Zeichenfolge an diesem Index aus dem Argument der Kette ab.

Mathematica, 84 Bytes

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

Erläuterung

Mehr "Rechnen" mit Strings! Wie in der verknüpften Antwort basiert dies auf der Tatsache, dass Sie Zeichenfolgen in Mathematica "multiplizieren" können, wodurch sie nicht bewertet werden (ähnlich wie beim Multiplizieren von zwei nicht zugewiesenen Variablen x*y), Mathematica jedoch grundlegende Vereinfachungen anwendet, z. B. das Löschen von Faktoren in einer Division.

So starten wir durch Speichern der drei Paare als Produkte x, y, zjeweils und multiplizieren sie alle zusammen:

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

Dies ergibt

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

(Mathematica sortiert die Faktoren automatisch, aber die Reihenfolge ist uns egal.)

Wir teilen dies durch die Eingabe, um das Wort zu entfernen, mit dem wir nicht wollen .../#, da Mathematica die Faktoren aufhebt. Wenn die Eingabe beispielsweise "peace"so wäre, würden wir am Ende Folgendes erhalten:

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

Schließlich erhalten wir von den Paaren befreien wir nicht interessiert sind, die von jedem der Substitution x, yund zmit 1. Auch hier ist die Vereinfachung von Mathematica 1*aimmer so a. Dieser Teil ist erledigt mit:

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

Das Schöne ist, dass Mathematica weiß, dass Multiplikation Orderlessso ist, dass die beiden Faktoren unabhängig davon gefunden werden, ob sie im Produkt benachbart sind oder nicht. Nur das Wort, das der Eingabe entgegengesetzt ist, wird im Produkt nicht mehr gepaart, sodass eines nicht entfernt wird und als einzige Ausgabe verbleibt.

Vim, 60 Bytes

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

Probieren Sie es online! im abwärtskompatiblen V-Interpreter.

Wenn wir zu V wechseln würden, könnten wir natürlich ein Byte sparen, indem wir eine bequemere Eingabemethode verwenden. Aber da dies ein so kleiner Unterschied ist, würde ich es vorziehen, die nicht-golfende Version zu verwenden.

Erläuterung:

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 Bytes

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

Maximaler Zeigermissbrauch! Benötigt eine Little-Endian-Maschine und 64-Bit-Longs.

Der Code enthält einige nicht druckbare Dateien, das Einfügen von Kopien sollte jedoch weiterhin funktionieren.

Probieren Sie es online!

Python, 81 Bytes

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

Oder gleiche Länge:

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

Perl 6 , 61 Bytes

Mit nicht druckbaren Zeichen, die als angezeigt werden (da StackExchange sie sonst entfernt):

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

Hier ist ein xxdHex-Dump:

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~^$_]}.

Erweiterte Version (nicht druckbare Zeichen werden durch Escape-Sequenzen ersetzt und Leerzeichen und Kommentare hinzugefügt):

{    # 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 Bytes

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

Probieren Sie es online!

Der zweite Buchstabe jedes Wortes identifiziert dieses Wort eindeutig, daher verwende ich dieses Zeichen als Variablennamen. Der Wert dieser Variablen ist das entsprechende andere Wort.

Zum Beispiel von dem zweiten Brief peaceist e, und das Wort entsprechend peaceist war, so dass ich eingestellte=war .

Bei einer gegebenen Eingabezeichenfolge wird das zweite Zeichen dieser Zeichenfolge als Variablenname verwendet, um das gewünschte entsprechende Wort unter Verwendung der indirekten Parametererweiterung von bash aufzurufen.

TI-Basic, 103 84 77 Bytes

Das Reduzieren auf einen Einzeiler sparte viele Bytes! Haha, wie ironisch diese Aussage war ...

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

Perl , 63 Bytes

62 Bytes + -pFlag.

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

Probieren Sie es online!

ordGibt den Zeichencode des ersten Zeichens des Eingabeworts zurück.
Nach dem %6haben wir:

- Freiheit => ord = 102 =>% 6 = 0  
- Sklaverei => ord = 115 =>% 6 = 1  
- Unwissenheit => ord = 105 =>% 6 = 3  
- Stärke => ord = 115 =>% 6 = 1  
- war => ord = 119 =>% 6 = 5  
- Frieden => ord = 112 =>% 6 = 4  

Also haben wir slavery und strengthbeide geben 1 zurück (da beide mit dem gleichen Buchstaben beginnen), und keiner gibt 2 zurück. Daher addieren wir 1for strength(es ist das einzige passende Wort /h/) und haben jedes Wort einem Index von 0 bis zugeordnet 5.

R 86 87 92 Bytes

Geändert zu einer unbenannten Funktion und gsubzu subeinigen Bytes. Mit wird grepfestgelegt, welche der 3 Zeichenfolgen verwendet wird, und die Eingabe wird mit aus dieser Zeichenfolge entfernt sub.

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

PHP, 70 Bytes

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

Befunge, 89 88 Bytes

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

Probieren Sie es online!

Erläuterung

Wir beginnen damit, dass wir alle möglichen Output-Strings null-terminiert auf den Stack legen. Diese Sequenz wird von rechts nach links ausgeführt, sodass die Werte umgekehrt verschoben werden, da dies die Reihenfolge ist, in der die Zeichen benötigt werden, wenn sie schließlich ausgegeben werden.
Wir lesen dann die ersten beiden Zeichen von stdin, was alles ist, was wir brauchen, um die Eingabezeichenfolge zu identifizieren. Wenn wir den ASCII-Wert des ersten Buchstabens Mod 2 plus des zweiten Buchstabens Mod 7 nehmen, erhalten wir eine eindeutige Zahl im Bereich von 2 bis 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

Diese Nummer kann dann als eine Art Index in die Zeichenfolgenliste auf dem Stapel verwendet werden. Wir dekrementieren den Index iterativ (das erste Mal um 2) und löschen für jede Iteration eine Zeichenfolge aus dem Stapel mit der Sequenz >_.
Sobald der Index Null erreicht, verbleibt die richtige Ausgabezeichenfolge am oberen Rand des Stapels. Daher verwenden wir eine einfache Zeichenfolgenausgabesequenz, um das Ergebnis in stdout zu schreiben.

Pyke, 29 Bytes

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

Probieren Sie es hier aus!

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

C 93

@ Arnauld's Antwort portiert auf C

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

C (GCC) , 113 108 Bytes

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

Alle Instanzen von \0können zu Bewertungszwecken durch tatsächliche NUL-Bytes ersetzt werden.

t+*--t-47ist undefiniertes Verhalten; Dies funktioniert möglicherweise nicht mit anderen Compilern.

Probieren Sie es online!

JavaScript (ES6), 71 78

Soviel langweilig als Arnauld's Antwort, aber auch kürzer.

Jetzt habe ich die Kodierung mit hinzugefügt btoa. In der codierten Zeichenfolge befinden sich 4 Bytes, die ich nicht auf dieser Site veröffentlichen kann, selbst wenn es sich um gültige Zeichen in einer JavaScript-Zeichenfolge handelt. Also habe ich ein Fluchtsymbol in der Form verwendet\xHH . Jedes dieser Escapes wird als 1 Byte gezählt.

Die codierte Zeichenfolge lautet strength0ignorance0peace0war0slavery0freedom

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

Dieser ist 82 und Groß- / Kleinschreibung wird nicht berücksichtigt

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

Prüfung

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)))

Jam, 52 (nur ASCII)

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

Probieren Sie es online aus

Hinweis: Bei den raumbezogenen Elementen handelt es sich um Tabulatorzeichen (eins vor und eins nach "EK {").

Erläuterung:

Der Teil bis "+" dekomprimiert die Zeichenfolge "slaveryjfreedomjwarjpeacejignorancejstrength" unter Verwendung der Basisumwandlung:
Zeichenfolge (behandelt als Array von Zeichencodes) → (Basis 144) Zahl → (Basis 26) Array von Zahlen → (Hinzufügen von 'a' zu jedem Zahl) Zeichenfolge

'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

> <> (Fisch), 84 78 Bytes

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

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

Probieren Sie es online!

Wir schwimmen von links oben nach rechts. Zuerst laden wir den Stack mit einer 0. Dann lesen wir den ersten Buchstaben von input ( i), verwerfen ihn ( ~), lesen den zweiten Buchstaben ( i) und reduzieren seinen ASCII-Wert modulo 10 (a% ). Dies ordnet a, e, r, l, g und t jeweils 7, 1, 4, 8, 3 und 6 zu - nennen wir diese Zahl N. .Ermittelt zwei Werte aus dem Stapel - N und 0 - und springt zu Zeile N, Zeichen 0.

Nach einem Sprung setzt der Fisch einen Tick fort, bevor er Anweisungen ausführt, ignoriert also das erste Zeichen und schwimmt über die Linie N, die das entsprechende Wort auf den Stapel lädt. Schließlich gehen wir zu Zeile 2, die den gesamten Stapel ausgibt und beendet.

• Mit einem Sprung sechs Bytes gespart, anstatt der zuvor verwendeten coolen Code-Selbstmodifikation. Naja.

JavaScript, 78 Byte

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

Dies ist eine Art Port meiner Python-Antwort . Wir speichern die Wörter in einer Zeichenfolge, wobei sich jedes an der entgegengesetzten Position zu seinem Gegenstück befindet. Wir finden den Index des gegebenen Wortes wund erhalten diesen Index am Ende, um das Ergebnis zurückzugeben.

Testschnipsel:

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 ist ein interaktiver Interpreter, wir brauchen kein "print" -cmd für die Ausgabe; Das Try-It_Online-Dienstprogramm benötigt jedoch ein "print" -cmd, daher habe ich dieses in die "footer" getrennt.
Wir definieren eine "Objekt-Funktion" (der Buchstabe O erinnert mich sehr an die Orwell-Funktion ... ;-)):

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

Rufen Sie danach an

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

Probieren Sie es online!

(Beachten Sie, dass die hier angegebenen Token in Pari / GP keine Zeichenfolgen, sondern zulässige Variablennamen sind! Diesen Variablen sollte niemals ein Wert zugewiesen werden.)

Gestapelt, 70 Bytes

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

Probieren Sie es hier aus! Übernimmt die Eingabe im Stapel und belässt die Ausgabe im Stapel. Zum Beispiel:

'war'

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

out

Dieser Code ist ziemlich selbsterklärend. Leicht modifiziert, um alle Testfälle auszuführen:

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

Jolf, 35 Bytes

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

Es gibt viele nicht druckbare Dateien. Hier ist ein Hexdump, der allerdings nicht viel bringt:

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

Hier ist ein Online-Link.

Grundsätzlich sieht der Code so aus:

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

Eigentlich 56 Bytes

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

Probieren Sie es online!

Leider ist es ohne eingebaute Komprimierung kürzer, die Zeichenfolge nicht zu komprimieren und manuell zu dekomprimieren.

Erläuterung:

' "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 Bytes

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

Idee:

• Führen Sie die Schlüsselwörter so auf, dass ihr Gegenüber 3 Positionen entfernt ist
• Nehmen Sie das Schlüsselwort, ermitteln Sie seine Position fromEnum, bewegen Sie sich 3 Schritte nach rechts (Modul 6) und konvertieren Sie es zurück in das Schlüsselwort
• Dies ::Oist erforderlich, da die Typinferenz einige Probleme aufweist. Geben Sie feine Signatur f :: O -> Ohätte den gleichen Effekt aber ist nicht so kurz.

Bearbeiten:

Ersetzt

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

durch

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

danke an @Laikoni.

Dyalog APL , 66 Bytes

Eines davon:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞verwendet diese Methode (erfordert, ⎕IO←0was auf vielen Systemen Standard ist).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ führt eine Suche durch und wählt dann das entsprechende Element aus der umgekehrten Liste aus.

Qbasic, 138 99 Bytes

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

D$speichert alle Wörter von der linken Seite des Mantras, dann alle der rechten Seite. Jedes Wort wird mit Leerzeichen auf genau 9 Buchstaben pro Wort aufgefüllt. D$dann wird an sich selbst angehängt.

Dann instrwird der Index des vom Benutzer eingegebenen Wortes ermittelt. Der andere Teil des Mantras wird immer genau 9 * 3 Stellen weiter in der Zeichenkette gespeichert, also drucken wir einen Teilstring, der an dieser Stelle beginnt und 9 Zeichen benötigt.

SmileBASIC, 92 Bytes

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

Python , 80 Bytes

Irgendwie hat xnor die Nase voll!

Dies ist eine unbenannte Lambda-Funktion, die das Ergebnis zurückgibt.

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

Probieren Sie es online!

Die Liste der Wörter ist so angeordnet, dass sie sich jeweils in der entgegengesetzten Position zu ihrem Gegenstück befinden. Wenn das Wort gegeben ist w, finden wir seinen Index in der Wortliste und dann bitweise NOT ( ~). Dies kippt alle Bits, die berechnet werdenn => -n-1 . Erhält aufgrund der negativen Indizierung von Python den entgegengesetzten Index in der Liste.

Als eine Art unbeabsichtigten Bonus können Sie dieser Funktion als zweites Argument eine beliebige Wortliste von Gegensätzen übergeben.