फैक्टरिंग फैक्टरियल

Question

आज मेरी सांख्यिकी कक्षा में, मैंने पाया कि कुछ गुटों को एक साथ गुणा करने पर सरल बनाया जा सकता है! उदाहरण के लिए: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!

शुभकामनाएँ

Comments

चूंकि खाली उत्पाद 1 है, इसके लिए आउटपुट है, 1!1!बस एक खाली स्ट्रिंग कहें ?

— जोनाथन एलन

@JonathanAllan 1! 1! 1 पर कम कर देता है! या ०!

— tuskiomi

जो फिर खाली स्ट्रिंग को कम कर देता है: /

— जोनाथन एलन

@JonathanAllan मैं कहने जा रहा हूं 1 खाली स्ट्रिंग के बराबर नहीं है

— tuskiomi

Answer 1

जेली ,  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)

Comments

मेरे लिए पर्याप्त स्पष्ट लगता है - हमें इसका उपयोग करने की आवश्यकता नहीं है, लेकिन यदि हम चाहें तो ऐसा कर सकते हैं।

— जोनाथन एलन

@tuskiomi पाद लेख स्पष्टता के लिए सूची आउटपुट को केवल स्वरूपित कर रहा है ... एक पूर्ण कार्यक्रम (एक फ़ंक्शन के बजाय) के रूप में कोड एक सूची के जेली के प्रारूप को प्रिंट करेगा (लंबाई के सूची के लिए खाली और कोई संलग्न नहीं [] के लिए) 1 ।

— जोनाथन एलन

@tuskiomi TIO की सीमाएं हैं ;-) लेकिन मुझे लगता है कि यह सैद्धांतिक रूप से काम करती है।

— को आउटगोल्फर को एरिक करें

@tuskiomi कार्टेशियन शक्ति 23 की सूची में परिणाम होगा! ^ 4 सूची। यह समय से बाहर चलेगा (60s की सीमा TIO पर) यदि मेमोरी नहीं है।

— जोनाथन एलन

N! ^ M जहाँ N उत्पाद है और M शब्दों की संख्या है (और अंतरिक्ष में भी !!)

— जोनाथन एलन

Answer 2

जेली , 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.

Comments

हम सूची का उपयोग I / O

— योनातन एलन

@JonathanAllan ओह, यह स्पष्ट रूप से ओपी में संपादित नहीं किया गया था

— पुरकाकूदरी

मेरा 17 भी धीमा लग रहा है ...

— योनातन एलन

ओह, यह भी इसी तरह से है - tio.run/##y0rNyan8/…

— जोनाथन एलन

@JonathanAllan आगे बढ़ो और इसे पोस्ट करो, मेरे लिए अलग दिखता है भले ही एल्गोरिथ्म अनिवार्य रूप से एक ही हो।

— पुरकाकूदरी

Answer 3

क्लीन , 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]परिणाम के प्रमुख कारकों को निर्धारित करता है, और सबसे छोटे कारक का पता लगाने के लिए कारकों को कम कर देता है, किसी भी स्तर पर सबसे बड़े कारक का उपयोग करते हुए अगले तथ्यात्मक शब्द के लिए आधारभूत मान होता है। यह टीआईओ पर कुछ परीक्षण मामलों को पूरा नहीं करेगा, लेकिन यह काफी * तेज है, और इन सभी को मिडरेंज लैपटॉप पर 3 मिनट के भीतर चला सकता है।

* एक O((prod(N)!)^sum(N))जटिलता एल्गोरिथ्म के लिए

Comments

टेस्टकेस: 6, 2, 2

— टीएस

@tsh अब ठीक किया गया। यह छोटी से छोटी लंबाई के आधार पर छँटनी नहीं थी, लेकिन एक गलत धारणा के आधार पर सबसे पहले सदस्य द्वारा।

— Οurous

Answer 4

> <> , 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 से विभाज्य है! प्रथम।

Answer 5

रूबी , 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]}

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