วันนี้ในชั้นเรียนสถิติของฉันฉันพบว่าแฟคทอเรียลบางตัวสามารถทำให้ง่ายขึ้นเมื่อคูณเข้าด้วยกัน! ตัวอย่างเช่น: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

ลิงก์ monadic ที่รับและส่งคืนรายการของตัวเลข (เกาะติดกับหนึ่งแฟคทอเรียลต่อตัวเลือกตัวเลข)

ลองออนไลน์!

อย่างไร?

เวอร์ชันของโซลูชัน 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 ไบต์

มันไม่มีประสิทธิภาพอย่างไม่น่าเชื่อ

ยอมรับอาร์เรย์ของ ints เป็นอินพุต

ส่งคืนสตริงและเลือกตัวเลือกที่สั้นที่สุดระหว่าง, พูด'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]}

ลองออนไลน์!