एक नामित फ़ंक्शन या प्रोग्राम लिखें जो दो चतुर्भुज के चतुर्धातुक उत्पाद की गणना करता है। जितना संभव हो उतना कम बाइट्स का उपयोग करें।

quaternions

क्वाटरनियन वास्तविक संख्याओं का एक विस्तार है जो जटिल संख्याओं को और बढ़ाता है। एक एकल काल्पनिक इकाई के बजाय i, चतुर्भुज तीन काल्पनिक इकाइयों का उपयोग करते हैं i,j,kजो रिश्तों को संतुष्ट करते हैं।

i*i = j*j = k*k = -1
i*j =  k
j*i = -k
j*k =  i
k*j = -i
k*i =  j
i*k = -j

( विकिपीडिया पृष्ठ पर इनमें से तालिकाएँ भी हैं ।)

शब्दों में, प्रत्येक काल्पनिक इकाई का वर्ग है -1, और दो अलग-अलग काल्पनिक इकाइयों का उत्पाद शेष तीसरा है, जो +/-इस बात पर निर्भर करता है कि चक्रीय आदेश (i,j,k)का सम्मान किया जाता है (यानी, दाएं हाथ से शासन )। तो, गुणा का क्रम मायने रखता है।

एक सामान्य चतुर्धातुक एक वास्तविक भाग और तीन काल्पनिक इकाइयों का एक रैखिक संयोजन है। तो, यह चार वास्तविक संख्याओं द्वारा वर्णित है (a,b,c,d)।

x = a + b*i + c*j + d*k

इसलिए, हम वितरण प्रणाली का उपयोग करके दो चतुर्धातुक गुणा कर सकते हैं, सही क्रम में इकाइयों को गुणा करने के लिए सावधान रहें, और परिणाम में शर्तों की तरह समूहीकरण करें।

(a + b*i + c*j + d*k) * (e + f*i + g*j + h*k)
= (a*e - b*f - c*g - d*h)    +
  (a*f + b*e + c*h - d*g)*i  +
  (a*g - b*h + c*e + d*f)*j  +
  (a*h + b*g - c*f + d*e)*k

इस तरह से, चतुर्भुज गुणन को 4-ट्यूपल्स की एक जोड़ी से एक एकल 4-ट्यूपल्स के मानचित्र के रूप में देखा जा सकता है, जिसे आप लागू करने के लिए कहते हैं।

स्वरूप

आपको एक प्रोग्राम या नामांकित फ़ंक्शन लिखना चाहिए । एक प्रोग्राम को एसटीडीआईएन से इनपुट लेना चाहिए और परिणाम का प्रिंट आउट लेना चाहिए। एक फ़ंक्शन को फ़ंक्शन इनपुट में लेना चाहिए और एक आउटपुट को वापस करना चाहिए (प्रिंट नहीं करना चाहिए)।

इनपुट और आउटपुट प्रारूप लचीले हैं। इनपुट आठ वास्तविक संख्याएं हैं (दो बटेरों के लिए गुणांक), और आउटपुट में चार वास्तविक संख्याएं हैं। इनपुट आठ नंबर, चार नंबर की दो सूची, एक 2x4 मैट्रिक्स, आदि हो सकता है। इनपुट / आउटपुट प्रारूप में समान नहीं होना चाहिए। (1,i,j,k)गुणांकों का क्रम आपके ऊपर है।

गुणांक नकारात्मक या गैर-संपूर्ण हो सकता है। वास्तविक सटीकता या अति-चिंता के बारे में चिंता न करें।

प्रतिबंधित: विशेष रूप से quaternions या समकक्षों के लिए फ़ंक्शन या प्रकार।

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

ये (1,i,j,k)गुणांक प्रारूप में हैं।

[[12, 54, -2, 23], [1, 4, 6, -2]] 
 [-146, -32, 270, 331]

[[1, 4, 6, -2], [12, 54, -2, 23]] 
 [-146, 236, -130, -333]

[[3.5, 4.6, -0.24, 0], [2.1, -3, -4.3, -12]] 
 [20.118, 2.04, 39.646, -62.5]

संदर्भ कार्यान्वयन

पायथन में, फ़ंक्शन के रूप में:

#Input quaternions: [a,b,c,d], [e,f,g,h]
#Coeff order: [1,i,j,k]

def mult(a,b,c,d,e,f,g,h):
    coeff_1 = a*e-b*f-c*g-d*h
    coeff_i = a*f+b*e+c*h-d*g
    coeff_j = a*g-b*h+c*e+d*f
    coeff_k = a*h+b*g-c*f+d*e

    result = [coeff_1, coeff_i, coeff_j, coeff_k]
    return result

code-golf math complex-numbers

— XNOR
स्रोत

4

CJam, 49 45 39 बाइट्स

"cM-^\M-^G-^^KM-zP"256bGbq~m*f{=:*}4/{:-W*}/W*]`

ऊपर कोड और एम संकेतन का उपयोग करता है, क्योंकि कोड में अनपेक्षित वर्ण हैं।

दो अतिरिक्त बाइट्स की कीमत पर, उन पात्रों से बचा जा सकता है:

6Z9C8 7YDXE4BFA5U]q~m*f{=:*}4/{:-W*}/W*]`

आप इस संस्करण को ऑनलाइन आज़मा सकते हैं: सीजेएम दुभाषिया

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

गणना करने के लिए (a + bi + cj + dk) * (e + fi + gj + hk), निम्नलिखित इनपुट का उपयोग करें:

[ d c b a ] [ h g f e ]

आउटपुट होगा

[ z y x w ]

जो चतुष्कोण से मेल खाती है w + xi + yj + zk।

$ base64 -d > product.cjam <<< ImOchy0eS/pQIjI1NmJHYnF+bSpmez06Kn00L3s6LVcqfS9XKl1g
$ wc -c product.cjam
39 product.cjam
$ LANG=en_US cjam product.cjam <<< "[23 -2 54 12] [-2 6 4 1]"; echo
[331 270 -32 -146]
$ LANG=en_US cjam product.cjam <<< "[-2 6 4 1] [23 -2 54 12]"; echo
[-333 -130 236 -146]
$ LANG=en_US cjam product.cjam <<< "[0 -0.24 4.6 3.5] [-12 -4.3 -3 2.1]"; echo
[-62.5 39.646 2.04 20.118]

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

6Z9C8 7YDXE4BFA5U]  " Push the array [ 6 3 9 12 8 7 2 13 1 14 4 11 15 10 5 0].         ";
q~                  " Read from STDIN and interpret the input.                         ";
m*                  " Compute the cartesian product of the input arrays.               ";
f                   " Execute the following for each element of the first array:       ";
{                   " Push the cartesian product (implicit).                           ";
    =               " Retrieve the corresponding pair of coefficients.                 ";
    :*              " Calculate their product.                                         ";
}                   "                                                                  ";
4/                  " Split into chunks of 4 elements.                                 ";
{:-W*}/             " For each, subtract the first element from the sum of the others. ";
W*                  " Multiply the last integers (coefficient of 1) by -1.             ";
]`                  " Collect the results into an array and stringify it.              ";

— डेनिस
स्रोत

6

पायथन (83)

r=lambda A,B,R=range(4):[sum(A[m]*B[m^p]*(-1)**(14672>>p+4*m)for m in R)for p in R]

क्रम A,Bमें दो सूचियाँ लेता है [1,i,j,k]और एक ही प्रारूप में परिणाम देता है।

प्रमुख विचार यह है कि [1,i,j,k]सूचकांकों के अनुरूप [0,1,2,3], आपको XOR'ing सूचकांकों द्वारा उत्पाद का सूचकांक (साइन अप करने के लिए) मिलता है। इसलिए, जो शब्द इंडेक्स में रखे pजाते हैं, वे XOR को इंडिकेट करते हैं p, और इस प्रकार उत्पाद हैं A[m]*B[m^p]।

यह केवल संकेतों को काम करने के लिए बनी हुई है। मुझे जो सबसे छोटा रास्ता मिला वह था उन्हें बस एक जादुई स्ट्रिंग में कोडित करना। के लिए 16 संभावनाओं (m,p)संख्या में बदल रहे हैं 0करने के लिए 15के रूप में p+4*m। 14672बाइनरी की संख्या 1उन स्थानों पर है जहां -1संकेतों की आवश्यकता होती है। इसे उचित स्थान पर स्थानांतरित करके, 1या 0अंतिम अंक में हवाएं, संख्या को विषम या समान बनाती हैं, और इसलिए या (-1)**तो 1या -1आवश्यकतानुसार होती है।

— XNOR
स्रोत

XOR भाग शुद्ध प्रतिभा है।

— डेनिस

3

अजगर - 90 75 72 69

शुद्ध अजगर, कोई पुस्तकालय नहीं - 90:

m=lambda a,b,c,d,e,f,g,h:[a*e-b*f-c*g-d*h,a*f+b*e+c*h-d*g,a*g-b*h+c*e+d*f,a*h+b*g-c*f+d*e]

शायद पायथन में इस "डिफ़ॉल्ट" समाधान को छोटा करना बहुत कठिन है। लेकिन मैं बहुत उत्सुक हूं कि दूसरे क्या कर सकते हैं। :)

NumPy का उपयोग करना - ~~75 72~~ 69:

खैर, चूंकि इनपुट और आउटपुट अधिक लचीले हैं, हम कुछ न्यूमप फ़ंक्शन का उपयोग कर सकते हैं और स्केलर-वेक्टर प्रतिनिधित्व का फायदा उठा सकते हैं :

import numpy
m=lambda s,p,t,q:[s*t-sum(p*q),s*q+t*p+numpy.cross(p,q)]

इनपुट तर्क sऔर tदो चतुर्भुज (वास्तविक भाग) के अदिश भाग हैं pऔर qये संबंधित वेक्टर भाग (काल्पनिक इकाइयाँ) हैं। आउटपुट एक सूची है जिसमें स्केलर भाग और परिणामी चतुर्धातुक का वेक्टर हिस्सा होता है, जिसे बाद में नुम्पी सरणी के रूप में दर्शाया जाता है।

सरल परीक्षण स्क्रिप्ट:

for i in range(5):
    a,b,c,d,e,f,g,h=np.random.randn(8)
    s,p,t,q=a, np.array([b, c, d]), e, np.array([f, g, h])
    print mult(a, b, c, d, e, f, g, h), "\n", m(s,p,t,q)

( mult(...)ओपी के संदर्भ कार्यान्वयन होने के नाते।)

आउटपुट:

[1.1564241702553644, 0.51859264077125156, 2.5839001110572792, 1.2010364098925583] 
[1.1564241702553644, array([ 0.51859264,  2.58390011,  1.20103641])]
[-1.8892934508324888, 1.5690229769129256, 3.5520713781125863, 1.455726589916204] 
[-1.889293450832489, array([ 1.56902298,  3.55207138,  1.45572659])]
[-0.72875976923685226, -0.69631848934167684, 0.77897519489219036, 1.4024428845608419] 
[-0.72875976923685226, array([-0.69631849,  0.77897519,  1.40244288])]
[-0.83690812141836401, -6.5476014589535243, 0.29693969165495304, 1.7810682337361325] 
[-0.8369081214183639, array([-6.54760146,  0.29693969,  1.78106823])]
[-1.1284033842268242, 1.4038096725834259, -0.12599103441714574, -0.5233468317643214] 
[-1.1284033842268244, array([ 1.40380967, -0.12599103, -0.52334683])]

— फ़ाल्को
स्रोत

2

हास्केल, 85

m a b c d e f g h=[a*e-b*f-c*g-d*h,a*f+b*e+c*h-d*g,a*g-b*h+c*e+d*f,a*h+b*g-c*f+d*e]

हास्केल में इसे भेजना हमें कुछ चार्ट बचाता है;)

— ThreeFx
स्रोत

2

गणितज्ञ 83 50

शायद और अधिक गोल्फ हो सकता है ..

p = Permutations;
f = #1.(Join[{{1, 1, 1, 1}}, p[{-1, 1, -1, 1}][[1 ;; 3]]] p[#2][[{1, 8, 17, 24}]]) &

रिक्त स्थान और newlines नहीं गिना और जरूरत नहीं है।

उपयोग:

f[{a,b,c,d},{e,f,g,h}]        (* => {x,w,y,z}   *)

EDIT यह कैसे काम करता है।

Mathematica फ़ंक्शन (दूसरा तर्क) के Permutationsसभी संभावित क्रमपरिवर्तन करता है #2। 24 क्रमपरिवर्तन रहे हैं, लेकिन हम केवल जरूरत है {e,f,g,h}, {f,e,h,g}, {g,h,e,f}, और {h,g,f,e}। ये पहले, 8 वें, 17 वें और 24 वें क्रमपरिवर्तन हैं। तो कोड

p[#2][[{1,8,17,24}]]

दूसरे तर्क के क्रमपरिवर्तन से इनका चयन करता है और उन्हें एक मैट्रिक्स के रूप में लौटाता है। लेकिन तब उनके पास अभी तक सही संकेत नहीं है। कोड p[{-1,1,-1,1}][[1;;3]]सही संकेत के साथ 3x4 मैट्रिक्स लौटाता है। हम इसका {1,1,1,1}उपयोग करके आगे बढ़ाते हैंJoin , और एक सामान्य गुणन करके ( Timesऔर जैसा कि यहाँ एक दूसरे के बाद लिखकर करते हैं) दो मैट्रिसेस के बीच मैथेमेटिका में एक तत्व-दर-तत्व गुणा बनाता है।

तो आखिरकार, का नतीजा

(Join[{{1, 1, 1, 1}}, p[{-1, 1, -1, 1}][[1 ;; 3]]] p[#2][[{1, 8, 17, 24}]])

मैट्रिक्स है

 e  f  g  h
-f  e -h  g
-g  h  e -f
-h -g  f  e

{a,b,c,d}(पहले तर्क #1) और पूर्व मैट्रिक्स के बीच एक मैट्रिक्स गुणा करना वांछित परिणाम देता है।

EDIT 2 शॉर्टर कोड

फाल्को के पायथन कोड से प्रेरित होकर, मैंने चतुर्भुज को एक स्केलर और एक वेक्टर भाग में विभाजित किया है, और Crossवेक्टर भागों के क्रॉस उत्पाद की गणना करने के लिए Mathematica के कमांड में निर्मित का उपयोग करता हूं :

f[a_, A_, b_, B_] := Join[{a*b - A.B}, a*B + b*A + Cross[A, B]]

उपयोग:

f[a,{b,c,d},e,{f,g,h}]        (* => {x,w,y,z}   *)

— freddieknets
स्रोत

क्या आप बता सकते हैं कि यह कैसे काम करता है? क्या हैं 1, 8, 17, 24?

— xnor

1

पायथन, 94

सबसे सीधा रास्ता बहुत लंबा नहीं है।

def m(a,b,c,d,e,f,g,h):return[a*e-b*f-c*g-d*h,a*f+b*e+c*h-d*g,a*g-b*h+c*e+d*f,a*h+b*g-c*f+d*e]

— फ्लोरियन एफ
स्रोत

1

जावास्क्रिप्ट ES6 - 86

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

— विलियम बारबोसा
स्रोत

1

लुआ - 99

क्यों ना।

_,a,b,c,d,e,f,g,h=unpack(arg)print(a*e-b*f-c*g-d*h,a*f+b*e+c*h-d*g,a*g-b*h+c*e+d*f,a*h+b*g-c*f+d*e)

लुआ का "अनपैक ()" एक तालिका के तत्वों को मुक्त करता है। तो तालिका 'arg' वह जगह है जहाँ सभी कमांड लाइन इनपुट संग्रहीत हैं (जिसमें arg[0]प्रोग्राम का फ़ाइल नाम है, यह छूट जाता है)।

— AndoDaan
स्रोत

1

पायथन, 58 56 वर्ण

m=lambda x,y,z,w:(x*z-y*(2*w.real-w),x*w+y*(2*z.real-z))

मैं इनपुट / आउटपुट फॉर्मेट विगेल रूम का बहुत उदार उपयोग करता हूं । इनपुट्स 4 जटिल संख्याएँ हैं, इस प्रकार इनकोडिंग:

x = a+b*i
y = c+d*i
z = e+f*i
w = g+h*i

यह एक समान प्रारूप में जटिल संख्याओं की एक जोड़ी का उत्पादन करता है, जोड़ी का पहला वास्तविक और iभाग को एन्कोड करता है, दूसरा भाग jऔर kभागों को एन्कोड करता है ।

इस काम को देखने के लिए, ध्यान दें कि पहला चतुर्भुज है x+y*jऔर दूसरा है z+w*j। बस मूल्यांकन करें (x+y*j)*(z+w*j)और महसूस करें कि j*t= conj(t)*jकिसी भी काल्पनिक संख्या के लिए t।

— कीथ रान्डेल
स्रोत

बहुत चालाक! क्या आप जानते हैं कि चतुर्भुज जटिल गुणांक वाले जटिल संख्याओं की तरह गुणा क्यों करते हैं, क्योंकि यह आपकी अभिव्यक्ति से दिखता है?

— xnor

कोई बात नहीं, मैं अब आपके स्पष्टीकरण से समझता हूं कि आंतरिक और बाहरी जटिल गुणांक की तरह कैसे iऔर jकार्य करते हैं। कितना आकर्षक है!

— xnor

यह मजेदार है कि कैसे कॉल्स आपके वर्णों के 2/5 से अधिक लेती हैं। मुझे लगता है कि आप प्रत्येक का उपयोग करके एक शेव कर सकते हैं (2*w.real-w)। abs(w)**2/wकाम करेगा लेकिन 0. शायद स्ट्रिंग प्रतिस्थापन के साथ निष्पादन भी इसके लायक होगा? `

— xnor

1

व्हिस्पर v2 , 396 बाइट्स

> 1
> 2
> 0
> 4
> Input
> Input
>> 6ᶠ2
>> 6ᵗ2
>> 7ⁿ3
>> 7ⁿ1
>> 10‖9
>> 8ⁿ3
>> 8ⁿ1
>> 13‖12
>> 7‖8
>> 11‖14
>> 8‖7
>> 14‖11
>> 15‖16
>> 19‖17
>> 20‖18
>> 4⋅5
>> L⋅R
>> Each 23 22 21
> [1,-1,-1,-1,1,1,1,-1,1,-1,1,1,1,1,-1,1]
>> Each 23 24 25
>> 26ᶠ4
>> 26ᵗ4
>> 28ᶠ4
> 8
>> 26ᵗ30
>> 31ᶠ4
>> 31ᵗ4
>> ∑27
>> ∑29
>> ∑32
>> ∑33
>> Output 34 35 36 37

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

फॉर्म में इनपुट लेता है

[a, b, c, d]
[e, f, g, h]

और आउटपुट के रूप में

w
x
y
z

$q = w + xi + yj + zk$

इस उत्तर का संरचना वृक्ष है:

इस उत्तर का एक अच्छा हिस्सा फुसफुसाते हुए दो मुख्य दोषों से आता है:

किसी सरणी को उलटने के लिए कोई फ़ंक्शन नहीं
कार्टेसियन उत्पाद की गणना में सेट का उपयोग

इसलिए, हम कोड को 3 खंडों में विभाजित कर सकते हैं।

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

हम स्पष्टता और संक्षिप्तता के लिए निम्नलिखित परिभाषाओं का उपयोग करेंगे:

q = a + b i + c j + d k

$q = a + bi + cj + dk$

p = e + f i + g j + h k

$p = e + fi + gj + hk$

r = w + x i + y j + z k, (q \cdot p = r)

$r = w + xi + yj + zk, \: (q \cdot p = r)$

A = [a, b, c, d]

$A = [a, b, c, d]$

B = [e, f, g, h]

$B = [e, f, g, h]$

C = [w, x, y, z]

$C = [w, x, y, z]$

$A$ $B$

पहला खंड अब तक का सबसे लंबा, पंक्ति 1 से पंक्ति 22 तक फैला है :

> 1
> 2
> 0
> 4
> Input
> Input
>> 6ᶠ2
>> 6ᵗ2
>> 7ⁿ3
>> 7ⁿ1
>> 10‖9
>> 8ⁿ3
>> 8ⁿ1
>> 13‖12
>> 7‖8
>> 11‖14
>> 8‖7
>> 14‖11
>> 15‖16
>> 19‖17
>> 20‖18
>> 4⋅5

$B$ $A$ $B$ $B$ $A$

B_{1} = [e, f, g, h]

$B_1 = [e, f, g, h]$

B_{2} = [f, e, h, g]

$B_2 = [f, e, h, g]$

B_{3} = [g, h, e, f]

$B_3 = [g, h, e, f]$

B_{4} = [h, g, f, e]

$B_4 = [h, g, f, e]$

$B$ $B$ $B$ $B_2$ $B_4$

>> 7ⁿ3
>> 7ⁿ1
>> 10‖9

$[f, e]$

>> 8ⁿ3
>> 8ⁿ1
>> 13‖12

$[h, g]$ $B_1, B_2, B_3$ $B_4$ $B_T$ $A_T$ $A$ $4$

A_{T} = [a, b, c, d, a, b, c, d, a, b, c, d, a, b, c, d]

$A_T = [a, b, c, d, a, b, c, d, a, b, c, d, a, b, c, d]$

B_{T} = [e, f, g, h, f, e, h, g, g, h, e, f, h, g, f, e]

$B_T = [e, f, g, h, f, e, h, g, g, h, e, f, h, g, f, e]$

$B_T$ $A_T$ $q \cdot p$

धारा 2: संकेत और उत्पाद

$A_T$ $B_T$ $q \cdot p$

> [1,-1,-1,-1,1,1,1,-1,1,-1,1,1,1,1,-1,1]

$S$ $A_T, B_T$ $S$ $[[a, e, 1], [b, f, -1], \dots, [e, f, -1], [d, e, 1]] \to D = [ae, -bf, \dots, -ef, de]$

खंड 3: विभाजन और अंतिम रकम।

$q \cdot p$ $q \cdot p$

> 4

$5$ $4$ $D$ $D$

— केर्ड सिक्काहिरिंग
स्रोत

गुणा चतुर्भुज

quaternions

स्वरूप

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

संदर्भ कार्यान्वयन

CJam, 49 45 39 बाइट्स

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

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

पायथन (83)

अजगर - 90 75 72 69

हास्केल, 85

गणितज्ञ 83 50

पायथन, 94

जावास्क्रिप्ट ES6 - 86

लुआ - 99

पायथन, 58 56 वर्ण

व्हिस्पर v2 , 396 बाइट्स

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

AAABBB

धारा 2: संकेत और उत्पाद

खंड 3: विभाजन और अंतिम रकम।

$A$ $B$