Путешественник должен остановиться на n дней в отеле за городом. У него нет денег, а срок действия его кредитной карты истек. Но у него золотая цепочка с n звеньями.

Правило в этом отеле состоит в том, что жители должны платить за квартиру каждое утро. Путешественник приходит к соглашению с менеджером по оплате одного звена золотой цепочки за каждый день. Но менеджер также требует, чтобы путешественник наносил наименьший ущерб цепи при оплате каждый день. Другими словами, он должен найти решение, чтобы сократить как можно меньше ссылок.

Разрезание ссылки создает три подцепи: одну, содержащую только ссылку обрезки, и одну на каждой стороне. Например, разрезание третьего звена цепочки длиной 8 создает подцепи длины [2, 1, 5]. Менеджер рад внести изменения, поэтому путешественник может оплатить первый день цепочкой длины 1, а затем второй день цепочкой длины 2, получая первую цепочку обратно.

Ваш код должен вводить длину n и выводить список ссылок для вырезания минимальной длины.

Правила :

• n является целым числом> 0.
• Вы можете использовать индексацию на основе 0 или 1 для ссылок.
• Для некоторых чисел решение не является уникальным. Например, если n = 15оба [3, 8]и [4, 8]являются действительными выходами.
• Вы можете либо вернуть список, либо распечатать его с любым разумным разделителем.
• Это код-гольф , поэтому выигрывает самый короткий код в байтах.

Тестовые случаи :

Input          Output (1-indexed)
1              []
3              [1]
7              [3]
15             [3, 8]
149            [6, 17, 38, 79]

Подробный пример

Для n = 15 обрезка звеньев 3 и 8 приводит к подцепям длины [2, 1, 4, 1, 7]. Это правильное решение, потому что:

 1 = 1
 2 = 2
 3 = 1+2
 4 = 4
 5 = 1+4
 6 = 2+4
 7 = 7
 8 = 1+7
 9 = 2+7
10 = 1+2+7
11 = 4+7
12 = 1+4+7
13 = 2+4+7
14 = 1+2+4+7
15 = 1+1+2+4+7

Не существует решения с одним разрезом, так что это оптимальное решение.

добавление

Обратите внимание, что эта проблема связана с целочисленным разбиением. Мы ищем разбиения P из п , что все целые числа от 1 до п , по крайней мере , один patition , который является подмножеством P .

Вот видео на YouTube об одном из возможных алгоритмов этой проблемы.

05AB1E , 23 11 8 байтов

ΔÍN-;иg=

Попробуйте онлайн!

Использует индексирование на основе 0.

Объяснение:

             # start from the implicit input
Δ            # loop forever
 Í           # subtract 2
  N-         # subtract the current iteration number
    ;        # divide by 2
     и       # create a list of length x
      g      # get the length of the list
       =     # print

иgвыглядит как noop, но на самом деле он делает две полезные вещи: он усекает целое число ( ;возвращает число с плавающей запятой) и сбивает интерпретатор, если x отрицателен (это единственное условие выхода).

23-байтовое решение использовало совершенно другой подход, поэтому здесь оно для потомков: ÅœʒR2äθP}ʒæOê¥P}θ2äθη€O( TIO , объяснение ).

Python 2 , 75 байт

f=lambda n,i=0:n>=i<<i and f(n,i+1)or[min(n,2**j*i-i+j)for j in range(1,i)]

Попробуйте онлайн!

Объяснение:

Создает последовательность «двоичных» чанков, базовый номер которых соответствует количеству срезов.

Например:

63 может быть сделано в 3 разреза, что означает разделение в base-4 (так как у нас есть 3 одинарных кольца):

Порезы:, 5, 14, 31который дает цепочки 4 1 8 1 16 1 32(отсортировано:) 1 1 1 4 8 16 32.

Все номера могут быть сделаны:

1       1
2       1 1
3       1 1 1
4       4
...
42      1 1 8 32
...
62      1 1 4 8 16 32
63      1 1 1 4 8 16 32

Другие примеры:

18: 4,11        ->  3 1 6 1 7
27: 5,14,27     ->  4 1 8 1 13 1
36: 5,14,31     ->  4 1 8 1 16 1 5
86: 6,17,38,79  ->  5 1 10 1 20 1 40 1 7

R , 77 69 байт

-8 байт благодаря Аарону Хейману

pmin(n<-scan(),0:(k=sum((a=2:n)*2^a<=n))+cumsum((k+2)*2^(0:k))+1)[-n]

Попробуйте онлайн!

Позволять $k$ количество необходимых разрезов; $k$ наименьшее целое число такое, что $(k+1)\cdot2^k\geq n$, Действительно, тогда возможное решение состоит в том, чтобы иметь подцепи длин$1,1,\ldots,1$ ($k$ раз) и $(k+1), 2(k+1), 4(k+1), 8(k+1), \ldots, (k+1)\cdot 2^{k-1}$, Нетрудно убедиться, что этого достаточно и оптимально.

(Последняя подцепь может быть сокращена, если мы превысим общую длину цепочки.)

Ungolfed (на основе предыдущей, аналогичной версии):

n = scan()                            # read input
if(n - 1){                            # If n==1, return NULL
  k = match(F, (a = 2:n) * 2 ^ a > n) # compute k
  b = (k + 1) * 2 ^ (1:k - 1)         # lengths of subchains
  c = 1:k + cumsum(b)                 # positions of cuts
  pmin(c, n )                         # if last value is >n, coerce it to n
}

(Доказательство того, что значение $k$ это как я утверждаю: предположим, у нас есть $k$порезы. Затем мы имеем$k$ единичные подцепи, поэтому нам нужно, чтобы первая подцепь имела длину $k+1$. We can now handle all lengths up to $2k+1$, so we need the next one to be of length $2k+2$, then $4k+4$... Thus the maximum we can get out of $k$ cuts is obtained by summing all those lengths, which gives $(k+1)\cdot 2^k-1$.)

If $a(k)$ is the smallest integer $n$ requiring $k$ cuts, then $a(k)$ is OEIS A134401.

Jelly, 12 bytes

’_‘ɼ:2»-µƬṖḊ

Try it online!

Translation of Grimy's 05AB1E answer so be sure to upvote that one too! Slightly disappointed this comes in a byte longer, but does at least have something a bit like an emoticon as the first three bytes!

JavaScript (ES6), 66 bytes

This is a port of TFeld's answer.

n=>(g=a=>n<++i<<i?a.map(j=>(j+=(i<<j)-i)>n?n:j):g([...a,i]))(i=[])

Try it online!

C++, 109,107 bytes

-2 bytes thanks to Kevin

#include<iostream>
main(){int n,k=0;for(std::cin>>n;++k<<k<n;);for(n-=k;n>0;k*=2,n-=k+1)std::cout<<n<<',';}

The algorithm is similar to the Robin Ryder's answer. The code is written in a compilable, whole form. Try it!

Details:

std::cin>>n;               // get the value of n as input
while(++k<<k<n);           // determine k
for(n-=k;n>0;k*=2,n-=k+1)  // we don't need n, so the lengths...
    std::cout<<n<<' ';     // of links are subtracted repeatedly

This has a C variation with the same byte length (doesn't seem to need a separate answer):

#include<stdio.h>
main(){int n,k=0;for(scanf("%d",&n);++k<<k<n;);for(n-=k;n>0;k*=2,n-=k+1)printf("%d,",n);}

Retina 0.8.2, 61 bytes

.+
11,$&$*
+`\b(1+),(\1(1*)1?\3)$
1$2¶1$1,$3
1+,
1
1A`
1+
$.&

Try it online! 1-indexed port of @Grimy's answer. Explanation:

.+
11,$&$*

Start with N=2 and the input converted to unary.

+`\b(1+),(\1(1*)1?\3)$

Repeatedly try to subtract N from the input and then divide by 2.

1$2¶1$1,$3

If successful, remember 1 more than the input on the previous line, increment N on the current line, and update the input to the new value.

1+,
1

Remove N and increment the last value so that it's also 1-indexed.

1A`

Remove the incremented original input.

1+
$.&

Convert the results to decimal.

Ruby, 62 bytes

->n{(1...c=(0..n).find{|r|n<r<<r}).map{|b|[n,b-c+(c<<b)].min}}

Try it online!

Mostly stolen from TFeld's Python answer.