बहुपद का सांकेतिक विभेदन

Question

प्रतीकात्मक विभेदीकरण 1: गया कोफिशिन '

कार्य

एक प्रोग्राम है जो एक बहुपद में में लेता लिखें एक्स stdin से (1 <डिग्री (पी) <128) और यह अलग करती है। इनपुट बहुपद निम्नलिखित रूप की एक स्ट्रिंग होगी:

"a + bx + cx^2 + dx^3 +" ...

जहां प्रत्येक शब्द का गुणांक एक पूर्णांक (-128 <a <128) है। प्रत्येक शब्द को एक स्थान, + और दूसरे स्थान से अलग किया जाता है; रैखिक और निरंतर शब्द ऊपर के रूप में दिखाई देते हैं (यानी, नहीं x^0या x^1)। बढ़ती डिग्री के क्रम में शर्तें दिखाई देंगी, और शून्य गुणांक वाली शक्तियां छोड़ दी जाती हैं। गुणांक 1 या -1 वाले सभी शब्द स्पष्ट रूप से गुणांक प्रदर्शित करते हैं।

आपके आउटपुट में ठीक उसी रूप में होना चाहिए। ध्यान दें कि आउटपुट में गुणांक 127 * 127 == 16129 जितना बड़ा हो सकता है।

उदाहरण

"3 + 1x + 2x^2" ==> "1 + 4x"
"1 + 2x + -3x^2 + 17x^17 + -1x^107" ==> "2 + -6x + 289x^16 + -107x^106"
"17x + 1x^2" ==> "17 + 2x"

स्कोरिंग

यदि आप बिल्ट-इन या एक पुस्तकालय का उपयोग करते हैं, जो प्रतीकात्मक बीजगणित करता है, तो आपका स्कोर बाइट्स में आपके प्रोग्राम की लंबाई तीन से गुणा है।

Comments

मुझे विश्वास नहीं हो रहा है कि हमारे पास पहले से ही यह चुनौती नहीं है!

— दोष

@flawr हमने किया। (हालांकि उस एक को अन्य कार्यों की आवश्यकता थी और आउटपुट प्रारूप पर सख्त नियम नहीं थे।)

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

@flawr मैंने एक ही बात सोची ... और फिर भी मुझे मार्टिन की लिंक्ड पोस्ट सर्च नहीं मिली। ठीक है।

— hYPotenuser 15

Answer 1

रेटिना , 53 43 42 41 40 35 बाइट्स

^[^x]+ |(\^1)?\w(?=1*x.(1+)| |$)
$2

गणना के उद्देश्यों के लिए प्रत्येक पंक्ति एक अलग फ़ाइल में जाती है, लेकिन आप -sझंडे के साथ रेटिना को आमंत्रित करके उपरोक्त को एकल फ़ाइल के रूप में चला सकते हैं ।

यह इनपुट स्ट्रिंग में संख्याओं को एकात्मक रूप में दिए जाने की अपेक्षा करता है और एक ही प्रारूप में आउटपुट देगा। उदाहरण के लिए

1 + 11x + -111x^11 + 11x^111 + -1x^11111
-->
11 + -111111x + 111111x^11 + -11111x^1111

के बजाय

1 + 2x + -3x^2 + 2x^3 + -1x^5
-->
2 + -6x + 6x^2 + -5x^4

व्याख्या

कोड एक एकल रेगेक्स प्रतिस्थापन का वर्णन करता है, जो मूल रूप से एक में संकुचित 4 प्रतिस्थापन है। ध्यान दें कि शाखाओं में से केवल एक ही समूह को भरेगा, $2यदि अन्य तीन मैचों में से कोई भी, मैच केवल स्ट्रिंग से हटा दिया जाएगा। इसलिए हम चार अलग-अलग मामलों को अलग-अलग देख सकते हैं:

^[^x]+<space>
<empty>

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

x(?= )
<empty>

यह मेल खाता है xजो एक स्थान के बाद होता है, अर्थात xरैखिक शब्द का (यदि यह मौजूद है), और इसे हटा देता है। हम यह सुनिश्चित कर सकते हैं कि इसके बाद एक स्थान है, क्योंकि बहुपद की डिग्री हमेशा कम से कम 2 होती है।

1(?=1*x.(1+))
$1

यह घातांक द्वारा गुणांक का गुणन करता है। यह 1गुणांक में एकल से मेल खाता है और इसे लुकहेड के माध्यम से पूरे संबंधित घातांक द्वारा प्रतिस्थापित करता है।

(\^1)?1(?= |$)
<empty>

यह अनुरेखण 1(लुकहेड द्वारा सुनिश्चित) का मिलान करके शेष सभी व्यय को कम करता है । यदि मैच ^11(और एक शब्द सीमा) करना संभव है , तो हम इसके बजाय इसे हटा देते हैं, जो रैखिक शब्द को सही ढंग से प्रदर्शित करने का ख्याल रखता है।

संपीड़न के लिए, हम देखते हैं कि अधिकांश स्थितियाँ एक दूसरे को प्रभावित नहीं करती हैं। (\^1)?अगर तीसरे मामले में लुकहेड सच है, तो हम मेल नहीं खाएंगे, इसलिए हम उन दोनों को एक साथ रख सकते हैं

(\^1)?1(?=1*x.(1+)| |$)
$2

अब हम पहले से ही अग्रदर्शी दूसरे मामले के लिए आवश्यक है और दूसरों से सच है जब मिलान कभी नहीं हो सकता xहै, तो हम बस सामान्यीकरण कर सकते हैं 1एक करने के लिए \w:

(\^1)?\w(?=1*x.(1+)| |$)
$2

पहला मामला वास्तव में दूसरों के साथ कुछ भी नहीं है, इसलिए हम इसे अलग रखते हैं।

Answer 2

CJam, 43 41 बाइट्स

Qleu'^/';*'+/{~:E[*'x['^E(]]E<}/]1>" + "*

एक बग को इंगित करने और दो बाइट को बंद करने के लिए @ jimmy23013 का धन्यवाद!

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

Q           e# Leave an empty array on the bottom of the stack.
l           e# Read a line from STDIN.
eu'^/';*    e# Convert to uppercase and replace carets with semicolons.
'+/         e# Split at plus signs.

{           e# For each resulting chunk:
  ~         e#   Evaluate it. "X" pushes 1 and ";" discards.
            e#   For example, "3X" pushes (3 1) and "3X;2" (3 2).
   :E       e#   Save the rightmost integer (usually the exponent) in E.
   [        e#
     *      e#   Multiply both integers.
            e#   For a constant term c, this repeats the empty string (Q) c times.
     'x     e#   Push the character 'x'.
     ['^E(] e#   Push ['^' E-1].
   ]        e#
   E<       e#  Keep at most E elements of this array.
            e#  If E == 1, 'x' and ['^' E-1] are discarded.
            e#  If E == 2, ['^' E-1] is discarded.
            e#  If E >= 3, nothing is discarded.
}/          e#

]           e# Wrap the entire stack in an array.
1>          e# Discard its first element.
            e# If the first term was constant, this discards [""]. ["" 'x']
            e# or ["" 'x' ['^' E-1]], depending on the constant.
            e# In all other cases, it discards the untouched empty array (Q).
" + "*      e# Join all kept array elements, separating by " + ".

Answer 3

पर्ल, 64 63 बाइट्स

62b कोड + 1 कमांड लाइन (-p)

फिलहाल आश्चर्यजनक नहीं है, लेकिन मैं इसे छोटा करने की कोशिश जारी रखूंगा।

s/(\d+)x.(\d+)/$1*$2."x^".($2-1)/eg;s/\^1\b|^\d+ . |x(?!\^)//g

उपयोग उदाहरण:

echo "1 + 2x + 3x^2" | perl -pe 's/(\d+)x.(\d+)/$1*$2."x^".($2-1)/eg;s/\^1\b|^\d+ . |x(?!\^)//g'

धन्यवाद डे -1 बी के लिए

Answer 4

जूलिया, 220 बाइट्स

कोई नियमित अभिव्यक्ति नहीं!

y->(A=Any[];for i=parse(y).args[2:end] T=typeof(i);T<:Int&&continue;T==Symbol?push!(A,1):(a=i.args;c=a[2];typeof(a[3])!=Expr?push!(A,c):(x=a[3].args[3];push!(A,string(c*x,"x",x>2?string("^",ex-1):""))))end;join(A," + "))

यह एक लंबो फ़ंक्शन बनाता है जो एक स्ट्रिंग को स्वीकार करता है और एक स्ट्रिंग लौटाता है। जब जूलिया कोड का मूल्यांकन किया जाता है, तो जो नकल करता है: एक स्ट्रिंग प्रतीकों, अभिव्यक्तियों और कॉल में पार्स होती है। मैं वास्तव में एक पूर्ण जूलिया प्रतीकात्मक भेदभाव समारोह लिखने की कोशिश कर सकता हूं और इसे जूलिया का हिस्सा बनने के लिए प्रस्तुत कर सकता हूं।

असंगठित + स्पष्टीकरण:

function polyderiv{T<:AbstractString}(y::T)

    # Start by parsing the string into an expression
    p = parse(y)

    # Define an output vector to hold each differentiated term
    A = Any[]

    # Loop through the elements of p, skipping the operand
    for i in p.args[2:end]

        T = typeof(i)

        # Each element will be an integer, symbol, or expression.
        # Integers are constants and thus integrate to 0. Symbols
        # represent x alone, i.e. "x" with no coefficient or
        # exponent, so they integrate to 1. The difficulty here
        # stems from parsing out the expressions.

        # Omit zero derivatives
        T <: Int && continue

        if T == Symbol
            # This term will integrate to 1
            push!(A, 1)
        else
            # Get the vector of parsed out expression components.
            # The first will be a symbol indicating the operand,
            # e.g. :+, :*, or :^. The second element is the
            # coefficient.
            a = i.args

            # Coefficient
            c = a[2]

            # If the third element is an expression, we have an
            # exponent, otherwise we simply have cx, where c is
            # the coefficient.
            if typeof(a[3]) != Expr
                push!(A, c)
            else
                # Exponent
                x = a[3].args[3]

                # String representation of the differentiated term
                s = string(c*x, "x", x > 2 ? string("^", x-1) : "")

                push!(A, s)
            end
        end
    end

    # Return the elements of A joined into a string
    join(A, " + ")
end

Answer 5

सी, 204 162 बाइट्स

#define g getchar()^10
h,e;main(c){for(;!h&&scanf("%dx%n^%d",&c,&h,&e);h=g?g?e?printf(" + "):0,0:1:1)e=e?e:h?1:0,e?printf(e>2?"%dx^%d":e>1?"%dx":"%d",c*e,e-1):0;}

मूल रूप से प्रत्येक शब्द को पार्स करें और अनुक्रम में विभेदित शब्द का प्रिंट आउट लें। काफी सरल।

Answer 6

जावास्क्रिप्ट ईएस 6, 108 बाइट्स

f=s=>s.replace(/([-\d]+)(x)?\^?(\d+)?( \+ )?/g,(m,c,x,e,p)=>x?(c*e||c)+(--e?x+(e>1?'^'+e:''):'')+(p||''):'')

ES5 स्निपेट:

// ES5 version, the only difference is no use of arrow functions.
function f(s) {
  return s.replace(/([-\d]+)(x)?\^?(\d+)?( \+ )?/g, function(m,c,x,e,p) {
    return x ? (c*e||c) + (--e?x+(e>1?'^'+e:''):'') + (p||'') : '';
  });
}

[
  '3 + 1x + 2x^2',
  '1 + 2x + -3x^2 + 17x^17 + -1x^107',
  '17x + 1x^2'
].forEach(function(preset) {
  var presetOption = new Option(preset, preset);
  presetSelect.appendChild(presetOption);
});

function loadPreset() {
  var value = presetSelect.value;
  polynomialInput.value = value;
  polynomialInput.disabled = !!value;
  showDifferential();
}

function showDifferential() {
  var value = polynomialInput.value;
  output.innerHTML = value ? f(value) : '';
}

code {
  display: block;
  margin: 1em 0;
}

<label for="presetSelect">Preset:</label>
<select id="presetSelect" onChange="loadPreset()">
  <option value="">None</option>
</select>
<input type="text" id="polynomialInput"/>
<button id="go" onclick="showDifferential()">Differentiate!</button>
<hr />
<code id="output">
</code>

Answer 7

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

लड़का, ऐसा लगता है कि यह होना चाहिए की तुलना में लंबे समय तक।

S=str.split
def d(t):e="^"in t and int(S(t,"^")[1])-1;return`int(S(t,"x")[0])*(e+1)`+"x"[:e]+"^%d"%e*(e>1)
print" + ".join(d(t)for t in S(raw_input()," + ")if"x"in t)

फ़ंक्शन dएक गैर-स्थिर शब्द लेता है tऔर इसका व्युत्पन्न लौटाता है। defलैंबडा का उपयोग करने के बजाय कार्य करने का कारण यह है कि मैं घातांक माइनस 1 को असाइन कर सकता हूं e, जिसके बाद एक और चार बार उपयोग किया जाता है। मुख्य कष्टप्रद बात स्ट्रिंग्स और इन्टस के बीच आगे और पीछे डालने की है, हालांकि पायथन 2 के बैकटिक ऑपरेटर इसके साथ मदद करते हैं।

फिर हम इनपुट को शब्दों में विभाजित करते हैं और उसमें मौजूद dहर एक पर कॉल "x"करते हैं, जिससे निरंतर अवधि समाप्त हो जाती है। परिणाम वापस एक साथ जुड़ जाते हैं और मुद्रित हो जाते हैं।

Answer 8

CJam, 62 57 55 49 बाइट्स

ठीक है, डेनिस ने शर्म की बात यह करने से पहले कि मैंने यह भी देखा कि साइट वापस आ गई थी। लेकिन यहाँ मेरी रचना वैसे भी है:

lS/{'x/:T,({T~1>:T{~T~*'xT~(:T({'^T}&}&" + "}&}/;

नवीनतम संस्करण @Dennis (चर का उपयोग करें, और इसके बजाय अंतरिक्ष में विभाजित +) द्वारा सुझाए गए शॉर्टकट के साथ कुछ बाइट्स बचाता है ।

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

Comments

एक चर में सहेजना अन्य ब्लॉक में पॉपिंग से कम है। उदाहरण के लिए, _({'^a\}{;}?1 बाइट से अधिक लंबा है :T({T'^a\}&।

— डेनिस

यदि आप प्लस संकेतों के बजाय रिक्त स्थान पर विभाजित होते हैं, तो आपको ~शेष अन्य ब्लॉक में आवश्यकता नहीं है और उस एक को भी समाप्त कर सकते हैं।

— डेनिस

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

— रेटो कोराडी

Answer 9

पायथ, 62 बाइट्स

jJ" + "m::j"x^",*Fdted"x.1$"\x"x.0"kftTmvMcd"x^"c:z"x ""x^1 "J

बहुत बदसूरत समाधान, कुछ रेगेक्स प्रतिस्थापन का उपयोग कर।

Answer 10

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

s=input().split(' + ')
y='x'in s[0]
L=map(lambda x:map(int,x.split('x^')),s[2-y:])
print(' + '.join([s[1-y][:-1]]+['x^'.join(map(str,[a*b,b-1])).rstrip('^1')for a,b in L]))

वास्तव में, मुख्य झुंझलाहट को तार और इन्ट्स के बीच परिवर्तित करना है। इसके अलावा, यदि एक निरंतर अवधि की आवश्यकता होती है, तो कोड केवल 153 बाइट्स होगा।

Comments

पहला उत्तर, डीकोस की पिटाई के लिए शूटिंग कर रहा था, वहां बहुत कुछ नहीं मिला।

— एल'एंडिया स्ट्रोमैन

Answer 11

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

import os
print' + '.join([i,i[:-2]][i[-2:]=='^1'].replace('x^0','')for i in[`a*b`+'x^'+`b-1`for a,b in[map(int,a.split('x^'))for a in[[[i+'x^0',i+'^1'][i[-1]=='x'],i]['^'in i]for i in os.read(0,9**9).split(' + ')]]]if i[0]!='0')

Answer 12

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

print' + '.join(['%d%s%s'%(b[0]*b[1],'x'*(b[1]>1),'^%d'%(b[1]-1)*(b[1]>2))for b in[map(int,a.split('x^')if 'x^'in a else[a[:-1],1])for a in input().split(' + ')if 'x'in a]])

दुर्भाग्य से, DLosc की चाल विभाजन विधि का नाम बदलने और एक विशिष्ट फ़ंक्शन में भेदभाव करने के लिए मेरे कोड को छोटा नहीं करता है ...