किसी भी लम्बाई के अनुक्रम के लिए असतत फूरियर ट्रांसफॉर्म (DFT) को लागू करें। इसे या तो एक फ़ंक्शन या प्रोग्राम के रूप में लागू किया जा सकता है और अनुक्रम को एक तर्क के रूप में या मानक इनपुट का उपयोग करके दिया जा सकता है।

एल्गोरिथ्म आगे की दिशा में मानक डीएफटी के आधार पर एक परिणाम की गणना करेगा। इनपुट अनुक्रम की लंबाई Nऔर समाहित है [x(0), x(1), ..., x(N-1)]। आउटपुट अनुक्रम की लंबाई समान होगी और इसमें [X(0), X(1), ..., X(N-1)]प्रत्येक X(k)उस संबंध में होगा जहां नीचे दिए गए संबंध द्वारा परिभाषित किया गया है।

नियम

ये है कोड गोल्फ तो सबसे छोटा समाधान जीतता है।
DFT जो आगे या पीछे (उलटा के रूप में भी जाना जाता है) दिशाओं की गणना करते हैं, उन्हें अनुमति नहीं है।
फ्लोटिंग-पॉइंट अशुद्धि को आपके खिलाफ नहीं गिना जाएगा।

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

DFT([1, 1, 1, 1]) = [4, 0, 0, 0]
DFT([1, 0, 2, 0, 3, 0, 4, 0]) = [10, -2+2j, -2, -2-2j, 10, -2+2j, -2, -2-2j]
DFT([1, 2, 3, 4, 5]) = [15, -2.5+3.44j, -2.5+0.81j, -2.5-0.81j, -2.5-3.44j]
DFT([5-3.28571j, -0.816474-0.837162j, 0.523306-0.303902j, 0.806172-3.69346j, -4.41953+2.59494j, -0.360252+2.59411j, 1.26678+2.93119j] = [2, -3j, 5, -7j, 11, -13j, 17]

मदद

2. की शक्ति के बराबर लंबाई वाले दृश्यों के लिए एफएफटी एल्गोरिथ्म का उपयोग करते हुए डीएफटी को खोजने के लिए एक पिछली चुनौती थी । आपको कुछ तरकीबें मिल सकती हैं जो आपको यहां मदद कर सकती हैं। ध्यान रखें कि यह चुनौती आपको किसी जटिलता तक सीमित नहीं करती है और किसी भी लम्बाई के अनुक्रम के लिए आपके समाधान की आवश्यकता होती है।

code-golf math

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

2

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

LR’µ×'÷L-*²³÷S€

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

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

LR’µ×'÷L-*²³÷S€  Main link. Argument [x(0), ..., x(N-1)].

L                Length; yield N.
 R               Range; yield [1, ..., N].
  ’              Decrement; yield [0, ..., N-1].
   µ             Begin a new, monadic chain. Argument: [0, ..., N-1]
    ×'           Spawned multiply [0, ..., N-1] with itself, yielding the matrix
                 of all possible products k×n.
      ÷L         Divide each product by N.
        -*       Compute (-1)**(kn÷L) for each kn.
          ²      Square each result, computing (-1)**(2kn÷L).
           ³÷    Divide [x(0), ..., x(N-1)] by the results.
             S€  Compute the sum for each row, i.e., each X(k).

— डेनिस
स्रोत

निंजाडे :(

— लीक नून

5

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

lambda x,e=enumerate:[sum(t/1j**(4*k*n/len(x))for n,t in e(x))for k,_ in e(x)]

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

कोड समकक्ष सूत्र का उपयोग करता है

सूत्र

— डेनिस
स्रोत

वाह, अपमानजनक आंकड़े। समतुल्य फ़ार्मुलों को देखकर अच्छा लगता है जो छोटे कोड के लिए अनुमति दे सकते हैं।

— मील

4

जे, 30 20 बाइट्स

3 बाइट्स @ मीलों के लिए धन्यवाद ।

इस तथ्य का उपयोग करता है कि e^ipi = -1।

सूत्र बन जाता है X_k = sum(x_n / ((-1)^(2nk/N)))।

+/@:%_1^2**/~@i.@#%#

प्रयोग

>> DCT =: +/@:%_1^2**/~@i.@#%#
>> DCT 1 2 3 4 5
<< 15 _2.5j3.44095 _2.5j0.812299 _2.5j_0.812299 _2.5j_3.44095

जहाँ >>STDIN है और <<STDOUT है।

"फ्लोटिंग-पॉइंट अशुद्धि को आपके खिलाफ नहीं गिना जाएगा।"

— लीक नन
स्रोत

3

MATL , 20 16 बाइट्स

-1yn:qt!Gn/E*^/s

इनपुट एक कॉलम वेक्टर है, अर्थात अर्धविराम द्वारा अल्पविराम बदलें:

[1; 1; 1; 1]
[1; 0; 2; 0; 3; 0; 4; 0]
[1; 2; 3; 4; 5]
[5-3.28571j; -0.816474-0.837162j; 0.523306-0.303902j; 0.806172-3.69346j; -4.41953+2.59494j; -0.360252+2.59411j; 1.26678+2.93119j]

इस में सूत्र का उपयोग करता लीकी नून का जवाब , तथ्यों के आधार पर कि exp ( iπ ) = -1, और कहा कि गैर पूर्णांक प्रतिपादक के साथ Matl की शक्ति operaton (सबसे प्रोग्रामिंग भाषाओं के रूप में) का उत्पादन प्रमुख शाखा परिणाम।

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

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

व्याख्या

-1      % Push -1
y       % Get input implicitly. Push a copy below and one on top of -1
n:q     % Row vector [0 1 ... N-1] where N is implicit input length
t!      % Duplicate and transpose: column vector
Gn      % Push input length
/       % Divide
E       % Multiply by 2
*       % Multiply, element-wise with broadcast. Gives the exponent as a matrix
^       % Power (base is -1), element-wise. Gives a matrix
/       % Divide matrix by input (column vector), element-wise with broadcast
s       % Sum

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

2

अजगर, ३०

ms.e*b^.n1****c_2lQk.n0d.j0)QU

परीक्षण सूट

बहुत भोली दृष्टिकोण, सिर्फ सूत्र का कार्यान्वयन। मूल्यों के साथ विभिन्न छोटे फ्लोटिंग पॉइंट मुद्दों में चलता है, जो कि शून्य से थोड़ा दूर होने वाले मूल्यों में परिणाम के लिए एडिटिव व्युत्क्रम होना चाहिए।

अजीब तरह से .jकोई तर्क के साथ काम करने के लिए प्रतीत नहीं होता है, लेकिन मुझे यकीन नहीं है अगर मैं इसे सही तरीके से उपयोग कर रहा हूं।

— FryAmTheEggman
स्रोत

1

10k पर बधाई !!

— लुइस मेंडो

2

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

इस तथ्य का उपयोग करता है कि e^ipi = -1।

सूत्र बन जाता है X_k = sum(x_n / ((-1)^(2nk/N)))।

ms.ecb^_1*cyklQdQU

परीक्षण सूट।

— लीक नन
स्रोत

2

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

~=endof
!x=sum(x./im.^(4(r=0:~x-1).*r'/~x),1)

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

कोड समकक्ष सूत्र का उपयोग करता है

सूत्र

— डेनिस
स्रोत

2

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

l=input();p=1
for _ in l:print reduce(lambda a,b:a*p+b,l)*p;p*=1j**(4./len(l))

बहुपद का मूल्यांकन प्रत्येक शक्ति pके लिए किया जाता है 1j**(4./len(l))।

अभिव्यक्ति हॉर्नर की विधि के माध्यम से मूल्य पर reduce(lambda a,b:a*p+b,l)दी गई बहुपद का मूल्यांकन करती है :lp

reduce(lambda a,b:a*10+b,[1,2,3,4,5])
=> 12345

सिवाय, इनपुट सूची उलट है, अंत में निरंतर शब्द के साथ। हम इसे उल्टा कर सकते हैं, लेकिन क्योंकि p**len(l)==1फूरियर गुणांक के लिए, हम inverting के एक हैक का उपयोग कर सकते हैं pऔर पूरे परिणाम को गुणा कर सकते हैं p।

कुछ समान लंबाई के प्रयास:

l=input();i=0
for _ in l:print reduce(lambda a,b:(a+b)*1j**i,l,0);i+=4./len(l)

l=input();i=0
for _ in l:print reduce(lambda a,b:a*1j**i+b,l+[0]);i+=4./len(l)

1 बाइट अधिक (79) के लिए एक समारोह के रूप में:

lambda l:[reduce(lambda a,b:a*1j**(i*4./len(l))+b,l+[0])for i in range(len(l))]

पुनरावर्तन का प्रयास (80):

f=lambda l,i=0:l[i:]and[reduce(lambda a,b:(a+b)*1j**(i*4./len(l)),l,0)]+f(l,i+1)

समान रूप से अनुकरण reduce(80):

l=input();p=1;N=len(l)
exec"s=0\nfor x in l:s=s*p+x\nprint s*p;p*=1j**(4./N);"*N

— XNOR
स्रोत

2

सी (जीसीसी) , 86 78 बाइट्स

k;d(a,b,c)_Complex*a,*b;{for(k=c*c;k--;)b[k/c]+=a[k%c]/cpow(1i,k/c*k%c*4./c);}

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

यह उपयोग से पहले आउटपुट वेक्टर शून्य हो जाता है।

— ceilingcat
स्रोत

1

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

इस तथ्य का उपयोग करता है कि e^ipi = -1।

सूत्र बन जाता है X_k = sum(x_n / ((-1)^(2nk/N)))।

lambda a:[sum(a[x]/(-1+0j)**(x*y*2./len(a))for x in range(len(a)))for y in range(len(a))]

Ideone यह!

— लीक नन
स्रोत

एक अलग उत्तर के रूप में पोस्ट करें!

— लीक नून

ठीक है, अगर आप ऐसा कहते हैं।

— डेनिस

1

गणितज्ञ, ४ ९ ४ by ४ by बाइट्स

Total[I^Array[4(+##-##-1)/n&,{n=Length@#,n}]#]&

@ डेनिस समाधान से सूत्र के आधार पर ।

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

1

Axiom, 81 बाइट्स

g(x)==(#x<2=>x;[reduce(+,[x.j/%i^(4*k*(j-1)/#x)for j in 1..#x])for k in 0..#x-1])

सूत्र का उपयोग करते हुए कोई यहां पोस्ट करता है। परिणाम

(6) -> g([1,1,1,1])
   (6)  [4,0,0,0]
                                    Type: List Expression Complex Integer
(7) -> g([1,2,3,4])
   (7)  [10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(8) -> g([1,0,2,0,3,0,4,0])
   (8)  [10,- 2 + 2%i,- 2,- 2 - 2%i,10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(11) -> g([1,2,3,4,5])
   (11)
        5+--+4       5+--+3    5+--+2      5+--+
        \|%i   + 5%i \|%i   - 4\|%i   - 3%i\|%i  + 2
   [15, --------------------------------------------,
                           5+--+4
                           \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 3%i \|%i   - 5\|%i   - 2%i\|%i  + 4
    --------------------------------------------,
                       5+--+4
                       \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 4%i \|%i   - 2\|%i   - 5%i\|%i  + 3
    --------------------------------------------,
                       5+--+4
                       \|%i
    5+--+4       5+--+3    5+--+2      5+--+
    \|%i   + 2%i \|%i   - 3\|%i   - 4%i\|%i  + 5
    --------------------------------------------]
                       5+--+4
                       \|%i
                                    Type: List Expression Complex Integer
(12) -> g([1,2,3,4,5.])
   (12)
   [15.0, - 2.5 + 3.4409548011 779338455 %i, - 2.5 + 0.8122992405 822658154 %i,
    - 2.5 - 0.8122992405 822658154 %i, - 2.5 - 3.4409548011 779338455 %i]
                                      Type: List Expression Complex Float

— RosLuP
स्रोत

0

ऑक्टेव , 43 39 बाइट्स

@(x)j.^(-4*(t=0:(s=rows(x))-1).*t'/s)*x

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

DFT मैट्रिक्स द्वारा इनपुट वेक्टर को गुणा करता है।

— ceilingcat
स्रोत

असतत फूरियर रूपांतरण की गणना करें

नियम

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

मदद

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

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

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

जे, 30 20 बाइट्स

प्रयोग

MATL , 20 16 बाइट्स

व्याख्या

अजगर, ३०

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

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

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

सी (जीसीसी) , 86 78 बाइट्स

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

गणितज्ञ, ४ ९ ४ by ४ by बाइट्स

Axiom, 81 बाइट्स

ऑक्टेव , 43 39 बाइट्स