Dado un vector de nvalores (x1,x2,x3,...,xn)devuelve el determinante de la matriz de Vandermonde correspondiente .

Este determinante se puede escribir como:

Detalles

Su programa / función tiene que aceptar una lista de números de coma flotante en cualquier formato conveniente que permita una longitud variable y generar el determinante especificado.

Puede suponer que tanto la entrada como la salida están dentro del rango de los valores que admite su idioma. Si su idioma no admite números de coma flotante, puede suponer enteros.

Algunos casos de prueba

Tenga en cuenta que siempre que haya dos entradas iguales, el determinante será 0ya que hay dos filas iguales en la matriz de Vandermonde correspondiente. Gracias a @randomra por señalar este caso de prueba perdido.

[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

Jalea, 6 bytes

œc2IFP

œc2obtiene todas las combinaciones sin reemplazar la longitud 2. Icalcula la lista de diferencias de cada uno de esos pares, produciendo una lista como [[1], [2], [3], ..., [1]]. Nos Faferramos y tomamos el Producto.

Pruébalo aquí!

Ruby, 49 47 bytes

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

Esta es una función lambda que acepta una matriz unidimensional de valor real y devuelve un flotante o un entero dependiendo del tipo de entrada. Para llamarlo, asígnelo a una variable y luego hagaf.call(input) .

Obtenemos todas las combinaciones de tamaño 2 usando .combination(2)y obtenemos las diferencias para cada par usando .map {|a, b| b - a}. Unimos la matriz resultante en una cadena separada por *, luego evalesto, que devuelve el producto. Si la entrada tiene longitud 1, esta será nil, que es falsey en Ruby, por lo que ||1al final podemos devolver 1 en esta situación. Tenga en cuenta que esto todavía funciona cuando el producto es 0 porque, por cualquier razón, 0 es verdadero en Ruby.

Verifique todos los casos de prueba en línea

¡Ahorré 2 bytes gracias a Doorknob!

Mathematica, 30 bytes

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

Esta es una función anónima.

Ampliado por Mathematica, es equivalente a (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &. 1##&es un equivalente para Times(página de consejos de agradecimiento), que se aplica a cada par distinto de elementos de la lista de entrada, generado por Subsets[list, {2}]. Tenga en cuenta que Subsetsno verifica la unicidad de los elementos.

J, 13 bytes

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

Esta es una función monádica que toma una matriz y devuelve un número. Úselo así:

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

Explicación

Construyo explícitamente la matriz de Vandermonde asociada con la matriz de entrada, y luego calculo su 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

Pruébalo en línea!

Esto calcula una matriz de todas las diferencias y luego mantiene solo la parte debajo de la diagonal principal, haciendo las otras entradas 1para que no afecten al producto. La función triangular inferior hace que los elementos 0no deseados , no 1. Entonces restamos 1, tomamos la parte triangular inferior y sumamos de 1nuevo. Entonces podemos tomar el producto de todas las entradas.

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)

Gracias a @FryAmTheEggman y @ Pietu1998 por un byte cada uno.

Mathematica, 32 bytes

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

Me sorprendió no encontrar un lugar para las cosas de Vandermonde. Probablemente porque es muy fácil hacerlo uno mismo.

Éste construye explícitamente la transposición de una VM y toma su determinante (que, por supuesto, es el mismo que el original). Este método resultó ser significativamente más corto que el uso de cualquier fórmula que conozco.

Haskell, 34 bytes

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

Una solución recursiva. Cuando hse antepone un nuevo elemento al frente, la expresión se multiplica por el producto de x-hpara cada elemento xde la lista. Gracias a Zgarb por 1 byte.

Matlab, 26 bytes

(sin competencia)

Uso directo de los incorporados. Tenga en cuenta que (una vez más) Matlab's vandercrea matrices de Vandermonde pero con el orden de las filas invertido.

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

Óxido, 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);

Óxido, detallado como siempre ...

La explicación vendrá más tarde (sin embargo, es bastante sencillo).

Perl, 38 41 bytes

Incluye +1 para -p

Dé los números en una línea en STDIN. Entonces, por ejemplo, correr como

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

Usa una expresión regular malvada para obtener el doble bucle:

vandermonde.pl:

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

JavaScript (ES6), 61 bytes

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

Probé una comprensión de matriz (Firefox 30-57) y fue 5 bytes más larga:

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

Sin embargo, el bucle anidado aburrido es probablemente más corto.

Haskell, 53 bytes

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

Ejemplo de uso: f [1,2,4,8,16]->20321280 .

Ir a través de los índices jy ien un bucle anidado y hacer una lista de las diferencias de los elementos en la posición jy i. Haga el producto de todos los elementos en la lista.

Otras variantes que resultaron ser un poco más largas:

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

En respuesta a la publicación de A Simmons , a pesar de la falta de un operador de combinaciones de CJam, sí, es posible hacerlo mejor :)

-1 byte gracias a @ MartinBüttner.

Pruébalo en línea | Banco de pruebas

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

Estoy seguro de que alguien puede jugar mejor en CJam ... El problema principal es que no puedo ver una buena manera de obtener los subconjuntos para que use la mayoría de mis bytes. Esto genera el conjunto de potencia (utilizando una idea de Martin Büttner) y luego selecciona los elementos de longitud 2.

R , 41 bytes

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

Pruébalo en línea!

¡Me sorprendió no ver una respuesta R aquí!

Perl 5 -pa , 36 bytes

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

Pruébalo en línea!