Zainspirowany tym pytaniem na Math.SE .
Zaczynając od 1
, możesz wielokrotnie wykonać jedną z następujących dwóch operacji:
Podwój liczbę.
lub
Zmień kolejność cyfr w dowolny sposób, z tym wyjątkiem, że nie może być żadnych zer wiodących.
Biorąc przykład z połączonego postu Math.SE, możemy dotrzeć, 1000
wykonując następujące kroki:
1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 125, 250, 500, 1000
Jakie liczby można osiągnąć dzięki temu procesowi i jakie jest najkrótsze rozwiązanie?
Wyzwanie
Biorąc pod uwagę dodatnią liczbę całkowitą N
, określ najkrótszą możliwą sekwencję liczb całkowitych do osiągnięcia N
w powyższym procesie, jeśli to możliwe. Jeśli istnieje kilka optymalnych rozwiązań, wypisz dowolne z nich. Jeśli taka sekwencja nie istnieje, powinieneś wypisać pustą listę.
Sekwencja może mieć dowolny dogodny, jednoznaczny ciąg lub format listy.
Możesz napisać program lub funkcję, pobierając dane wejściowe przez STDIN (lub najbliższą alternatywę), argument wiersza poleceń lub argument funkcji i wypisując wynik przez STDOUT (lub najbliższą alternatywę), wartość zwracaną funkcji lub parametr funkcji (wyjściowej).
To jest kod golfowy, więc wygrywa najkrótsza odpowiedź (w bajtach).
Przypadki testowe
Oto lista wszystkich osiągalnych liczb do 256 włącznie. Pierwsza kolumna to liczba (dane wejściowe), druga kolumna to optymalna liczba kroków (których można użyć do sprawdzenia poprawności rozwiązania) i trzecia kolumna jest jedną optymalną sekwencją, aby się tam dostać:
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}
Jeśli chcesz uzyskać jeszcze więcej danych testowych, oto ta sama tabela do 1000 włącznie .
Każda liczba nie pojawiająca się w tych tabelach powinna dać pustą listę (pod warunkiem, że liczba mieści się w zakresie tabeli).
źródło
Odpowiedzi:
Pyth, 43 bajty
Demonstracja.
Zaczyna się to od wygenerowania wszystkich możliwych sekwencji podwójnych lub przestawionych. Ponieważ jednak naprawdę chciałem, aby to się skończyło, dodałem zwarcie.
Działa albo dopóki nie znajdzie rozwiązania, albo przez szereg iteracji równych wejściowi, w którym to momencie poddaje się i wraca
[]
.Gwarantuje to wystarczającą liczbę iteracji. Po pierwsze wiemy, że dzięki tak wielu przykładowym wynikom wystarczy tyle iteracji dla wszystkich n <= 1000. W przypadku większych liczb obowiązuje następujący argument:
Po pierwsze, każdy etap procesu musi albo utrzymywać, albo zwiększać liczbę cyfr.
Po drugie, trzy liczby, które wszystkie są wzajemnie przestawione, nigdy nie mogą pojawić się w najkrótszej sekwencji, ponieważ szybsze byłoby wykonanie pojedynczej przegrupowania od pierwszej do ostatniej.
Po trzecie, wszystkie wielokrotności 3 są nieosiągalne, ponieważ ani podwojenie, ani przegrupowanie nie może dać wielokrotności 3 z wielokrotności 3.
Zatem najdłuższa możliwa sekwencja kończąca się na danej liczbie jest równa sumie dwukrotności liczby zestawów cyfr z mniejszą lub równą tylu cyfrom na wejściu, przy czym cyfry nie sumują się do wielokrotności 3.
Liczba takich zestawów cyfr dla każdej liczby cyfr:
Ponadto wiemy z przykładów, że żadna najkrótsza sekwencja zakończona trzycyfrową liczbą nie ma długości większej niż 26. Zatem górna granica długości sekwencji wynosi:
W każdym przypadku górna granica jest niższa niż dowolna liczba z liczbą cyfr
Liczba zestawów cyfr nie może wzrosnąć więcej niż o współczynnik 10, gdy liczba cyfr zostanie zwiększona o jeden, ponieważ nowe liczby można podzielić na grupy według ostatniej cyfry, z których każdy nie może mieć większej liczby zestawów niż z jedną mniejszą cyfra.
Zatem górna granica będzie niższa niż jakakolwiek liczba z taką liczbą cyfr dla wszystkich możliwych liczb cyfr większych lub równych 4, co uzupełnia dowód, że liczba iteracji równa wartości wejściowej jest zawsze wystarczająca.
źródło
SWI-Prolog, 252 bajty
Przykład:
a(92,Z).
wyjściaZ = [1, 2, 4, 8, 16, 32, 64, 46, 92]
Nie sprawdziłem jeszcze, czy to działa dla N> 99 ze względu na czas, ale nie widzę powodu, dla którego to nie działałoby.
źródło
Julia,
306245218 bajtówNadal pracuję nad golfem. Dostarczy wersję bez golfa, gdy skończę.
źródło
Haskell, 246 bajtów
Nie jestem do końca pewien, czy to działa, czy działa, gdy sekwencja, która najpierw rozbiera się niżej (aby zostać posortowana niżej) jest zawsze krótsza, jak na przykład
[1,2,4,8,16,32,64,128,256,512,125,250,500,1000]
jest krótszy niż
[1,2,4,8,16,32,64,128,256,512,251,502,250,500,1000]
który sprawdziłem, aby był prawdziwy do 1000.
źródło
C # 655 bajtów
Zadzwoń za pomocą (LinqPad):
Nie testowałem liczb powyżej 99. Jeśli masz czas -> powodzenia ;-)
edycja: wersja bez golfa:
źródło
CJam, 83
Wypróbuj online
Siedzę nad tym od dłuższego czasu, nie jest on zbyt krótki ani szybki i nie jestem pewien, czy mam energię / motywację, aby to poprawić, więc po prostu to publikuję.
źródło