Math.SE'deki bu sorudan ilham alındı .

1Sizinle başlamak , aşağıdaki iki işlemden birini tekrar tekrar gerçekleştirebilir:

• Numarayı ikiye katla.

  veya

• Herhangi bir baştaki sıfır olmamasının dışında, rakamlarını istediğiniz şekilde yeniden düzenleyin.

Bağlantılı Math.SE yazısından bir örnek alarak 1000, aşağıdaki adımlarla ulaşabiliriz :

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

Bu işlemle hangi rakamlara ulaşabilirsiniz ve en kısa çözüm nedir?

Meydan okuma

Pozitif bir tamsayı verildiğinde N, mümkünse N, yukarıdaki işlemle ulaşılabilecek en kısa tamsayı dizisini belirleyin . Birkaç en uygun çözüm varsa, bunlardan herhangi birini çıkarın. Eğer böyle bir sıra yoksa, boş bir liste çıkarmalısınız.

Dizi, uygun herhangi bir net dize veya liste biçiminde olabilir.

STDIN (veya en yakın alternatif), komut satırı argümanı veya işlev argümanı yoluyla giriş alarak ve sonucu STDOUT (veya en yakın alternatif), fonksiyon dönüş değeri veya function (out) parametresi ile çıktı alarak bir program veya işlev yazabilirsiniz.

Bu kod golf, yani en kısa cevap (bayt cinsinden) kazanır.

Test Kılıfları

256'ya kadar ve dahil olmak üzere tüm erişilebilir numaraların bir listesi. İlk sütun sayı (girişiniz), ikinci sütun en uygun adım sayısıdır (çözümün geçerliliğini kontrol etmek için kullanabileceğiniz) ve üçüncü sütun oraya ulaşmak için en uygun sıradır:

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}

Daha fazla test verisi istiyorsanız, işte 1.000 ve dahil olmak üzere aynı tablo .

Bu tablolarda görünmeyen herhangi bir sayı (sayının tablo aralığında olması şartıyla) boş bir liste vermelidir.

Pyth, 43 bayt

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

Gösteri.

Bu, olası tüm çift veya yeniden düzenlenmiş dizileri üreterek başlar. Ancak, aslında bitirmek istediğim için kısa bir devre ekledim.

Bir çözüm bulana kadar veya girişe eşit sayıda iterasyon için çalışır, bu noktada vazgeçip geri döner [].

Bu yeterli yineleme olacağı garantilidir. Öncelikle, bu kadar yinelemenin, örnek sonuçları sayesinde tüm n <= 1000 için yeterli olduğunu biliyoruz. Daha büyük sayılar için aşağıdaki argüman geçerlidir:

İlk olarak, işlemin her adımı basamak sayısını korumalı veya artırmalıdır.

İkincisi, bir diğerinin tümünün yeniden düzenlenmesi olan üç sayı asla kısa bir sırayla görünmez, çünkü ilkinden bir sonrasına sadece tek bir yeniden düzenleme yapmak daha hızlı olurdu.

Üçüncüsü, 3 katlarının tümüne erişilemez, çünkü ne iki katına ne de yeniden düzenlemeye, 3'ün katı olmayan birinden 3 kat üretebilir.

Bu nedenle, verilen bir sayı ile biten mümkün olan en uzun dizi, girdi sayısı ile aynı sayıya eşit veya daha az sayıdaki hane kümesi sayısının iki katına eşittir ve hane sayısı 3'ün bir katına toplanmaz.

Bu rakamların sayısı, her basamak sayısı için belirlenir:

4 - 474
5 - 1332
6 - 3330

Ek olarak, örneklerden, 3 basamaklı bir sayı ile biten en kısa sekansın, uzunlukların 26'dan büyük olmadığını biliyoruz. Dolayısıyla, sekans uzunluklarının bir üst sınırı:

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

Her durumda, üst sınır basamak sayısı ile herhangi bir sayıdan daha düşüktür.

Rakam sayısı bir artarsa, rakam kümelerinin sayısı 10 katından daha fazla büyüyemez, çünkü yeni rakamlar, her biri bir rakamdan daha az olan setlere sahip olamayacak şekilde son rakamlara göre gruplara ayrılabilir. hane.

Bu nedenle, üst sınır, 4'ten büyük veya ona eşit tüm olası basamak sayıları için bu kadar rakam ile herhangi bir sayıdan düşük olacaktır; bu, girişe eşit sayıda yinelemenin her zaman yeterli olduğuna dair kanıtı tamamlar.

SWI-Prolog, 252 bayt

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

Örnek: a(92,Z).çıktılarZ = [1, 2, 4, 8, 16, 32, 64, 46, 92]

Bunun zaman harcadığı için N> 99 için işe yaramadığını henüz kontrol etmedim, ancak işe yaramayacağına dair hiçbir neden göremiyorum.

Julia, 306 245 218 bayt

Hala bu golf üzerinde çalışıyor. Ben bittiğinde bir ungolfed sürümünü sağlayacaktır.

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 bayt

Bunun işe yarayıp yaramadığını tam olarak bilmiyorum, ilk önce daha düşük sapmalar (daha düşük olarak sıralanacak şekilde) her zaman daha kısa olduğundan emin olmaz

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

daha kısa

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

1000'e kadar doğru olduğunu test ettim.

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 bayt

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) ile arayın:

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

99'un üzerindeki sayıları test etmedim. Zamanınız varsa -> iyi şanslar ;-)

düzenleme: ungolfed versiyonu:

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

Çevrimiçi deneyin

Uzun zamandır bunun üzerinde oturuyorum, çok kısa ya da hızlı değil ve onu geliştirmek için gerekli enerjim / motivasyonum olduğundan emin değilim, bu yüzden sadece gönderiyorum.