मल्टीप्लेयर टू इंटेगर पॉलिनॉमिअल्स

14

आपका कार्य दो एकल-चर पूर्णांक बहुपद अभिव्यक्तियों को लेना है और उन्हें उनके असम्बद्ध पहले-अवधि-प्रमुख बाएं-से-दाएं विस्तार ( द्विपद के मामले में AKA FOIL ) में गुणा करना है । शर्तों की तरह गठबंधन न करें या परिणाम को फिर से व्यवस्थित करें। विस्तार के बारे में अधिक स्पष्ट होने के लिए, पहले शब्द में पहले शब्द को दूसरे में हर शब्द से गुणा करें, और पहली अभिव्यक्ति में तब तक जारी रखें जब तक कि सभी शब्दों को अन्य सभी शब्दों से गुणा न किया गया हो। अभिव्यक्तियाँ एक सरलीकृत LaTeX संस्करण में दी जाएंगी।

प्रत्येक अभिव्यक्ति +(प्रत्येक पक्ष पर बिल्कुल एक स्थान के साथ) अलग-अलग शब्दों का एक क्रम होगा, प्रत्येक शब्द निम्नलिखित नियमित अभिव्यक्ति के अनुरूप होगा: (PCRE संकेतन)

-?\d+x\^\d+

सादे अंग्रेजी में, शब्द एक वैकल्पिक अग्रणी है -जिसके बाद एक या एक से अधिक अंक होते हैं xऔर एक नॉनगेटिव पूर्णांक शक्ति (के साथ ^)

एक पूर्ण अभिव्यक्ति का एक उदाहरण:

6x^3 + 1337x^2 + -4x^1 + 2x^0

जब LaTeX में प्लग किया जाता है, तो आपको 6 x 3 + 1337 x 2 + - 4 x 1 + 2 x 0 मिलते हैं6x3+1337x2+−4x1+2x0

आउटपुट को इस प्रारूप के अनुरूप होना चाहिए।

चूंकि कोष्ठक इस प्रारूप में घातांक को घेरते नहीं हैं, इसलिए LaTeX वास्तव में बहु अंकों के घातांक को गलत तरीके से प्रस्तुत करेगा। (उदाहरण के लिए 4x^3 + -2x^14 + 54x^28 + -4x^5प्रदान के रूप में 4x3+−2x14+54x28+−4x5 ) आप इस के लिए खाते की जरूरत नहीं है और आप कोष्ठक शामिल नहीं होना चाहिए अपने उत्पादन में।

उदाहरण परीक्षण मामले

5x^4
3x^23

15x^27

6x^2 + 7x^1 + -2x^0
1x^2 + -2x^3

6x^4 + -12x^5 + 7x^3 + -14x^4 + -2x^2 + 4x^3

3x^1 + 5x^2 + 2x^4 + 3x^0
3x^0

9x^1 + 15x^2 + 6x^4 + 9x^0

4x^3 + -2x^14 + 54x^28 + -4x^5
-0x^7

0x^10 + 0x^21 + 0x^35 + 0x^12

4x^3 + -2x^4 + 0x^255 + -4x^5
-3x^4 + 2x^2

-12x^7 + 8x^5 + 6x^8 + -4x^6 + 0x^259 + 0x^257 + 12x^9 + -8x^7

नियम और मान्यताएँ

  • आप मान सकते हैं कि सभी इनपुट इस सटीक प्रारूप के अनुरूप हैं। किसी अन्य प्रारूप के लिए व्यवहार इस चुनौती के उद्देश्यों के लिए अपरिभाषित है।
    • यह ध्यान दिया जाना चाहिए कि दो बहुपद में लेने की कोई भी विधि मान्य है, बशर्ते कि दोनों को उपरोक्त प्रारूप के अनुरूप स्ट्रिंग के रूप में पढ़ा जाए।
  • उत्पाद के विस्तार के अपेक्षित क्रम के कारण बहुपद का क्रम मायने रखता है।
  • −128127255
    • −16,25616,384510
  • आप मान सकते हैं कि प्रत्येक इनपुट बहुपद में 16 से अधिक शब्द नहीं हैं
    • इसलिए आपको आउटपुट में 256 शब्दों तक (न्यूनतम) समर्थन करना चाहिए
  • शून्य गुणांक के साथ शर्तों को छोड़ दिया जाना चाहिए, साथ ही साथ expors को ठीक से जोड़ा जा सकता है
  • इनपुट में ऋणात्मक शून्य की अनुमति है, लेकिन शब्दार्थ से सकारात्मक शून्य से अप्रभेद्य है। हमेशा सकारात्मक शून्य का उत्पादन करें। शून्य शब्दों को न छोड़ें।

हैप्पी गोल्फिंग! सौभाग्य!

code-golf  math  parsing 
— Beefster
स्रोत
1
— H.PWiz
2
@LuisfelipeDejesusMunoz मैं कल्पना नहीं। पार्सिंग चुनौती का एक अभिन्न हिस्सा है और ओपी कहता है - "यह ध्यान दिया जाना चाहिए कि दो बहुपद में लेने की कोई भी विधि मान्य है, बशर्ते कि दोनों को उपरोक्त प्रारूप के अनुरूप तार के रूप में पढ़ा जाए। " (जोर दिया)
— ग्यूसेप

जवाबों:

4

आर , 159 153 153 बाइट्स

function(P,Q,a=h(P),b=h(Q))paste0(b[1,]%o%a[1,],"x^",outer(b,a,"+")[2,,2,],collapse=" + ")
h=function(s,`/`=strsplit)sapply(el(s/" . ")/"x.",strtoi)

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

मैं वास्तव में उपयोग करना चाहता था outer, इसलिए लगभग निश्चित रूप से एक अधिक कुशल दृष्टिकोण है।

— ग्यूसेप
स्रोत
4

हास्केल , 131 122 बाइट्स

(%)=drop
f s=do(a,t)<-reads s;(i,u)<-reads$2%t;(a,i):f(3%u)
p!q=3%do(a,i)<-f p;(b,j)<-f q;" + "++shows(a*b)"x^"++show(i+j)

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

fएक स्ट्रिंग से एक बहुपद को पार करता है, !उनमें से दो को गुणा करता है और परिणाम को प्रारूपित करता है।

H.PWiz ने 9 बाइट्स बचाए। धन्यवाद!

Ungolfed

type Monomial = (Int, Int) -- a^i
type Polynomial = [Monomial]

parse :: String -> Polynomial
parse s = do (a, s')  <- reads s
             (i, s'') <- reads (drop 2 s')
             (a, i) : parse (drop 3 s'')

(!) :: String -> String -> String
p!q = drop 3 (concat terms)
  where terms    = [term (a*b) (i+j) | (a,i) <- p', (b,j) <- q']
        term a i = concat [" + ", show a, "x^", show i]
        p'       = parse p
        q'       = parse q
— लिन
स्रोत
— एच.पी.विज़
1
— H.PWiz
2

रूबी , 102 100 98 बाइट्स

->a,b{a.scan(w=/(.*?)x.(\d+)/).map{|x|b.scan(w).map{|y|(eval"[%s*(z=%s;%s),z+%s]"%y+=x)*"x^"}}*?+}

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

कैसे?

पहला कदम: दोनों बहुपदों से सभी संख्याएँ प्राप्त करें: scanसंख्याओं को जोड़ियों की एक सरणी के रूप में लौटाता है। फिर, 2 सूचियों का एक कार्टेशियन उत्पाद करें। अब हमारे पास सभी संख्याएं हैं जहां हमें उनकी आवश्यकता है, लेकिन फिर भी गलत क्रम में है।

उदाहरण: हम गुणा अगर 3x^4द्वारा -5x^2, हम नंबर प्राप्त के रूप में [["3","4"],["-5","2"]], पहला विचार ज़िप करने के लिए था और इस सूची समतल, और फिर अभिव्यक्ति के रूप में मूल्यांकन किया जाना में संख्या डाल [3*-5, 4+2]। वास्तव में, हमें संख्याओं को फिर से व्यवस्थित करने की आवश्यकता नहीं है, हम इसे अस्थायी चर का उपयोग करके अभिव्यक्ति के अंदर कर सकते हैं: अभिव्यक्ति बन जाती है [3*(z=4,-5),z+2]।

इन अभिव्यक्तियों का मूल्यांकन करने के बाद, हमें गुणांक और प्रतिपादक मिलते हैं, हमें उनका उपयोग करके जुड़ने की आवश्यकता होती है "x^", और फिर उपयोग करने वाले सभी तंतुओं से जुड़ते हैं "+"।

— जीबी
स्रोत
2

हास्केल, 124 121 बाइट्स

import Data.Lists
f!x=map f.splitOn x
z=read!"x^"!"+"
a#b=drop 3$do[u,v]<-z a;[p,q]<-z b;" + "++shows(u*p)"x^"++show(v+q)

नोट: TIO की कमी है Data.Lists, इसलिए मैं आयात करता हूं : Data.Lists.Splitऔर इसे ऑनलाइन आज़माता हूं !Data.List

संपादित करें: -3 बाइट्स @ लियन के लिए धन्यवाद।

— nimi
स्रोत
यह वास्तव में 123 बाइट्स है! f!x=map f.splitOn xऔर फिर z=read!"x^"!"+"एक बाइट बचाता है; अंतिम पंक्ति के लिए drop 3$do[u,v]<-z a;[p,q]<-z b;" + "++shows(u*p)"x^"++show(v+q)दो और बचाता है। 120 बाइट्स
— लिन
1
@Lynn: TIO संस्करण आयात करता Data.Listहै Data.Lists, इसलिए यह +1 बाइट है।
— निम्मी
1

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

import re
f=re.finditer
lambda a,b:' + '.join(' + '.join(`int(m.group(1))*int(n.group(1))`+'x^'+`int(m.group(2))+int(n.group(2))`for n in f('(-?\d+)x\^(\d+)',b))for m in f('(-?\d+)x\^(\d+)',a))

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

साइड नोट: पहली बार एक कोड गोल्फ चैलेंज कर रहा है, इसलिए क्षमा करें यदि प्रयास हाहा

— GotCubes
स्रोत
3
PPCG में आपका स्वागत है! मैं अजगर प्रोग्रामर के बहुत नहीं हूँ, लेकिन सुधार के लिए शायद कुछ जगह है। शायद आप पायथन में गोल्फिंग के लिए टिप्स या गोल्फिंग के लिए टिप्स <> सभी भाषाओं में पा सकते हैं ! आशा है कि आप यहां बिताए गए समय का आनंद लेंगे :-)
— Giuseppe
— बचाएं
1
161 बाइट्स के लिए कुछ त्वरित गोल्फिंग । हालांकि अन्य अजगर जवाबों को देखते हुए, re.finditerशायद सबसे छोटा दृष्टिकोण नहीं है
— जो किंग
1

रेटिना , 110 बाइट्स

\S\S+(?=.*\n(.+))
 $1#$&
|" + "L$v` (-?)(\d+)x.(\d+).*?#(-?)(\d+)x.(\d+)
$1$4$.($2*$5*)x^$.($3*_$6*
--|-(0)
$1

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

\S\S+(?=.*\n(.+))
 $1#$&

पहले इनपुट में प्रत्येक शब्द को एक #, दूसरे इनपुट की एक कॉपी और एक स्पेस के साथ प्रीफिक्स करें । इसका मतलब यह है कि दूसरे इनपुट की प्रतियों में सभी शर्तें एक स्थान से पहले हैं और पहले इनपुट में से कोई भी शब्द नहीं हैं।

|" + "L$v` (-?)(\d+)x.(\d+).*?#(-?)(\d+)x.(\d+)
$1$4$.($2*$5*)x^$.($3*_$6*

दूसरे इनपुट में शर्तों की सभी प्रतियों और पहले इनपुट से उनके संबंधित शब्द से मिलान करें। किसी भी -संकेत को मिलाएं , गुणांक को गुणा करें, और सूचक जोड़ें। अंत में स्ट्रिंग के साथ सभी परिणामी प्रतिस्थापन में शामिल हों  + ।

--|-(0)
$1

-एस के किसी भी जोड़े को हटा दें और कन्वर्ट -0करें 0।

— नील
स्रोत
1

SNOBOL4 (CSNOBOL4) , 192 176 बाइट्स

	P =INPUT
	Q =INPUT
	D =SPAN(-1234567890)
P	P D . K ARB D . W REM . P	:F(O)
	B =Q
B	B D . C ARB D . E REM . B	:F(P)
	O =O ' + ' K * C 'x^' W + E	:(B)
O	O ' + ' REM . OUTPUT
END

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

	P =INPUT				;* read P
	Q =INPUT				;* read Q
	D =SPAN(-1234567890)			;* save PATTERN for Digits (or a - sign); equivalent to [0-9\\-]+
P	P D . K ARB D . W REM . P	:F(O)	;* save the Koefficient and the poWer, saving the REMainder as P, or if no match, goto O
	B =Q					;* set B = Q
B	B D . C ARB D . E REM . B	:F(P)	;* save the Coefficient and the powEr, saving the REMainder as B, or if no match, goto P
	O =O ' + ' K * C 'x^' W + E	:(B)	;* accumulate the output
O	O ' + ' REM . OUTPUT			;* match ' + ' and OUTPUT the REMainder
END
— ग्यूसेप
स्रोत
1

सी # (विज़ुअल सी # इंटरएक्टिव कंपाइलर) , 192 190 बाइट्स

n=>m=>string.Join(g=" + ",from a in n.Split(g)from b in m.Split(g)select f(a.Split(p="x^")[0])*f(b.Split(p)[0])+p+(f(a.Split(p)[1])+f(b.Split(p)[1])));Func<string,int>f=int.Parse;string p,g;

क्वेरी सिंटैक्स विधि सिंटैक्स की तुलना में बाइट कम लगती है।

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

— अज्ञान का अवतार
स्रोत
प्रत्येक अभिव्यक्ति + (प्रत्येक पक्ष पर बिल्कुल एक स्थान के साथ) 190 बाइट्स
— एक्सपायर्ड डेटा
1

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

ṣ”+ṣ”xV$€)p/ZPSƭ€j⁾x^Ʋ€j“ +

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

पूरा कार्यक्रम। दो बहुपदों को दो तारों की सूची के रूप में लेता है।

स्पष्टीकरण (विस्तारित रूप)

ṣ”+ṣ”xV$€µ€p/ZPSƭ€j⁾x^Ʋ€j“ + ” Arguments: x
         µ                     Monadic chain.
          €                    Map the monadic link over the argument.
                               Note that this will "pop" the previous chain, so
                               it will really act as a link rather than a
                               sub-chain.
ṣ”+                             ṣ, right = '+'.
                                Split the left argument on each occurrence of
                                the right.
                                Note that strings in Jelly are lists of
                                single-character Python strings.
        €                       Map the monadic link over the argument.
       $                         Make a non-niladic monadic chain of at least
                                 two links.
   ṣ”x                            ṣ, right = 'x'.
                                  Split the left argument on each occurrence of
                                  the right.
      V                           Evaluate the argument as a niladic link.
            /                  Reduce the dyadic link over the argument.
           p                    Cartesian product of left and right arguments.
                       €       Map the monadic link over the argument.
                      Ʋ         Make a non-niladic monadic chain of at least
                                four links.
             Z                   Transpose the argument.
                 €               Map the monadic link over the argument.
                ƭ                 At the first call, call the first link. At the
                                  second call, call the second link. Rinse and
                                  repeat.
              P                    Product: ;1×/$
               S                   Sum: ;0+/$
                  j⁾x^           j, right = "x^".
                                 Put the right argument between the left one's
                                 elements and concatenate the result.
                        j“ + ” j, right = " + ".
                               Put the right argument between the left one's
                               elements and concatenate the result.

एलियासिंग

)के रूप में ही है µ€।
एक अनुगामी ”निहित है और छोड़ा जा सकता है।

कलन विधि

मान लें कि हमारे पास यह इनपुट है:

["6x^2 + 7x^1 + -2x^0", "1x^2 + -2x^3"]

पहली प्रक्रिया पार्सिंग है, जो दो बहुपदों में से प्रत्येक पर लागू होती है। चलो पहले एक को संभालते हैं "6x^2 + 7x^1 + -2x^0":

पहला चरण स्ट्रिंग को विभाजित करना है '+', ताकि शर्तों को अलग किया जा सके। इसका परिणाम यह होगा:

["6x^2 ", " 7x^1 ", " -2x^0"]

अगला चरण 'x'घातांक से गुणांक को अलग करने के लिए प्रत्येक स्ट्रिंग को विभाजित करना है। परिणाम यह है:

[["6", "^2 "], [" 7", "^1 "], [" -2", "^0"]]

वर्तमान में, ऐसा लगता है कि इन तारों में बहुत कचरा है, लेकिन यह कचरा वास्तव में महत्वहीन है। ये तार सभी का आंकलन निलादि जेली लिंक के रूप में किया जाएगा। सामान्य रूप से, रिक्त स्थान महत्वहीन हैं, क्योंकि वे संख्याओं के अंकों के बीच नहीं हैं। इसलिए हम नीचे का मूल्यांकन कर सकते हैं और अभी भी एक ही परिणाम प्राप्त कर सकते हैं:

[["6", "^2"], ["7", "^1"], ["-2", "^0"]]

^^0^^0^^20 XOR 2=20 XOR n=n। सभी घातांक पूर्णांक हैं, इसलिए हम ठीक हैं। इसलिए, उपरोक्त के बजाय इसका मूल्यांकन करने से परिणाम नहीं बदलेगा:

[["6", "2"], ["7", "1"], ["-2", "0"]]

ये रहा:

[[6, 2], [7, 1], [-2, 0]]

यह चरण भी परिवर्तित "-0"हो जाएगा 0।

चूंकि हम दोनों इनपुटों को पार्स कर रहे हैं, पार्सिंग के बाद परिणाम यह होने जा रहा है:

[[[6, 2], [7, 1], [-2, 0]], [[1, 2], [-2, 3]]]

पार्सिंग अब पूरी हो चुकी है। अगली प्रक्रिया गुणन है।

हम पहले इन दो सूचियों के कार्टेशियन उत्पाद लेते हैं:

[[[6, 2], [1, 2]], [[6, 2], [-2, 3]], [[7, 1], [1, 2]], [[7, 1], [-2, 3]], [[-2, 0], [1, 2]], [[-2, 0], [-2, 3]]]

कई जोड़े बनाये जाते हैं, प्रत्येक को बाईं सूची में से एक तत्व और दाएं से एक क्रम में। यह आउटपुट का इच्छित क्रम भी होता है। यह चुनौती वास्तव में हमें गुणात्मक वितरण को लागू करने के लिए कहती है, क्योंकि हमें इसके बाद परिणाम को आगे की प्रक्रिया नहीं करने के लिए कहा जाता है।

axcbxd=abxcxd=ab(xcxd)=(ab)xc+d[[6, 2], [-2, 3]]

हम पहले जोड़ी को स्थानांतरित करते हैं:

[[6, -2], [2, 3]]

हम फिर पहली जोड़ी का उत्पाद लेते हैं, और दूसरे का योग:

[-12, 5]

कोड का प्रासंगिक हिस्सा, PSƭ€वास्तव में प्रत्येक जोड़ी के लिए अपने काउंटर को रीसेट नहीं करता है, लेकिन, चूंकि वे जोड़े हैं, इसलिए इसकी आवश्यकता नहीं है।

हमारे पास सभी शर्तों को संभालते हुए:

[[6, 4], [-12, 5], [7, 3], [-14, 4], [-2, 2], [4, 3]]

यहां, गुणा किया जाता है, क्योंकि हमें शर्तों की तरह गठबंधन नहीं करना है। अंतिम प्रक्रिया प्रिटीफाइंग है।

हम पहली बार प्रत्येक जोड़ी के साथ जुड़ते हैं "x^":

[[6, 'x', '^', 4], [-12, 'x', '^', 5], [7, 'x', '^', 3], [-14, 'x', '^', 4], [-2, 'x', '^', 2], [4, 'x', '^', 3]]

फिर हम इस सूची में शामिल होते हैं " + ":

[6, 'x', '^', 4, ' ', '+', ' ', -12, 'x', '^', 5, ' ', '+', ' ', 7, 'x', '^', 3, ' ', '+', ' ', -14, 'x', '^', 4, ' ', '+', ' ', -2, 'x', '^', 2, ' ', '+', ' ', 4, 'x', '^', 3]

ध्यान दें कि हमें अभी भी सूची में नंबर कैसे मिले हैं, इसलिए यह वास्तव में एक स्ट्रिंग नहीं है। हालांकि, जेली की एक प्रक्रिया है, जिसे "स्ट्रिफ़िकेशन" कहा जाता है, परिणाम को प्रिंट करने के लिए एक कार्यक्रम के निष्पादन के अंत में सही तरीके से चलाया गया। गहराई 1 की सूची के लिए, यह वास्तव में प्रत्येक तत्व को अपने स्ट्रिंग प्रतिनिधित्व में परिवर्तित करता है और तारों को एक साथ जोड़ता है, इसलिए हमें वांछित आउटपुट मिलता है:

6x^4 + -12x^5 + 7x^3 + -14x^4 + -2x^2 + 4x^3
— आउटगोल्फ को एरिक करें
स्रोत
1

जावास्क्रिप्ट, 112 110 बाइट्स

मुझे एक ही लंबाई के साथ दो विकल्प मिले। करी सिंटैक्स के साथ कॉल करें:f(A)(B)

A=>B=>(P=x=>x.split`+`.map(x=>x.split`x^`))(A).flatMap(a=>P(B).map(b=>a[0]*b[0]+'x^'+(a[1]- -b[1]))).join` + `

कोड स्निपेट दिखाएं

A=>B=>(P=x=>x.split`+`.map(x=>x.split`x^`))(A).flatMap(([c,e])=>P(B).map(([C,E])=>c*C+'x^'+(e- -E))).join` + `

कोड स्निपेट दिखाएं

-2 बाइट्स ( लुइस ): splitसीमांकक के आसपास रिक्त स्थान निकालें ।

जावास्क्रिप्ट, 112 बाइट्स

का उपयोग कर String.prototype.matchAll।

A=>B=>(P=x=>[...x.matchAll(/(\S+)x.(\S+)/g)])(A).flatMap(a=>P(B).map(b=>a[1]*b[1]+'x^'+(a[2]- -b[2]))).join` + `

कोड स्निपेट दिखाएं

— darrylyeo
स्रोत
1
split' + ' => split'+'2 बाइट्स को बचाने के लिए
— लुइस फेलिप डी जेउस मुनोज़
— अज्ञानता का अवतार
@EmbodimentofIgnorance मेरा बुरा, मैं लुइस की टिप्पणी गलत। मैंने सोचा कि यह के बारे में था join।
— अरनुलद
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.