แรงบันดาลใจจากคำถามนี้ใน Math.SE

เริ่มต้นด้วย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

หมายเลขใด ๆ ที่ไม่ปรากฏในตารางเหล่านี้ควรให้รายการที่ว่างเปล่า (หากตัวเลขอยู่ในช่วงของตาราง)

Pyth, 43 ไบต์

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

สาธิต.

สิ่งนี้เริ่มต้นด้วยการสร้างลำดับที่เป็นไปได้สองครั้งหรือจัดลำดับใหม่ทั้งหมด อย่างไรก็ตามเนื่องจากฉันอยากเห็นมันจบฉันจึงเพิ่มการลัดวงจร

[]มันทั้งวิ่งจนกว่าจะพบวิธีการแก้ปัญหาหรือสำหรับจำนวนของการทำซ้ำเท่ากับการป้อนข้อมูลที่ชี้ให้ขึ้นและผลตอบแทน

นี่รับประกันได้ว่าจะมีการทำซ้ำที่เพียงพอ ก่อนอื่นเรารู้ว่าการวนซ้ำจำนวนมากนี้เพียงพอสำหรับ n <= 1,000 ทั้งหมดขอบคุณผลลัพธ์ตัวอย่าง สำหรับตัวเลขที่มากขึ้นอาร์กิวเมนต์ดังต่อไปนี้จะเก็บ:

ขั้นแรกแต่ละขั้นตอนของกระบวนการต้องรักษาหรือเพิ่มจำนวนหลัก

ประการที่สองตัวเลขสามตัวที่มีการเรียงลำดับใหม่ของกันและกันไม่สามารถปรากฏได้ในลำดับที่สั้นที่สุดเพราะมันจะเร็วกว่าที่จะทำการเรียงลำดับครั้งเดียวจากครั้งแรกไปครั้งสุดท้าย

ประการที่สามการทวีคูณของ 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 ซึ่งทำให้การพิสูจน์สมบูรณ์ว่ามีการวนซ้ำจำนวนเท่ากับการป้อนข้อมูลที่เพียงพอเสมอ

SWI-Prolog ขนาด 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 เพราะใช้เวลา แต่ฉันไม่เห็นเหตุผลว่าทำไมมันไม่ทำงาน

Julia, 306 245 218 ไบต์

ยังคงทำงานเกี่ยวกับการเล่นกอล์ฟนี้ จะจัดเตรียมเวอร์ชันที่ไม่อัปโหลดเมื่อฉันทำเสร็จแล้ว

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 ไบต์

ฉันไม่แน่ใจว่าจะใช้งานได้หรือไม่หากลำดับที่ diverges แรกต่ำกว่า (เรียงลำดับต่ำกว่า) จะสั้นกว่าเสมอเช่น

[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]

ซึ่งฉันทดสอบว่าเป็นจริงมากถึง 1,000

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 ไบต์

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

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

ลองออนไลน์

ฉันนั่งอยู่ที่นี่เป็นเวลานานมันไม่สั้นหรือเร็วและฉันไม่แน่ใจว่าฉันมีพลังงาน / แรงจูงใจในการปรับปรุงมันดังนั้นฉันแค่โพสต์