Cho một vectơ các ngiá trị (x1,x2,x3,...,xn)trả về định thức của ma trận Vandermonde tương ứng .

Yếu tố quyết định này có thể được viết là:

Chi tiết

Chương trình / hàm của bạn phải chấp nhận một danh sách các số dấu phẩy động ở bất kỳ định dạng thuận tiện nào cho phép độ dài thay đổi và xuất ra định thức xác định.

Bạn có thể giả định rằng đầu vào cũng như đầu ra nằm trong phạm vi của các giá trị mà ngôn ngữ của bạn hỗ trợ. Nếu ngôn ngữ của bạn không hỗ trợ số dấu phẩy động, bạn có thể giả sử số nguyên.

Một số trường hợp thử nghiệm

Lưu ý rằng bất cứ khi nào có hai mục nhập bằng nhau, định thức sẽ 0có hai hàng bằng nhau trong ma trận Vandermonde tương ứng. Cảm ơn @randomra đã chỉ ra bản thử nghiệm còn thiếu này.

[1,2,2,3]            0 
[-13513]             1
[1,2]                1
[2,1]               -1
[1,2,3]              2
[3,2,1]             -2
[1,2,3,4]           12
[1,2,3,4,5]        288
[1,2,4]              6
[1,2,4,8]         1008
[1,2,4,8,16]  20321280
[0, .1, .2,...,1]   6.6586e-028
[1, .5, .25, .125]  0.00384521
[.25, .5, 1, 2, 4]  19.3798828

Thạch, 6 byte

œc2IFP

œc2được tất cả các kết hợp mà không thay thế độ dài 2. Itính toán danh sách khác biệt của từng cặp đó, mang lại một danh sách như thế nào [[1], [2], [3], ..., [1]]. Chúng tôi Flatten và lấy Pque thử.

Hãy thử nó ở đây!

Ruby, 49 47 byte

->x{eval(x.combination(2).map{|a,b|b-a}*?*)||1}

Đây là hàm lambda chấp nhận mảng một chiều có giá trị thực và trả về số float hoặc số nguyên tùy thuộc vào loại đầu vào. Để gọi nó, gán nó cho một biến sau đó làm f.call(input).

Chúng tôi nhận được tất cả các kết hợp của kích thước 2 bằng cách sử dụng .combination(2)và nhận được sự khác biệt cho mỗi cặp sử dụng .map {|a, b| b - a}. Chúng tôi nối mảng kết quả thành một chuỗi được phân tách bằng *, sau đó, chuỗi evalnày trả về sản phẩm. Nếu đầu vào có độ dài 1, thì đây sẽ nillà falsey trong Ruby, vì vậy chúng ta chỉ có thể ||1ở cuối để trả về 1 trong tình huống này. Lưu ý rằng điều này vẫn hoạt động khi sản phẩm bằng 0 vì bất kỳ lý do gì 0 là sự thật trong Ruby.

Xác nhận tất cả các trường hợp kiểm tra trực tuyến

Đã lưu 2 byte nhờ Doorknob!

Toán học, 30 byte

1##&@@(#2-#&@@@#~Subsets~{2})&

Đây là một chức năng ẩn danh.

Được mở rộng bởi Mathicala, nó tương đương với (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &. 1##&là một tương đương cho Times(trang lời khuyên cảm ơn), được áp dụng cho từng cặp yếu tố riêng biệt từ danh sách đầu vào, được tạo bởi Subsets[list, {2}]. Lưu ý rằng Subsetskhông kiểm tra tính duy nhất của các yếu tố.

J, 13 byte

-/ .*@(^/i.)#

Đây là một hàm đơn sắc lấy trong một mảng và trả về một số. Sử dụng nó như thế này:

  f =: -/ .*@(^/i.)#
  f 1 2 4
6

Giải trình

Tôi xây dựng rõ ràng ma trận Vandermonde liên kết với mảng đầu vào, và sau đó tính toán định thức của nó.

-/ .*@(^/i.)#   Denote input by y
            #   Length of y, say n
         i.     Range from 0 to n - 1
       ^/       Direct product of y with the above range using ^ (power)
                This gives the Vandermonde matrix
                 1 y0     y0^2     ... y0^(n-1)
                 1 y1     y1^2     ... y1^(n-1)
                   ...
                 1 y(n-1) y(n-1)^2 ... y(n-1)^(n-1)
-/ .*           Evaluate the determinant of this matrix

TOÁN , 9

!G-qZRQpp

Hãy thử trực tuyến!

Điều này sẽ tính toán một ma trận của tất cả các khác biệt và sau đó chỉ giữ phần bên dưới đường chéo chính, làm cho các mục khác 1để chúng không ảnh hưởng đến sản phẩm. Hàm tam giác thấp hơn làm cho các phần tử không mong muốn 0, không 1. Vì vậy, chúng tôi trừ 1, lấy phần tam giác thấp hơn, và thêm 1lại. Sau đó chúng ta có thể lấy sản phẩm của tất cả các mục.

t     % take input. Transpose
G     % push input again
-     % subtract with broadccast: matrix of all pairwise differences
q     % subtract 1
ZR    % make zero all values on the diagonal and above
Q     % add 1
p     % product of all columns
p     % product of all those products

Pyth, 15 13 12 11 byte

*F+1-M.c_Q2

         Q    take input (in format [1,2,3,...])
        _     reverse the array: later we will be subtracting, and we want to
                subtract earlier elements from later elements
      .c  2   combinations of length 2: this gets the correct pairs
    -M        map a[0] - a[1] over each subarray
  +1          prepend a 1 to the array: this does not change the following
                result, but prevents an error on empty array
*F            fold over multiply (multiply all numbers in array)

Cảm ơn @FryAmTheEggman và @ Pietu1998 cho mỗi byte!

Toán học, 32 byte

Det@Table[#^j,{j,0,Length@#-1}]&

Tôi đã ngạc nhiên khi không tìm thấy một nội dung tích hợp cho công cụ Vandermonde. Có lẽ bởi vì nó rất dễ để tự làm điều đó.

Cái này xây dựng rõ ràng sự hoán vị của VM và lấy định thức của nó (tất nhiên giống như bản gốc). Phương pháp này hóa ra ngắn hơn đáng kể so với sử dụng bất kỳ công thức nào tôi biết.

Haskell, 34 byte

f(h:t)=f t*product[x-h|x<-t]
f _=1

Một giải pháp đệ quy. Khi một phần tử mới hđược thêm vào phía trước, biểu thức được nhân với sản phẩm của x-htừng phần tử xcủa danh sách. Cảm ơn Zgarb cho 1 byte.

Matlab, 26 byte

(không soạn thảo)

Sử dụng đơn giản các nội dung. Lưu ý rằng (một lần nữa) Matlab vandertạo ra ma trận Vandermonde nhưng với thứ tự các hàng được lật.

@(v)det(fliplr(vander(v)))

Rust, 86 byte

|a:Vec<f32>|(0..a.len()).flat_map(|x|(x+1..a.len()).map(move|y|y-x)).fold(1,|a,b|a*b);

Rust, dài dòng như thường lệ ...

Giải thích sẽ đến sau (tuy nhiên nó khá đơn giản).

Perl, 38 41 byte

Bao gồm +1 cho -p

Cho các số trên một dòng trên STDIN. Vì vậy, ví dụ như chạy như

perl -p vandermonde.pl <<< "1 2 4 8"

Sử dụng một regex ác để có được vòng lặp kép:

vandermonde.pl:

$n=1;/(^| ).* (??{$n*=$'-$&;A})/;*_=n

JavaScript (ES6), 61 byte

a=>a.reduce((p,x,i)=>a.slice(0,i).reduce((p,y)=>p*(x-y),p),1)

Tôi đã thử hiểu một mảng (Firefox 30-57) và nó dài hơn 5 byte:

a=>[for(i of a.keys(p=1))for(j of Array(i).keys())p*=a[i]-a[j]]&&p

Vòng lặp lồng nhau nhàm chán có lẽ là ngắn hơn mặc dù.

Haskell, 53 byte

 f x=product[x!!j-x!!i|j<-[1..length x-1],i<-[0..j-1]]

Ví dụ sử dụng: f [1,2,4,8,16]-> 20321280.

Đi qua các chỉ số jvà itrong một vòng lặp lồng nhau và lập danh sách các khác biệt của các phần tử tại vị trí jvà i. Làm cho sản phẩm của tất cả các yếu tố trong danh sách.

Các biến thể khác hóa ra dài hơn một chút:

f x=product[last l-i|l<-scanl1(++)$pure<$>x,i<-init l], 54 byte

import Data.List;f i=product[y-x|[x,y]<-subsequences i], 55 byte

CJam, 16 byte

1l~{)1$f-@+:*\}h

Đáp lại bài đăng của A Simmons , mặc dù CJam không có toán tử kết hợp, nhưng có thể làm tốt hơn :)

-1 byte nhờ @ MartinBüttner.

Dùng thử trực tuyến | Bộ kiểm tra

1                   Push 1 to kick off product
 l~                 Read and evaluate input V
   {          }h    Do-while loop until V is empty
    )                 Pop last element of V
     1$               Copy the prefix
       f-             Element-wise subtract each from the popped element
         @+           Add the current product to the resulting array
           :*         Take product to produce new product
             \        Swap, putting V back on top

CJam, 32 byte

1q~La\{1$f++}/{,2=},{~-}%~]La-:*

Tôi chắc chắn rằng ai đó có thể chơi golf tốt hơn trong CJam ... Vấn đề chính là tôi không thể thấy một cách tốt để có được các tập hợp con để sử dụng hầu hết các byte của tôi. Điều này tạo ra tập hợp sức mạnh (sử dụng một ý tưởng của Martin Büttner) và sau đó chọn các yếu tố độ dài-2.

R , 41 byte

function(v)det(outer(v,1:sum(v|1)-1,"^"))

Hãy thử trực tuyến!

Tôi đã ngạc nhiên khi không thấy một câu trả lời R ở đây!

Perl 5 -pa , 36 byte

$\=1;map$\*=$q-$_,@F while$q=pop@F}{

Hãy thử trực tuyến!