34

1आपके साथ शुरू करने से आप निम्न दो कार्यों में से एक को बार-बार कर सकते हैं:

संख्या को दोगुना करें।

या
किसी भी तरह से अपने अंकों को फिर से व्यवस्थित करें, सिवाय इसके कि कोई अग्रणी शून्य नहीं होना चाहिए।

लिंक किए गए Math.SE पोस्ट से एक उदाहरण लेते हुए, हम 1000निम्नलिखित चरणों तक पहुँच सकते हैं :

1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 125, 250, 500, 1000

आप इस प्रक्रिया के साथ किन नंबरों तक पहुंच सकते हैं और सबसे छोटा उपाय क्या है?

चुनौती

एक सकारात्मक पूर्णांक को देखते हुए N, पूर्णांक के सबसे कम संभव अनुक्रम को निर्धारित करें N, यदि संभव हो तो उपरोक्त प्रक्रिया के साथ पहुंचें । यदि कई इष्टतम समाधान हैं, तो उनमें से किसी एक को आउटपुट करें। यदि ऐसा कोई अनुक्रम मौजूद नहीं है, तो आपको एक खाली सूची का उत्पादन करना चाहिए।

अनुक्रम किसी भी सुविधाजनक, अस्पष्ट स्ट्रिंग या सूची प्रारूप में हो सकता है।

आप STDIN (या निकटतम विकल्प), कमांड-लाइन तर्क या फ़ंक्शन तर्क के माध्यम से इनपुट ले रहे हैं और STDOUT (या निकटतम विकल्प), फ़ंक्शन रिटर्न मान या फ़ंक्शन (आउट) पैरामीटर के माध्यम से परिणाम लिख सकते हैं।

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

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

यहां 256 तक की सभी पहुंच योग्य संख्याओं की सूची दी गई है। पहला कॉलम नंबर (आपका इनपुट) है, दूसरा कॉलम इष्टतम चरणों की संख्या है (जिसका उपयोग आप अपने समाधान की वैधता की जांच करने के लिए कर सकते हैं) और तीसरा स्तंभ वहां पहुंचने के लिए एक इष्टतम अनुक्रम है:

1       1       {1}
2       2       {1,2}
4       3       {1,2,4}
8       4       {1,2,4,8}
16      5       {1,2,4,8,16}
23      7       {1,2,4,8,16,32,23}
29      10      {1,2,4,8,16,32,23,46,92,29}
32      6       {1,2,4,8,16,32}
46      8       {1,2,4,8,16,32,23,46}
58      11      {1,2,4,8,16,32,23,46,92,29,58}
61      6       {1,2,4,8,16,61}
64      7       {1,2,4,8,16,32,64}
85      12      {1,2,4,8,16,32,23,46,92,29,58,85}
92      9       {1,2,4,8,16,32,23,46,92}
104     15      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104}
106     14      {1,2,4,8,16,32,64,128,256,265,530,305,610,106}
107     14      {1,2,4,8,16,32,23,46,92,29,58,85,170,107}
109     18      {1,2,4,8,16,32,23,46,92,184,368,386,772,277,554,455,910,109}
116     12      {1,2,4,8,16,32,23,46,92,29,58,116}
122     7       {1,2,4,8,16,61,122}
124     16      {1,2,4,8,16,32,23,46,92,29,58,85,170,107,214,124}
125     11      {1,2,4,8,16,32,64,128,256,512,125}
128     8       {1,2,4,8,16,32,64,128}
136     18      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158,316,136}
140     15      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,140}
142     16      {1,2,4,8,16,32,23,46,92,29,58,85,170,107,214,142}
145     17      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,145}
146     18      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,146}
148     11      {1,2,4,8,16,32,23,46,92,184,148}
149     16      {1,2,4,8,16,32,64,128,182,364,728,287,574,457,914,149}
152     11      {1,2,4,8,16,32,64,128,256,512,152}
154     17      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,154}
158     16      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158}
160     14      {1,2,4,8,16,32,64,128,256,265,530,305,610,160}
161     13      {1,2,4,8,16,32,23,46,92,29,58,116,161}
163     18      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158,316,163}
164     18      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,164}
166     20      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,154,308,616,166}
167     17      {1,2,4,8,16,32,23,46,92,184,148,296,269,538,358,716,167}
169     23      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,461,922,229,458,916,169}
170     13      {1,2,4,8,16,32,23,46,92,29,58,85,170}
176     17      {1,2,4,8,16,32,23,46,92,184,148,296,269,538,358,716,176}
182     9       {1,2,4,8,16,32,64,128,182}
184     10      {1,2,4,8,16,32,23,46,92,184}
185     16      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,185}
188     23      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,185,370,740,470,940,409,818,188}
190     18      {1,2,4,8,16,32,23,46,92,184,368,386,772,277,554,455,910,190}
194     16      {1,2,4,8,16,32,64,128,182,364,728,287,574,457,914,194}
196     23      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,461,922,229,458,916,196}
203     16      {1,2,4,8,16,32,64,128,256,265,530,305,610,160,320,203}
205     13      {1,2,4,8,16,32,64,128,256,512,125,250,205}
208     16      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208}
209     19      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,145,290,209}
212     8       {1,2,4,8,16,61,122,212}
214     15      {1,2,4,8,16,32,23,46,92,29,58,85,170,107,214}
215     11      {1,2,4,8,16,32,64,128,256,512,215}
218     9       {1,2,4,8,16,32,64,128,218}
221     8       {1,2,4,8,16,61,122,221}
223     14      {1,2,4,8,16,32,23,46,92,29,58,116,232,223}
227     20      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158,316,361,722,227}
229     20      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,461,922,229}
230     16      {1,2,4,8,16,32,64,128,256,265,530,305,610,160,320,230}
232     13      {1,2,4,8,16,32,23,46,92,29,58,116,232}
233     22      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,154,308,616,166,332,233}
235     19      {1,2,4,8,16,32,23,46,92,184,148,296,269,538,358,716,176,352,235}
236     19      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158,316,632,236}
238     19      {1,2,4,8,16,32,64,128,256,512,125,250,205,410,104,208,416,832,238}
239     25      {1,2,4,8,16,32,23,46,92,184,368,736,376,752,257,514,154,308,616,166,332,233,466,932,239}
241     16      {1,2,4,8,16,32,23,46,92,29,58,85,170,107,214,241}
244     8       {1,2,4,8,16,61,122,244}
247     21      {1,2,4,8,16,32,23,46,92,184,148,296,592,259,518,158,316,632,362,724,247}
248     17      {1,2,4,8,16,32,23,46,92,29,58,85,170,107,214,124,248}
250     12      {1,2,4,8,16,32,64,128,256,512,125,250}
251     11      {1,2,4,8,16,32,64,128,256,512,251}
253     19      {1,2,4,8,16,32,23,46,92,184,148,296,269,538,358,716,176,352,253}
256     9       {1,2,4,8,16,32,64,128,256}

यदि आप और भी अधिक परीक्षण डेटा चाहते हैं, तो यहां एक ही तालिका 1,000 तक की है ।

इन तालिकाओं पर दिखाई देने वाली किसी भी संख्या को एक खाली सूची नहीं मिलनी चाहिए (बशर्ते कि संख्या तालिका की सीमा में हो)।

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

क्या फांसी के समय पर कोई सीमा है?

— 9

2

@ फ़ालतू नहीं, पागल हो जाओ।

— मार्टिन एंडर

मुझे लगता है कि संभावित अनंत निष्पादन समय हालांकि स्वीकार्य नहीं है? यह सैद्धांतिक रूप से समाप्त करना है?

— घातक

@Fatalize आह हाँ, हमेशा की तरह ।

— मार्टिन एंडर

जब एक से अधिक परिणाम होते हैं तो क्या होता है: [1, 2, 4, 8, 16, 32, 64, 46, 92, 29] [1, 2, 4, 8, 16, 32, 23, 46, 92, आदि। 29]

— dbramwell 17

18

पायथ, 43 बाइट्स

?}QKhu?Jf}QTGJsm+Ld+yedsMfnhT\0.p`edGQ]]1KY

प्रदर्शन।

यह सभी संभव दोहरे या पुनर्व्यवस्थित दृश्यों को उत्पन्न करके शुरू होता है। हालांकि, चूंकि मैं वास्तव में इसे खत्म होते देखना चाहता था, इसलिए मैंने एक शॉर्ट सर्किट जोड़ा।

यह या तो तब तक चलता है जब तक कि यह एक समाधान नहीं ढूंढता है, या इनपुट के बराबर कई पुनरावृत्तियों के लिए, जिस बिंदु पर यह देता है और वापस लौटता है []।

यह पर्याप्त पुनरावृत्तियों होने की गारंटी है। सबसे पहले, हम जानते हैं कि यह कई पुनरावृत्तियों सभी n <= 1000 के लिए पर्याप्त है, उदाहरण के परिणामों के लिए धन्यवाद। बड़ी संख्या के लिए, निम्नलिखित तर्क रखता है:

सबसे पहले, प्रक्रिया के प्रत्येक चरण को अंकों की संख्या को बनाए रखना होगा या बढ़ाना होगा।

दूसरा, तीन नंबर जो एक दूसरे के सभी पुनर्व्यवस्था हैं, सभी कभी भी कम से कम अनुक्रम में प्रकट नहीं हो सकते हैं, क्योंकि यह पहले से आखिरी तक केवल एक पुनर्व्यवस्था करने के लिए तेज होता।

तीसरा, 3 के सभी गुणक अनुपलब्ध हैं, क्योंकि न तो दोहरीकरण और न ही पुनर्व्यवस्था 3 के गैर-एकाधिक से 3 के कई का उत्पादन कर सकते हैं।

इस प्रकार, दिए गए नंबर पर समाप्त होने वाला सबसे लंबा संभव अनुक्रम इनपुट के रूप में कई अंकों से कम या उसके बराबर अंकों के सेट की संख्या के दोगुने के बराबर है, और जहां अंक 3 के एक से अधिक के लिए योग नहीं है।

प्रत्येक अंक के लिए ऐसे अंकों की संख्या निर्धारित होती है:

4 - 474
5 - 1332
6 - 3330

इसके अलावा, हम ऐसे उदाहरणों से जानते हैं कि 3 अंकों की संख्या के साथ समाप्त होने वाला कोई सबसे छोटा अनुक्रम 26 से अधिक लंबाई का नहीं है। इस प्रकार, अनुक्रम लंबाई का एक ऊपरी भाग है:

4: 474 * 2 + 26 = 974
5: 974 * 2 + 1332 = 3638
6: 3330 * 2 + 3638 = 10298

प्रत्येक मामले में, ऊपरी सीमा अंकों की संख्या के साथ किसी भी संख्या से कम है

अंकों की संख्या की संख्या 10 के एक कारक से अधिक नहीं बढ़ सकती है जब अंकों की संख्या एक से बढ़ जाती है, क्योंकि नए अंकों को समूहों में अंतिम अंकों से अलग किया जा सकता है, जिनमें से प्रत्येक में अधिक सेट नहीं हो सकते हैं जो एक से कम के साथ थे अंक।

इस प्रकार, ऊपरी सीमा किसी भी संख्या से कम होगी, जिसमें सभी अंकों की संभावित संख्याओं के लिए कई अंक 4 से अधिक या उसके बराबर होंगे, जो इस प्रमाण को पूरा करता है कि इनपुट के बराबर पुनरावृत्तियों की संख्या हमेशा पर्याप्त होती है।

— isaacg
स्रोत

क्या आप सुनिश्चित हैं कि इनपुट के बराबर कई पुनरावृत्तियां पर्याप्त हैं? सिद्धांत रूप में ऊपरी सीमा 10 की अगली बड़ी शक्ति के आसपास नहीं होगी (चूंकि अनुक्रम अक्सर मनमाने ढंग से घट सकता है)।

— मार्टिन एंडर

@ मार्टिनबटनर अच्छी बात। मुझे लगता है कि एक सबूत होना चाहिए कि इनपुट हमेशा पर्याप्त होता है, लेकिन मैं इसे अभी के लिए संपादित करूंगा।

— isaacg

@ मार्टिनबटनर सबूत कि इनपुट के बराबर पुनरावृत्तियों हमेशा पर्याप्त होती है।

— isaacg

आह, बहुत अच्छा। :) (दिलचस्प बात यह है कि 100,000 तक भी आपको 26 से अधिक चरणों की आवश्यकता नहीं है।)

— मार्टिन एंडर

मेरा मानना है कि इनपुट से अधिक लंबे समय तक सभी कदमों की गणना करना तेज होगा?

— जॉन ड्वोरक

7

एसडब्ल्यूआई-प्रोलॉग, 252 बाइट्स

a(N,Z):-findall(X,b(N,[1],X),R),sort(R,[Z|_]);Z=[].
b(N,[A|T],Z):-n(A,C),n(N,M),length(C,L),length(M,O),L=<O,((A=N,reverse([A|T],Z));(A\=N,(B is A*2;permutation(C,D),\+ nth0(0,D,48),n(B,D),\+member(B,[A|T])),b(N,[B,A|T],Z))).
n(A,B):-number_codes(A,B).

उदाहरण: a(92,Z).आउटपुटZ = [1, 2, 4, 8, 16, 32, 64, 46, 92]

मैंने अभी तक जाँच नहीं की है कि यह N> 99 के लिए काम करता है क्योंकि इसमें समय लगता है, लेकिन मुझे कोई कारण नहीं दिखता कि यह काम क्यों नहीं करेगा।

— Fatalize
स्रोत

2

जूलिया, 306 245 218 बाइट्स

अभी भी यह गोल्फिंग पर काम कर रहा है। एक बार मैं कर रहा हूँ एक ungolfed संस्करण प्रदान करेगा।

s->(M=s=[s];while 1∉s C=0;for i=1:size(s,1) p=2;for j=permutations(dec(s[i])) j[1]>48&&j[end]%2<1&&(l=int(j);l=l÷p;l∉M&&(M=[M,l];S=[l s[i,:]];C==0?C=S:C=[C;S]));p=1end;end;C==0&&return [];s=C;end;sortrows(s)[1,:])

— ग्लेन हे
स्रोत

1

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

मुझे पूरी तरह से यकीन नहीं है कि अगर यह काम करता है, तो यह iff के अनुक्रम को घटाता है जो पहले कम होता है (जैसा कि कम किया जा सकता है) हमेशा छोटा होता है, उदाहरण के लिए

[1,2,4,8,16,32,64,128,256,512,125,250,500,1000]

से छोटा है

[1,2,4,8,16,32,64,128,256,512,251,502,250,500,1000]

जो मैंने 1000 तक सच होने का परीक्षण किया।

import Data.List
h l|mod(e l)2==0=l:h(div(e l)2:l)|0<1=[l]
s l=map((:l).read)(filter((/='0').e)(permutations$show$e l))
e=head
m=map e
n f=m.groupBy(\a b->e a==e b).sort.concatMap f
w l|e(e l)==1=[nub$e l]|m x/=m l=w x|0<1=[[]] where x=n h(n s l)

— लीफ़ विलर्ट्स
स्रोत

1

सी # 655 बाइट्स

List<int> C(int i,List<int> x,int a){x.Add(a);if(a==i)return x;List<int> o=null;string s=a.ToString(),m=i.ToString();var res=G(s,s.Length);foreach (var r in res)if (r.First()!='0'){var l=int.Parse(new String(r.ToArray()));if(!x.Contains(l)&&l.ToString().Length<=m.Length){var n=C(i,x.ToList(),l);if(n!=null&&(o==null||o.Count()>n.Count()))o=n;}}if ((a*2).ToString().Length>m.Length)return o;var p = C(i, x.ToList(), a * 2);if (p!=null&&(o==null||o.Count()>p.Count()))o=p;return o;}IEnumerable<IEnumerable<T>> G<T>(IEnumerable<T> l,int i){return i==1?l.Select(t =>new T[]{t}):G(l,i-1).SelectMany(t=>l.Where(e=>!t.Contains(e)),(a,b)=>a.Concat(new T[]{b}));}

(LinqPad) के साथ कॉल करें:

var i = 64;
C(i,new List<int>(),1).Dump();

99 से ऊपर की संख्या का परीक्षण नहीं किया गया है। यदि आपके पास समय है -> सौभाग्य; ;-)

संपादित करें: अपंग संस्करण:

List<int> C(int i, List<int> x, int toAdd, bool removeLast)
{
    x.Add(toAdd);

    if ( toAdd == i )
    {
        return x;
    }
    else
    {
        List<int> shortest = null;
        if ( toAdd > 9 )
        {
            var res = G(toAdd.ToString(), toAdd.ToString().Length);

            foreach ( var r in res )
            {
                if ( r.First () != '0' )
                {
                    var resi = int.Parse(new String(r.ToArray()));

                    if ( !x.Contains(resi) && resi.ToString().Length <= i.ToString().Length )
                    {
                        var resPerm = C(i, x.ToList(), resi, false);
                        if ( resPerm != null )
                        {
                            if ( shortest == null || shortest.Count() > resPerm.Count() )
                            {
                                shortest = resPerm;
                            }
                        }
                    }
                }
            }
        }
        if ( (toAdd * 2).ToString().Length > i.ToString().Length )
        {
            return shortest;
        }
        var resDouble = C(i, x.ToList(), toAdd * 2, false);
        if ( resDouble != null )
        {
            if ( shortest == null || shortest.Count() > resDouble.Count() )
            {
                shortest = resDouble;
            }
            return shortest;
        }

        return shortest;
    }
}
IEnumerable<IEnumerable<T>> G<T>(IEnumerable<T> l,int i)
{
    return i==1?l.Select(t => new T[]{t}):G(l,i-1).SelectMany(t=>l.Where(e=>!t.Contains(e)),(a,b)=>a.Concat(new T[]{b}));
}

— स्टेफ़न शिंकेल
स्रोत

0

सीजेएम, 83

ri:N_1a:Xa:Y;{X,{XI=__se!{c~},:i^\2*|NA*,&X-_YI=f+Y\+:Y;X\+:X;}fI}*X#_){Y=W%}{;L}?p

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

मैं इस पर लंबे समय से बैठा हूं, यह बहुत छोटा नहीं है और न ही तेज है, और मुझे यकीन नहीं है कि मेरे पास इसे सुधारने के लिए ऊर्जा / प्रेरणा है, इसलिए मैं इसे पोस्ट कर रहा हूं।

— aditsu
स्रोत

क्या आप दोहरीकरण और पुनर्व्यवस्थापन करके इस संख्या तक पहुँच सकते हैं?

चुनौती

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

पायथ, 43 बाइट्स

एसडब्ल्यूआई-प्रोलॉग, 252 बाइट्स

जूलिया, 306 245 218 बाइट्स

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

सी # 655 बाइट्स

सीजेएम, 83