एक वॉल्श मैट्रिक्स उत्पन्न करें


22

एक वाल्श मैट्रिक्स क्वांटम कंप्यूटिंग में अनुप्रयोगों के साथ एक विशेष प्रकार का वर्ग मैट्रिक्स है (और शायद अन्यत्र, लेकिन मैं केवल क्वांटम कंप्यूटिंग के बारे में परवाह करता हूं)।

वाल्श मैट्रिस के गुण

आयाम, इसलिए 2. का एक ही शक्ति हैं हम यहाँ दो के प्रतिपादक द्वारा इन मैट्रिक्स का उल्लेख कर सकते हैं, उन्हें बुला W(0), W(1), W(2)...

W(0)के रूप में परिभाषित किया गया है [[1]]

के लिए n>0, W(n)जैसा दिखता है:

[[W(n-1)  W(n-1)]
 [W(n-1) -W(n-1)]]

तो W(1)है:

[[1  1]
 [1 -1]]

और W(2)है:

[[1  1  1  1]
 [1 -1  1 -1]
 [1  1 -1 -1]
 [1 -1 -1  1]]

पैटर्न जारी है ...

आपका कार्य

एक प्रोग्राम या फ़ंक्शन लिखें जो इनपुट के रूप में एक पूर्णांक nऔर प्रिंट / रिटर्न W(n)को किसी भी सुविधाजनक प्रारूप में लेता है । यह सरणियों का एक सरणी हो सकता है, बूलियन का एक चपटा सरणी, एक .svgछवि, आप इसे नाम देते हैं, जब तक यह सही है।

मानक खामियों को मना किया जाता है।

कुछ बातें:

इसके लिए W(0), 1आवश्यकता को एक बार भी नहीं लपेटना चाहिए। यह एक मात्र पूर्णांक हो सकता है।

आपको 1-अनुक्रमणिका परिणामों की अनुमति है- W(1)फिर होगा [[1]]

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

0 -> [[1]]
1 -> [[1  1]
      [1 -1]]
2 -> [[1  1  1  1]
      [1 -1  1 -1]
      [1  1 -1 -1]
      [1 -1 -1  1]]
3 -> [[1  1  1  1  1  1  1  1]
      [1 -1  1 -1  1 -1  1 -1]
      [1  1 -1 -1  1  1 -1 -1]
      [1 -1 -1  1  1 -1 -1  1]
      [1  1  1  1 -1 -1 -1 -1]
      [1 -1  1 -1 -1  1 -1  1]
      [1  1 -1 -1 -1 -1  1  1]
      [1 -1 -1  1 -1  1  1 -1]]

8 -> pastebin

यह , इसलिए प्रत्येक भाषा में सबसे छोटा समाधान जीतता है! हैप्पी गोल्फिंग!



क्या परिणाम 1-अनुक्रमित हो सकते हैं? (उदा। W(1)रिटर्न [[1]], W(2)रिटर्न [[1,1],[1,-1]...)
सिंह

@ लेप हां, वे कर सकते हैं। में संपादित किया गया।
खुल्द्रेसथ ना'बरिया

जवाबों:


7

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

{map {:3(.base(2))%2},[X+&] ^2**$_ xx 2}

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

गैर-पुनरावर्ती दृष्टिकोण, इस तथ्य का फायदा उठाता है कि x, y का मूल्य निर्देशांक है (-1)**popcount(x&y)। बूलियंस का एक चपटा सरणी देता है।

-4 के लिए धन्यवाद बाइट्स XNOR के बिट समता चाल


10

MATL , 4 बाइट्स

W4YL

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

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

W       % Push 2 raised to (implicit) input
4YL     % (Walsh-)Hadamard matrix of that size. Display (implicit)

बिना अंतर्निहित: 11 बाइट्स

1i:"th1M_hv

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

यह कैसे काम करता है :

प्रत्येक वाल्श मैट्रिक्स डब्ल्यू के लिए , अगले मैट्रिक्स को [ डब्ल्यू डब्ल्यू] के रूप में गणना की जाती है ; डब्ल्यू - डब्ल्यू ], जैसा कि चुनौती में वर्णित है। कोड उस nसमय करता है , जो 1 × 1 मैट्रिक्स [1] से शुरू होता है।

1       % Push 1. This is equivalent to the 1×1 matrix [1]
i:"     % Input n. Do the following n times
  t     %   Duplicate
  h     %   Concatenate horizontally
  1M    %   Push the inputs of the latest function call
  _     %   Negate
  h     %   Concatenate horizontally
  v     %   Concatenate vertically
        % End (implicit). Display (implicit)

2
ऊ ... और यहां मैं उपयोग करने की कोशिश कर रहा हूं kron। ;)
बीकर

6

हास्केल , 57 56 बाइट्स

(iterate(\m->zipWith(++)(m++m)$m++(map(0-)<$>m))[[1]]!!)

इसे ऑनलाइन आज़माएं! यह दिए गए पुनरावर्ती निर्माण को लागू करता है।

-1 बाइट धन्यवाद अर्जन जोहान्सन को !


2
आप के साथ एक बाइट बचा सकते हैं (iterate(\m->zipWith(++)(m++m)$m++(map(0-)<$>m))[[1]]!!)
अर्जन जोहान्सन

5

ऑक्टेव बिल्डिन के साथ, 18 17 बाइट्स

@(x)hadamard(2^x)

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

ऑक्टेव बिना बिलिन के, 56 51 47 बाइट्स

function r=f(x)r=1;if x,r=[x=f(x-1) x;x -x];end

इसे ऑनलाइन आज़माएं! -4 के लिए @Luis मेंडू को धन्यवाद ।

पुनरावर्ती लंबोदर के साथ ऑक्टेव , 54 53 52 48 बाइट्स

f(f=@(f)@(x){@()[x=f(f)(x-1) x;x -x],1}{1+~x}())

इसे ऑनलाइन आज़माएं! इस जवाब और प्रेरणा के लिए इस सवाल के लिए धन्यवाद ।


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


4

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

r=range(2**input())
print[[int(bin(x&y),13)%2or-1for x in r]for y in r]

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

वाल्श मैट्रिक्स बुरी संख्याओं से संबंधित है। अगर x&y(बिटवाइज़ और, 0-आधारित निर्देशांक) एक बुराई संख्या है, मैट्रिक्स में मूल्य है 1, -1घृणित संख्या के लिए। इस उत्तर पर नूडल 9 की टिप्पणी int(bin(n),13)%2से बिट समता गणना ली गई है ।


2
सहज रूप से, संकेत (x, y) पर कई बार फ़्लिप किया जाता है क्योंकि पुनरावृत्ति के स्तर होते हैं, जिस पर (x, y ) मैट्रिक्स के निचले-दाएं चतुर्थांश में होता है (2 ^ k × 2 ^ k) मैट्रिक्स, जो तब होता है जब x और y दोनों के k- वें बिट में 1 है। इस तथ्य का उपयोग करते हुए, हम केवल x&yसाइन को फ्लिप करने के लिए कितनी बार निर्धारित करने के लिए 1-बिट्स की गणना कर सकते हैं ।
लिन

4

आर , 61 56 53 50 बाइट्स

w=function(n)"if"(n,w(n-1)%x%matrix(1-2*!3:0,2),1)

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

पुनरावर्ती क्रोनकर उत्पाद द्वारा मैट्रिक्स की गणना करता है, और n=0मामले के लिए 1 रिटर्न देता है (यह बाहर इशारा करने के लिए Giuseppe के लिए धन्यवाद, और प्रारंभिक संस्करण में मदद करने के लिए JAD के लिए भी)।

अतिरिक्त -3 बाइट्स फिर से ग्यूसेप के लिए धन्यवाद।


डनो अगर वैध होने के 1बजाय लौटाया matrix(1)जाता है, लेकिन अगर आप इसे नीचे गिरा सकते हैं, और 61 बाइट का Reduceतरीका भी है: तो इसे आजमाएँ!
Giuseppe

मैं n=0मामले के प्रारूप के बारे में भी अनिश्चित हूं , अधिकांश अन्य उत्तर इसे [[1]] में लपेटते हैं, लेकिन सभी नहीं ...
Kirill L.

1
आप बदल सकते हैं matrix(1)के साथ t(1)
JAD

1
प्रश्न संपादित किया गया है। आप एक मैट्रिक्स के बजाय पूर्णांक वापस कर सकते हैं।
खुल्द्रेसथ ना'बरिया

1
1-2*!3:0c(1,1,1,-1)तीन बाइट्स से कम है ।
ग्यूसेप


2

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

n=>[...Array(1<<n)].map((_,i,a)=>a.map((_,j)=>1|-f(i&j)),f=n=>n&&n%2^f(n>>1))

अनुभवहीन गणना लेने के द्वारा शुरू होता है 0 <= X, Y <= 2**Nमें W[N]। सरल मामला है जब या तो Xया Yकम से कम है 2**(N-1), ऐसी स्थिति में हम पर recurse X%2**(N-1)और Y%2**(N-1)। दोनों के मामले में Xऔर Yकम से कम 2**(N-1)पुनरावर्ती कॉल को नकारने की आवश्यकता है।

यदि किसी बिटमास्क से तुलना Xया Yकम करने के बजाय लिया जाता है तो यह गैर-शून्य होता है जब पुनरावर्ती कॉल को नकारात्मक और शून्य करना पड़ता है जब ऐसा नहीं होता है। यह भी modulo को कम करने से बचा जाता है ।2**(N-1)X&Y&2**(N-1)2**(N-1)

बिट्स को निश्चित रूप से उसी परिणाम के लिए रिवर्स ऑर्डर में परीक्षण किया जा सकता है। फिर हम जितनी बार समन्वय करते हैं, उसके बजाय हर बार बिटमास्क को दोगुना करने के बजाय, परिणाम को XORed करने की अनुमति दी जा सकती है, जिससे अंतिम परिणाम का 0कोई मतलब नहीं है और नकारात्मकता का 1मतलब है।



2

K (ngn / k) , 18 बाइट्स

{x{(x,x),'x,-x}/1}

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


उम, इंटरप्रेटर गीथहब पर क्यों नहीं है?
आउटगोल्फर

@EriktheOutgolfer मैं इस समय बहुत व्यापक रूप से कोड प्रकाशित नहीं करना चाहता।
ngn

हम्म, फिर आपने इसे TIO से कैसे जोड़ा?
आउटगोलेफर

@EriktheOutgolfer मैंने विनम्रता से पूछा :) TIO पर अन्य मालिकाना भाषाएं हैं - गणितज्ञ, ड्यालोग।
ngn

1

05AB1E , 16 बाइट्स

oFoL<N&b0м€g®smˆ

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

व्याख्या

oF                 # for N in 2**input do:
  oL<              # push range [1..2**input]-1
     N&            # bitwise AND with N
       b           # convert to binary
        0м         # remove zeroes
          €g       # length of each
            ®sm    # raise -1 to the power of each
               ˆ   # add to global array

काश, मैं हेमिंग वजन की गणना करने का एक छोटा तरीका जानता।
1δ¢˜के रूप में एक ही लंबाई है 0м€g


1

भूसी , 13 बाइट्स

!¡§z+DS+†_;;1

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

1 अनुक्रमित।

व्याख्या

!¡§z+DS+†_;;1
 ¡        ;;1    Iterate the following function starting from the matrix [[1]]
  §z+              Concatenate horizontally
     D               The matrix with its lines doubled
      S+†_           and the matrix concatenated vertically with its negation
!                Finally, return the result after as many iterations as specified
                 by the input (where the original matrix [[1]] is at index 1)



0

अजगर २ , 49 बाइट्स

अतिरिक्त पुस्तकालयों का उपयोग करते हुए कुछ तरीकों को प्रदर्शित करना। यह एक निर्मित स्कैपी पर निर्भर करता है:

lambda n:hadamard(2**n)
from scipy.linalg import*

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

अजगर २ , 65 बाइट्स

और यह केवल Numpy का उपयोग करता है, और क्रोनकर उत्पाद द्वारा हल करता है, जो मेरे R उत्तर के अनुरूप है :

from numpy import*
w=lambda n:0**n or kron(w(n-1),[[1,1],[1,-1]])

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


0

स्टैक्स , 20 बाइट्स

àΩ2┤â#╣_ê|ª⌐╦è│╞►═∞H

भागो और इसे staxlang.xyz पर डीबग करें!

सोचा था कि कुछ समय बाद अपनी चुनौती दूंगा। गैर-पुनरावर्ती दृष्टिकोण। अन्य गोल्फिंग भाषाओं के प्रति भी प्रतिस्पर्धी नहीं ...

अनपैक्ड (24 बाइट्स) और स्पष्टीकरण

|2c{ci{ci|&:B|+|1p}a*d}*
|2                          Power of 2
  c                         Copy on the stack.
   {                  }     Block:
    c                         Copy on stack.
     i                        Push iteration index (starts at 0).
      {           }           Block:
       ci                       Copy top of stack. Push iteration index.
         |&                     Bitwise and
           :B                   To binary digits
             |+                 Sum
               |1               Power of -1
                 p              Pop and print
                   a          Move third element (2^n) to top...
                    *         And execute block that many times.
                     d        Pop and discard
                       *    Execute block (2^n) times
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.