34

시작 1하여 다음 두 가지 작업 중 하나를 반복적으로 수행 할 수 있습니다.

숫자를 두 배로 늘리십시오.

또는
선행 0이 없어야한다는 점을 제외하고 원하는 방식으로 숫자를 다시 정렬하십시오.

연결된 Math.SE 게시물에서 예를 들어 1000다음 단계를 통해 도달 할 수 있습니다 .

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

이 과정에서 어떤 숫자를 얻을 수 있으며 가장 짧은 해결책은 무엇입니까?

도전

양의 정수가 주어지면 N가능한 N경우 위의 프로세스 에 도달 할 수있는 가장 짧은 정수 시퀀스를 결정하십시오 . 최적의 솔루션이 여러 개인 경우 그 중 하나를 출력하십시오. 이러한 순서가 없으면 빈 목록을 출력해야합니다.

시퀀스는 편리하고 명확한 문자열 또는 목록 형식 일 수 있습니다.

STDIN (또는 가장 가까운 대안), 명령 행 인수 또는 함수 인수를 통해 입력을 받고 STDOUT (또는 가장 가까운 대안), 함수 리턴 값 또는 함수 (out) 매개 변수를 통해 결과를 출력하는 프로그램 또는 함수를 작성할 수 있습니다.

이것은 코드 골프이므로 가장 짧은 대답 (바이트)이 이깁니다.

테스트 사례

다음은 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 이하의 동일한 테이블이 있습니다.

이 테이블에 나타나지 않는 숫자는 빈 목록을 생성해야합니다 (숫자가 테이블 범위에있는 경우).

— 마틴 엔더
소스

실행 시간에 한계가 있습니까?

— Fatalize

2

@ 운명을 싫어, 미쳐.

— Martin Ender

잠재적으로 무한한 실행 시간이 허용되지 않는다고 생각합니까? 이론적으로 종료해야합니까?

— Fatalize

@Fatalize Ah 예, 평소처럼 .

— 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

데모.

가능한 모든 이중 또는 재 배열 시퀀스를 생성하여 시작합니다. 그러나 실제로 마무리 작업을보고 싶기 때문에 단락을 추가했습니다.

솔루션을 찾을 때까지 또는 입력과 동일한 여러 반복에 대해 실행되어 포기하고 반환합니다 [].

이것은 충분한 반복이 보장됩니다. 첫째, 우리는 예제 결과 덕분에이 많은 반복이 모든 n <= 1000에 충분하다는 것을 알고 있습니다. 숫자가 클 경우 다음과 같은 인수가 사용됩니다.

먼저 프로세스의 각 단계는 자릿수를 유지하거나 늘려야합니다.

둘째, 처음부터 끝까지 단일 재배치를하는 것이 더 빠르기 때문에, 서로의 재 배열 인 3 개의 숫자는 모두 가장 짧은 순서로 나타날 수 없습니다.

셋째, 배가도 재배 열도 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 이상의 모든 가능한 자릿수에 대해 많은 자릿수를 가진 숫자보다 낮을 것이므로 입력과 동일한 반복 횟수가 항상 충분하다는 증거를 완성합니다.

— 아이작
소스

입력과 동일한 반복 횟수로 충분합니까? 이론적으로 상한은 10의 다음 거듭 제곱 주위가 아닙니다 (시퀀스가 임의로 자주 감소 할 수 있기 때문에).

— 마틴 엔더

@ MartinBüttner 좋은 지적입니다. 입력이 항상 충분하다는 증거가 있어야한다고 생각하지만 지금은 편집 할 것입니다.

— isaacg

@ MartinBüttner 입력과 동일한 반복이 항상 충분하다는 증거.

— isaacg

아, 아주 좋아요 :) (흥미롭게도, 심지어 100,000 단계까지 26 단계 이상이 필요하지 않습니다.)

— Martin Ender

입력보다 길지 않은 모든 단계를 열거하는 것이 더 빠를 것이라고 생각합니까?

— John Dvorak

7

SWI- 프롤로그, 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에서 작동하는지 아직 확인하지는 않았지만 왜 작동하지 않을 이유가 없다.

— 치명적
소스

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 바이트

이것이 작동하는지 완전히 확신하지 못합니다. 예를 들어 처음으로 더 낮은 분기 (더 낮은 정렬)가 항상 더 짧은 경우

[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

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보다 큰 숫자는 테스트하지 않았습니다. 시간이 있으면 행운을 빕니다 ;-)

편집 : ungolfed 버전 :

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

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

온라인으로 사용해보십시오

나는 오랫동안 이것에 앉아 있었고, 짧거나 빠르지 않으며 그것을 향상시킬 에너지 / 동기가 있는지 확실하지 않으므로 게시하고 있습니다.

— 아디 츠
소스

배가하고 정리하여이 수에 도달 할 수 있습니까?

도전

테스트 사례

Pyth, 43 바이트

SWI- 프롤로그, 252 바이트

줄리아, 306 245 218 바이트

하스켈, 246 바이트

C # 655 바이트

CJam, 83