Lấy cảm hứng từ câu hỏi này trên Math.SE .

Bắt đầu với 1bạn có thể liên tục thực hiện một trong hai thao tác sau:

• Nhân đôi số lượng.

  hoặc là

• Sắp xếp lại các chữ số của nó theo bất kỳ cách nào bạn muốn, ngoại trừ việc không được có bất kỳ số 0 đứng đầu nào.

Lấy một ví dụ từ bài đăng Math.SE được liên kết, chúng ta có thể tiếp cận 1000thông qua các bước sau:

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

Những con số nào bạn có thể đạt được với quá trình này và giải pháp ngắn nhất là gì?

Các thách thức

Cho một số nguyên dương N, xác định chuỗi số nguyên ngắn nhất có thể đạt được Nvới quy trình trên, nếu có thể. Nếu có một số giải pháp tối ưu, hãy xuất bất kỳ một trong số chúng. Nếu không có trình tự như vậy tồn tại, bạn nên xuất ra một danh sách trống.

Chuỗi có thể ở bất kỳ định dạng chuỗi hoặc danh sách thuận tiện, rõ ràng.

Bạn có thể viết chương trình hoặc hàm, lấy đầu vào qua STDIN (hoặc thay thế gần nhất), đối số dòng lệnh hoặc đối số hàm và xuất kết quả qua tham số STDOUT (hoặc thay thế gần nhất), tham số trả về hàm hoặc tham số hàm (out).

Đây là mã golf, vì vậy câu trả lời ngắn nhất (tính bằng byte) sẽ thắng.

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

Dưới đây là danh sách tất cả các số có thể truy cập lên đến và bao gồm 256. Cột đầu tiên là số (đầu vào của bạn), cột thứ hai là số bước tối ưu (bạn có thể sử dụng để kiểm tra tính hợp lệ của giải pháp của mình) và thứ ba cột là một chuỗi tối ưu để đạt được điều đó:

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}

Nếu bạn muốn có nhiều dữ liệu thử nghiệm hơn nữa, thì đây là cùng một bảng lên tới và bao gồm 1.000 .

Bất kỳ số nào không xuất hiện trên các bảng này sẽ mang lại một danh sách trống (miễn là số đó nằm trong phạm vi của bảng).

Bình thường, 43 byte

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

Trình diễn.

Điều này được bắt đầu bằng cách tạo ra tất cả các chuỗi kép hoặc sắp xếp lại có thể. Tuy nhiên, vì tôi thực sự muốn thấy nó kết thúc, tôi đã thêm một mạch ngắn.

Nó hoặc chạy cho đến khi tìm thấy giải pháp hoặc cho một số lần lặp bằng với đầu vào, tại thời điểm đó, nó từ bỏ và trả về [].

Điều này được đảm bảo là đủ lặp. Đầu tiên, chúng ta biết rằng nhiều lần lặp này là đủ cho tất cả n <= 1000, nhờ vào kết quả ví dụ. Đối với số lớn hơn, đối số sau đây giữ:

Đầu tiên, mỗi bước của quy trình phải duy trì hoặc tăng số lượng chữ số.

Thứ hai, ba số là tất cả các sắp xếp lại của nhau không bao giờ có thể xuất hiện theo một chuỗi ngắn nhất, bởi vì sẽ nhanh hơn nếu chỉ thực hiện một sắp xếp lại từ đầu đến cuối.

Thứ ba, tất cả bội số của 3 đều không thể truy cập được, bởi vì không nhân đôi hay sắp xếp lại có thể tạo ra bội số của 3 từ bội số của 3.

Do đó, dãy dài nhất có thể kết thúc tại một số đã cho bằng tổng hai lần số tập hợp các chữ số có ít hơn hoặc bằng nhiều chữ số như đầu vào và trong đó các chữ số không tổng bằng bội số của 3.

Số lượng các chữ số như vậy cho mỗi số chữ số:

4 - 474
5 - 1332
6 - 3330

Ngoài ra, chúng tôi biết từ các ví dụ rằng không có chuỗi ngắn nhất kết thúc bằng số có 3 chữ số có độ dài lớn hơn 26. Do đó, giới hạn trên của độ dài chuỗi là:

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

Trong mỗi trường hợp, giới hạn trên thấp hơn bất kỳ số nào có số chữ số

Số lượng bộ chữ số không thể tăng hơn 10 lần khi số chữ số tăng thêm một, vì các số mới có thể được tách thành các nhóm bằng chữ số cuối cùng, mỗi số không thể có nhiều bộ hơn số có ít hơn một số chữ số.

Do đó, giới hạn trên sẽ thấp hơn bất kỳ số nào có nhiều chữ số cho tất cả các số có thể có chữ số lớn hơn hoặc bằng 4, điều này hoàn thành bằng chứng rằng một số lần lặp bằng đầu vào luôn luôn là đủ.

SWI-Prolog, 252 byte

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).

Ví dụ: a(92,Z).đầu raZ = [1, 2, 4, 8, 16, 32, 64, 46, 92]

Tôi chưa kiểm tra xem cái này có hiệu quả với N> 99 không vì thời gian, nhưng tôi không thấy lý do gì nó không hoạt động.

Julia, 306 245 218 byte

Vẫn đang làm việc trên sân golf này. Sẽ cung cấp một phiên bản chưa được chỉnh sửa sau khi tôi hoàn thành.

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,:])

Haskell, 246 byte

Tôi không hoàn toàn chắc chắn nếu điều này hoạt động, nó không phải là trình tự đầu tiên phân kỳ thấp hơn (như được sắp xếp thấp hơn) luôn luôn ngắn hơn, ví dụ như

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

ngắn hơn

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

mà tôi đã thử nghiệm là đúng đến 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)

C # 655 byte

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}));}

Gọi với (LinqPad):

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

Chưa kiểm tra các con số trên 99. Nếu bạn có thời gian -> chúc may mắn ;-)

chỉnh sửa: phiên bản chưa được chỉnh sửa:

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}));
}

Camam, 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

Dùng thử trực tuyến

Tôi đã ngồi trên nó trong một thời gian dài, nó không quá ngắn cũng không nhanh và tôi không chắc mình có năng lượng / động lực để cải thiện nó, vì vậy tôi chỉ đăng nó.