17

चुनौती वास्तव में सरल है: एक संख्या दी गई है, आप इसके अंकों को छोटी संख्याओं की एक सरणी में विभाजित करते हैं, ताकि परिणामी संख्या गैर-घटती हो। पकड़ यह है कि आपको इसे विभाजित करना होगा जैसे कि सरणी की लंबाई अधिकतम है।

उलझन में?

आपको STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से किसी भी सुविधाजनक, अस्पष्ट इनपुट प्रारूप में एक सकारात्मक पूर्णांक दिया जाता है।
आपको संख्याओं के दशमलव अंकों को सन्निहित, असमान समूहों में विभाजित करना होगा।
इन अंकों के समूहों द्वारा दर्शाई गई संख्याओं की सरणी को समूहों को पुन: व्यवस्थित किए बिना (सामान्य, गैर-घटते क्रम में) क्रमबद्ध किया जाना चाहिए ।
ऐसे मामलों में जहां एक से अधिक ऐसे विभाजन मौजूद हैं, आपको इनपुट को अधिक से अधिक संख्या में विभाजित करना होगा। संबंधों के मामले में, ऐसा एक परिणाम लौटाएं।
आप सरणी को STDOUT (या निकटतम वैकल्पिक) या फ़ंक्शन रिटर्न मान के रूप में आउटपुट कर सकते हैं। STDOUT (या निकटतम विकल्प) के मामले में, सरणी को किसी भी सुविधाजनक, स्पष्ट सूची प्रारूप में मुद्रित किया जाना चाहिए।
विभाजित संख्याओं में अग्रणी शून्य नहीं होना चाहिए। उदाहरण के लिए या 1002003तो मुद्रित नहीं किया जा सकता है [1, 002, 003]या इसके [1, 2, 3]लिए केवल मान्य उत्तर है [100, 2003]।

परीक्षण के मामलों:

123456 -> [1, 2, 3, 4, 5, 6]
345823 -> [3, 4, 5, 8, 23]
12345678901234567890 -> [1, 2, 3, 4, 5, 6, 7, 8, 90, 123, 456, 7890]
102 -> [102]
302 -> [302]
324142 -> [3, 24, 142] OR [32, 41, 42]
324142434445 -> [32, 41, 42, 43, 44, 45]
1356531 -> [1, 3, 5, 6, 531]
11121111111 -> [1, 1, 1, 2, 11, 11, 111]
100202003 -> [100, 202003]

स्कोरिंग

यह कोड-गोल्फ है इसलिए बाइट्स जीत में सबसे छोटा कोड है।

— अनुकूलक
स्रोत

10

अजगर, ३४

FNyUz#aYmv:zhdedC,+0N+NlzB)efqSTTY

इसे यहाँ ऑनलाइन आज़माएँ । ध्यान दें, इसमें O (n) की एक समय (और स्थान) जटिलता है। इसलिए 12345678901234567890ऑनलाइन संकलक में परीक्षण के मामले में बहुत लंबा समय लगता है। इसके बजाय ऑफ़लाइन का उपयोग करें (मेरे लैपटॉप पर 1 मिनट)।

यह केवल मेरा पहला प्रयास है। सुधार के लिए कुछ जगह हो सकती है।

पहले कुछ विचार कि मेरा एल्गोरिथ्म कैसे काम करता है।

मैं इनपुट को स्ट्रिंग के रूप में व्याख्या करता हूं और संख्या के रूप में नहीं।
फिर मैं सभी संभव उपसमूह बनाता हूं [0, 1, 2, ..., len(n-1)]
इनमें से प्रत्येक सबसेट (ले लेने देता है [1, 4, 5]) के लिए, मैं इन नंबरों का उपयोग करके इनपुट स्ट्रिंग को भाग में विभाजित करता हूं। [input[0:1], input[1, 4], input[4,5], input[5,len(input)]]।
बाद में मैं इन नंबरों को स्ट्रिंग्स में बदलने की कोशिश करता हूं। दो समस्याएं हो सकती हैं। पायथ (या पायथन) एक खाली स्ट्रिंग के लिए एक अपवाद फेंकता है, और संख्याओं की एक स्ट्रिंग के साथ शुरू होता है 0। इसलिए मैं एक try - catchब्लॉक (वास्तव में एक तात्कालिक ब्रेक के साथ अनंत लूप) का उपयोग करता हूं । यदि रूपांतरण सफलतापूर्वक किया गया था, तो मैं एक सूची में परिणाम जोड़ता हूं Y।
जब मैंने सभी सबसेट को संभाला उसके बाद, मैं Yपरिणामों के लिए सूची को फ़िल्टर करता हूं , जो पहले से ही सॉर्ट किए गए हैं और पिछले एक को प्रिंट करते हैं (आखिरी में सबसे अधिक समूह हैं)।

अब विस्तृत विवरण:

                            Implicit: z = input() (z is a String!)
                                      Y = empty list
FNyUz                       for each subset N of [0, 1, 2, ..., len(z)-1]:

     #                         start try-catch block (actually an infinite loop, 
                               but the Python implementation uses a try catch. 

      aY                          append to Y:
                C,+0N+Nlz            zip([0] + N, N + [len(z)])
        m                            map each element d to
          :zhded                     z[d[0]:d[-1]]
         v                           evaluated
                         B        if this didn't throw an exception already, end the infinite loop
                          ) end for loop   

 f    Y      filter Y for elements T, for which
  qSTT           sorted(T) == T
e            and print the last one (the subsets generated with yUz are sorted 
             by length, so the last one has the most groups)

— Jakube
स्रोत

आप aYइसके बजाय का उपयोग कर सकते हैं~Y]

— FryAmTheEggman

@FryAmTheEggman मैं हमेशा के बारे में भूल जाते हैं a। पता नहीं क्यों।

— जकुबे

@ जाकुब शायद इसलिए कि यह डॉक्स में नहीं है?

— Sp3000

मेरे पास ~ 45 चार्ट के लिए एक समाधान था। मुझे इस तथ्य के बारे में पता नहीं था कि int("01")पायथ में एक त्रुटि है (यह पायथन में नहीं होता है)।

— orlp

3

@ जाकुब हाहा, हालांकि तार्किक लगता है, लेकिन आम तौर पर nइनपुट की लंबाई है।

— ऑप्टिमाइज़र

6

मैथेमेटिका, 134 127 बाइट्स

यह बहुत अक्षम है क्योंकि यह वैध लोगों की तुलना में बहुत अधिक विभाजन उत्पन्न करता है। 324142434445परीक्षण का मामला कुछ सेकंड के भीतर चलाता है, लेकिन मैं कोशिश नहीं की 12345678901234567890।

f/@Last@Select[Needs@"Combinatorica`";f=FromDigits;SetPartitions[d=IntegerDigits@#],0<=##&@@f/@#&&Join@@#==d&&#~FreeQ~{0,__}&]&

यह एक अनाम फ़ंक्शन को परिभाषित करता है जो पूर्णांक लेता है और पूर्णांक की एक सूची देता है।

व्याख्या

इस कोड का रीडिंग ऑर्डर पूरे स्थान पर एक सा है, इसलिए मैं इसे पढ़ने के लिए (और अधिकांश भाग के लिए मूल्यांकन किया गया) के क्रम में तोड़ दूँगा:

d=IntegerDigits@#इनपुट के दशमलव अंक प्राप्त करें और इस सूची को असाइन करें d।
SetPartitions(जिसकी आवश्यकता है Needs@"Combinatorica`";) मुझे इसके सभी विभाजन देता है। हालाँकि, यह एक बहुत अधिक रिटर्न देता है जितना मैं वास्तव में चाहता हूं क्योंकि यह इनपुट को एक सेट के रूप में मानता है । यह वही है जो इसे अक्षम बनाता है, लेकिन मैं इसका उपयोग कर रहा हूं, क्योंकि मुझे पता है कि सभी सूची विभाजन प्राप्त करने का सबसे छोटा तरीका बहुत लंबा है। एक उदाहरण के रूप में, यदि सूची थी {1, 2, 3}कि समारोह वापस आ जाएगा:
```
{{{1, 2, 3}}, {{1}, {2, 3}}, {{1, 2}, {3}}, {{1, 3}, {2}}, {{1}, {2}, {3}}}
```
ध्यान दें कि ए) लगातार विभाजन सभी सही क्रम में हैं और बी) विभाजन मोटे से बेहतरीन तक छांटे गए हैं।
Select[...,...&] फिर इस सूची को दूसरे तर्क के रूप में पारित अनाम फ़ंक्शन द्वारा फ़िल्टर किया जाता है।
- Join @@ # == d चेक हमने वास्तव में सामान्य सेट विभाजन के बजाय एक सूची विभाजन प्राप्त किया है।
- #~FreeQ~{0, __} जाँच करता है कि कोई विभाजन एक अग्रणी शून्य से शुरू नहीं होता है।
- 0 <= ## & @@ f /@ #थोड़ा और अधिक अस्पष्ट है। सबसे पहले हम FromDigitsविभाजन में प्रत्येक सूची पर अंकों द्वारा दर्शाए गए अंकों को पुनर्प्राप्त करने के लिए मैप करते हैं। फिर हम 0 <= ##उन नंबरों पर लागू होते हैं , जहां ##सभी नंबरों को संदर्भित करता है। यदि विभाजन है {1, 23, 45}तो यह फैलता है 0 <= 1 <= 23 <= 45, इसलिए यह जांचता है कि सरणी क्रमबद्ध है।
Last@फिर मुझे फ़िल्टर करने के बाद बचा हुआ अंतिम विभाजन देता है - यह काम करता है क्योंकि SetPartitionsपहले से ही विभाजन को क्रमबद्ध किया गया है, जैसे कि सबसे अंत में हैं।
अंत में, f/@अंकों को सूचियों से हटाता है।

— मार्टिन एंडर
स्रोत

5

पायथन 3, 134 बाइट्स

def f(s,n=0,L=[],R=[],i=0):
 while s[i:]:i+=1;m=int(s[:i]);R=max([f(s[i:],m,L+[m]),R][m<n or"1">s[i:]>"":],key=len)
 return[L,R][s>""]

यह थोड़ा गड़बड़ है, लेकिन ओह ठीक है। कार्यक्रम सिर्फ सभी वैध विभाजन पुनरावर्ती उत्पन्न करता है। दिलचस्प बात यह है कि अग्रणी शून्य को खत्म करने के लिए, जो आवश्यक था वह एक अतिरिक्त or "1">s[i:]>""शर्त थी।

इनपुट्स को पसंद करता है f("12345678901234567890")और इनट्स की सूची लौटाता है।

— Sp3000
स्रोत

4

Pyth, 62 61 60

JlzKkef&qJsml`dTqTSTolNmmibTcjKsC,z+m>Ndt>+*J]0jk2_JKNU^2-J1

व्याख्या

एल्गोरिथ्म 0(समावेशी) और 2^(n-1)(अनन्य) के बीच सभी बाइनरी नंबर उत्पन्न करके काम करता है , जहां nइनपुट की लंबाई है।

प्रत्येक के बाइनरी अंक फिर 1 के लिए एक विभाजक ( N) के लिए मैप किए जाते हैं और 0 के लिए कुछ भी नहीं है।

इन वर्णों को फिर प्रत्येक इनपुट वर्ण के बीच डाला जाता है, और परिणाम को विभाजित करके N, एक सूची तैयार की जाती है।

सूचियों में मानों को पूर्णांकों तक छोड़ दिया जाता है, और सूचियों को लंबाई द्वारा क्रमबद्ध किया जाता है। फिर जो कुछ बचा है वह गैर-सॉर्ट किए गए लोगों और उन लोगों को फ़िल्टर करना है जो अग्रणी शून्य पर विभाजित हो गए हैं, जिसके बाद सबसे लंबी सूची को चुना गया है।

Jlz                                                   set J to len(input)
Kk                                                    set K to ""
e                                                     take the last of:
 f&                                                    only take lists where:
   qJsml`dT                                             sum of string lengths of items
                                                        is equal to length of input and
           qTST                                         list is in order
               olN                                       sort by length
                  m                                       map k over...
                   mibT                                    convert items to int (base-10)
                       c                        N           split by N
                        jK                                   join by ""
                          s                                   sum to combine tuples
                           C,z                                 zip input with
                              +                K                append [""] for equal lengths
                               m>Nd                              replace 1 with N, 0 with ""
                                   t                              take all but first
                                    >        _J                    take len(input) last values
                                     +                              pad front of binary with
                                      *J]0                           [0] times input's length
                                          jk2                        current k in binary
                                                 U^2-J1  range 0..2^(len(input)-1)-1

— PurkkaKoodari
स्रोत

1

(नॉन-कम्पेटिंग) पायथ, 25 बाइट्स

ef&&Fmnhd\0T.A<V=NsMTtN./

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

यह काम किस प्रकार करता है:

ef&&Fmnhd\0T.A<V=NsMTtN./  Q = eval(input())
                         ./  all partitions of Q
 f                       ./  filter all partitions of Q where:
  &                            both:
   &Fmnhd\0T                     neither substring starts with "0"
                               and:
            .A<V=NsMTtN          all entries are less than their proceeding ones
e                            returns the last amongst the filtered partitions

— लीक नन
स्रोत

0

जे, 109 बाइट्स

बहुत लंबा लेकिन कम से कम O (n * (2n)!) मेमोरी और O (n * लॉग (n) * (2n)!) समय लगता है जहां n इनपुट की लंबाई है। (इसलिए इसे 5 से अधिक अंकों के साथ चलाने की कोशिश न करें।)

f=.3 :0
>({~(i.>./)@:(((-:/:~)@(#$])*#)@>))<@".(' 0';' _1')rplc"1~(#~y-:"1' '-."#:~])(i.!2*#y)A.y,' '#~#y
)

फ़ंक्शन इनपुट को एक स्ट्रिंग के रूप में लेता है।

उदाहरण:

   f every '5423';'103';'1023'
  5 423
103   0
 10  23

तरीका:

इनपुट में लंबाई के बराबर रिक्त स्थान जोड़ें।
हर संभव तरीके से इसकी अनुमति दें।
जाँच करें कि क्या स्पेसलेस स्ट्रिंग इनपुट के समान है (यानी यह उसका एक विभाजन है)।
प्रमुख शून्य समाधानों को अमान्य करने के लिए '0' को '_1' में बदलें।
प्रत्येक स्ट्रिंग का मूल्यांकन करें।
सबसे लंबी सूची का पता लगाएं जिसे भी क्रमबद्ध किया गया है। यह रिटर्न वैल्यू है।

— randomra
स्रोत

0

हास्केल, 161 बाइट्स

(#)=map
f[x]=[[[x]]]
f(h:t)=([h]:)#f t++(\(a:b)->(h:a):b)#f t
g l=snd$maximum[(length x,x::[Int])|x<-[read#y|y<-f l,all((/='0').head)y],and$zipWith(>=)=<<tail$x]

परीक्षण चालन:

*Main> mapM_ (print . g) ["123456","345823","12345678901234567890","102","302","324142","324142434445","1356531","11121111111","100202003"]
[1,2,3,4,5,6]
[3,4,5,8,23]
[1,2,3,4,5,6,7,8,90,123,456,7890]
[102]
[302]
[32,41,42]
[32,41,42,43,44,45]
[1,3,5,6,531]
[1,1,1,2,11,11,111]
[100,202003]

यह कैसे काम करता है: सहायक फ़ंक्शन fइनपुट सूची को सब्लिस्ट की हर संभावित सूची में विभाजित करता है। gपहले उन लोगों को शामिल करता है, जिनके पास शुरुआत होती है 0और फिर बिना उचित आदेश के। हर शेष सूची को इसकी लंबाई के साथ बाँधें, अधिकतम लें और फिर से लंबाई वाले हिस्से को छोड़ दें।

— nimi
स्रोत

एक संख्या के क्रमबद्ध लेक्सिकल विभाजन

अजगर, ३४

मैथेमेटिका, 134 127 बाइट्स

व्याख्या

पायथन 3, 134 बाइट्स

Pyth, 62 61 60

व्याख्या

(नॉन-कम्पेटिंग) पायथ, 25 बाइट्स

जे, 109 बाइट्स

हास्केल, 161 बाइट्स