ตามที่George Orwellเขียนใน1984 :

สงครามคือสันติภาพ
เสรีภาพเป็นทาส
ความไม่รู้เป็นพลัง

เขียนโปรแกรมหรือฟังก์ชั่นที่ใช้หนึ่งในหกคำหลักจาก Orwell quote และส่งออกคู่ของมัน

โดยเฉพาะ:

[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กับ modulo 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"]

µ เริ่มต้นห่วงโซ่ monadic ใหม่โดยมีอาร์เรย์สตริงนั้นเป็นอาร์กิวเมนต์ซึ่งเป็นค่าส่งคืนปัจจุบัน

ɠอ่านอินพุตหนึ่งบรรทัดจาก STDIN และiค้นหาดัชนีของค่าส่งคืนก่อนหน้านั่นคืออาร์เรย์สตริงที่สร้างขึ้น

ตอนนี้^1จะใช้เวลา XOR บิตของดัชนีที่และ1 สำหรับดัชนีแม้ - จำไว้ว่าดัชนีวุ้นเป็น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 จะเรียงลำดับปัจจัยโดยอัตโนมัติ แต่เราไม่สนใจคำสั่งซื้อ)

เราหารสิ่งนี้โดยอินพุตเพื่อลบคำที่เราไม่ต้องการด้วย.../#เนื่องจาก Mathematica จะยกเลิกปัจจัยต่างๆ เช่นถ้า"peace"เราป้อนข้อมูลลงเอยด้วย

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

สุดท้ายเราได้รับการกำจัดคู่เราไม่ได้สนใจในโดยการแทนแต่ละx, yและกับz 1อีกครั้ง Mathematica ของความบันเทิงความเรียบง่ายในการที่อยู่เสมอ1*a aส่วนนี้ทำด้วย:

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

สิ่งที่ดีคือ Mathematica รู้ดีว่าการคูณคือOrderlessสิ่งนี้จะพบสองปัจจัยโดยไม่คำนึงถึงว่าพวกมันอยู่ติดกับผลิตภัณฑ์หรือไม่ เฉพาะคำที่ตรงข้ามกับอินพุตเท่านั้นที่จะไม่ถูกจับคู่ในผลิตภัณฑ์ดังนั้นจะไม่ถูกลบออกและยังคงเป็นเอาท์พุทเพียงอย่างเดียว

เป็นกลุ่ม 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 บิต

รหัสประกอบด้วย unprintables ไม่กี่ แต่การวางสำเนาควรยังคงทำงาน

ลองออนไลน์!

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 bytes

ด้วยอักขระที่ไม่สามารถพิมพ์ได้ที่แสดงเป็น (เพราะ StackExchange จะแยกเป็นอย่างอื่น):

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

นี่คือการxxdถ่ายโอนข้อมูล hex:

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 ของpeaceเป็นeและคำที่สอดคล้องกับการpeaceเป็นดังนั้นฉันตั้งware=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เรามี:

- freedom => ord = 102 =>% 6 = 0  
- ทาส => ord = 115 =>% 6 = 1  
- ignorance => ord = 105 =>% 6 = 3  
- strength => ord = 115 =>% 6 = 1  
- war => ord = 119 =>% 6 = 5  
- peace => ord = 112 =>% 6 = 4  

ดังนั้นเราจึงมีslaveryและstrengthทั้งสองกลับ 1 (ตั้งแต่พวกเขาทั้งสองเริ่มต้นด้วยตัวอักษรเดียวกัน) และไม่มีใครกลับมา 2. ดังนั้นเราเพิ่ม1สำหรับstrength(เป็นคำเดียวที่จะตรง/h/) และเรามีคำแต่ละคำแมปกับดัชนีจาก 0 ถึง 5

R, 86 87 92 Bytes

เปลี่ยนเป็นฟังก์ชั่นที่ไม่มีชื่อและ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:-<
@>:#,_

ลองออนไลน์!

คำอธิบาย

เราเริ่มต้นด้วยการกดสตริงเอาต์พุตที่เป็นไปได้ทั้งหมดลงในสแต็ก ลำดับนี้ถูกดำเนินการจากขวาไปซ้ายดังนั้นค่าจะถูกส่งกลับเนื่องจากนั่นเป็นลำดับอักขระที่จะต้องใช้เมื่อพวกมันถูกส่งออกในที่สุด
จากนั้นเราอ่านตัวละครสองตัวแรกจาก stdin ซึ่งเป็นสิ่งที่เราต้องระบุสายป้อน ถ้าเราใช้ค่า ASCII ของตัวอักษรตัวแรก mod 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) >_และสำหรับแต่ละซ้ำเราล้างหนึ่งสายจากสแต็คที่มีลำดับ
เมื่อดัชนีถึงศูนย์เราจะเหลือสตริงเอาท์พุทที่ถูกต้องที่ด้านบนของสแต็กดังนั้นเราจึงใช้ลำดับเอาต์พุตสตริงอย่างง่ายเพื่อเขียนผลลัพธ์ไปยัง 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) , 113 108 ไบต์

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 ไบต์ที่ฉันไม่สามารถโพสต์ในเว็บไซต์นี้แม้ว่าพวกเขาจะเป็นตัวละครที่ถูกต้องในสตริงจาวาสคริปต์ \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)]

นี้เป็นชนิดของพอร์ตของฉันคำตอบหลาม เราเก็บคำในสตริงโดยที่แต่ละคำนั้นอยู่ในตำแหน่งตรงกันข้ามกับคู่ของมัน เราค้นหาดัชนีของคำที่กำหนด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 ดังนั้นฉันจึงแยกมันออกเป็น "footer"
เราให้คำจำกัดความว่า "object-function" (ตัวอักษร O ทำให้ฉันนึกถึง Orwell-function ... ;-)):

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γ

มีหลาย unprintables นี่คือ hexdump แม้ว่ามันจะไม่ทำได้ดีมาก:

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 bytes

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เราหาดัชนีในรายการคำแล้ว bitwise ไม่ ( ~) มัน n => -n-1นี้พลิกบิตทั้งหมดซึ่งเป็นคำนวณ เนื่องจากการจัดทำดัชนีเชิงลบของงูหลามได้รับดัชนีตรงกันข้ามในรายการ

เป็นโบนัสที่ไม่ได้ตั้งใจคุณสามารถส่งรายการคำศัพท์ตรงข้ามใด ๆ ไปยังฟังก์ชันนี้เป็นอาร์กิวเมนต์ที่สอง