मुझे बिट चौड़ाई की ग्रे कोड सूची दें n

Question

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

संदर्भ

उदाहरण इनपुट:

3

उदाहरण आउटपुट:

000
001
011
010
110
111
101
100

टिप्पणियाँ:

• इस सवाल पर एक ठप्पा लगता है लेकिन ऐसा नहीं है, क्योंकि यह सवाल कोड-गोल्फ नहीं है, और यह अलग आउटपुट की मांग करता है। हालाँकि, यह उत्तर देने में मदद करेगा।
• आप एक चर मान सकते हैं nजिसमें इनपुट शामिल है।

Comments

यह देखते हुए कि अन्य प्रश्न एक उद्देश्य जीत मानदंड के बिना सबसे तेज़ कोड-चुनौती है (सबसे तेजी से मापा कैसे?), मैं दूसरे को बंद करने और इस को फिर से खोलने का प्रस्ताव करता हूं।

— डेनिस

मैं @ डेनिस के साथ सहमत हूं और इसलिए मैंने मूल प्रश्न पर निम्नलिखित अलोकप्रिय उत्तर को उलझा दिया है। "यदि आप जिस उत्तर की तलाश कर रहे हैं, वह कड़ाई से एक तेज़ परिणाम है, तो यदि आप एक सरणी (ग्रे कोड्स) की घोषणा करते हैं ..." हालांकि मूल प्रश्न क्षेत्र में 7-वर्ण और 4-वर्ण का उत्तर है, इसलिए मैं नहीं करता टी सुधार के लिए बहुत कुछ देखें। इसलिए मैं वर्तमान में दोबारा वोट नहीं डाल रहा हूं।

— लेवल रिवर सेंट

यह भयानक रूप से सभी नंबरों के साथ केवल एक बिट प्रति कदम फ्लिप के समान है ...

— डेनिस

जल्द से जल्द ग्रे कोड प्रश्न महान नहीं है, लेकिन इसमें पहले से ही उत्तर हैं जो मूल रूप से उत्तर के समान हैं जो यह प्रश्न चाहता है, और जिनके बेहतर होने की संभावना नहीं है। मुझे लगता है कि इसे बंद करने और दूसरे को कोड गोल्फ में बदलने के लिए इसे और अधिक समझ में आया होगा।

— पीटर टेलर

Answer 1

जावास्क्रिप्ट (77)

for(i=0;i<1<<n;)alert((Array(n*n).join(0)+(i>>1^i++).toString(2)).substr(-n))

अधिक ब्राउज़र-अनुकूल संस्करण (कंसोल.लॉग और शीघ्र ()):

n=prompt();for(i=0;i<1<<n;)console.log((Array(n*n).join(0)+(i>>1^i++).toString(2)).substr(-n))

Comments

हो सकता है कि यह सरणी ... ज्वाइन ओवरकिल होfor(i=0;i<(l=1<<n);i++)console.log((i^(i>>1)|l).toString(2).slice(1));

— edc65

Answer 2

पायथन 2 (47)

for i in range(2**n):print bin(2**n+i/2^i)[3:]

अभिव्यक्ति i/2^iके लिए i'वें ग्रे कोड नंबर से है इस सवाल का जवाब । लंबाई में अग्रणी पैड को nजोड़ने के लिए, मैं 2**nएक बाइनरी स्ट्रिंग में परिवर्तित होने से पहले जोड़ता हूं , जिससे लंबाई की एक स्ट्रिंग बनती है n+1। फिर, मैं अग्रणी 1और संख्या प्रकार उपसर्ग 0bको काट देता हूं [3:]।

Answer 3

के (ngn / k) , 10 बाइट्स

+~0=':!n#2

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

Comments

ओडोमीटर ओवरलोड !ने मुझे आश्चर्यचकित कर दिया। बहुत ही शांत !

— scrl

Answer 4

APL (Dyalog Classic) , 11 बाइट्स

2≠/0,↑,⍳n⍴2

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

n⍴2है 2 2...2- nदोहों का एक सदिश

⍳nआकार के साथ एक आयामी सरणी के सूचकांक है 2 2...2- यह है, एक 2 × 2 × ... × 2 सरणी नेस्टेड वैक्टर। जैसा कि हम 0-इंडेक्सिंग ( ⎕IO←0) का उपयोग करते हैं, वे सभी लंबाई के बाइनरी वैक्टर हैं n।

,2 × 2 × ... × 2 आकार को समतल करें, इसलिए हमें 2 ⁿ नेस्टेड बाइनरी वैक्टर का एक वेक्टर मिलता है

↑"मिक्स" - वैक्टर के वेक्टर को एक ठोस 2 ⁿ × n मैट्रिक्स में परिवर्तित करें । यह इस तरह दिख रहा है:

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

0, मैट्रिक्स के बाईं ओर जीरो प्रीपेंड करता है

2≠/अंतिम आयाम के साथ युग्मक ( 2) xor ( ≠) की गणना करता है ( /विरोध के अनुसार ⌿); दूसरे शब्दों में, प्रत्येक तत्व अपने सही पड़ोसी के साथ xor-ed हो जाता है, और अंतिम कॉलम गायब हो जाता है

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

Comments

क्या आप एक त्वरित स्पष्टीकरण जोड़ना चाहेंगे?

— जोनाह

@ जोना ज़रूर, जोड़ा

— ngn

बहुत चतुर, thx

— योना

Answer 5

जाप , 14 12 बाइट्स

2pU Ç^z)¤ùTU

ETHproductions के लिए धन्यवाद दो बाइट्स मुंडा ।

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

Comments

कैसे ùउपयोग किया जाता है इसका सही उदाहरण । चूंकि N.z(n)डिफॉल्ट arg = 2 के साथ पूर्णांक विभाजन है, तो आप इसके साथ दो बाइट्स बचा सकते हैं 2pU Ç^z)¤ùTU: इसे ऑनलाइन आज़माएं!

— ETHproductions

@ETHproductions धन्यवाद, मुझे अभी भी हर बार डिफ़ॉल्ट चूक की याद आती है। बहुत काम, बहुत बहुत धन्यवाद।

— लीख

Answer 6

अजगर - ५४

चुनौती में दिए गए संदर्भ से एक एल्गोरिथ्म के आधार पर:

for i in range(2**n):print'{1:0{0}b}'.format(n,i>>1^i)

Ungolfed:

# For each of the possible 2**n numbers...
for num in range(2**n):
    gray = num>>1 ^ num

    # Print in binary and pad with n zeros.
    print '{1:0{0}b}'.format(grey)

Answer 7

PowerShell (168)

शौकिया PowerShell वापस golF पर एक और प्रयास के साथ! आशा है कि आप बुरा नहीं मानेंगे! बहुत कम से कम ये सवाल मजेदार हैं, और बूट करने के लिए एक सीखने का अनुभव है। मान लिया गया है कि n इनपुट किया गया है, हमारे पास है:

$x=@('0','1');for($a=1;$a-lt$n;$a++){$x+=$x[($x.length-1)..0];$i=[Math]::Floor(($x.length-1)/2);0..$i|%{$x[$_]='0'+$x[$_]};($i+1)..($x.length-1)|%{$x[$_]='1'+$x[$_]}}$x

क्योंकि जिस PowerShell के साथ मैं काम कर रहा हूं, वह केवल 2.0 है, मैं किसी भी बिट शिफ्टिंग cmdlets का उपयोग नहीं कर सकता, जो कि छोटे कोड के लिए हो सकता है। इसलिए मैंने प्रश्न स्रोत में वर्णित एक अलग विधि का लाभ उठाया , सरणी को फ़्लिप करते हुए और इसे खुद से जोड़ते हुए, शीर्ष आधे के सामने 0 से जोड़ते हुए, और 1 से नीचे आधे तक।

Answer 8

एफ # (86) (84) (80)

for i in 0..(1<<<n)-1 do printfn"%s"(Convert.ToString(i^^^i/2,2).PadLeft(n,'0'))

इसे शायद और बेहतर बनाया जा सके।

यह भी ध्यान दें, यदि एफएसआई में चलाया जाता है, तो आपको open System;;पहले करना होगा। यदि आप वह आयात करने से बचना चाहते हैं, (और यदि आप उस क्रम के बारे में परवाह नहीं करते हैं जिसमें मान मुद्रित किए जाते हैं) तो आप इस 82-अक्षर का उपयोग कर सकते हैं:

for i in 0..(1<<<n)-1 do(for j in 0..n-1 do printf"%i"((i^^^i/2>>>j)%2));printfn""

Answer 9

रूबी - ४२ ३ ९

समान एल्गोरिथ्म, अलग भाषा:

(2**n).times{|b|puts"%0#{n}b"%(b>>1^b)}

से स्विचिंग #mapको #times@voidpigeon पता चलता है के रूप में 3 अक्षरों की बचत होती है।

Comments

इसके बजाय [*0...2**n].mapआप उपयोग कर सकते हैं (2**n).times।

— 18

Answer 10

जे, 24 बाइट्स

[:#:@(22 b.<.@-:)[:i.2^]

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

"XOR के साथ इसका स्वयं का फ़्लोरवर्ड आधा" एल्गोरिदम का सीधा कार्यान्वयन। ध्यान दें कि 22 b.XOR है।

Answer 11

MATL , 10 बाइट्स

W:qt2/kZ~B

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

अच्छा पुराना "XOR n with n >> 2" विधि।

W- गणना 2 ^ (इनपुट) (इनपुट अनुमानित रूप से मिलता है)
:q- 0 से 2 ^ n - 1 तक संख्याओं की श्रेणी बनाएं
t - उस सीमा की नकल करें
2/k- MATL में बिटशिफ्ट नहीं है, इसलिए 2 (और प्रत्येक) को विभाजित करें और
Z~ एलिमेंट - X उस परिणाम के मूल 0 से 2 ^ n - 1 सरणी
B - परिणाम में प्रत्येक संख्या को बाइनरी में परिवर्तित करें
(Implicitly डिस्प्ले आउटपुट।)

Answer 12

के (ngn / k) , 25 बाइट्स

{(x-1){,/0 1,''|:\x}/0 1}

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

---

• |:\x"रिवर्स स्कैन एक्स" है। जब तक आउटपुट इनपुट के बराबर नहीं होता तब तक x पर रिवर्स लागू होता है, और प्रत्येक पुनरावृत्ति को दिखाता है। पहली पास पर रिटर्न (0 1; 1 0)।
• 0 1,''"0 1 प्रत्येक में शामिल हों"। 1 हाथ के प्रत्येक मान में 0 और दूसरे हाथ के प्रत्येक मान के साथ 1 जोड़ता है, (प्रथम चरण में) ((0 1; 1 0; 1))।
• ,/ "ज्वाइन ओवर" है, और सूची में समतल है।
• (x-1){...}/0 1" 0 1x-1 बार" {func} लागू करें "। इनपुट के रूप में अंतिम पुनरावृत्ति का आउटपुट लेता है

Answer 13

एपीएल (22)

{(0,⍵)⍪1,⊖⍵}⍣(n-1)⍪0 1

यह एक n-by-2 ^ n मैट्रिक्स को आउटपुट करता है जिसमें बिट्स इसकी पंक्तियों के रूप में होते हैं:

      n←3
      {(0,⍵)⍪1,⊖⍵}⍣(n-1)⍪0 1
0 0 0
0 0 1
0 1 1
0 1 0
1 1 0
1 1 1
1 0 1
1 0 0

स्पष्टीकरण:

• {... }⍣(n-1)⍪0 1: n-1आरंभिक इनपुट मैट्रिक्स के साथ फ़ंक्शन बार चलाएं (0 1)T(जो कि 1-बिट ग्रे कोड है)

  • (0,⍵): उपसर्ग के ⍵साथ प्रत्येक पंक्ति 0,
  • ⍪: के शीर्ष पर,
  • 1,⊖⍵: प्रत्येक पंक्ति के ⍵साथ एक 1उपसर्ग, उलटा क्रम में

Answer 14

Jq 1.5 , 105 100 बाइट्स

def g(n):if n<2then. else map([0]+.)+(reverse|map([1]+.))|g(n-1)end;[[0],[1]]|g(N)[]|map("\(.)")|add

मान लेता है कि एन इनपुट प्रदान करता है। जैसे

def N: 3 ;

विस्तारित

def g(n):  # recursively compute gray code
  if n < 2
  then .
  else map([0]+.) + (reverse|map([1]+.)) | g(n-1)
  end;

  [[0],[1]]                 # initial state
| g(N)[]                    # for each element in array of gray codes
| map("\(.)")|add           # covert to a string

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

Answer 15

जाप , 10 बाइट्स

³Ç¤ÅÃf_Ê¥U

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

Answer 16

टी-एसक्यूएल 134

यह चुनौती {(0), (1)} की कार्टेशियन शक्ति को वापस करने के लिए कह रही है। यह स्निपेट उस कोड का निर्माण करता है जो {(0), (1)} n के कार्टेसियन उत्पाद को निष्पादित करेगा।

DECLARE @ int=4,@s varchar(max)='SELECT*FROM's:set @s+='(VALUES(0),(1))t'+ltrim(@)+'(b)'if @>1set @s+=','set @-=1if @>0goto s exec(@s)

Comments

यह एक विशिष्ट क्रम में कार्टेशियन शक्ति के लिए पूछ रहा है। क्या आपका कोड उसके लिए है?

— तूनअल्फ्रिंक