"इन्फिनिटी" से नीचे गणना


47

एक असंभव कार्य सही लगता है? खैर, यह वास्तव में मुश्किल नहीं है। यदि हम Infinity8-बिट बाइनरी ASCII कोड के रूप में शब्द लिखते हैं , तो हमें मिलेगा:

01001001 01101110 01100110 01101001 01101110 01101001 01110100 01111001

इसे संक्षिप्त किया जा सकता है, और दशमलव मान में परिवर्तित किया जा सकता है 5291279215216915577। अब यह एक संख्या है जिसके साथ हम काम कर सकते हैं ...

आपके द्वारा गिना जाने वाला तरीका है:

  1. मूल स्ट्रिंग को दशमलव संख्या के रूप में आउटपुट करें (जैसा कि ऊपर दिखाया गया है)
  2. इसके द्विआधारी प्रतिनिधित्व में अग्रणी 0s निकालें (यदि कोई हो)
  3. बाइनरी प्रतिनिधित्व में बिट्स को टॉगल करें (1-> 0, 0-> 1)
  4. दशमलव में संख्या को आउटपुट करें
  5. जब तक आप 0 तक नहीं पहुँचते तब तक चरण 2-4 दोहराएं।

चुनौती:

एक प्रोग्राम या फ़ंक्शन बनाएं जो एक स्ट्रिंग को इनपुट के रूप में लेता है, और आउटपुट (किसी भी उपयुक्त प्रारूप पर) संख्या आप ऊपर की प्रक्रिया करते समय प्राप्त करेंगे।

परीक्षण का मामला:

मुझे लगता है कि चुनौती को समझना काफी आसान होगा, भले ही यह केवल एक परीक्षण का मामला हो। मैं इसे काफी छोटा रखने के Infबजाय उपयोग करूँगा Infinity

Inf
4812390  (10010010110111001100110)
3576217  ( 1101101001000110011001)
618086   (   10010110111001100110)
430489   (    1101001000110011001)
93798    (      10110111001100110)
37273    (       1001000110011001)
28262    (        110111001100110)
4505     (          1000110011001)
3686     (           111001100110)
409      (              110011001)
102      (                1100110)
25       (                  11001)
6        (                    110)
1        (                      1)
0        (                      0)

Input: Inf 
Output:
4812390, 3576217, 618086, 430489, 93798, 37273, 28262, 4505, 3686, 409, 102, 25, 6, 1, 0 

Input: Infinity
Output:
5291279215216915577, 3932092821637860230, 679593196789527673, 473328307817319302, 103132444486104185, 40982743589751686, 31074850448176249, 4953946570787718, 4053252683953273, 450346943417222, 112603010004089, 28134478351238, 7049893737593, 1746199284614, 452823970937, 96931842950, 40507110521, 28212366214, 6147372153, 2442562438, 1852404857, 295078790, 241792121, 26643334, 6911097, 1477510, 619641, 428934, 95353, 35718, 29817, 2950, 1145, 902, 121, 6, 1, 0

आपके कोड को उन स्ट्रिंग्स का समर्थन करना चाहिए जिन्हें आपकी भाषा की सीमा तक बाइनरी नंबर के रूप में दर्शाया जा सकता है। सभी स्ट्रिंग्स में केवल 32-126 (टिल्ड के लिए स्थान) से मुद्रण योग्य ASCII-अक्षर होंगे।


लीडरबोर्ड


31
चक नॉरिस , 8 बाइट्स:Inf:-1:0
लुइस मेन्डो

2
@LuisMendo चक नॉरिस 'एनएआरएस-एपीएल:∞..0
एडम नोव

5
@LuisMendo क्या आप सुनिश्चित हैं कि आपका मतलब जॉन स्कीट से नहीं है ?
mbomb007

जवाबों:


12

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

-5 बाइट्स @ @ डेनिस के लिए धन्यवाद (क्रमिक कलाकारों के बाद सीधे आधार 256 से कन्वर्ट)

Oḅ⁹µBCḄµÐĿ

TryItOnline!

कैसे?

Oḅ⁹µBCḄµÐĿ - Main link: s                     e.g. "Inf"
O          - cast to ordinals                 e.g. [73,110,102]
 ḅ⁹        - convert from base 256 to integer e.g. 4812390
   µ   µ   - monadic chain separations
    B      -     convert to binary
     C     -     complement
      Ḅ    -     convert to integer
        ÐĿ - loop until no longer unique and collect results 

1
पहला हिस्सा सिर्फ है Oḅ⁹
डेनिस

ओह, मैं कैसे याद किया कि ?!
जोनाथन एलन

11

पायथन 2, 89 82 77 76 75 बाइट्स

n=0
for c in input():n=n<<8|ord(c)
while 1:print n;n^=2**n.bit_length()-n/n

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

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

N 0 से प्रारंभ करने के बाद , दूसरी पंक्ति चुनौतियों के रूप में निर्दिष्ट स्ट्रिंग-से-पूर्णांक रूपांतरण करती है।

प्रत्येक चरण में, एन स्थानांतरित कर दिया है 8 बाईं ओर इकाइयों, तो बिटवाइज़ या अगले वर्ण के कोड बिंदु के साथ एड । इनपुट के लिए Inf , इस प्रकार चला जाता है।

n                                  0
a = n<<8                           0
b = 'I'                      1001001
n = a ^ b                    1001001
a = n<<8             100100100000000
b = 'n'                      1101110
n = a ^ b            100100101101110
a = n<<8     10010010110111000000000
b = 'f'                      1100110
n = a ^ b    10010010110111001100110

अब हम आउटपुट जेनरेट करने के लिए तैयार हैं। N के बिट्स को पलटने के लिए , हम निम्नानुसार आगे बढ़ते हैं।

सबसे पहले, हम अग्रणी शून्य के बिना n के बाइनरी प्रतिनिधित्व में बिट्स की गणना करते हैं। के परिणाम कहते हैं कश्मीर । फिर, हम k k 2 की शक्ति की गणना करते हैं , जिसमें k + 1 बाइनरी अंक हैं: एक एकल 1 , जिसके बाद k 0 है । हम घटाना 1 परिणाम से, से बना एक नंबर उपज कश्मीर जो हम तो साथ XOR हैं, n इसके बिट्स को उलटने के लिए। इनपुट inf के लिए यह निम्नानुसार है।

n         4812390   10010010110111001100110
k              23 
t = 2**k           100000000000000000000000
t -= 1              11111111111111111111111
n ^= t    3576217    1101101001000110011001
k              22
t = 2**k            10000000000000000000000
t -= 1               1111111111111111111111
n ^= t     618086      10010110111001100110
.
.
.
n               6                       110
k               3
t = 2**k                               1000
t -= 1                                  111
n ^= t          1                         1
k               1
t = 2**k                                 10
t -= 1                                    1
n ^= t          0                         0

कार्यान्वयन में अतिरिक्त बाधा पर यह है कि हमें पहले कदम से पहले एन को अंतिम चरण के बाद और बीच में सभी चरणों में प्रिंट करना होगा । पायथन में लूप नहीं होता है और एक प्रिंट स्टेटमेंट में 8 बाइट्स खर्च होते हैं , इसलिए हम इसके बजाय निम्नलिखित करते हैं।

अद्यतन चरण के सीधे कार्यान्वयन में, अर्थात,

while n:print n;n^=2**n.bit_length()-1
print n

हम एक अनंत एक (के साथ पाश की जगह while 1) और गणना 1के रूप में पाश में n/n। यह n> 0 के बराबर है ।

एक बार n = 0 के बाद , हम लूप में रहते हैं, एक बार फिर से प्रिंट करें, फिर इसे अपडेट करने का प्रयास करें। हालाँकि, 0/0एक ZeroDivisionError को ट्रिगर करता है , लूप से बाहर निकलता है और एक त्रुटि के साथ बाहर निकलता है। ध्यान दें कि यह एसटीडीआरआर को आवारा उत्पादन का कारण बनता है, जिसे डिफ़ॉल्ट रूप से अनुमति दी जाती है


2
मुझे वह -n/nट्रिक पसंद है :-)
ETHproductions

क्या आप n/nचाल से समझा सकते हैं ? यह शायद कहीं और एक और उत्तर में समझाया गया है, लेकिन मैंने इसे नहीं पाया है। यहाँ क्या करता है?
स्टिव ग्रिफ़िन

@StewieGriffin n / n 1 है जब तक n 0 है, तब यह एक त्रुटि फेंकता है और प्रोग्राम को रोकने का कारण बनता है।
जैजपीआई

त्रुटि संदेश के साथ (मुझे आशा है)?
स्टीवी ग्रिफिन

1
@StewieGriffin वास्तव में। जब यह त्रुटि रिपोर्टिंग की बात आती है, तो पायथन दर्दनाक रूप से क्रियाशील होता है। मैंने स्पष्टीकरण को शामिल करने के लिए अपना उत्तर संपादित किया है।
डेनिस

8

जावास्क्रिप्ट, 82 बाइट्स

@Arnuald को बाइट धन्यवाद दिया

for(y of prompt(n=0))n=n<<8|y.charCodeAt()
for(;alert(n)|n;)for(i=1;i<=n;i*=2)n^=i

बहुत कम समय में से एक जब एक पूर्ण कार्यक्रम एक फ़ंक्शन को बेहतर बनाता है (और ES6 ईएस 5 से बेहतर प्रदर्शन नहीं करता है) ...


उपरोक्त 4-अक्षर शब्दों का समर्थन करता है। 6-अक्षर शब्दों का समर्थन करने के लिए 4 बाइट्स जोड़ें:

for(y of prompt(n=0))n=n*256+y.charCodeAt()
for(;alert(n)|n;n=i-n-1)for(i=1;i<=n;)i*=2


g=a=>a[0]?a.pop().charCodeAt()+g(a)*256:0(-1)
टाइटस

@ धन्यवाद! मुझे यकीन नहीं है कि मैंने ऐसा क्यों नहीं सोचा
ETHproductions

n<<8|y.charCodeAt()एक बाइट को बचाना चाहिए। for(;n;)for(i=!alert(n);i<=n;i*=2)n^=iएक और बाइट को बचाएगा, लेकिन आप प्रदर्शित नहीं करेंगे 0, जिसकी आवश्यकता है।
अरनौलद

@ अरनुलद धन्यवाद मैंने n<<8पहले करने के बारे में सोचा था लेकिन फैसला किया कि यह काम नहीं करेगा क्योंकि यह 31 से अधिक बिट्स के साथ एन के लिए टूट जाएगा। मुझे लगता है कि यह अब कोई फर्क नहीं पड़ता कि मैंने पहले से ही इसे 31-बिट संस्करण और 53-बिट संस्करण के बीच विभाजित कर दिया है ... और दुख की बात है कि मुझे नहीं लगता कि मैं अलर्ट पर कुछ भी बचा सकता हूं, जबकि दोनों पहले पुनरावृत्ति और अंतिम।
ETHproductions

7

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

2@├¿W■├♂≈♂Y2@¿

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

स्पष्टीकरण:

2@├¿W■├♂≈♂Y2@¿
 @├             encode input in binary
2  ¿            convert from binary to decimal
    W           while the number is not 0:
     ■            print the number without popping
      ├           convert number to binary
       ♂≈         convert each character to an int
         ♂Y       boolean negate each int
           2@¿    convert from binary to decimal

6

05AB1E , 18 बाइट्स

CP-1252 एन्कोडिंग का उपयोग करता है ।

Çžz+b€¦J[CÐ,_#bS_J

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

व्याख्या

Ç                     # convert string to list of ascii codes
 žz+                  # add 256 to each
    b                 # convert to binary
     €¦               # remove the first digit of each list of digits
       J              # join
        [             # start loop
         C            # convert to decimal
          Ð           # triplicate
           ,          # print 1 copy
            _#        # if the 2nd copy is 0, break loop
              b       # convert 3rd copy to binary
               S      # split to list
                _     # negate each in list
                 J    # join


4

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

a=FromDigits;b=IntegerDigits;NestWhileList[a[1-#~b~2,2]&,a[Join@@b[ToCharacterCode@#,2,8],2],#>0&]&

अनाम फ़ंक्शन। एक स्ट्रिंग को इनपुट के रूप में लेता है, और आउटपुट के रूप में संख्याओं की एक सूची देता है।


4

हास्केल, 109 123 118 102 97 बाइट्स

5 बाइट्स बचाने के लिए @nimi को धन्यवाद!

c 0=0
c n=1-mod n 2+2*c(div n 2)
(++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum

उपयोग: (++[0]).fst.span(>0).iterate c.foldl((+).(256*))0.map fromEnum $ "Infinity"

भाषा द्वारा 29 बिट तक की संख्या पर काम करने की गारंटी, आमतौर पर 64-बिट सिस्टम पर 63-बिट संख्या तक काम करती है। map(fromIntegral.fromEnum)इसके बजाय का उपयोग करें (+14 बाइट्स) मनमाने ढंग से बड़ी संख्या का समर्थन करने के लिए।

यूनिकोड श्रेणी के लिए काम करता है [0..255]। पुनरावर्ती बिट्स flips।


1
आप बदल सकते हैं takeWhile(>0)के साथ fst.span(>0)। यदि आप पॉइंटफ्री जाते हैं तो आप नाम छोड़ सकते हैं f, इसलिए आपका मुख्य कार्य है (++[0]) ... map fromEnum
nimi

@ नमि धन्यवाद, नाम छोड़ना मेरे साथ हुई प्रकार की समस्या को हल करता है f
एंग्स

क्यों fromIntegral? चुनौती से: "समर्थन करना चाहिए ... 63 बिट तक ... या आपकी भाषा की सीमा", इसलिए Intठीक होना चाहिए। यदि आप इसे रखना चाहते हैं, तो इसे mapअपने पुराने संस्करण पर ले जाएं , foldl1और map(fromIntegral.fromEnum)
नीमी

@nimi ओपी ने यहां एक टिप्पणी पोस्ट की (डिलीट किए जाने के बाद से), यह पूछने पर कि क्या यह 63 बिट्स का समर्थन करता है, इसलिए मैंने मान लिया कि यही उनका इरादा था। मुझे पता नहीं।
एंग्स

4

पीएचपी, 132 126 123 120 108 107 बाइट्स

foreach(unpack("C*",$argv[1])as$i)$n=$n*256+$i;for(print$n;$n;)echo _.$n=bindec(strtr(decbin($n),"01",10));
  • लूप 6 प्रारंभिक बाइट्स सहेजने से पहले प्रारंभिक मान के बजाय 0 मुद्रण।
  • unpackबजाय str_splitrenders ord()अप्रचलित -> -3 बाइट्स
  • _विभाजक के रूप में अंडरस्कोर 3 बचाता है।
  • bindecइसके बजाय ltrimअग्रणी शून्य को हटाने के लिए: -12
  • echoलूप बॉडी printमें लूप हेड में 1 बाइट बचाता है ।

के $n=$n*256+$i;for(print$n;$n;)रूप में नहीं लिखा जा सकता है for(print$n=$n*256+$i;$n;)? चूंकि असाइनमेंट भाग एक बार निष्पादित होगा, इसलिए यह काम करना चाहिए। और इसके बजाय echo _.$n=[...], आपको echo _,$n=[...]इसके बजाय उपयोग करना चाहिए । यह किसी भी बाइट को नहीं बचाएगा, लेकिन एक छोटे से छोटे छोटे कोड को कोड को गति देगा और बयानों को अलग करेगा। इसका मतलब है कि, उदाहरण के लिए, के echo _,$a?5:6;बजाय लिखा जा सकता है echo _.($a?5:6);। यह भविष्य में मददगार हो सकता है।
इस्माइल मिगुएल

@IsmaelMiguel असाइनमेंट भाग एक लूप है। मैं वास्तव में कॉमा का उपयोग करता हूं जब मुझे डॉट की आवश्यकता नहीं होती है; यह printइस मामले में एक अवशेष है । अकेले एक संपादन के लायक नहीं; लेकिन धन्यवाद।
टाइटस

ओह, ठीक है ... यह अंदर है foreach(unpack("C*",$argv[1])as$i)... मूर्खतापूर्ण मुझे ... और हाँ, अल्पविराम के लिए एक ही प्रभाव बदलने की अवधि परेशानी के लायक नहीं है।
इस्माइल मिगुएल

4

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

53 बाइट्स कोड + 12 के लिए -Mbigint -p

13 बाइट बचाने के लिए @ दादा को धन्यवाद !

$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0

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

प्रयोग

echo -n 'Inf' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0
echo -n 'Infinity' | perl -Mbigint -pE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

1
मेरे दोस्त को अनपैक करो, अनपैक करो! perl -Mbigint -lpE'$_=unpack"B*";say(0+"0b$_"),s/^0+//,y/10/01/while$_>0'(मुझे नहीं पता कि आमतौर पर अनपैक का उपयोग कैसे किया जाता है, मैं बस भाग्यशाली हो गया जब googling कैसे बाइनरी को स्ट्रिंग में परिवर्तित कर सकता हूं ;-))
दादा

आह, मैं हमेशा unpackवाक्यविन्यास के बारे में भूल जाता हूं हमेशा मेरे दिमाग को उड़ा देता है! मैं अपडेट करूंगा, धन्यवाद!
डोम हेस्टिंग्स

वहाँ perlpacktut है कि मदद करनी चाहिए ... मैंने पहली बार 10 पंक्ति दर्जनों बार पढ़ा है, लेकिन मुझे वास्तव में बाकी पढ़ने के लिए समय निकालना चाहिए!
दादा

@ दादा मुझे यकीन है कि मैंने इसे कई बार पढ़ा है, यह बस कभी नहीं रहता है ... धन्यवाद फिर से -13 कोई छोटी उपलब्धि नहीं है! मुझे echo -nकेवल अन्य बदलाव के लिए स्विच करना पड़ा ।
डोम हेस्टिंग्स

4

पायथ, 12 बाइट्स

.usi!MjN2 2C

एक प्रोग्राम जो एक उद्धृत स्ट्रिंग का इनपुट लेता है और परिणाम को पूर्णांक की सूची के रूप में प्रिंट करता है।

सभी परीक्षण मामलों की जाँच करें

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

.usi!MjN2 2C  Program. Input: Q
           C  Convert Q to an integer by code-points using base-256 (implicit input)
.u            Apply the following function A(N) until a repeat occurs, storing the results
              in a list:
      jN2       Convert to binary as a list
    !M          Map negation over the above
   i      2     Convert from binary to integer
  s             Integer (Converts final False to 0)
              Implicitly print

3

पायथन 3, 99 95 बाइट्स

x=int.from_bytes(bytes(input(),'utf-8'),'big')
while x:print(x);x^=2**x.bit_length()-1
print(0)

मुख्य विचार स्ट्रिंग को बाइट्स में संख्या में बदलना है। प्रत्येक पुनरावृत्ति आउटपुट और XOR को सभी 1s के साथ शून्य की ओर बढ़ने के लिए प्रिंट करती है।


आपको चारों ओर कोष्ठक की आवश्यकता नहीं है 2**x.bit_length()-1। शक्ति और घटाव के लिए संचालन का क्रम एक्सोर से अधिक है। इसके अलावा, यह whileएक लाइन पर हो सकता है।
mbomb007

एक पंक्ति पर लूप लिखते समय (न्यूलाइन और इंडेंट को हटा दें)
FlipTack

साथ कार्यक्रम शुरू करने का प्रयास P=printकरें और फिर का उपयोग कर P()के बजायprint()
Cyoce

3

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

साइओस को धन्यवाद 2 बाइट्स बचा रहा है।

उद्धरण में संलग्न इनपुट मानता है, जैसे "Inf"

s=input()
n=sum(ord(s[-i-1])<<i*8for i in range(len(s)))
while n:
 print n;k,m=n,1
 while k:k/=2;m*=2
 n^=m-1
print 0

mउच्चतम अंक तक गिना जाता है, इसलिए m-1वांछित ऑपरेशन करने के लिए एक XOR मास्क है। सबसे लंबा हिस्सा इनपुट को प्रारंभिक बिट अनुक्रम में परिवर्तित कर रहा है।

उदाहरण:

"Inf"
4812390
3576217
618086
430489
93798
37273
28262
4505
3686
409
102
25
6
1
0

"Infinity"
5291279215216915577
3932092821637860230
679593196789527673
473328307817319302
103132444486104185
40982743589751686
31074850448176249
4953946570787718
4053252683953273
450346943417222
112603010004089
28134478351238
7049893737593
1746199284614
452823970937
96931842950
40507110521
28212366214
6147372153
2442562438
1852404857
295078790
241792121
26643334
6911097
1477510
619641
428934
95353
35718
29817
2950
1145
902
121
6
1
0

आप के -i-1साथ बदल सकते हैं~i
Cyoce

3

रूबी, 104 101 100 81 80 65 बाइट्स

19 बाइट्स ने @ayneConrad को धन्यवाद दिया!
15 बाइट्स @philomory की बदौलत बच गईं!
1 बाइट @LeeW के लिए धन्यवाद बचा लिया!

p n=$*[0].unpack('B*')[0].to_i(2)
p n^=2**n.bit_length-1while n>0

कमांड लाइन तर्कों के माध्यम से इनपुट लेता है।

@ जिम्मी जॉनसन के पायथन जवाब से प्रेरित


आप की जगह कुछ वर्ण को बचाने के लिए सक्षम हो सकता है i.to_s(2).rjust 8,'0'के साथ"%08b"%i
वेन कॉनरोड

इसके अलावा, मुझे लगता है कि inject(:+)साथ बदला जा सकताjoin
वेन कॉनरोड

@WayneConrad मदद के लिए धन्यवाद! मुझे यकीन नहीं है कि मैं उन लोगों के बारे में कैसे भूल गया
21

मैं खुशी से मदद कर सकता है! मुझे #bit_length विधि सिखाने के लिए धन्यवाद, जिसके बारे में मुझे नहीं पता था।
वेन कॉनराड

1
के साथ खिलवाड़ करने के बजाय unpackइसके बाद स्विच करने [0]से gsub11 बाइट बचेंगे। पर स्विच किया जा $*[0]बजाय gets.chop(कंसोल इनपुट के बजाय एक कमांड लाइन तर्क का उपयोग करके) एक और 9 की बचत होगी, पहली पंक्ति हो जाता है p n=$*[0].unpack('B*')[0].to_i(2)
दार्शनिक

3

भूलभुलैया , 104 103 बाइट्स

'  )25 }_';:_';_2/;{
''', 6 2 1   1   { (
 ' | / _ _   _}*2_ $
 * _ :!\ }2_\     !:
 652       @'''''''

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

स्पष्टीकरण:

स्रोत कोड का रंग-कोडित चित्र

निर्देश सूचक शीर्ष-बाएं सबसे गैर-दीवार चरित्र पर शुरू होता है (दीवारों में रिक्त स्थान और किसी भी पत्र को छोड़कर v) शामिल हैं।

संतरा:

इस लूप को एक समय में एक ASCII कोड के रूप में इनपुट एक वर्ण मिलता है, इसे वर्तमान मूल्य में जोड़ता है और वर्तमान मूल्य को 256 से गुणा करता है।

  • ' कोई-op
  • ,स्टैक के शीर्ष पर अगले इनपुट चार के ascii कोड को पुश करें या यदि EOF। इस बिंदु पर यदि इनपुट प्राप्त हुआ था, तो कोड दाएं (नीचे की ओर) मुड़ जाएगा क्योंकि स्टैक के शीर्ष पोटेंशियल है। अन्यथा यह बाएं मुड़ जाएगा क्योंकि ढेर के ऊपर नकारात्मक है।
  • | स्टैक से शीर्ष दो आइटम पॉप करें और बिटवाइज़ OR के परिणाम को धक्का दें।
  • _ शून्य धक्का
  • 256प्रत्येक अंक में चबूतरे xऔर पुश दिखाई देते हैं x*10+digit। तो यह स्टैक के शीर्ष पर पुश शून्य पिछले पुश 256 के साथ संयुक्त है।
  • *पॉप y, पॉप x, पुश x*y। इस बिंदु पर स्टैक के शीर्ष पर सकारात्मक है कोड लूप के चारों ओर जारी रखने के लिए दाएं मुड़ जाएगा।

नीला:

  • )ढेर के ऊपर वृद्धि। जब इनपुट का अंत हो जाता है, तो कोड को इस बिंदु पर ले जाने के लिए बाईं ओर मुड़ जाएगा -1 के साथ स्टैक पर जो शून्य में वृद्धि होगी।
  • 256 स्टैक 0 के ऊपर होने से हम इस 256 को आगे बढ़ा सकते हैं।
  • /पॉप y, पॉप xपुश x/y(पूर्णांक विभाजन)। चूंकि हम इनपुट को प्रत्येक लूप में 256 से गुणा कर रहे थे, इसलिए हमें अंतिम गुणन को वापस लेना होगा।
  • : स्टैक के शीर्ष को डुप्लिकेट करें ताकि हमारे पास बाद के लिए वर्तमान मूल्य की एक प्रति हो।
  • ! स्टैक के शीर्ष पर पॉप करें और पूर्णांक मान को STDOUT में प्रिंट करें।
  • \ एक नई लाइन प्रिंट करें।
  • _2 स्टैक के शीर्ष पर एक दो पुश करें।
  • } स्टैक के शीर्ष को सहायक स्टैक के शीर्ष पर ले जाएं।

लाल:

यह लूप XOR द्वारा करंट वैल्यू के बिट्स को इनर (ग्रीन) लूप में गणना किए गए एक विशेष मूल्य से फ़्लिप करता है। यह तब वर्तमान मूल्य को आउटपुट करता है और यदि वर्तमान मूल्य शून्य है तो प्रोग्राम से बाहर निकल जाता है।

  • _ शून्य शून्य (नियंत्रण प्रवाह)।
  • ; स्टैक के शीर्ष (नियंत्रण प्रवाह) को त्यागें।
  • :वर्तमान मूल्य को डुप्लिकेट करें। XOR की गणना करने के लिए प्रतिलिपि का उपयोग किया जाएगा।
  • _ शून्य शून्य (नियंत्रण प्रवाह)।
  • (ग्रीन लूप)
  • $पॉप y, पॉप x, पुश x XOR y
  • :! वर्तमान मान को डुप्लिकेट करें और पूर्णांक प्रतिनिधित्व प्रिंट करें।
  • यदि वर्तमान मान 0 है, तो हम सीधे जारी रखते हैं @और समाप्त करते हैं।
  • \ एक नई लाइन प्रिंट करें।
  • _2} 2 पुश करें और ऑक्स स्टैक पर जाएं।
  • _1 पुश 1 (नियंत्रण प्रवाह)।

हरा:

यह लूप उस मूल्य की गणना करता है जिसके द्वारा हमें वर्तमान मूल्य को XOR करने की आवश्यकता होती है। यह 0 तक पहुंचने तक मुख्य स्टैक के वर्तमान मूल्य की एक प्रति को हटाते हुए सहायक स्टैक के शीर्ष को दोहराते हुए बार-बार किया जाता है।

  • _ शून्य शून्य (नियंत्रण प्रवाह)।
  • ; वर्तमान मूल्य को त्यागें जो केवल नियंत्रण प्रवाह को लागू करने के लिए उपयोग किया जाता है।
  • _2 वर्तमान मूल्य को आधा करने के लिए 2 पुश करें।
  • / फूट डालो
  • { ऑक्स स्टैक के शीर्ष को मुख्य स्टैक के शीर्ष पर ले जाएं।
  • _2* ढेर के ऊपर डबल
  • } मुख्य स्टैक के शीर्ष को वापस आक्स स्टैक पर ले जाएं।
  • _1 नियंत्रण प्रवाह के लिए एक धक्का।
  • लूप से बाहर निकलने के बाद:
  • ; XOR की गणना करने से बचे शून्य को छोड़ें।
  • { गणना किए गए XOR को मुख्य स्टैक पर ले जाएं।
  • ( XOR मान से एक घटाएँ।

2

PowerShell v2 +, 158 बाइट्स

for($a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)});$a){[convert]::ToInt64($a,2);$a=$a.TrimStart('0')-split0-replace1,0-join1}

हाँ, इसलिए, PowerShell में आधारों को परिवर्तित करना वास्तव में बेकार है । और हम इसे यहां दो बार करते हैं।

ठीक है, तो यह सिर्फ एक forलूप है $a- यानी, हम लूप को इतने लंबे समय तक $aमौजूद रखते हैं। हम अंततः एक खाली स्ट्रिंग (जो कि गलत है) तक पहुँचेंगे, इसलिए हम इसे समाप्त करेंगे।

लूप की स्थापना, $a=-join([char[]]$args[0]|%{([int][convert]::ToString(+$_,2)).ToString('0'*8)})इनपुट लेती है $args[0], इसे एक char-रे के रूप में डालती है, और प्रत्येक वर्ण के माध्यम से लूप करती है। हम [convert]::ToString(int,base)प्रत्येक को बाइनरी स्ट्रिंग में बदलने के लिए .NET का उपयोग करते हैं । हालाँकि, इसमें अग्रणी शून्य शामिल नहीं है, इसलिए हमें उस स्ट्रिंग को फिर से कास्ट करने की आवश्यकता है [int]और शून्य के साथ इसकी .ToString() विधि 8को मास्क के रूप में कॉल करें । फिर उन तारों को पैरेंस और -joinएड में एक साथ समझाया जाता है , फिर में बचाया जाता है $a

लूप के अंदर, हम [convert]::ToInt64(string,base)बाइनरी नंबर को एक दशमलव संख्या में परिवर्तित करते हैं। यह पाइप लाइन पर छोड़ दिया जाता है और बाद में जब लूप रीसेट करता है (और इसलिए स्पष्ट रूप से मुद्रित होता है) फ्लश हो जाता है। अगला भाग गणना करता है - हम .TrimStart()किसी भी अग्रणी शून्य को हटाते हैं, शून्य -split0पर विभाजित करने के लिए और s stringका एक सरणी प्राप्त करते हैं 1, -replaceजो शून्य के साथ होते हैं, और अंत -joinमें 1s के साथ मिलकर वापस आ जाते हैं । फिर, लूप फिर से शुरू होता है।

PS C:\Tools\Scripts\golfing> .\count-down-from-infinity.ps1 'PPCG'
1347437383
800046264
273695559
263175352
5260103
3128504
1065799
1031352
17223
15544
839
184
71
56
7
0

2

CJam , 17 16 18 बाइट्स

q256b0{_p2b:!2bj}j

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

q256b   e# read printable ascii to integer
0       e# value for terminal case
{       e# recursive function
  _p    e#   print current number
  2b    e#   create binary representation with no leading zeros
  :!    e#   flip bits
  2b    e#   convert binary back to integer
  j     e#   recursive call
}j      e# end

नोट: पुराने 16 बाइट संस्करण ने खाली तारों के साथ सही व्यवहार नहीं किया:

q256b{_p2b:!2b}h

इसके अलावा, सुझाव के लिए डेनिस के लिए धन्यवाद pजो N\स्टैक में newlines डालकर 1 बाइट बचाता है ।


_p2b:!2bएक बाइट बचाता है। इसके अलावा, आपको उपयोग करना चाहिए l; rयदि इनपुट में रिक्त स्थान हैं तो विफल हो जाएगा।
डेनिस

@ डेनिस धन्यवाद, हालांकि यह अब मुझे चिंता करता है अगर एक खाली स्ट्रिंग एक मुद्दा है।
लिनस

सही। qखाली तारों के साथ सही ढंग से काम करेगा।
डेनिस


1

रेटिना, 116 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है। पंक्ति 5 में गैर-मुद्रण योग्य बाइट्स हैं। यह है T`\x00-\xFF

-2`
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+
$*
+`(1+)\1
${1}0
01
1


{*(`1
01
+`10
011
^0+

)M`1
^0+

T`01`10

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

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

दुर्भाग्य से, एक अनुगामी शून्य और लाइनफीड है, लेकिन मैंने यह मानने का फैसला किया कि ठीक था क्योंकि आउटपुट अभी भी सही है।

व्याख्या

-2`         # Convert ASCII to decimal (ord)
±
s{`±(.)
$&$1
}T`-`_o`±.
[^±]+
$.&
±

\d+         # Decimal to binary
$*
+`(1+)\1
${1}0
01
1


{*(`1       # Loop; Loop print and undo; Convert binary to unary
01
+`10
011
^0+

)M`1        # Unary to decimal; End print and undo
^0+         # Remove leading zeros

T`01`10     # Flip bits; (implicit loop end)

1

रूबी - 70 बाइट्स

λ cat inf.rb
n,=$*[0].unpack 'B*';loop{p n.to_i(2);n.tr!('10','01').sub!(/^0*/,'')}
λ ruby inf.rb Hello
310939249775
788572378000
310939249775
238816564112
36061342831
32658133904
1701604463
445879184
90991727
43226000
23882863
9671568
7105647
1282960
814191
234384
27759
5008
3183
912
111
16
15
0
inf.rb:1:in `block in <main>': undefined method `sub!' for nil:NilClass (NoMethodError)
        from inf.rb:1:in `loop'
        from inf.rb:1:in `<main>'

कार्यक्रम पूरा होने के बाद एक अपवाद के साथ बाहर निकलता है, लेकिन मेरी समझ यह है कि जब तक त्रुटि आउटपुट STDERR के बजाय STDERR (जो यह करता है) के लिए ठीक हो जाता है।


1

सी, 147 135 133 125 125 122 121 117 115 103 बाइट्स

सहेजे गए 5 बाइट्स @Cyoce की बदौलत!

सहेजे गए 2 बाइट @Cyoce और @cleblanc की बदौलत!

सहेजे गए 12 बाइट्स @ceilingcat की बदौलत

i,n;main(p,v)char**v;{while(*v[1])i=i*256+*v[1]++;for(;printf("%d\n",n=i),i;i^=p-1)for(p=2;n/=2;)p*=2;}

Ungolfed:

int i;
int main (c,v) {
    char**v;
    while (*v[1]) /* put first command line argument into i as binary */
        i = i*256 + *v[1]++;
    while (i != 0) { 
        printf("%d\n",i);
        int p = 2,n = i;
        while (n /= 2) /* calculate smallest power of 2 > i */
            p *= 2;
        i ^= p - 1; /* flip bits */
    }
}

मुझे लगता है कि आप int
साइओस

तुम भी एक बाइट पिछले परिवर्तित करके बचा सकता है whileएक में पाश forपाश
Cyoce

और अगर आप बदल सकते हैं while(1)करने के लिएfor(;;)
Cyoce

@ मुझे लगता है कि मैंने intहर जगह घोषणाओं को हटाने की कोशिश की और gcc -std=89त्रुटियों को प्राप्त किया। लेकिन for(;;)टिप के लिए धन्यवाद । मैं intघोषणाओं को दूर करने की कोशिश करता रहूँगा :)))
नूडल

क्षमा करें, मैंने इसका परीक्षण नहीं किया। मुझे लगता है कि यह काम करेगा यदि आप उन्हें शीर्ष पर ले जाएँ ( i;main(c,v)char**v;{...})। मोबाइल पर अभी तो मुझे यकीन नहीं है
Cyoce

0

सी, 129 120 117 110 107 105 बाइट्स

long long i,m,n;f(char*v){for(;*v;i<<=8,i+=*v++);for(;printf("%llu,",i),n=i;i^=m-1)for(m=2;n>>=1;m<<=1);}

के साथ परीक्षण किया गया

main (int c, char**v) {
    f(v[1]);
}

उत्पादन

5291279215216915577,3932092821637860230,679593196789527673,473328307817319302,103132444486104185,40982743589751686,31074850448176249,4953946570787718,4053252683953273,450346943417222,112603010004089,28134478351238,7049893737593,1746199284614,452823970937,96931842950,40507110521,28212366214,6147372153,2442562438,1852404857,295078790,241792121,26643334,6911097,1477510,619641,428934,95353,35718,29817,2950,1145,902,121,6,1,0,

मुझे लगता है कि आप ले जा सकते हैं i=0की घोषणा करने के लिए iऔर के प्रारंभ अनुभाग छोड़ forपाश खाली
Cyoce

@Cyoce फ़ंक्शन को हर बार काम करने की आवश्यकता होती है जिसे यह कहा जाता है और चूंकि iअंतर्निहित वैश्विक int है इसे हर बार च को प्रारंभ करने की आवश्यकता है (...) कहा जाता है।
13

@Cyoce तुम सब के बाद सही थे। फ़ंक्शन तब तक बाहर नहीं निकलता है जब तक iकि शून्य फिर से न हो इसलिए यह अभी भी पुन: प्रयोज्य है।
क्लेब्लांक


0

सी #, 360 359 बाइट्स

using w=System.Console;using q=System.Convert;s={System.Func<int,int,string>S=q.ToString;string t="",f="";for(int i=0;i<s.Length;i++)t+=i>0?S(s[i],2).PadLeft(8,'0'):S(s[i],2);w.WriteLine(q.ToInt64(t,2).ToString());while(t!="0"){f="";foreach(var n in t)f+=n=='0'?'1':'0';t=f.TrimStart(new char[]{'0'});t+=t==""?"0":"";w.WriteLine(q.ToInt64(t,2).ToString());}};

पूरा कार्यक्रम:

using w = System.Console;
using q = System.Convert;

class a
{
    static void Main()
    {
        System.Action<string> b = s =>
        {
            System.Func<int,int,string> S = q.ToString;
            string t = "", f = ""; // Var does not work here
            for(int i = 0; i < s.Length; i++)
                t += i > 0 ? S(s[i], 2).PadLeft(8, '0') : S(s[i], 2);
            w.WriteLine(q.ToInt64(t, 2).ToString());
            while(t != "0")
            {
                f = "";
                foreach (var n in t) f += n== '0' ? '1' : '0';
                t = f.TrimStart(new char[] { '0' });
                t += t == "" ? "0" : "";
                w.WriteLine(q.ToInt64(t, 2).ToString());
            }
        };

        b("Inf");
        b("Infinity");
        w.Read(); // prevent close in VS
    }
}

मैं C # नहीं करता, लेकिन इसके बजाय हो var t="";var f="";सकता है var t="",f=""? 5 बाइट बचाता है।
corsiKa

@ corsiKa हाँ मैंने कोशिश की थी कि लेकिन यह मुझे एक त्रुटि दे गया, मुझे लगता है कि इसका कारण यह है कि यह स्ट्रिंग नहीं है।
Yodle

दरअसल, स्ट्रिंग एक बाइट को बचाती है, इसलिए मुझे लगता है कि मैं इसे इस तरह से करूंगा।
Yodle

क्या आप उन गंदे उद्धरणों को बचाने के लिए शून्य के लिए az चर बना सकते हैं?
corsiKa 20

बस कोशिश की, यह वास्तव में bytecount उठाता है क्योंकि मैं दोनों स्ट्रिंग "0" और चार '0' को प्रतिस्थापित नहीं कर सकता :(
Yodle
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.