20

उत्पाद पार दो तीन आयामी वैक्टर की और अद्वितीय वेक्टर है ऐसी है कि: $\vec a$ $\vec b$ $\vec c$

$\vec c$ दोनों के लिए एक orthogonal और $\vec a$ $\vec b$
की परिमाण और द्वारा निर्मित समांतर चतुर्भुज के क्षेत्रफल के बराबर होती है $\vec c$ $\vec a$ $\vec b$
उस क्रम में , , और की दिशाएँ , दाएँ हाथ के नियम का पालन करें । $\vec a$ $\vec b$ $\vec c$

क्रॉस उत्पाद के लिए कुछ समकक्ष सूत्र हैं, लेकिन एक इस प्रकार है:

\vec{ए} \times \vec{ख} = det [\begin{matrix} \vec{मैं} & \vec{जे} & \vec{क} \\ ए_{1} & ए_{2} & ए_{3} \\ ख_{1} & ख_{2} & ख_{3} \end{matrix}]

$\vec a\times\vec b=\det\begin{bmatrix}\vec i&\vec j&\vec k\\a_1&a_2&a_3\\b_1&b_2&b_3\end{bmatrix}$

जहां $\vec i$ , $\vec j$ , और $\vec k$ पहले, दूसरे और तीसरे आयाम में यूनिट वैक्टर हैं।

चुनौती

दो 3 डी वैक्टर को देखते हुए, उनके क्रॉस उत्पाद को खोजने के लिए एक पूर्ण कार्यक्रम या फ़ंक्शन लिखें। क्रॉस उत्पाद की गणना करने वाले बिल्डरों को विशेष रूप से अस्वीकृत कर दिया जाता है।

इनपुट

तीन वास्तविक संख्याओं में से दो सरणियाँ। यदि आपकी भाषा में सरणियाँ नहीं हैं, तो संख्याओं को अभी भी समूह में रखा जाना चाहिए। दोनों वैक्टर में परिमाण होगा $<2^{16}$ । ध्यान दें कि क्रॉस उत्पाद noncommutative है ( $\vec a\times\vec b=-\bigl(\vec b\times\vec a\bigr)$ ), इसलिए आपके पास ऑर्डर निर्दिष्ट करने का एक तरीका होना चाहिए।

उत्पादन

उनका क्रॉस उत्पाद, एक उचित प्रारूप में, प्रत्येक घटक के साथ चार महत्वपूर्ण आंकड़े या $10^{-4}$ सटीक है , जो भी शिथिल है। वैज्ञानिक संकेतन वैकल्पिक है।

परीक्षण के मामलों

[3, 1, 4], [1, 5, 9]
[-11, -23, 14]

[5, 0, -3], [-3, -2, -8]
[-6, 49, -10]

[0.95972, 0.25833, 0.22140],[0.93507, -0.80917, -0.99177]
[-0.077054, 1.158846, -1.018133]

[1024.28, -2316.39, 2567.14], [-2290.77, 1941.87, 712.09]
[-6.6345e+06, -6.6101e+06, -3.3173e+06]

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा समाधान है।

_{माल्टीसेन ने एक समान चुनौती पोस्ट की , लेकिन प्रतिक्रिया खराब थी और सवाल संपादित नहीं किया गया था।}

code-golf math linear-algebra

— lirtosiast
स्रोत

क्या इनपुट को 2D सरणी के रूप में लिया जा सकता है?

— डेनिस

हाँ, जब तक 2 बाहरी आयाम है।

— lirtosiast

14

जेली, 14 13 12 बाइट्स

;"s€2U×¥/ḅ-U

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

यह काम किस प्रकार करता है

;"s€2U×¥/ḅ-U Main link. Input: [a1, a2, a3], [b1, b2, b3]

;"           Concatenate each [x1, x2, x3] with itself.
             Yields [a1, a2, a3, a1, a2, a3], [b1, b2, b3, b1, b2, b3].
  s€2        Split each array into pairs.
             Yields [[a1, a2], [a3, a1], [a2, a3]], [[b1, b2], [b3, b1], [b2, b3]].
       ¥     Define a dyadic chain:
     U         Reverse the order of all arrays in the left argument.
      ×        Multiply both arguments, element by element.
        /    Reduce the 2D array of pairs by this chain.
             Reversing yields [a2, a1], [a1, a3], [a3, a2].
             Reducing yields [a2b1, a1b2], [a1b3, a3b1], [a3b2, a2b3].
         ḅ-  Convert each pair from base -1 to integer.
             This yields [a1b2 - a2b1, a3b1 - a1b3, a2b3 - a3b2]
           U Reverse the array.
             This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1] (cross product).

गैर-प्रतिस्पर्धात्मक संस्करण (10 बाइट्स)

ठीक है, यह शर्मनाक है, लेकिन सरणी हेरफेर भाषा जेली में अभी तक सरणी रोटेशन के लिए अंतर्निहित नहीं था। इस नए बिल्ट-इन के साथ, हम दो अतिरिक्त बाइट्स बचा सकते हैं।

ṙ-×
ç_ç@ṙ-

यह @ अलेक्सा के जे उत्तर से दृष्टिकोण का उपयोग करता है । इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ṙ-×     Helper link. Left input: x = [x1, x2, x3]. Right input: y = [y1, y2, y3].

ṙ-      Rotate x 1 unit to the right (actually, -1 units to the left).
        This yields [x3, x1, x2].
  ×     Multiply the result with y.
        This yields [x3y1, x1y2, x2y3].


ç_ç@ṙ-  Main link. Left input: a = [a1, a2, a3]. Right input: b = [b1, b2, b3].

ç       Call the helper link with arguments a and b.
        This yields [a3b1, a1b2, a2b3].
  ç@    Call the helper link with arguments b and a.
        This yields [b3a1, b1a2, b2a3].
_       Subtract the result to the right from the result to the left.
        This yields [a3b1 - a1b3, a1b2 - a2b1, a2b3 - a3b2].
    ṙ-  Rotate the result 1 unit to the right.
        This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1] (cross product).

— डेनिस
स्रोत

प्रत्येक जोड़ी को आधार -1 से परिवर्तित करें? वह सिर्फ बुराई है। +1

— ETHproductions

10

LISP, 128 122 बाइट्स

नमस्ते! यह मेरा कोड है:

(defmacro D(x y)`(list(*(cadr,x)(caddr,y))(*(caddr,x)(car,y))(*(car,x)(cadr,y))))(defun c(a b)(mapcar #'- (D a b)(D b a)))

मुझे पता है कि यह सबसे छोटा समाधान नहीं है, लेकिन किसी ने भी अब तक, लिस्प में एक प्रदान नहीं किया है :)

कॉपी करें और निम्नलिखित कोड पेस्ट यहाँ यह कोशिश करने के लिए!

(defmacro D(x y)`(list(*(cadr,x)(caddr,y))(*(caddr,x)(car,y))(*(car,x)(cadr,y))))(defun c(a b)(mapcar #'- (D a b)(D b a)))

(format T "Inputs: (3 1 4), (1 5 9)~%")
(format T "Result ~S~%~%" (c '(3 1 4) '(1 5 9)))

(format T "Inputs: (5 0 -3), (-3 -2 -8)~%")
(format T "Result ~S~%~%" (c '(5 0 -3) '(-3 -2 -8)))

(format T "Inputs: (0.95972 0.25833 0.22140), (0.93507 -0.80917 -0.99177)~%")
(format T "Result ~S~%" (c '(0.95972 0.25833 0.22140) '(0.93507 -0.80917 -0.99177)))

(format T "Inputs: (1024.28 -2316.39 2567.14), (-2290.77 1941.87 712.09)~%")
(format T "Result ~S~%" (c '(1024.28 -2316.39 2567.14) '(-2290.77 1941.87 712.09)))

— PieCot
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह एक महान जवाब है, +1। अच्छी तरह से एक ऐसी भाषा में जवाब देने के लिए किया जाता है जो जीतने वाली नहीं है, लेकिन फिर भी इसे लोड करने से रोकती है। अक्सर कोड-गोल्फ चुनौतियां उनके बीच की भाषाओं की तुलना में अधिक होती हैं!

— wizzwizz4

9

दिल्लोग एपीएल, 12 बाइट्स

2⌽p⍨-p←⊣×2⌽⊢

के आधार पर @ एलेक्सा। के जम्मू जवाब है कि इसका जवाब के टिप्पणी अनुभाग में @ randomra के सुधार के लिए और (संयोग) बराबर।

TryAPL पर इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

2⌽p⍨-p←⊣×2⌽⊢  Dyadic function.
              Left argument: a = [a1, a2, a3]. Right argument: b = [b1, b2, b3].

         2⌽⊢  Rotate b 2 units to the left. Yields [b3, b1, b2].
       ⊣×     Multiply the result by a. Yields [a1b3, a2b1, a3b2].
     p←       Save the tacit function to the right (NOT the result) in p.
  p⍨          Apply p to b and a (reversed). Yields [b1a3, b2a1, b3a2].
    -         Subtract the right result (p) from the left one (p⍨).
              This yields [a3b1 - a1b3, a1b2 - a2b1, a2b3 - a3b2].
2⌽            Rotate the result 2 units to the left.
              This yields [a2b3 - a3b2, a3b1 - a1b3, a1b2 - a2b1].

— डेनिस
स्रोत

9

जे, 27 14 बाइट्स

2|.v~-v=.*2&|.

यह एक डाईएडिक क्रिया है जो बाईं और दाईं ओर सरणियों को स्वीकार करती है और अपने क्रॉस उत्पाद को वापस करती है।

स्पष्टीकरण:

         *2&|.     NB. Dyadic verb: Left input * twice-rotated right input
      v=.          NB. Locally assign to v
   v~-             NB. Commute arguments, negate left
2|.                NB. Left rotate twice

उदाहरण:

    f =: 2|.v~-v=.*2&|.
    3 1 4 f 1 5 9
_11 _23 14

इसे यहाँ आज़माएँ

रैंडम के लिए 13 बाइट्स धन्यवाद!

— एलेक्स ए।
स्रोत

@randomra यह कमाल है, धन्यवाद! मैं कोई जे विशेषज्ञ नहीं हूं इसलिए मुझे अभी भी पता चल रहा है कि यह कैसे काम करता है लेकिन मेरे पास एक सामान्य विचार है।

— एलेक्स ए।

कुछ स्पष्टीकरण: *2&|.दो क्रियाओं का एक कांटा है: *और 2&|.। यह बाएं इनपुट को 2 दायें इनपुट से घुमाकर गुणा करता है। यह कांटा vतब संग्रहीत किया जाता है जब हम लिखते हैं v~, यह इसके बराबर होता है (*2&|.)~, जहां ~कोष्ठक भाग के लिए बाएं और दाएं इनपुट मापदंडों को स्वैप किया जाता है।

— 19

@rrrrara ठीक है, यह समझ में आता है। एक बार फिर धन्यवाद!

— एलेक्स ए।

6

सी, 156 154 150 148 144 बाइट्स

#include <stdio.h>
main(){float v[6];int i=7,j,k;for(;--i;)scanf("%f",v+6-i);for(i=1;i<4;)j=i%3,k=++i%3,printf("%f ",v[j]*v[k+3]-v[k]*v[j+3]);}

लंबाई के लिए कोई पुरस्कार नहीं जीता जा रहा है, लेकिन मुझे लगता है कि मैं वैसे भी जाऊंगा।

इनपुट घटकों की एक नई-या अंतरिक्ष-सीमांकित सूची है (अर्थात a1 a3 a1 b1 b2 b3), आउटपुट स्थान-सीमांकित (यानी c1 c2 c3) है।
उत्पाद की गणना करने के लिए दो इनपुट वैक्टर के सूचकांक को चक्रीय रूप से अनुमति देता है - निर्धारकों को लिखने की तुलना में कम वर्ण लेता है!

डेमो

Ungolfed:

#include <cstdio>
int main()
{
    float v[6];
    int i = 7, j, k;
    for (; --i; ) scanf("%f", v + 6 - 1);
    for (i = 1; i < 4; )
        j = i % 3,
        k = ++i % 3,
        printf("%f ", v[j] * v[k + 3] - v[k] * v[j + 3]);
}

— calvinsykes
स्रोत

1

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ स्टैक एक्सचेंज में आपका स्वागत है। यह एक महान जवाब है; अच्छी तरह से एक भाषा में जवाब देने के लिए किया जाता है जो गोल्फिंग भाषाओं को हरा नहीं पाएगी। +1।

— wizzwizz4

2

आपकी पहली forज़रूरत नहीं है{}

— हटा दिया

चीयर्स, अपडेट किया गया।

— कैल्विनसाइक

1

आप v + 6-i से & v [6-i] को बदल सकते हैं। इसके अलावा, आप अर्धविराम को j = i% 3 और k = (i + 1)% 3 के बाद अल्पविराम से बदल सकते हैं, जो एक कथन के बाद सब कुछ बनाता है ताकि आप {} को छोड़ सकें। अंत में, अगर आप लूप के लिए i को 1 के लिए इनिशियलाइज़ करते हैं, तो आप इंक्रीमेंट को k = ++ i% 3 में कोष्ठक की एक जोड़ी बचा सकते हैं। यदि आप चेतावनियों के बारे में चिंतित नहीं हैं और C के सही संस्करण का उपयोग करते हैं, तो आप इसे भी शामिल कर सकते हैं।

— Alchymist

भयानक, जयकार! मेरा संकलक हेडर की चूक को स्वीकार नहीं करेगा, इसलिए मैं एक ऐसे संस्करण के साथ फंस गया हूं जिसे मैं बनाने में सक्षम हूं।

— 21

4

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

x(a,b,c)(d,e,f)=(b*f-c*e,c*d-a*f,a*e-b*d)

एक सीधा समाधान।

— XNOR
स्रोत

4

बैश + कोरुटिल्स, 51

eval set {$1}*{$2}
bc<<<"scale=4;$6-$8;$7-$3;$2-$4"

लाइन 1 एक ब्रेस विस्तार का निर्माण करता है जो दो वैक्टर के कार्टेशियन उत्पाद देता है और उन्हें स्थितीय मापदंडों में सेट करता है।
पंक्ति 2 उपयुक्त शब्दों को घटाती है; bcआवश्यक सटीकता के लिए अंकगणितीय मूल्यांकन करता है।

इनपुट कमांड-लाइन पर दो अल्पविराम से अलग सूची के रूप में है। न्यूलाइन-सेपरेटेड लाइनों के रूप में आउटपुट:

$ ./crossprod.sh 0.95972,0.25833,0.22140 0.93507,-0.80917,-0.99177
-.07705
1.15884
-1.01812
$

— डिजिटल आघात
स्रोत

4

MATL , 17 बाइट्स

!*[6,7,2;8,3,4])d

पहले इनपुट है एक दूसरा है, ख ।

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

व्याख्या

!              % input b as a row array and transpose into a column array
*              % input a as a row array. Compute 3x3 matrix of pairwise products
[6,7,2;8,3,4]  % 2x3 matrix that picks elements from the former in column-major order
)              % apply index
d              % difference within each column

— लुइस मेंडो
स्रोत

4

पायथ, 16 बाइट्स

-VF*VM.<VLQ_BMS2

इसे ऑनलाइन आज़माएँ: प्रदर्शन

स्पष्टीकरण:

-VF*VM.<VLQ_BMS2   Q = input, pair of vectors [u, v]
              S2   creates the list [1, 2]
           _BM     transforms it to [[1, -1], [2, -2]]
      .<VLQ        rotate of the input vectors accordingly to the left:
                   [[u by 1, v by -1], [u by 2, v by -2]]
   *VM             vectorized multiplication for each of the vector-pairs
-VF                vectorized subtraction of the resulting two vectors

— Jakube
स्रोत

3

K5, 44 40 37 32 बाइट्स

यह एक बहुत पहले लिखा था और हाल ही में फिर से इसे बंद कर दिया ।

{{x[y]-x[|y]}[*/x@']'3 3\'5 6 1}

कार्रवाई में:

 cross: {{x[y]-x[|y]}[*/x@']'3 3\'5 6 1};

 cross (3 1 4;1 5 9)
-11 -23 14
 cross (0.95972 0.25833 0.22140;0.93507 -0.80917 -0.99177)
-7.705371e-2 1.158846 -1.018133

1 संपादित करें:

दो अलग-अलग तर्कों के बजाय सूचियों की सूची के रूप में इनपुट लेकर 4 बाइट्स सहेजे गए:

old: {m:{*/x@'y}(x;y);{m[x]-m[|x]}'(1 2;2 0;0 1)}
new: {m:{*/x@'y}x    ;{m[x]-m[|x]}'(1 2;2 0;0 1)}

2 संपादित करें:

बेस-डीकोड के साथ एक लुकअप तालिका की गणना करके 3 बाइट्स सहेजे गए:

old: {m:{*/x@'y}x;{m[x]-m[|x]}'(1 2;2 0;0 1)}
new: {m:{*/x@'y}x;{m[x]-m[|x]}'3 3\'5 6 1}

संपादित करें 3:

स्थानीय लैम्ब्डा के बजाय टैसिट परिभाषा का उपयोग करने की अनुमति देने के लिए आवेदन को पुन: व्यवस्थित करके 5 बाइट्स सहेजें। दुर्भाग्य से, यह समाधान अब ओके में काम नहीं करता है, और आधिकारिक k5 दुभाषिया की आवश्यकता है। जब तक मैं बग को ठीक नहीं कर लेता, तब तक मुझे इसके लिए अपना शब्द लेना होगा:

old: {m:{*/x@'y}x;{m[x]-m[|x]}'3 3\'5 6 1}
new: {{x[y]-x[|y]}[*/x@']     '3 3\'5 6 1}

— JohnE
स्रोत

3

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

->u,v{(0..2).map{|a|u[a-2]*v[a-1]-u[a-1]*v[a-2]}}

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

रूबी ने नकारात्मक सरणी सूचकांकों के साथ कैसे व्यवहार किया, इसका उपयोग करके मैंने 12 बाइट्स का मुंडन किया। -1सरणी का अंतिम तत्व, -2दूसरा अंतिम आदि है।

रूबी, ५ Rub

->u,v{(0..2).map{|a|u[b=(a+1)%3]*v[c=(a+2)%3]-u[c]*v[b]}}

परीक्षण कार्यक्रम में

f=->u,v{(0..2).map{|a|u[b=(a+1)%3]*v[c=(a+2)%3]-u[c]*v[b]}}

p f[[3, 1, 4], [1, 5, 9]]

p f[[5, 0, -3], [-3, -2, -8]]

p f[[0.95972, 0.25833, 0.22140],[0.93507, -0.80917, -0.99177]]

p f[[1024.28, -2316.39, 2567.14], [-2290.77, 1941.87, 712.09]]

— स्तर नदी सेंट
स्रोत

2

पायथन, 73 48 बाइट्स

धन्यवाद @FryAmTheEggman

lambda (a,b,c),(d,e,f):[b*f-c*e,c*d-a*f,a*e-b*d]

यह वेक्टर क्रॉस उत्पाद की घटक परिभाषा पर आधारित है।

इसे यहाँ आज़माएँ

— TanMath
स्रोत

lambda (a,b,c),(d,e,f):...बहुत कुछ बचाना चाहिए।

— FryAmTheEggman

@FryAmTheEggman आप सही हैं। मैं यह भूल गया कि मेमना यह बता सकता है कि तर्क कैसा होना चाहिए।

— तानमथ

2

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

$[[x_1,x_2],[y_1,y_2],[z_1,z_2]]$ Z

ṁ4ÆḊƝ

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

एसई मार्काडाउन इसे संभाल नहीं सकता मामले में एक पीडीएफ स्पष्टीकरण है।

विश्लेषणात्मक रूप में क्रॉस-उत्पाद

$(x_1,y_1,z_1)$ $\vec{v_1}$ $(x_2,y_2,z_2)$ $\vec{v_2}$

\vec{v_{1}} = {एक्स}_{1} \cdot \vec{मैं} + y_{1} \cdot \vec{जे} + z_{1} \cdot \vec{क}

$\boldsymbol{\vec{v_1}}=x_1\cdot \boldsymbol{\vec{i}}+y_1\cdot \boldsymbol{\vec{j}}+z_1\cdot\boldsymbol{\vec{k}}$

\vec{v_{2}} = {एक्स}_{2} \cdot \vec{मैं} + y_{2} \cdot \vec{जे} + z_{2} \cdot \vec{क}

$\boldsymbol{\vec{v_2}}=x_2\cdot \boldsymbol{\vec{i}}+y_2\cdot \boldsymbol{\vec{j}}+z_2\cdot\boldsymbol{\vec{k}}$

$Oxyz$

\vec{v_{1}} \times \vec{v_{2}} = ({एक्स}_{1} \cdot \vec{मैं} + y_{1} \cdot \vec{जे} + z_{1} \cdot \vec{क}) \times ({एक्स}_{2} \cdot \vec{मैं} + y_{2} \cdot \vec{जे} + z_{2} \cdot \vec{क})

$\boldsymbol{\vec{v_1}}\times \boldsymbol{\vec{v_2}}=\left(x_1\cdot \boldsymbol{\vec{i}}+y_1\cdot \boldsymbol{\vec{j}}+z_1\cdot\boldsymbol{\vec{k}}\right)\times\left(x_2\cdot \boldsymbol{\vec{i}}+y_2\cdot \boldsymbol{\vec{j}}+z_2\cdot\boldsymbol{\vec{k}}\right)$

\vec{मैं} \times \vec{जे} = \vec{क}, \vec{मैं} \times \vec{क} = - \vec{जे}, \vec{जे} \times \vec{मैं} = - \vec{क}, \vec{जे} \times \vec{क} = \vec{मैं}, \vec{क} \times \vec{मैं} = \vec{जे}, \vec{क} \times \vec{जे} = - \vec{मैं}

$\boldsymbol{\vec{i}}\times \boldsymbol{\vec{j}}=\boldsymbol{\vec{k}}, \:\: \boldsymbol{\vec{i}}\times \boldsymbol{\vec{k}}=-\boldsymbol{\vec{j}}, \:\: \boldsymbol{\vec{j}}\times \boldsymbol{\vec{i}}=-\boldsymbol{\vec{k}}, \:\: \boldsymbol{\vec{j}}\times \boldsymbol{\vec{k}}=\boldsymbol{\vec{i}}, \:\: \boldsymbol{\vec{k}}\times \boldsymbol{\vec{i}}=\boldsymbol{\vec{j}}, \:\: \boldsymbol{\vec{k}}\times \boldsymbol{\vec{j}}=-\boldsymbol{\vec{i}}$

आवश्यक व्यवस्था और गणना के बाद:

\vec{v_{1}} \times \vec{v_{2}} = (y_{1} z_{2} - z_{1} y_{2}) \cdot \vec{मैं} + (z_{1} {एक्स}_{2} - {एक्स}_{1} z_{2}) \cdot \vec{जे} + ({एक्स}_{1} y_{2} - y_{1} {एक्स}_{2}) \cdot \vec{क}

$\boldsymbol{\vec{v_1}}\times \boldsymbol{\vec{v_2}}=(y_1z_2-z_1y_2)\cdot \boldsymbol{\vec{i}}+(z_1x_2-x_1z_2)\cdot \boldsymbol{\vec{j}}+(x_1y_2-y_1x_2)\cdot \boldsymbol{\vec{k}}$

मैट्रिक्स निर्धारकों के साथ घनिष्ठ संबंध

यहां ध्यान देने योग्य बात है:

{एक्स}_{1} y_{2} - y_{1} {एक्स}_{2} = | \begin{matrix} {एक्स}_{1} & y_{1} \\ {एक्स}_{2} & y_{2} \end{matrix} |

$x_1y_2-y_1x_2=\left|\begin{matrix}x_1 & y_1 \\\ x_2 & y_2\end{matrix}\right|$

z_{1} {एक्स}_{2} - {एक्स}_{1} z_{2} = | \begin{matrix} z_{1} & {एक्स}_{1} \\ z_{2} & {एक्स}_{2} \end{matrix} |

$z_1x_2-x_1z_2=\left|\begin{matrix}z_1 & x_1 \\\ z_2 & x_2\end{matrix}\right|$

y_{1} z_{2} - z_{1} y_{2} = | \begin{matrix} y_{1} & z_{1} \\ y_{2} & z_{2} \end{matrix} |

$y_1z_2-z_1y_2=\left|\begin{matrix}y_1 & z_1 \\\ y_2 & z_2\end{matrix}\right|$

$\left|\cdot\right|$

जेली कोड स्पष्टीकरण

खैर ... यहाँ समझाने के लिए ज्यादा नहीं। यह सिर्फ मैट्रिक्स उत्पन्न करता है:

(\begin{matrix} {एक्स}_{1} & y_{1} & z_{1} & {एक्स}_{1} \\ {एक्स}_{2} & y_{2} & z_{2} & {एक्स}_{2} \end{matrix})

$\left(\begin{matrix}x_1 & y_1 & z_1 & x_1 \\\ x_2 & y_2 & z_2 & x_2\end{matrix}\right)$

और पड़ोसी मैट्रिसेस की प्रत्येक जोड़ी के लिए, यह दोनों को जोड़कर गठित मैट्रिक्स के निर्धारक की गणना करता है।

ṁ4ÆḊƝ – Monadic Link. Takes input as [[x1,x2],[y1,y2],[z1,z2]].
ṁ4    – Mold 4. Cycle the list up to length 4, reusing the elements if necessary.
        Generates [[x1,x2],[y1,y2],[z1,z2],[x1,x2]].
    Ɲ – For each pair of neighbours: [[x1,x2],[y1,y2]], [[y1,y2],[z1,z2]], [[z1,z2],[x1,x2]].
  ÆḊ  – Compute the determinant of those 2 paired together into a single matrix.

— श्री Xcoder
स्रोत

यहाँ समीकरणों में neater रूप: P

— ASCII-only

2

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 38 33 बाइट्स

Det@{a={i,j,k},##}~Coefficient~a&

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

— alephalpha
स्रोत

1

ईएस 6, 40 बाइट्स

(a,b,c,d,e,f)=>[b*f-c*e,c*d-a*f,a*e-b*d]

44 बाइट्स यदि इनपुट को दो एरे होने चाहिए:

([a,b,c],[d,e,f])=>[b*f-c*e,c*d-a*f,a*e-b*d]

अधिक दिलचस्प संस्करण के लिए 52 बाइट्स:

(a,b)=>a.map((_,i)=>a[x=++i%3]*b[y=++i%3]-a[y]*b[x])

— नील
स्रोत

1

जूलिया 0.7 , 45 39 बाइट्स

f(a,b)=1:3 .|>i->det([eye(3)[i,:] a b])

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

कार्य विवरण में दिए गए निर्धारक-आधारित सूत्र का उपयोग करता है।

H.PWiz -6 बाइट्स के लिए धन्यवाद।

— किरिल एल।
स्रोत

दो चाल के साथ 39 बाइट्स:f(a,b)=1:3 .|>i->det([eye(3)[i,:] a b])

— H.PWiz

0

एपीएल (एनएआरएस), 23 चार्ट, 46 बाइट्स

{((1⌽⍺)×5⌽⍵)-(5⌽⍺)×1⌽⍵}

परीक्षा:

  f←{((1⌽⍺)×5⌽⍵)-(5⌽⍺)×1⌽⍵}
  (3 1 4) f (1 5 9)
¯11 ¯23 14 
  (5 0 ¯3) f (¯3 ¯2 ¯8)
¯6 49 ¯10 
  (0.95972 0.25833 0.22140) f (0.93507 ¯0.80917 ¯0.99177)
¯0.0770537061 1.158846002 ¯1.018133265 
  (1024.28 ¯2316.39 2567.14) f (¯2290.77 1941.87 712.09)
¯6634530.307 ¯6610106.843 ¯3317298.117

— RosLuP
स्रोत

0

परी / जीपी , 41 बाइट्स

(a,b)->Vec(matdet(Mat([[x^2,x,1],a,b]~)))

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

— alephalpha
स्रोत

क्रॉस उत्पाद का पता लगाएं

चुनौती

इनपुट

उत्पादन

परीक्षण के मामलों

जेली, 14 13 12 बाइट्स

यह काम किस प्रकार करता है

गैर-प्रतिस्पर्धात्मक संस्करण (10 बाइट्स)

यह काम किस प्रकार करता है

LISP, 128 122 बाइट्स

दिल्लोग एपीएल, 12 बाइट्स

यह काम किस प्रकार करता है

जे, 27 14 बाइट्स

सी, 156 154 150 148 144 बाइट्स

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

बैश + कोरुटिल्स, 51

MATL , 17 बाइट्स

व्याख्या

पायथ, 16 बाइट्स

स्पष्टीकरण:

K5, 44 40 37 32 बाइट्स

1 संपादित करें:

2 संपादित करें:

संपादित करें 3:

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

रूबी, ५ Rub

पायथन, 73 48 बाइट्स

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

विश्लेषणात्मक रूप में क्रॉस-उत्पाद

मैट्रिक्स निर्धारकों के साथ घनिष्ठ संबंध

जेली कोड स्पष्टीकरण

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 38 33 बाइट्स

ईएस 6, 40 बाइट्स

जूलिया 0.7 , 45 39 बाइट्स

एपीएल (एनएआरएस), 23 चार्ट, 46 बाइट्स

परी / जीपी , 41 बाइट्स