27

चुनौती

यथासंभव कुछ वर्णों में, i ^ n का मान ज्ञात करें, n दिया गया है, एक सकारात्मक पूर्णांक 0. से अधिक है। इसे स्ट्रिंग के रूप में आउटपुट किया जाना चाहिए।

उन लोगों के लिए जो नहीं जानते हैं, मुझे ऐसे परिभाषित किया गया है कि i ^ 2 = -1। इसलिए:

मैं ^ 1 = मैं
मैं ^ 2 = -1
मैं ^ 3 = मैं
मैं ^ 4 = 1

यह फिर दोहराता है ।।

नियम

यदि आपकी भाषा जटिल संख्याओं का समर्थन करती है, तो किसी भी फ़ंक्शन या अंकगणित का उपयोग न करें जो इसे बाहर काम कर सकता है।
फ़्लोटिंग पॉइंट गलतियाँ ऐसे उत्तरों के लिए ठीक हैं, जो वैसे भी दशमलव लौटा देंगे, लेकिन पूर्णांक इनपुट सटीक परिणाम देने चाहिए

बोनस अंक

-5 यदि आप मूल्य को काम कर सकते हैं जहां n भी नकारात्मक है

-15 यदि आप किसी वास्तविक संख्या के लिए मान निकाल सकते हैं (इस बोनस में उपरोक्त बोनस से -5 शामिल हैं)

सौभाग्य!

— Kezz101
स्रोत

1

हम वास्तव में किस प्रारूप में लौटते हैं? फ़ंक्शन आउटपुट या स्टडआउट के माध्यम से?

— गर्वित हैकेलर

@proudhaskeller टैग विकी उस के लिए डिफॉल्ट को सूचीबद्ध करता है। जब तक अन्यथा निर्दिष्ट न हो, फ़ंक्शन और प्रोग्राम ठीक हैं, फ़ंक्शन तर्क के माध्यम से इनपुट, एसटीडीआईएन या कमांड-लाइन तर्क और एसटीडीयूएस या फ़ंक्शन रिटर्न वैल्यू के माध्यम से आउटपुट। कार्यों का नाम नहीं है।

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

1

@ मार्टिनबटनर, लेकिन अगर मैं फ़ंक्शन आउटपुट का चयन करता हूं, तो मेरी भाषा में मूल जटिल संख्याओं के बिना आउटपुट को कैसे स्वरूपित / संग्रहीत किया जाना चाहिए?

— गर्वित हैकेलर

16

@BetaDecay फ़्लोटिंग पॉइंट पूर्णांक क्या हैं? ऊ

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

2

@ मार्टिनबटनर हाहा गलत शब्द: / फ़्लोटिंग पॉइंट संख्या तब

— बीटा डिके

15

रूबी, स्कोर -2

(13 बाइट्स, -15 बोनस)

->n{[1,90*n]}

सुविधाओं में शामिल हैं: कोई गोल त्रुटियाँ नहीं! (यदि आप इनपुट को तर्कसंगत मानते हैं)

लेखक द्वारा, Kezz101 द्वारा पोस्ट किया गया

यदि आप किसी भी वास्तविक संख्या का समर्थन करते हैं तो आप किसी भी वैध जटिल रूप में आउटपुट कर सकते हैं।

नकारात्मक स्कोर मेरे एड्रेनालाईन को आगे बढ़ाते हैं। इस प्रकार नियमों का ~~दुरुपयोग किया~~ जाता है ताकि इस महान लक्ष्य को प्राप्त किया जा सके।

एक अनाम फ़ंक्शन बनाता है और ध्रुवीय रूप (कोणीय इकाई: डिग्री) में एक जटिल संख्या का प्रतिनिधित्व करने वाली 2 प्रविष्टियों के साथ एक सरणी आउटपुट करता है।

— blutorange
स्रोत

4

"रूबी, -2 बाइट्स" .....

— FantaC

3

तो, क्या यह 1,000,000,000,000 बार डाउनलोड करने से मुझे 2TB का मुफ्त हार्ड ड्राइव स्पेस देता है? यह मेरे लिए एक अच्छे सौदे जैसा लगता है।

— रेडवुल्फ प्रोग्राम्स

^ ऐसा करने में सफल होने से पहले मेरा ब्राउज़र टूट गया। शायद अंदर फ़ाइल के साथ एक "ज़िप बम" की कोशिश करो? (निकाला जा रहा है यह अंतरिक्ष की बचत होती है।)

— एक

15

CJam, 12 वर्ण - 5 = 7

1'iW"-i"]li=

इसका परीक्षण यहां करें।

नकारात्मक इनपुट का समर्थन करता है।

1              "Push 1.";
 'i            "Push the character i.";
   W           "Push -1.";
    "-i"       "Push the string -i.";
        ]      "Wrap all four in an array.";
         li    "Read STDIN and convert to integer.";
           =   "Access array. The index is automatically taken module the array length.";

परिणाम कार्यक्रम के अंत में स्वचालित रूप से मुद्रित होता है।

गणितज्ञ, २२ २० १ ९ वर्ण - १५ = ४

Sin[t=π#/2]i+Cos@t&

यह एक अनाम फ़ंक्शन है, जिसे आप पसंद कर सकते हैं

Sin[t=π#/2]i+Cos@t&[15]

(या fकहने के लिए असाइन करें , और फिर करें f[15]।)

वास्तविक का समर्थन करता है और पूर्णांक इनपुट के लिए सटीक परिणाम देता है।

ध्यान दें कि iहै नहीं मेथेमेटिका के जटिल मैं (जो I)। यह सिर्फ एक अपरिभाषित चर है।

इसके अलावा, अभिव्यक्ति के आदेश के बावजूद, Mathematica R+Ciरूप में आउटपुट को फिर से व्यवस्थित करेगा ।

— मार्टिन एंडर
स्रोत

आप की जरूरत नहीं है 4%। यह स्वचालित रूप से किया जा सकता है।

— jimmy23013

@ user23013 निफ्टी :)

— मार्टिन

8

क्या दो उत्तर अलग नहीं होने चाहिए?

— जस्टिन

@Quincunx हो सकता है ... मूल रूप से वे दोनों सीजेएम में थे, यही कारण है कि मैंने उन्हें एक ही जवाब में डाल दिया। लेकिन दूसरा वाला वैध नहीं था, इसलिए मैंने इसे गणितज्ञ के पास भेज दिया, लेकिन इसे छोड़ दिया जहां यह था। अगर लोग जोर देते हैं तो मैं उन्हें विभाजित कर सकता हूं।

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

और आप f@15इसके बजाय का उपयोग करने में एक चरित्र को बचा सकते हैं f[15]।

— ओवोम

14

अजगर 2 - (24-5) = 19

lambda n:'1i--'[n%4::-2]

सबसे अधिक श्रेय @ user2357112 का है, मैंने इस उत्तर पर टिप्पणियों से उनके उत्तर को थोड़ा और अधिक जोड़ दिया ।

स्पष्टीकरण: n%4स्ट्रिंग में सूचकांक पर शुरू होता है '1i--'। फिर स्ट्रिंग में प्रत्येक अक्षर पर दो से अधिक चरणों में पीछे की ओर। इसलिए, उदाहरण के लिए, n=6सूचकांक 2 पर शुरू होगा, पहले -, फिर छोड़ें iऔर 1वापस लेने के लिए , वापस जाएं -1।

@xnor ने एक समान लंबाई वाला समाधान बताया:

lambda n:'--i1'[~n%4::2]

पायथ - (14-5) = 9

मैं केवल 14 प्राप्त कर सकता हूं, चाहे मैं रिवर्स / स्लाइस / आदि की कोशिश करूं। : '(

%_2<"1i--"h%Q4

जो मूल रूप से उपरोक्त अजगर के उत्तर के समान है, लेकिन 2 चरणों में, क्योंकि अजगर अजगर के पूर्ण अनुक्रमण विकल्पों का समर्थन नहीं करता है। इसे ऑनलाइन आज़माएं।

मैं जा रहा हूँ के बारे में एक बात है अजगर के बारे में isaacg के साथ अनुक्रमण;)

— FryAmTheEggman
स्रोत

क्या अजगर lambdaको एक चर को सौंपा जाना आवश्यक नहीं है ? कम से कम, इसे कॉल करने के लिए आपको इसे दो बाइट्स जोड़कर कोष्ठक के साथ घेरना होगा, ताकि इसे कॉल किया जा सके (lambda...)(n)।

— mbomb007

@ mbomb007 मेटा के अनुसार यह स्वीकार्य है। यहां कोड एक फ़ंक्शन बनाता है जो कार्य को एक आवश्यक कार्य करता है। अनाम लैंबडास का उपयोग अजगर जैसे कार्यों के लिए अपेक्षाकृत अक्सर किया जाता है mapऔर sorted।

— FryAmTheEggman

11

TI-BASIC (NSpire) - 5 (20 अक्षर -15)

cos(nπ/2)+sin(nπ/2)i

यदि आप एक जटिल रिटर्न मान प्राप्त करना चाहते हैं, iतो अंत में (जटिल i) के साथ बदलें ।

— Shujal
स्रोत

@ मार्टिनबटनर टीआई-बेसिक कुछ प्रकार के 'एक्सप्रेशन' प्रकार का उपयोग करने के लिए लगता है, और बिल्ट-इन विधियाँ इनका सटीक परिणाम देती हैं।

— शुजाल

मैं देख रहा हूँ, सब अच्छा है। ;)

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

नियम के बारे में "यदि आपकी भाषा जटिल संख्याओं का समर्थन करती है, तो किसी भी फ़ंक्शन या अंकगणित का उपयोग न करें जो इसे बाहर काम कर सकता है।" + i अंकगणित है

— edc65

@ edc65 The + वास्तव में एक जटिल ऑपरेशन है। हालांकि, अगर आपको वह पसंद नहीं है, तो एक सामान्य के साथ बदलें i। यदि चर iको परिभाषित नहीं किया गया है, तो आपको जटिल संख्या मिल जाएगी, बस iइसके बजाय । मैं सिर्फ वास्तविक और काल्पनिक भागों की अलग-अलग गणना कर रहा हूं।

— शुजाल

1

@ शुजल उस मामले में, मुझे लगता है कि आपको iवैसे भी उपयोग करना चाहिए । जटिल मैं भी चरित्र नहीं है जो सवाल पूछता है, और यह आपको दो बाइट्स बचाएगा, इसलिए आप कम से कम मेरे साथ टाई करेंगे।)

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

7

मारबेलस , 43 बाइट्स

वास्तव में विजेता नहीं है, लेकिन मारबेलस मजेदार है। :)

}0
^0
=0&2
&1
}0
^1\/
=0&02D3169
\/\/&0&1&2

यह एक प्रोग्राम है जो इनपुट को पहले कमांड-लाइन तर्क से एकल पूर्णांक के रूप में पढ़ता है। ध्यान दें कि इनपुट को मोडुलो 256 लिया गया है, लेकिन यह 255 से अधिक इनपुट के लिए परिणाम की वैधता को प्रभावित नहीं करता है, क्योंकि 256 4 से विभाज्य है।

व्याख्या

मारबेलस एक 2 डी प्रोग्रामिंग भाषा है, जो उपकरणों के एक समूह के माध्यम से गिरने वाले "मार्बल्स" (बाइट मूल्यों) का अनुकरण करती है। बोर्ड 2-कैरेक्टर वाइड सेल (डिवाइस) से बना है, जो मार्बल्स को प्रोसेस कर सकता है। एक बोर्ड के नीचे से गिरने वाली हर चीज को STDOUT में प्रिंट किया जाता है।

चलो उपयोग में उपकरणों के माध्यम से चलते हैं:

}0वह जगह है जहाँ पहला कमांड-लाइन तर्क जाता है। मैंने इस उपकरण के दो उदाहरणों का उपयोग किया है, इसलिए मुझे इनपुट मान (एक ही समय में) की दो प्रतियां प्राप्त होती हैं।
^nnइनपुट मार्बल के थ्रेड के लिए जांच (जहां n=0कम से कम महत्वपूर्ण बिट है), और बिट पर निर्भर करता है 1या पैदा 0करता है।
=0के साथ समानता के लिए जाँच करता है 0। यदि इनपुट मार्बल समान है, तो यह सीधे से होकर गिरता है, यदि यह नहीं है तो इसे दाईं ओर धकेल दिया जाता है।
\/ एक कचरा है, तो यह सिर्फ इनपुट संगमरमर को निगल सकता है और कभी भी कुछ भी पैदा नहीं करता है।
2Dका ASCII कोड है -, 31ASCII कोड है 1और 69ASCII का कोड है i।
&nSynchronisers हैं। सिंक्रोनाइजर्स एक संगमरमर को तब तक स्टॉल करते हैं जब तक कि सभी सिंक्रोनाइज़र nएक संगमरमर को पकड़ नहीं लेते हैं, जिस बिंदु पर वे सभी अपने संग्रहीत संगमरमर को गिरने देंगे।

इसलिए प्रभावी रूप से, मैं जो करता हूं, वह है कि तीन संबंधित वर्णों को तीन सिंक्रोनाईज़र में रखें, और उन पर निर्भर करते हुए इनपुट में कम से कम महत्वपूर्ण बिट्स कैसे सेट करें।

अधिक जानकारी के लिए, विशिष्ट ड्राफ्ट देखें ।

— मार्टिन एंडर
स्रोत

1

मुझे यह वास्तव में पसंद है! मारबेलस लगता है फैब मुझे इसे कुछ समय पहले ही जांचना होगा :)

— केज़े १०

3

@ Kezz101 हमें यहां पर

— मार्टिन

ओह अच्छा! यह वास्तव में दिलचस्प लग रहा है

— Kezz101

यह मत भूलो कि आप कमांड लाइन पर मुख्य बोर्ड को इनपुट दे सकते हैं, इसलिए इस बोर्ड का उपयोग किया जा सकता है।

— शुक्राणु

1

@overactor Hm, मुझे नहीं पता ... अतिरिक्त वर्णों (भले ही वे अप्रतिस्पर्धी हों) का आउटपुट देना अभी भी मेरे लिए आउटपुट स्वरूप का उल्लंघन लगता है। हालांकि एक मेटा सवाल के लायक हो सकता है।

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

6

जावास्क्रिप्ट (ईएस 6) 29-5 = 24

नकारात्मक शक्ति का समर्थन करता है।

f=n=>(n&2?'-':'')+(n&1?'i':1)

ES5:

function f(n){return (n&2?'-':'')+(n&1?'i':1)}

— माइकल एम।
स्रोत

हां, छोटा ( f=n=>[1,'i',-1,'-i'][n%4])। लेकिन यह कम सेक्सी है और यह नकारात्मक शक्तियों का समर्थन नहीं करेगा। यह उस बोनस पर निर्भर करता है जो मुझे लगता है।

— माइकल एम।

एनओपी, 29 बाइट्स। नकारात्मक इस कोड के साथ समर्थित हैं।

— माइकल एम।

क्या JS के पास एक बिटवाइज़ &ऑपरेटर है? यदि ऐसा है तो आप &3एक सच्चे मापांक -4 ऑपरेशन के लिए कर सकते हैं । संपादित करें: ऐसा लगता है जैसे यह &2आपके उत्तर में उपयोग किया गया है ...

— feersum

5

पायथन 28 बाइट्स - 5 = 23

-V इनपुट्स का समर्थन करता है।

मान लें कि लंबोदर कार्य स्वीकार्य हैं (धन्यवाद FryAmTheEggman!):

lambda n:n%4/2*'-'+'1i'[n%2]

अन्यथा 31 बाइट्स - 5 = 26

print[1,"i",-1,"-i"][input()%4]

— डिजिटल आघात
स्रोत

1

आप इसे बिल्कुल नहीं कह सकते। आपको इसे कहीं स्टोर करना होगा जिसे आप एक्सेस कर सकते हैं। तुम कर सकते हो तो foo=..., या आप कर सकता है map(<your lambda>,range(10))की मानों की सूची प्राप्त करने के लिए i^nसे 0-9।

— FryAmTheEggman

2

मूल रूप से आप एक फंक्शन पॉइंटर बना रहे हैं, यदि वह अधिक स्पष्ट है: P

— FryAmTheEggman

3

@ डिटिजल ट्रॉमा: हां, हालांकि आप स्ट्रिंग स्लाइसिंग ट्रिक्स के साथ बेहतर कर सकते हैं। उदाहरण के लिए, lambda n:'--1i'[n%4-2::2]।

— user2357112

2

User2357112 के पोस्ट का अनुवाद करने के लिए: हर दूसरे वर्ण को '--1i'इंडेक्स पर शुरू करने से लें n%4-2। जब अजगर को एक नकारात्मक सूचकांक मिलता है, तो यह शुरू हो जाएगा कि कई पद सरणी के अंत से छोड़ दिए जाते हैं, और फिर ऊपर जाते हैं 0। इस तरह, 0और 1कभी भी -संकेतों को मत मारो , जबकि 3और 4करो।

— फ्राईमईएग्गमैन

1

lambda n:n%4/2*'-'+'1i'[n%2]स्थान को हटा देता है और छोटा होता है :)

— FryAmTheEggman

4

(Emacs) लिस्प - 34

सिर्फ मनोरंजन के लिए, (Emacs) लिस्प:

(lambda(n)(elt[1 i -1 -i](% n 4)))

यदि आप इसका उपयोग करना चाहते हैं, तो एक का defunउपयोग करें या उपयोग करें funcall:

(funcall
 (lambda (n) (elt [1 i -1 -i] (% n 4)))
 4) => 1

(mapcar
 (lambda(n)(elt[1 i -1 -i](% n 4)))
 [0 1 2 3 4 5 6 7 8])
 => (1 i -1 -i 1 i -1 -i 1)

— सीन एलाड
स्रोत

4

एपीएल (डायलॉग) , 8 चार्ट - 15 बोनस = स्कोर -7

अंतर्निहित (और इस प्रकार निषिद्ध) फ़ंक्शन है 0J1*⊢, लेकिन यह @ blutorange की विधि का उपयोग करता है ।

¯12○.5×○

चुनौती लेखक, Kezz101, ने लिखा :

यदि आप किसी भी वास्तविक संख्या का समर्थन करते हैं तो आप किसी भी वैध जटिल रूप में आउटपुट कर सकते हैं।

यह प्रपत्र में एक जटिल संख्या देता है aJbजो APL के लिए जटिल संख्याओं को प्रदर्शित करने का सामान्य तरीका है।

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

व्याख्या

¯12○ यूनिट वेक्टर को खोजें जिसमें रेडियन के कोण हैं

.5× एक आधा बार

○ तर्क को the (सर्कल स्थिरांक) से गुणा किया जाता है

— एडम
स्रोत

3

शुद्ध बैश, 29 बाइट्स - 5 = 24

-V इनपुट्स का समर्थन करता है।

a=(1 i -1 -i)
echo ${a[$1%4]}

— डिजिटल आघात
स्रोत

3

बेफुज -98, 41-5 = 36 35-5 = 30 32-5 = 27

&4%:01-`!4*+:2%'8*'1+\2/d*' +,,@

नकारात्मक पूर्णांक का समर्थन करता है। इस समाधान के साथ किसी भी पुरस्कार को जीतने के लिए नहीं, लेकिन जो भी हो।

यह सिर्फ इनपुट के रूप में एक संख्या को स्वीकार करता है, मापांक पर कुछ प्रवंचना करता है (जो, निराशा की बात है, नकारात्मक काम करने के लिए सामान्य मापांक के लिए सामान्य मापक की तरह काम नहीं करता है) इसे नकारात्मक काम करने के लिए, और फिर कुछ मौन स्थितियों के लिए करता है तय करें कि प्रत्येक चरित्र क्या होना चाहिए।

मुझे यकीन है कि यह बहुत नीचे गोल्फ हो सकता है। अभी के लिए, यहां एक और समाधान है जो नकारात्मक स्वीकार नहीं करता है, लेकिन कम होने से बोनस के नुकसान के लिए बनाता है:

बेगुंजे -98, 32 26 23

&4%:2%'8*'1+\2/d*' +,,@

संपादित करें - अब इस तथ्य का लाभ उठाता है कि "" - "" से 13 (0xd) वर्ण दूर है।

2 संपादित करें - अब, फिर से, इस तथ्य का लाभ उठाता है कि "i" 56 (0x38, या '8) वर्ण "1" से दूर है।

— Kasran
स्रोत

3

जावा 8 स्कोर: 72

जावा में, अब तक की सबसे बुरी गोल्फ भाषा! golfed:

java.util.function.Function s=n->{new String[]{"i","-1","-i","1"}[n%4]};

विस्तारित:

class Complex{

    java.util.function.Function s = n -> {new String[]{"i","-1","-i","1"}[n%4]};

}

नोट: मैं जावा 8 का उपयोग नहीं कर रहा हूँ। मेरे पास अभी तक इसके लिए रनटाइम नहीं है। अगर कोई सिंटैक्स त्रुटियां हैं, तो कृपया मुझे बताएं। यह मेरा पहला गोल्फ भी है।

संपादित करें: निकाला गया import।

संपादित करें: हटाए गए वर्ग की घोषणा।

स्कोर के साथ एक और उत्तर = 87 - 15 = 72

java.util.function.Function s=n->{Math.cos(n*Math.PI/2)+"+"+Math.sin(n*Math.PI/2)+"i"};

विस्तारित:

class Complex{

    java.util.function.Function s = n -> {Math.cos(n * Math.PI/2) + " + " + Math.sin(n * Math.PI/2) + "i"};

}

— नंबर एक
स्रोत

आप कुछ को "import java.util। *" से बचा सकते हैं

— Anubian Noob

@Anubian Noob क्लास फंक्शन पैकेज में java.util.functionहै java.util(या क्या मैं गलत हूं?)।

— TheNumberOne

लेकिन अगर आप पैकेज के अंतर्गत साधन आयात सब कुछ। जैसे आप वर्तमान में पैकेज में सभी वर्गों का आयात कर रहे हैं । java.util.*.*fuction

— अबूझ नोब

5

@ Anubian Noob importकेवल उस पैकेज में कक्षाएं आयात करता है। यह उस पैकेज के किसी भी वर्ग को संकुल से आयात नहीं करता है। उदाहरण के लिए, क्लास Functionपैकेज में है java.util.functionलेकिन पैकेज में नहीं है java.util।

— TheNumberOne

ओह मेरी बुर, उसके बारे में सॉरी।

— एनूबियन नोब

3

MATLAB, 33 बाइट्स - 5 = 28

x={'i','-1','-i','1'};x(mod(n,4))

हालांकि यह कुछ बाइट्स अधिक (37-5 = 32) है, मुझे वास्तव में यह दृष्टिकोण बेहतर लगता है:

x='1i -';x((mod([n/2,n],2)>=1)+[3,1])

— स्टीवी ग्रिफिन
स्रोत

i^3इसके -iबजाय i, लगता है कि यह सिर्फ 1 वर्ण जोड़ता है। - अन्य पाठकों के लिए सिडेनोट: चुनौती के पहले नियम के बिना, मैटलैब समाधान केवल 3 वर्ण लंबा होगा।

— डेनिस जहरुद्दीन

हां, वह टाइपो था। फिक्स्ड! ध्यान देने के लिए धन्यवाद ... कम से कम दूसरा (थोड़ा और अधिक रोचक) दृष्टिकोण सही है =)

— स्टेवि ग्रिफिन

3

C 77

main(){int n;scanf("%d",&n);char c[]={n%4>1?'-':' ',~n%2?'1':'i',0};puts(c);}

रुस्लान के लिए बेहतर धन्यवाद

C 74-5 = 69

ओह और निश्चित रूप से सबसे स्पष्ट दृष्टिकोण

main(){unsigned n,*c[]={"1","i","-1","-i"};scanf("%d",&n);puts(c[n%4]);}

— rames
स्रोत

2

आप कोष्ठक को हटा सकते हैं n%2और ~इसके बजाय उपयोग कर सकते हैं !क्योंकि nपहले नकारात्मकता , फिर %2 के साथ आईएनजी एक ही परिणाम देगा, कम से कम के लिए n<(1<<32)-1। और C को फ़ंक्शन के लिए स्पष्ट रूप से रिटर्न प्रकार को परिभाषित करने की आवश्यकता नहीं है, इसलिए आप int शुरुआत में हटा सकते हैं । और के 0बजाय का उपयोग करें '\0'। इस प्रकार -9 वर्ण।

— रुसलान

3

OCaml 47

let m n=List.nth["1";"i";"-1";"-i"](n mod 4);;

पुरस्कार जीतने का समाधान नहीं, लेकिन यह मेरा पहली बार कोड-गोल्फिंग है, इसलिए मैं बिल्कुल यकीन नहीं कर रहा हूं कि मैं क्या कर रहा हूं। मैंने पैटर्न मिलान का उपयोग करने की कोशिश की, लेकिन मुझे 58 से अधिक मिला।

— usernumber
स्रोत

3

परी / जीपी , 19 बाइट्स - 5 = 14

$\mathbb{C}$ $\mathbb{R}[x]/(x^2+1)$

n->Str(i^n%(i^2+1))

iयहाँ केवल एक संकेत है, न कि काल्पनिक इकाई (जो है IPari / जीपी में)।

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

— alephalpha
स्रोत

2

रूबी 32-5 = 27

puts(%w[1 i -1 -i][gets.to_i%4])

नकारात्मक शक्तियों के लिए काम करता है!

— MegaTom
स्रोत

आप तुच्छ रूप से इस के साथ गोल्फ कर सकते हैं puts %w[1 i -1 i][gets.to_i % 4]।

— 20

2

पर्ल, 26 - 5 = 21

say qw(1 i -1 -i)[pop()%4]

एक स्टैंडअलोन प्रोग्राम (कमांडलाइन पर तर्क) या एक फ़ंक्शन के शरीर के रूप में काम करता है।

— हॉब्स
स्रोत

2

जावा: 151 131-5 = 126

golfed:

class A{public static void main(String[]a){int n=Integer.parseInt(a[0]);System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}}

Ungolfed:

class A {
    public static void main(String[] a) {
        int n = Integer.parseInt(a[0]);
        System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
    }
}

एक समारोह के रूप में: 72-5 = 67

golfed:

void f(int n){System.out.print(n%4==0?"1":n%4==1?"i":n%4==2?"-1":"-i");}

Ungolfed:

public void f(int n) {
    System.out.print(n % 4 == 0 ? "1" : n % 4 == 1 ? "i" : n % 4 == 2 ? "-1" : "-i");
}

हाँ, अभी तक एक और जावा उत्तर - और पहले से कहीं ज्यादा बदतर गोल्फिंग। लेकिन आप जो कर सकते हैं उसके साथ काम करते हैं ...

संपादित करें : जोड़ा गया फ़ंक्शन संस्करण।

EDIT 2 : तो, थोड़ा परीक्षण और त्रुटि के बाद, यहां एक संस्करण है जो पुस्तक द्वारा इसे करने की कोशिश करता है, चक्र लूपहोल की खोज के बिना। इसलिए…

जावा मूल्य गणना के साथ: 146-15 = 131

golfed:

class B{public static void main(String[]a){float n=Float.parseFloat(a[0]);System.out.print(Math.cos((n*Math.PI)/2)+Math.sin((n*Math.PI)/2)+"i");}}

Ungolfed:

class B {
    public static void main(String[] a) {
        float n = Float.parseFloat(a[0]);
        System.out.print(Math.cos((n * Math.PI) / 2) + Math.sin((n * Math.PI) / 2) + "i");
    }
}

(कम से कम, मुझे लगता है कि मैं शीर्ष बोनस का दावा कर सकता हूं, मुझे सही कर लें)

— रोडोल्फो डायस
स्रोत

यदि आप इसे तर्क के रूप में मुख्य रूप से पास करते हैं, तो आप अपना कोड कम कर सकते हैं।

— user902383

@ user902383 मैं हमेशा एक फंक्शन कर सकता था। शायद दोनों संस्करणों को भी पोस्ट करेंगे।

— रोडोल्फो डायस

वास्तव में मैं इसे पार्स करने के बारे में सोच रहा था, इसलिए आपके पास होगाint n = Integer.parseInt(a[0])

— user902383

@ user902383 Daaaaamn, यह भी याद नहीं था। अंगूठे

— रोडोल्फो डायस

2

अजगर - 31

print[1,'i',-1,'-i'][input()%4]

मैंने हाल ही में अजगर सीखना शुरू किया है। हालांकि मुझे पता है कि यह अच्छा नहीं है, यह सबसे अच्छा मैं कर सकता हूं।

— kukac67
स्रोत

2

हास्केल जीएचसीआई, 29 बाइट्स - 15 = 14

i p=[cos(p*pi/2),sin(p*pi/2)]

उपयोग:

*Main> i 0
[1.0,0.0]
*Main> i pi
[0.22058404074969779,-0.9753679720836315]
*Main> i (-6.4)
[-0.8090169943749477,0.5877852522924728]

— Rentsy
स्रोत

2

आर , 29 - 5 = 24 बाइट्स

c(1,"i",-1,"-i")[scan()%%4+1]

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

उपर्युक्त अधिकांश विधियों के समान, 4 का एक मोड्यूल लेता है, और 1 से बढ़ाता है, क्योंकि R की सरणियाँ 1-अनुक्रमित हैं। नकारात्मक पूर्णांक के लिए भी काम करता है।

मैं यहाँ मिश्रित आउटपुट के बारे में चिंतित था, लेकिन Giuseppe ने बताया कि R संख्यात्मक प्रकारों को स्ट्रिंग प्रकारों में मिलाते हैं जब वे मिश्रित होते हैं।

— Sumner18
स्रोत

29 - 5 = 24 बाइट्स

— ग्यूसेप

उस पर @Giuseppe पूरी तरह से खाली है। उस के साथ मेरी चिंता यह है कि आउटपुट तकनीकी रूप से मिश्रित है, आधा स्ट्रिंग, आधा संख्यात्मक।

— सुमनेर १18

नहींं, R स्वचालित रूप numericसे characterजब वे मिश्रित होते हैं, तब तक coerces होते हैं! हैडली की पुस्तक इसे बहुत अच्छी तरह से समझाती है - बस Ctrl + F से "ज़बरदस्ती" और आप इसे देखेंगे, लेकिन पूरी किताब एक पढ़ने लायक है (गैर-गोल्फ प्रयोजनों के लिए ज्यादातर, लेकिन कभी-कभी आप एक चाल या दो उठाते हैं, हेह )

— गिउसेप्पे

2

पावरशेल , 28 बाइट्स -5 = 23

('i',-1,'-i',1)["$args"%4-1]

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

सभी चक्रीय अनुक्रमण का पोर्ट

— Veskah
स्रोत

1

हास्केल, 29 बाइट्स - 5 = 24

f n=words"1 i -1 -i"!!mod n 4

नकारात्मक शक्तियों के लिए काम करता है।

मेरे पास एक पॉइंटफ्री संस्करण था, लेकिन यह वास्तव में लंबा है।

f=(words"1 i -1 -i"!!).(`mod`4)

— colevk
स्रोत

1

क्लोजर ( 64 54 31 वर्ण)

(defn i2n[n](println(case(mod n 4) 1 "i" 2 "-1" 3 "-i" 0 "1")))

संपादित करें

@ SeanAllred के सुझाव के अनुसार, यहां एक संस्करण है जो एक caseफ़ंक्शन के बजाय शाब्दिक वेक्टर का उपयोग करता है :

(defn i2n[n](println (["1" "i" "-1" "-i"] (mod n 4))))

संपादित करें 2

परिणाम को इकट्ठा करने और #()शॉर्टकट का उपयोग करके फ़ंक्शन को कोड करने के लिए REPL पर गणना करके हम इसे कम कर सकते हैं

#(["1" "i" "-1" "-i"](mod % 4))

(जो वास्तव में अधिक क्लोजर / लिस्प-ईश है क्योंकि फ़ंक्शन अब वास्तव में उत्पन्न परिणाम देता है, फ़ंक्शन को उपयोग करने की अनुमति देता है map, जैसे कि

(map #(["1" "i" "-1" "-i"](mod % 4)) [0 1 2 3 4 5 6 7 8])

जो प्रिंट करता है

("1" "i" "-1" "-i" "1" "i" "-1" "-i" "1")

साझा करें और आनंद लें।

— बॉब जार्विस - मोनिका को बहाल करें
स्रोत

एक चयनित संरचना का उपयोग करने के बजाय, क्या आप मेरे जवाब में किसी प्रकार के स्पष्ट सरणी का उपयोग नहीं कर सकते हैं ?

— सीन एलेड

1

ग्रूवी: 27-5 = 22

f={n->[1,'i',-1,'-i'][n%4]}

— आर्मंड
स्रोत

1

C 105, 117 था

char c[2];
int main()
{
int n,i,j=0;scanf("%d",&n);i=n%4;
i>1?c[j++]='-':c[j+1]='\0';
c[j]=i&1?'i':'1';
puts(c);
}

— bacchusbeale
स्रोत

यह भी संकलित नहीं करता है क्योंकि आपको सादे सी :में ?:बयानों के बाद असाइनमेंटों को संक्षिप्त करना होगा । इसके अलावा, 0==0जब आप अपने चार्ट का उपयोग कर सकते हैं तो उपयोग करने का क्या मतलब है 1? और पहले कोष्ठक में कोई जरूरत नहीं है ?। इसके अलावा, अंतिम ?:विवरण को छोटा किया जा सकता है c[j]=i&1?'i':'1';।

— रुसलान

@Ruslan कोडब्लॉक मिंगव में आई एंड 0 के आसपास केवल 1 चेतावनी है। i & 0 == 0 एक परीक्षण है यहां तक कि, अगर मैं परिणाम भी 0 है तो यह 1 और है।

— bacchusbeale

हाँ, लेकिन 0==0इसके समान होने पर उपयोग करने की क्या बात है 1? ध्यान दें कि ==पहले की तुलना में उच्च वरीयता है &, अन्यथा आपकी (माना) परीक्षा (i&0)==0हमेशा सही होगी।

— रुस्लान

1

PARI / GP , 26 - 5 = 21

n->Str([1,I,-1,-I][n%4+1])

n->cos(t=Pi*n/2)+I*sin(t)एक वर्ण छोटा है, लेकिन सटीक उत्तर नहीं देता है। बेशक n->I^n, अस्वीकृत है, और संभवतः PARI की भी है powIs।

— चार्ल्स
स्रोत

1

जेली , 2 - 20 = -18 बाइट्स

ı*

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

यह एक i ^ xबिलिन का उपयोग नहीं करता है, लेकिन यह अनुमति के लिए बिलीन्स का उपयोग करता है 1jऔर **इसलिए निश्चित नहीं है।

— आउटग्रॉफर को एरिक करें
स्रोत

"यदि आपकी भाषा जटिल संख्याओं का समर्थन करती है, तो किसी भी ऐसे फ़ंक्शन या अंकगणित का उपयोग न करें जो इसे बाहर काम कर सके।" मुझे लगता है कि यह बहुत स्पष्ट है ...

— अमानवीय

@totallyhuman खैर, मुझे यकीन नहीं है कि क्या 1j शाब्दिक हालांकि प्रतिबंधित है?

— आउटगोल्फर

हाँ, लेकिन अंकगणित ( *) है।

— अशुभ

1

@totallyhuman Hm, हो सकता है कि मैं नीचे एक और संस्करण जोड़ दूं, हालांकि "किसी भी फ़ंक्शन या अंकगणित का उपयोग न करें जो इस पर काम कर सकता है" ऐसा प्रतीत होता है कि मैं इस सटीक कार्य को करने के लिए बिल्ट-इन का उपयोग नहीं कर सकता ... BTW जिस तरह से वह वाक्यांश यह मुझे लगता है कि आप शाब्दिक का उपयोग करने के लिए प्रोत्साहित किया जाता है हो जाता 1jहै।

— एलिक आउटफोलर

1

05AB1E , स्कोर 5 (10 बाइट्स - 5 बोनस)

'i®„-i1)Iè

इसे ऑनलाइन आज़माएं या कुछ और परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

'i         '# Push character "i"
  ®         # Push -1
   „-i      # Push string "-i"
      1     # Push 1
       )    # Wrap everything on the stack into a list: ["i", -1, "-i", 1]
        Iè  # Use the input to index into it (0-based and with automatic wrap-around)
            # (and output the result implicitly)

— केविन क्रूज़सेन
स्रोत

ढूँढें i ^ n, दिए गए n

रूबी, स्कोर -2

CJam, 12 वर्ण - 5 = 7

गणितज्ञ, २२ २० १ ९ वर्ण - १५ = ४

अजगर 2 - (24-5) = 19

पायथ - (14-5) = 9

TI-BASIC (NSpire) - 5 (20 अक्षर -15)

मारबेलस , 43 बाइट्स

व्याख्या

जावास्क्रिप्ट (ईएस 6) 29-5 = 24

पायथन 28 बाइट्स - 5 = 23

अन्यथा 31 बाइट्स - 5 = 26

(Emacs) लिस्प - 34

एपीएल (डायलॉग) , 8 चार्ट - 15 बोनस = स्कोर -7

व्याख्या

शुद्ध बैश, 29 बाइट्स - 5 = 24

बेफुज -98, 41-5 = 36 35-5 = 30 32-5 = 27

बेगुंजे -98, 32 26 23

जावा 8 स्कोर: 72

MATLAB, 33 बाइट्स - 5 = 28

C 77

C 74-5 = 69

OCaml 47

परी / जीपी , 19 बाइट्स - 5 = 14

रूबी 32-5 = 27

पर्ल, 26 - 5 = 21

जावा: 151 131-5 = 126

एक समारोह के रूप में: 72-5 = 67

जावा मूल्य गणना के साथ: 146-15 = 131

अजगर - 31

हास्केल जीएचसीआई, 29 बाइट्स - 15 = 14

आर , 29 - 5 = 24 बाइट्स

पावरशेल , 28 बाइट्स -5 = 23

हास्केल, 29 बाइट्स - 5 = 24

क्लोजर ( 64 54 31 वर्ण)

संपादित करें

संपादित करें 2

ग्रूवी: 27-5 = 22

C 105, 117 था

PARI / GP , 26 - 5 = 21

जेली , 2 - 20 = -18 बाइट्स

05AB1E , स्कोर 5 (10 बाइट्स - 5 बोनस)