युद्ध शांति है। स्वतंत्रता गुलामी है। अनभिज्ञता ही शक्ति है

Question

जैसा कि 1984 में जॉर्ज ऑरवेल ने लिखा था :

युद्ध शांति है
स्वतंत्रता गुलामी है
अज्ञानता शक्ति है

एक प्रोग्राम या फ़ंक्शन लिखें जो ऑरवेल उद्धरण से छह मुख्य शब्दों में से एक में लेता है और अपने समकक्ष को आउटपुट करता है।

विशेष रूप से:

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

किसी अन्य इनपुट / आउटपुट जोड़े की आवश्यकता नहीं है।

आपको यह मान लेना चाहिए कि शब्द हमेशा पूरी तरह से निचले होते हैं, जैसा कि ऊपर। वैकल्पिक रूप से, आप मान सकते हैं शब्द हमेशा पूरी तरह से अपरकेस रहे हैं: WAR -> PEACE, PEACE -> WAR, आदि

बाइट्स में सबसे छोटा कोड जीतता है।

Comments

संबंधित :-)

— xnor

@ डेनिस हां। या तो सब कुछ लोअरकेस है, या सब कुछ अपरकेस है।

— केल्विन के शौक

नहीं जानते कि क्या कोई इसका उपयोग अपने तार को अधिक संपीड़ित करने के लिए कर सकता है (यह पिप में मेरे स्कोर में सुधार नहीं करता है), लेकिन इन शब्दों के प्रारंभिक अक्षर ( w p f s i) कहीं भी किसी भी अन्य शब्द में नहीं पाए जाते हैं। एक पेचीदा संपत्ति।

— DLosc

यह एक दोहरी चुनौती है

— जोजोडमो

लगभग कोई भी इस पुस्तक को पसंद नहीं करता है। यह झूठ से भरा है! दुखी।

— पीटर ए। श्नाइडर

Answer 1

05AB1E , 30 बाइट्स

05AB1E CP-1252 का उपयोग करता है ।

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

इसे ऑनलाइन आज़माएं! या टेस्ट सूट के रूप में

व्याख्या

सीधे आगे का रास्ता

• स्ट्रिंग को पुश करें ignorance strength war peace freedom slavery
• रिक्त स्थान पर विभाजित करें
• सूची में इनपुट का सूचकांक प्राप्त करें
• 1 के साथ सूचकांक XOR
• उस सूचकांक में सूची में तत्व प्राप्त करें

Comments

14 बाइट्स सभी शब्दों की लंबाई से छोटी होती हैं। यह भाषा भी क्या है?

— DJMcMayhem

> स्ट्रिंग को धक्का देंignorance strength war peace freedom slavery मुझे लगता है कि मैं वहां लगभग एक दर्जन चरणों को याद कर रहा हूं!

— बॉब

i.imgur.com/vI4ZIfW.jpg

— पावेल

क्या कोई समझा सकता है कि "अज्ञान" के अलावा बाकी शब्द कहाँ से आए हैं?

— कार्निजनेट

05AB1E में एक अंतर्निहित शब्दकोष है जो 2 बाइट्स द्वारा दर्शाया गया है: github.com/Adriandmen/05AB1E/blob/master/dEDIA.py

— रॉबर्ट फ्रेजर

Answer 2

जावास्क्रिप्ट (ईएस 6), 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मोडुलो 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'))

Comments

यह एक अच्छा तरीका है। ऐसा कभी नहीं सोचा होगा।

— कैरिजिनेट

बहुत अच्छा। अवशेष 6, 7, 8 के लिए अलग-अलग नहीं हैं, इसलिए आपको 9. की जरूरत है।

— श्रीवत्सआर

जैसे विभाजक का उपयोग करना zऔर फिर atob8 बाइट्स के साथ स्ट्रिंग को संपीड़ित करना ?

— डाउनगेट

@Downgoat 32-126 की सीमा के बाहर के पात्रों के लिए बहुत भागने की आवश्यकता नहीं होगी?

— अरनुलद

उपयोग करने से atobआपको एक स्ट्रिंग मिलती है जो ज्यादातर मान्य जावास्क्रिप्ट है - अंततः आपको केवल `\ 'और समापन उद्धरण से बचने की आवश्यकता है। इस साइट पर इसे पोस्ट करना मुश्किल हो सकता है, लेकिन यह जवाब को अमान्य नहीं करता है।

— Smis

Answer 3

जेली , 24 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

सबसे पहले, टोकन

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

स्ट्रिंग बनाने के लिए जेली के शब्दकोश में अनुक्रमित करता है

strength war peace freedom slavery ignorance

जो Ḳस्ट्रिंग सरणी उत्पन्न करने के लिए रिक्त स्थान पर विभाजित करता है

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

µ अपने तर्क के रूप में उस स्ट्रिंग ऐरे के साथ एक नई, विवादास्पद श्रृंखला शुरू करता है, जो वर्तमान रिटर्न मूल्य भी है।

ɠएसटीडीआईएन से इनपुट की एक पंक्ति पढ़ता है, और iपिछले रिटर्न मान के अपने सूचकांक को खोजता है, अर्थात, उत्पन्न स्ट्रिंग सरणी।

अब, ^1उस इंडेक्स के बिट वाइज XOR और 1 को लेता है । यहां तक कि सूचकांक के लिए - याद रखें कि जेली अनुक्रमित रहे हैं 1 आधारित और मॉड्यूलर है, तो शक्ति सूचक है 1 और अज्ञान सूचकांक है 6 / 0 - इस सूचकांक की वृद्धि कर; विषम सूचकांकों के लिए, यह उन्हें घटाता है।

अंत में, ịश्रृंखला के तर्क से उस सूचकांक पर स्ट्रिंग को पुनः प्राप्त करता है।

Answer 4

मैथेमेटिका, 84 बाइट्स

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

व्याख्या

तार के साथ अधिक "अंकगणित"! जैसा कि जुड़े हुए उत्तर में, यह इस तथ्य पर आधारित है कि आप गणितज्ञ में "गुणा" कर सकते हैं जो उन्हें निर्विवाद रूप से छोड़ देगा (दो अप्रकाशित चर को गुणा करने के समान x*y), लेकिन यह कि गणितज्ञ बुनियादी सटीकता को लागू करेगा, जैसे विभाजन में कारकों को रद्द करना।

तो हम में उत्पादों के रूप में तीन जोड़े भंडारण के द्वारा शुरू x, y, zक्रमशः, और उन सब एक साथ गुणा:

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

यह करने के लिए मूल्यांकन करता है

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

(गणितज्ञ स्वचालित रूप से कारकों को हल करते हैं, लेकिन हम आदेश की परवाह नहीं करते हैं।)

Mathematica कारकों को रद्द करने के बाद से हम उस शब्द को हटाने के लिए इनपुट द्वारा विभाजित करते हैं, जिसे हम नहीं चाहते .../#हैं। उदाहरण के लिए यदि इनपुट था "peace"तो हम इसके साथ समाप्त हो जाएंगे:

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

अंत में, हम में से प्रत्येक के प्रतिस्थापन, जोड़े हम में कोई दिलचस्पी नहीं कर रहे हैं से छुटकारा पाने के x, yऔर zसाथ 1। फिर, मैथेमेटिका का सरलीकरण 1*aहमेशा उसमें रहता है a। इस भाग के साथ किया जाता है:

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

अच्छी बात यह है कि गणितज्ञ जानता है कि गुणन Orderlessइतना है कि इससे दो कारक मिलेंगे चाहे वे उत्पाद में सटे हों या नहीं। केवल शब्द जो इनपुट के विपरीत है, अब उत्पाद में युग्मित नहीं है, ताकि किसी को हटाया न जाए और एकमात्र आउटपुट के रूप में बना रहे।

Comments

अर्घ, इतना अच्छा किया! मैं 7 बाइट के साथ हारता हूं WordList[][[<|"l"->14007,"t"->17083,"a"->25105,"r"->32106,"g"->33790,"e"->39048|>@#[[2]]]]&।

— ग्रेग मार्टिन

@GregMartin ओह, WordListअच्छा है। इनपुट के रूप में वर्णों की एक सूची लेना और एक स्ट्रिंग वापस करना हालांकि थोड़ा नीरस लगता है। ;) ने कहा कि, आप 4 बाइट्स के साथ बेहतर कर सकते हैं x[[7-Position[x={"war","slavery","ignorance","strength","freedom","peace"},#][[1,1]]]]&।

— मार्टिन एंडर

मुझे आपकी राय में दिलचस्पी होगी, लेकिन मेरे लिए, यह पीपी एंड सीजी-स्वीकृत डॉगी लगता है :)

— ग्रेग मार्टिन

<|#->#2&~MapThread~{x={"war","slavery","ignorance","strength","fre‌edom","peace"},Reverse@x}|>94 बाइट्स के लिए भी

— ग्रेग मार्टिन

Answer 5

विम, 60 बाइट्स

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

इसे ऑनलाइन आज़माएं! पीछे संगत 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

Answer 6

सी (जीसीसी) , 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 होते हैं, लेकिन कॉपी-पेस्टिंग को अभी भी काम करना चाहिए।

इसे ऑनलाइन आज़माएं!

Answer 7

पायथन, 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

Comments

क्या लांबा के बाहर परिवर्तनीय परिभाषाओं की अनुमति है, जब एक पूर्ण कार्यक्रम के बजाय लंबोदा का उपयोग किया जाता है?

— SMLS

@smls हाँ, यह मेटा चर्चा देखें । ध्यान दें कि अन्यथा, एक lवैकल्पिक तर्क के रूप में कोई भी तस्करी कर सकता है।

— xnor

Answer 8

पर्ल 6 , 61 बाइट्स

Ex के रूप में दिखाए गए अनपेक्षित वर्णों के साथ (क्योंकि 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.
    ]
}

Answer 9

बैश , 100 87 86 78 बाइट्स

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

इसे ऑनलाइन आज़माएं!

प्रत्येक शब्द का दूसरा अक्षर उस शब्द को विशिष्ट रूप से पहचानता है, इसलिए मैं उस चरित्र को एक चर नाम के रूप में उपयोग करता हूं; उस चर का मान अन्य शब्द है।

उदाहरण के लिए, दूसरा अक्षर peaceहै e, और संबंधित शब्द peaceहै war, इसलिए मैंने सेट किया है e=war।

इनपुट स्ट्रिंग को देखते हुए, उस स्ट्रिंग के दूसरे वर्ण का उपयोग चर नाम के रूप में किया जाता है, जो वांछित संबंधित शब्द को खींचने के लिए है, बैश का अप्रत्यक्ष रूप से विस्तार।

Answer 10

टीआई-बेसिक, 103 84 77 बाइट्स

एक-लाइनर को कम करने से बहुत सारे बाइट्स बच गए! हाहा, यह कथन कितना विडंबनापूर्ण था ...

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

Answer 11

पर्ल , 63 बाइट्स

62 बाइट्स + -pध्वज।

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

इसे ऑनलाइन आज़माएं!

ordइनपुट शब्द के पहले वर्ण का चार कोड देता है।
हमारे बाद %6, हमारे पास है:

- स्वतंत्रता => अध्या = १०२ =>% ६ = ०  
- गुलामी => ताल = ११५ =>% ६ = १  
- अज्ञान => ord = १०५ =>% ६ = ३  
- शक्ति => अध्या = ११५ =>% ६ = १  
- युद्ध => ताल = ११ ९ =>% ६ = ५  
- शांति => अध्या = ११२ =>% ६ = ४  

इसलिए हमारे पास दोनों हैं slaveryऔर strength1 लौट रहा है (क्योंकि वे दोनों एक ही अक्षर से शुरू होते हैं), और कोई भी वापस नहीं आता है। 2. इसलिए, हम इसमें जोड़ते 1हैं strength(यह एकमात्र शब्द है जो मेल खाएगा /h/), और हमारे पास प्रत्येक शब्द 0 से एक इंडेक्स में मैप किया गया है 5।

Answer 12

आर, 86 87 92 बाइट्स

एक अनाम कार्य करने के लिए और बदल दिया है gsubकरने के लिए subकुछ बाइट्स के लिए। grepजो 3 तार के निर्धारित करता है प्रयोग किया जाता है और इनपुट के साथ कि स्ट्रिंग से निकाल दिया जाता sub।

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

Answer 13

PHP, 70 बाइट्स

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

Answer 14

Befunge, 89 88 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

हम स्टैक पर सभी संभावित आउटपुट स्ट्रिंग्स को धक्का देकर शुरू करते हैं, शून्य समाप्त। इस क्रम को बाएं से दाएं निष्पादित किया जाता है, इसलिए मानों को रिवर्स में धकेल दिया जाता है, क्योंकि जब वे अंततः आउटपुट होते हैं, तो वर्णों की आवश्यकता होगी।
हम तब स्टड से पहले दो अक्षर पढ़ते हैं, जो हम सभी को इनपुट स्ट्रिंग की पहचान करने की आवश्यकता है। यदि हम पहले अक्षर mod 2 का ASCII मान लेते हैं, तो दूसरा अक्षर 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) बढ़ाते हैं, और प्रत्येक पुनरावृत्ति के लिए हम अनुक्रम से स्टैक से एक स्ट्रिंग को साफ़ करते हैं >_।
एक बार जब सूचकांक शून्य तक पहुंच जाता है, तो हम स्टैक के शीर्ष पर सही आउटपुट स्ट्रिंग के साथ छोड़ देते हैं, इसलिए हम परिणाम को लिखने के लिए एक साधारण स्ट्रिंग आउटपुट अनुक्रम का उपयोग करते हैं।

Comments

मुझे यहाँ :-<और @>:#"

— स्माइलीज़

Answer 15

पाइके, 29 बाइट्स

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

यहाँ यह कोशिश करो!

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

Answer 16

सी, 93

@ अरनौलद का उत्तर C पर अंकित है

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

Answer 17

सी (जीसीसी) , 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स्कोरिंग उद्देश्यों के लिए वास्तविक एनयूएल बाइट्स से बदला जा सकता है।

t+*--t-47अपरिभाषित व्यवहार है; यह अन्य संकलक के साथ काम नहीं कर सकता / सकती है।

इसे ऑनलाइन आज़माएं!

Answer 18

जावास्क्रिप्ट (ईएस 6), 71 78

अर्नुलद के जवाब की तुलना में बहुत उबाऊ, लेकिन बहुत कम।

अब मैंने एन्कोडिंग को इसके साथ जोड़ा 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)))

Answer 19

CJam, 52 (केवल ASCII)

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

इसे ऑनलाइन आज़माएं

नोट: अंतरिक्ष में दिखने वाली चीजें टैब वर्ण हैं (एक से पहले और "ईके {" के बाद)

स्पष्टीकरण:

"+" तक का हिस्सा आधार रूपांतरण का उपयोग करके "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

Answer 20

> <> (मछली), 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। .स्टैक से दो मानों को पॉप करता है — एन और 0 और जंप करने के लिए रेखा एन, चरित्र 0।

कूदने के बाद, मछली निर्देशों को निष्पादित करने से पहले एक टिक को आगे बढ़ाता है, इसलिए यह पहले चरित्र को अनदेखा करता है और लाइन एन के पार तैरता है, जो स्टैक पर संबंधित शब्द को लोड करता है। अंत में हम पंक्ति 2 पर जाते हैं, जो पूरे स्टैक को आउटपुट करता है और बाहर निकलता है।

• मैंने पहले इस्तेमाल किए गए कूल कोड सेल्फ-मॉडिफिकेशन के बजाय जंप का उपयोग करके छह बाइट्स बचाए। ओह अच्छा।

Answer 21

जावास्क्रिप्ट, 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"))

Answer 22

परी / जीपी, 86 बाइट

Pari / GP एक इंटरएक्टिव इंटरप्रिटर है, हमें आउटपुट के लिए "प्रिंट" -cmd की आवश्यकता नहीं है; हालाँकि, ट्राई-इट_ऑनलाइन-यूटिलिटी को "प्रिंट" -cmd की आवश्यकता होती है, इसलिए मैंने इसे "पाद" के लिए अलग कर दिया।
हम एक "ऑब्जेक्ट-फंक्शन" को परिभाषित करते हैं (ओ अक्षर मुझे ऑरवेल-फंक्शन की प्यारी याद दिलाता है ... ;-));

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 में यहां दिए गए टोकन तार नहीं हैं, लेकिन कानूनी चर-नाम हैं! (चर को कभी भी असाइन नहीं किया जाना चाहिए)

Answer 23

स्टैक्ड, 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

Comments

क्या करता 'LFहै?

— डाउनगोट

@Downgoat खैर, @xएक चर सेट करता है, '...'एक स्ट्रिंग है, और LFलाइनफीड चर है

— कॉनर ओ'ब्रायन

आह, मैं देखता हूं, तो फ़ंक्शन नाम फ़ंक्शन से पहले आता है?

— डाउनगेट

@Downgoat ठीक है। स्टैक्ड, अच्छी तरह से, स्टैक-आधारित है।

— कॉनर ओ'ब्रायन

अब मैं इस तरह के स्पष्ट तथ्य को महसूस नहीं करने के लिए गूंगा महसूस करता हूं: |

— डाउनगोट

Answer 24

जोल्फ, 35 बाइट्स

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

बहुत सी अनपेक्षित वस्तुएं हैं। यहाँ एक हेक्सडंप है, हालांकि यह बहुत अच्छा नहीं करेगा:

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

Answer 25

दरअसल , 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

Answer 26

हास्केल, 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 को धन्यवाद।

Comments

बिंदु-पूर्ण अंकन का उपयोग fकम होता है:f s=toEnum$mod(3+fromEnum s)6

— लाइकोनी

Answer 27

डायलॉग एपीएल , 66 बाइट्स

या तो इनमें से एक:

'slavery' 'freedom' 'ignorance' 'strength' 'war' 'peace'⊃⍨6|⎕UCS⊃⍞इस विधि का उपयोग करता है ( ⎕IO←0जो कई प्रणालियों पर डिफ़ॉल्ट है)।

'strength' 'freedom' 'war' 'peace' 'slavery' 'ignorance'(⍳⊃(⌽⊣))⊂⍞ लुकअप करता है, फिर संबंधित तत्व को उलटी सूची से चुनता है।

Answer 28

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 अक्षरों को लेते हुए, उस स्थान पर शुरू होने वाले एक स्ट्रिंग को प्रिंट करते हैं।

Answer 29

स्माइलबासिक, 92 बाइट्स

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

Answer 30

पायथन , 80 बाइट्स

किसी तरह बाहर निकले xnor!

यह एक अनाम लंबू फ़ंक्शन है, जो परिणाम देता है।

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

इसे ऑनलाइन आज़माएं!

शब्दों की सूची ऐसी व्यवस्थित की गई है कि यह प्रत्येक अपने समकक्ष के विपरीत स्थिति में है। शब्द को देखते हुए w, हम शब्द सूची में इसके सूचकांक को पाते हैं, और फिर बिटवाइज़ नहीं ( ~) करते हैं। यह सभी बिट्स को फ़्लिप करता है, जो गणना करता है n => -n-1। पायथन के नकारात्मक अनुक्रमण के कारण, सूची में विपरीत सूचकांक प्राप्त करता है।

एक प्रकार के अनजाने बोनस के रूप में, आप इस फ़ंक्शन के विपरीत किसी भी शब्द सूची को दूसरे तर्क के रूप में पारित कर सकते हैं।