वन्डरमोंडे निर्धारक

Question

nमानों के एक सदिश को देखते हुए (x1,x2,x3,...,xn)इसी वैंडमोंडे मैट्रिक्स के निर्धारक को लौटाते हैं ।

इस निर्धारक को इस प्रकार लिखा जा सकता है:

विवरण

आपके प्रोग्राम / फ़ंक्शन को किसी भी सुविधाजनक प्रारूप में फ़्लोटिंग पॉइंट नंबरों की एक सूची को स्वीकार करना होगा जो एक चर लंबाई की अनुमति देता है, और निर्दिष्ट निर्धारक को आउटपुट करता है।

आप मान सकते हैं कि इनपुट के साथ-साथ आउटपुट आपकी भाषा का समर्थन करने वाले मूल्यों की सीमा के भीतर है। यदि आप भाषा फ्लोटिंग पॉइंट नंबरों का समर्थन नहीं करते हैं, तो आप पूर्णांक मान सकते हैं।

कुछ परीक्षण मामले

ध्यान दें कि जब भी दो समान प्रविष्टियाँ होती हैं, तो निर्धारक भी 0वैन्डरमोंडे मैट्रिक्स में दो समान पंक्तियाँ होंगी । इस लापता टेस्टकेस को इंगित करने के लिए @randomra को धन्यवाद।

[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

Comments

क्या हम मान सकते हैं कि इनपुट कम से कम लंबाई 2 का है?

— PurkkaKoodari

@ Pietu1998 नहीं, पहला परीक्षण मामला देखें।

— एलेक्स ए।

महत्वपूर्ण परीक्षण मामला:: [1,2,2,3] => 0यदि कोड की xi-xiतुलना करके कोड आत्म-अंतर ( ) की जांच करता है, तो सरणी में दो समान तत्व 0।

— रैंडम

@randomra धन्यवाद, मैं उनमें से एक को शामिल करना पूरी तरह से भूल गया। जब भी दो प्रविष्टियाँ समान होती हैं, निर्धारक 0 होगा क्योंकि एक ही पंक्ति के दो गुना हैं।

— दोष

@flawr अपेक्षित आउटपुट आपके स्पेक्स से स्पष्ट था। मैंने परीक्षण मामले का सुझाव दिया ताकि समान संख्याओं के लिए तैयार किए गए उत्तर उनकी गलतियों को अधिक आसानी से नहीं पा सकें।

— यादृच्छिक

Answer 1

जेली, 6 बाइट्स

œc2IFP

œc2लंबाई के प्रतिस्थापन के बिना सभी संयोजनों को प्राप्त होता है। 2 Iउन जोड़ियों की अंतर सूची की गणना करता है, जैसे सूची बनाना [[1], [2], [3], ..., [1]]। हम Fलेटते हैं और रोजा रखते हैं P।

यहाँ यह कोशिश करो!

Answer 2

रूबी, 49 47 बाइट्स

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

यह एक लंबोतरा फ़ंक्शन है जो एक वास्तविक मूल्यवान, एक-आयामी सरणी को स्वीकार करता है और इनपुट के प्रकार के आधार पर एक फ्लोट या पूर्णांक लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें f.call(input)।

हम आकार 2 के सभी संयोजनों का उपयोग करके .combination(2)प्राप्त करते हैं और प्रत्येक जोड़ी का उपयोग करने के लिए मतभेद प्राप्त करते हैं .map {|a, b| b - a}। हम परिणामस्वरूप सरणी को एक स्ट्रिंग द्वारा अलग कर देते हैं *, फिर evalयह, जो उत्पाद लौटाता है। यदि इनपुट की लंबाई 1 है, तो यह होगा nil, जो रूबी में गलत है, इसलिए हम ||1इस स्थिति में 1 को वापस करने के लिए बस अंत में कर सकते हैं । ध्यान दें कि यह तब भी काम करता है जब उत्पाद 0 है क्योंकि रूबी में 0 जो भी कारण है।

सभी परीक्षण मामलों को ऑनलाइन सत्यापित करें

Doorknob के लिए धन्यवाद 2 बाइट्स सहेजे गए!

Answer 3

गणितज्ञ, 30 बाइट्स

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

यह एक अनाम फ़ंक्शन है।

मैथेमेटिका द्वारा विस्तारित, यह इसके बराबर है (1 ##1 & ) @@ Apply[#2 - #1 & , Subsets[#1, {2}], {1}] &। (थैंक्स टिप्स पेज) के 1##&लिए एक समतुल्य है Times, जो इनपुट लिस्ट के प्रत्येक अलग-अलग पेयर पर लागू होता है Subsets[list, {2}]। ध्यान दें कि Subsetsतत्वों की विशिष्टता के लिए जाँच नहीं करता है।

Answer 4

जे, 13 बाइट्स

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

यह एक मोनैडिक फ़ंक्शन है जो एक सरणी में लेता है और एक नंबर देता है। इसे इस तरह उपयोग करें:

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

व्याख्या

मैं स्पष्ट रूप से इनपुट सरणी से जुड़े वैंडमोंडे मैट्रिक्स का निर्माण करता हूं, और फिर इसके निर्धारक की गणना करता हूं।

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

Comments

मुझे लगा कि व्हाट्सएप जम्मू में गैर-महत्वपूर्ण था ...

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ निर्धारक एक विशेष मामला है जिसमें एक अलग स्थान की आवश्यकता होती है, क्योंकि .एक संशोधक चरित्र भी है। उसी के लिए :।

— झगरब

ओह! यह अच्छा है।

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ वास्तव में, मुझे लगता है कि वास्तव में यही जे अनकूल बनाता है। J का अर्थ है Jot, यानी एक डॉट या छोटी रिंग (APL ∘), जैसा कि J के साथ मजाक में है ... अविश्वसनीय रूप से अतिभारित .और :(जो फिर से नेत्रहीन दो स्टैक किए गए .s के रूप में है) J को पढ़ने के लिए कठिन बनाता है (मेरे लिए)। कितना अधिक जब डॉट्स के बगल में व्हाट्सएप अर्थ का निर्धारण करता है! जम्मू के .कंप्यूटिंग इतिहास के सभी में सबसे अतिभारित प्रतीक होना चाहिए: मैं 53 अलग अर्थ गिनती .(यदि आप के सभी गिनती 61 और 43 _9:के लिए 9:के विशिष्ट अर्थ) :। Yukk। ;-)

— Adám

@ N @ यह सोचने में मदद कर सकता है। अपने स्वयं के टोकन के रूप में; इस प्रकार, यह एक सफेद स्थान के बिना, दूसरे ऑपरेटर के लिए गलत हो सकता है। यदि J आपके लिए नहीं है, हालांकि, यह समझ में आता है।

— कॉनर ओ'ब्रायन

Answer 5

MATL , 9

!G-qZRQpp

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

यह सभी अंतरों के एक मैट्रिक्स की गणना करता है और फिर मुख्य विकर्ण के नीचे का हिस्सा रखता है, जिससे अन्य प्रविष्टियां होती हैं 1ताकि वे उत्पाद को प्रभावित न करें। निचला त्रिकोणीय फ़ंक्शन अवांछित तत्वों को बनाता है 0, नहीं 1। इसलिए हम घटाते हैं 1, निचले त्रिकोणीय भाग को लेते हैं, और 1वापस जोड़ते हैं। फिर हम सभी प्रविष्टियों का उत्पाद ले सकते हैं।

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

Comments

यह दुर्भाग्यपूर्ण है, लेकिन 2Xn!dpकेवल एकल मूल्यों के साथ काम करने लगता है जब मूल्य 2 से अधिक या उसके बराबर होता है ... मैंने इसे खुद जेली को पीटने की कोशिश करते हुए लिखा था: पी

— फ्रैमएग्मैनमैन

@FryAmTheEggman Awww। तुम सही हो। सर उठाने के लिए धन्यवाद!

— लुइस मेन्डो

हाँ, मुझे लगा कि समस्या थी। मैं एक रैपर जोड़ने की तरह कुछ करने की कोशिश कर रहा हूँ जब आप Xnएक चेक की तरह if size(arg) == [1,1] ...या कुछ और करने के लिए मिलता है। मैं स्रोत को देखने के लिए बहुत आलसी हूं, लेकिन (उम्मीद है) यह उतना मुश्किल नहीं होना चाहिए।

— FryAmTheEggman 21

@FryAmTheEggman वास्तव में मुझे यकीन नहीं है कि यह समस्या है (यही कारण है कि मैंने जल्दी से अपनी टिप्पणी संपादित की है)। यदि पहला इनपुट एक नंबर है तो दूसरा इनपुट होना चाहिए 1या 0फिर इससे कोई फ़र्क नहीं पड़ता अगर पहले इनपुट को एरे के रूप में या किसी नंबर के रूप में व्याख्या किया जाए। असली समस्या यह है, दूसरा इनपुट सरणी आकार से अधिक नहीं हो सकता। "1 तत्व में से 2 तत्वों को चुनने के कितने तरीके हैं"। इस मामले में सरणी / संख्या अंतर मायने रखता है: यदि पहला इनपुट एक सरणी रिटर्न [](खाली सरणी) है, यदि यह एक नंबर रिटर्न है 0। मुझे लगता है कि मैं वापस आ जाऊंगा [], क्योंकि फिर pदूसरी व्याख्या को मजबूर करता है

— जाऊंगा लुइस मेंडो

@FryAmTheEggman मुझे लगता है कि मैं फ़ंक्शन को दो संस्करणों में विभाजित करूंगा। एक बार फिर धन्यवाद!

— लुइस मेन्डो

Answer 6

पायथ, 15 13 12 11 बाइट्स

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

एक बाइट के लिए @FryAmTheEggman और @ Pietu1998 को धन्यवाद !

Comments

* एक खाली सरणी पर F वास्तव में 1. होना चाहिए

— lirtosiast

Answer 7

गणितज्ञ, 32 बाइट्स

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

मुझे आश्चर्य हुआ कि वैंडर्मोंडे सामान के लिए बिलिन नहीं मिला। शायद इसलिए क्योंकि इसे स्वयं करना बहुत आसान है।

यह एक स्पष्ट रूप से एक वीएम के पारगमन का निर्माण करता है और अपने निर्धारक को ले जाता है (जो मूल के समान ही है)। यह विधि मेरे द्वारा ज्ञात किसी भी सूत्र का उपयोग करने की तुलना में काफी कम है।

Answer 8

हास्केल, 34 बाइट्स

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

एक पुनरावर्ती समाधान। जब किसी नए तत्व hको सामने की ओर रखा जाता है, तो सूची के x-hप्रत्येक तत्व xके लिए गुणनफल को अभिव्यक्ति से गुणा किया जाता है । 1 बाइट के लिए ज़गरब को धन्यवाद।

Answer 9

मतलाब, 26 बाइट्स

(Noncompeting)

बिल्डरों का सीधा उपयोग। ध्यान दें कि (एक बार फिर) मैटलैब vanderवैंडर्मोंडे मैट्रिस बनाता है लेकिन पंक्तियों के क्रम के साथ फ़्लिप करता है।

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

Comments

क्यों नॉनकंपेटिंग?

— एलेक्स ए।

क्योंकि मैं वह हूं जिसने इस चुनौती को बनाया है, मैं सिर्फ यह प्रदान करना चाहता था ताकि लोग अपने स्वयं के उदाहरणों की कोशिश कर सकें।

— दोष

क्या पता नहीं है (फ़्लिप्ड पंक्तियाँ) = (-1) ^ n डिटेल (मूल)?

— hyPotenuser

जब भी आप दो कॉलम या पंक्तियों को स्विच करते हैं, तो मैं निश्चित रूप से निश्चित नहीं होता हूं।

— दोष

@hYPotenuser - n को n + 1 से बदलें। आप जो कुछ कर रहे हैं, वह एक मैट्रिक्स P से गुणा कर रहा है, जो नीचे से ऊपर की ओर जाने वाले तिरछे हिस्से को छोड़कर सभी शून्य है (इसलिए आप det (P * vander (v)) = det (P) det (vander) (v) चाहते हैं )))। पहले कॉलम के साथ या जो भी हो, आपको det (P) = (-1) ^ (n + 1) दिखाई देगा।

— बैटमैन

Answer 10

जंग, 86 बाइट्स

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

जंग, हमेशा की तरह क्रिया ...

स्पष्टीकरण बाद में आएगा (यह बहुत सीधा है, हालांकि)।

Answer 11

पर्ल, 38 41 बाइट्स

के लिए +1 शामिल करें -p

STDIN पर एक लाइन पर नंबर दें। इसलिए के रूप में चलाते हैं

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

डबल लूप पाने के लिए एक बुराई रेगेक्स का उपयोग करें:

vandermonde.pl:

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

Answer 12

जावास्क्रिप्ट (ईएस 6), 61 बाइट्स

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

मैंने एक सरणी समझने की कोशिश की (फ़ायरफ़ॉक्स 30-57) और यह 5 बाइट्स लंबा था:

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

बोरिंग नेस्टेड लूप शायद कम है।

Answer 13

हास्केल, 53 बाइट्स

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

उपयोग उदाहरण: f [1,2,4,8,16] -> 20321280।

सूचकांकों के माध्यम से jऔर iएक नेस्टेड लूप में जाएं और स्थिति jऔर तत्वों के अंतर की सूची बनाएंi । सूची में सभी तत्वों के उत्पाद बनाएं।

अन्य वेरिएंट जो थोड़े लंबे थे:

f x=product[last l-i|l<-scanl1(++)$pure<$>x,i<-init l], 54 बाइट्स

import Data.List;f i=product[y-x|[x,y]<-subsequences i], 55 बाइट्स

Answer 14

सीजेएम, 16 बाइट्स

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

ए सिमंस के पोस्ट के जवाब में , सीजेएम की एक संयोजन ऑपरेटर की कमी के बावजूद, हाँ बेहतर करना संभव है :)

-1 बाइट @ मार्टिनबटनर को धन्यवाद।

इसे ऑनलाइन आज़माएं | परीक्षण सूट

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

Answer 15

CJam, 32 बाइट्स

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

मुझे यकीन है कि कोई सीजेएम में इसे बेहतर कर सकता है ... मुख्य मुद्दा यह है कि मैं सबसे अच्छी तरह से सबसेट का उपयोग करने वाले सबसेट का सबसे अच्छा तरीका नहीं देख सकता। यह पावर सेट (मार्टिन ब्यूटनर द्वारा एक विचार का उपयोग करके) उत्पन्न करता है और फिर लंबाई -2 तत्वों का चयन करता है।

Answer 16

आर , 41 बाइट्स

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

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

मैं यहाँ एक आर उत्तर नहीं देखकर आश्चर्यचकित था!

Answer 17

पर्ल 5 -pa , 36 बाइट्स

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

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