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

31

मैं रात के खाने के लिए एक दोस्त के घर पर था और उन्होंने "प्राइम-फैक्टर वेक्टर स्पेस" के विचार का सुझाव दिया। इस स्पेस में पॉजिटिव पूर्णांक को एक वेक्टर के रूप में व्यक्त किया जाता है जैसे कि वेक्टर में n th एलिमेंट की संख्या n n प्राइम को विभाजित करता है। (ध्यान दें कि इसका मतलब है कि हमारे वैक्टर में अनंत संख्या में शब्द हैं।) उदाहरण के लिए 20 है

2 0 1 0 0 0 ...

क्योंकि इसका मुख्य कारक 2 * 2 * 5 है ।

चूंकि प्रधान गुणनखंड अद्वितीय है प्रत्येक संख्या एक वेक्टर से मेल खाती है।

हम उनकी प्रविष्टियाँ जोड़कर वैक्टरों को जोड़ सकते हैं। यह उन संख्याओं को गुणा करने के समान है, जिनसे वे जुड़े हैं। हम स्केलर गुणा भी कर सकते हैं, जो संबंधित संख्या को एक शक्ति में बढ़ाने के लिए समान है।

समस्या यह है कि यह स्थान वास्तव में एक सदिश स्थान नहीं है क्योंकि कोई उलटा नहीं है। यदि हम आगे बढ़ते हैं और व्युत्क्रम जोड़ते हैं और वेक्टर स्थान को बंद करते हैं तो हमारे पास अब वेक्टर के रूप में प्रत्येक सकारात्मक परिमेय संख्या को व्यक्त करने का एक तरीका है। यदि हम इस तथ्य को रखते हैं कि वेक्टर जोड़ गुणन का प्रतिनिधित्व करता है। फिर एक प्राकृतिक संख्या का व्युत्क्रम इसका पारस्परिक है।

उदाहरण के लिए संख्या 20 में वेक्टर था

2 0 1 0 0 0 ...

तो अंश 1/20 इसका विलोम है

-2 0 -1 0 0 0 ...

यदि हम 14/15 की तरह एक अंश से जुड़े वेक्टर को खोजना चाहते हैं तो हम 14 पाएंगे

1 0 0 1 0 0 ...

और 1/15

0 -1 -1 0 0 0 ...

और वेक्टर जोड़कर उन्हें गुणा करें

1 -1 -1 1 0 0 ...

अब जब हमारे पास एक सदिश स्थान है तो हम इसे एक आंतरिक उत्पाद देकर एक आंतरिक उत्पाद के रूप में बदल सकते हैं। ऐसा करने के लिए हम आंतरिक उत्पाद चोरी करते हैं जो वेक्टर रिक्त स्थान को शास्त्रीय रूप से दिया जाता है। दो वैक्टरों के आंतरिक उत्पाद को उनकी शर्तों के युग्मवाचक गुणन के योग के रूप में परिभाषित किया गया है। उदाहरण के लिए 20 · 14/15 की गणना निम्नानुसार की जाएगी

20    =  2  0  1  0  0  0 ...
14/15 =  1 -1 -1  1  0  0 ...
         2  0 -1  0  0  0 ...  -> 1

एक अन्य उदाहरण के रूप में उत्पाद 2/19 · 4/19

2/19 = 1 0 0 0 0 0 0 -1 0 0 0 ...
4/19 = 2 0 0 0 0 0 0 -1 0 0 0 ...
       2 0 0 0 0 0 0  1 0 0 0 ... -> 3

आपका कार्य इस डॉट उत्पाद को करने वाले प्रोग्राम को लागू करना है। इसे सकारात्मक पूर्णांक (अंश और हर) की एक जोड़ी के माध्यम से दो सकारात्मक परिमेय संख्याओं को लेना चाहिए या एक तर्कसंगत प्रकार (फ़्लोट्स की अनुमति नहीं है, क्योंकि वे परिशुद्धता और विभाजन के साथ समस्याएं पैदा करते हैं) और दो के डॉट उत्पाद का प्रतिनिधित्व करने वाले पूर्णांक का उत्पादन करना चाहिए। आदानों।

यह कोड-गोल्फ है इसलिए उत्तर बाइट्स में कम बाइट के साथ बेहतर स्कोर किए जाएंगे।

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

4 · 4 = 4
8 · 8 = 9
10 · 10 = 2
12 · 12 = 5
4 · 1/4 = -4
20 · 14/15 = 1
2/19 · 4/19 = 3
code-golf  math  number-theory  linear-algebra  factoring 
— गेहूं का जादूगर
स्रोत
एक वेक्टर में एक आयाम नहीं होता है, एक वेक्टर अंतरिक्ष करता है।
— जोनाथन फ्रेच
5
@JonathanFrech मुझे लगता है कि यह थोड़ा कठिन है, लेकिन मैंने बदलाव किया है।
— गेहूं जादूगर
"नेचुरल नंबर" को आम तौर पर 0 समाहित करने के लिए समझा जाता है, जो आपके सिस्टम में प्रतिनिधित्व नहीं करता है। और ये वैक्टर नहीं हैं। एक वेक्टर अंतरिक्ष एक क्षेत्र के ऊपर है, और यह एक रिंग के ऊपर है, जो इसे एक मॉड्यूल बना देगा। और यह पूर्णांकों से अलग स्थान नहीं है, यह एक अलग प्रतिनिधित्व के साथ एक ही स्थान है।
— संचित
6
@Accumulation "प्राकृतिक संख्या" एक अच्छी तरह से परिभाषित शब्द नहीं है, जो इस बात पर निर्भर करता है कि आप इसे पूछते हैं या इसमें शून्य नहीं हो सकता है। आप सही हैं कि मेरे प्रश्न में "स्केलर गुणन" एक समूह के बजाय एक मोनोड के साथ एक जी-सेट बनाता है, लेकिन प्रश्न को हल करने योग्य बनाने के लिए इसे सरल बनाया गया था। मुझे यकीन नहीं है कि आपकी अंतिम टिप्पणी क्या है, सुनिश्चित करें कि इसमें पूर्णांक के समान ही कार्डिनैलिटी है, लेकिन कार्रवाई वास्तव में है जो एक स्थान को परिभाषित करती है यह आकार नहीं है। शायद आपका मतलब कुछ और विशिष्ट है जो मुझे याद आ रहा है। यदि ऐसा है तो मुझे यह चर्चा जारी रखने में खुशी होगी (चैट में सबसे अच्छा हो सकता है)।
— गेहूं जादूगर
2
एक और शब्दावली नाइट-पिक: वेक्टर रिक्त स्थान आमतौर पर एक क्षेत्र से स्केलर गुणा करने के लिए फिर से बनाए जाते हैं, इसलिए केवल पूर्णांक का उपयोग करना पर्याप्त नहीं है। ऐसा इसलिए है क्योंकि हम चाहते हैं कि समानांतर वैक्टर एक-दूसरे के गुणक हों, न कि केवल कुछ एक समान। उदाहरण के लिए, $ 4 $ और $ 8 $ इस स्थान में समानांतर "वैक्टर" हैं (वे दोनों रूप (a, 0, 0, ...) हैं), लेकिन न तो कोई अदिश बहु (यानी पूर्णांक शक्ति) है अन्य। वहाँ वास्तव में कई अन्य शर्तें हैं, जिनका आप उपयोग कर सकते हैं, हालांकि, यह सामान्य रूप से लोगों को पता होगा। "पूर्णांक पर मुक्त मॉड्यूल" सबसे अच्छा मैं कर सकता हूं।
— आर्थर

जवाबों:

4

MATL , 12 बाइट्स

YF2:&Y)dwd*s

इनपुट एक सरणी है [num1 den1 num2 den2]।

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

उदाहरण इनपुट पर विचार करें [20 1 14 15]।

YF      % Implicit input: array of 4 numbers. Exponents of prime factorization.
        % Gives a matrix, where each row corresponds to one of the numbers in
        % the input array. Each row may contain zeros for non-present factors
        % STACK: [2 0 1 0
                  0 0 0 0
                  1 0 0 1
                  0 1 1 0]
2:&Y)   % Push a submatrix with the first two rows, then a submatrix with the
        % other two rows
        % STACK: [2 0 1 0
                  0 0 0 0],
                 [1 0 0 1
                  0 1 1 0]
d       % Consecutive difference(s) along each column
        % STACK: [2 0 1 0
                  0 0 0 0],
                 [-1 1 -1 1]
wd      % Swap, and do the same for the other submatrix
        % STACK: [-1 1 -1 1]
                 [-2 0 -1 0]
*       % Element-wise product
        % STACK: [2 0 -1 0]
s       % Sum. Implicit display
        % STACK: 1
— लुइस मेंडो
स्रोत
4

सी (जीसीसी) , 99 + 32 = 131 बाइट्स

  • एक कंपाइलर ध्वज का उपयोग करते हुए, 32 बाइट्स की आवश्यकता होती है -D=F(v,V,e)for(;v%p<1;V+=e)v/=p;।
T,p,A,C;f(a,b,c,d){T=0;for(p=2;a+b+c+d>4;p++){A=C=0;F(a,A,1)F(b,A,~0)F(c,C,1)F(d,C,~0)T+=A*C;}a=T;}

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

— जोनाथन फ्रेच
स्रोत
मुझे लगता है कि यह स्पष्ट रूप से निर्दिष्ट करना बेहतर है कि अतिरिक्त ध्वज -D=F(v,V,e)for(;v%p<1;V+=e)v/=p;(32 बाइट्स) का उपयोग किया जाता है (इसलिए 99 + 32 = 131); अन्यथा अकेले कोड का कोई मतलब नहीं है।
— बब्बलर
3

पायथन 2 , 110 बाइट्स

l=input()
p=t=2
while~-max(l):r=i=0;exec"while l[i]%p<1:l[i]/=p;r+=1j**i\ni+=1\n"*4;t+=r*r;p+=1
print t.imag/2

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

जैसे इनपुट लेता है [num1, num2, den1, den2]। दो युक्तियों के rलिए प्राइम के pलिए प्रविष्टियों को संग्रहीत करने के लिए , और कुल राशि के भीतर (r*r).imag/2अपने उत्पाद को निकालने के लिए एक जटिल संख्या का उपयोग करता है । जोड़ने के लिए चार इनपुट नंबरों के लिए वास्तविक या काल्पनिक भाग को बढ़ाने या घटाने का प्रत्येक संयोजन करता है।r.real*r.imagt1j**ii=0,1,2,3

बबलर ने शुरुआती मूल्यों को मिलाकर 2 बाइट्स बचाए p=t=2।

— XNOR
स्रोत
1
p=t=2के बजाय p=2;t=0के बाद से t.realवैसे भी नजरअंदाज कर दिया है ( TIO )।
— बुबलर
@ बब्बलर एक अच्छा, जोड़ना!
— xnor
1

जावास्क्रिप्ट (Node.js) , 104 ... 100 94 बाइट्स

F=(A,i=2)=>A.some(x=>x>1)&&([a,b,c,d]=A.map(G=(x,j)=>x%i?0:1+G(A[j]/=i,j)),a-b)*(c-d)+F(A,i+1)

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

[Num1, Den1, Num2, Den2] की एक सरणी के रूप में संख्याओं को पास करें।

F=कोई अतिरिक्त बाइट्स के साथ लापता को ठीक करने के लिए अरनौलड के लिए धन्यवाद , और 2 और बाइट्स कम।

स्पष्टीकरण और अपुष्ट

function F(A, i = 2) {                 // Main function, recursing from i = 2
 if (A.some(function(x) {              // If not all numbers became 1:
  return x > 1;
 })) {
  var B = A.map(G = function(x, j) {   // A recursion to calculate the multiplicity
   if (x % i)
    return 0;
   else
    return 1 + G(A[j] /= i, j);        // ...and strip off all powers of i
  });
  return (B[0] - B[1]) * (B[2] - B[3]) // Product at i
   + F(A, i + 1);                      // Proceed to next factor. All composite factors 
 }                                     // will be skipped effectively
 else 
  return 0;                            // Implied in the short-circuit &&
}
— शायरु असकोतो
स्रोत
1

जे , 19 बाइट्स

1#.*/@,:&([:-/_&q:)

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

स्पष्टीकरण:

एक रंग क्रिया, तर्क बाएं हाथ और दाहिने हाथ दोनों तरफ हैं

         &(        ) - for both arguments (which are lists of 2 integers)
               _&q:  - decompose each number to a list of prime exponents
           [:-/      - and find the difference of these lists
       ,:            - laminate the resulting lists for both args (to have the same length)
   */@               - multiply them
1#.                  - add up
— गैलेन इवानोव
स्रोत
1

स्टैक्स , 11 बाइट्स

ä÷ß½♂←√:=Ü]

इसे चलाएं और डीबग करें

इसी कार्यक्रम का संबंधित एएससीआई प्रतिनिधित्व है।

{|nmMFE-~-,*+

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

— पुनरावर्ती
स्रोत
1

पायथन 2 , 133 127 बाइट्स

a=input();s=0;p=2;P=lambda n,i=0:n%p and(n,i)or P(n/p,i+1)
while~-max(a):a,(w,x,y,z)=zip(*map(P,a));s+=(w-x)*(y-z);p+=1
print s

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

Xnor की सबमिशन से लूप की स्थिति चुरा ली ।

समारोह को एक कार्यक्रम में बदलने के लिए @mathmandan द्वारा सलाह के लिए धन्यवाद (हां, यह वास्तव में कुछ बाइट्स को बचाता है)।

अप्रचलित, गलत समाधान (124 बाइट्स):

lambda w,x,y,z:sum((P(w,p)-P(x,p))*(P(y,p)-P(z,p))for p in[2]+range(3,w+x+y+z,2))
P=lambda n,p,i=1:n%p and i or P(n/p,p,i+1)
— bubbler
स्रोत
क्या p9 जैसे गैर-प्रधान मूल्यों का परीक्षण नहीं किया जा रहा है?
— xnor
उफ़, मैं इसे जल्द ही ठीक कर दूंगा।
— बब्बलर
3
आप के returnसाथ बदल सकते हैं print, और आप इंडेंटेशन रिक्त स्थान भी बचा सकते हैं यदि आप एक फ़ंक्शन के बजाय एक प्रोग्राम के रूप में लिखते हैं।
— गणितमण्डल
@mathmandan जानकारी के लिए धन्यवाद। मेरे अन्य Py2 सबमिशन के लिए उपयोगी लगता है, Py3 के लिए निश्चित नहीं है (हालांकि यह अतिरिक्त लेता है eval()जब तक कि फ़ंक्शन इनपुट स्वयं एक स्ट्रिंग नहीं है)।
— बुबलर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.