Bei einem gegebenen Vektor von nWerten (x1,x2,x3,...,xn)zurückkehren , die Determinante der entsprechenden Vandermonde-Matrix .

Diese Determinante kann wie folgt geschrieben werden:

Einzelheiten

Ihr Programm / Ihre Funktion muss eine Liste von Gleitkommazahlen in einem beliebigen geeigneten Format akzeptieren, das eine variable Länge zulässt, und die angegebene Determinante ausgeben.

Sie können davon ausgehen, dass sowohl die Eingabe als auch die Ausgabe im Bereich der von Ihrer Sprache unterstützten Werte liegt. Wenn Ihre Sprache keine Gleitkommazahlen unterstützt, können Sie ganze Zahlen annehmen.

Einige Testfälle

Es ist zu beachten, dass die Determinante immer dann ist, wenn zwei gleiche Einträge 0vorhanden sind , da in der entsprechenden Vandermonde-Matrix zwei gleiche Zeilen vorhanden sind. Vielen Dank an @randomra für den Hinweis auf diesen fehlenden Testfall.

[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

Gelee, 6 Bytes

œc2IFP

œc2Ruft alle Kombinationen ab, ohne die Länge 2 zu ersetzen. IBerechnet die Differenzliste jedes dieser Paare und ergibt eine Liste wie [[1], [2], [3], ..., [1]]. Wir Flatten und nehmen das PProdukt.

Probieren Sie es hier aus!

Ruby, 49 47 Bytes

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

Dies ist eine Lambda-Funktion, die ein eindimensionales Array mit einem reellen Wert akzeptiert und je nach Art der Eingabe einen Gleitkommawert oder eine Ganzzahl zurückgibt. Um es aufzurufen, weisen Sie es einer Variablen zu f.call(input).

Wir erhalten alle Kombinationen der Größe 2 mit .combination(2)und erhalten die Unterschiede für jedes Paar mit .map {|a, b| b - a}. Wir verbinden das resultierende Array in eine Zeichenfolge getrennt durch *, dann evaldieses, das das Produkt zurück. Wenn die Eingabe die Länge 1 hat, ist dies nil, was in Ruby falsch ist, so dass wir ||1in dieser Situation gerade am Ende 1 zurückgeben können. Beachten Sie, dass dies immer noch funktioniert, wenn das Produkt 0 ist, da 0 in Ruby aus irgendeinem Grund wahr ist.

Überprüfen Sie alle Testfälle online

2 Bytes gespart dank Doorknob!

Mathematica, 30 Bytes

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

Dies ist eine anonyme Funktion.

Erweitert um Mathematica ist es äquivalent zu (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &. 1##&ist eine Entsprechung für Times(Dankesseite), die auf jedes einzelne Elementpaar aus der von generierten Eingabeliste angewendet wird Subsets[list, {2}]. Beachten Sie, dass Subsetsdie Eindeutigkeit von Elementen nicht überprüft wird.

J, 13 Bytes

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

Dies ist eine monadische Funktion, die ein Array aufnimmt und eine Zahl zurückgibt. Benutze es so:

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

Erläuterung

Ich konstruiere explizit die dem Eingabearray zugeordnete Vandermonde-Matrix und berechne dann ihre Determinante.

-/ .*@(^/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

MATL , 9

!G-qZRQpp

Probieren Sie es online!

Dadurch wird eine Matrix aller Unterschiede berechnet, und es wird nur der Teil unterhalb der Hauptdiagonale beibehalten, sodass die anderen Einträge 1das Produkt nicht beeinträchtigen. Die untere Dreiecksfunktion macht die unerwünschten Elemente 0nicht 1. Also subtrahieren wir 1, nehmen den unteren dreieckigen Teil und addieren 1zurück. Dann können wir das Produkt aus allen Einträgen entnehmen.

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 Bytes

*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)

Vielen Dank an @FryAmTheEggman und @ Pietu1998 für jeweils ein Byte!

Mathematica, 32 Bytes

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

Ich war überrascht, dass ich kein eingebautes Gerät für Vandermonde gefunden habe. Wahrscheinlich, weil es so einfach ist, es selbst zu machen.

Dieser konstruiert explizit die Transponierung einer VM und nimmt ihre Determinante (die natürlich mit der des Originals identisch ist). Diese Methode erwies sich als erheblich kürzer als die Verwendung einer mir bekannten Formel.

Haskell, 34 Bytes

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

Eine rekursive Lösung. Wenn ein neues Element hvorangestellt wird, wird der Ausdruck x-hfür jedes Element xder Liste mit dem Produkt von multipliziert . Danke an Zgarb für 1 Byte.

Matlab, 26 Bytes

(nicht konkurrierend)

Einfache Verwendung von Builtins. Beachten Sie, dass Matlab's (noch einmal) vanderVandermonde-Matrizen erstellt, wobei jedoch die Reihenfolge der Zeilen vertauscht wird.

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

Rust, 86 Bytes

|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, wortreich wie immer ...

Die Erklärung wird später kommen (es ist jedoch ziemlich einfach).

Perl, 38 41 Bytes

Fügen Sie +1 für -p

Geben Sie die Zahlen in einer Zeile auf STDIN ein. Also zB laufen als

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

Benutze einen bösen Regex, um die doppelte Schleife zu erhalten:

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)

Ich habe versucht, ein Array zu verstehen (Firefox 30-57) und es war 5 Bytes länger:

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

Die langweilige verschachtelte Schleife ist jedoch wahrscheinlich kürzer.

Haskell, 53 Bytes

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

Anwendungsbeispiel: f [1,2,4,8,16]-> 20321280.

Gehen Sie die Indizes jund iin einer verschachtelten Schleife durch und erstellen Sie eine Liste der Unterschiede der Elemente an Position jund i. Machen Sie das Produkt aus allen Elementen in der Liste.

Andere Varianten, die sich als etwas länger herausstellten:

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

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

CJam, 16 Bytes

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

Als Antwort auf den Beitrag von A Simmons , obwohl CJam keinen Kombinationsoperator hat, ist es möglich, es besser zu machen :)

-1 Byte Danke an @ MartinBüttner.

Versuchen Sie es online | Testsuite

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 Bytes

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

Ich bin sicher, dass jemand in CJam besser Golf spielen kann ... Das Hauptproblem ist, dass ich keinen guten Weg sehe, um die Teilmengen zu erhalten, die den größten Teil meiner Bytes verbrauchen. Dies erzeugt den Kraftsatz (nach einer Idee von Martin Büttner) und wählt dann die Elemente der Länge 2 aus.

R , 41 Bytes

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

Probieren Sie es online!

Ich war überrascht, hier keine Antwort von R zu sehen!

Perl 5 -pa , 36 Bytes

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

Probieren Sie es online!