今天在我的统计课上，我发现将某些阶乘相乘时可以简化！例如：5! * 3! = 5! *3*2 = 5! *6 = 6!

你的工作：

给定仅包含阿拉伯数字和感叹号的字符串，请将我的阶乘简化为最短的字符串，以最少的字节数表示您的语言，即高尔夫风格。

输入值

仅包含阿拉伯数字和感叹号的字符串。输入的阶乘不大于200!。每个数字的阶乘不得超过一个。输入可以视为整数列表。

输出量

可能是缩短的字符串，其输入值相等。顺序不重要。阶乘符号是必须的，但是您不需要每个数字使用一个以上的阶乘符号。

测试用例

In: 3!2!2!  
Out: 4! 

In 2!3!2!0! 
Out: 4! 

In: 7!2!2!7!2!2!2!2! 
Out: 8!8! 

In: 23!3!2!2! 
Out: 24!  
Also: 4!!

In: 23!3!2!2!2! 
Out: 24!2!

In: 127!2!2!2!2!2!2!2! 
Out: 128!

In: 32!56!29!128!  
Out: 29!32!56!128!

祝你好运

果冻， 17  18 字节

!P
ÇṗLÇ⁼¥ÐfÇḢḟ1ȯ0F

单声道链接，获取并返回数字列表（坚持每个数字一个阶乘选项）

在线尝试！

怎么样？

Pietu1998解决方案的高尔夫版本（尽管独立编写）。

!P - Link 1, product of factorials: list
!  - factorial (vectorises)
 P - product

ÇṗLÇ⁼¥ÐfÇḢḟ1ȯ0F - Main link: list                       e.g. [3,2,2]
Ç               - call the last link (1) as a monad           24
  L             - length                                      3
 ṗ              - Cartesian power      [[1,1,1],[1,1,2],...,[1,1,24],...,[24,24,24]]
        Ç       - call the last link (1) as a monad           24
      Ðf        - filter keep if:
     ¥          -   last two links as a dyad:
   Ç            -     call the last link (1) as a monad     [1,2,...,24!,...,24!^3]
    ⁼           -     equal?
         Ḣ      - head
          ḟ1    - filter out any ones
            ȯ0  - or with zero (for the empty list case)
              F - flatten (to cater for the fact that zero is not yet a list)

果冻，19字节

,!P€E
SṗLçÐfµḢḟ1ȯ1F

在线尝试！

快速又脏。非常慢，即使23!2!3!2!测试用例也很麻烦。I / O为整数列表。

说明

,!P€E    Helper link. Arguments: attempt, original
,        Make the array [attempt, original].
         Example: [[1,1,1,4], [2,3,2,0]]
 !       Take the factorial of each item.
         Example: [[1,1,1,24], [2,6,2,1]]
  P€     Take the product of each sublist.
         Example: [24, 24]
    E    Check if the values are equal.

SṗLçÐfµḢḟ1ȯ1F   Main link. Arguments: original
S               Find the sum S of the integers in the input.
  L             Find the number N of integers in the input.
 ṗ              Generate all lists containing N integers from 1 to S.
   çÐf          Take the lists whose factorial-product is the same as the original.
       Ḣ        Take the first match. This is the one with the most ones.
        ḟ1      Remove any ones.
          ȯ1    If there were only ones, return a one instead.
            F   Turn into a list if needed.

干净，397个 ... 317个字节

import StdEnv,StdLib
c=length
f c m=sortBy c o flatten o map m
%n=f(>)@[2..n]
@1=[]
@n#f=[i\\i<-[2..n]|n/i*i==n&&and[i/j*j<i\\j<-[2..i-1]]]
=f++ @(n/prod f)
?l=group(f(>)%l)
$l=hd(f(\a b=c a<c b)(~(?l))[0..sum l])
~[]_=[[]]
~i n=[[m:k]\\m<-take n[hd(i!!0++[0])..],k<- ~[drop(c a)b\\a<-group(%m)&b<-i|b>a]n|i== ?[m:k]]

在线尝试！

这将使用[Int]来确定结果的主要因子，并减少这些因子以找到最小表示，将任何阶段的最大因子用作下一个析因项的基线值。它不会在TIO上完成一些测试用例，但是它相当快，并且可以在一台中型笔记本电脑上在3分钟内全部运行它们。

*用于O((prod(N)!)^sum(N))复杂度算法

> <>，66字节

1}:?\~l1=?v{!
-:?!\:{*}1
v?( 4:{/}1<o"!"n-1
{:,} :{/?%}:+1
\:1-?n;

在线尝试！

效率不高，找不到最小的字符串，并且解释器无法处理非常大的数字。但是至少我尝试过吗？通过-v标志将输入作为数字列表。

首先，它通过分解每个数字并将它们相乘来计算输入的值。然后，找到最大的因子，将其整洁地划分为总计并输出。重复直到它得到一个质数（输出）或为1并退出程序。因此，它有时找不到最短的数字表示形式，例如，7!2!2!7!2!2!2!2!返回测试用例，10!224而不是8!8!因为发现总数可被10整除！第一。

红宝石，240个237 233字节

这是非常低效的

接受一个整数数组作为输入

返回一个字符串，并选择之间，最短的选项比如'720!'，'6!!'和'3!!!'

->i{f=->n{n>0?n*f[n-1]:1}
s=->a{eval a.map{|i|f[i]}*?*}
r=->e,a=[2]{e==s[a]?a:s[a]<=e&&(r[e,a[0..-2]+[a[-1]+1]]||r[e,a+[2]])}
j=->v{v.join(?!)+?!}
u=r[s[i]]
while j[g=u.map{|i|i&&r[i]?[r[i],p]:i}.flatten].size<j[u].size;u=g;end
j[u]}

在线尝试！