इसके अलावा गुणा करने के लिए घातांक

Question

2 पूर्णांक के बीच गुणा को इसके अलावा की श्रृंखला में घटाया जा सकता है

3 * 5 = 3 + 3 + 3 + 3 + 3 = 5 + 5 + 5

घातांक (ऊपर उठाने के लिए एक सत्ता में ख ) भी गुणा की एक श्रृंखला में कम किया जा सकता:

5 ^ 3 = 5 * 5 * 5

इसलिए, एक्सप्रेशन को कई गुणा जोड़कर घटाया जा सकता है, फिर गुणन अभिव्यक्ति बनाकर, फिर जोड़ की श्रृंखला में। उदाहरण के लिए, 5 ^ 3(5 घन) को फिर से लिखा जा सकता है

5 ^ 3 = 5 * 5 * 5
      = (5 + 5 + 5 + 5 + 5) * 5
      = (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5) + (5 + 5 + 5 + 5 + 5)
      = 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5

आपका कार्य यह है कि एक्सप्रेशन, गुणा और जोड़ को मिलाकर दिए गए एक्सप्रेशंस इसे जोड़कर सबसे छोटी श्रृंखला में जोड़ते हैं। "सबसे छोटी" अभिव्यक्ति को सबसे कम संख्या के +प्रतीकों के साथ अभिव्यक्ति के रूप में परिभाषित किया गया है , फिर भी मूल अभिव्यक्ति में दो में से केवल एक संख्या का उपयोग कर रहा है। उदाहरण के लिए, सबसे छोटी अभिव्यक्ति 10 * 2है 10 + 10।

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

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

इनपुट और आउटपुट को अलग रिक्त स्थान या अपने कार्यक्रमों में इस्तेमाल नहीं किया जा सकता, यानी 3 * 5के रूप में या तो outputted किया जा सकता है 5 + 5 + 5या 5+5+5।

ध्यान दें कि ज्यादातर मामलों में, इसके अलावा वास्तव में प्रदर्शन नहीं किया जाता है। एकमात्र ऐसा मामला जहां इसके अलावा प्रदर्शन किया जाना है, जब आपके पास ऐसा कुछ है 5 ^ (1 + 2), तो किस मामले में, जारी रखने के लिए इसके अलावा आवश्यक है -> 5 ^ 3 -> 5 * 5 * 5 -> ...। देखें टेस्ट केस # 4

आपके कोड को अस्पष्ट अभिव्यक्ति पर आने वाले इनपुट को संभालने की आवश्यकता नहीं है। उदाहरण के लिए, (2 + 2) * (4 + 1)। अब तक तय किए गए नियमों के कारण, लक्ष्य उत्तर की गणना नहीं करना है, लक्ष्य को परिवर्धन को सरल बनाना है। इसलिए परिणाम उस आदेश के आधार पर भिन्न हो सकता है जो अभिव्यक्तियों को हल किया जाता है या सराहा जाता है (जो सरल बनाने के लिए अतिरिक्त है, जिसे छोड़ना है?)। एक और अवैध उदाहरण: ((3 + 2) ^ 2) ^ 3 -> ((3 + 2) * (3 + 2)) ^ 3 -> ???।

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

परीक्षण के मामलों

Input => output

5 ^ 3 + 4 * 1 ^ 5 => 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 5 + 4
2 ^ 1 * 2 + 3 + 9 => 2 + 2 + 3 + 9
2 ^ 1 * (2 + 3) + 9 => 2 + 3 + 2 + 3 + 9
2 ^ (1 * (2 + 3)) + 9 => 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 9
10 + 3 * 2 + 33 ^ 2 => 10 + 3 + 3 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33 + 33
100 * 3 => 100 + 100 + 100
2 ^ 1 + 2 ^ 1 + 2 ^ 2 + 8 ^ 1 => 2 + 2 + 2 + 2 + 8
(1 + 2 + 5 * 8 + 2 ^ 4) * 2 => 1 + 2 + 8 + 8 + 8 + 8 + 8 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 1 + 2 + 8 + 8 + 8 + 8 + 8 + 2 + 2 + 2 + 2 + 2 + 2 + 2 + 2

Comments

क्या हम **इसके बजाय उपयोग कर सकते हैं ^?

— आउटगॉल्फ ऑक्ट

@EriktheOutgolfer हाँ, यह उचित लगता है।

— caird coinheringaahing

सम्बंधित।

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

मैं अभी भी उलझन में हूँ कि वैध आउटपुट का क्या मतलब है। सवाल में आप कहते हैं using only one of the two numbers in the original expression.लेकिन मूल अभिव्यक्ति दो से अधिक संख्या हो सकती है। मुझे नहीं मिलता कि क्यों के 8 + 8लिए एक वैध उत्पादन नहीं है 2 ^ 1 + 2 ^ 1 + 2 ^ 2 + 8 ^ 1। यह प्रश्न अभी भी मेरे लिए बहुत अस्पष्ट है।

— पोस्ट रॉक गरफ हंटर

Answer 1

रेटिना , 302 बाइट्स

मुझे यकीन है कि यह गोल्फ हो सकता है, लेकिन इस बिंदु पर, मुझे खुशी है कि यह काम करता है। घातांक और गुणन खंड दोनों बहुत समान हैं, लेकिन चूंकि संचालन का क्रम महत्वपूर्ण है, मुझे नहीं पता कि उन्हें कैसे संयोजित किया जाए।

y- घातांक
x- गुणन
p- जोड़

\d+
$*
{1`(\(\w+\)|1+)y(\(\w+\)|1+)
>$0<
(?<=>(\(\w+\)|1+)y1*)1
$1x
>(\(\w+\)|1+)y
(
x<
)
\((1+(x1+)*)\)(?!y)
$1
(?<!1)(1+)x(\(\w+\)|1+\1)(?!1)
$2x$1
1`(\(\w+\)|1+)x1+
>$0<
(?<=>(\(\w+\)|1+)x1*)1
$1p
>(\(\w+\)|1+)x
(
p<
)
(?<!x|y)\((1+(p1+)*)\)(?!x|y)
$1
y\((1+)p([1p]*\))
y($1$2
}`y\((1+)\)
y$1
1+
$.0

इसे ऑनलाइन आज़माएं - सभी परीक्षण मामले

टेस्ट केस कन्वर्टर

व्याख्या

\d+                             Convert to unary
$*
{1`(\(\w+\)|1+)y(\(\w+\)|1+)    Begin loop: Delimit current exponentiation group
>$0<
(?<=>(\(\w+\)|1+)y1*)1          Replace exponentiation with multiplication
$1x
>(\(\w+\)|1+)y                  Replace garbage with parentheses
(
x<
)
\((1+(x1+)*)\)(?!y)             Remove unnecessary parentheses around multiplication
$1
(?<!1)(1+)x(\(\w+\)|1+\1)(?!1)  Maybe swap order of multiplicands
$2x$1
1`(\(\w+\)|1+)x1+               Delimit current multiplication group
>$0<
(?<=>(\(\w+\)|1+)x1*)1          Replace multiplication with addition
$1p
>(\(\w+\)|1+)x                  Replace garbage with parentheses
(
p<
)
(?<!x|y)\((1+(p1+)*)\)(?!x|y)   Remove unnecessary parentheses around addition
$1
y\((1+)p([1p]*\))               Handle the 4th test case by adding if necessary
y($1$2
}`y\((1+)\)                     End of loop
y$1
1+                              Convert unary back to decimal
$.0

आप यह भी देख सकते हैं कि सबसे अधिक इस्तेमाल किया जाने वाला समूह है (\(\w+\)|1+)। यह कोष्ठक, या पूर्णांक के साथ एक आंतरिक अभिव्यक्ति से मेल खाता है। मैंने अपने द्वारा किए गए प्रतीकों का उपयोग करने के लिए चुना ताकि मैं \wएक चरित्र वर्ग के बजाय उपयोग कर सकूं। मुझे यकीन नहीं है कि अगर गैर-शब्द प्रतीकों का उपयोग करना बेहतर होगा और शब्द सीमाओं ( \b) के साथ कुछ लुकरॉइड्स को बदलना होगा ।

Answer 2

गणितज्ञ, २५० २१ 18 १ 170३ १atic० बाइट्स

f~(s=SetAttributes)~HoldAll;{a,t}~s~Flat;f@n_:=Infix[Hold@n//.{a_~Power~b_:>t@@Hold@a~Table~b,Times->t,Plus->a,Hold->Dot}/.t->(a@@Table[#,1##2]&@@Reverse@Sort@{##}&),"+"]

^{यह काम करता हैं! आखिरकार!}

में फ़ंक्शन को परिभाषित करता है f।

इनपुट एक सादा गणित अभिव्यक्ति है। (अर्थात 1 + 2नहीं "1 + 2")।

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

ध्यान दें कि TIO लिंक में थोड़ा अलग कोड है, TIO के रूप में (जो, मुझे लगता है, Mathematica कर्नेल का उपयोग करता है) पसंद नहीं है Infix। मैंने Riffleमैथेमैटिका आरईपीएल के समान उपस्थिति प्राप्त करने के बजाय उपयोग किया ।

Ungolfed

f~(s = SetAttributes)~HoldAll;  (* make f not evaluate its inputs *)

{a, t}~s~Flat;  (* make a and t flat, so that a[a[1,a[3]]] == a[1,3] *)

f@n_ :=  (* define f, input n *)

 Infix[

  Hold@n  (* hold the evaluation of n for replacement *)

    //. {  (* expand exponents *)

     (* change a^b to t[a,a,...,a] (with b a's) *)
     a_~Power~b_ :> t @@ Hold@a~Table~b,

     (* Replace Times and Plus with t and a, respectively *)
     Times -> t, 
     Plus -> a, 

     (* Replace the Hold function with the identity, since we don't need
         to hold anymore (Times and Plus are replaced) *)
     Hold -> Dot 

     } /.  (* Replace; expand all t (= `Times`) to a (= `Plus`) *)

        (* Take an expression wrapped in t. *)
        (* First, sort the arguments in reverse. This puts the term
            wrapped in `a` (if none, the largest number) in the front *)
        (* Next, repeat the term found above by <product of rest
            of the arguments> times *)
        (* Finally, wrap the entire thing in `a` *)
        (* This will throw errors when there are multiple elements wrapped
           in `a` (i.e. multiplying two parenthesized elements) *)
        t -> (a @@ Table[#, 1 ##2] & @@
               Reverse@Sort@{##} &),

  "+"]  (* place "+" between each term *)

Comments

ठीक है, मुझे खुशी है कि मैंने एक चुनौती बनाई है कि गणितज्ञ के लिए इसमें कोई निर्माण नहीं है: P

— caird coinheringaahing

Answer 3

गणितज्ञ, 405 406 बाइट्स

f~SetAttributes~HoldAll;p=(v=Inactive)@Plus;t=v@Times;w=v@Power;f@x_:=First@MinimalBy[Inactivate@{x}//.{w[a___,b_List,c___]:>(w[a,#,c]&/@b),t[a___,b_List,c___]:>(t[a,#,c]&/@b),p[a___,b_List,c___]:>(p[a,#,c]&/@b),p[a_]:>a,w[a_,b_]:>t@@Table[a,{Activate@b}],t[a___,t[b__],c___]:>t[a,b,c],p[a___,p[b__],c___]:>p[a,b,c],{a___,{b__},c___}:>{a,b,c},t[a__]:>Table[p@@Table[i,{Activate[t@a/i]}],{i,{a}}]},Length];f

अनगढ़ और समझाया गया

SetAttributes[f, HoldAll]
p = Inactive[Plus]; t = Inactive[Times]; w = Inactive[Power];
f[x_] := First@MinimalBy[
   Inactivate[{x}] //. {
     w[a___, b_List, c___] :> (w[a, #, c] & /@ b),
     t[a___, b_List, c___] :> (t[a, #, c] & /@ b),
     p[a___, b_List, c___] :> (p[a, #, c] & /@ b),
     (* distribute lists of potential expansions over all operations *)
     p[a_] :> a,
     (* addition of a single term is just that term *)
     w[a_, b_] :> t @@ Table[a, {Activate@b}],
     (* a^b simplifies to a*a*...*a b times no matter what b is *)
     t[a___, t[b__], c___] :> t[a, b, c],
     p[a___, p[b__], c___] :> p[a, b, c],
     {a___, {b__}, c___} :> {a, b, c},
     (* operations are associative *)
     t[a__] :> Table[p @@ Table[i, {Activate[t@a/i]}], {i, {a}}]
     (* for a product, generate a list of potential expansions *)}
   , Length]
f

मैं मुसीबत के एक महान सौदा के पास गया निम्नलिखित असर पाने के लिए: इस समारोह के साथ हमेशा की तरह एक मानक मेथेमेटिका अभिव्यक्ति इनपुट के रूप में लेता है, +, *, और ^परिचालन (और कोष्ठक) उस में, और आउटपुट क्या एक मानक मेथेमेटिका अभिव्यक्ति की तरह दिखता है (लेकिन साथ उत्तर के रूप में "निष्क्रिय" प्लस चिह्न)।

उपरोक्त फ़ंक्शन इनपुट में सभी संचालन को निष्क्रिय करके शुरू होता है। फिर, यह बार-बार विस्तार नियमों को लागू करता है जब तक कि कुछ भी सरल नहीं किया जा सकता है। जब भी यह किसी उत्पाद का सामना करता है जैसे कि 2 * 3 * 4, जिसे कई तरीकों से विस्तारित किया जा सकता है, यह संभावित विस्तार की एक सूची बनाता है, और चलता रहता है। अंत में, हमें संभावित अंतिम उत्तरों की एक सूची मिलती है, और सबसे छोटा चुना जाता है।