परिचय

मनुष्य एक उल्लेखनीय प्रजाति है, लेकिन हम कभी-कभी समझने के लिए बहुत अजीब हो सकते हैं - विशेष रूप से कंप्यूटर के लिए। विशेष रूप से, हम बहुतायत से मनमाने नियमों के साथ बहुपत्नी शैली में बहुपद लिखना पसंद करते हैं।

सबसे छोटा कार्यक्रम क्या है जिसे आप इन नियमों का उपयोग करके एक बहुपद को सही ढंग से प्रारूपित करने के लिए लिख सकते हैं?

चुनौती

इनपुट

-1000 और 1000 (सम्मिलित) के बीच पूर्णांकों की एक सूची, एक बहुपद के गुणांक का प्रतिनिधित्व करती है, जिसमें अंतिम प्रविष्टि x ^ 0 (स्थिर) का गुणांक है, दूसरा अंतिम बार x 1, 1 का गुणांक है।

उत्पादन

मनुष्यों के सही ढंग से स्वरूपित गणितीय संकेतन में इस बहुपद का प्रतिनिधित्व करने वाला एक तार।

नियम:

अग्रणी गुणांक पर संकेत केवल तभी दिखाया जाता है जब यह नकारात्मक हो।

Right: -x^2+3

Wrong: +x^2+3

0 के गुणांक वाले घटक मुद्रित नहीं होते हैं (कोने के मामले को छोड़कर जहां सभी गुणांक 0 * हैं)।

Right: x^5-x^2+3

Wrong: x^5+0x^4+0x^3-x^2+0x+3

गुणांक -1और +11 के बिना प्रदर्शित किए जाते हैं, जब तक कि वे स्थिर न हों।

Right: x^5-x^2+1

Wrong: 1x^5-1x^2+1

घातांक केवल तभी दिखाया जाता है यदि यह 1 से अधिक है और चर केवल दिखाया गया है यदि घातांक 0 से अधिक है।

Right: 3x^3-7x^2+2x+1

Wrong: 3x^3-7x^2+2x^1+1x^0

* कॉर्नर केस: जबकि शून्य मान आमतौर पर उस घटक को प्रिंट नहीं करते हैं, यदि सभी गुणांक शून्य हैं स्थिर 0 को मुद्रित किया जाना चाहिए।

Right: 0

Wrong: 0x+0

Wrong: (nothing)

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

उदाहरण इनपुट और आउटपुट

Input:                  Output:
      [0]                      0
      [0,0]                    0
      [0,-1,35,0]             -x^2+35x
      [5,1,7,-9]               5x^3+x^2+7x-9
      [100,0,0,-1]             100x^3-1
      [931,21,-11,1]           931x^3+21x^2-11x+1

मैं आपके समाधान को देखने के लिए उत्सुक हूं। मज़े करो!

संपादित करें:

आप चाहें तो व्हाट्सएप द्वारा परिचालन को घेर सकते हैं। इसलिए 3x+5और 3x + 5दोनों ठीक हैं। 3x+ 5और 3x +5नहीं हैं।
यदि आप वास्तविक घातांक वर्ण (टेक्स में कहते हैं) का उत्पादन करना चाहते हैं, तो इसकी अनुमति दी जाती है क्योंकि यह मनुष्य के लिखने के करीब भी है।
गुणांक किसी भी दशमलव के बिना दिखाई देना चाहिए जैसे 9x^2कि सही है, 9.0x^2नहीं है।

code-golf polynomials

— ओइसिन मोरन
स्रोत

7

एक सवाल जो मुझे सैंडबॉक्स में पूछा जाना चाहिए था, लेकिन क्या हम ऑपरेटरों के बीच व्हाट्सएप से नहीं छाप सकते? तो 3x^2 + 4बनाम 3x^2+4?

— ग्यूसेप

1

क्या हमें करियर का उपयोग कर एक्सपोर्टर्स को आउटपुट करने की आवश्यकता है? या एक वास्तविक सुपरस्क्रिप्ट चरित्र का निर्माण करने की अनुमति दी जाएगी (जैसे TeX में एक उत्तर के लिए)?

— टटलमैन

3

@ केविनक्रूजसेन मैं ओपी नहीं हूं, लेकिन मैं यह नहीं कहूंगा, क्योंकि अधिकांश मनुष्य ऐसा नहीं लिखते हैं।

— श्रीवत्सआर

2

@ManishKundu हाँ सुनिश्चित करें कि आप स्ट्रिंग्स के रूप में इनपुट ले सकते हैं।

— Oisín Moran

1

@ OisínMoran कुछ भी नहीं कायरता, बस यह सुनिश्चित करना एक सरल 1x-> xप्रतिस्थापन में नहीं बदलता 21x^2है 2x^2।

— DLosc

10

रेटिना 0.8.2 , 56 बाइट्स

(?=( \S+)+)
x^$#1
\b0x.\d+ 

\b1x
x
x.1 
x 
 0

 -
-
 
+

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

(?=( \S+)+)
x^$#1

xसहित, x^1लेकिन नहीं की सभी शक्तियों को सम्मिलित करें x^0।

\b0x.\d+

xशून्य गुणांक वाली सभी शक्तियों को हटाएं , लेकिन अनुगामी 0(अभी तक) नहीं।

\b1x
x

का एक गुणक हटाएं 1(लेकिन स्थिर नहीं 1)।

x.1 
x

हटाएँ ^1की x^1।

एक निरंतर 0 हटाएं जब तक कि यह केवल एक चीज न रह जाए।

-
-

एक से पहले अंतरिक्ष को हटा दें -।

शेष स्थानों को बदल दें +।

— नील
स्रोत

6

जावास्क्रिप्ट (ईएस 6), 107 106 बाइट्स

a=>a.map(c=>c?s+=(c>0&&s?'+':_)+(!--e|c*c-1?c:c<0?'-':_)+(e?e-1?'x^'+e:'x':_):e--,e=a.length,_=s='')&&s||0

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

कैसे?

आउटपुट को इनपुट एरे के प्रत्येक गुणांक c [a] में निम्न सूत्रों को लागू करके बनाया गया है जबकि वर्तमान घातांक e का ट्रैक रखते हैं ।

पहला सूत्र: प्लस चिन्ह

यदि गुणांक सख्ती से सकारात्मक है और आउटपुट अभिव्यक्ति में यह पहला शब्द नहीं है, तो हम संलग्न करते हैं +। अन्यथा, हम कुछ नहीं कहते हैं।

c > 0 && s ? '+' : _

दूसरा सूत्र: ऋण चिह्न और गुणांक

यदि घातांक शून्य है या गुणांक का पूर्ण मान 1 के बराबर नहीं है, तो हम गुणांक को जोड़ते हैं (जिसमें एक अग्रणी शामिल हो सकता है -)। अन्यथा, हम या तो एक -(अगर गुणांक नकारात्मक है) या कुछ नहीं करते हैं।

!--e | c * c - 1 ? c : c < 0 ? '-' : _

3 सूत्र: चर और घातांक

यदि प्रतिपादक 0 है, तो हम कुछ नहीं कहते हैं। यदि प्रतिपादक 1 है, तो हम संलग्न करते हैं x। अन्यथा, हम x^घातांक का अनुसरण करते हैं।

e ? e - 1 ? 'x^' + e : 'x' : _

— Arnauld
स्रोत

यह इस मामले में विफल रहता है: [0,1,35,0], यह + x ^ 2 के साथ आगे

— बढ़ेगा

2

@Makotosan इस रिपोर्ट के लिए धन्यवाद! अब ठीक होना चाहिए।

— अरनौलद

5

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

┴₧↕ê♦•Vªâÿσ9s╘dσ■à@@ⁿ■o─╦ñºº┌x╡ER▓ δ¿

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

यहां अनपैक्ड, अनगॉल्फड वर्जन है।

r{          reverse the input and map using block ...
  |c        skip this coefficient if it's falsy (zero)
  0<.+-@    sign char; e.g. '+'
  _|aYv i!+ abs(coeff)!=1 || i>0
    y$      str(abs(coeff)); e.g. '7'
    z       ""
  ?+        if-then-else, concatenate; e.g. '+7'
  "x^`i"    string template e.g. 'x^3' or 'x^0'
  iJ(T+     truncate string at i*i and trim. e.g. 'x^3' or ''
mr$         re-reverse mapped array, and flatten to string
c43=t       if it starts with '+', drop the first character
c0?         if the result is blank, use 0 instead

इसको चलाओ

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

5

पायथन 3, 279 277 258 251 बाइट्स

k=str.replace
def f(x):
 z=len(x)
 y='--'*(['-1']==[c for c in x if'0'!=c][:1])
 for i,v in enumerate(x):
  p=str(z+~i)
  if v in'-1'and~i+z:y+='+x^'+p
  elif'0'!=v:y+='+'+v+'x^'+p
 return y and k(k(k(k(y[1:],'+-','-'),'^1',''),'x^0',''),'-+','-')or 0

इनपुट को स्ट्रिंग्स की सूची के रूप में लेता है। यह समाधान अभी तक अत्यधिक गोल्फ नहीं है। यह मूल रूप से आउटपुट स्वरूप के अनुरूप चीजों को प्रतिस्थापित करके काम करता है, जो बाइट की गिनती को बढ़ाता है।

यह ऑनलाइन की कोशिश करो!

Ovs और NK1406 के लिए विशेष धन्यवाद ।

— मनीष कुंडू
स्रोत

सभी त्रुटियों को ठीक किया।

— मनीष कुंडू

आप उन्हें if'0'!=iऔर बनाने के लिए आप समानता की जांच फिर से कर सकते हैं if'-1'==i।

— ज़ाचारि

258 बाइट्स

— ओव्स

@ovs बहुत बहुत धन्यवाद

— मनीष कुंडू

251 बाइट्स दोहराया अभिव्यक्ति के लिए कुछ चर जोड़कर

— NK1406

4

परी / जीपी , 41 बाइट्स

p->concat([c|c<-Vec(Str(Pol(p))),c!="*"])

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

यदि *गुणांक और चर के बीच की अनुमति है:

परी / जीपी , 3 बाइट्स

Pol

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

— alephalpha
स्रोत

यहां तक कि Mathematica के लिए भी यह एक नहीं बना था!

— नानी मोस

4

APL (Dyalog Classic) , 114 113 109 107 106 बाइट्स

{{⍵≡'':⍕0⋄⍵↓⍨'+'=⊃⍵}∊⍵{{'1x'≡2↑1↓⍵:¯1⌽1↓1⌽⍵⋄⍵}('-0+'[1+×⍺]~⍕0),∊(U/⍕|⍺),(U←⍺≠0)/(⍵>⍳2)/¨'x'('^',⍕⍵)}¨⌽⍳⍴⍵}

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

-4 बाइट्स @ @ @ @ धन्यवाद!

यह निश्चित रूप से आगे नीचे गोल्फ हो सकता है। ये आवश्यक⎕IO←0

— जाकारी
स्रोत

मैंने आखिरकार उन दो बाइट्स को निकाल दिया ...

— Zacharý

3

पिप , 78 बाइट्स

(RV(B."x^"._MERVg)J'+)R[`\b0[^+]+``x.0|\^1|^\++|\++$``\b1x``\++-?`][xx'x_@v]|0

कमांड लाइन तर्क के रूप में गुणांक लेता है। इसे ऑनलाइन आज़माएं!

उपयोग ME(मानचित्र-गणना) और J(शामिल होने) फार्म के कुछ उत्पन्न करने के लिए 0x^3+-1x^2+35x^1+0x^0, और फिर regex प्रतिस्थापन की एक गुच्छा उचित प्रारूप में इस को बदलने के लिए।

— DLosc
स्रोत

3

एपीएल (डायलॉग क्लासिक) , 79 76 बाइट्स

{'^$' '\b1x' '\+?¯' '^\+'⎕r('0x-',⊂⍬)∊⍕¨(0≠⍵)⌿'+',⍵,⊖⍪((⊢↓⍨2≤⊢)↑'x^',⍕)¨⍳≢⍵}

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

— NGN
स्रोत

3

पायथन 3, 161 162 बाइट्स

अंडा के लिए एक बग धन्यवाद।

l=len
lambda p:''.join(['+'*(i>0)*(c>0)+(str(c)[:-1],str(c))[abs(c)!=1or i==l(p)-1]+'x'*(i!=l(p)-1)+('^%d'%(l(p)+~i))*(i<l(p)-2)for i,c in enumerate(p)if c])or'0'

विस्तारित:

l=len # Alias the len function since we use it a lot
lambda p: ''.join([ # Join a list of strings
    '+'*(i>0)*(c>0) # Prepend a + if this isn't the first term and the coefficient is positive
    + (str(c)[:-1], str(c))[abs(c) != 1 or i == l(p) - 1] # If the coefficient is 1 and this isn't the last term, delete the '1' from the string representation, otherwise just use the string representation
    + 'x' * (i != l(p) - 1) # If this isn't the last term, append an x
    + ('^%d' % (l(p) + ~i)) * (i < l(p) - 2) # If this isn't one of the last two terms, append the exponent
for i, c in enumerate(p) if c]) # Iterating over each coefficient with its index, discarding the term if the coefficient is zero
or '0' # If all of the above resulted in an empty string, replace it with '0'

— bkul
स्रोत

3

सी # , 237 बाइट्स

c=>{var b=1>0;var r="";int l=c.Length;var p=!b;for(int i=0;i<l;i++){int n=c[i];int e=l-1-i;var o=p&&i>0&&n>0?"+":n==-1&&e!=0?"-":"";p=n!=0?b:p;r+=n==0?"":o+(e==0?$"{n}":e==1?$"{n}x":n==1||n==-1?$"x^{e}":$"{n}x^{e}");}return r==""?"0":r;}

— Romen
स्रोत

1

PPCG में आपका स्वागत है!

— मार्टिन एंडर

3

साफ , 172 बाइट्स

import StdEnv,Text
r=reverse
@""="0"
@a|a.[size a-1]<'0'=a+"1"=a
? -1="-"
?1=""
?a=a<+""
$l=join"-"(split"+-"(join"+"(r[?v+e\\v<-r l&e<-["","x":map((<+)"x^")[1..]]|v<>0])))

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

— Οurous
स्रोत

@BMO ने अस्थायी रूप से अधिक गोल्फिंग लंबित तय की।

— Οurous

3

वोल्फ्राम भाषा / गणितज्ञ, 39 बाइट्स

TraditionalForm@Expand@FromDigits[#,x]&

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

सही क्रम में आने के लिए एक बिल्ट-इन है।

पिछला समाधान:

वोल्फ्राम भाषा / गणितज्ञ, 93 बाइट्स

StringReplace[StringRiffle[ToString/@InputForm/@MonomialList@FromDigits[#,x],"+"],"+-"->"-"]&

कम से कम मेरे लिए, यह गणितीय हेरफेर के लिए डिज़ाइन की गई भाषा के लिए आश्चर्यजनक रूप से लंबा है। ऐसा लगता है कि Expand@FromDigits[#,x]&काम करना चाहिए, लेकिन बहुपद के लिए डिफॉल्ट ऑर्डर करने वाले को इस सवाल का उल्टा होना चाहिए, इसलिए कुछ अतिरिक्त फाइनग्लिंग की आवश्यकता होती है।

व्याख्या

FromDigits[#,x]               converts input list to polynomial (technically converts to a number in base x)
MonomialList@                 gets list of terms of polynomial
InputForm/@                   converts each term to the form a*x^n
ToString/@                    then to a string version of that
StringRiffle[...,"+"]         joins using +'s
StringReplace[...,"+-"->"-"]& replaces +-'s with -'s

— DanTheMan
स्रोत

नहीं SringReplaceहोना चाहिए StringReplace?

— स्कॉट मिलनर

जब मैं इसे कॉपी कर रहा था तो @ScottMilner की गलती रही होगी। यह ध्यान देने के लिए धन्यवाद!

— दानामेन

3

पायथन 3: ~~150~~ 146 बाइट्स

f=lambda l:''.join('+-'[a<0]+str(a)[a<0:5*((abs(a)!=1)|(1>i))]+'x^'[:i]+str(i)[:i-1]for i,a in zip(range(len(l)-1,-1,-1),l)if a).lstrip('+')or '0'

(पिछले कार्यान्वयन):

f=lambda l: ''.join('+-'[a<0]+str(a)[a<0:5*((abs(a)!=1)|(1>i))]+'x^'[:i]+str(i)[:i-1] for i,a in zip(range(len(l)-1,-1,-1),l) if a).lstrip('+') or '0'

आप इसे ऑनलाइन आज़मा सकते हैं

कुदोस को: @ बेंजामिन

— विलेम वान ओन्सेम
स्रोत

1

अर्ग, मुझे मिल गया! आप इसे कुछ स्थानों को हटाकर 4 से नीचे लाते हैं:

f=lambda l:''.join('+-'[a<0]+str(a)[a<0:5*((abs(a)!=1)|(1>i))]+'x^'[:i]+str(i)[:i-1]for i,a in zip(range(len(l)-1,-1,-1),l)if a).lstrip('+')or '0'

— बेंजामिन

3

पर्ल 5 `-a` , 94 बाइट्स

($_=shift@F)&&push@a,@a*!/-/>0&&'+',@F?s/\b1\b//r:$_,@F>0&&'x',@F>1&&'^'.@F while@F;say@a?@a:0

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

— Xcali
स्रोत

यदि अंतिम (स्थिर) गुणांक 1 या -1 है तो सही ढंग से काम नहीं करता है।

— nwellnhof

डैंग। टूट गया होगा कि जब मैं इसे गोल्फ था। इसे कुछ और बाइट्स के साथ तय किया।

— 20

2

रेटिना 0.8.2 , 113 बाइट्स

\w+
a$'b$&
a( [^b ]*)*?b(\d+)
$2x^$#1
(\^1|x\^0)(?!\d)

(?<= |-|^)(1(?=x)|0[^ -]*)

([ -])*
$1
[ -]$|^ 

^$
0
 
+

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

मुझे यकीन है कि यहाँ गोल्फ के लिए बहुत कुछ है ...

— OVS
स्रोत

2

हास्केल , 166 163 बाइट्स

g s|l<-length s,v:w:r<-id=<<["- +"!!(1+signum m):(id=<<[show$abs m|abs m>1||e==0]++["x"|e>0]++['^':show e|e>1])|(e,m)<-zip[l-1,l-2..]s,m/=0]=[v|v>'+']++w:r|1<3="0"

इसे ऑनलाइन आज़माएं! उदाहरण उपयोग: g [0,-1,35,0]पैदावार "-x^2+35x"।

पिछला 166 बाइट समाधान, जो थोड़ा बेहतर पठनीय है:

0#n=show n
m#n=id=<<[show n|n>1]++"x":['^':show m|m>1]
m%0=""
m%n|n<0='-':m#(-n)|1<3='+':m#n
g s|l<-length s,v:m:r<-id=<<zipWith(%)[l-1,l-2..]s=[v|v>'+']++m:r|1<3="0"

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

— Laikoni
स्रोत

2

रूबी , 111 बाइट्स

->a{i=a.size;s=a.map{|x|i-=1;"%+d"%x+[?x,"x^#{i}",""][i<=>1]if x!=0}*'';s[0]?s.gsub(/(?<!\d)1(?=x)|^\+/,""):?0}

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

रूबी में इसे हल करना थोड़ा निराशाजनक था, मुख्यतः इस तथ्य के कारण कि अधिकांश भाषाओं के विपरीत, रूबी में (लगभग) सब कुछ सत्य है, जिसमें 0-एस और खाली तार शामिल हैं, ताकि शून्य के लिए एक सरल जांच भी अब निकट हो जाए जितना छोटा x?।

मैंने स्ट्रिंग के निर्माण के विभिन्न तरीकों के साथ खेला, और अंततः कई दृष्टिकोणों के मिश्रण पर बसे:

0 गुणांक वाले शर्तों को एक साधारण सशर्त का उपयोग करके गिरा दिया जाता है
+और -संकेत मजबूर संकेत के साथ वाक्यविन्यास प्रारूपण द्वारा निर्मित होते हैं:%+d
x^iरॉकेट ऑपरेटर इंडेक्सिंग का उपयोग करके सही रूप या चयन किया जाता है[...][i<=>1]
लीडिंग + और अनावश्यक 1-एस को रेगेक्स रिप्लेसमेंट द्वारा हटा दिया जाता है

— किरिल एल।
स्रोत

2

हस्क , 44 43 41 40 बाइट्स

|s0Ψf¤|□ṁ`:'+f¹zμ+↓s²_&ε²¹↑□¹+"x^"s)¹m←ṡ

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

यह थोड़ा भद्दा लगता है; भूसी स्ट्रिंग हेरफेर के लिए अनुकूलित नहीं है। मैंने स्टैक्स जवाब से कुछ विचार उधार लिए ।

व्याख्या

         Implicit input, say L = [2,-3,0,-1].
         First we compute the exponents.
ṡ        Reversed indices: [4,3,2,1]
m←       Decrement each: [3,2,1,0]
         Then we format the individual terms of the polynomial.
zμ...)¹  Zip with L using two-argument lambda:
          Arguments are coefficient and index, say C = -3 and I = 2.
+"x^"s    Convert I to string and concatenate to "x^": "x^2"
↑□¹       Take first I*I characters (relevant when I = 0 or I = 1): "x^2"
_&ε²¹     Check if abs(C) <= 1 and I != 0, negate; returns -1 if true, 0 if false.
↓s²       Convert C to string and drop that many elements (from the end, since negative).
          Result: "-3"
          The drop is relevant if C = 1 or C = -1.
+         Concatenate: "-3x^2"
         Result of zipping is ["2x^3","-3x^2","x","-1"]
f¹       Keep those where the corresponding element of L is nonzero: ["2x^3","-3x^2","-1"]
         Next we join the terms with + and remove extraneous +s.
ṁ        Map and concatenate
`:'+      appending '+': "2x^3+-3x^2+-1+"
Ψf       Adjacent filter: keep those chars A with right neighbor B
¤|□       where at least one of A or B is alphanumeric: "2x^3-3x^2-1"
|s0      Finally, if the result is empty, return "0" instead.

— Zgarb
स्रोत

2

पर्ल 6 , 97 बाइट्स

{$!=+$_;.map({('+'x?($_&&$++&$_>0)~.substr(--$!&&2>.abs)~(<<''x>>[$!]//'x^'~$!))x?$_}).join||'0'}

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

स्पष्टीकरण:

$!=+$_;

$! वर्तमान घातांक का ट्रैक रखता है।

'+'x?($_&&$++&$_>0)

+सकारात्मक गुणांक से पहले जोड़ें , भले ही यह पहला गैर-शून्य हो। $_&&शॉर्ट सर्किट लगता है कि गुमनाम राज्य चर बनाता है $केवल गैर शून्य गुणांक के लिए वृद्धि की जाती है। &जब साथ बूल के लिए मजबूर जंक्शन संकुचित हो जाता है ?।

.substr(--$!&&2>.abs)

कमी $!। चॉप 1 या -1 गुणांक जब तक यह स्थिर नहीं होता है।

<<''x>>[$!]//'x^'~$!

विशेष-केस रैखिक और निरंतर शब्द। बोली-रक्षा करने वाले << >> निर्माण का उपयोग करना समकक्ष ('','x')या की तुलना में छोटा है 2>$!??'x'x$!!!'x^'~$!।

x?$_

शून्य शब्द छिपाएं, लेकिन --$!साइड इफेक्ट के लिए हमेशा पूर्ववर्ती अभिव्यक्ति का मूल्यांकन करें ।

||'0'

0यदि सभी गुणांक शून्य हैं, तो वापस लौटें ।

— nwellnhof
स्रोत

2

जावा 8, 202 176 174 173 बाइट्स

a->{String r="";int j=a.length;for(int i:a)r+=i==0*j--?"":"+"+i+(j<1?"":j<2?"x":"x^"+j);return r.isEmpty()?"0":r.substring(1).replace("+-","-").replaceAll("(\\D)1x","$1x");}

26 बाइट्स @Nevay को धन्यवाद ।

स्पष्टीकरण:

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

a->{                     // Method with String-array parameter and String return-type
  String r="";           //  Result-String, starting empty
  int j=a.length;        //  Power-integer, starting at the size of the input-array
  for(int i:a)           //  Loop over the array
    r+=i==0              //   If the current item is 0
           *j--?         //   (And decrease `j` by 1 at the same time)
        ""               //    Append the result with nothing
       :                 //   Else:
        "+"              //    Append the result with a "+",
        +i               //    and the current item,
        +(j<1?           //    +If `j` is 0:
           ""            //      Append nothing more
          :j<2?          //     Else-if `j` is 1:
           "x"           //      Append "x"
          :              //     Else:
           "x^"+j);      //      Append "x^" and `j`
  return r.isEmpty()?    //  If `r` is still empty
    "0"                  //   Return "0"
   :                     //  Else:
    r.substring(1)       //   Return the result minus the leading "+",
     .replace("+-","-")  //   and change all occurrences of "+-" to "-",
     .replaceAll("(\\D)1x","$1x");}
                         //   and all occurrences of "1x" to "x"

— केविन क्रूज़सेन
स्रोत

1

176 बाइट्स:

a->{String r="";int j=a.length;for(int u:a)r+=u==(j^j--)?"":"+"+u+(j<1?"":j<2?"x":"x^"+j);return r.isEmpty()?"0":r.substring(1).replace("+-","-").replaceAll("([+-])1x","$1x");}

— नेवेय

1

@ केवल मुझे अब पता चला है कि सभी इनपुट पूर्णांक हैं .. मैंने स्ट्रिंग-इनपुट का उपयोग किया क्योंकि मुझे लगा कि दशमलव इनपुट को अच्छी तरह से अनुमति दी गई थी ..>> वैसे भी, -26 बाइट्स के लिए धन्यवाद। और मैं करने के लिए बदलकर गोल्फ 2 और अधिक सक्षम (j^j--)है 0*j--।

— केविन क्रूज़सेन

2

अजगर, 165 बाइट्स

lambda a:"".join([("+"if c>0 and i+1<len(a)else"")+(str(c)if i==0 or abs(c)!=1 else "")+{0:"",1:"x"}.get(i,"x^"+str(i))for i,c in enumerate(a[::-1])if c][::-1])or"0"

— pppery
स्रोत

1

PHP, 213 बाइट्स

$p=0;for($i=count($a=array_reverse(explode(',',trim($argv[1],'[]'))))-1;$i>=0;$i--)if(($b=(float)$a[$i])||(!$i&&!$p)){$k=abs($b);echo ($b<0?'-':($p?'+':'')).((($k!=1)||!$i)?$k:'').($i>1?'x^'.$i:($i?'x':''));$p=1;}

ओपी द्वारा अनुरोधित कमांड लाइन तर्क (ब्रैकेट और कॉमा के साथ एकल तर्क)।

सुंदर प्रिंट और कुछ स्पष्टीकरण:

$p = false; /* No part of the polynomial has yet been printed. */
for ($i = count($a = array_reverse(explode(',',trim($argv[1],'[]')))) - 1; $i >= 0; $i--)
{
    $b = (float)$a[$i]; /* Cast to float to avoid -0 and numbers like 1.0 */
    if (($b != 0) or (($i == 0) and !$p)) /* Print, if $b != 0 or the constant if there is no part until here. */
    {
        $k = abs($b);
        echo ($b < 0 ? '-' : ( $p ? '+' : '')); /* Sign. The first sign is suppressed (if $p is false) if $b positive. */
        echo ((($k != 1) || ($i == 0)) ? $k : '');  /* Coefficient */
        echo ($i > 1 ? 'x^' . $i : (($i != 0) ? 'x' : ''));  /* x^3, x^2, x, constant with empty string. */
        $p = true; /* Part of the polynomial has been printed. */
    }
}

— rexkogitans
स्रोत

1

पॉवरशेल, 295 बाइट्स

$c=$args[0]
$p=$c.length-1
$i=0
$q=""
while($p -ge 0){$t="";$e="";$d=$c[$i];switch($p){0{$t=""}1{$t="x"}Default{$t="x^";$e=$p}}if($d-eq 0){$t=""}elseif($d-eq 1){$t="+$t$e"}elseif($d-eq-1){$t="-$t$e"}elseif($d-lt 0 -or$i -eq 0){$t="$d$t$e"}else{$t="+$d$t$e"}$q+=$t;$i++;$p--}if($q -eq""){$q=0}
$q

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

सुंदर प्रिंट बहुपद

परिचय

चुनौती

नियम:

उदाहरण इनपुट और आउटपुट

संपादित करें:

रेटिना 0.8.2 , 56 बाइट्स

जावास्क्रिप्ट (ईएस 6), 107 106 बाइट्स

कैसे?

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

पायथन 3, 279 277 258 251 बाइट्स

परी / जीपी , 41 बाइट्स

परी / जीपी , 3 बाइट्स

APL (Dyalog Classic) , 114 113 109 107 106 बाइट्स

पिप , 78 बाइट्स

एपीएल (डायलॉग क्लासिक) , 79 76 बाइट्स

पायथन 3, 161 162 बाइट्स

सी # , 237 बाइट्स

साफ , 172 बाइट्स

वोल्फ्राम भाषा / गणितज्ञ, 39 बाइट्स

वोल्फ्राम भाषा / गणितज्ञ, 93 बाइट्स

व्याख्या

पर्ल 5 -a , 94 बाइट्स

रेटिना 0.8.2 , 113 बाइट्स

हास्केल , 166 163 बाइट्स

रूबी , 111 बाइट्स

हस्क , 44 43 41 40 बाइट्स

व्याख्या

पर्ल 6 , 97 बाइट्स

जावा 8, 202 176 174 173 बाइट्स

अजगर, 165 बाइट्स

PHP, 213 बाइट्स

पॉवरशेल, 295 बाइट्स

पर्ल 5 `-a` , 94 बाइट्स