परिचय

एक ग्रे कोड द्विआधारी प्रतिनिधित्व का एक विकल्प है जिसमें बिट की एक परिवर्तनीय राशि के बजाय केवल एक बिट टॉगल करके एक संख्या बढ़ाई जाती है। उनके दशमलव और द्विआधारी समकक्षों के साथ कुछ ग्रे कोड यहां दिए गए हैं:

 decimal | binary | gray
-------------------------
       0 |      0 |    0
-------------------------
       1 |      1 |    1
-------------------------
       2 |     10 |   11
-------------------------
       3 |     11 |   10
-------------------------
       4 |    100 |  110
-------------------------
       5 |    101 |  111
-------------------------
       6 |    110 |  101
-------------------------
       7 |    111 |  100
-------------------------
       8 |   1000 | 1100
-------------------------
       9 |   1001 | 1101
-------------------------
      10 |   1010 | 1111
-------------------------
      11 |   1011 | 1110
-------------------------
      12 |   1100 | 1010
-------------------------
      13 |   1101 | 1011
-------------------------
      14 |   1110 | 1001
-------------------------
      15 |   1111 | 1000

एक ग्रे कोड का चक्रीय बिट पैटर्न

कभी-कभी "प्रतिबिंबित बाइनरी" कहा जाता है, एक समय में केवल एक बिट को बदलने की संपत्ति आसानी से कम से कम महत्वपूर्ण बिट से शुरू होने वाले प्रत्येक कॉलम के लिए चक्रीय बिट पैटर्न के साथ प्राप्त की जाती है:

bit 0: 0110011001100110011001100110011001100110011001100110011001100110
bit 1: 0011110000111100001111000011110000111100001111000011110000111100
bit 2: 0000111111110000000011111111000000001111111100000000111111110000
bit 3: 0000000011111111111111110000000000000000111111111111111100000000
bit 4: 0000000000000000111111111111111111111111111111110000000000000000
bit 5: 0000000000000000000000000000000011111111111111111111111111111111

...और इसी तरह।

लक्ष्य

एक ग्रे कोड के गैर-गद्देदार इनपुट स्ट्रिंग को देखते हुए, अनुक्रम में एक ही चरित्र को वैकल्पिक करके या 1(जब 2 की अगली शक्ति में वृद्धि) को बढ़ाकर ग्रे कोड बढ़ाएँ , तो परिणाम को गैर-पैडल ग्रे कोड के रूप में आउटपुट करें।

चेतावनियां

0इनपुट के रूप में खाली स्ट्रिंग लेने या लेने की चिंता न करें ।
सबसे कम इनपुट होगा 1, और पर्यावरण द्वारा लगाए गए स्मृति सीमाओं के अलावा स्ट्रिंग की लंबाई के लिए कोई ऊपरी-बाध्य नहीं है।
गैर-गद्देदार स्ट्रिंग द्वारा, मेरा मतलब है कि कोई अग्रणी या अनुगामी व्हाट्सएप नहीं होगा (एक वैकल्पिक अनुगामी न्यूलाइन के अलावा), और 0इनपुट या आउटपुट में कोई अग्रणी नहीं है ।

I / O प्रारूप

इनपुट और आउटपुट के लिए निम्न प्रारूप स्वीकार किए जाते हैं, लेकिन अन्य स्वरूपों में तार को प्रोत्साहित किया जाता है:

सबसे महत्वपूर्ण "बिट" पहले
गैर गद्देदार चरित्र सरणी या ASCII '1's और '0's का तार
गैर-गद्देदार पूर्णांक सरणी के 1s और 0s
गैर-गद्देदार बूलियन सरणी

क्या अनुमति नहीं है:

कम से कम महत्वपूर्ण "बिट" पहले
दशमलव, बाइनरी या अनियारी पूर्णांक
निश्चित-लंबाई डेटा-संरचना
चरित्र या गैर-मुद्रण योग्य ASCII सूचकांकों की स्ट्रिंग 1और0

टेस्ट

input -> output
1 -> 11
11 -> 10
111 -> 101
1011 -> 1001
1111 -> 1110
10111 -> 10110
101100 -> 100100
100000 -> 1100000

_{अनुरोध द्वारा अधिक परीक्षण जोड़े जा सकते हैं।}

मानदंड

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कार्यक्रम है! पहले के सबमिशन के पक्ष में सभी संबंध टूट जाएंगे; मानक खामियों लागू होते हैं। सबसे अच्छा प्रस्तुत उत्तर 9 अक्टूबर, 2016 को स्वीकार किया जाएगा और जब भी बेहतर उत्तर दिए जाएंगे, अपडेट किया जाएगा।

— पैट्रिक रॉबर्ट्स
स्रोत

1

सम्बंधित। सम्बंधित।

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

क्या हम एक संख्या के रूप में इनपुट ले सकते हैं?

— xnor

1

स्पष्ट रूप से कम, संबंधित भी ।

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

1

क्या मैं इनपुट और आउटपुट दोनों को उलट सकता हूं, उदाहरण के 0011लिए

— टन हास्पेल

1

@ टोनहॉरी क्षमा करें, मैंने आपका प्रश्न I / O से उलट नहीं देखा। जैसा कि मैंने बताया कि 1000000000 मेरा उत्तर नहीं है।

— पैट्रिक रॉबर्ट्स

13

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

2 बाइट बचाने के लिए डेनिस के लिए धन्यवाद।

^\Ḅ‘^H$B

इनपुट और आउटपुट 0s और 1s की सूची हैं।

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

व्याख्या

ग्रे कोड का व्युत्क्रम A006068 द्वारा दिया गया है । इसके प्रयोग से इनपुट देखने के लिए हमें बड़ी संख्या में ग्रे कोड बनाने की आवश्यकता नहीं है। OEIS पर दिए गए इस क्रम का एक वर्गीकरण यह है:

a(n) = n XOR [n/2] XOR [n/4] XOR [n/8] ...

जहां []फर्श कोष्ठक हैं। 44किसके द्विआधारी प्रतिनिधित्व का उदाहरण पर विचार करें 101100। 2 से विभाजित और फर्श केवल एक सही बदलाव है, कम से कम महत्वपूर्ण बिट काट। तो हम निम्नलिखित संख्या को XOR करने का प्रयास कर रहे हैं

1 0 1 1 0 0
  1 0 1 1 0
    1 0 1 1
      1 0 1
        1 0
          1

ध्यान दें कि nवें कॉलम में पहले nबिट्स हैं। इसलिए, इस सूत्र को सूची में XOR की संचयी कमी के रूप में द्विआधारी इनपुट पर तुच्छ रूप से गणना की जा सकती है (जो मूल रूप से सूची के प्रत्येक उपसर्ग पर XOR लागू करता है और हमें परिणामों की एक सूची देता है)।

यह हमें ग्रे कोड को पलटने का एक सरल तरीका देता है। बाद में, हम सिर्फ परिणाम को बढ़ाते हैं और इसे ग्रे कोड में बदल देते हैं। बाद के चरण के लिए हम निम्नलिखित परिभाषा का उपयोग करते हैं:

a(n) = n XOR floor(n/2)

शुक्र है, जेली XOR की कोशिश करते समय इनपुट को स्वचालित रूप से फ़्लोर करने लगती है। वैसे भी, यहाँ कोड है:

^\          Cumulative reduce of XOR over the input.
  Ḅ         Convert binary list to integer.
   ‘        Increment.
    ^H$     XOR with half of itself.
       B    Convert integer to binary list.

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

आप की जरूरत नहीं है Ḟ$; बिटवाइज ऑपरेटरों को इंट करने के लिए ।

— डेनिस

@ डेनिस धन्यवाद, मुझे पता चला कि लिखते समय। :)

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

@MartinEnder क्या पूर्णांक यह आंतरिक रूप से एक बड़े पूर्णांक में परिवर्तित होता है?

— पैट्रिक रॉबर्ट्स

@PatrickRoberts हाँ, यदि आवश्यक हो - यह हुड के नीचे पायथन है।

— जोनाथन एलन

अच्छा विश्लेषण और स्पष्टीकरण।

— वेन कॉनराड

8

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

s=>s.replace(s.split`1`.length%2?/.$/:/.?(?=10*$)/,c=>1-c)

उचित बिट को सीधे टॉगल करता है। स्पष्टीकरण: जैसा कि मार्टिनएंडर के जवाब में दिखाया गया है, प्रत्येक डिकोड्ड ग्रे कोड में प्रत्येक बिट का संचयी XOR या समता है, और उसके बाईं ओर बिट्स। इसके बाद हमें उस संख्या को बढ़ाने की आवश्यकता होती है, जो एक कैरी रिपल का कारण बनती है, जो सभी सबसे सही 1 बिट्स को 0 पर टॉगल करता है और फिर अगले 0 बिट को 1. कोड में रि-एन्कोडिंग परिणाम के साथ सिर्फ एक 0 बिट स्थिति में टॉगल किया जाता है। यदि सभी 1 बिट्स की समता समान है, तो सबसे सही बिट 0 है और इसलिए हम अंतिम बिट को टॉगल करते हैं। यदि सभी 1 बिट्स की समता विषम है, तो सबसे सही बिट्स 1 हैं, और हमें अंतिम 1 बिट खोजने की आवश्यकता है। यह अब किए गए बिट्स में से अंतिम है, इसलिए हमें जिस बिट को टॉगल करने की आवश्यकता है वह दाईं ओर से अगला बिट है।

— नील
स्रोत

बहुत अच्छी विधि। क्या वास्तव ?में पहली /.?(?=10*$)/आवश्यकता है? ओह कोई बात नहीं। हाँ यही है। :-)

— अरनुलद

8

पर्ल, 27 25 बाइट्स

के लिए +1 शामिल है -p

STDIN पर इनपुट स्ट्रिंग दें, जैसे

gray.pl <<< 1010

gray.pl:

#!/usr/bin/perl -p
s%(10*\K1(\K0)*)*%1-$&%e

पर्ल का कोई सस्ता अनंत-सटीक पूर्णांक नहीं है। तो सीधे सही बिट को टॉगल करें जो कि पिछले विषम संख्या 1 के ठीक पहले वाला है।

— टन हास्पेल
स्रोत

1

वाह, \Gवास्तव में चीजें आपके लिए आसान बनाती हैं!

— नील

1

दूसरी ओर, \Kआपके लिए चीजों को और भी आसान बना देता है।

— नील

Haaaaa ... अब मैं \Gकार्यान्वयन को भी देखना चाहता हूं ।

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

2

@carusocomputing आप संपादित लिंक पर क्लिक करके सबमिशन के पुराने संस्करणों को देख सकते हैं

— Ton Hospel

6

हास्केल, 118 115 108 बाइट्स

g 0=[""]
g n|a<-g$n-1=map('0':)a++map('1':)(reverse a)
d=dropWhile
f s=d(=='0')$(d(/='0':s)$g$1+length s)!!1

Ideone पर इसे आज़माएं।
भोली दृष्टिकोण: gलंबाई के साथ सभी ग्रे कोड का सेट n(0-गद्दी के साथ) उत्पन्न करता है , fकॉल gकरता है length(input)+1, सभी तत्वों को हटाता है जब तक 0<inputstring>कि पाया नहीं जाता है और अगले तत्व को वापस करता है (संभवतः एक अग्रणी अग्रणी 0)।

— Laikoni
स्रोत

1

अच्छा पहला जवाब! मुझे उम्मीद है कि हम जल्द ही कुछ और कुशल मिल सकते हैं।

— पैट्रिक रॉबर्ट्स

5

MATL , 18 बाइट्स

ZBtE:t2/kZ~tb=fQ)B

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

व्याख्या

चलो एक ( एन ) ग्रे कोड (करने के लिए इसी पूर्णांकों का अनुक्रम निरूपित OEIS A003188 )। कार्यक्रम में वर्णक a ( n ) = n XOR फ़्लोर ( n / 2) का उपयोग किया जाता है, जहाँ XOR बिट-वार होता है।

अनिवार्य रूप से, कोड पूर्णांक एक के लिए इनपुट धर्मान्तरित एक ₀ , पता चलता है कि अनुक्रम में पूर्णांक, और फिर अगले अवधि का चयन करता है। यह क्रम के मामले की एक पर्याप्त बड़ी संख्या में पैदा करने की आवश्यकता है एक ( एन )। ऐसा लगता है कि 2 · एक ₀ पर्याप्त रूप से बड़े है। यह इस तथ्य से उपजा है कि ग्रे कोड a ( n ) में n की तुलना में कभी भी अधिक बाइनरी अंक नहीं हैं ।

'101'एक उदाहरण के रूप में इनपुट लेते हैं ।

ZB      % Input string implicitly. Convert from binary string to integer
        %   STACK: 5
t       % Duplicate
        %   STACK: 5, 5
E       % Multiply by 2. This is the number of terms we'll generate from the sequence
        %   STACK: 5, 10
:       % Range
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10]
t       % Duplicate
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10], [1 2 3 4 5 6 7 8 9 10]
2/k     % Divide by 2 and round down, element-wise
        %   STACK: 5, [1 2 3 4 5 6 7 8 9 10], [0 1 1 2 2 3 3 4 4 5]
Z~      % Bit-wise XOR, element-wise
        %   STACK: 5, [1 3 2 6 7 5 4 12 13 15]
t       % Duplicate
        %   STACK: 5, [1 3 2 6 7 5 4 12 13 15], [1 3 2 6 7 5 4 12 13 15]
b       % Bubble up
        %   STACK: [1 3 2 6 7 5 4 12 13 15], [1 3 2 6 7 5 4 12 13 15], 5
=       % Equality test, element-wise
        %   STACK: [1 3 2 6 7 5 4 12 13 15], [0 0 0 0 0 1 0 0 0 0]
f       % Find: yield (1-based) index of nonzero values (here there's only one)
        %   STACK: [1 3 2 6 7 5 4 12 13 15], 6
Q       % Increase by 1
        %   STACK: [1 3 2 6 7 5 4 12 13 15], 7
)       % Apply as index
        %   STACK: 4
B       % Convert to binary array
        %   STACK: [1 0 0]
        % Implicitly display

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

मुझे लगता है कि आउटपुट स्पेस-सीमांकित वर्ण है ... क्या यह किसी प्रकार की सरणी को प्रिंट कर रहा है?

— पैट्रिक रॉबर्ट्स 23

@PatrickRoberts हां, बिल्कुल। मैंने मान लिया कि यह स्वीकार्य है, है?

— लुइस मेंडो

मैं इसे स्वीकार करूंगा। मैंने पहले ही अपनी आवश्यकताओं को I / O प्रारूप पर ढीला कर दिया है, इसलिए इसे फिर से अधिक सख्त बनाने का कोई मतलब नहीं है। अच्छी नौकरी।

— पैट्रिक रॉबर्ट्स

5

CJam (19 बाइट्स)

{_2b__(^@1b1&*)^2b}

ऑनलाइन डेमो । यह बिट एरे से बिट एरे तक एक अनाम ब्लॉक (फ़ंक्शन) है, जिसे डेमो लूप में निष्पादित करता है।

यह सरल सिद्धांत पर काम करता है कि यदि सेट बिट्स की संख्या सम है तो हमें कम से कम महत्वपूर्ण बिट को टॉगल करना चाहिए, और अन्यथा हमें बिट को कम से कम महत्वपूर्ण बिट के बाईं ओर टॉगल करना चाहिए। वास्तव में बिट की सूची का उपयोग करने की तुलना में पूर्णांक पर बिट हैक्स का उपयोग करके उस बिट को पहचानना बहुत आसान हो जाता है।

विच्छेदन

{         e# Declare a block:
  _2b     e#   Convert the bit array to a binary number
  __(^    e#   x ^ (x-1) gives 1s from the least significant set bit down
  @1b1&   e#   Get the parity of the number of set bits from the original array
  *       e#   Multiply: if we have an even number of set bits, we get 0;
          e#   otherwise we have 2**(lssb + 1) - 1
  )^      e#   Increment and xor by 1 or 2**(lssb + 1)
  2b      e#   Base convert back to a bit array
}

पूरी तरह से बिट सरणी के साथ काम करना, मुझे लगता है कि इसे उल्टा करना आवश्यक है: बाईं ओर के साथ काम 1करना सही-सबसे की तुलना में बहुत आसान है। मैंने अब तक जो सबसे अच्छा पाया है, वह है (24 बाइट्स):

{W%_1b)1&1$+1#0a*1+.^W%}

वैकल्पिक दृष्टिकोण (19 बाइट्स)

{[{1$^}*]2b)_2/^2b}

यह ग्रे कोड से इंडेक्स, इंक्रीमेंट में परिवर्तित होता है और ग्रे कोड में परिवर्तित होता है।

— पीटर टेलर
स्रोत

5

जावास्क्रिप्ट (ईएस 6), 53 बाइट्स (गैर-प्रतिस्पर्धात्मक)

एक पुनरावर्ती कार्य जो इनपुट मिलने तक सभी ग्रे कोड बनाता है, फिर अगले पुनरावृत्ति पर रुक जाता है।

उच्चतम संभव इनपुट ब्राउज़र पुनरावर्तन सीमा (फ़ायरफ़ॉक्स में लगभग 13 बिट्स और क्रोम में 15 बिट्स) पर निर्भर करता है।

f=(s,n=1)=>(b=(n^n/2).toString(2),s)?f(b!=s&&s,n+1):b

console.log(f("1"));      // -> 11
console.log(f("11"));     // -> 10
console.log(f("111"));    // -> 101
console.log(f("1011"));   // -> 1001
console.log(f("1111"));   // -> 1110
console.log(f("10111"));  // -> 10110
console.log(f("101100")); // -> 100100
console.log(f("100000")); // -> 1100000

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

— Arnauld
स्रोत

मुझे डर है कि यह सबमिशन योग्य नहीं है, क्योंकि यह विधि अनबाउंड स्ट्रिंग लेंथ के लिए काम नहीं करती है। यदि आप इस उत्तर को यहाँ रखना चाहते हैं तो कृपया इसे गैर-प्रतिस्पर्धी में बदल दें।

— पैट्रिक रॉबर्ट्स

@ पैट्रिक रॉबर्ट्स - ज़रूर। यह समझ आता है।

— Arnauld

@PatrickRoberts सच में? "पर्यावरण द्वारा लगाए गए स्मृति सीमाओं" के तहत एक पुनरावृत्ति सीमा कैसे नहीं होती है?

— Sanchises

@sanchises मैं स्मृति को ढेर करने की बात कर रहा था, लेकिन इस बिंदु पर अधिक, यह कार्यक्रम परीक्षण किए जा रहे हर संभव ग्रे कोड के लिए पुनरावृत्ति करता है, जो बेहद अक्षम है। तकनीकी रूप से इसे "Node.js 6.5" के रूप में प्रस्तुत किया जा सकता है और --harmonyपेनल्टी बाइट्स के लिए जोड़ा गया है ताकि टेल-कॉल पुनरावृत्ति अनुकूलन तक पहुंच हो, जो यहां संभव प्रतीत होता है।

— पैट्रिक रॉबर्ट्स

@sanchises मेरे जवाब को देखते हुए, यह एक खराब तर्क था। मुख्य मुद्दा यह है कि सीमा पर्यावरण द्वारा थोपा नहीं गया है, यह एल्गोरिथ्म द्वारा लगाया गया है। ऐसे अन्य उत्तर हैं जो प्रत्येक वृद्धिशील मूल्य के बजाय प्रत्येक बिट के लिए पुनरावृत्ति करते हैं, और मुझे लगता है कि वे अधिक स्वीकार्य हैं क्योंकि यह मूल्यों की एक विस्तृत श्रृंखला के लिए काम करता है।

— पैट्रिक रॉबर्ट्स

2

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

^(10*10*)*
$1:
1:
0
.?:
1

मुझे यकीन है कि ऐसा करने का एक बेहतर तरीका होना चाहिए ...

— नील
स्रोत

क्या आपको वास्तव में इसकी आवश्यकता है ^?

— टन हास्पेल

@ टोनहॉज रेगेक्स ने इसके बिना हर जगह मैच करने की कोशिश की। (बदलें मोड एक वैश्विक प्रतिस्थापन के लिए चूक।)

— नील

2

05AB1E , 12 बाइट्स

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

CÐ<^¹SOÉ*>^b

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

व्याख्या

इनपुट के लिए उदाहरण 1011 ।

C              # convert to int (bigint if necessary)
               # STACK: 11
 Ð             # triplicate
               # STACK: 11, 11, 11
  <            # decrease by 1
               # STACK: 11, 11, 10
   ^           # XOR
               # STACK: 11, 1
    ¹          # push first input
               # STACK: 11, 1, 1011
     S         # split to list
               # STACK: 11, 1, [1,0,1,1]
      O        # sum
               # STACK: 11, 1, 3
       É       # mod 2
               # STACK: 11, 1, 1
        *      # multiply
               # STACK: 11, 1
         >     # increase by 1
               # STACK: 11, 2
          ^    # XOR
               # STACK: 9
           b   # convert to binary
               # STACK: 1001
               # implicitly print top of stack

— Emigna
स्रोत

2

पायथन 2.7, 68 वर्ण

def f(s):i=long(s,2);print bin(i^(1,(i&-i)<<1)[s.count('1')&1])[2:]

पायथन 3, 68 वर्ण

def f(s):i=int(s,2);print(bin(i^(1,(i&-i)<<1)[s.count('1')&1])[2:])

यह फ़ंक्शन किसी दिए गए बाइनरी स्ट्रिंग को एक पूर्णांक में परिवर्तित करता है, तो अंतिम बिट को xor करता है यदि मूल स्ट्रिंग में सेट बिट्स की संख्या सम है, या इसके बिट्स को दाईं ओर सेट बिट के बाईं ओर स्वैप करता है यदि मूल बिट्स में सेट बिट्स की संख्या स्ट्रिंग विषम है। फिर यह परिणाम को एक बाइनरी स्ट्रिंग में परिवर्तित करता है और 0bबूलियन उपसर्ग को हटाता है ।

— Morwenn
स्रोत

1

आप 1 बाइट बचा सकते हैं def f(s):और इसके बाद के स्थान को हटाकर (पायथन 2 को मानकर) printइसके स्थान पर उपयोग कर सकते हैं return।

— ElPedro

@ElPedro धन्यवाद, मैंने एक शर्त भी लागू की और कुछ अतिरिक्त पात्रों को बचाने के लिए एक

— एक्सोर

बस वही देखा। अच्छा उत्तर :-)

— एलपेड्रो

उम .. अजगर प्रलेखन की जाँच, ऐसा लगता है कि int()एक 32 बिट पूर्णांक उत्पन्न करता है, हालांकि मेरी आवश्यकता आपको अपनी लंबाई स्ट्रिंग में वृद्धि के लिए है। मुझे यकीन नहीं है कि यह एक वैध प्रस्तुत करने के लिए योग्य है

— पैट्रिक रॉबर्ट्स

1

@PatrickRoberts मैं बाद में जाँच करूँगा। longइसके बजाय intसमस्या का समाधान हो सकता है।

— मॉर्वन

2

सी ++, 205 बाइट्स

#include <string>
std::string g(std::string s){int i,z;if(s=="1")return"11";for(i=z=0;i<s.length();i++)if(s[i]=='1')z++;i--;if(z%2){char c=s[i];s.erase(i);s=g(s);s+=c;}else{s[i]=s[i]==49?48:49;}return s;}

विवरण: यहां तक कि संख्याओं की संख्या भी है। परिवर्तनीय zलोगों को गिनता है; यदि zहै ( z mod 2 = z%2 = 0- और शाखा), तो अंतिम बिट में परिवर्तन करें; यदि zविषम है, तो अंतिम फ़ंक्शन के बिना इस फ़ंक्शन को फिर से कॉल करें और नए मान की गणना करें, फिर बाद के चरित्र को जोड़ें।

परीक्षण के मामलों के लिए इसे आजमाने के लिए यहां क्लिक करें।

— AlexRacer
स्रोत

आपकी प्रस्तुति के लिए धन्यवाद। यदि आप अपने दृष्टिकोण का एक संक्षिप्त विवरण और एक डेमो के रूप में ऑनलाइन संकलन के लिए लिंक प्रदान कर सकते हैं, तो मैं वास्तव में इसकी सराहना करूंगा।

— पैट्रिक रॉबर्ट्स

1

@PatrickRoberts आपके अनुरोध के अनुसार लिंक और विवरण जोड़ा गया।

— अलेक्जेंडर

2

बैच, 199 197 बाइट्स

@echo off
set/ps=
set r=
set t=%s:0=%
if 1%t:11=%==1 goto g
:l
set b=%s:~-1%
set s=%s:~,-1%
set r=%b%%r%
if %b%==0 goto l
if 0%s%==0 set s=0
:g
set/ab=1-%s:~-1%
echo %s:~,-1%%b%%r%

STDIN से इनपुट को वेरिएबल में पढ़ता है s। 0s को निकालता है और 1s पर समता की जाँच करता है और यदि कोई विषम संख्या है तो यह एक लूप में सबसे दाहिने 0 s को स्ट्रिप करता है, जब यह 1 स्ट्रिप्स को रोकता है। sइसलिए इसमें समता उपसर्ग और rस्ट्रिंग के बाकी हिस्से होते हैं। sशून्य पर सेट है यदि यह खाली था ताकि इसका अंतिम अंक टॉगल किया जा सके, और फिर सब कुछ समाप्‍त हो गया।

— नील
स्रोत

1

दरअसल, 20 19 13 बाइट्स

"इनपुट पर XOR के संचयी कम" के अपने संस्करण के साथ मार्टिन एंडर के जेली उत्तर के आधार पर । गोल्फ सुझाव का स्वागत करते हैं। इसे ऑनलाइन आज़माएं!

σ1♀&2@¿u;½≈^├

Ungolfing

      Implicit input a as a list, such as [1,0,1,1,0,0].
σ     Get the cumulative sums of a.
1♀&   Map x&1 (equivalent to x%2) over every member of the cumulative sum.
2@¿   Convert from binary to decimal.
u     Increment x.
;½≈   Duplicate and integer divide by 2.
^     XOR x and x//2.
├     Convert to binary to obtain our incremented Gray code.
      Implicit return as a string, such as "100100".

— Sherlock9
स्रोत

1

जे, 38 बाइट्स

[:#:@(22 b.<.@-:)@>:@#.[:22 b./[:#:#.\

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

यह अनिवार्य रूप से जे में मार्टिन का एल्गोरिदम है।

ध्यान दें कि 22 b.XOR है।

                                    [: #: #.\   Creates the prefixes of the input
                                                converts to a number, then converts
                                                back to binary.  Needed to get the
                                                padding on the left.

                          [: 22 b./             Reduce the rows of the resulting 
                                                matrix with XOR, giving us the 
                                                normal binary
                      @#.                       Convert to int and...
                   @>:                          Increment and...
      (22 b. <.@-:)                             XOR that with its own floored half
[: #:@                                          And turn the result back to binary

— जोनाह
स्रोत

अच्छा काम है, यार!

— पैट्रिक रॉबर्ट्स

ग्रे कोड्स बढ़ाना

परिचय

एक ग्रे कोड का चक्रीय बिट पैटर्न

लक्ष्य

चेतावनियां

I / O प्रारूप

टेस्ट

मानदंड

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

व्याख्या

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

पर्ल, 27 25 बाइट्स

हास्केल, 118 115 108 बाइट्स

MATL , 18 बाइट्स

व्याख्या

CJam (19 बाइट्स)

विच्छेदन

वैकल्पिक दृष्टिकोण (19 बाइट्स)

जावास्क्रिप्ट (ईएस 6), 53 बाइट्स (गैर-प्रतिस्पर्धात्मक)

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

05AB1E , 12 बाइट्स

पायथन 2.7, 68 वर्ण

पायथन 3, 68 वर्ण

सी ++, 205 बाइट्स

बैच, 199 197 बाइट्स

दरअसल, 20 19 13 बाइट्स

जे, 38 बाइट्स