Các sản phẩm chéo của hai vectơ ba chiều và là độc đáo vector sao cho:$\vec a$$\vec b$$\vec c$

• $\vec c$ là trực giao cho cả và$\vec a$$\vec b$

• Độ lớn của bằng diện tích hình bình hành được tạo bởi và$\vec c$$\vec a$$\vec b$

• Các hướng của , và , theo thứ tự đó, tuân theo quy tắc bàn tay phải .$\vec a$$\vec b$$\vec c$

Có một vài công thức tương đương cho sản phẩm chéo, nhưng một công thức như sau:

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

trong đó $\vec i$ , $\vec j$ và $\vec k$ là các vectơ đơn vị ở các chiều thứ nhất, thứ hai và thứ ba.

Thử thách

Đưa ra hai vectơ 3D, viết chương trình hoặc hàm đầy đủ để tìm sản phẩm chéo của chúng. Nội dung tính toán cụ thể các sản phẩm chéo không được phép.

Đầu vào

Hai mảng gồm ba số thực mỗi số. Nếu ngôn ngữ của bạn không có mảng, các số vẫn phải được nhóm thành ba. Cả hai vectơ sẽ có độ lớn $<2^{16}$ . Lưu ý rằng sản phẩm chéo không hoạt động ( $\vec a\times\vec b=-\bigl(\vec b\times\vec a\bigr)$ ), vì vậy bạn nên có cách chỉ định đơn hàng.

Đầu ra

Sản phẩm chéo của họ, trong một định dạng hợp lý, với mỗi thành phần chính xác đến bốn con số có ý nghĩa hoặc $10^{-4}$ , tùy theo cái nào lỏng hơn. Ký hiệu khoa học là tùy chọn.

Các trường hợp thử nghiệm

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

Đây là môn đánh gôn , vì vậy giải pháp ngắn nhất tính bằng byte sẽ thắng.

_{Maltysen đã đăng một thử thách tương tự , nhưng phản hồi rất kém và câu hỏi không được chỉnh sửa.}

Thạch, 14 13 12 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

;"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).

Phiên bản không cạnh tranh (10 byte)

OK, điều này thật đáng xấu hổ, nhưng ngôn ngữ thao tác mảng Jelly không được tích hợp để xoay mảng cho đến bây giờ. Với sự tích hợp mới này, chúng ta có thể lưu hai byte bổ sung.

ṙ-×
ç_ç@ṙ-

Điều này sử dụng cách tiếp cận từ câu trả lời J của @ AlexA . Hãy thử trực tuyến!

Làm thế nào nó hoạt động

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

LISP, 128 122 byte

Chào! Đây là mã của tôi:

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

Tôi biết rằng đó không phải là giải pháp ngắn nhất, nhưng cho đến giờ vẫn chưa có ai cung cấp một cái trong Lisp :)

Sao chép và dán đoạn mã sau vào đây để thử!

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

APL Dyalog, 12 byte

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

Dựa trên câu trả lời J của @ AlexA. Và (trùng hợp) tương đương với sự cải thiện của @ Randomra trong phần bình luận của câu trả lời đó.

Dùng thử trực tuyến trên TryAPL .

Làm thế nào nó hoạt động

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

J, 27 14 byte

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

Đây là một động từ dyadic chấp nhận các mảng ở bên trái và bên phải và trả về sản phẩm chéo của chúng.

Giải trình:

         *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

Thí dụ:

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

Hãy thử nó ở đây

Đã lưu 13 byte nhờ Randomra!

C, 156 154 150 148 144 byte

#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]);}

Sẽ không giành được bất kỳ giải thưởng nào trong thời gian dài, nhưng nghĩ rằng dù sao tôi cũng sẽ đi.

• Đầu vào là danh sách các thành phần được phân tách bằng dòng mới hoặc không gian (ví dụ a1 a2 a3 b1 b2 b3), đầu ra được phân cách bằng dấu cách (ví dụ c1 c2 c3).
• Chu kỳ hoán vị các chỉ số của hai vectơ đầu vào để tính toán sản phẩm - mất ít ký tự hơn là viết ra các định thức!

Bản giới thiệu

Ung dung:

#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]);
}

Haskell, 41 byte

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

Một giải pháp đơn giản.

Bash + coreutils, 51

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

• Dòng 1 xây dựng một mở rộng cú đúp cung cấp cho sản phẩm cartesian của hai vectơ và đặt chúng vào các tham số vị trí.
• Dòng 2 trừ các điều khoản thích hợp; bckhông đánh giá số học đến độ chính xác cần thiết.

Đầu vào là hai danh sách được phân tách bằng dấu phẩy trên dòng lệnh. Đầu ra dưới dạng dòng phân tách dòng mới:

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

MATL , 17 byte

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

Đầu vào đầu tiên là a , thứ hai là b .

Hãy thử trực tuyến!

Giải trình

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

Bình thường, 16 byte

-VF*VM.<VLQ_BMS2

Dùng thử trực tuyến: Trình diễn

Giải trình:

-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

K5, 44 40 37 32 byte

Đã viết cái này khá lâu rồi và lại bị bẩn lần nữa .

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

Trong hành động:

 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

Chỉnh sửa 1:

Đã lưu 4 byte bằng cách lấy đầu vào làm danh sách danh sách thay vì hai đối số riêng biệt:

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

Chỉnh sửa 2:

Đã lưu 3 byte bằng cách tính toán bảng tra cứu với giải mã cơ sở:

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}

Chỉnh sửa 3:

Lưu 5 byte bằng cách sắp xếp lại ứng dụng để cho phép sử dụng định nghĩa ngầm thay vì lambda cục bộ. Thật không may, giải pháp này không còn hoạt động trong oK và cần có trình thông dịch k5 chính thức. Gonna phải lấy lời của tôi cho cái này cho đến khi tôi sửa lỗi trong 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}

Ruby , 49 byte

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

Hãy thử trực tuyến!

Trở về sau 2 năm, tôi đã loại bỏ 12 byte bằng cách sử dụng cách Ruby xử lý các chỉ số mảng âm. -1là phần tử cuối cùng của mảng, -2phần thứ hai cuối cùng, v.v.

Ruby, 57

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

Trong chương trình thử nghiệm

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

Python, 73 48 byte

Cảm ơn @FryAmTheEggman

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

Điều này dựa trên định nghĩa thành phần của sản phẩm chéo vector.

Hãy thử nó ở đây

Thạch , 5 byte

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

ṁ4ÆḊƝ

Hãy thử trực tuyến!

Dưới đây là một lời giải thích PDF trong trường hợp SE markdown không thể xử lý nó.

---

Sản phẩm chéo ở dạng phân tích

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

$$\boldsymbol{\vec{v_1}}=x_1\cdot \boldsymbol{\vec{i}}+y_1\cdot \boldsymbol{\vec{j}}+z_1\cdot\boldsymbol{\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$

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

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

Sau khi sắp xếp lại và tính toán cần thiết:

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

Mối quan hệ chặt chẽ với các yếu tố quyết định ma trận

Có một điều thú vị cần lưu ý ở đây:

$$x_1y_2-y_1x_2=\left|\begin{matrix}x_1 & y_1 \\\ x_2 & y_2\end{matrix}\right|$$ $$z_1x_2-x_1z_2=\left|\begin{matrix}z_1 & x_1 \\\ z_2 & x_2\end{matrix}\right|$$ $$y_1z_2-z_1y_2=\left|\begin{matrix}y_1 & z_1 \\\ y_2 & z_2\end{matrix}\right|$$

$\left|\cdot\right|$

Giải thích mã Jelly

Chà ... không có gì nhiều để giải thích ở đây. Nó chỉ tạo ra ma trận:

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

Và với mỗi cặp ma trận lân cận, nó tính toán xác định của ma trận được hình thành bằng cách nối hai ma trận.

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

Ngôn ngữ Wolfram (Mathicala) , 38 33 byte

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

Hãy thử trực tuyến!

ES6, 40 byte

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

44 byte nếu đầu vào cần phải là hai mảng:

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

52 byte cho phiên bản thú vị hơn:

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

Julia 0,7 , 45 39 byte

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

Hãy thử trực tuyến!

Sử dụng công thức dựa trên xác định được đưa ra trong mô tả nhiệm vụ.

Cảm ơn H.PWiz cho -6 byte.

APL (NARS), 23 ký tự, 46 byte

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

kiểm tra:

  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 

Pari / GP , 41 byte

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

Hãy thử trực tuyến!