20

สินค้าข้ามของสองเวกเตอร์สามมิติและเป็นที่ไม่ซ้ำกันเวกเตอร์ดังกล่าวว่า: $\vec a$ $\vec b$ $\vec c$

$\vec c$ เป็นมุมฉากทั้งและ $\vec a$ $\vec b$
ขนาดของเท่ากับพื้นที่ของรูปสี่เหลี่ยมด้านขนานที่เกิดขึ้นโดยและ $\vec c$ $\vec a$ $\vec b$
ทิศทางของ ,และในลำดับที่ปฏิบัติตามกฎขวามือ $\vec a$ $\vec b$ $\vec c$

มีสูตรเทียบเท่าสองสามอย่างสำหรับผลิตภัณฑ์ข้าม แต่มีสูตรหนึ่งดังต่อไปนี้:

\vec{a} \times \vec{b} = det [\begin{matrix} \vec{i} & \vec{j} & \vec{k} \\ a_{1} & a_{2} & a_{3} \\ b_{1} & b_{2} & b_{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 มิติสองตัวเขียนโปรแกรมหรือฟังก์ชั่นเต็มรูปแบบเพื่อค้นหาผลิตภัณฑ์ครอส Builtins ที่คำนวณผลิตภัณฑ์โดยเฉพาะจะไม่ได้รับอนุญาต

อินพุต

สองอาร์เรย์ของสามจำนวนจริงแต่ละตัว หากภาษาของคุณไม่มีอาร์เรย์ตัวเลขจะต้องถูกจัดกลุ่มเป็นสาม ทั้งสองเวกเตอร์จะมีขนาด $<2^{16}$ {16} โปรดทราบว่าผลิตภัณฑ์ไขว้นั้นไม่ใช่คำสั่ง ( $\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]

นี่คือรหัสกอล์ฟดังนั้นทางออกที่สั้นที่สุดในหน่วยไบต์ชนะ

_{Maltysen โพสต์ความท้าทายที่คล้ายกันแต่คำตอบไม่ดีและคำถามไม่ได้ถูกแก้ไข}

code-golf math linear-algebra

— lirtosiast
แหล่งที่มา

อินพุตสามารถใช้เป็นอาร์เรย์ 2 มิติได้หรือไม่

— Dennis

ใช่ตราบใดที่ 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 ไบต์)

ตกลงนี่เป็นเรื่องน่าอาย แต่ภาษาการจัดการอาเรย์ของ Jelly ไม่มีตัวในการหมุนอาเรย์จนกระทั่งตอนนี้ ด้วยบิวด์อินใหม่นี้เราสามารถบันทึกสองไบต์เพิ่มเติมได้

ṙ-×
ç_ç@ṙ-

วิธีนี้ใช้วิธีการจากคำตอบ J ของ @ AlexA . ลองออนไลน์!

มันทำงานอย่างไร

ṙ-×     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

— ประโยชน์ทับซ้อน

10

LISP, 128 122 ไบต์

Hi! นี่คือรหัสของฉัน:

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

ฉันรู้ว่ามันไม่ใช่วิธีแก้ปัญหาที่สั้นที่สุด แต่ก็ไม่มีใครให้ Lisp จนกระทั่งตอนนี้ :)

คัดลอกและวางรหัสต่อไปนี้ที่นี่เพื่อลอง!

(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

Dyalog APL ขนาด 12 ไบต์

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

ตามคำตอบ J ของ @ AlexA.และ (โดยบังเอิญ) เทียบเท่ากับการปรับปรุงของ @ 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

J, 27 14 ไบต์

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

นี่คือคำกริยา dyadic ที่ยอมรับอาร์เรย์ทางซ้ายและขวาและส่งคืนผลิตภัณฑ์ครอส

คำอธิบาย:

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

— อเล็กซ์เอ
แหล่งที่มา

@randomra มันยอดเยี่ยมขอบคุณ! ฉันไม่ใช่ผู้เชี่ยวชาญ J ดังนั้นฉันจึงยังคงหาวิธีทำงานได้ดี แต่ฉันมีความคิดทั่วไป

— Alex A.

บางคำชี้แจง: *2&|.เป็นทางแยกของทั้งสองคำกริยา: และ* 2&|.มันคูณอินพุตซ้ายโดยหมุนด้วย 2 อินพุตขวา ส้อมนี้จะถูกเก็บไว้ในvเมื่อเราเขียนv~มันจะเทียบเท่ากับ(*2&|.)~ที่~แลกเปลี่ยนพารามิเตอร์อินพุตซ้ายและขวาสำหรับส่วนที่วงเล็บ

— Randomra

@ randomra เอาล่ะนั่นทำให้รู้สึก ขอบคุณอีกครั้ง!

— Alex A.

6

C, 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 a2 a3 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ไม่ต้องการ{}

— ลบ

ไชโยอัพเดท

— calvinsykes

1

คุณสามารถแทนที่ & v [6-i] ด้วย v + 6-i นอกจากนี้คุณสามารถแทนที่เครื่องหมายอัฒภาคหลังจาก j = i% 3 และ k = (i + 1)% 3 ด้วยเครื่องหมายจุลภาคซึ่งทำให้ทุกอย่างหลังคำสั่งเดียวเพื่อให้คุณสามารถละเว้น {} สุดท้ายถ้าคุณกำหนดค่าเริ่มต้น i เป็น 1 สำหรับวินาทีสำหรับลูปคุณสามารถย้ายส่วนเพิ่มลงใน k = ++ i% 3 บันทึกวงเล็บสองอัน หากคุณไม่กังวลเกี่ยวกับคำเตือนและใช้เวอร์ชันที่เหมาะสมของ C คุณสามารถข้ามการรวมได้เช่นกัน

— เล่นแร่แปรธาตุ

ยอดเยี่ยมไชโย! คอมไพเลอร์ของฉันจะไม่ยอมรับการละเว้นของส่วนหัวดังนั้นฉันจึงติดกับรุ่นที่ฉันสามารถสร้างได้

— calvinsykes

4

Haskell, 41 ไบต์

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

ทางออกที่ตรงไปตรงมา

— XNOR
แหล่งที่มา

4

Bash + coreutils, 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

Pyth, 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 ไบต์โดยจัดเรียงแอปพลิเคชันใหม่เพื่ออนุญาตให้ใช้คำจำกัดความโดยปริยายแทนแลมบ์ดาท้องถิ่น น่าเสียดายที่โซลูชันนี้ใช้งานไม่ได้ใน oK และต้องการล่าม k5 อย่างเป็นทางการ จะต้องใช้คำของฉันสำหรับสิ่งนี้จนกว่าฉันจะแก้ไขข้อผิดพลาดใน oK:

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

Ruby , 49 ไบต์

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

ลองออนไลน์!

กลับมาหลังจาก 2 ปีฉันโกนออก 12 ไบต์โดยใช้วิธีการที่ Ruby ปฏิบัติต่อดัชนีอาเรย์เชิงลบ -1เป็นองค์ประกอบสุดท้ายของอาร์เรย์-2ที่สองที่ผ่านมา ฯลฯ

ทับทิม, 57

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

Python 73 73ไบต์

ขอบคุณ @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 คุณพูดถูก ฉันลืมแลมบ์ดาที่สามารถระบุว่าอาร์กิวเมนต์ควรเป็นอย่างไร

— TanMath

2

เยลลี่ 5 ไบต์

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

ṁ4ÆḊƝ

ลองออนไลน์!

นี่คือคำอธิบาย PDF ในกรณีที่เครื่องหมายSE ไม่สามารถจัดการได้

ผลิตภัณฑ์ข้ามในรูปแบบการวิเคราะห์

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

\vec{{โวลต์}_{1}} = x_{1} \cdot \vec{ผม} + Y_{1} \cdot \vec{J} + Z_{1} \cdot \vec{k}

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

\vec{{โวลต์}_{2}} = x_{2} \cdot \vec{ผม} + Y_{2} \cdot \vec{J} + Z_{2} \cdot \vec{k}

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

$Oxyz$

\vec{{โวลต์}_{1}} \times \vec{{โวลต์}_{2}} = (x_{1} \cdot \vec{ผม} + Y_{1} \cdot \vec{J} + Z_{1} \cdot \vec{k}) \times (x_{2} \cdot \vec{ผม} + Y_{2} \cdot \vec{J} + Z_{2} \cdot \vec{k})

$\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{J} = \vec{k}, \vec{ผม} \times \vec{k} = - \vec{J}, \vec{J} \times \vec{ผม} = - \vec{k}, \vec{J} \times \vec{k} = \vec{ผม}, \vec{k} \times \vec{ผม} = \vec{J}, \vec{k} \times \vec{J} = - \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{{โวลต์}_{1}} \times \vec{{โวลต์}_{2}} = (Y_{1} Z_{2} - Z_{1} Y_{2}) \cdot \vec{ผม} + (Z_{1} x_{2} - x_{1} Z_{2}) \cdot \vec{J} + (x_{1} Y_{2} - Y_{1} x_{2}) \cdot \vec{k}

$\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}}$

ความสัมพันธ์ใกล้ชิดกับปัจจัยเมทริกซ์

มีสิ่งที่น่าสนใจที่ควรทราบที่นี่:

x_{1} Y_{2} - Y_{1} x_{2} = | \begin{matrix} x_{1} & Y_{1} \\ x_{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} x_{2} - x_{1} Z_{2} = | \begin{matrix} Z_{1} & x_{1} \\ Z_{2} & x_{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} x_{1} & Y_{1} & Z_{1} & x_{1} \\ x_{2} & Y_{2} & Z_{2} & x_{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 เท่านั้น

2

ภาษา Wolfram (Mathematica) , 38 33 ไบต์

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

ลองออนไลน์!

— alephalpha
แหล่งที่มา

1

ES6, 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

Julia 0.7 , 45 39 bytes

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

ลองออนไลน์!

ใช้สูตรตามดีเทอร์มิแนนต์ที่กำหนดไว้ในคำอธิบายงาน

ขอบคุณ H.PWiz สำหรับ -6 ไบต์

— คิริลล์แอล
แหล่งที่มา

39 bytes ด้วยสองเทคนิค:f(a,b)=1:3 .|>i->det([eye(3)[i,:] a b])

— H.PWiz

0

APL (NARS), 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

Pari / GP , 41 ไบต์

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

ลองออนไลน์!

— alephalpha
แหล่งที่มา

ค้นหาผลิตภัณฑ์ข้าม

ท้าทาย

อินพุต

เอาท์พุต

กรณีทดสอบ

เยลลี่, 14 13 12 ไบต์

มันทำงานอย่างไร

รุ่นที่ไม่ใช่คู่แข่ง (10 ไบต์)

มันทำงานอย่างไร

LISP, 128 122 ไบต์

Dyalog APL ขนาด 12 ไบต์

มันทำงานอย่างไร

J, 27 14 ไบต์

C, 156 154 150 148 144 ไบต์

Haskell, 41 ไบต์

Bash + coreutils, 51

MATL , 17 ไบต์

คำอธิบาย

Pyth, 16 ไบต์

คำอธิบาย:

K5, 44 40 37 32 ไบต์

แก้ไข 1:

แก้ไข 2:

แก้ไข 3:

Ruby , 49 ไบต์

ทับทิม, 57

Python 73 73ไบต์

เยลลี่ 5 ไบต์

ผลิตภัณฑ์ข้ามในรูปแบบการวิเคราะห์

ความสัมพันธ์ใกล้ชิดกับปัจจัยเมทริกซ์

คำอธิบายรหัสเยลลี่

ภาษา Wolfram (Mathematica) , 38 33 ไบต์

ES6, 40 ไบต์

Julia 0.7 , 45 39 bytes

APL (NARS), 23 ตัวอักษร, 46 ไบต์

Pari / GP , 41 ไบต์