As George Orwell yazdığı 1984 :

Savaş barışdır
Özgürlük köleliktir
Cehalet güçtür

Orwell alıntıdan altı ana kelimeden birini alan ve karşılığını veren bir program veya işlev yazın.

özellikle:

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

Başka hiçbir giriş / çıkış çifti gerekli değildir.

Yukarıdaki gibi, kelimelerin daima küçük harf olduğunu varsaymalısınız. Alternatif olarak, kelimeler her zaman tam olarak büyük harfe varsayacağız olabilir: WAR -> PEACE, PEACE -> WARvb

Bayt cinsinden en kısa kod kazanır.

05AB1E , 30 bayt

05AB1E , CP- 1252'yi kullanır .

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

Çevrimiçi deneyin! veya Test paketi olarak

açıklama

Dümdüz ileri yaklaşım

• Dizeye bas ignorance strength war peace freedom slavery
• Boşluklarda ayır
• Listedeki girişin dizinini al
• XOR dizini 1 ile
• Listedeki öğeyi bu dizinde al

JavaScript (ES6), 80 bayt

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

Nasıl çalışır

Her kelimenin 2. karakterinin ASCII kodunu temel alarak, karşıtının dizinini döndüren küçük bir arama tablosu kullanıyoruz.

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

Yan bir not olarak, karışık durumda izin varsa, war PEACE FREEDOM slavery IGNORANCE strengthmodulo 6 ile kullanılması mükemmel bir karmaşa yol açacaktır.

Ölçek

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

Jöle , 24 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

İlk olarak, belirteç

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

dizeyi oluşturmak için Jelly'in sözlüğüne endeksler

strength war peace freedom slavery ignorance

ki Ḳdize dizisi elde etmek için boşluk yarılmaktadırlar

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

µ Yeni bir monadik zincir başlatır, aynı zamanda şu anki dönüş değeri olan argümanı olan dizge dizisini içerir.

ɠSTDIN'den bir satır girdi satırı okur ive önceki dönüş değerinin indeksini, yani oluşturulan dize dizisini bulur.

Şimdi, ^1bu indeksteki bit yönünde XOR değerini alır ve 1 . Endeksler için bile - Jelly endekslerinin 1 tabanlı ve modüler olduğunu unutmayın, bu nedenle kuvvet endeksi 1'dir ve cehaletin endeksi 6 / 0'dır - bu indeksi artırır; Tek endeksler için onları azaltır.

Son olarak, ịbu dizindeki dizgiyi zincir argümanından alır.

Mathematica, 84 bayt

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

açıklama

Dizeleri ile daha fazla "aritmetik"! Bağlantılı cevapta olduğu gibi, bu, Mathematica'da dizelerini "çarpmadan" (onları atanmamış iki değişkeni çarpma işlemine benzer x*y), ancak Mathematica'nın bir bölümdeki faktörleri iptal etme gibi temel basitleştirmeler uygulayacağı gerçeğine dayanmaktadır .

Bu yüzden de ürünleri gibi üç çift depolayarak başlamak x, y, zsırasıyla ve hepsini bir araya çarpın:

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

Bu değerlendirir

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

(Mathematica otomatik olarak faktörleri sıralar, ancak düzeni umursamıyoruz.)

Mathematica faktörleri iptal ettiğinden bunu istemediğimiz sözcüğü kaldırma girişine böleriz .../#. Örneğin, eğer giriş "peace"biz olsaydı:

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

Son olarak, biz her yerine, biz ilgilenmiyoruz çiftleri kurtulmak x, yve zile 1. Yine, Mathematica'nın sadeleştirmesi 1*a, her zaman olduğu gibi başlıyor a. Bu kısım şununla yapılır:

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

İşin güzel yanı, Mathematica'nın çarpmanın, Orderlessüründe bitişik olup olmadıklarına bakılmaksızın iki faktörü bulabilmesi olduğunu bilmesidir . Sadece girişin karşıtı olan sözcük artık üründe eşlenmez, böylece çıkartılamaz ve tek çıktı olarak kalır.

Vim, 60 bayt

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

Çevrimiçi deneyin! geriye doğru uyumlu V yorumlayıcısında.

Tabii ki, eğer V'ye geçersek , daha uygun bir giriş metodu kullanarak bir bayttan tasarruf edebiliriz . Ancak bu kadar küçük bir fark olduğu için golf oynamayan versiyonunu kullanmayı tercih ederim.

Açıklama:

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 bayt

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

Maksimum işaretçi istismarı! Küçük bir endian makinesi ve 64-bit uzunluk gerektirir.

Kod birkaç yazdırılamaz içeriyor, ancak kopyala yapıştırmanın yine de çalışması gerekir.

Çevrimiçi deneyin!

Python, 81 bayt

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

Veya aynı uzunluk:

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

Perl 6 , 61 bayt

Shown olarak gösterilen yazdırılamayan karakterlerle (çünkü StackExchange bunları başka bir şekilde çıkarır):

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

İşte xxdonaltılık bir dökümü:

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

Genişletilmiş sürüm (kaçış dizileriyle değiştirilebilen yazdırılamayan karakterler ve boşluk ve yorum eklendi):

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

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

Çevrimiçi deneyin!

Her kelimenin 2. harfi bu kelimeyi benzersiz bir şekilde tanımlar, bu yüzden bu karakteri değişken ismi olarak kullanırım; bu değişkenin değeri karşılık gelen diğer kelimedir.

Örneğin, 2. mektup peaceolduğunu eve karşılık gelen kelime peaceolduğunu war, bu yüzden set e=war.

Bir giriş dizgesi verildiğinde, bu dizgenin 2. karakteri, bash'in dolaylı parametre genişlemesi kullanılarak istenen ilgili kelimeyi çıkarmak için değişken bir isim olarak kullanılır.

TI-Basic, 103 84 77 bayt

Tek bir astarı azaltmak, çok fazla bayt kurtardı! Haha, bu ifadenin ne kadar ironik olduğu ...

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

Perl , 63 bayt

62 bayt + -pbayrak.

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

Çevrimiçi deneyin!

ordgiriş sözcüğünün ilk karakterinin char kodunu döndürür.
Ondan sonra %6, biz var:

- freedom => ord = 102 =>% 6 = 0  
- kölelik => ord = 115 =>% 6 = 1  
- cehalet => ord = 105 =>% 6 = 3  
- gücü => ord = 115 =>% 6 = 1  
- savaş => ord = 119 =>% 6 = 5  
- peace => ord = 112 =>% 6 = 4  

Bu yüzden sahip olduğumuz slaveryve strengthher ikisi dönen 1 (ikisi de aynı harfle başlayan beri) ve hiçbiri Dolayısıyla 2. dönen, biz eklemek 1için strength(o maç olacak tek bir kelime /h/) ve biz 0'dan bir dizin eşleştirilmiş her kelime var 5.

R, 86 87 92 Bayt

Adsız bir işleve ve Değişti gsubiçin subbirkaç bayt için. grep3 şeritlerinin belirler kullanılır ve giriş ile bu dize çıkarılır sub.

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

PHP, 70 bayt

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

Befunge, 89 88 bayt

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

Çevrimiçi deneyin!

açıklama

Tüm olası çıkış dizgilerini yığının üzerine boş bırakarak, boş bırakarak başlıyoruz. Bu sıra sağdan sola doğru yürütülür, böylece değerler geriye doğru itilir, çünkü sonunda çıkışta karakterlerin gerekli olacağı sıra budur.
Daha sonra ilk iki karakteri stdin'den okuruz, bunlar girdi dizgisini tanımlamak için tek ihtiyacımız olan şeydir. İlk harf mod 2'nin ASCII değerini ve ikinci harf mod 7'yi alırsak, 2 ila 7 aralığında benzersiz bir sayı elde ederiz.

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

Bu sayı daha sonra yığındaki dize listesine bir tür dizin olarak kullanılabilir. Dizini yinelemeli olarak azaltırız (ilk defa 2), ve her yineleme için diziden bir dizgiyi sileriz >_.
Dizin sıfıra ulaştığında, yığının en üstündeki doğru çıktı dizisi kalır, bu nedenle sonucu stdout'a yazmak için basit bir dizge çıktı dizisi kullanırız.

Pyke, 29 bayt

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

Burada dene!

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

C, 93

@ Arnauld'un cevabı C'ye iletildi

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

C (gcc) , 113 108 bayt

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

Tüm örnekleri \0puanlama amacıyla gerçek NUL bayt ile değiştirilebilir.

t+*--t-47tanımsız davranış; bu diğer derleyicilerle çalışmayabilir / çalışmayabilir.

Çevrimiçi deneyin!

JavaScript (ES6), 71 78

Arnauld'un cevabından çok sıkıcı ama daha kısa.

Şimdi kodlamayı ekledim btoa. Kodlanmış dizgede, bir javascript dizesinde geçerli karakterler olsalar bile, bu siteye gönderemediğim 4 bayt var. Bu yüzden formda altıgen bir kaçış kullandım\xHH . Bu kaçanların her biri 1 bayt olarak sayılır.

Kodlanmış dize strength0ignorance0peace0war0slavery0freedom

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

Bu bir 82 ve büyük / küçük harf duyarsız

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

Ölçek

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 (yalnızca ASCII)

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

Çevrimiçi deneyin

Not: boşluk görünümlü şeyler sekme karakterleridir ("EK {" öncesi ve sonraki bir)

Açıklama:

"+" 'Ya kadar olan kısım, "slaveryjfreedomjwarjpeacejignorancejstrength" dizgisinin taban dönüşümünü kullanarak açar:
string (karakter kodları dizisi olarak işlem görür) → (temel 144) sayı → (temel 26) sayı dizileri → (her birine' a 'eklenir) sayı) dize

'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

> <> (Balık), 84 78 bayt

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

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

Çevrimiçi deneyin!

Sol üstten yüzmeye başlıyoruz, sağa gidiyoruz. İlk önce yığını 0 ile yüklüyoruz. Daha sonra girişin ilk harfini i( ~) okuyoruz , atın ( ), ikinci harfini ( i) okuduk ve ASCII değeri modulo 10 ( a%) 'u azalttık . Bu a, e, r, l, g ve t'yi sırasıyla 7, 1, 4, 8, 3 ve 6 ile eşleştirir - bu sayıya N diyelim.. : yığından iki değer çıkarır - N ve 0 — ve satır N, karakter 0

Bir atlamadan sonra, balık talimatları yürütmeden önce bir keneyi ilerletir, böylece ilk karakteri yok sayar ve karşılık gelen sözcüğü yığına yükleyen N çizgisi boyunca yüzer. Sonunda tüm yığını çıkaran ve çıkan 2. satıra geçiyoruz.

• Daha önce kullandığım cool kod kendiliğinden değişiklik yerine, bir atlama kullanarak altı bayt kurtardı. Oh iyi.

JavaScript, 78 bayt

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

Bu Python cevabımın bir tür limanı . Kelimeleri, her birinin karşıtına zıt konumda olduğu bir dizgide depolarız. Verilen kelimenin dizinini buluruz wve sonucu döndürmek için o dizini baştan alırız.

Test snippet'i:

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 Bayt

Pari / GP etkileşimli bir tercümandır, çıktı için bir "print" -cmd'ye ihtiyacımız yoktur; ancak, Try-It_Online yardımcı programının bir "print" -cmd'ye ihtiyacı var, bu yüzden bunu "footer" e ayırdım.
Bir "nesne işlevi" tanımlıyoruz (O harfi Orwell işlevinin güzelliğini hatırlatıyor ... ;-)):

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

Ondan sonra ara

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

Çevrimiçi deneyin!

(Pari / GP’de burada verilen belirteçlerin karakter dizisi değil, yasal değişken isimleri olduğuna dikkat ediniz!

Yığılmış, 70 bayt

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

Burada dene! Yığın üzerinde girdi alır ve çıktıyı yığında bırakır. Örneğin:

'war'

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

out

Bu kod oldukça açıklayıcıdır. Tüm test durumlarını çalıştırmak için hafifçe değiştirildi:

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

Jolf, 35 bayt

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

Yazdırılamayan çok şey var. İşte bir hexdump, çok iyi yapmaz olsa da:

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

İşte bir çevrimiçi link.

Temel olarak, kod gibi görünüyor:

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

Aslında , 56 bayt

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

Çevrimiçi deneyin!

Ne yazık ki, herhangi bir sıkıştırma yerleşik olmadan, dizeyi sıkıştırmamak ve elle sıkıştırmasını kaldırmak daha kısadır.

Açıklama:

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

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

Fikir:

• Anahtar kelimeleri, karşıtları 3 konum uzakta olacak şekilde numaralandırın
• Anahtar kelimeyi al, konumunu al fromEnum 3 adımı sağa hareket ettirin (modulus 6) ve tekrar anahtar kelimeye dönüştürün
• Bu ::O, tür çıkarımında bazı problemler olduğundan gereklidir. fİmza vermekf :: O -> O aynı etkiye sahip olacaktır, ancak o kadar kısa değildir.

Düzenle:

Değiştirilen

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

tarafından

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

@Likonik sayesinde.

Dyalog APL , 66 bayt

Bunlardan biri:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞Bu yöntemi kullanır ( ⎕IO←0birçok sistemde varsayılan olan gerektirir ).

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ bir arama yapar, ardından karşılık gelen öğeyi ters çevrilmiş listeden alır.

Qbasic, 138 99 bayt

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

D$tüm kelimeleri mantranın sol tarafından sonra da sağ taraftaki tüm kelimeleri saklar. Her kelime, boşluk başına, kelime başına tam 9 harfe kadar doldurulur. D$sonra kendine eklenir.

Sonra instrkullanıcı tarafından girilen kelimenin dizinini bulmak için kullanılır. Mantranın diğer kısmı her zaman ipte tam olarak 9 * 3 pozisyonda saklanır, bu nedenle 9 pozisyon alarak bu pozisyondan başlayarak bir alt tabaka basarız.

SmileBASIC, 92 bayt

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

piton , 80 bayt

Her nasılsa xnor aştı!

Bu, sonucu döndüren adsız bir lambda işlevidir.

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

Çevrimiçi deneyin!

Sözcük listesi, her biri karşıtına zıt konumda olacak şekilde düzenlenmiştir. Sözcük göz önüne alındığında, wdizinini kelime listesinde bulduk ve sonra bit biti NOT ( ~). Bu, hesaplanan tüm bitleri döndürürn => -n-1 . Python'un negatif indekslemesi nedeniyle listedeki ters indeksi alır.

Bir çeşit kasıtsız bonus olarak, bu fonksiyona karşıtların herhangi bir kelime listesini ikinci argüman olarak iletebilirsiniz.