Puoi raggiungere questo numero raddoppiando e riorganizzando?

34

Ispirato da questa domanda Math.SE .

A partire da 1te puoi eseguire ripetutamente una delle due seguenti operazioni:

  • Raddoppia il numero.

    o

  • Riorganizza le sue cifre nel modo desiderato, tranne per il fatto che non devono esserci zero iniziali.

Prendendo un esempio dal post Math.SE collegato, possiamo raggiungere 1000i seguenti passi:

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

Quali numeri puoi raggiungere con questo processo e qual è la soluzione più breve?

La sfida

Dato un numero intero positivo N, determinare la sequenza più breve possibile di numeri interi da raggiungere Ncon il processo sopra, se possibile. Se esistono diverse soluzioni ottimali, emetterne una qualsiasi. Se tale sequenza non esiste, è necessario generare un elenco vuoto.

La sequenza può essere in qualsiasi stringa o formato elenco conveniente, non ambiguo.

È possibile scrivere un programma o una funzione, prendendo l'input tramite STDIN (o l'alternativa più vicina), l'argomento della riga di comando o l'argomento della funzione e producendo il risultato tramite STDOUT (o l'alternativa più vicina), il valore di ritorno della funzione o il parametro della funzione (out).

Questo è il golf del codice, quindi vince la risposta più breve (in byte).

Casi test

Ecco un elenco di tutti i numeri raggiungibili fino a 256 inclusi. La prima colonna è il numero (il tuo input), la seconda colonna è il numero ottimale di passaggi (che puoi usare per verificare la validità della tua soluzione) e la terza colonna è una sequenza ottimale per arrivarci:

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}

Se desideri ancora più dati di test, ecco la stessa tabella fino a 1.000 inclusi .

Qualsiasi numero che non appare in queste tabelle dovrebbe produrre un elenco vuoto (a condizione che il numero sia compreso nell'intervallo della tabella).

code-golf  sequence  number-theory  path-finding  permutations 
— Martin Ender
fonte
Ci sono limiti al tempo di esecuzione?
— Fatalizza il
2
@Fatalizza no, impazzisci.
— Martin Ender,
Suppongo che tempi di esecuzione potenzialmente infiniti non siano accettabili? Deve teoricamente terminare?
— Fatalizza il
@Fatalize Ah sì, come al solito .
— Martin Ender,
Che dire quando c'è più di un risultato: [1, 2, 4, 8, 16, 32, 64, 46, 92, 29] [1, 2, 4, 8, 16, 32, 23, 46, 92, 29]
— dbramwell,

Risposte:

18

Pyth, 43 byte

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

Dimostrazione.

Questo inizia generando tutte le possibili sequenze doppie o riorganizzate. Tuttavia, poiché in realtà volevo vederlo finire, ho aggiunto un corto circuito.

Funziona fino a quando non trova una soluzione o per un numero di iterazioni pari all'input, a quel punto si arrende e ritorna [].

Questo è garantito per essere iterazioni sufficienti. Innanzitutto, sappiamo che queste numerose iterazioni sono sufficienti per tutti n <= 1000, grazie ai risultati di esempio. Per numeri più grandi, vale il seguente argomento:

Innanzitutto, ogni fase del processo deve mantenere o aumentare il numero di cifre.

In secondo luogo, tre numeri che sono tutti riarrangiamenti l'uno dell'altro non possono mai apparire tutti in una sequenza più breve, perché sarebbe stato più veloce eseguire un singolo riarrangiamento dal primo all'ultimo.

Terzo, tutti i multipli di 3 sono irraggiungibili, poiché né il raddoppio né il riarrangiamento possono produrre un multiplo di 3 da un non multiplo di 3.

Pertanto, la sequenza più lunga possibile che termina in corrispondenza di un determinato numero è uguale alla somma del doppio del numero di insiemi di cifre con un numero minore o uguale a quante cifre dell'input e in cui le cifre non si sommano a un multiplo di 3.

Il numero di tali set di cifre per ciascun numero di cifre:

4 - 474
5 - 1332
6 - 3330

Inoltre, dagli esempi sappiamo che nessuna sequenza più breve che termina con un numero di 3 cifre ha una lunghezza maggiore di 26. Pertanto, un limite superiore delle lunghezze della sequenza è:

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

In ogni caso, il limite superiore è inferiore a qualsiasi numero con il numero di cifre

Il numero di set di cifre non può aumentare di oltre un fattore 10 quando il numero di cifre viene aumentato di uno, poiché i nuovi numeri possono essere separati in gruppi dall'ultima cifra, ognuno dei quali non può avere più set di quanti ce ne fossero con uno in meno cifre.

Pertanto, il limite superiore sarà inferiore a qualsiasi numero con quel numero di cifre per tutti i possibili numeri di cifre maggiori o uguali a 4, il che completa la prova che un numero di iterazioni uguale all'input è sempre sufficiente.

— isaacg
fonte
Sei sicuro che un numero di iterazioni uguale all'input sia sufficiente? In teoria il limite superiore non si aggirerebbe attorno alla successiva potenza maggiore di 10 (poiché la sequenza può diminuire arbitrariamente spesso).
— Martin Ender,
@ MartinBüttner Un buon punto. Penso che ci dovrebbe essere una prova che l'input è sempre sufficiente, ma lo modificherò per ora.
— isaacg,
@ MartinBüttner La prova che iterazioni uguali all'input è sempre sufficiente.
— isaacg,
Ah, molto carino. :) (È interessante notare che anche fino a 100.000 non sono necessari più di 26 passaggi.)
— Martin Ender,
Credo che sarebbe più veloce enumerare tutti i passaggi non più a lungo dell'input?
— John Dvorak,
7

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

Esempio: a(92,Z).usciteZ = [1, 2, 4, 8, 16, 32, 64, 46, 92]

Non ho ancora verificato che questo funzioni per N> 99 a causa del tempo impiegato, ma non vedo alcun motivo per cui non funzionerebbe.

— Fatalize
fonte
2

Julia, 306 245 218 byte

Sto ancora lavorando sul golf. Fornirà una versione non golfata una volta terminato.

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,:])
— Glen O
fonte
1

Haskell, 246 byte

Non sono del tutto sicuro che funzioni, se la sequenza che prima diverge in basso (come da ordinare in basso) è sempre più breve, come ad esempio

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

è più corto di

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

che ho testato per essere vero fino a 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)
— Leif Willerts
fonte
1

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

Chiama con (LinqPad):

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

Non ho testato numeri superiori a 99. Se hai tempo -> buona fortuna ;-)

modifica: versione non golfata:

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}));
}
— Stephan Schinkel
fonte
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

Provalo online

Sono stato seduto su questo per molto tempo, non è molto breve né veloce, e non sono sicuro di avere l'energia / la motivazione per migliorarlo, quindi lo sto solo postando.

— aditsu
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.