正如乔治·奥威尔（George Orwell）在1984年写道：

战争是和平
自由是奴隶制
无知是力量

编写一个程序或函数，该程序或函数接受Orwell引号中的六个主要词之一，并输出其对应词。

特别：

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

不需要其他输入/输出对。

如上所述，您应该假设单词始终全部为小写。或者，你可以假设的话总是完全大写：WAR -> PEACE，PEACE -> WAR，等。

以字节为单位的最短代码获胜。

05AB1E，30个字节

05AB1E使用CP-1252。

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

在线尝试！或作为测试套件

说明

直截了当的方法

• 推弦 ignorance strength war peace freedom slavery
• 在空格上分割
• 获取列表中输入的索引
• 将索引与1异或
• 在该索引处获取列表中的元素

JavaScript（ES6），80个字节

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

这个怎么运作

我们使用一个小的查询表，该查询表基于每个单词的第二个字符的ASCII码，返回其对应的索引。

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

附带说明一下，如果允许使用大小写混合的情况，则使用war PEACE FREEDOM slavery IGNORANCE strength模6将导致完美的哈希。

测试

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

果冻，24字节

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

在线尝试！

这个怎么运作

一，代币

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

索引果冻的字典以创建字符串

strength war peace freedom slavery ignorance

它Ḳ在空格处分割以产生字符串数组

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

µ 以该字符串数组作为参数开始一个新的单子链，这也是当前的返回值。

ɠ从STDIN读取一行输入，并i找到其上一个返回值的索引，即生成的字符串数组。

现在，^1对该索引和1进行按位XOR运算。对于偶数索引-记住，果冻索引是1基和模块化的，所以强度具有索引1和无知具有索引6 / 0 -这将索引递增; 对于奇数索引，它会使它们递减。

最后，ị从链的参数中检索该索引处的字符串。

Mathematica，84个字节

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

说明

带有字符串的更多“算术”！就像在链接的答案中一样，这是基于以下事实：您可以在Mathematica中“乘以”字符串，这将使它们保持未赋值的状态（类似于将两个未分配的变量相乘x*y），但是Mathematica将应用基本的简化方法，例如消除除法中的因子。

因此，我们首先将三对作为乘积存储在x，中y，z然后将它们全部相乘：

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

这评估为

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

（Mathematica会自动对因素进行排序，但我们不在乎顺序。）

我们通过将输入除以该删除我们的话不与希望.../#，因为数学取消的因素。例如，如果输入是"peace"我们的最终结果：

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

最后，我们摆脱我们不感兴趣的对，通过替换每一个x，y并z用1。同样，Mathematica的简化1*a总是如此a。这部分完成：

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

令人高兴的是，Mathematica知道乘法就是Orderless这样，所以无论它们在乘积中是否相邻，这都将找到两个因子。产品中仅不再与输入相反的单词配对，因此不会删除一个单词并将其保留为唯一输出。

Vim，60个字节

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

在线尝试！在向后兼容的V解释器中。

当然，如果要切换到V，则可以使用更方便的输入法来节省一个字节。但是由于这是一个很小的差异，所以我宁愿使用非高尔夫版本。

说明：

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字节

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

最大程度的滥用指针！需要使用低端字节序的计算机和64位long。

该代码包含一些不可打印的内容，但复制粘贴仍应起作用。

在线尝试！

Python，81个字节

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

或者，相同长度：

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

Perl 6，61字节

不可打印字符显示为 （因为StackExchange否则将其剥离）：

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

这是一个xxd十六进制转储：

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

扩展版本（无法打印的字符替换为转义序列，并添加了空格和注释）：

{    # 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字节

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

在线尝试！

每个单词的第二个字母唯一地标识该单词，因此我将该字符用作变量名。该变量的值是对应的另一个单词。

例如，第二届信peace是e，和对应的词peace是war，所以我设置e=war。

给定输入字符串，该字符串的第二个字符用作变量名，以使用bash的间接参数扩展来提取所需的相应单词。

TI-Basic，103 84 77字节

减少到单线可节省大量字节！哈哈，那句话多么讽刺...

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

Perl，63个字节

62个字节+ -p标志。

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

在线尝试！

ord返回输入单词的第一个字符的字符代码。
之后%6，我们有：

-自由=> ord = 102 =>％6 = 0  
-奴隶制=> ord = 115 =>％6 = 1  
-无知=> ord = 105 =>％6 = 3  
-强度=> ord = 115 =>％6 = 1  
-战争=>奥德= 119 =>％6 = 5  
-和平=> ord = 112 =>％6 = 4  

因此，我们都有slavery并且strength都返回1（因为它们都以相同的字母开头），并且都不返回2。因此，我们将1for 添加strength（这是唯一将匹配的单词/h/），并且我们将每个单词映射到从0到索引的索引5，

R，86 87 92字节

更改为一个未命名的函数，并gsub更改sub为几个字节。在grep这3个串的确定的使用量和输入从该字符串移除sub。

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

PHP，70个字节

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

Befunge，89 88字节

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

在线尝试！

说明

我们首先将所有可能的输出字符串压入堆栈，以null终止。此序列从右到左执行，因此将值反向推入，因为这是最终输出字符时需要的顺序。
然后，我们从stdin中读取前两个字符，这是识别输入字符串所需的全部。如果我们采用第一个字母mod 2的ASCII值加上第二个字​​母mod 7，我们将获得2到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

然后，该数字可用作堆栈中字符串列表的一种索引。我们迭代地将索引递减（第一次递减2），对于每次迭代，我们使用序列从堆栈中清除一个字符串>_。
一旦索引达到零，我们将在堆栈顶部保留正确的输出字符串，因此我们使用简单的字符串输出序列将结果写入stdout。

Pyke，29个字节

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

在这里尝试！

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

C，93

@Arnauld的答案已移植到C

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

C（gcc），113108字节

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

\0出于评分目的，可以将所有的实例替换为实际的NUL字节。

t+*--t-47是未定义的行为；这可能/将不适用于其他编译器。

在线尝试！

JavaScript（ES6），71 78

比Arnauld的答案无聊得多，但也更简短。

现在，我使用添加了编码btoa。编码的字符串中有4个字节，即使它们是JavaScript字符串中的有效字符，也无法发布到此站点。因此，我使用了形式的十六进制转义符\xHH。这些转义中的每一个都计为1个字节。

编码的字符串是 strength0ignorance0peace0war0slavery0freedom

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

这个是82，不区分大小写

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

测试

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（仅ASCII）

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

在线尝试

注意：空格表示的是制表符（“ EK {”之前和之后的一个）

说明：

直到“ +”的部分正在使用基本转换解压缩“ slaveryjfreedomjwarjpeacejignorancejstrength”字符串，该字符串使用基本转换：
字符串（视为字符代码数组）→（基本144）数字→（基本26）数字数组→（向每个数字添加“ a”数字）字符串

'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

> <>（鱼），84 78字节

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

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

在线尝试！

我们从左上方开始向右游泳。首先，将0加载到堆栈中。然后，读取输入（i）的第一个字母，舍弃它（~），读取第二个字母（i），然后将其ASCII值取模10（a%）。它将a，e，r，l，g和t分别映射为7、1、4、8、3和6（我们将其称为N）。.从堆栈中弹出两个值N和0，然后跳转到第N行，字符0。

跳转之后，鱼在执行指令之前会进行一次滴答，因此它会忽略第一个字符并游过N行，这会将相应的单词加载到堆栈中。最后，我们转到第2行，该行输出整个堆栈并退出。

• 通过使用跳转来节省六个字节，而不是之前使用的很酷的代码自我修改。那好吧。

JavaScript，78个字节

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

这是我的Python答案的一种形式。我们将单词存储在字符串中，每个单词的位置与其对应的单词相反。我们找到给定单词的索引w，然后从末尾获取该索引，以返回结果。

测试代码段：

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字节

Pari / GP是一个交互式解释器，我们不需要输出“ print” -cmd；但是，Try-It_Online-utility需要一个“ print” -cmd，因此我将其分隔为“页脚”。
我们定义了一个“对象函数”（字母O让我想起了奥威尔函数... ;-)）：

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

之后，致电

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

在线尝试！

（请注意，在Pari / GP中，此处给出的标记不是字符串，而是合法的变量名！该变量永远不应分配任何值）

堆叠，70字节

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

在这里尝试！在堆栈上接受输入，而在堆栈上保留输出。例如：

'war'

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

out

这段代码是不言自明的。稍作修改即可运行所有测试用例：

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

Jolf，35个字节

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

有许多不可打印的东西。这是一个十六进制转储，尽管效果不佳：

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

这是一个在线链接。

基本上，代码如下所示：

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

实际上是56个字节

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

在线尝试！

不幸的是，没有任何压缩内置函数，不压缩字符串并手动将其解压缩的时间要短一些。

说明：

' "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，104111字节

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

理念：

• 枚举关键字，使它们的对等词位于3个位置之外
• 取得关键字，通过定位fromEnum，向右移动3步（模数为6），然后转换回关键字
• ::O之所以需要，是因为类型推断存在一些问题。给人f签名f :: O -> O也有同样的效果，但并不短。

编辑：

已更换

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

通过

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

感谢@Laikoni。

Dyalog APL，66 字节

这些之一：

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞使用此方法（需要⎕IO←0在许多系统上使用默认方法）。

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ 查找，然后从反向列表中选择相应的元素。

Qbasic，138 99字节

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

D$存储来自咒语左侧的所有单词，然后存储右侧的所有单词。每个单词都用空格填充，每个单词恰好有9个字母。D$然后附加到自身。

然后instr用于查找用户输入的单词的索引。咒语的另一部分始终精确地存储在字符串中9 * 3个位置，因此我们从该位置开始打印一个子字符串，使用9个字符。

SmileBASIC，92个字节

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

Python，80个字节

不知何故超出了xnor！

这是一个未命名的lambda函数，它返回结果。

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

在线尝试！

单词列表的排列方式使其分别处于与相应单词相反的位置。给定单词w，我们在单词列表中找到它的索引，然后按位非（~）。这将翻转所有位，即computes n => -n-1。由于Python的负索引，因此在列表中获取相反的索引。

作为一种无意的奖励，您可以将与此相反的任何单词列表作为第二个参数传递给此函数。