एक रैखिक समीकरण को हल करें

Question

^{यह चुनौती है लेकिन बेहतर कल्पना के साथ।}

कल्पना

आपका प्रोग्राम एक वैरिएबल समीकरण लेगा जिसमें सिंगल वैरिएबल होगा xऔर का वैल्यू आउटपुट होगा x।

इनपुट / पार्सिंग

• इनपुट में केवल नंबर, ऑपरेटर, कोष्ठक ( ()) x, और एक =संकेत होगा (इसका अर्थ है कोई व्हाट्सएप नहीं)।
• कोष्ठक हमेशा संतुलित रहेगा।
• हमेशा कम से कम 1 होगा x। एक xनंबर से पहले हो सकता है।
• सभी समीकरणों का ठीक एक परिणाम होगा।

---

इन चरणों का पालन करके एक संख्या को परिभाषित किया जा सकता है। एक संख्या को रेगेक्स द्वारा परिभाषित किया जा सकता है -?(\d+(\.\d+)?|\.\d+):।

---

यदि आप रेगेक्स नहीं बोलते हैं: एक अंक के रूप में परिभाषित किया गया है 0-9

1. इसकी -शुरुआत में इसका संकेत नकारात्मक हो सकता है
2. फिर कुछ अंक हो सकते हैं। यदि वे कोई अंक नहीं हैं तो एक दशमलव बिंदु होगा
3. यदि कोई दशमलव बिंदु मौजूद है, तो कम से कम एक अंक इसका अनुसरण करेगा

सबसे बड़ी संख्या / मूल्य आपकी भाषा की क्षमताओं द्वारा परिभाषित किया जाएगा।

---

एक ऑपरेटर किसी भी प्रकार का होता है: +-*/वे हमेशा संख्याओं, और कोष्ठक के बीच दिखाई देंगे

इसका मतलब (5)(5)सादगी के लिए एक वैध इनपुट नहीं है।

---

कोष्ठक में हमेशा उनके अंदर एक वैध अभिव्यक्ति (संख्याओं और / या संचालकों का एक वैध संयोजन) होगा। "संतुलित" कोष्ठक को परिभाषित किया गया है क्योंकि प्रत्येक (में एक संबद्ध समापन होगा)

मूल्यांकन

• संचालन के आदेश का पालन किया जाना चाहिए और वरीयताएँ सबसे कम (सबसे कम) हैं:
  • लघुकोष्ठक (सबसे पहले गहरी नेस्टेड)
  • गुणा और भाग
  • जोड़ और घटाव
• यदि एक ही पूर्वता वाले दो ऑपरेटर होते हैं, तो आपको बाएं - दाएं चलना पसंद करना चाहिए

उत्पादन

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

नियम

• अंतर्निहित कार्य इस कार्य को अनुमति देते हैं लेकिन , आपको [uses built-in]उत्तर के शीर्ष पर स्पष्ट रूप से जोड़ना चाहिए । यह आपके उत्तर को जीतने से छूट देता है
• "बिल्ट-इन-ट्रिवियलाइजिंग इस कार्य" में से कोई एक है:
  • कुछ जो एक समीकरण में लेता है और एक / चर के लिए मूल्य को आउटपुट करता है
  • कुछ जो पूरी तरह से एक समीकरण को सरल करेगा
  • evalपार्सिंग की एक महत्वपूर्ण राशि का उपयोग करने के लिए या संबंधित फ़ंक्शन का उपयोग करना । उपयोग की evalकार्य करता है और संबंधित अस्वीकृत कर दी जाती है अगर वे करने के लिए उपयोग किया जाता है रेखीय समीकरण का समाधान (इनपुट करने के लिए कम से कम संशोधन के साथ)।
  • यदि आप संदेह में हैं, तो बस एक टिप्पणी में पूछें।
• बिल्ट-इन जो समीकरण को पार्स करने की अनुमति है

उदाहरण

3+4=x
7

4+x=5
1

3+3*3=x
12

3x-4=7+2x
11

3--1=x
4

3*(2+4x)=7x-4
-2

1.2+2.3x=5.8
2

10=4x
2.5

चालान इनपुट:

(5)(4)=x  no operator between (5) and (4)
5(x+3)=2  no operator 5 and (...)
x=y       the only variable is x
4=3       there is no x
x+3=x-7   no solution
x=x       infinite solutions
+5=x      + is not an unary operator. -5=x would be valid though
1/(x-3)=5 Nonlinear
3/x       Nonlinear

Comments

आप कहते हैं कि बिल्ट-इन आपके सबमिशन को अयोग्य बना देता है, लेकिन इसे केवल उन ऑपरेशन्स को संदर्भित करने के लिए स्पष्ट करें जो समीकरण को हल करने और पार्स करने और पसंद करते हैं। मुझे लगता है कि यह एक अलग शब्द का उपयोग करने के लिए स्पष्ट होगा, क्योंकि मैं किसी भी नामित ऑपरेशन को अंतर्निहित के रूप में सोचता हूं।

— xnor

उत्तर कितने सही हैं?

— दोष

@MrPublic आपका कार्यक्रम एक एकल चर वाला एक रैखिक समीकरण लेगा ...

— लुइस मेन्डो

साथ ही, जावास्क्रिप्ट की evalगिनती चुनौती को तुच्छ साबित करती है? इसके अलावा, new Function(...)गिनती के रूपों ?

— कॉनर ओ'ब्रायन

@ C @O'Bʀɪᴇɴ निर्भर करता है कि आप इसका क्या उपयोग करते हैं। लेकिन यह मानते हुए कि आप जावास्क्रिप्ट का उपयोग कर रहे हैं, मैं यह नहीं देखता कि यह चुनौती को कैसे सुनिश्चित करेगा

— डाउनगेट

Answer 1

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

अभी भी कुछ गोल्फिंग किया जाना है, लेकिन कम से कम यह एक समाधान है!

C=a=>new Function("x","return "+a.replace(/(\d)x/g,"$1*x"));n=>{n=n.split("=");t=Math.abs,r=C(n[0]),c=C(n[1]),a=0,i=r(a)-c(a);a++;v=r(a)-c(a);o=t(i)<t(v)?-1:1;for(u=1/0;r(a)!==c(a);)a+=o,e=t(r(a)-c(a)),e>u&&(u=1/0,o/=10),u=Math.min(e,u);return a}

n=>{n=n.split("=")...इसका उपयोग करने के लिए फ़ंक्शन का नाम दें।

हाइपर-ungolfed:

function solveLinear(equation){
    equation = equation.split("=");
    var abs = Math.abs;
    var LHS = convertToFunction(equation[0]), RHS = convertToFunction(equation[1]);
    var pivot = 0;
    var dir;
    var dir1 = LHS(pivot) - RHS(pivot);
    pivot++;
    var dir2 = LHS(pivot) - RHS(pivot);
    if(abs(dir1)<abs(dir2)) dir = -1;
    else dir = 1;
    var dif, minDif = Infinity;
    while(LHS(pivot) !== RHS(pivot)){
        pivot += dir;
        dif = abs(LHS(pivot) - RHS(pivot));
        if(dif > minDif){
            minDif = Infinity;
            dir /= 10;
        }
        minDif = Math.min(dif, minDif);
        console.log(pivot,dir,dif,minDif);
    }
    return {
        x: pivot,
        LHS: LHS,
        RHS: RHS
    };
}

यह एक धुरी दृष्टिकोण का उपयोग करता है। (मुझे यकीन नहीं है कि यह वही है जिसे एल्गोरिथ्म कहा जाता है, बस एक ऐसा नाम है जिसका मैंने आविष्कार किया था।) यह पहली बार शून्य से खोज करने के लिए किस दिशा में इकट्ठा होता है (यानी, समीकरणों के दो पक्षों के ढलान किस तरह से अंतर होगा) और मूल्य के लिए लग रहा है। एक बार जब यह न्यूनतम अंतर का बिंदु पाता है, तो यह उस बिंदु पर जाता है और खोज वृद्धि में कमी करता है। यह अंततः हमें आवश्यक समाधान के रूप में उपज देता है।

Comments

मुझे लगता है कि आप फंक्शन नए के बजाय eval + ES6 सिंटैक्स का उपयोग करके एक अच्छा सा शेव कर सकते हैं

— Ven

Answer 2

जावास्क्रिप्ट (Node.js) , 106 93 बाइट्स

a=>eval(`f=x=>${a[R='replace'](/(\d)x/g,"$1*x")[R]("=","-(")[R](/-/g,"+-")})`)(0)/(f(0)-f(1))

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

-13 बाइट्स @tsh को धन्यवाद

Ungolfed:

var h=a=>{
  a=a.replace(/(\d)x/g,"$1*x").replace("=","-(").replace("--","- -"); //get into an eval-able form
  var f=x=>eval(a+")");
  var df=(f(1)-f(0))/(1-0) //derivative or slope of the function
  var x=0;
  return x-(f(x)/df); //newton's method
}

explaination:

यह समाधान जड़ों को खोजने के लिए न्यूटन की विधि द्वारा काम करता है । कोड बाएं हाथ की ओर से समीकरण के दाहिने हाथ की ओर, जैसे कि जब कि घटा देती है f(x)=0, xमूल्य हम के लिए हल करते बराबर होगा। इसलिए, जब हम इस नए फ़ंक्शन की जड़ पाते हैं, तो यह हमारा वांछित xमूल्य होगा। फिर यह f'(x)फ़ंक्शन पर दो बिंदुओं के बीच ढलान को खोजकर व्युत्पन्न पाता है । फिर, मूल्यों को बस न्यूटन की विधि में डाला जाता है जो रूट के एक अनुमान के लिए बताता है x, x=x-(f(x)/f'(x))(कोड में, हम 0 का उपयोग प्रारंभिक xमूल्य के रूप में करते हैं)। चूंकि यह जड़ें खोजता है, इसलिए यह हमारे xमूल्य को खोजता है । और चूंकि समीकरण रैखिक होने की गारंटी है, इसलिए अनुमान सटीक होगा।

Comments

93 बाइट्स

— 3

Answer 3

मठकाद, [निर्मित में उपयोग करता है]

मथकड में ऐसे समीकरणों को हल करने के दो अंतर्निहित तरीके हैं:

• प्रतीकात्मक विलायक (कीवर्ड हल का उपयोग करता है)
• ब्लॉक को हल करें (जो संख्यात्मक और प्रतीकात्मक दोनों मोड में काम करता है)। एक सॉल्यूशन ब्लॉक कीवर्ड के साथ शुरू होता है, ब्याज की शर्तों को परिभाषित करने वाले भावों के एक सेट के बाद, और एक हल करने वाले कीवर्ड्स में से एक द्वारा बंद हो जाता है, जैसे Find (जो एक सटीक समाधान पाता है) या MinErr (जो लक्ष्य के बीच त्रुटि को कम करता है और कोई भी समाधान)।

प्रतीकात्मक सॉल्वर y = x से काफी खुश है और समाधान x = y लौटाता है।

Mathcad से अपरिचित लोगों के लिए, नीचे दी गई छवि WYSIWYGish Mathcad 15 वर्कबुक से सीधे ली गई है। जहाँ वे लिखे गए हैं, उनमें से किसी भी भाव को बदलने से उसके उत्तर का पुनर्मूल्यांकन होगा और तदनुसार प्रदर्शन को अद्यतन किया जाएगा।

Comments

बेकार की जिज्ञासा से बाहर, नीचे क्यों? मैं समझ सकता हूं कि इसकी सरलता इसके मूल में हो सकती है, लेकिन यह मूल रूप से TI बेसिक सॉल्यूशन से अलग नहीं है, जो कि बिल्ट-इन सॉल्वर को कॉल करने से पहले थोड़े से इनपुट प्रोसेसिंग को जोड़ता है और फिर भी नीचा नहीं था।

— स्टुअर्ट ब्रूफ

इस कार्यक्रम की वास्तविक बाइट गिनती क्या है?

— जो किंग

डाउनवोट होने की संभावना है क्योंकि आपका समाधान तुच्छ है - देखें 'एक तुच्छ समाधान क्या है?' मेटा पर।

Answer 4

Axiom, 214 बाइट्स [बिल्ट-इन का उपयोग करता है]

q(t:EQ POLY FLOAT):Any==(a:=[variables(lhs t),variables(rhs t)];a.1~=[x]and a.1~=[]=>%i;a.2~=[x]and a.2~=[]=>%i;a.1=[]and a.2=[]=>%i;a.1=[x]and degree(lhs t,x)>1=>%i;a.2=[x]and degree(rhs t,x)>1=>%i;rhs solve(t).1)

कुछ त्रुटि के लिए% i वापस आ जाएगा, अन्य प्रकार की त्रुटियों के लिए फ़ंक्शन को सिस्टम से रोक दिया जाता है, 1--2 के रूप में कुछ और भाषा से बाहर लगता है ...:

(72) -> q(x+3=9)
   (72)  6.0
                                  Type: Complex Fraction Polynomial Float
(73) -> q(3+4=x)
   (73)  7.0
                                  Type: Complex Fraction Polynomial Float
(74) -> q(4+x=5)
   (74)  1.0
                                  Type: Complex Fraction Polynomial Float
(75) -> q(3+3*3=x)
   (75)  12.0
                                  Type: Complex Fraction Polynomial Float
(76) -> q(3*x-4=7+2*x)
   (76)  11.0
                                  Type: Complex Fraction Polynomial Float
(77) -> q(3--1=x)
  Line   1: q(3--1=x)
           .AB
  Error  A: Missing mate.
  Error  B: syntax error at top level
  Error  B: Possibly missing a )
   3 error(s) parsing
(77) -> q(3*(2+4*x)=7*x-4)
   (77)  - 2.0
                                  Type: Complex Fraction Polynomial Float
(78) -> q(1.2+2.3*x=5.8)
   (78)  2.0
                                  Type: Complex Fraction Polynomial Float
(79) -> q(10=4*x)
   (79)  2.5
                                  Type: Complex Fraction Polynomial Float
(80) -> q((5)(4)=x)
   Cannot find a definition or applicable library operation named 5
      with argument type(s)
                           PositiveInteger

  Perhaps you should use "@" to indicate the required return type,
  or "$" to specify which version of the function you need.
(80) -> q(5(x+3)=2 )
   (80)  %i
                                                    Type: Complex Integer
(81) -> q(x=y)
   (81)  %i
                                                    Type: Complex Integer
(82) -> q(4=3)
   (82)  %i
                                                    Type: Complex Integer
(83) -> q(x+3=x-7)
   >> Error detected within library code:
   inconsistent equation
protected-symbol-warn called with (NIL)
(83) -> q(x=x)
   >> Error detected within library code:
   equation is always satisfied
protected-symbol-warn called with (NIL)