एक अभिव्यक्ति, कई मूल्य

Question

हमारे परिचित गणितीय प्रतीकों का उपयोग करना: +, x, कोष्ठक और कोई तर्कसंगत संख्या, कुछ आसान संख्याओं का मूल्यांकन करने वाले भावों को बनाना आसान है। उदाहरण के लिए: 1+(2x3)=7, (1+2)+(3x6.5)=22.5और पर इतना। काफी बोरिंग है।

इस चुनौती के लिए, हम एक नए ऑपरेटर का उपयोग करेंगे: ±। के उपयोग के ±एक अभिव्यक्ति में साधन आप की जगह अभिव्यक्ति मूल्यांकन करने की जरूरत ±द्वारा की +या -हर संभव तरीके में, और सभी संभव मूल्यों का वह समूह वापस जाएँ। उदाहरण के लिए:

• 1±2±3 = {-4,0,2,6}क्योंकि 1±2±3कोई भी हो सकता 1+2+3, 1+2-3, 1-2+3और 1-2-3और उनके मान रहे हैं 6,0,2,-4क्रमशः।
• (±2)x(2±3) = {-10,-2,2,10} इसी तरह के कारणों के लिए।

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

कार्य

आपका काम अपनी पसंद का एक भाषा, कि एक दृश्य (सूची / सरणी / किसी भी सुविधाजनक प्रारूप) की लेता है में एक कार्यक्रम या समारोह लिखना है पूर्णांकों (एक स्ट्रिंग के रूप में) और एक अभिव्यक्ति आउटपुट से मिलकर +, x, (, ), ±, और तर्कसंगत संख्याओं जो दिए गए नंबरों के सेट का मूल्यांकन करता है।

• ध्यान दें कि सटीक चरित्र ±मायने नहीं रखता है; आप अपनी पसंद के किसी भी अन्य चरित्र का उपयोग कर सकते हैं जब तक कि यह आपके द्वारा उपयोग किए जा रहे अन्य वर्णों से अलग हो। लेकिन आपको इस बात का उल्लेख करना होगा कि आप अपने जमा करने के लिए किस चरित्र का उपयोग कर रहे हैं।
• इनपुट का उपयोग उपयोग किए गए तर्कसंगत संख्याओं के दशमलव सन्निकटन (उचित सटीकता तक) से करने की अनुमति है।
• इनपुट और आउटपुट को किसी भी मानक तरीके से लिया जा सकता है।
• मानक खामियों को मना किया जाता है।
• आप मान सकते हैं कि दिए गए पूर्णांक अलग-अलग होंगे, और बढ़ते क्रम में प्रदान किए जाएंगे।
• आउटपुट में रिक्त स्थान और newlines हो सकते हैं।

जीत का मानदंड

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा कोड है।

उदाहरण

इनपुट | संभव उत्पादन
------------- + -----------------------------
[1,2,3] | 2 ± 0.5 ± 0.5                   
[-7, -3,1,21] | (1 ± 2) x (3 ± 4)

_{2015 के टूर्नामेंट में एक प्रश्न से लिया गया आइडिया , फॉल 2015 ।}

Comments

PPCG में आपका स्वागत है! अच्छी पहली चुनौती! मुझे लगता है कि यह अधिक जवाब आकर्षित करेगा यदि यह आसपास का दूसरा तरीका था (सेट को अभिव्यक्ति दी जाए) क्योंकि ऐसा लगता है कि यह काफी मुश्किल चुनौती है। फिर भी अच्छी चुनौती!

— हाइपरएन्यूट्रीनो

पुन: स्वागत है! @HyperNeutrino पर जोड़ते हुए, संभवतः कुछ सेटों में से कई समाधान होंगे, जो एक समस्या हो सकती है, जब निर्णय लेना "सबसे अच्छा" है जब तक कि निर्णायक कारक निर्णायक नहीं है

— डेविड आर्किबाल्डो

@HyperNeutrino धन्यवाद! मैंने आशंका जताई कि यह थोड़ा कठिन हो सकता है, लेकिन मैं पूरी तरह से यहां के गोल्फरों की श्रेष्ठ क्षमताओं पर विश्वास करता हूं; आइए देखें कि यह कैसे निकलता है। :)

— अंकोगनीत

हाँ। इस साइट पर मौजूद कुछ गोल्फरों के पास कमाल के सुपरपावर हैं, और हमें शक भी है कि कुछ गोल्फिंग बॉट्स> _>: D

— HyperNeutrino

@DavidArchibald हाँ, इच्छित आउटपुट कोई भी समाधान है जो काम करता है।

— अंकोगनीत

Answer 1

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

f=lambda h,*t:t and"(.5?.5)*(%s+%%s)+"%f(*t)%-h+`h`or`h`

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

?के लिए खड़ा है ±। उदाहरण का उपयोग:

f(-3,5,20) ->
(.5?.5)*((.5?.5)*(20+-5)+5+3)+-3

विचार यह है कि हम एक अभिव्यक्ति ले सकते हैं Eऔर एक नए मूल्य hको इसके मूल्यों के सेट से जोड़ सकते हैं (.5±.5)*(E+-h)+h।

Comments

+-hसिर्फ क्यों और कैसे नहीं -h? यही कारण है, क्यों नहीं बनाते हैं और +एक -है -कि कार्यक्रम में वर्तमान में हटा दें ?

— isaacg

@isaacg कल्पना -अभिव्यक्ति में ऑपरेटर के लिए अनुमति नहीं देती है ।

— xnor

Answer 2

हास्केल , 52 बाइट्स

f(h:t)=shows h"+(.5?.5)*("++f[x-h|x<-t]++")"
f e="0"

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

के लिए उपयोग करता ?है ±। उदाहरण:

f [1,3,7] ->
1+(.5?.5)*(2+(.5?.5)*(4+(.5?.5)*(0)))

फ़ंक्शन showsकरता है shows a b=(show a)++b, एक चाल जिसे मैंने लिन से सीखा है।

shows 12 "abc" ->
"12abc"

Answer 3

हास्केल , 58 बाइट्स

का उपयोग #करने के लिए ±, के रूप में यह एक कम बाइट है।

f पूर्णांकों की सूची लेता है और एक स्ट्रिंग लौटाता है।

f[x]=show x
f(x:r)=show x++"+(.5#.5)x("++f((-x+)<$>r)++")"

परिणाम फॉर्म का है n+(.5#.5)x(rest), जहां nसूची का पहला तत्व है और प्रत्येक से घटाए गए restसभी अन्य लोगों का प्रतिनिधित्व है n।

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

Answer 4

जेली , 29 बाइट्स

“(¤)”j.⁾+×j;”(
I;@Ḣj¢;”)ẋ⁸L¤¤

प्रिंट्स v + (0.5¤0.5) × (i ₁ + (0.5¤0.5) × (i ₂ + (0.5¤0.5) × (... (i _n ) ...)) जहाँ v पहले नंबर पर है इनपुट सरणी और मैं _n है n ^वें इनपुट सरणी के तत्वों के बीच वृद्धिशील अंतर।

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

कैसे?

“(¤)”j.⁾+×j;”( - Link 1, adjoining list: no input
“(¤)”          - literal     ['(','¤',')']
      .        - literal     0.5
     j         - join        ['(',0.5,'¤',0.5,')']
       ⁾+×     - literal     ['+','×']
          j    - join        ['+',['(',0.5,'¤',0.5,')'],'×']
            ”( - literal     '('
           ;   - concatenate ['+',['(',0.5,'¤',0.5,')'],'×','(']

I;@Ḣj¢;”)ẋ⁸L¤¤ - Main link: list a               e.g. [-1,5,2]
I              - incremental differences(a)           [6,-3]
   Ḣ           - head(a)                              [-1]
 ;@            - concatenate (rev @rgs)               [-1,6,-3]
     ¢         - last link (1) as a nilad             ['+',['(',0.5,'¤',0.5,')'],'×','(']
    j          - join                                 [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3]
             ¤ - nilad followed by link(s) as a nilad
            ¤  -     nilad followed by link(s) as a nilad
          ⁸    -         link's left argument, a
           L   -         length                       3
       ”)      -     literal ')'
         ẋ     -     repeat                           [')',')',')']
      ;        - concatenate                          [-1,['+',['(',0.5,'¤',0.5,')'],'×','('],6,['+',['(',0.5,'¤',0.5,')'],'×','('],-3,')',')',')']
               - implicit print                       -1+(0.5¤0.5)×(6+(0.5¤0.5)×(-3))

Answer 5

05AB1E , 25 बाइट्स

0¸«¥X;D"+(ÿ±ÿ)*("ý¹g<')×J

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

व्याख्या

0¸«                        # prepend a 0 to input list
   ¥                       # calculate delta's
    X;D                    # push 0.5 twice
       "+(ÿ±ÿ)*("          # push this string and interpolate 0.5 where "ÿ" is
                 ý         # merge the list of delta's with this string as a separator
                  ¹g<')×J  # add the closing parenthesis

दुर्भाग्य से अभिव्यक्ति का निर्माण दुर्भाग्य से उसी बाइट के साथ होता है
0¸«¥¤s¨RvX;Dy"ÿ+(ÿ±ÿ)*(ÿ)। सेटअप के लिए उपयोग किए जाने वाले 8 बाइट यहां का बड़ा कचरा है।

Answer 6

हास्केल, 54 बाइट्स

f[]="0"
f(x:s)=show x++"+(.5?.5)*("++f(map(-x+)s)++")"

+ - संकेत है '?'। उदाहरण:

f[1,2,3,4] = "1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(1+(.5#.5)*(0))))"

Answer 7

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

f=([v,...a],x=v)=>x?x+`+(.5@.5)*(${f(a,a[0]-v)})`:0

@ जोनाथनअल्लन के फॉर्मूले के आधार पर। @के लिए खड़ा है ±।