एक रेखांकन कैलकुलेटर लागू करें

Question

कैलकुलेटर से जुड़े कई सवाल हैं; हालाँकि, ऐसा नहीं लगता है कि किसी भी रेखांकन कैलकुलेटर को लागू करना शामिल है।

चुनौती

आपको एक पूरा कार्यक्रम लिखना है जो STDIN से इनपुट के रूप में कई सूत्र लेता है और उन्हें STDOUT में रेखांकन करता है। इनपुट फॉर्म लेंगे f1(x)=x^2-x-1। वहाँ एक हो जाएगा fएक नंबर 0-9 (सम्मिलित) के द्वारा पीछा किया, जिसके बाद (x)=, ग्राफ के लिए सूत्र के द्वारा पीछा किया। आपका प्रोग्राम इनपुट, ग्राफ, अधिक इनपुट, ग्राफ आदि लेने में सक्षम होना चाहिए।

यह कोड गोल्फ है।

आपके ग्राफ़ में प्रत्येक 1/2 यूनिट में कम से कम एक बिंदु के रिज़ॉल्यूशन के साथ -5 से 5 तक एक्स-एक्सिस रेंज होनी चाहिए। Y- अक्ष आवश्यकताएँ समान हैं। यह आधुनिक कैलकुलेटर की तुलना में एक छोटी रेंज की तरह लग सकता है, लेकिन इसे बढ़ाने में यह सबसे अधिक संभावना है। ग्राफ़ +में पूर्णांक के रूप में टिक के निशान के साथ उन पर खींची गई धुरी होनी चाहिए ।

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

जब किसी सूत्र को रेखांकन किया जाता है, तो सूत्र की संख्या से इसकी रेखा बनाई जानी चाहिए। जब कोई रेखा किसी अक्ष को पार करती है, तो अक्ष को शीर्ष पर खींचा जाना चाहिए। जब दो लाइनें एक-दूसरे को पार करती हैं, तो इससे कोई फर्क नहीं पड़ता है जो दिखाया गया है।

उदाहरण इनपुट

f1(x)=x+1

उत्पादन

          +       1
          |      1
          +     1
          |    1
          +   1
          |  1
          + 1
          |1
          +
         1|
+-+-+-+-+-+-+-+-+-+-+
       1  |
      1   +
     1    |
    1     +
   1      |
  1       +
 1        |
1         +
          |
          +

इनपुट

f2(x)=(x^2)^0.25

उत्पादन

          +       1
          |      1
          +     1
          |    1
          +   1
          |  1
2222      + 1    2222
    222   |1  222
       22 + 22
         2|2
+-+-+-+-+-+-+-+-+-+-+
       1  |
      1   +
     1    |
    1     +
   1      |
  1       +
 1        |
1         +
          |
          +

इनपुट

f1(x)=-x  

(ध्यान दें, यह आपके प्रोग्राम को इस इनपुट को अस्वीकार करने के लिए स्वीकार्य है और केवल 0-x या x * -1 को छोड़कर, लेकिन इसे प्रलेखित किया जाना चाहिए)

उत्पादन

1         +
 1        |
  1       +
   1      |
    1     +
     1    |
2222  1   +      2222
    2221  |   222
       22 + 22
         2|2
+-+-+-+-+-+-+-+-+-+-+
          |1
          + 1
          |  1
          +   1
          |    1
          +     1
          |      1
          +       1
          |        1
          +         1

Answer 1

पर्ल, 177 अक्षर (+1 कमांड लाइन स्विच)

perl -nE 's!\^!**!g;s!x!(\$k/2-6)!g;s/\d.*=/;/;$f[$&]=$_;my%a;for$k(@x=2..22){$i=0;$a{int 12.5-2*eval}[$k-2]=$i++for@f}$p="|";$$_[10]=$p^=W,$a{12}=[$p."-+"x10],say map$_//$",@$_ for@a{@x}'

प्रति इस मेटा धागा , मेरा मानना है कि इस योग में 178 पात्रों के रूप में गिना जाए।

रूबी समाधान की तरह, मैं भी उपयोग कर रहा हूँ evalऔर जगह ^के साथ **।

इनपुट पार्सिंग एक ही समय में अविश्वसनीय रूप से नाजुक और अविश्वसनीय रूप से मजबूत दोनों है: या तो या तो बस के f1(x)=रूप में लिखा जा सकता है , लेकिन बहुत अजीब चीजें हो सकती हैं यदि आप किसी ऐसी चीज के साथ प्रतिस्थापित करते हैं जो एक वैध, पक्ष-प्रभावहीन पर्ल स्टेटमेंट नहीं है। आपको चेतावनी दी गई है।f 1 ( x ) =foo 1 bar =1=f

ब्याज के अन्य विवरणों में ऊर्ध्वाधर अक्ष को खींचने का तरीका शामिल है, जो इस तथ्य का फायदा उठाता है कि पात्रों का बिटवाइंड XOR +और |है W। जाहिर है, यह EBCDIC सिस्टम पर काम नहीं करेगा।

आउटपुट को सरणियों के एक हैश में प्रस्तुत किया जाता है, न कि सरणी का एक सरणी - यह पता चलता है कि यह पूर्णांक के लिए हैश कुंजी को स्पष्ट रूप से कम करने के लिए कम वर्ण लेता है और फिर हैश स्लाइस पर लूप की तुलना में यह सुनिश्चित करने के लिए लेता है कि कोई सरणी नहीं है नकारात्मक मूल्यों के साथ अनुक्रमित। मैं दो और पात्रों को काट सकता था यदि यह कष्टप्रद तरीके के लिए नहीं थे, तो पर्ल का intशून्य के प्रति नकारात्मक मान कम हो जाता था, जिसने मुझे शीर्ष किनारे पर कलाकृतियों को गोल करने से बचने के लिए 0 से 20 के बजाय आउटपुट पंक्तियों को 2 से 22 तक सीमित करने के लिए मजबूर किया। उत्पादन क्षेत्र का।

मैं इनपुट पार्सिंग में पर्ल के उदार स्ट्रिंग-टू-नंबर रूपांतरण का उपयोग करता हूं, जहां मैं 1(x)=एक सरणी सूचकांक के रूप में पूरे स्ट्रिंग का उपयोग करता हूं (यह सिर्फ 1 में परिवर्तित हो जाता है)।

मैं कर सकता भी बचाने तीन और वर्ण (और पार्स थोड़ा और अधिक मजबूत बनाने) की जगह s/\d.*=/;/;$f[$&]=$_के साथ /\d.*=/;$f[$&]=$', लेकिन फिर मैं लिखने के लिए अतिरिक्त वर्णों की संख्या समान खर्च करने के लिए होगा $'के रूप में $'\''एक एकल उद्धृत खोल स्ट्रिंग में। मुझे लगता है कि तकनीकी रूप से मुझे उन लोगों की गिनती नहीं करनी होगी, लेकिन यह धोखा देने जैसा लगता है।

Answer 2

रूबी, 200 अक्षर

f={}
r=0..20
(f[gets[1]]=$_[6..-1].gsub /\^/,'**'
s=r.map{' '*21}
f.map{|n,k|r.map{|y|x=y*0.5-5
v=(2*eval(k)).round
v.abs<11&&y!=10&&s[10-v][y]=n
s[y][10]='+|'[y%2]
s[10][y]='+-'[y%2]}}
puts s)while 1

अभिव्यक्तियों के लिए मानक मूल्यांकनकर्ता का उपयोग करके एक सादा रूबी कार्यान्वयन ( ^प्रतिस्थापित किया जाएगा ताकि काम ठीक ऊपर दिए गए उदाहरण)। यह बहुत मजबूत नहीं है और इनपुट को बिल्कुल उसी तरह मानता है जैसा कि प्रश्न में निर्दिष्ट है।

Comments

पांचवीं पंक्ति पर, क्या आप दो वर्णों y*0.5को बदल सकते हैं y/2और निकाल सकते हैं? मैं रूबी को नहीं जानता, इसलिए मैं सही नहीं हो सकता।

— PhiNotPi 19

@PhiNotPi दुर्भाग्य से यह काम नहीं करेगा। y/2पूर्णांक विभाजन करता है।

— हॉवर्ड

के loop{}बजाय आप का उपयोग कर सकते हैं ()while 1?

— डेथ जूल

यह दाहिने हाथ की तरफ साइड बार पर लिंक के माध्यम से मिला। यह बहुत अच्छी तरह से किया गया है। मुझे इस छोटे को पाने की कोशिश में कुछ मज़ा आया, लेकिन मुझे केवल 9 बाइट्स मिले , एक बाइट रूबी 2.1 (?) में पेश की गई शाब्दिक शाब्दिक सामग्री पर निर्भर थी।

— ब्लुटोरांगे

Answer 3

पायथन 2: 320 वर्ण

N=20
r=range(N+1)
d={}
while(1):
 l=raw_input()
 d[l[1]]=l[6:].replace('^','**')
 g=[[' ']*(N+1) for i in r]
 for n,f in d.items():
  for x in r:
   v=N/2+int(round(2*eval(f.replace('x','(%f)'%(x/2.0-N/4)))))
   if 0<=v<=N:g[N-v][x]=n
 for i in r:
  g[i][N/2]='+|'[i%2]
  g[N/2][i]='+-'[i%2]
 for l in g:print''.join(l)

शायद कम किया जा सकता है, लेकिन मैं इस पर एक नौसिखिया का एक सा हूँ :)

Nएक चर बनाने से 9 वर्ण व्यर्थ हो जाते हैं लेकिन मुझे यह बेहतर लगता है।