एससीआई कला समीकरण विज़ुअलाइज़र

Question

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

इंटीग्रल [x ^ 3 e ^ ((mx ^ 2 b / 2), dx] = - (((2 + b m x ^ 2) / (b ^ 2 * e ^ ((b m x ^ 2) / 2) * m ^ 2))

पर integrals.wolfram.com , इस "इनपुट फार्म।" कहा जाता है कोई भी व्यक्ति "इनपुट फॉर्म" में समीकरण देखना पसंद नहीं करता है। इस समीकरण की कल्पना करने का आदर्श तरीका होगा:

(वोल्फ्राम इसे "पारंपरिक रूप" कहते हैं)

इस कोडगॉल्फ के लिए, एक प्रोग्राम लिखें जो इनपुट के रूप में "इनपुट फॉर्म" में कुछ समीकरण लेगा और "पारंपरिक रूप" के ascii प्रतिनिधित्व में उस समीकरण को कल्पना करेगा। तो, इस उदाहरण के लिए हमें कुछ इस तरह मिल सकता है:

       /\      3
       |      x
       | ------------  dx = 
       |       2
      \/   (m x  b)/2
          e

              2
     2 + b m x
-(-----------------)
            2
   2  (b m x )/2  2
  b  e           m

आवश्यकताएँ:

1. किसी भी तरह से इनपुट को फेरबदल, सरल या पुनर्व्यवस्थित न करें। इसे उसी रूप में प्रस्तुत करें जैसा कि इसे इनपुट द्वारा वर्णित किया गया था।
2. चार बुनियादी गणितीय संक्रियाओं (+, -, *, /) का समर्थन करें। दो आसन्न संख्याओं को गुणा न करने पर * प्रतीक निहित होता है और इसे छोड़ दिया जाना चाहिए।
3. एकीकरण के लिए समर्थन (जैसा कि ऊपर उदाहरण में दिखाया गया है) की आवश्यकता नहीं है। एकीकृत [...] या Sqrt [...] जैसे कार्यों के साथ इनपुट का समर्थन करने में सक्षम होने के नाते एक बोनस है।
4. उपर्युक्त उदाहरण में दर्शाई गई समर्थन शक्तियाँ (nth रूट को 1 / nth पावर तक बढ़ाकर मॉडल किया जा सकता है)।
5. निरर्थक कोष्ठक (जैसे कि उपर्युक्त उदाहरण में बड़े अंश के संप्रदाय और अंश के आसपास के लोग) को छोड़ दिया जाना चाहिए।
6. एक अंश के हर और अंश में अभिव्यक्ति क्षैतिज विभाजन रेखा के ऊपर और नीचे केंद्रित होनी चाहिए।
7. आप चुन सकते हैं कि समान संकेत के बाद एक नई लाइन शुरू करें या नहीं। ऊपर के उदाहरण में, एक नई लाइन शुरू की गई है।
8. संचालन का क्रम आउटपुट में बिल्कुल वैसा ही होना चाहिए जैसा कि इनपुट में है।

आपके समाधान के परीक्षण के लिए इनपुट और संबंधित आउटपुट के कुछ उदाहरण:

इनपुट:

1/2 + 1/3 + 1/4

आउटपुट:

1   1   1
- + - + -
2   3   4

इनपुट:

3x^2 / 2 + x^3^3

आउटपुट:

   2     3
3 x     3
---- + x   
 2

इनपुट:

(2 / x) / (5 / 4^2)

आउटपुट:

2
-
x
--
5
--
 2
4

इनपुट:

(3x^2)^(1/2)

आउटपुट:

    2 1/2
(3 x )

Comments

आपके सवाल में आम तौर पर एक टैग होना चाहिए जो यह व्यक्त करता है कि यह किस तरह की प्रतियोगिता है। मैंने एक जोड़ने की स्वतंत्रता ले ली है क्योंकि आपने पाठ में "कोडगॉल्फ" कहा है।

— dmckee --- पूर्व-मध्यस्थ ने बिल्ली का बच्चा

कोड-गोल्फ होने के लिए यह समस्या बहुत ही भयानक है। आप यह नहीं कहते हैं कि किस निर्माण का समर्थन किया जाना चाहिए, या उन्हें क्या देखना होगा। क्या सिर्फ +, -, *, और / का समर्थन करना पर्याप्त होगा? क्या सिग्मा का समर्थन करना है? ग्रीक अक्षरों के बारे में क्या? प्रश्न के संभावित समाधान जैसा कि आपने देखा है कि यह कोड-लंबाई की तुलना में कार्यक्षमता में बहुत भिन्न हो सकता है।

— माउंटन व्यूमार्क

@MtnViewMark, मैंने कुछ "आवश्यकताएँ" जोड़ीं ... मुझे बताएं कि क्या गोल्फ अब बेहतर है।

— आमी

@ अम्मी - हाँ, बहुत।

— माउंटन व्यूमार्क

मैं MtnViewMark से सहमत हूं, यह बहुत ही खुले अंत और अस्पष्ट लगता है। शायद आप गोल्फिंग के उद्देश्यों के लिए इनपुट और आउटपुट को टेस्टकेस के एक अच्छी तरह से परिभाषित सेट तक सीमित करना बेहतर होगा। क्या आपने एक संदर्भ कार्यान्वयन किया है?

— gnibbler

Answer 1

पायथन 2, 1666 चार्ट

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

import re,shlex
s=' '
R=range

# Tokenize.  The regex is because shlex doesn't treat 3x and x3 as two separate tokens.  The regex jams a space in between.                                                 
r=r'\1 \2'
f=re.sub
x=shlex.shlex(f('([^\d])(\d)',r,f('(\d)([^\d])',r,raw_input())))
T=[s]
while T[-1]:T+=[x.get_token()]
T[-1]=s

# convert implicit * to explicit *                                                                                                                                          
i=1
while T[i:]:
 if(T[i-1].isalnum()or T[i-1]in')]')and(T[i].isalnum()or T[i]in'('):T=T[:i]+['*']+T[i:]
 i+=1

# detect unary -, replace with !                                                                                                                                            
for i in R(len(T)):
 if T[i]=='-'and T[i-1]in'=+-*/^![( ':T[i]='!'
print T

# parse expression: returns tuple of op and args (if any)                                                                                                                   
B={'=':1,',':2,'+':3,'-':3,'*':4,'/':4,'^':5}
def P(t):
 d,m=0,9
 for i in R(len(t)):
  c=t[i];d+=c in'([';d-=c in')]'
  if d==0and c in B and(B[c]<m or m==B[c]and'^'!=c):m=B[c];r=(c,P(t[:i]),P(t[i+1:]))
 if m<9:return r
 if'!'==t[0]:return('!',P(t[1:]))
 if'('==t[0]:return P(t[1:-1])
 if'I'==t[0][0]:return('I',P(t[2:-1]))
 return(t[0],)

# parenthesize a layout                                                                                                                                                     
def S(x):
 A,a,b,c=x
 if b>1:A=['/'+A[0]+'\\']+['|'+A[i]+'|'for i in R(1,b-1)]+['\\'+A[-1]+'/']
 else:A=['('+A[0]+')']
 return[A,a+2,b,c]

# layout a parsed expression.  Returns array of strings (one for each line), width, height, centerline                                                                      
def L(z):
 p,g=z[0],map(L,z[1:])
 if p=='*':
  if z[1][0]in'+-':g[0]=S(g[0])
  if z[2][0]in'+-':g[1]=S(g[1])
 if p=='^'and z[1][0]in'+-*/^!':g[0]=S(g[0])
 if g:(A,a,b,c)=g[0]
 if g[1:]:(D,d,e,f)=g[1]
 if p in'-+*=,':
  C=max(c,f);E=max(b-c,e-f);F=C+E;U=[s+s+s]*F;U[C]=s+p+s;V=3
  if p in'*,':U=[s]*F;V=1
  return([x+u+y for x,u,y in zip((C-c)*[s*a]+A+(E-b+c)*[s*a],U,(C-f)*[s*d]+D+(E-e+f)*[s*d])],a+d+V,F,C)
 if'^'==p:return([s*a+x for x in D]+[x+s*d for x in A],a+d,b+e,c+e)
 if'/'==p:w=max(a,d);return([(w-a+1)/2*s+x+(w-a)/2*s for x in A]+['-'*w]+[(w-d+1)/2*s+x+(w-d)/2*s for x in D],w,b+e+1,b)
 if'!'==p:return([' -  '[i==c::2]+A[i]for i in R(b)],a+2,b,c)
 if'I'==p:h=max(3,b);A=(h-b)/2*[s*a]+A+(h-b+1)/2*[s*a];return(['  \\/|/\\  '[(i>0)+(i==h-1)::3]+A[i]for i in R(h)],a+3,h,h/2)
 return([p],len(p),1,0)

print'\n'.join(L(P(T[1:-1]))[0])

प्रश्न में बड़े इनपुट के लिए, मुझे:

 /\         2                     2 
 |     - m x  b          2 + b m x  
 |     --------    = - -------------
 |  3      2                    2   
\/ x  e         dx         b m x    
                           ------   
                        2     2    2
                       b  e       m 

यहाँ कुछ और पेचीदा परीक्षण मामले हैं:

I:(2^3)^4
O:    4
  / 3\ 
  \2 / 

I:(2(3+4)5)^6
O:             6
  (2 (3 + 4) 5) 

I:x Integral[x^2,dx] y
O:   /\ 2     
  x  | x  dx y
    \/        

I:(-x)^y
O:     y
  (- x) 

I:-x^y
O:     y
  (- x)

पिछले एक गलत है, पार्सर में कुछ पूर्ववर्ती त्रुटि।

Comments

अभिन्न तर्क की आधार रेखा को अभिन्न के बाद मौखिक रूप से केंद्रित नहीं किया जाना चाहिए? वर्तमान में यह इंटीग्रल के सबस्क्रिप्ट की तरह दिखता है।

— जॉय

बदलने के लिए मुश्किल नहीं है, लेकिन यह कुछ जगह बर्बाद करेगा। मैं वर्तमान में अपने तर्क (3 उच्च न्यूनतम के साथ) का विस्तार करने के लिए अभी-अभी अभिन्न संकेत करता हूं।

— कीथ रान्डेल

थोड़ा गोल्फ: डबल स्पेस के बजाय टैब का उपयोग करें।

— कैलक्यूलेटरफलाइन