34

首先，1您可以重复执行以下两个操作之一：

将数字加倍。

要么
以任何您想要的方式重新排列其数字，但不得有任何前导零。

以链接的Math.SE帖子为例，我们可以1000通过以下步骤进行操作：

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

您可以通过此过程获得哪些数字，最短的解决方案是什么？

挑战

给定正整数，如果可能的话N，确定N上述过程可以达到的最短整数序列。如果有几个最佳解决方案，请输出其中任何一个。如果不存在这样的序列，则应输出一个空列表。

该序列可以采用任何方便，明确的字符串或列表格式。

您可以编写程序或函数，通过STDIN（或最接近的替代方案），命令行参数或函数自变量获取输入，并通过STDOUT（或最接近的替代方案），函数返回值或函数（out）参数输出结果。

这是代码高尔夫球，因此最短的答案（以字节为单位）获胜。

测试用例

这是所有可达的数字列表，最大为256，包括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}

如果您想要更多的测试数据，请使用以下表格，最多1000张，包括1000张。

这些表上未出现的任何数字都应产生一个空列表（前提是该数字在表的范围内）。

— 马丁·恩德
source

执行时间有界限吗？

— 2015年

2

@Fatalize不，发疯。

— Martin Ender

我想可能无限的执行时间是不能接受的吗？从理论上讲它必须终止？

— 致命

@Fatalize嗯，像往常一样。

— Martin Ender

如果有多个结果，该怎么办：[1，2，4，8，16，32，64，46，92，29] [1，2，4，8，16，32，23，46，92， 29]

— dbramwell

18

Pyth，43个字节

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

示范。

首先生成所有可能的double或rerange序列。但是，由于我实际上希望看到它完成，所以添加了一个短路。

它要么运行直到找到解决方案，要么进行等于输入的迭代次数，然后放弃并返回[]。

保证有足够的迭代次数。首先，由于示例结果，我们知道对于所有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的情况，上限将小于具有这么多位数的任何数字，这完成了证明等于输入的迭代次数总是足够的证明。

— 伊萨格
source

您确定等于输入的迭代次数就足够了吗？从理论上讲，上限不会在下一个10的幂附近（因为序列可以任意频繁地减小）。

— 马丁·恩德

@MartinBüttner好点。我认为应该有一个证明，即输入总是足够的，但是我现在将对其进行编辑。

— isaacg 2015年

@MartinBüttner证明足以等于输入的迭代总是足够的。

— isaacg 2015年

啊，很好。：）（有趣的是，甚至多达100,000，您也不需要超过26个步骤。）

— Martin Ender 2015年

我相信枚举不超过输入内容的所有步骤会更快吗？

— John Dvorak

7

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，但是我看不出为什么它不起作用。

— 致命
source

2

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

— 格伦·奥
source

1

Haskell，246个字节

我不确定这是否行得通，但确实会发现，先分散开的顺序（例如排序较低）总是较短，例如

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

— 雷夫·威勒茨
source

1

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

— 斯蒂芬·辛克尔
source

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

在线尝试

我已经坐了很长时间了，它不是很短也不很快，而且我不确定我是否有动力/动力去改进它，所以我只是发布它。

— di
source

您可以通过加倍并重新排列来达到此数字吗？

挑战