Như George Orwell đã viết vào năm 1984 :

Chiến tranh là hòa bình
Tự do là nô lệ
Vô minh là sức mạnh

Viết chương trình hoặc chức năng lấy một trong sáu từ chính từ trích dẫn Orwell và xuất ra bản sao của nó.

Đặc biệt:

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

Không có cặp đầu vào / đầu ra khác được yêu cầu.

Bạn nên giả sử các từ luôn luôn là chữ thường, như trên. Ngoài ra, bạn có thể đảm nhận lời luôn chữ hoa đầy đủ: WAR -> PEACE, PEACE -> WARvv

Mã ngắn nhất tính bằng byte thắng.

05AB1E , 30 byte

05AB1E sử dụng CP-1252 .

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

Hãy thử trực tuyến! hoặc như một bộ thử nghiệm

Giải trình

Cách tiếp cận thẳng về phía trước

• Đẩy chuỗi ignorance strength war peace freedom slavery
• Tách trên không gian
• Lấy chỉ mục của đầu vào trong danh sách
• XOR chỉ số với 1
• Lấy phần tử trong danh sách tại chỉ mục đó

JavaScript (ES6), 80 byte

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

Làm thế nào nó hoạt động

Chúng tôi sử dụng một bảng tra cứu nhỏ dựa trên mã ASCII của ký tự thứ 2 của mỗi từ, trả về chỉ mục của đối tác của nó.

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

Như một lưu ý phụ, nếu trường hợp hỗn hợp được cho phép, sử dụng war PEACE FREEDOM slavery IGNORANCE strengthvới modulo 6 sẽ dẫn đến một hàm băm hoàn hảo.

Kiểm tra

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

Thạch , 24 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Đầu tiên, mã thông báo

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

lập chỉ mục vào từ điển của Jelly để tạo chuỗi

strength war peace freedom slavery ignorance

mà Ḳchia ở không gian để mang lại mảng chuỗi

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

µ bắt đầu một chuỗi mới, đơn âm, với mảng chuỗi đó làm đối số của nó, cũng là giá trị trả về hiện tại.

ɠđọc một dòng đầu vào từ STDIN và itìm chỉ mục của giá trị trả về trước đó, tức là mảng chuỗi được tạo.

Bây giờ, ^1lấy XOR bitwise của chỉ mục đó và 1 . Đối với chỉ số thậm chí - hãy nhớ rằng chỉ số Jelly là 1 dựa trên và mô-đun, vì vậy sức mạnh có chỉ số 1 và sự thiếu hiểu biết có chỉ số 6 / 0 - đây increments chỉ số; cho các chỉ số lẻ, nó giảm chúng.

Cuối cùng, ịlấy chuỗi tại chỉ mục đó từ đối số của chuỗi.

Toán học, 84 byte

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

Giải trình

Thêm "số học" với chuỗi! Như trong câu trả lời được liên kết, điều này dựa trên thực tế là bạn có thể "nhân" các chuỗi trong Mathicala, điều này sẽ khiến chúng không được đánh giá (tương tự như nhân hai biến không được gán x*y), nhưng Mathicala sẽ áp dụng các đơn giản hóa cơ bản, như hủy bỏ các yếu tố trong một phép chia.

Vì vậy, chúng ta bắt đầu bằng cách lưu trữ ba cặp như các sản phẩm trong x, y, z, tương ứng và nhân chúng lại với nhau:

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

Điều này đánh giá

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

(Mathematica tự động sắp xếp các yếu tố, nhưng chúng tôi không quan tâm đến thứ tự.)

Chúng tôi chia điều này cho đầu vào để loại bỏ từ mà chúng tôi không muốn .../#, vì Mathematica hủy bỏ các yếu tố. Ví dụ: nếu đầu vào là "peace"cuối cùng chúng ta sẽ:

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

Cuối cùng, chúng ta thoát khỏi những cặp chúng tôi không quan tâm, bằng cách thay thế mỗi x, yvà zvới 1. Một lần nữa, sự đơn giản hóa của Mathicala 1*aluôn luôn được áp dụng a. Phần này được thực hiện với:

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

Điều tuyệt vời là Mathicala biết rằng phép nhân là Orderlessdo đó điều này sẽ tìm thấy hai yếu tố bất kể chúng có liền kề nhau trong sản phẩm hay không. Chỉ từ đối diện với đầu vào không còn được ghép nối trong sản phẩm, do đó từ này sẽ không bị xóa và vẫn là đầu ra duy nhất.

Vim, 60 byte

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

Hãy thử trực tuyến! trong trình thông dịch V tương thích ngược.

Tất nhiên, nếu chúng ta chuyển sang V, chúng ta có thể tiết kiệm một byte bằng cách sử dụng phương thức nhập thuận tiện hơn. Nhưng vì đây là một sự khác biệt nhỏ nên tôi thích sử dụng phiên bản không chơi gôn.

Giải trình:

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

Lạm dụng con trỏ tối đa! Yêu cầu một máy endian nhỏ và dài 64 bit.

Mã này chứa một vài dấu vết không thể in được, nhưng sao chép vẫn hoạt động.

Hãy thử trực tuyến!

Python, 81 byte

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

Hoặc, cùng chiều dài:

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

Perl 6 , 61 byte

Với các ký tự không thể in được hiển thị là (vì StackExchange loại bỏ chúng theo cách khác):

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

Đây là một xxdbãi chứa 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~^$_]}.

Phiên bản mở rộng (các ký tự không thể thay thế được thay thế bằng các chuỗi thoát và thêm khoảng trắng & nhận xét):

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

Hãy thử trực tuyến!

Chữ cái thứ 2 của mỗi từ xác định duy nhất từ ​​đó, vì vậy tôi sử dụng ký tự đó làm tên biến; giá trị của biến đó là từ khác tương ứng.

Ví dụ, chữ cái thứ 2 peacelà evà từ tương ứng peacelà war, vì vậy tôi đặt e=war.

Đưa ra một chuỗi đầu vào, ký tự thứ 2 của chuỗi đó được sử dụng làm tên biến để kéo lên từ tương ứng mong muốn, sử dụng mở rộng tham số gián tiếp của bash.

TI-Basic, 103 84 77 byte

Giảm xuống một lớp lót đã lưu rất nhiều byte! Haha, câu nói đó thật mỉa mai ...

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

Perl , 63 byte

62 byte + -pcờ.

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

Hãy thử trực tuyến!

ordtrả về mã char của ký tự đầu tiên của từ đầu vào.
Sau đó %6, chúng tôi có:

- tự do => ord = 102 =>% 6 = 0  
- chế độ nô lệ => ord = 115 =>% 6 = 1  
- thiếu hiểu biết => ord = 105 =>% 6 = 3  
- sức mạnh => ord = 115 =>% 6 = 1  
- chiến tranh => ord = 119 =>% 6 = 5  
- hòa bình => ord = 112 =>% 6 = 4  

Vì vậy, chúng tôi có slaveryvà strengthcả hai trở về 1 (vì cả hai đều bắt đầu bằng chữ giống nhau), và không ai trở về 2. Do đó, chúng tôi thêm 1cho strength(đó là từ duy nhất mà sẽ phù hợp /h/), và chúng tôi có mỗi từ ánh xạ tới một chỉ số từ 0 đến 5.

R, 86 87 92 byte

Thay đổi để một chức năng vô danh và gsubđể subcho một vài byte. Các grepxác định 3 dây được sử dụng và các đầu vào được lấy ra từ đó chuỗi với 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:-<
@>:#,_

Hãy thử trực tuyến!

Giải trình

Chúng tôi bắt đầu bằng cách đẩy tất cả các chuỗi đầu ra có thể lên ngăn xếp, kết thúc bằng không. Chuỗi này được thực hiện từ phải sang trái để các giá trị được đẩy ngược lại, vì đó là thứ tự các ký tự sẽ cần khi cuối cùng chúng xuất ra.
Sau đó chúng tôi đọc hai ký tự đầu tiên từ stdin, đó là tất cả những gì chúng tôi cần để xác định chuỗi đầu vào. Nếu chúng ta lấy giá trị ASCII của chữ cái đầu tiên mod 2, cộng với chữ cái thứ hai mod 7, chúng ta sẽ nhận được một số duy nhất trong phạm vi từ 2 đến 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

Số này sau đó có thể được sử dụng như một loại chỉ mục vào danh sách chuỗi trên ngăn xếp. Chúng tôi lặp lại giảm chỉ số (lần đầu tiên bằng 2) và với mỗi lần lặp, chúng tôi xóa một chuỗi khỏi ngăn xếp với chuỗi >_.
Khi chỉ mục về 0, chúng ta sẽ để lại chuỗi đầu ra chính xác ở đầu ngăn xếp, vì vậy chúng tôi sử dụng chuỗi đầu ra chuỗi đơn giản để ghi kết quả vào thiết bị xuất chuẩn.

Pyke, 29 byte

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

Hãy thử nó ở đây!

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

C, 93

Câu trả lời của @ Arnauld được chuyển đến 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);}

Tất cả các trường hợp \0có thể được thay thế bằng byte NUL thực tế cho mục đích ghi điểm.

t+*--t-47là hành vi không xác định; điều này có thể / sẽ không hoạt động với các trình biên dịch khác.

Hãy thử trực tuyến!

JavaScript (ES6), 71 78

Quá nhàm chán so với câu trả lời của Arnauld, nhưng cũng ngắn hơn.

Bây giờ tôi đã thêm mã hóa với btoa. Trong chuỗi được mã hóa có 4 byte mà tôi không thể đăng lên trang web này, ngay cả khi chúng là các ký tự hợp lệ trong chuỗi javascript. Vì vậy, tôi đã sử dụng một lối thoát hex trong mẫu \xHH. Mỗi một trong những lần thoát này được tính là 1 byte.

Chuỗi được mã hóa là strength0ignorance0peace0war0slavery0freedom

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

Đây là 82 và trường hợp không nhạy cảm

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

Kiểm tra

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 (chỉ ASCII)

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

Dùng thử trực tuyến

Lưu ý: những thứ trông như không gian là các ký tự tab (một trước và một sau "EK {")

Giải trình:

Phần lên đến "+" đang giải nén chuỗi "slaveryjfreedomjwarjpeacejignorancejst cường", sử dụng chuyển đổi cơ sở:
chuỗi (được coi là mảng mã ký tự) → (cơ sở 144) số → (cơ sở 26) cho mỗi số số) chuỗi

'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

> <> (Fish), 84 78 byte

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

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

Hãy thử trực tuyến!

Chúng tôi bắt đầu bơi từ phía trên bên trái, hướng sang phải. Đầu tiên chúng ta tải stack bằng 0. Sau đó, chúng ta đọc chữ cái đầu tiên của đầu vào ( i), loại bỏ nó ( ~), đọc chữ cái thứ hai ( i) và giảm giá trị ASCII modulo 10 ( a%). Điều này ánh xạ a, e, r, l, g và t thành 7, 1, 4, 8, 3 và 6, tương ứng, Hãy gọi số này là N. .bật hai giá trị từ ngăn xếp N và 0 và nhảy vào dòng N, ký tự 0.

Sau khi nhảy, con cá tiến hành một tích tắc trước khi thực hiện các hướng dẫn, vì vậy nó bỏ qua ký tự đầu tiên và bơi qua dòng N, tải từ tương ứng lên ngăn xếp. Cuối cùng, chúng ta đi đến dòng 2, đầu ra toàn bộ ngăn xếp và thoát.

• Đã lưu sáu byte bằng cách sử dụng một bước nhảy, thay vì tự sửa đổi mã mát mẻ mà tôi đã sử dụng trước đây. Ồ tốt

JavaScript, 78 byte

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

Đây là một loại cổng của câu trả lời Python của tôi . Chúng tôi lưu trữ các từ trong một chuỗi trong đó mỗi từ ở vị trí đối diện với đối tác của nó. Chúng tôi tìm chỉ mục của từ đã cho wvà lấy chỉ mục đó từ cuối để trả về kết quả.

Đoạn kiểm tra:

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 là một trình thông dịch tương tác, chúng tôi không cần "in" -cmd cho đầu ra; tuy nhiên, tiện ích Try-It_Online cần "in" -cmd vì vậy tôi đã tách phần này thành "chân trang".
Chúng tôi định nghĩa một "hàm đối tượng" (chữ O nhắc nhở tôi đáng yêu về hàm Orwell ... ;-)):

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

Sau đó, gọi

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

Hãy thử trực tuyến!

(Lưu ý rằng trong Pari / GP, các mã thông báo được cung cấp ở đây không phải là chuỗi mà là tên biến hợp pháp! Các biến đó không bao giờ có bất kỳ giá trị nào được gán cho)

Xếp chồng lên nhau, 70 byte

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

Hãy thử nó ở đây! Đưa đầu vào vào ngăn xếp và để lại đầu ra trên ngăn xếp. Ví dụ:

'war'

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

out

Mã này là khá tự giải thích. Sửa đổi một chút để chạy tất cả các trường hợp thử nghiệm:

('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γ

Có nhiều điều không thể in được. Đây là một hexdump, mặc dù nó sẽ không làm được gì nhiều:

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

Đây là một liên kết trực tuyến.

Về cơ bản, mã trông như:

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

Trên thực tế , 56 byte

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

Hãy thử trực tuyến!

Thật không may, không có bất kỳ nội dung nén nào, nó ngắn hơn để không nén chuỗi và giải nén thủ công.

Giải trình:

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

Ý tưởng:

• Liệt kê các từ khóa sao cho đối tác của chúng cách xa 3 vị trí
• Lấy từ khóa, lấy vị trí của nó bằng cách fromEnumdi chuyển 3 bước sang phải (mô đun 6) và chuyển đổi trở lại từ khóa
• Điều ::Onày là cần thiết bởi vì suy luận kiểu có một số vấn đề. Đưa ra fmột chữ ký f :: O -> Osẽ có tác dụng tương tự nhưng không phải là ngắn.

Biên tập:

Đã thay thế

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

bởi

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

cảm ơn @Laikoni.

APL Dyalog , 66 byte

Một trong những điều này:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞sử dụng phương pháp này (yêu cầu ⎕IO←0mặc định trên nhiều hệ thống).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ thực hiện tra cứu, sau đó chọn phần tử tương ứng từ danh sách đảo ngược.

Qbasic, 138 99 byte

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

D$lưu trữ tất cả các từ từ bên trái của câu thần chú, sau đó tất cả những từ bên phải. Mỗi từ được đệm bằng khoảng trắng đến chính xác 9 chữ cái cho mỗi từ. D$sau đó được gắn vào chính nó.

Sau đó instrđược sử dụng để tìm chỉ mục của từ được nhập bởi người dùng. Phần khác của câu thần chú luôn được lưu trữ chính xác hơn 9 * 3 vị trí trong chuỗi, vì vậy chúng tôi in một chuỗi con bắt đầu từ vị trí đó, lấy 9 ký tự.

SmileBASIC, 92 byte

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

Python , 80 byte

Bằng cách nào đó đã vượt qua xnor!

Đây là một hàm lambda không tên, trả về kết quả.

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

Hãy thử trực tuyến!

Danh sách các từ được sắp xếp sao cho mỗi từ nằm ở vị trí đối diện với đối tác của nó. Đưa ra từ này w, chúng tôi tìm thấy chỉ mục của nó trong danh sách từ, và sau đó bit bit KHÔNG ( ~) nó. Điều này lật tất cả các bit, đó là tính toán n => -n-1. Do lập chỉ mục tiêu cực của Python, có được chỉ mục ngược lại trong danh sách.

Là một loại phần thưởng không chủ ý, bạn có thể chuyển bất kỳ danh sách từ nào của các từ trái nghĩa sang chức năng này làm đối số thứ hai.