Phép nhân giữa 2 số nguyên có thể được giảm thành một chuỗi bổ sung như vậy

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

Số mũ (tăng a lên lũy thừa b ) cũng có thể được giảm thành một chuỗi các phép nhân:

5 ^ 3 = 5 * 5 * 5

Do đó, lũy thừa có thể được giảm thành một loạt các phép cộng, bằng cách tạo một biểu thức nhân, sau đó thành một chuỗi các phép cộng. Ví dụ: 5 ^ 3(5 khối) có thể được viết lại thành

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

Nhiệm vụ của bạn là, được đưa ra các biểu thức được cộng lại với nhau bao gồm lũy thừa, nhân và cộng, giảm nó thành chuỗi bổ sung ngắn nhất. Biểu thức "ngắn nhất" được định nghĩa là biểu thức có số lượng +ký hiệu ít nhất , vẫn chỉ sử dụng một trong hai số trong biểu thức gốc. Ví dụ, biểu thức ngắn nhất 10 * 2là 10 + 10.

Tất cả các số liên quan đến đầu vào sẽ là các số nguyên dương và biểu thức sẽ chỉ bao gồm +(cộng), *(nhân) và ^(lũy thừa), cùng với các số nguyên và ngoặc ( ()) để biểu thị mức độ ưu tiên.

Đầu ra chỉ bao gồm các số nguyên dương và +ký hiệu. Bạn không nên xuất các bước giảm riêng lẻ, chỉ là đầu ra cuối cùng. Đầu ra có thể không bao gồm bất kỳ số nào không xuất hiện trong đầu vào. Tuy nhiên, bạn có thể sử dụng bất kỳ 3 biểu tượng riêng biệt nào thay vì +*^, nhưng vui lòng cho biết chúng là những biểu tượng nào

Các không gian ngăn cách đầu vào và đầu ra có thể hoặc không thể được sử dụng trong các chương trình của bạn, nghĩa là 3 * 5có thể xuất ra dưới dạng 5 + 5 + 5hoặc 5+5+5.

Lưu ý rằng trong hầu hết các trường hợp, bổ sung không thực sự được thực hiện. Trường hợp duy nhất mà việc bổ sung được thực hiện là khi bạn có một cái gì đó như 5 ^ (1 + 2), trong trường hợp đó, sự bổ sung là cần thiết để tiếp tục -> 5 ^ 3 -> 5 * 5 * 5 -> .... Xem trường hợp thử nghiệm # 4.

Mã của bạn không cần xử lý các đầu vào đến một biểu thức mơ hồ. Ví dụ , (2 + 2) * (4 + 1). Do các quy tắc được đặt ra cho đến nay, mục tiêu không phải là tính toán câu trả lời, mục tiêu là đơn giản hóa để bổ sung. Vì vậy, kết quả có thể khác nhau tùy theo thứ tự các biểu thức được giải quyết hoặc đi lại (bổ sung nào để đơn giản hóa, cái nào để lại?). Một ví dụ không hợp lệ khác : ((3 + 2) ^ 2) ^ 3 -> ((3 + 2) * (3 + 2)) ^ 3 -> ???.

Đây là môn đánh gôn nên mã ngắn nhất sẽ thắng

Các trường hợp thử nghiệm

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

Võng mạc , 302 byte

Tôi chắc chắn rằng điều này có thể được chơi golf, nhưng tại thời điểm này, tôi chỉ vui mừng vì nó hoạt động. Cả hai phần lũy thừa và nhân đều rất giống nhau, nhưng vì thứ tự các thao tác rất quan trọng, tôi không biết cách kết hợp chúng.

y- lũy thừa
x- Nhân
p- Bổ sung

\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ùng thử trực tuyến - tất cả các trường hợp thử nghiệm

Kiểm tra chuyển đổi trường hợp

Giải trình

\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

Bạn cũng có thể nhận thấy rằng nhóm được sử dụng phổ biến nhất là (\(\w+\)|1+). Điều này khớp với một biểu thức bên trong với dấu ngoặc đơn hoặc một số nguyên. Tôi đã chọn sử dụng các biểu tượng tôi đã làm để tôi có thể sử dụng \wchứ không phải là một lớp nhân vật. Tôi không chắc liệu có tốt hơn không nếu sử dụng các ký hiệu không phải từ và thay thế một số giao diện bằng viền từ ( \b).

Toán học, 250 218 183 170 byte

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@{##}&),"+"]

^{Nó hoạt động! Cuối cùng!}

Xác định hàm trong f.

Đầu vào là một biểu thức toán học đơn giản. (tức là 1 + 2không "1 + 2").

Hãy thử trực tuyến!

Lưu ý rằng liên kết TIO có mã hơi khác, vì TIO (mà tôi đoán là sử dụng hạt nhân Mathicala) không thích Infix. Tôi đã sử dụng Rifflethay thế để có được diện mạo tương tự như Mathicala REPL.

Bị đánh cắp

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 *)

Toán học, 405 406 byte

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

Ung dung và giải thích

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

Tôi đã đi đến một thỏa thuận rất nhiều rắc rối để có được hiệu quả như sau: function này có làm đầu vào một biểu thức Mathematica tiêu chuẩn, với bình thường +, *và ^các hoạt động (và dấu ngoặc đơn) trong đó, và kết quả những gì trông giống như một biểu Mathematica tiêu chuẩn (nhưng với "Vô hiệu hóa" cộng với dấu hiệu) là câu trả lời.

Chức năng trên bắt đầu bằng cách hủy kích hoạt tất cả các hoạt động trong đầu vào. Sau đó, nó áp dụng các quy tắc mở rộng nhiều lần cho đến khi không còn gì có thể đơn giản hóa nữa. Bất cứ khi nào nó gặp một sản phẩm như 2 * 3 * 4, có thể được mở rộng theo nhiều cách, nó sẽ tạo ra một danh sách các mở rộng có thể, và tiếp tục. Cuối cùng, chúng tôi nhận được một danh sách các câu trả lời cuối cùng có thể, và câu trả lời ngắn nhất được chọn.