36

आइए पॉजिटिव पूर्णांकों से गॉसियन पूर्णांकों तक एक सरल, विशेषण मानचित्रण बनाएं , जो कि जटिल संख्याएं हैं जहां वास्तविक और काल्पनिक भाग पूर्णांक होते हैं।

एक सकारात्मक पूर्णांक को देखते हुए, उदाहरण के लिए 4538, इसे बिना किसी अग्रणी के बाइनरी में व्यक्त करें 0:

4538 base 10 = 1000110111010 base 2

किसी भी ट्रेलिंग को निकालें 0:

100011011101

एक या अधिक के किसी भी रन की जगह 0'एक भी साथ +:

1+11+111+1

सभी 1के साथ बदलें i:

i+ii+iii+i

परिणामी जटिल अभिव्यक्ति का मूल्यांकन करें और सरलीकृत गाऊसी पूर्णांक का उत्पादन करें:

i+ii+iii+i = i+i*i+i*i*i+i = 2i+i^2+i^3 = 2i+(-1)+(-i) = -1+i

आउटपुट को पारंपरिक गणितीय तरीके से व्यक्त किया जा सकता है, या वास्तविक और जटिल भागों के लिए दो अलग-अलग पूर्णांकों के रूप में दिया जा सकता है। उदाहरण के 4538लिए, इनमें से कोई भी ठीक होगा:

-1+i
i-1
-1+1i
(-1, 1)
-1 1
-1\n1

जैसे आदानों के लिए 29, इस तरह के रूप mathy स्वरूपित आउटपुट 0, 0iया 0+0iसब ठीक कर रहे हैं।

jइसके बजाय (या कुछ और) का उपयोग करना iठीक है अगर यह आपकी भाषा के लिए अधिक स्वाभाविक है।

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

— केल्विन के शौक
स्रोत

शीर्षक से मुझे लगा कि चुनौती बाइनरी में जटिल संख्याओं के बारे में होगी, जैसे 4+2j-> 100+10j...

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

22

MATL , 7 बाइट्स

BJ*Y'^s

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

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

4538उदाहरण के लिए इनपुट पर विचार करें ।

B     % Implicit input. Convert to binary
      % STACK: [1 0 0 0 1 1 0 1 1 1 0 1 0]
J*    % Multiply by 1i
      % STACK: [1i 0 0 0 1i 1i 0 1i 1i 1i 0 1i 0]
Y'    % Run-length encoding
      % STACK: [1i 0 1i 0 1i 0 1i 0], [1 3 2 1 3 1 1 1]
^     % Power, element-wise
      % STACK: [1i 0 -1 0 -1i 0 1i 0]
s     % Sum of array. Implicit display
      % STACK: -1+1i

— लुइस मेंडो
स्रोत

2

MATL में 7 बाइट्स, और सबसे अच्छा मुझे मिल सकता है 58 MATLAB में ... आपने वहाँ एक अच्छी छोटी भाषा बनाई है! =)

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

1

जब यह ग्राफ़िंग या प्लॉटिंग की बात आती है तो @StewieGriffin आसानी से शो में सबसे अच्छा होता है, शायद मैट्रिक्स अंकगणित के लिए भी जो मैंने उसे देखा है उसके भयानक उत्तरों से।

— मैजिक ऑक्टोपस Urn

13

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

BŒgaıP€S

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

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

BŒgaıP€S  Main link. Argument: n (integer)

B         Convert to binary.
          If n = 4538, this yields [1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0].
 Œg       Group equal elements.
          This yields [[1], [0, 0, 0], [1, 1], [0], [1, 1, 1], [0], [1], [0]].
   aı     Logical AND with the imaginary unit.
          This yields [[ı], [0, 0, 0], [ı, ı], [0], [ı, ı, ı], [0], [ı], [0]].
     P€   Product each.
          This yields [ı, 0, -1, 0, -ı, 0, ı, 0].
       S  Sum.
          This yields -1+ı.

— डेनिस
स्रोत

10

पायथन 2, 53 बाइट्स

f=lambda n,k=0:(n and f(n/2,n%2*(k or 1)*1j))+~n%2*k

यह गोल्फ की कोशिश कर रहा है और यह गोल्फ लगता है, लेकिन मैं विचारों से बाहर हूँ ...

— Sp3000
स्रोत

1

यह (k or 1)इष्टतम नहीं लगता है, लेकिन केवल एक चीज जो मैं सोच सकता हूं वह है (k+0**k)...

— ETHproductions

@ETHproductions मेरे विचार बिल्कुल, लेकिन दुर्भाग्य से 0**kजटिल के लिए काम नहीं करता है k...

— Sp3000

6

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

Tr[1##&@@@Split[I*#~IntegerDigits~2]]&

व्याख्या

#~IntegerDigits~2

इनपुट को आधार 2 में परिवर्तित करें ( 4538बन जाता है {1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0})

I*

से गुणा I( {1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0}हो जाता है {I, 0, 0, 0, I, I, 0, I, I, I, 0, I, 0})

Split

रन से विभाजित ( {I, 0, 0, 0, I, I, 0, I, I, I, 0, I, 0}हो जाता है {{I}, {0, 0, 0}, {I, I}, {0}, {I, I, I}, {0}, {I}, {0}})

1##&@@@ ...

2. स्तर पर उत्पाद का पता लगाएं ( {{I}, {0, 0, 0}, {I, I}, {0}, {I, I, I}, {0}, {I}, {0}}हो जाता है {I, 0, -1, 0, -I, 0, I, 0})

Tr

परिणाम का योग। ( {I, 0, -1, 0, -I, 0, I, 0}बन जाता है -1 + I)

— जंगहवान मिन
स्रोत

माइनस 1 बाइट:Tr[Times@@@(I*Split@RealDigits[#,2][[1]])]&

— मार्टिन

1

@ स्मार्टिन वेल, मैंने आपके विचार को Iपहले गुणा करने का उपयोग किया था , लेकिन IntegerDigitsछोटा होने पर समाप्त हो गया।

— जुंगह्वान मिन

हाँ - बहुत बेहतर :)

— मार्टिन

5

पायथन 2 , 77 76 71 बाइट्स

p=r=0
for n in bin(input()*2):t=n=='1';r-=p*~-t;p=p*t*1jor t*1j
print r

1 बाइट को बंद करने के लिए @ZacharyT को धन्यवाद!

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

— डेनिस
स्रोत

5

जावास्क्रिप्ट (ईएस 6), 67 64 बाइट्स

f=(n,q=0,a=[0,0])=>q|n?f(n/2,n&1?q+1:q&&0*(a[q&1]+=1-(q&2)),a):a

<input oninput="O.innerHTML=f(this.value)" type="number" step=1 min=0 value="4538">
<pre id=O></pre>

स्निपेट का विस्तार करें

एक 2-तत्व सरणी के रूप में आउटपुट।

व्याख्या

चूंकि जावास्क्रिप्ट में काल्पनिक संख्या नहीं है, इसलिए हमें अलग-अलग चर में वास्तविक और काल्पनिक भागों का ट्रैक रखना होगा। ऐसा करने का सबसे आसान तरीका एक ही सरणी में है, पहले वास्तविक भाग के साथ। मैं के रूप में प्रस्तुत किया जाता है [0,1] , मैं ² (या -1 ) के रूप में [-1,0] , मैं ³ (या मैं ) के रूप में [0, -1] , और मैं ⁴ (या 1 ) के रूप में [1 , 0] ।

सबसे पहले, हम बार-बार संख्या को 2 से विभाजित करते हैं, प्रत्येक के रन को बाइनरी प्रतिनिधित्व में एकत्रित करते हैं। N का प्रत्येक रन i ⁿ से मेल खाता है । यह दो-आइटम सरणी में अनुक्रमणिका n & 1 पर आइटम में 1 - (n & 2) जोड़ने से मेल खाती है । तो हम करते हैं।

मुझे शायद अधिक स्पष्टीकरण जोड़ना चाहिए, लेकिन मैं यह नहीं सोच सकता कि और क्या समझाने की आवश्यकता है। किसी भी प्रश्न के साथ टिप्पणी करने के लिए स्वतंत्र महसूस करें।

— ETHproductions
स्रोत

5

अजगर, 199 129 124 116 94 90 71 63 61 बाइट्स

print sum(1j**len(s)for s in bin(input())[2:].split('0')if s)

इनपुट सिर्फ नंबर ही है।
आउटपुट प्रारूप में है (a+bj), जहां jकाल्पनिक इकाई है। 0jके बजाय आउटपुट होगा(0+0j)

पहले बाइनरी में कनवर्ट करें। '0b'बंद ट्रंक । अनुगामी शून्य को मार डालो। एक सीमांकक के रूप में शून्य (एस) के एक ब्लॉक का उपयोग करके विभाजित करें। प्रत्येक ब्लॉक को मैप करें 1j ** len। फिर, पूरी चीज़ का योग लें।

-70 बाइट्स प्लसस में कनवर्ट नहीं करके।
-5 बाइट्स रेगेक्स छोटा होता है।
-8 बाइट्स से छुटकारा पाने के लिए दो अनावश्यक चर जो केवल एक बार बुलाए जा रहे थे। मेरी अजीब बात के बजाय जटिल संख्या का उपयोग करके
-22 बाइट्स । जटिल संख्याओं की सूचना देने के लिए @ डेनिस के उत्तर के लिए धन्यवाद!
-4 बाइट्स यह महसूस करके कि mapसूची बोध करने का सिर्फ एक फैंसी तरीका है, लंबे समय तक छोड़कर।
-19 बाइट्स के साथ त्रुटियों से बचने j ** 0और regex से बचने के लिए थोड़ा रहस्यमय तरीका पर स्विच करके । @ ग्रिफिन की टिप्पणी से प्रेरित है। धन्यवाद! :)
-8 बाइट्सif भाग को अंत तक ले जाकर ।
-2 बाइट्स इसके बजाय जनरेटर अभिव्यक्ति बनाने के लिए चौकोर कोष्ठक को हटाकर 2 बाइट्स बचाने के लिए @Griffin का धन्यवाद!

— HyperNeutrino
स्रोत

मुझे काफी कुछ समान मिला इसलिए अलग उत्तर पोस्ट नहीं करूंगा, हालांकि थोड़ा कमsum(1j**x.count('1')for x in bin(input()).split('0')if x)

— ग्रिफिन

@ ग्रिफिन नाइस। मुझे लगता है कि यह काफी अलग है कि आप एक अलग उत्तर पोस्ट कर सकते हैं, क्योंकि यह 1ब्लॉकों को गिनने की एक अलग विधि का उपयोग करता है और यह मेरा उपयोग करके रेगेक्स का उपयोग नहीं करता है। इसके अलावा, मैं आपसे कोड चोरी नहीं करना चाहता क्योंकि यह मेरे संस्करण से बहुत बेहतर है। :)

— हाइपरएन्यूट्रीनो

@Griffin मुझे एक और समाधान मिला है जो लंबाई के बजाय आपके समाधान के समान 1लंबाई है, यह 0xपहले भाग को बंद कर देता है। ifअंत तक जाने के विचार के लिए धन्यवाद ; मुझे कभी नहीं पता था कि अन्यथा काम करता है!

— हाइपरएन्यूट्रीनो

आपको सूची समझने की आवश्यकता नहीं है। वर्ग कोष्ठक निकालें इसे एक जनरेटर अभिव्यक्ति बनाने के लिए

— ग्रिफिन

@ श्रीफल ओह। ठीक है शुक्रिया! मुझे याद है कि भविष्य में गोल्फ के लिए

— हायपरनेट्रिनो

4

MATLAB, 58 बाइट्स

@(x)eval([strrep(strrep(dec2bin(x),48,43),49,'i*1'),'.0'])

dec2bin(x) % converts the decimal value to a binary string of 1s and 0s.
strrep(dec2bin(x),48,43) % Substitutes ASCII character 48 with 43 (0s become +)
strrep(___,49,'i*1')     % Substitutes ASCII character 49 with 'i*1'
                         % 1s become 'i*1' (this is the gem)
eval([___,'.0']          % Appends .0 in the end and evaluates the expression.

285प्रक्रिया का वर्णन करने के लिए उपयोग करते हैं:

temp1 = dec2bin(285)
      = 100011101

temp2 = strrep(temp1,48,43)
      = 1+++111+1

सौभाग्य से MATLAB के 1+++1रूप 1+1में व्यवहार करता है , इसलिए ऊपर का मूल्यांकन करता है 1+111+1:।

temp3 = strrep(temp2,49,'i*1')
      = i*1+++i*1i*1i*1+i*1

अब यह strrep-call असली रत्न है! डालने के i*1लिए 1हम वास्तव में कुछ अच्छा मिलता है। यदि केवल एक ही है 1, तो हमें बस i*1वही मिलता है जो है i। यदि एक से अधिक हैं तो i*1एक क्रम में दोहराया और समाप्‍त हो जाता है i*1i*1i*1i*1:। चूंकि i==1iMATLAB और 1i*1==iयह बस है i*i*i*i:।

temp4 = [temp3,'.0']
      = i*1+++i*1i*1i*1+i*1.0

लागू करना .0यहां अनावश्यक लगता है, लेकिन इसकी आवश्यकता है यदि अंतिम चरित्र temp3ए है +। हम सिर्फ एक शून्य नहीं जोड़ सकते हैं, क्योंकि यह i*10ऊपर के मामले में देगा और इसलिए गलत परिणाम।

और अंत में:

eval(temp4)
0.0000 + 1.0000i

यह कई कारणों से ऑक्टेव में काम नहीं करता है। strrepइनपुट के रूप में एएससीआईआई-मान नहीं ले सकता है, इसे वास्तविक पात्रों ( '0'इसके बजाय 48) की आवश्यकता है। इसके अलावा, +++केवल +ओक्टेव में मूल्यांकन नहीं करता है , क्योंकि यह वेतन वृद्धि / कमी शॉर्टकट x++और x--।

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

1

उपयोग करने के लिए हमेशा +1: - evalक्या आप 1iइसके बजाय उपयोग नहीं कर सकते 1*i?

— लुइस मेंडू

1

ओह, आप इसे अलग तरह से इस्तेमाल कर रहे हैं। बहुत चालाक!

— लुइस मेंडो

धन्यवाद :-) मुझे स्वीकार करना चाहिए, मैं इस i*1भाग से काफी संतुष्ट था ...

— Stewie Griffin

3

पायथ - 15 बाइट्स

निराशा से लंबा।

s^L.j)hMe#r8jQ2

टेस्ट सूट ।

— Maltysen
स्रोत

2

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

ToExpression[#~IntegerString~2~StringTrim~"0"~StringReplace~{"0"..->"+","1"->"I "}]&

अनाम फ़ंक्शन। एक संख्या को इनपुट के रूप में लेता है और एक जटिल संख्या को आउटपुट के रूप में लौटाता है।

— LegionMammal978
स्रोत

6

वाह, मुझे आश्चर्य है कि गणितज्ञ के पास इसके लिए कोई अंतर्निहित नहीं है!

— हाइपरएन्यूट्रीनो

2

गणितज्ञ, 75 बाइट्स

ToExpression[#~IntegerString~2~StringReplace~{"1"->"I ","0"..->"+"}<>"-0"]&

स्वतंत्र रूप से लगभग एक ही समाधान के साथ आया था कि LegionMammal978 ने 23 मिनट पहले पोस्ट किया था! के 1साथ प्रतिस्थापित करना I (जो कि -1 के वर्गमूल के लिए मैथेमेटिका का आंतरिक प्रतीक है) काम करता है क्योंकि रिक्त स्थान को पड़ोसी अभिव्यक्तियों के गुणन के रूप में माना जाता है। जिस स्थान को मैंने दूसरे समाधान पर रखा, अर्थात् आवश्यकता से बचकर StringTrim, हमेशा जोड़कर -0: यदि द्विआधारी संख्या समाप्त हो जाती है 1, तो यह अभिव्यक्ति समाप्त हो जाती है, ...I-0जो इसके मूल्य को प्रभावित नहीं करता है; जबकि यदि बाइनरी संख्या '0' में समाप्त होती है, तो यह अभिव्यक्ति समाप्त हो जाती है ...+-0जिसमें "नकारात्मक 0 जोड़ें" के रूप में पार्स किया जाता है और इस प्रकार अनुगामी प्लस चिह्न से छुटकारा मिलता है।

— ग्रेग मार्टिन
स्रोत

2

मतलाब, 99 बाइट्स

function c=z(b)
c=0;b=strsplit(dec2bin(b),'0');for j=1:numel(b)-isempty(b{end});c=c+i^nnz(b{j});end

परीक्षण के मामलों:

z(656) = 3i
z(172) = -1 + 2i
z(707) = -2 + i
z(32)  = i
z(277) = 4i

— ओवेन मॉर्गन
स्रोत

2

हास्केल, 102 91 89 87 बाइट्स

0%a=a
n%c@[a,b]|odd n=div n 2%[-b,a]|d<-div n 2=zipWith(+)c$d%[mod d 2,0]
(%[0,0]).(*2)

बार-बार दो से विभाजित करता है और बिट की जांच करता है। का एक संचायक रखता हैi^(number of odds)जहां और के a+b*iरूप में इनकोडिंग है है (90 डिग्री से रोटेशन)। पहले बिट के लिए लुकअप से बचने के लिए प्रारंभिक है।[a,b]*i[a,b]↦[-b,a](*2)

उपयोग (उदाहरणों के लिए @OwenMorgan के लिए धन्यवाद):

(%[0,0]).(*2)<$>[656,172,707,32,277]
[[0,3],[-1,2],[-2,1],[0,1],[0,4]]

— Angs
स्रोत

1

जावा, 172 बाइट्स

l->{int i=0,j=i;for(String x:l.toString(2).split("0")){int a=x.length();j+=a&1>0?(a&3>2?(a-3)/-4+1:(a-3)/4+1):0;i+=a&1<1?(a&3>1?(a-3)/4+1:(a-3)/-4+1):0;}return i+"|"j+"i";}

— रोमन ग्रैफ़
स्रोत

1

क्लोजर, 183 बाइट्स

#(loop[x(clojure.string/split(Integer/toString % 2)#"0+")y[0 0]a 0](if(= a(count x))y(recur x(let[z([[1 0][0 1][-1 0][0 -1]](mod(count(x a))4))][(+(y 0)(z 0))(+(y 1)(z 1))])(inc a))))

क्या मुझे ऐसा करने की अनुमति है?

फ़ंक्शन का उपयोग करें जैसे:

(#(...) {num}) -> (Wrap the # function in brackets first!)

— clismique
स्रोत

1

दरअसल , 35 बाइट्स

├'0' aÆô' @s"j+"j'jo`"1j*1"'1τ(Æ`Y≡

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

स्पष्टीकरण:

├'0' aÆô' @s"j+"j'jo`"1j*1"'1τ(Æ`Y≡
├                                    binary representation of input
 '0' aÆ                              replace 0s with spaces
       ô                             trim leading and trailing spaces
        ' @s                         split on spaces
            "j+"j                    join with "j+"
                 'jo                 append "j"
                    `"1j*1"'1τ(Æ`Y   do until the string stops changing (fixed-point combinator):
                     "1j*1"'1τ(Æ       replace "11" with "1j*1"
                                  ≡  evaluate the resulting string to simplify it

बिल्कुल बराबर पायथन 3 कोड:

a='j+'.join(bin(eval(input()))[2:].replace('0',' ').strip().split())+'j'
b=0
while a!=b:b,a=a,a.replace("11","1j*1")
print(eval(a))

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

— मेगो
स्रोत

किसी भी अनुगामी खाली तारों को ट्रिम करने के लिए '0 के साथ '0@sऔर प्रयोग ``░करने पर आपको चार बाइट्स बचाने चाहिए।

— शर्लक

1

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

यह डेनिस के जेली जवाब से बेहतर नहीं है, लेकिन मैं वैसे भी जेली के जवाब में अपना हाथ आजमाना चाहता था। गोल्फ सुझाव आपका स्वागत है! इसे ऑनलाइन आज़माएं!

BŒrm2Ṫ€ı*S

Ungolfing

BŒrm2Ṫ€ı*S   Main link. Argument: n (integer)

B            Convert n to binary.
 Œr          Run-length encode the binary list.
   m2        Every 2nd element of the run_length encoding, getting only the runs of 1s.
     Ṫ€      Tail each, getting only the lengths of the runs.
       ı*    The imaginary unit raised to the power of each run (as * is vectorized).
         S   Sum it all into one complex number.

— Sherlock9
स्रोत

ऊपर दिए गए लिंक में इनपुट 1 रिटर्न 1 जे इनपुट 2 रिटर्न 1 जे .... क्या यह सही है?

— RosLuP

@RosLuP हां, यह सही है? चूँकि हम 0 के अनुगामी को निकालते हैं, 1 => 1 => 1jइसके बराबर है 2 => 10 => 1 => 1j।

— शर्लक

1

वास्तव में , 15 बाइट्स

गोल्फ सुझाव आपका स्वागत है! इसे ऑनलाइन आज़माएं!

├'0@s``░`lïⁿ`MΣ

Ungolfing:

         Implicit input n.
├        Convert n to binary.
'0@s     Split by '0's.
``░      Filter out non-truthy values.
`...`M   Map over the filtered result, a list of runs of '1's.
  l        Yield the length of the run of '1's.
  ïⁿ       Yield the imaginary unit to the power of that length.
Σ        Sum all of this into one complex number.

— Sherlock9
स्रोत

0

Axiom, 140, 131, 118 108 बाइट्स

b(x)==(s:=0;repeat(x=0=>break;r:=x rem 2;repeat(x rem 2=1=>(r:=r*%i;x:=x quo 2);break);s:=s+r;x:=x quo 2);s)

% i काल्पनिक लागत है

sb(x:NNI):Complex INT==
  r:Complex INT;s:Complex INT:=0
  repeat
    x=0=>break
    r:=x rem 2
    repeat
       x rem 2=1=>(r:=r*%i;x:=x quo 2)
       break
    s:=s+r
    x:=x quo 2
  s

परिणाम

(3) -> b 4538
   The type of the local variable r has changed in the computation.
   We will attempt to interpret the code.
   (3)  - 1 + %i
                                                    Type: Complex Integer
(4) -> b 29
   (4)  0
                                                    Type: Complex Integer
(5) -> sb 299898979798233333333333333339188888888888888888222
   Compiling function sb with type NonNegativeInteger -> Complex Integer
   (5)  - 7 + 12%i
                                                    Type: Complex Integer
(6) -> b 299898979798233333333333333339188888888888888888222
   (6)  - 7 + 12%i
                                                    Type: Complex Integer

— RosLuP
स्रोत

0

पर्ल 6 , 40 46 बाइट्स

मैं यह काफी जल्दी के साथ आया था

*.base(2).comb(/1+/).map(i***.chars).sum

दुर्भाग्य से यह वर्तमान में MoarVM पर Rakudo कार्यान्वयन में गलत है ।
say i ** 3; # -1.83697019872103e-16-1i

तो मुझे अगला सबसे अच्छा काम करना था:

*.base(2).comb(/1+/).map({[*] i xx.chars}).sum

विस्तारित:

*\             # Whatever lambda
.base(2)       # convert to a Str representation in base 2
.comb(/ 1+ /)  # get a list of substrings of one or more ｢1｣s
.map({         # for each of those

  [*]            # reduce using ｢&infix:<**>｣
    i xx .chars    # ｢i｣ list repeated by the count of the characters matched

}).sum          # sum it all up

परीक्षा:

.say for (4538, 29).map:

    *.base(2).comb(/1+/).map({[*] i xx.chars}).sum

# -1+1i
# 0+0i

— ब्रैड गिल्बर्ट b2gills
स्रोत

बग रिपोर्ट दायर

— ब्रैड गिलबर्ट b2gills

0

PHP, 87 बाइट्स

for($n=$argv[1];$n|$i;$n>>=1)$n&1?$i++:($i?$i=0*${$i&1}+=1-($i&2):0);echo"(${0},${1})";

लगभग ETHproductions´ समाधान के समान है; केवल पुनरावृत्ति के बजाय पुनरावृत्ति।
कमांड लाइन से इनपुट लेता है, चर सेट करता है ${0}और ${1}।

— टाइटस
स्रोत

0

टीआई-बेसिक (TI-84 Plus CE), 70 बाइट्स

Prompt X
0→S
0→N
While X
If remainder(X,2
Then
N+1→N
int(X/2→X
Else
S+i^Nnot(not(N→S
X/2→X
0→N
End
End
S+i^Nnot(not(N

बाइनरी स्ट्रिंग में कनवर्ट करने के लिए कोई बिल्ट नहीं है, (न ही स्ट्रिंग को पार्स करने के लिए है), इसलिए यह प्रोग्राम मैन्युअल रूप से 2 से विभाजित होता है, एन को बढ़ाता है हर बार यह 1 को देखता है और i ^ N से S (N> 0) जोड़कर रीसेट कर रहा है। यदि यह शून्य देखता है।

— pizzapants184
स्रोत

0

जावा , 100 बाइट्स

int[]f(int n){int c=2,r[]=new int[2];for(;n>0;r[c&1]+=n%4==1?(c&2)-1:0,n/=2)c=n%2<1?2:c+1;return r;}

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

— लीक नन
स्रोत

0

आर , 54 बाइट्स

function(n,x=rle(n%/%2^(0:log2(n))%%2))sum(1i^x$l*x$v)

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

n%/%2^(0:log2(n))%%2द्विआधारी अंकों के एक वेक्टर की गणना करता है। रन-लंबाई एन्कोडिंग का उपयोग करके, हम आर का उपयोग करते हैंcomplex उपयुक्त योग की गणना करने प्रकार का उपयोग करते हैं, जो कि गुणा से होता हैx$values शून्य को हटाने लिए ।

complexएक तत्व का एक वेक्टर लौटाता है ।

— ग्यूसेप
स्रोत

कॉम्प्लेक्स बाइनरी नंबर

MATL , 7 बाइट्स

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

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

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

पायथन 2, 53 बाइट्स

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

व्याख्या

पायथन 2 , 77 76 71 बाइट्स

जावास्क्रिप्ट (ईएस 6), 67 64 बाइट्स

व्याख्या

अजगर, 199 129 124 116 94 90 71 63 61 बाइट्स

MATLAB, 58 बाइट्स

पायथ - 15 बाइट्स

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

गणितज्ञ, 75 बाइट्स

मतलाब, 99 बाइट्स

हास्केल, 102 91 89 87 बाइट्स

जावा, 172 बाइट्स

क्लोजर, 183 बाइट्स

दरअसल , 35 बाइट्स

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

वास्तव में , 15 बाइट्स

Axiom, 140, 131, 118 108 बाइट्स

पर्ल 6 , 40 46 बाइट्स

विस्तारित:

परीक्षा:

PHP, 87 बाइट्स

टीआई-बेसिक (TI-84 Plus CE), 70 बाइट्स

जावा , 100 बाइट्स

आर , 54 बाइट्स