28

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

इस प्रक्रिया के लिए आपको सीमा [0, 2 ⁿ -1] पर पुनरावृति करना और प्रत्येक मान को द्विआधारी में परिवर्तित करना और बिट्स को उस मूल्य में परिवर्तित करना है। आप प्रत्येक मान को आधार 2 में n -digit संख्या के रूप में मानेंगे जिसका अर्थ है कि अंतिम n बिट्स के बीच केवल उलटा होगा ।

उदाहरण के लिए, यदि n = 3, पूर्णांक की सीमा है [0, 1, 2, 3, 4, 5, 6, 7]। य़े हैं

i  Regular  Bit-Reversed  j
0    000        000       0
1    001        100       4
2    010        010       2
3    011        110       6
4    100        001       1
5    101        101       5
6    110        011       3
7    111        111       7

जहां प्रत्येक इंडेक्स i को बिट-रिवर्सल का उपयोग करके इंडेक्स जे में परिवर्तित किया जाता है । इसका मतलब है कि आउटपुट है [0, 4, 2, 6, 1, 5, 3, 7]।

N के लिए आउटपुट 0 के माध्यम से 4 हैं

n    Bit-Reversed Permutation
0    [0]
1    [0, 1]
2    [0, 2, 1, 3]
3    [0, 4, 2, 6, 1, 5, 3, 7]

आपने एक पैटर्न बनाने पर गौर किया होगा। N को देखते हुए , आप n -1 के लिए पिछले अनुक्रम को ले सकते हैं और इसे दोगुना कर सकते हैं। फिर उस दोहरे सूची को उसी डबल सूची में संक्षिप्त करें लेकिन एक के बाद एक वृद्धि। दिखाना,

[0, 2, 1, 3] * 2 = [0, 4, 2, 6]
[0, 4, 2, 6] + 1 = [1, 5, 3, 7]
[0, 4, 2, 6] ⊕ [1, 5, 3, 7] = [0, 4, 2, 6, 1, 5, 3, 7]

जहां ⊕संघटन का प्रतिनिधित्व करता है।

अपना समाधान बनाने के लिए आप ऊपर दिए गए दो तरीकों का उपयोग कर सकते हैं। यदि आप एक बेहतर तरीका जानते हैं, तो आप उसका उपयोग करने के लिए स्वतंत्र हैं। कोई भी तरीका ठीक है जब तक कि वह सही परिणाम नहीं देता।

नियम

यह कोड-गोल्फ है इसलिए सबसे छोटा समाधान जीतता है।
इस चुनौती को एक पूरे के रूप में हल करने वाले बिल्डरों और एक मूल्य के बिट-उलट गणना करने वाले बिल्डरों की अनुमति नहीं है। इसमें ऐसे बाइनरी शामिल नहीं हैं जो द्विआधारी रूपांतरण या अन्य बिटवाइज़ ऑपरेशन करते हैं।
आपका समाधान 0 से 31 तक n के लिए कम से कम मान्य होना चाहिए ।

— मील की दूरी पर
स्रोत

3

"इस चुनौती को हल करने वाले बिल्डरों और एक मूल्य के बिट-उलट की गणना करने वाले बिल्डरों की अनुमति नहीं है।" Awww IntegerReverse[Range[2^#]-1,2,#]&,। (मुझे नहीं पता कि गणितज्ञ को उस अंतर्निहित की आवश्यकता क्यों है , लेकिन मुझे लगता है कि यह Sunset... की तुलना में बहुत अधिक अजीब नहीं है )

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

@MartinEnder अच्छा लगता है। किसी दिन, यह हो सकता है कि यादृच्छिक कोड-गोल्फ चुनौतियों को उत्पन्न करने वाले गणितज्ञ में सब कुछ के लिए एक बिलिन होगा।

— मील

क्या हम 0इसके बजाय प्रिंट कर सकते हैं [0]या इसकी सूची होनी चाहिए?

— डेनिस

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

— मील

क्या 0 के बजाय झूठी वापसी स्वीकार्य होगी?

— डेनिस

2

जेली , 7 6 बाइट्स

Ḥ;‘$$¡

1 बाइट को बंद करने के लिए @EriktheOutgolfer का शुक्रिया!

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

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

Ḥ;‘$$¡  Main link. No arguments.
        Implicit argument / initial return value: 0

     ¡  Read an integer n from STDIN and call the link to the left n times.
    $   Combine the two links to the left into a monadic chain, to be called
        with argument A (initially 0, later an array).
Ḥ         Unhalve; yield 2A.
   $      Combine the two links to the left into a monadic chain, to be called
          with argument 2A.
  ‘         Increment; yield 2A + 1
 ;          Concatenate 2A and 2A + 1.

— डेनिस
स्रोत

4

05AB1E , 8 बाइट्स

कोड:

¾)IF·D>«

स्पष्टीकरण:

¾         # Constant for 0.
 )        # Wrap it up into an array.
  IF      # Do the following input times.
    ·     # Double every element.
     D    # Duplicate it.
      >   # Increment by 1.
       «  # Concatenate the first array.

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं! ।

— अदनान
स्रोत

अच्छा है! मेरे पास जो बीट्स है :)

— एमिग्ना

@Emigna धन्यवाद! आपका संस्करण तब क्या था?

— अदनान

0)ïsF·D>«हालांकि करीब था। '0' के साथ कुछ मुद्दे थे।

— इमीना

1

का अच्छा उपयोग ¾। उस चाल को याद रखना होगा।

— इमिग्ना

1

@KevinCruijssen इनपुट ० के लिए , यह ० के अंतर का प्रतिनिधित्व करने के लिए प्रिटियर दिखता है और स्ट्रिंग का प्रतिनिधित्व नहीं है :)। उसके अलावा, कोई मतभेद नहीं हैं।

— अदनान

4

MATL, 13 12 10 9 8 बाइट्स

0i:"EtQh

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

व्याख्या

0       % Push number literal 0 to the stack
i:"     % Loop n times
    E   % Multiply by two
    t   % Duplicate
    Q   % Add one
    h   % Horizontally concatenate the result
        % Implicit end of loop, and implicitly display the result

पूर्णता के लिए, गैर-पुनरावर्ती दृष्टिकोण (9 बाइट्स) का उपयोग करके यहां मेरा पुराना उत्तर था।

W:qB2&PXB

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

व्याख्या

W       % Compute 2 to the power% ofImplicitly thegrab input (n) and compute 2^n
:       % Create an array from [1...2^n]
q       % Subtract 1 to get [0...(2^n - 1)]
B       % Convert to binary where each row is the binary representation of a number
2&P     % Flip this 2D array of binary numbers along the second dimension
XB      % Convert binary back to decimal
        % Implicitly display the result

— Suever
स्रोत

4

जे, 15 11 बाइट्स

2&(*,1+*)0:

15 बाइट्स के लिए एक विकल्प है जो सीधे-आगे बाइनरी रूपांतरण और उत्क्रमण का उपयोग करता है।

2|."1&.#:@i.@^]

प्रयोग

   f =: 2&(*,1+*)0:
   f 0
0
   f 1
0 1
   f 2
0 2 1 3
   f 3
0 4 2 6 1 5 3 7
   f 4
0 8 4 12 2 10 6 14 1 9 5 13 3 11 7 15

व्याख्या

2&(*,1+*)0:  Input: n
         0:  The constant 0
2&(     )    Repeat n times starting with x = [0]
2      *       Multiply each in x by 2
     1+        Add 1 to each
    ,          Append that to
2  *           The list formed by multiplying each in x by 2
               Return that as the next value of x
             Return the final value of x

— मील की दूरी पर
स्रोत

4

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

2ṗ’UḄ

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

-1 डेनिस को धन्यवाद ।

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

4

हास्केल , 40 37 बाइट्स

f 0=[0]
f a=[(*2),(+1).(*2)]<*>f(a-1)

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

तीन बाइट्स के लिए @ लिकोनी को धन्यवाद!

— Angs
स्रोत

3

ऑक्टेव, 37 बाइट्स

@(n)bin2dec(fliplr(dec2bin(0:2^n-1)))

एक अनाम फ़ंक्शन बनाता ansहै जिसे बस कहा जा सकता है ans(n)।

ऑनलाइन डेमो

— Suever
स्रोत

3

पायथन 2, 56 55 54 बाइट्स

f=lambda n:[0][n:]or[i+j*2for i in 0,1for j in f(n-1)]

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

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

— डेनिस
स्रोत

आप कर सकते हैं [0][n:]or।

— xnor

3

जावा, 422 419 बाइट्स:

import java.util.*;class A{static int[]P(int n){int[]U=new int[(int)Math.pow(2,n)];for(int i=0;i<U.length;i++){String Q=new String(Integer.toBinaryString(i));if(Q.length()<n){Q=new String(new char[n-Q.length()]).replace("\0","0")+Q;}U[i]=Integer.parseInt(new StringBuilder(Q).reverse().toString(),2);}return U;}public static void main(String[]a){System.out.print(Arrays.toString(P(new Scanner(System.in).nextInt())));}}

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

यह ऑनलाइन की कोशिश करो! (Ideone)

— आर। कप
स्रोत

आप कुछ बाइट्स को StdIn से पढ़ने के बजाए args से एक int पार्स करने से बचा सकते हैं

— Pavel

3

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

बाइट गिनती एक आईएसओ 8859-1 एन्कोडेड स्रोत मानती है।

±0={0};±x_:=Join[y=±(x-1)2,y+1]

यह एक अपरिपक्व ऑपरेटर को परिभाषित करने के लिए पुनरावर्ती परिभाषा का उपयोग करता है ±।

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

3

पर्ल, 46 45 बाइट्स

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

STDIN पर इनपुट नंबर दें

#!/usr/bin/perl -p
map$F[@F]=($_*=2)+1,@F for(@F=0)..$_;$_="@F"

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

2

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

ushMByMGQ]0

टेस्ट सूट ।

— Maltysen
स्रोत

2

जावास्क्रिप्ट ईएस 6, 65 53 51 बाइट्स

f=(n,m=1)=>n?[...n=f(n-1,m+m),...n.map(i=>i+m)]:[0]

पुनरावर्ती दोहरे-वृद्धि-अवकलन एल्गोरिथ्म का उपयोग करता है।

उदाहरण चलता है:

f(0) => [0]
f(1) => [0, 1]
f(2) => [0, 2, 1, 3]
f(4) => [0, 8, 4, 12, 2, 10, 6, 14, 1, 9, 5, 13, 3, 11, 7, 15]

— Dendrobium
स्रोत

कैसे के बारे में f=n=>n>0?(r=f(n-1).map(i=>i*2)).concat(r.map(i=>i+1)):[0]?

— मील

@ मीलों वूप्स, एहसास नहीं हुआ कि मुझे n==1धन्यवाद के लिए आधार मामले की आवश्यकता नहीं है ।

— डेंड्रोबियम

2

मुझे लगता है कि मैं दो बाइट को दो से गुणा करके शेव करने में कामयाब रहा:f=(n,m=1)=>n?[...n=f(n-1,m+m),...n.map(i=>i+m)]:[0]

— नील

2

पायथन 3, 67 59 बाइट्स

@ डेनिस -8 बाइट्स के लिए धन्यवाद

lambda n:[int(bin(i+2**n)[:1:-1],2)//2for i in range(2**n)]

पाइथन में हमारे पास (संशोधित) सीधा कार्यान्वयन हो सकता है, भले ही यह काफी लंबा हो।

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

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

lambda n                 Anonymous function with input n
...for i in range(2**n)  Range from 0 to 2**n-1
bin(i+2**n)[:1:-1]       Convert i+2**n to binary string, giving 1 more digit than needed,
                         remove '0b' from start, and reverse
int(...,2)               Convert back to decimal
...//2                   The binary representation of the decimal value has one trailing
                         bit that is not required. This is removed by integer division by 2
:[...]                   Return as list

Ideone पर इसे आज़माएं

— TheBikingViking
स्रोत

2

यह मेरे दृष्टिकोण के साथ संबंध रखता है, लेकिन यह गोल्फपार्ट पायथन 3.

— डेनिस

2

दिल्लोग एपीएल , 12 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

2⊥⊖2⊥⍣¯1⍳2*⎕

2⊥ के आधार -2 से

⊖ फ़्लिप किया

2⊥⍣¯1 के आधार -2 से उलटा

⍳पहला n पूर्णांक, जहां n है

2* की शक्ति से २

⎕ संख्यात्मक इनपुट

TryAPL ऑनलाइन!

तुलना के लिए, यहाँ दूसरी विधि है:

(2∘×,1+2∘×)⍣⎕⊢0

( समारोह ट्रेन ...

2∘× दो बार (तर्क)

, के लिए सहमति

1+ एक प्लस

2∘× दो बार (तर्क)

)⍣ द्वारा निर्दिष्ट के रूप में कई बार लागू किया जाता है

⎕ संख्यात्मक इनपुट

⊢ पर

0 शून्य

— एडम
स्रोत

(⍋,⍨)⍣⎕⊢0( ⎕io←0)

— nnnn

@ng मेरा एल्गोरिथ्म से कोई लेना देना नहीं है।

— अदम

मैंने सोचा था कि यह आपके "अन्य तरीके" के समान था, लेकिन ठीक है, मैं एक अलग उत्तर

— लिखूंगा

2

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

2/|!2|&:

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

 x:3  / just for testing
 &x   / that many zeroes
0 0 0
 2|&x / max with 2
2 2 2
 !x#2 / binary words of length x, as a transposed matrix
(0 0 0 0 1 1 1 1
 0 0 1 1 0 0 1 1
 0 1 0 1 0 1 0 1)
 |!x#2 / reverse
(0 1 0 1 0 1 0 1
 0 0 1 1 0 0 1 1
 0 0 0 0 1 1 1 1)
 2/|!x#2 / base-2 decode the columns
0 4 2 6 1 5 3 7

&रचना में अंतिम क्रिया है, इसलिए हमें :इसे एकादिक होने के लिए मजबूर करने की आवश्यकता है

— NGN
स्रोत

1

जूलिया, 23 22 बाइट्स

!n=n>0&&[t=2*!~-n;t+1]

चुनौती कल्पना में वर्णित प्रक्रिया का सीधा कार्यान्वयन।

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

— डेनिस
स्रोत

1

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

iR2_M^U2

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

स्पष्टीकरण:

iR2_M^U2Q   implicit Q (=input number) at the end
     ^U2Q   generate all lists of zeros and ones of length Q in order
   _M       reverse each list
iR2         convert each list to a number

— Jakube
स्रोत

1

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

बस कल्पना के बाद ...

(defn f[n](if(= n 0)[0](let[F(map #(* 2 %)(f(dec n)))](concat F(map inc F)))))

— NikoNyrh
स्रोत

1

रूबी, 57 बाइट्स:

->n{(0...a=2**n).map{|x|("%b"%x+=a).reverse[0,n].to_i 2}}

— जीबी
स्रोत

1

PHP, 57 बाइट्स

while($i<1<<$argv[1])echo bindec(strrev(decbin($i++))),_;

कमांड लाइन पैरामीटर से इनपुट लेता है, अंडरस्कोर-सीमांकित मान प्रिंट करता है। के साथ भागो -nr।

पुनरावर्ती समाधान, 72 बाइट्स

function p($n){$r=[$n];if($n)foreach($r=p($n-1)as$q)$r[]=$q+1;return$r;}

फ़ंक्शन पूर्णांक लेता है, सरणी देता है

— टाइटस
स्रोत

1

रूबी , 51 बाइट्स

f=->n{n<1?[0]:(a=f[n-1].map{|i|i*2})+a.map(&:next)}

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

— आसोन तुहिद
स्रोत

1

पर्ल 6 , 42 बाइट्स

{0,{$^p+^($_-$_/2+>lsb ++$)}...$_}o 1+<*-1

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

एक पूर्णांक Incrementing बस से उदाहरण के लिए, कम से कम-महत्वपूर्ण बिट के एक दृश्य flips xxxx0111करने के लिए xxxx1000। तो अगले बिट-उलट सूचकांक को सबसे महत्वपूर्ण बिट्स के एक क्रम को फ़्लिप करके पिछले एक से प्राप्त किया जा सकता है। XOR मास्क के साथ या के m - (m >> (ctz(i) + 1))लिए गणना की जा सकती है ।m = 2**nm = 2**n-1

पर्ल 6 , 30 बाइट्स

my&f={$_&&(^2 X+(f($_-1)X*2))}

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

पुनरावर्ती दृष्टिकोण।

— nwellnhof
स्रोत

1

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 48 बाइट्स

f=n=>n?[for(x of[0,1])for(y of f(n-1))x+y+y]:[0]

@ डेनिस के पायथन 2 समाधान का पोर्ट।

— नील
स्रोत

संदर्भ: एफ परिभाषित नहीं है

— l4m2

1

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

2pU Ç¤w ú0U Í

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

अनपैक्ड और यह कैसे काम करता है

2pU o_s2 w ú0U n2

2pU    2**n
o_     range(2**n).map(...)
s2       convert to binary string
w        reverse
ú0U      right-pad to length n, filling with '0'
n2       convert binary string to number

सीधा कार्यान्वयन।

— bubbler
स्रोत

इसके लिए वास्तव में एक अनिर्दिष्ट शॉर्टकट है n2:Í

— ओलिवर

1

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

(⍋,⍨)⍣⎕⊢0

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

⎕ मूल्यांकन किया गया इनपुट

( )⍣⎕⊢0उस चीज को ( )कई बार लागू करें , जिसके साथ शुरू होता है0

,⍨ वर्तमान परिणाम को अपने साथ रखें

⍋ क्रमबद्ध आरोही क्रमांकन के सूचकांकों

— NGN
स्रोत

0

x86, 31 बाइट्स

एक पर्याप्त रूप से बड़े ले जाता है int[] bufferमें eaxऔर एन में ecx, और में बफर रिटर्न eax।

चुनौती बयान में दिए गए समवर्ती एल्गोरिथ्म को लागू करता है। यह संभव है कि सीधे एरे एक्सेस का उपयोग करने के बजाय पॉइंटर्स को 4 से बढ़ाकर बाइट्स को बचाया जा सकता है, लेकिन lea/ movपहले से ही बहुत कम है (3 रेज और एक गुणक के लिए 3 बाइट्स)।

.section .text
.globl main
main:
        mov     $buf, %eax          # buf addr
        mov     $3, %ecx            # n 

start:
        xor     %ebx, %ebx
        mov     %ebx, (%eax)        # init buf[0] = 0 
        inc     %ebx                # x = 1

l1:
        mov     %ebx, %edi          
        dec     %edi                # i = x-1
        lea     (%eax,%ebx,4), %edx # buf+x 

l2:
        mov     (%eax,%edi,4), %esi # z = buf[i]
        sal     %esi                # z *= 2
        mov     %esi, (%eax,%edi,4) # buf[i] = z
        inc     %esi                # z += 1
        mov     %esi, (%edx,%edi,4) # buf[x+i] = z

        dec     %edi                # --i 
        jns     l2                  # do while (i >= 0)

        sal     %ebx                # x *= 2
        loop    l1                  # do while (--n)

        ret

.data
buf:    .space 256, -1

Hexdump:

00000507  31 db 89 18 43 89 df 4f  8d 14 98 8b 34 b8 d1 e6  |1...C..O....4...|
00000517  89 34 b8 46 89 34 ba 4f  79 f1 d1 e3 e2 e7 c3     |.4.F.4.Oy......|

— qwr
स्रोत

बिट-उलटा क्रमपरिवर्तन

नियम

जेली , 7 6 बाइट्स

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

05AB1E , 8 बाइट्स

MATL, 13 12 10 9 8 बाइट्स

जे, 15 11 बाइट्स

प्रयोग

व्याख्या

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

हास्केल , 40 37 बाइट्स

ऑक्टेव, 37 बाइट्स

पायथन 2, 56 55 54 बाइट्स

जावा, 422 419 बाइट्स:

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

पर्ल, 46 45 बाइट्स

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

जावास्क्रिप्ट ईएस 6, 65 53 51 बाइट्स

पायथन 3, 67 59 बाइट्स

दिल्लोग एपीएल , 12 बाइट्स

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

जूलिया, 23 22 बाइट्स

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

स्पष्टीकरण:

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

रूबी, 57 बाइट्स:

PHP, 57 बाइट्स

रूबी , 51 बाइट्स

पर्ल 6 , 42 बाइट्स

पर्ल 6 , 30 बाइट्स

जावास्क्रिप्ट (फ़ायरफ़ॉक्स 30-57), 48 बाइट्स

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

अनपैक्ड और यह कैसे काम करता है

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

x86, 31 बाइट्स