Um viajante precisa ficar n dias em um hotel fora da cidade. Ele está sem dinheiro e seu cartão de crédito expirou. Mas ele tem uma corrente de ouro com n elos.

A regra neste hotel é que os residentes paguem o aluguel todas as manhãs. O viajante chega a um acordo com o gerente para pagar um elo da cadeia de ouro por dia. Mas o gerente também exige que o viajante cause o menor dano possível à cadeia e pague todos os dias. Em outras palavras, ele tem que encontrar uma solução para cortar o menor número possível de links.

Cortar um link cria três sub-cadeias: uma contendo apenas o link de corte e uma de cada lado. Por exemplo, cortar o terceiro elo de uma cadeia de comprimento 8 cria sub-cadeias de comprimento [2, 1, 5]. O gerente tem o prazer de fazer alterações, para que o viajante possa pagar o primeiro dia com a cadeia de comprimento 1, depois o segundo dia com a cadeia de comprimento 2, recuperando a primeira cadeia.

Seu código deve inserir o comprimento n e gerar uma lista de links para cortar no tamanho mínimo.

Regras :

• n é um número inteiro> 0.
• Você pode usar a indexação com base em 0 ou em 1 para os links.
• Para alguns números, a solução não é única. Por exemplo, se n = 15ambos [3, 8]e[4, 8] são saídas válidas.
• Você pode retornar a lista ou imprimi-la com qualquer separador razoável.
• Isso é código-golfe , então o código mais curto em bytes vence.

Casos de teste :

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

Exemplo detalhado

Para n = 15, cortar os links 3 e 8 resulta em sub-cadeias de comprimento [2, 1, 4, 1, 7]. Esta é uma solução válida porque:

 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

Não existe solução com apenas um corte; portanto, essa é uma solução ideal.

Termo aditivo

Observe que esse problema está relacionado ao particionamento inteiro. Estamos à procura de uma partição P de n tal que todos os inteiros de 1 a n ter pelo menos um patition que é um subconjunto de P .

Aqui está um vídeo do YouTube sobre um possível algoritmo para esse problema.

05AB1E , 23 11 8 bytes

ΔÍN-;иg=

Experimente online!

Usa indexação baseada em 0.

Explicação:

             # 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

иgparece um noop, mas na verdade faz duas coisas úteis: trunca para um número inteiro ( ;retorna um número flutuante) e trava o interpretador se x for negativo (esta é a única condição de saída).

A solução de 23 bytes usou uma abordagem muito diferente, então aqui está a posteridade: ÅœʒR2äθP}ʒæOê¥P}θ2äθη€O( TIO , explicação ).

Python 2 , 75 bytes

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

Experimente online!

Explicação:

Cria uma sequência de blocos 'binários', com um número base correspondente ao número de cortes.

Por exemplo:

63 pode ser feito em 3 cortes, o que significa uma partição na base-4 (como temos 3 anéis únicos):

Cortes:, 5, 14, 31que fornece cadeias de 4 1 8 1 16 1 32(classificadas:) 1 1 1 4 8 16 32.

Todos os números podem ser feitos:

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

Outros exemplos:

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 bytes

-8 bytes thanks to Aaron Hayman

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

Try it online!

Let $k$ be the number of cuts needed; $k$ is the smallest integer such that $(k+1)\cdot2^k\geq n$. Indeed, a possible solution is then to have subchains of lengths $1,1,\ldots,1$ ($k$ times) and $(k+1), 2(k+1), 4(k+1), 8(k+1), \ldots, (k+1)\cdot 2^{k-1}$. It is easy to check that this is sufficient and optimal.

(The last subchain might need to be made shorter if we exceed the total length of the chain.)

Ungolfed (based on previous, similar version):

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
}

(Proof that the value of $k$ is as I state: suppose we have $k$ cuts. We then have $k$ unit subchains, so we need the first subchain to be of length $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.