Seperti yang ditulis George Orwell pada 1984 :

Perang adalah kedamaian
Kebebasan adalah perbudakan
Ketidaktahuan adalah kekuatan

Tulislah sebuah program atau fungsi yang menggunakan salah satu dari enam kata utama dari kutipan Orwell dan menampilkan rekannya.

Secara khusus:

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

Tidak ada pasangan input / output lain yang diperlukan.

Anda harus menganggap kata-kata selalu huruf kecil sepenuhnya, seperti di atas. Atau, Anda mungkin menganggap kata-kata yang selalu penuh huruf besar: WAR -> PEACE, PEACE -> WAR, dll

Kode terpendek dalam byte menang.

05AB1E , 30 byte

05AB1E menggunakan CP-1252 .

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

Cobalah online! atau sebagai Test suite

Penjelasan

Pendekatan lurus ke depan

• Dorong senarnya ignorance strength war peace freedom slavery
• Berpisah pada spasi
• Dapatkan indeks input dalam daftar
• XOR indeks dengan 1
• Dapatkan elemen dalam daftar di indeks itu

JavaScript (ES6), 80 byte

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

Bagaimana itu bekerja

Kami menggunakan tabel pencarian kecil berdasarkan kode ASCII dari karakter ke-2 dari setiap kata, mengembalikan indeks rekannya.

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

Sebagai catatan tambahan, jika case campuran diizinkan, menggunakan war PEACE FREEDOM slavery IGNORANCE strengthdengan modulo 6 akan menghasilkan hash yang sempurna.

Uji

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

Jelly , 24 byte

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

Cobalah online!

Bagaimana itu bekerja

Pertama, token

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

mengindeks ke kamus Jelly untuk membuat string

strength war peace freedom slavery ignorance

yang Ḳterbagi pada spasi untuk menghasilkan array string

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

µ memulai rantai monadik baru, dengan array string sebagai argumennya, yang juga merupakan nilai pengembalian saat ini.

ɠmembaca satu baris input dari STDIN, dan imenemukan indeksnya dari nilai pengembalian sebelumnya, yaitu, array string yang dihasilkan.

Sekarang, ^1ambil bitor XOR dari indeks itu dan 1 . Untuk indeks bahkan - ingat bahwa Jelly indeks adalah 1 berbasis dan modular, sehingga kekuatan memiliki indeks 1 dan kebodohan memiliki index 6 / 0 - ini akan menambahkan indeks; untuk indeks ganjil, itu menurunkan mereka.

Akhirnya, ịambil string di indeks itu dari argumen rantai.

Mathematica, 84 byte

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

Penjelasan

Lebih banyak "aritmatika" dengan string! Seperti dalam jawaban yang ditautkan, ini didasarkan pada fakta bahwa Anda dapat "melipatgandakan" string dalam Mathematica yang akan membuat mereka tidak dievaluasi (mirip dengan mengalikan dua variabel yang tidak ditugaskan x*y), tetapi bahwa Mathematica akan menerapkan penyederhanaan dasar, seperti membatalkan faktor dalam suatu divisi.

Jadi kita mulai dengan menyimpan tiga pasang sebagai produk dalam x, y, z, masing-masing dan kalikan mereka semua bersama-sama:

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

Ini mengevaluasi ke

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

(Mathematica secara otomatis mengurutkan faktor, tetapi kami tidak peduli dengan urutannya.)

Kami membaginya dengan input untuk menghapus kata yang tidak kita inginkan .../#, karena Mathematica membatalkan faktor-faktornya. Misal jika inputnya "peace"kita akan berakhir dengan:

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

Akhirnya, kita menyingkirkan pasangan yang tidak kita minati, dengan mengganti masing-masing pasangan x, ydan zdengan 1. Sekali lagi, penyederhanaan Mathematica 1*aselalu muncul a. Bagian ini dilakukan dengan:

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

Yang menyenangkan adalah bahwa Mathematica tahu bahwa perkalian adalah Orderlessjadi ini akan menemukan dua faktor terlepas dari apakah mereka berdekatan dalam produk atau tidak. Hanya kata yang berseberangan dengan input yang tidak lagi dipasangkan dalam produk, sehingga satu tidak akan dihapus dan tetap sebagai output tunggal.

Vim, 60 byte

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

Cobalah online! di penerjemah V yang kompatibel.

Tentu saja, jika kita beralih ke V kita bisa menghemat satu byte dengan menggunakan metode input yang lebih nyaman. Tapi karena ini adalah perbedaan kecil saya lebih suka menggunakan versi non-golf.

Penjelasan:

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

Penyalahgunaan pointer maksimum! Membutuhkan mesin little-endian dan panjang 64-bit.

Kode ini berisi beberapa yang tidak dapat diinstal, tetapi penyalinan salinan masih berfungsi.

Cobalah online!

Python, 81 byte

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

Atau, panjang yang sama:

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

Perl 6 , 61 byte

Dengan karakter yang tidak diinginkan ditampilkan sebagai (karena StackExchange menghapus mereka sebaliknya):

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

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

Versi yang diperluas (karakter yang tidak dicetak diganti dengan urutan pelarian, dan spasi & komentar ditambahkan):

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

Cobalah online!

Huruf ke-2 dari setiap kata secara unik mengidentifikasi kata itu, jadi saya menggunakan karakter itu sebagai nama variabel; nilai variabel itu adalah kata lain yang sesuai.

Misalnya, huruf ke-2 peaceadalah e, dan kata yang sesuai peaceadalah war, jadi saya atur e=war.

Diberikan string input, karakter ke-2 dari string itu digunakan sebagai nama variabel untuk menarik kata terkait yang diinginkan, menggunakan ekspansi parameter tidak langsung bash.

TI-Basic, 103 84 77 byte

Mengurangi menjadi satu-baris menghemat banyak byte! Haha, betapa ironisnya pernyataan itu ...

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

Perl , 63 byte

62 byte + -pflag.

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

Cobalah online!

ordmengembalikan kode karakter pertama karakter input kata.
Setelah itu %6, kami memiliki:

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

Jadi kami memiliki slaverydan strengthkeduanya mengembalikan 1 (karena keduanya dimulai dengan huruf yang sama), dan tidak ada yang kembali 2. Oleh karena itu, kami menambahkan 1untuk strength(itu satu-satunya kata yang akan cocok /h/), dan kami memiliki setiap kata yang dipetakan ke indeks dari 0 hingga 5.

R, 86 87 92 Bytes

Berubah ke fungsi yang tidak disebutkan namanya dan gsubuntuk subselama beberapa byte. The grepmenentukan dari 3 senar digunakan dan masukan akan dihapus dari string dengan 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:-<
@>:#,_

Cobalah online!

Penjelasan

Kami mulai dengan mendorong semua string keluaran yang mungkin ke tumpukan, null dihentikan. Urutan ini dieksekusi dari kanan ke kiri sehingga nilainya didorong terbalik, karena itulah urutan karakter yang akan diperlukan ketika mereka akhirnya menghasilkan.
Kami kemudian membaca dua karakter pertama dari stdin, yang kita butuhkan untuk mengidentifikasi string input. Jika kita mengambil nilai ASCII dari huruf pertama mod 2, ditambah huruf kedua mod 7, kita mendapatkan nomor unik di kisaran 2 hingga 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

Nomor ini kemudian dapat digunakan sebagai semacam indeks ke dalam daftar string pada tumpukan. Kami secara iteratif menurunkan indeks (pertama kali oleh 2), dan untuk setiap iterasi kami menghapus satu string dari tumpukan dengan urutan >_.
Setelah indeks mencapai nol, kita pergi dengan string output yang benar di bagian atas tumpukan, jadi kami menggunakan urutan output string sederhana untuk menulis hasilnya ke stdout.

Pyke, 29 byte

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

Coba di sini!

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

C, 93

@Arnauld menjawab porting ke 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);}

Semua instance dari \0dapat diganti dengan byte NUL aktual untuk tujuan penilaian.

t+*--t-47adalah perilaku yang tidak terdefinisi; ini mungkin / tidak akan bekerja dengan kompiler lain.

Cobalah online!

JavaScript (ES6), 71 78

Jauh lebih membosankan daripada jawaban Arnauld, tetapi lebih pendek juga.

Sekarang saya menambahkan encoding dengan btoa. Dalam string yang disandikan ada 4 byte yang saya tidak bisa posting ke situs ini, bahkan jika mereka karakter yang valid dalam string javascript. Jadi saya menggunakan hex melarikan diri dalam formulir \xHH. Masing-masing lolos ini dihitung sebagai 1 byte.

String yang disandikan adalah strength0ignorance0peace0war0slavery0freedom

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

Yang ini 82 dan case-sensitive

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

Uji

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 (hanya ASCII)

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

Cobalah online

Catatan: yang tampak seperti spasi adalah karakter tab (satu sebelum dan satu setelah "EK {")

Penjelasan:

Bagian hingga "+" mendekompresi string "slaveryjfreedomjwarjpeacejignorancejstrength", menggunakan konversi basis:
string (diperlakukan sebagai larik kode karakter) → (basis 144) angka → (basis 26) array angka → (menambahkan 'a' untuk masing-masing angka) string

'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

> <> (Ikan), 84 78 byte

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

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

Cobalah online!

Kami mulai berenang dari kiri atas, menuju kanan. Pertama-tama kita memuat tumpukan dengan angka 0. Kemudian kita membaca huruf input pertama ( i), membuangnya ( ~), membaca huruf kedua ( i), dan mengurangi nilai ASCII modulo 10 ( a%). Ini memetakan a, e, r, l, g, dan t ke 7, 1, 4, 8, 3, dan 6, masing-masing — sebut saja angka ini N. .mengeluarkan dua nilai dari tumpukan — N ​​dan 0 — dan melompat ke baris N, karakter 0.

Setelah melompat, ikan menghasilkan satu centang sebelum menjalankan instruksi, sehingga mengabaikan karakter pertama dan berenang melintasi garis N, yang memuat kata yang sesuai ke tumpukan. Akhirnya kita pergi ke baris 2, yang menampilkan seluruh tumpukan dan keluar.

• Disimpan enam byte dengan menggunakan lompatan, bukan modifikasi diri kode keren yang saya gunakan sebelumnya. Baiklah.

JavaScript, 78 byte

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

Ini adalah semacam port jawaban Python saya . Kami menyimpan kata-kata dalam string di mana masing-masing berada di posisi yang berlawanan dengan rekannya. Kami menemukan indeks kata yang diberikan w, dan mendapatkan indeks itu dari akhir, untuk mengembalikan hasilnya.

Cuplikan uji:

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 adalah interpreter interaktif, kita tidak perlu "print" -cmd untuk output; namun, utilitas Try-It_Online membutuhkan "print" -cmd jadi saya pisahkan ini ke "footer".
Kami mendefinisikan "objek-fungsi" (huruf O mengingatkan saya pada fungsi Orwell ... ;-)):

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

Setelah itu, teleponlah

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

Cobalah online!

(Perhatikan, bahwa dalam Pari / GP token yang diberikan di sini bukan string tetapi nama variabel hukum! Variabel-variabel itu seharusnya tidak pernah memiliki nilai apa pun yang ditetapkan untuk)

Ditumpuk, 70 byte

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

Coba di sini! Mengambil input pada stack dan meninggalkan output pada stack. Sebagai contoh:

'war'

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

out

Kode ini cukup jelas. Sedikit dimodifikasi untuk menjalankan semua kasus uji:

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

Ada banyak hal yang tidak patut. Ini hexdump, meskipun tidak banyak manfaatnya:

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

Ini tautan online.

Pada dasarnya, kode ini terlihat seperti:

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

Sebenarnya , 56 byte

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

Cobalah online!

Sayangnya, tanpa builtin kompresi, lebih pendek untuk tidak memampatkan string dan secara manual mendekompresnya.

Penjelasan:

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

Ide:

• Hitung kata kunci sedemikian rupa sehingga mitra mereka berjarak 3 posisi
• Ambil kata kunci, dapatkan posisinya dengan fromEnum, gerakkan 3 langkah ke kanan (modulus 6) dan konversikan kembali ke kata kunci
• Ini ::Odiperlukan karena inferensi tipe memiliki beberapa masalah. Memberi ftanda tangan f :: O -> Oakan memiliki efek yang sama tetapi tidak sesingkat itu.

Sunting:

Diganti

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

oleh

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

terima kasih kepada @Laikoni.

Dyalog APL , 66 byte

Salah satu dari ini:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞menggunakan metode ini (mengharuskan ⎕IO←0yang default pada banyak sistem).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ melakukan pencarian, lalu mengambil elemen yang sesuai dari daftar terbalik.

Qbasic, 138 99 byte

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

D$menyimpan semua kata dari sisi kiri mantra, lalu semua kata dari sisi kanan. Setiap kata diisi dengan spasi hingga tepat 9 huruf per kata. D$kemudian ditambahkan ke dirinya sendiri.

Kemudian instrdigunakan untuk menemukan indeks kata yang dimasukkan oleh pengguna. Bagian lain dari mantra selalu disimpan tepat 9 * 3 posisi lebih jauh dalam string, jadi kami mencetak substring mulai dari posisi itu, mengambil 9 karakter.

SmileBASIC, 92 byte

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

Python , 80 byte

Entah bagaimana mengungguli xnor!

Ini adalah fungsi lambda yang tidak disebutkan namanya, yang mengembalikan hasilnya.

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

Cobalah online!

Daftar kata diatur sedemikian rupa sehingga masing-masing berada pada posisi yang berlawanan dengan rekannya. Diberikan kata w, kami menemukan indeksnya di daftar kata, dan kemudian bitwise TIDAK ( ~) itu. Ini membalik semua bit, yang dihitung n => -n-1. Karena pengindeksan negatif Python, mendapatkan indeks yang berlawanan dalam daftar.

Sebagai semacam bonus yang tidak disengaja, Anda dapat memberikan daftar kata yang bertentangan dengan fungsi ini sebagai argumen kedua.