48

খুব কম সম্ভাব্য অক্ষরগুলিতে ফাস্ট ফুরিয়ার রূপান্তর বাস্তবায়ন করুন।

নিয়মাবলী:

সংক্ষিপ্ত সমাধান জিতেছে
ধারণা করা যেতে পারে যে ইনপুটটি 1D অ্যারে যার দৈর্ঘ্য দুটি একটি।
আপনি আপনার পছন্দের অ্যালগরিদম ব্যবহার করতে পারেন, তবে সমাধানটি অবশ্যই একটি ফাস্ট ফিউরিয়ার ট্রান্সফর্ম হতে হবে, কেবল একটি নিরীহ ডিস্ক্রিট ফুরিয়ার ট্রান্সফর্ম নয় (এটির ক্ষেত্রে অবশ্যই $O(N \log N)$ এর অ্যাসিম্পটোটিক গণনা ব্যয় থাকতে হবে )

সম্পাদনা:

কোডটিতে স্ট্যান্ডার্ড ফরোয়ার্ড ফাস্ট ফুরিয়ার ট্রান্সফর্ম প্রয়োগ করা উচিত, যা রূপটি এই ওল্ফ্রাম নিবন্ধের সমীকরণ (3) এ দেখা যায় ,
প্রাক-বিদ্যমান স্ট্যান্ডার্ড লাইব্রেরি বা পরিসংখ্যান প্যাকেজ থেকে একটি এফএফটি ফাংশন ব্যবহারের অনুমতি নেই। এখানে চ্যালেঞ্জটি হল দৃ suc়ভাবে FFT অ্যালগরিদমকে বাস্তবায়ন করা ।

code-golf math complex-numbers

— jakevdp
সূত্র

3

এটি অপ্রকাশিত খুব কমপক্ষে আপনাকে স্বাভাবিককরণের কারণগুলি সংজ্ঞায়িত করতে হবে এবং আপনার এও সচেতন হওয়া উচিত যে কোনও অস্পষ্টতা ইচ্ছাকৃতভাবে ভুল ব্যাখ্যা করা হবে। উদাহরণস্বরূপ "প্রয়োগটি" উত্তরে সন্তুষ্ট " FFT(3 টি অক্ষর): এটি স্ট্যান্ডার্ড লাইব্রেরিতে আছে"? কিছু পরীক্ষার কেসও ভাল হবে।

— পিটার টেলর

এটি কি আউটপুট উপাদানগুলির ক্রম সম্পর্কে গুরুত্ব দেয়, অর্থাত্ কি আমাদের বিট বিপরীত আনস্র্যাম্বলিং বাস্তবায়ন করতে হবে বা আউটপুটটিকে স্ক্র্যাম্বলড ক্রমে রেখে যেতে পারি?

— পল আর

নিয়মে সম্পাদনাগুলি দেখুন। উপরের রেফারেন্সকৃত স্ট্যান্ডার্ড ডিএফটি এক্সপ্রেশন-এর সূচক অনুযায়ী অর্ডার করা মানগুলির সাথে আউটপুটটি তালিকা / অ্যারে হওয়া উচিত।

— jakevdp

2

আপনি কি আমাদের কিছু উদাহরণ এবং ইনপুট পোস্ট করতে পারেন যাতে আমরা আমাদের প্রয়োগগুলি পরীক্ষা করতে পারি?

— ফুজজেক্সএল

2

শিরোনামটি "দ্রুত এবং ফুরিয়ার-এস" হওয়া উচিত (দ্রুত এবং উগ্র)।

— ক্লিমেজিক

12

গণিত, 95 বাইট

@ ছায়াংয়ের সহায়তায় কুলি @ টুকি এফএফটির আর একটি বাস্তবায়ন ।

{n=Length@#}~With~If[n>1,Join[+##,#-#2]&[#0@#[[;;;;2]],#0@#[[2;;;;2]]I^Array[-4#/n&,n/2,0]],#]&

Ungolfed

FFT[x_] := With[{N = Length[x]},
  If[N > 1,
    With[{a = FFT[ x[[1 ;; N ;; 2]] ], 
          b = FFT[ x[[2 ;; N ;; 2]] ] * Table[E^(-2*I*Pi*k/N), {k, 0, N/2 - 1}]},
      Join[a + b, a - b]],
    x]]

— মাইল
সূত্র

1

আমি মনে করি #[[;;;;2]]==#[[1;;N;;2]]এবং [[2;;;;2]]==[[2;;N;;2]]।

— ছায়ানগ

1

101 টি অক্ষর ：With[{L=Length@#},If[L>1,Join[+##,#-#2]&[#0@#[[;;;;2]],#0@#[[2;;;;2]]E^(-2I*Pi(Range[L/2]-1)/L)],#]]&

— চ্যানোগ

সুন্দর, আপনি পুনরাবৃত্তির সাথে বিবাদ না করেই এর ভিতরে অন্য একটি বেনামি ফাংশন ঘনীভূত করতে পারেন। এছাড়াও শিখেছি যে পার্ট অনুপস্থিত সূচকগুলিতে পূরণ করে। আমরা ইউনিকোড ব্যবহার করে এটি আরও এগিয়ে নিতে পারি।

— মাইল

9

জে, 37 বাইট

_2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#

কয়েক বছর পরে একটি উন্নতি। এখনও কুলি-টুকি এফএফটি অ্যালগরিদম ব্যবহার করে।

ব্যবহার 4 বাইট সংরক্ষিত ই ^πi করতে = -1, ধন্যবাদ @ লিকি নূনের ।

এটি অনলাইন চেষ্টা করুন!

ব্যবহার

   f =: _2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#
   f 1 1 1 1
4 0 0 0
   f 1 2 3 4
10 _2j2 _2 _2j_2
   f 5.24626 3.90746 3.72335 5.74429 4.7983 8.34171 4.46785 0.760139
36.9894 _6.21186j0.355661 1.85336j_5.74474 7.10778j_1.13334 _0.517839 7.10778j1.13334 1.85336j5.74474 _6.21186j_0.355661

ব্যাখ্যা

_2&(0((+,-)]%_1^i.@#%#)&$:/@|:]\)~1<#  Input: array A
                                    #  Length
                                  1<   Greater than one?
_2&(                            )~     Execute this if true, else return A
_2                            ]\         Get non-overlapping sublists of size 2
    0                       |:           Move axis 0 to the end, equivalent to transpose
                          /@             Reduce [even-indexed, odd-indexed]
                       &$:               Call recursively on each 
                   #                     Get the length of the odd list
                i.@                      Range from 0 to that length exclusive
                    %#                   Divide each by the odd length
             _1^                         Compute (-1)^x for each x
           ]                             Get the odd list
            %                            Divide each in that by the previous
       +                                 Add the even values and modified odd values
         -                               Subtract the even values and modified odd values
        ,                                Join the two lists and return

— মাইল
সূত্র

1

এটিও দেখুন: blog.ndpar.com/2014/10/11/dft-j

— ফুজজেক্সএল

9

পাইথন, 166 151 150 টি অক্ষর

এটি Radix-2 কুলি-টুকি এফএফটি অ্যালগরিদম ব্যবহার করে

from math import*
def F(x):N=len(x);t=N<2or(F(x[::2]),F(x[1::2]));return N<2and x or[
a+s*b/e**(2j*pi*n/N)for s in[1,-1]for(n,a,b)in zip(range(N),*t)]

ফলাফল পরীক্ষা করা হচ্ছে

>>> import numpy as np
>>> x = np.random.random(512)
>>> np.allclose(F(x), np.fft.fft(x))
True

— jakevdp
সূত্র

1

২ টি জিনিস: এটি সাধারণত ব্যবহার করা সবচেয়ে ভাল from x import*এবং এর sum(([x for x in y] for y in z),[])চেয়ে লম্বা [x for y in z for x in y]।

— বুথবি

1

ধন্যবাদ - যা 15 টি অক্ষর সংরক্ষণ করে! 11 টি এবং এটি একটি টুইট।

— jakevdp

ওহ, এটা অবশ্যই সম্ভব। প্রায়শই যখন আপনি একটি উন্নতি পান, একজন পুরানো একটি হোঁচট খাতে পরিণত হয়।

— বুথবি

5

পাইথন 3: 140 134 113 টি অক্ষর

সংক্ষিপ্ত সংস্করণ - একটি টুইটে ছোট এবং মিষ্টি, তড়কা (ধন্যবাদ দিয়ে মাইল ):

from math import*
def f(v):
 n=len(v)
 if n<2:return v
 a,b=f(v[::2])*2,f(v[1::2])*2;return[a[i]+b[i]/1j**(i*4/n)for i in range(n)]

(পাইথন ২-এ, /উভয় পক্ষের পূর্ণসংখ্যার ক্ষেত্রে বিভাজনকে ছাঁটাই করা হয় So সুতরাং আমরা এর (i*4/n)দ্বারা প্রতিস্থাপন করব (i*4.0/n), যা দৈর্ঘ্যকে ১১৫ অক্ষরে পরিণত হয়))

দীর্ঘ সংস্করণ - ক্লাসিক কুলি-টুকি এফএফটির অভ্যন্তরের আরও স্পষ্টতা:

import cmath
def transform_radix2(vector):
    n = len(vector)
    if n <= 1:  # Base case
        return vector
    elif n % 2 != 0:
        raise ValueError("Length is not a power of 2")
    else:
        k = n // 2
        even = transform_radix2(vector[0 : : 2])
        odd  = transform_radix2(vector[1 : : 2])
        return [even[i % k] + odd[i % k] * cmath.exp(i * -2j * cmath.pi / n) for i in range(n)]

— Nayuki
সূত্র

1

113 বাইট ব্যবহার করে সংক্ষিপ্ত করেe^(-2j * pi * i / n) = (-1)^(2 * i / n) = (1j)^(4 * i / n)

— মাইল

@ মাইলস খুব চিত্তাকর্ষক পর্যবেক্ষণ, আপনাকে ধন্যবাদ! এক দশকেরও বেশি সময় ধরে বারবার ডিএফটি প্রয়োগ করার পরে, আমি পাপ / কোস / এক্সপ্রেসে আচ্ছন্ন হয়ে পড়েছি এবং ভুলে গিয়েছি যে আমার সহজ ক্ষমতাগুলি ব্যবহার করা যেতে পারে। নতুন অন্তর্দৃষ্টি এবং আপনাকে ক্রেডিট করার জন্য আমি আমার উত্তর সম্পাদনা করেছি।

— নায়ুকি

5

আর: 142 133 99 95 বাইট

32 জ্যাকেট শেভ করতে আমাকে সাহায্য করার জন্য @ জিউজ্পিকে ধন্যবাদ !

f=function(x,n=sum(x|1),y=1:(n/2)*2)`if`(n>1,f(x[-y])+c(b<-f(x[y]),-b)*exp(-2i*(y/2-1)*pi/n),x)

এখানে একটি অতিরিক্ত কৌশলটি কিছু ভেরিয়েবলগুলি ইনস্ট্যান্ট করতে প্রধান ফাংশন ডিফল্ট আর্গুমেন্টগুলি ব্যবহার করা।
ব্যবহার এখনও একইরকম:

x = c(1,1,1,1)
f(x)
[1] 4+0i 0+0i 0+0i 0+0i

133 বাইটে 4 বছরের পুরানো সংস্করণ:

f=function(x){n=length(x);if(n>1){a=Recall(x[seq(1,n,2)]);b=Recall(x[seq(2,n,2)]);t=exp(-2i*(1:(n/2)-1)*pi/n);c(a+b*t,a-b*t)}else{x}}

ইন্ডেন্টেশন সহ:

f=function(x){
    n=length(x)
    if(n>1){
        a=Recall(x[seq(1,n,2)])
        b=Recall(x[seq(2,n,2)])
        t=exp(-2i*(1:(n/2)-1)*pi/n)
        c(a+b*t,a-b*t)
        }else{x}
    }

এটি কুলি-টুকি অ্যালগোরিদমও ব্যবহার করে। এখানে কেবল কৌশলগুলি ফাংশনটির ব্যবহার Recallযা পুনরাবৃত্তির অনুমতি দেয় এবং আর ভেক্টরাইজেশন ব্যবহার করে যা প্রকৃত গণনাকে খুব ছোট করে তোলে।

ব্যবহার:

x = c(1,1,1,1)
f(x)
[1] 4+0i 0+0i 0+0i 0+0i

— plannapus
সূত্র

1

চার বছর পরে, এবং আমরা এটি 101 বাইটে নামব । Recallএটি ইতিমধ্যে একটি নামযুক্ত ফাংশন হিসাবে আপনি কেন ব্যবহার করেছেন তা 100% নিশ্চিত নয় তবে ওহে, পশ্চাদগ্রহনের পক্ষে গল্ফ করা সহজ! :) +1, খুব সুন্দর।

— জিউসেপে

হ্যাঁ Recallএখন অপ্রয়োজনীয়। আমি লক্ষ করেছি যে কয়েক মাস আগেও এটি পরিবর্তন করতে খুব অলস ছিল :) আমি এটি পরিবর্তন করব।

— প্ল্যানাপাস

খুব সুন্দর! আমি আরও 4 বাইট আউট আউট! ম্যাথামেটিকাকে সমান করে দিচ্ছি।

— জিউসেপ

ধন্যবাদ! আমি yসেখানে স্থাপন সম্পর্কে ভেবেছিলাম কিন্তু লক্ষ্য করি না যে এটি exp(...)অংশটির জন্যও ব্যবহার করা যেতে পারে ।

— প্ল্যানাপাস

4

পাইথন, 134

এটি জ্যাকেভিডিপি এর সমাধান থেকে প্রচুর orrowণ নিয়েছে, তাই আমি এটি একটি সম্প্রদায় উইকিতে সেট করেছি।

from math import*
F=lambda x:x*(len(x)<2)or[a+s*b/e**(2j*pi*n/len(x))for s in(1,-1)for n,(a,b)in
enumerate(zip(F(x[::2]),F(x[1::2])))]

পরিবর্তন করুন:

-12 অক্ষর: হত্যা t।

def F(x):N=len(x);t=N<2or(F(x[::2]),F(x[1::2]));return ... in zip(range(N),*t)]
def F(x):N=len(x);return ... in zip(range(N),F(x[::2]),F(x[1::2]))]

-1 চর: উদ্দীপক কৌশল, x*y**-z == x/y**z (এটি কিছু অন্যকে সাহায্য করতে পারে)

...[a+s*b*e**(-2j*pi*n/N)...
...[a+s*b/e**(2j*pi*n/N)...

-2 গৃহস্থালির কাজ: প্রতিস্থাপন andসঙ্গে*

...return N<2and x or[
...return x*(N<2)or[

+1 চর: lambdaআইজ, হত্যাN

def F(x):N=len(x);return x*(N<2)or[a+s*b/e**(2j*pi*n/N) ... zip(range(N) ...
F=lambda x:x*(len(x)<2)or[a+s*b/e**(2j*pi*n/len(x)) ... zip(range(len(x)) ...

-2 চর: enumerateপরিবর্তে ব্যবহার করুনzip(range(len(

...for(n,a,b)in zip(range(len(x)),F(x[::2]),F(x[1::2]))]
...for n,(a,b)in enumerate(zip(F(x[::2]),F(x[1::2])))]

— boothby
সূত্র

আমি মনে করি এটি আর দ্রুত ফুরিয়ার রূপান্তর নয়, যদিও ... "হত্যার টি" দ্বারা আপনি কিছু অপ্রয়োজনীয় গণনা যোগ করেছেন যা এটিকে ও [এন লগ (এন)] থেকে ও [এন ^ 2] এ

— স্থানান্তর করে

দেখা যাচ্ছে যে আমি আমার নিজের পোস্টকে কমিয়ে দিতে পারি না। আপনি সঠিক, আমি লুপ অর্ডার এক্সচেঞ্জ এবং কর্মক্ষমতা নিহত। আমি এখনই এটি ছেড়ে দেব, যদি আমি এটির সমাধানের কোনও উপায় খুঁজে পাই।

— বুথবি

101 বাইটf=lambda x:x*(len(x)<2)or[u+v/1j**(4*i/len(x))for i,(u,v)in enumerate(zip(f(x[::2])*2,f(x[1::2])*2))]

— মাইল

আপনি অর্ডার কোনও ব্যাপার না হলেও, এর for s in(1,-1)forসাথে for s in 1,-1forবা এমনকি প্রতিস্থাপন করতে পারেন for s in-1,1for।

— জোনাথন ফ্রেচ

4

সি, 259

typedef double complex cplx;
void fft(cplx buf[],cplx out[],int n,int step){
if(step < n){
fft(out, buf,n, step * 2);
fft(out+step,buf+step,n,step*2);
for(int i=0;i<n;i+=2*step){
cplx t=cexp(-I*M_PI*i/n)*out[i+step];
buf[i/2]=out[i]+t;
buf[(i+n)/2]=out[i]-t;
}}}

সমস্যাটি হ'ল, এই জাতীয় বাস্তবায়নগুলি অকেজো এবং সোজাসাপ্ট অ্যালগরিদম খুব দ্রুত।

— sanaris
সূত্র

2

স্বল্প পরিমাণে চরিত্রের জন্য আপনি আরও কিছু শ্বেতস্পেস সরিয়ে ফেলতে পারেন, উদাহরণস্বরূপ এর মধ্যে step < nপরিবর্তন করা যেতে পারে step<nএবং এর মধ্যে step * 2পরিবর্তন করা যেতে পারে step*2।

— প্রোগ্রামফক্স

2

সমস্ত ভেরিয়েবল এবং ফাংশন এবং

2

আপনার কাছে কেউ এর জন্য একগুচ্ছ উন্নয়নের পরামর্শ দিয়েছেন। তাদের এখানে একবার দেখুন: কোডগল্ফ.স্ট্যাকেক্সেঞ্জার

— জাস্টিন

1

আপনি সমস্ত

— নিউলাইনগুলি

@ TùxCräftîñg সমস্ত নিউলাইন অকেজো নয়। এগুলি # অন্তর্ভুক্ত, # নির্দিষ্ট, # আইফ ইত্যাদি ইত্যাদির জন্য প্রয়োজন

— নায়ুকি

3

মতলব, 128 118 107 102 101 94 93 বাইট

সম্পাদনা 6: আরেকটি বাইটের জন্য ধন্যবাদ @ এলজিমিয়ার!

function Y=f(Y);
n=numel(Y);
k=2:2:n;
if k;
   c=f(Y(k-1));
   d=f(Y(k)).*i.^(2*(2-k)/n);
   Y=[c+d;c-d];
end

এডিআইটি 5: এখনও আরও সংক্ষিপ্ত হচ্ছে :) @ সানচিইসকে ধন্যবাদ

function Y=f(Y)
n=numel(Y);
k=2:2:n;
if k;
   c=f(Y(k-1));
   d=f(Y(k)).*(-1).^((2-k)/n);
   Y=[c+d;c-d];
end

সম্পাদনা 4: হ্যাঁ, -1 চরিত্রটি আরও বেশি (এগুলি ছাড়া এটিও করতে পারত k):

function Y=f(Y)
n=numel(Y);
if n>1;
   k=2:2:n;
   c=f(Y(k-1));
   d=f(Y(k)).*(-1).^((k/2-1)*2/n)';
   Y=[c+d;c-d];
end

সম্পাদনা 2/3: আরও উন্নতির জন্য @ সানচাইজিসের জন্য ধন্যবাদ!

function Y=f(Y)
n=numel(Y);  
if n>1;
   c=f(Y(1:2:n));
   d=f(Y(2:2:n)).*(-1).^(-(0:n/2-1)*2/n).';
   Y=[c+d;c-d]; 
end

সম্পাদনা: কিছু উন্নতি করতে পারে এবং লক্ষ্য করেছে যে স্কেলিং ধ্রুবক প্রয়োজন হয় না।

এটি প্রসারিত সংস্করণ, আপনি নতুনলাইন / স্পেসগুলি সরিয়ে ফেললে অক্ষর গণনা বৈধ। (শুধুমাত্র কলামের ভেক্টরগুলির জন্য কাজ করে))

function y=f(Y)
n=numel(Y);  
y=Y;
if n>1;
   c=f(Y(1:2:n));
   d=f(Y(2:2:n));
   n=n/2;
   d=d.*exp(-pi*i*(0:n-1)/n).';
   y=[c+d;c-d]; 
end

— flawr
সূত্র

টিপ: আপনি দুই একত্রিত করতে পারেন d=এক লাইন: m=n/2;d=f(Y(2:2:n)).*exp(-pi*i*(0:m-1)/m).';। তদ্ব্যতীত, পরিবর্তন করার ব্যাপারে বিবেচনা y=f(Y)করতে Y=f(Y)এবং অপসারণ লাইন 3 (এবং প্রতিজ্ঞা আপনি কোড-গলফ যে বাহিরে কখনোই করব)

— Sanchises

ধন্যবাদ! function Y = f(Y)অপঠনযোগ্যতা ব্যতীত অন্য কোনও অবসন্নতা আছে কি ?

— flawr

ঠিক আছে, ম্যাটল্যাব কখনও কোনও রিটার্ন মান সম্পর্কে অভিযোগ করবে না, এমনকি যদি Y কখনও পরিবর্তন না হয়। এটি যদিও সামান্য দ্রুত, সুতরাং আমার ধারণা এটি কোনও কারণে এতটা খারাপ নয় (যেমন একটি ফাংশন যা প্রায়শই ইনপুট ভেরিয়েবল পরিবর্তন করে না)

— সানচাইজস

এখন, আরও শেভ করার জন্য: m=n/2সরানো যেতে পারে এবং পরিবর্তে যথাক্রমে এবং mপ্রতিস্থাপন করা যেতে পারে । এবং তারপরে, আমি দৃ strongly়ভাবে বিশ্বাস করি, প্রোগ্রামটি ম্যাটল্যাবে যতটা সংক্ষিপ্ত ছিল। n/2n*2

— সানচাইসেস

1

এবং তারপরে, আমি দৃ strongly়ভাবে বিশ্বাস করি, প্রোগ্রামটি ম্যাটল্যাবে যতটা সংক্ষিপ্ত ছিল। - 21 মার্চ সানাইজাইজ 8 '15 এ 21:05 বিখ্যাত শেষ কথা ...

— সানচাইজস

2

জেলি, 31 30 28 26 বাইট , প্রতিদ্বন্দ্বী

LḶ÷$N-*×,N$+ḷF
s2Zß€ç/µ¹Ṗ?

জেলি এই চ্যালেঞ্জের পরে তৈরি হয়েছিল তাই এটি প্রতিদ্বন্দ্বী is

এটি কুলি-টুকি রেডিক্স -২ পুনরাবৃত্তির অ্যালগরিদম ব্যবহার করে। একটি অ-গল্ফযুক্ত সংস্করণের জন্য, আমার উত্তরটি ম্যাথেমেটিকায় দেখুন।

এটি অনলাইনে চেষ্টা করুন বা একাধিক পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

LḶ÷$N-*×,N$+ḷF  Helper link. Input: lists A and B
L               Get the length of A
   $            Operate on that length
 Ḷ                Make a range [0, 1, ..., length-1]
  ÷               Divide each by length
    N           Negate each
     -          The constant -1
      *         Compute -1^(x) for each x in that range
       ×        Multiply elementwise between that range and B, call it B'  
          $     Operate on that B'
         N        Negate each
        ,         Make a list [B', -B']
            ḷ   Get A
           +    Add vectorized, [B', -B'] + A = [A+B', A-B']
             F  Flatten that and return

s2Zß€ç/µ¹Ṗ?  Main link. Input: list X
         Ṗ   Curtail - Make a copy of X with the last value removed
          ?  If that list is truthy (empty lists are falsey)
       µ       Parse to the left as a monad
s2             Split X into sublists of length 2
  Z            Transpose them to get [even-index, odd-index]
   ß€          Call the main link recursively on each sublist
     ç/        Call the helper link as a dyad on the sublists and return
             Else
        ¹      Identity function on X and return

— মাইল
সূত্র

2

সি (জিসিসি) , 188 186 184 183 বাইট

#define d(a,b,c)f(a,b,c,1,0)
f(a,b,c,n,k)_Complex*a,*b;{_Complex z[c];*b=*a;if(n<c)for(f(a,z,c,n*2),f(a+n,z+n,c,n*2);k<c;k+=n*2)b[k+c>>1]=z[k]*2-(b[k/2]=z[k]+z[k+n]/cpow(1i,2.*k/c));}

এটি অনলাইন চেষ্টা করুন!

কিছুটা কম গল্ফড

#define d(a,b,c)f(a,b,c,1,0)
f(a,b,c,n,k)_Complex*a,*b;{
  _Complex z[c];
  *b=*a;
  if(n<c)
    for(f(a,z,c,n*2),f(a+n,z+n,c,n*2);k<c;k+=n*2)
      b[k+c>>1]=z[k]*2-(b[k/2]=z[k]+z[k+n]/cpow(1i,2.*k/c));
}

— ceilingcat
সূত্র

1

পরি / জিপি, 76 টি অক্ষর

X(v)=my(t=-2*Pi*I/#v,s);vector(#v,k,s=t*(k-1);sum(n=0,#v-1,v[n+1]*exp(s*n)))

ব্যবহার

X([1,1,1,1])
%2 = [4.000000000000000000000000000, 0.E-27 + 0.E-28*I, 0.E-28 + 0.E-27*I, 0.E-27 + 0.E-28*I]

— P̳x͓L̳
সূত্র

3

এটি কি নিষ্পাপ ডিএফটি নয়? (যেমন থেটা (এন ^ 2))

— মাইল

1

অক্টোটা , 109 103 101 100 বাইট

f(f=@(f)@(x,n=rows(x)){@(d=f(f)(x(k=2:2:n)).*i.^((k*2-4)/n)')[d+(c=f(f)(x(k-1)));c-d],x}{1+(n<2)}())

এটি অনলাইন চেষ্টা করুন!

ওউও এই ~~পুনরাবৃত্ত~~ অভিশপ্ত ল্যাম্বদা থেকে আমার চোখের রক্ত ঝরছে। এর বড় অংশগুলি @ ফ্লাওয়ারের উত্তর থেকে তোলা হয়েছে।

f(                                          % lambda function
  f=@(f)                                    % defined in its own argument list, 
                                            % accepts itself as parameter (for recursion)
    @(x,n=rows(x)){                         % calls another lambda,
                                            % 2nd parameter is just to define a variable
      @(d=f(f)(x(k=2:2:n)).*i.^((k*2-4)/n)')% 1/4 of FFT (argument just defines a variable)
        [d+(c=f(f)(x(k-1)));                % 2/4 of FFT
         c-d                                % 4/4 of FFT
        ],                                  % This is in a @()[] to inhibit evaluation
                                            % unless actually called
      x                                     % FFT of length 1
    }{1+(n<2)}                              % if len(x)==1, return x
                                            % else return [d+c;c-d]
  ()                                        % this is probably important too
)

— ceilingcat
সূত্র

তুমি কি করেছ তা আমি বুঝতে পারছি না তবে আমি এটি অনেক পছন্দ করি।

— flawr

0

এক্সিয়াম, 259 , 193 , 181 , 179 বাইট

L(g,n,f)==>[g for i in 1..n|f]
h(a)==(n:=#a;n=1=>a;c:=h(L(a.i,n,odd? i));d:=h(L(a.i,n,even? i));n:=n/2;t:=1>0;v:=L(d.i*%i^(-2*(i-1)/n),n,t);append(L(c.i+v.i,n,t),L(c.i-v.i,n,t)))

এমনকি যদি জ (ক) সব পরীক্ষা পাস পারে এবং এই 'প্রতিযোগিতা' এর জন্য এন্ট্রি হিসেবে ঠিক আছে হবে এক জ () বা hlp () FFT () নীচের পুরনো ডাকতে ভালবাসি, জন্য রয়েছে আর্গুমেন্ট পরীক্ষণ । এই সফ্টওয়্যারটি ঠিক আছে কিনা তা আমি জানি না কারণ আমি কেবল অন্যটি যা লিখেছিলাম তা দেখেছি এবং কিছু সম্ভাব্য সঠিক ফলাফল ফেরত দেওয়ার জন্য এটি অক্সিয়মে যেভাবে চালাতে পারে তা অনুসন্ধান করেছি। কয়েকটি মন্তব্য সহ নিখরচায় কোডের নীচে:

-- L(g,n,f)==>[g for i in 1..n|f]
-- this macro L, build one List from other list, where in g, there is the generic element of index i
-- (as a.i, or a.i*b.i or a.i*4), n build 1..n that is the range of i, f is the condition 
-- for insert the element in the list result.

hlp(a)==
    n:=#a;n=1=>a
    -- L(a.i,n,odd? i)  it means build a list getting "even indices i of a.i as starting from index 0" [so even is odd and odd is even]
    -- L(a.i,n,even? i) it means build a list getting "odd  indices i of a.i as starting from index 0"
    c:=hlp(L(a.i,n,odd? i));d:=hlp(L(a.i,n,even? i))
    n:=n/2;t:=1>0
    v:=L(d.i*%i^(-2*(i-1)/n),n,t)
    append(L(c.i+v.i,n,t),L(c.i-v.i,n,t))

-- Return Fast Fourier transform of list a, in the case #a=2^n
fft(a)==(n:=#a;n=0 or gcd(n,2^30)~=n=>[];hlp(a))

(5) -> h([1,1,1,1])
   (5)  [4,0,0,0]
                                    Type: List Expression Complex Integer
(6) -> h([1,2,3,4])
   (6)  [10,- 2 + 2%i,- 2,- 2 - 2%i]
                                    Type: List Expression Complex Integer
(7) -> h([5.24626,3.90746,3.72335,5.74429,4.7983,8.34171,4.46785,0.760139])
   (7)
   [36.989359, - 6.2118552150 341603904 + 0.3556612739 187363298 %i,
    1.85336 - 5.744741 %i, 7.1077752150 341603904 - 1.1333387260 812636702 %i,
    - 0.517839, 7.1077752150 341603904 + 1.1333387260 812636702 %i,
    1.85336 + 5.744741 %i,
    - 6.2118552150 341603904 - 0.3556612739 187363298 %i]
                                      Type: List Expression Complex Float
(8) -> h([%i+1,2,%i-2,9])
   (8)  [10 + 2%i,3 + 7%i,- 12 + 2%i,3 - 7%i]
                                    Type: List Expression Complex Integer

কয়েকটিতে আমি দেখেছি h () বা fft () সঠিক সমাধান ফিরে আসতে পারে, তবে সরলীকরণটি যেমনটি তেমন ভাল না হয়:

(13) -> h([1,2,3,4,5,6,7,8])
   (13)
                    +--+                                   +--+
        (- 4 + 4%i)\|%i  - 4 + 4%i             (- 4 - 4%i)\|%i  - 4 + 4%i
   [36, --------------------------, - 4 + 4%i, --------------------------, - 4,
                    +--+                                   +--+
                   \|%i                                   \|%i
            +--+                                   +--+
    (- 4 + 4%i)\|%i  + 4 - 4%i             (- 4 - 4%i)\|%i  + 4 - 4%i
    --------------------------, - 4 - 4%i, --------------------------]
                +--+                                   +--+
               \|%i                                   \|%i
                                    Type: List Expression Complex Integer

আনুমানিক সমাধানের সন্ধানের জন্য নিচের লেখার মতো তালিকার কেবলমাত্র একটি উপাদানের প্রকারটি পরিবর্তনের কথা ভাবা হয়েছে (ভাসমান):

(14) -> h([1,2,3,4,5,6,7,8.])
   (14)
   [36.0, - 4.0000000000 000000001 + 9.6568542494 923801953 %i, - 4.0 + 4.0 %i,
    - 4.0 + 1.6568542494 92380195 %i, - 4.0, - 4.0 - 1.6568542494 92380195 %i,
    - 4.0 - 4.0 %i, - 4.0 - 9.6568542494 923801953 %i]
                                      Type: List Expression Complex Float

আমি এটি লিখেছিলাম, অন্যান্য সমস্ত উত্তর দেখেছি কারণ লিঙ্কে, পৃষ্ঠাটিটি খুব বেশি কঠিন ছিল তাই আমি জানি না যে এই কোডটি সঠিক হতে পারে কিনা। আমি একফুট বিশেষজ্ঞ নই তাই এগুলি (এটি সম্ভাব্য) ভুল হতে পারে।

— RosLuP
সূত্র

0

এপিএল (এনএআরএস), 58 টি চর, 116 বাইট

{1≥k←≢⍵:⍵⋄(∇⍵[y∼⍨⍳k])(+,-)(∇⍵[y←2×⍳t])×0J1*t÷⍨2-2×⍳t←⌊k÷2}

পরীক্ষা

  f←{1≥k←≢⍵:⍵⋄(∇⍵[y∼⍨⍳k])(+,-)(∇⍵[y←2×⍳t])×0J1*t÷⍨2-2×⍳t←⌊k÷2}
  f 1 1 1 1
4J0 0J0 0J0 0J0 
  f 1 2 3 4
10J0 ¯2J2 ¯2J0 ¯2J¯2 
  f 1J1 2 ¯2J1  9
10J2 3J7 ¯12J2 3J¯7 
  f 5.24626,3.90746,3.72335,5.74429,4.7983,8.34171,4.46785,0.760139
36.989359J0 ¯6.211855215J0.3556612739 1.85336J¯5.744741 7.107775215J¯1.133338726 ¯0.517839J0 
  7.107775215J1.133338726 1.85336J5.744741 ¯6.211855215J¯0.3556612739

— RosLuP
সূত্র

খুব দ্রুত, খুব ফুরিয়ার: এফএফটি কোড গল্ফ

গণিত, 95 বাইট

Ungolfed

জে, 37 বাইট

ব্যবহার

ব্যাখ্যা

পাইথন, 166 151 150 টি অক্ষর

পাইথন 3: 140 134 113 টি অক্ষর

আর: 142 133 99 95 বাইট

পাইথন, 134

সি, 259

মতলব, 128 118 107 102 101 94 93 বাইট

জেলি, 31 30 28 26 বাইট , প্রতিদ্বন্দ্বী

ব্যাখ্যা

সি (জিসিসি) , 188 186 184 183 বাইট

পরি / জিপি, 76 টি অক্ষর

অক্টোটা , 109 103 101 100 বাইট

এক্সিয়াম, 259 , 193 , 181 , 179 বাইট

এপিএল (এনএআরএস), 58 টি চর, 116 বাইট