ジョージ・オーウェルが書いた1984：

戦争は平和です
自由は奴隷です
無知は強さです

Orwell引用から6つの主要な単語の1つを取り込んで対応するものを出力するプログラムまたは関数を作成します。

具体的には：

[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とインデックスのXOR
• そのインデックスでリスト内の要素を取得します

JavaScript（ES6）、80バイト

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

使い方

各単語の2番目の文字の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ị»

Jellyの辞書にインデックスを付けて文字列を作成します

strength war peace freedom slavery ignorance

Ḳスペースで分割して文字列配列を生成します

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

µ 引数として文字列配列を使用して、現在の戻り値でもある新しいモナドチェーンを開始します。

ɠSTDINから1行の入力を読み取り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で文字列を「乗算」して評価せずにおくことができるという事実に基づいています（2つの未割り当て変数の乗算に似ていますx*y）が、Mathematicaは除算の要素をキャンセルするなどの基本的な単純化を適用します

だから我々は、中の製品として3組を格納することによって開始しx、y、zそれぞれ、と一緒にすべてを掛け：

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

これは評価する

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

（Mathematicaは自動的に因子をソートしますが、順序は気にしません。）

私たちは言葉削除するために入力することで、これを分割していないとの希望を.../#Mathematicaは要因をキャンセルするので、。たとえば、入力が次のようになった場合"peace"：

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

最後に、我々は、各代入することにより、我々は興味がないのペアを取り除くx、yとzしてを1。繰り返しますが、Mathematicaの簡素化1*aは常にそうaです。この部分は以下で行われます：

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

素晴らしいことは、乗算がMathematicaにあることを知っているOrderlessので、製品内で隣接しているかどうかに関係なく、2つの要因を見つけることができるということです。入力と反対の単語のみが製品でペアリングされないため、削除されず、唯一の出力として残ります。

Vim、60バイト

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

オンラインでお試しください！下位互換性のあるVインタープリター。

もちろん、Vに切り替えると、より便利な入力方法を使用して1バイトを節約できます。しかし、これは非常に小さな違いなので、ゴルフ以外のバージョンを使用することをお勧めします。

説明：

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}

オンラインでお試しください！

各単語の2文字目はその単語を一意に識別するため、その文字を変数名として使用します。その変数の値は、対応する他の単語です。

たとえば、peaceis の2番目の文字とis eに対応する単語peaceはwar、に設定されていe=warます。

入力文字列が与えられると、その文字列の2番目の文字が変数名として使用され、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  
-戦争=> ord = 119 =>％6 = 5  
-平和=> ord = 112 =>％6 = 4  

したがってslavery、strength両方が1を返し（両方とも同じ文字で始まるため）、どれも2を返しません。したがって、（一致する唯一の単語です）を追加1し、各単語を0から0のインデックスにマップします。 5。strength/h/

R、86 87 92バイト

名前のない関数と数バイトに変更さgsubれsubました。grep3列の判定するが使用され、入力が付き、その文字列から除去されます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:-<
@>:#,_

オンラインでお試しください！

説明

可能なすべての出力文字列をスタックにプッシュし、ヌルで終了することから始めます。このシーケンスは右から左に実行されるため、値は逆にプッシュされます。これは、文字が最終的に出力されるときに必要になる順序だからです。
次に、入力文字列を識別するために必要なstdinから最初の2文字を読み取ります。最初の文字mod 2のASCII値と2番目の文字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ずつ）、反復ごとにsequenceでスタックから1つの文字列をクリアします>_。
インデックスがゼロに達すると、スタックの最上部に正しい出力文字列が残るため、単純な文字列出力シーケンスを使用して結果をstdoutに書き込みます。

パイク、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

Cに移植された@Arnauldの回答

#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。エンコードされた文字列には、JavaScript文字列の有効な文字であっても、このサイトに投稿できない4バイトがあります。だから私はフォームで16進エスケープを使用しました\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」ストリングを解凍し
ています。番号）文字列

'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（~）を読み取り、破棄（）、2番目の文字（i）を読み取り、ASCII値のモジュロ10（a%）を減らします。これは、a、e、r、l、g、およびtをそれぞれ7、1、4、8、3、および6にマップします。この番号Nを呼び出しましょう。.スタックから2つの値、Nと0をポップし、ジャンプします。行N、文字0。

ジャンプの後、魚は命令を実行する前に1ティック進むため、最初の文字を無視して行Nを泳ぎ、対応する単語をスタックにロードします。最後に2行目に進み、スタック全体を出力して終了します。

• 以前使用したクールなコードの自己修正の代わりに、ジャンプを使用して6バイトを節約しました。しかたがない。

JavaScript、78バイト

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

これは私のPython answerの一種の移植です。単語を文字列に保存し、それぞれが対応する単語と反対の位置にあるようにします。与えられたwordのインデックスを見つけ、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"))

パリ/ 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γ

多くの印刷できないものがあります。これは16進ダンプですが、あまり役に立ちません。

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、104 111バイト

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 w,a="war slavery ignorance strength freedom peace".split():a[~a.index(w)]

オンラインでお試しください！

単語のリストは、それぞれが対応するものとは反対の位置になるように配置されます。単語が与えられると、単語wリストでそのインデックスを見つけ、ビットごとにNOT（~）します。これにより、すべてのビットが反転しますn => -n-1。Pythonのネガティブインデックスにより、リストの反対のインデックスを取得します。

一種の意図しないボーナスとして、この関数の反対の単語リストを2番目の引数として渡すことができます。