Hôm nay trong lớp thống kê của tôi, tôi thấy rằng một số giai thừa có thể được đơn giản hóa khi nhân với nhau! Ví dụ:5! * 3! = 5! *3*2 = 5! *6 = 6!

Công việc của bạn:

Đưa ra một chuỗi chỉ chứa các số Ả Rập và các dấu chấm than, đơn giản hóa giai thừa của tôi thành chuỗi ngắn nhất có thể, với số lượng byte ít nhất cho ngôn ngữ của bạn, mã kiểu golf.

Đầu vào

Một chuỗi chỉ chứa số Ả Rập và dấu chấm than. Các yếu tố cho đầu vào sẽ không lớn hơn 200!. Các yếu tố sẽ không có nhiều hơn một giai thừa cho mỗi số. Đầu vào có thể được lấy dưới dạng danh sách các số nguyên.

Đầu ra

Một chuỗi có thể rút ngắn, có giá trị tương đương trên đầu vào. Thứ tự là không quan trọng. Ký hiệu giai thừa là bắt buộc, nhưng bạn không bắt buộc phải sử dụng nhiều hơn một ký hiệu giai thừa cho mỗi số.

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

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!

May mắn nhất

Thạch ,  17  18 byte

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

Một liên kết đơn lấy và trả về một danh sách các số (dính vào tùy chọn một nhân tử cho mỗi số)

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

Làm sao?

Một phiên bản golf (mặc dù được viết độc lập) của giải pháp của 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)

Thạch , 19 byte

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

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

Nhanh chóng và hèn hạ. Rất chậm, ngay cả 23!2!3!2!trường hợp thử nghiệm là một căng. I / O là danh sách các số nguyên.

Giải trình

,!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.

Sạch , 397 ... 317 byte

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]]

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

Điều này cần một [Int], xác định các yếu tố chính của kết quả và giảm qua các yếu tố để tìm đại diện nhỏ nhất, sử dụng yếu tố lớn nhất ở bất kỳ giai đoạn nào làm giá trị cơ bản cho thuật ngữ giai đoạn tiếp theo. Nó sẽ không hoàn thành một số trường hợp thử nghiệm trên TIO, nhưng nó khá * nhanh và có thể chạy tất cả trong vòng dưới 3 phút trên một máy tính xách tay tầm trung.

* cho một O((prod(N)!)^sum(N))thuật toán phức tạp

> <> , 66 byte

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

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

Không hiệu quả, không tìm thấy chuỗi nhỏ nhất và trình thông dịch không xử lý tốt với số lượng cực lớn. Nhưng ít nhất tôi đã thử? Đưa đầu vào dưới dạng danh sách các số thông qua -vcờ.

Đầu tiên, nó tính toán giá trị của đầu vào bằng cách xác định từng số và nhân chúng với nhau. Sau đó, nó tìm thấy giai thừa lớn nhất phân chia sạch thành tổng số và xuất ra nó. Lặp lại cho đến khi nó nhận được một số nguyên tố, (nó xuất ra) hoặc 1 và thoát khỏi chương trình. Bởi vì điều này, đôi khi nó không tìm thấy đại diện ngắn nhất của số, ví dụ, trường hợp kiểm tra 7!2!2!7!2!2!2!2!trả về 10!224thay 8!8!vì vì nó tìm thấy tổng số chia hết cho 10! Đầu tiên.

Ruby , 240 237 233 byte

Điều này là vô cùng kém hiệu quả

Chấp nhận một mảng ints làm đầu vào

Returns một chuỗi và chọn tùy chọn ngắn nhất giữa, nói rằng, '720!', '6!!'và'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]}

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