Un voyageur doit rester n jours dans un hôtel situé en dehors de la ville. Il n'a plus d'argent et sa carte de crédit est expirée. Mais il a une chaîne en or avec n liens.

La règle dans cet hôtel est que les résidents doivent payer leur loyer tous les matins. Le voyageur conclut un accord avec le responsable pour payer un maillon de la chaîne en or chaque jour. Mais le responsable exige également que le voyageur fasse le moins de dégâts possible à la chaîne en payant tous les jours. En d'autres termes, il doit trouver une solution pour couper le moins de liens possible.

Couper un lien crée trois sous-chaînes: une contenant uniquement le lien coupé et une de chaque côté. Par exemple, couper le troisième maillon d'une chaîne de longueur 8 crée des sous-chaînes de longueur [2, 1, 5]. Le responsable est heureux de rendre la monnaie, de sorte que le voyageur puisse payer le premier jour avec la chaîne de longueur 1, puis le deuxième jour avec la chaîne de longueur 2, en récupérant la première chaîne.

Votre code doit entrer la longueur n et générer une liste de liens à couper de longueur minimale.

Règles :

• n est un entier> 0.
• Vous pouvez utiliser l'indexation 0 ou 1 pour les liens.
• Pour certains numéros, la solution n'est pas unique. Par exemple, si les n = 15deux [3, 8]et [4, 8]sont des sorties valides.
• Vous pouvez soit renvoyer la liste, soit l’imprimer avec un séparateur raisonnable.
• C'est le code-golf , donc le code le plus court en octets gagne.

Cas de test :

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

Exemple détaillé

Pour n = 15, couper les liens 3 et 8 donne des sous-chaînes de longueur [2, 1, 4, 1, 7]. C'est une solution valable pour les raisons suivantes:

 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

Il n’existe pas de solution avec une seule découpe, c’est donc une solution optimale.

Addenda

Notez que ce problème est lié au partitionnement entier. Nous sommes à la recherche d'une partition P de n tel que tous les entiers de 1 à n ont au moins un patition qui est un sous - ensemble de P .

Voici une vidéo YouTube sur un algorithme possible pour ce problème.

05AB1E , 23 11 8 octets

ΔÍN-;иg=

Essayez-le en ligne!

Utilise l'indexation basée sur 0.

Explication:

             # 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

иgCela ressemble à un noop, mais il fait deux choses utiles: il tronque un entier ( ;renvoie un float) et bloque l'interpréteur si x est négatif (c'est la seule condition de sortie).

La solution à 23 octets utilisait une approche très différente, donc la voici pour la postérité: ÅœʒR2äθP}ʒæOê¥P}θ2äθη€O( TIO , explication ).

Python 2 , 75 octets

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

Essayez-le en ligne!

Explication:

Construit une séquence de morceaux «binaires», avec un numéro de base correspondant au nombre de coupes.

Par exemple:

63 peut être fait en 3 coupes, ce qui signifie une partition en base 4 (comme nous avons 3 anneaux simples):

Cuts:, 5, 14, 31qui donne des chaînes de 4 1 8 1 16 1 32(trié:) 1 1 1 4 8 16 32.

Tous les nombres peuvent être faits:

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

Autres exemples:

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 octets

-8 octets grâce à Aaron Hayman

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

Essayez-le en ligne!

$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}$

(La dernière sous-chaîne devra peut-être être raccourcie si nous dépassons la longueur totale de la chaîne.)

Ungolfed (basé sur la version précédente similaire):

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$$2k+1$$2k+2$$4k+4$$k$$(k+1)\cdot 2^k-1$.)

$a(k)$$n$$k$$a(k)$

Gelée , 12 octets

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

Essayez-le en ligne!

Traduction de la réponse 05AB1E de Grimy, assurez-vous donc de l'emporter également! Légèrement déçu, cela vient dans un octet plus long, mais a au moins quelque chose qui ressemble un peu à une émoticône que les trois premiers octets!

JavaScript (ES6), 66 octets

Ceci est une réponse de TFeld .

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

Essayez-le en ligne!

C ++, 109 , 107 octets

-2 octets grâce à 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<<',';}

L'algorithme est similaire à la réponse de Robin Ryder. Le code est écrit sous une forme complète compilable. Essayez le!

Détails:

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

Cela a une variation C avec la même longueur d'octet (ne semble pas avoir besoin d'une réponse séparée):

#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 octets

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

Essayez-le en ligne! Port indexé 1 de la réponse de @ Grimy. Explication:

.+
11,$&$*

Commencez avec N=2et l'entrée convertie en unaire.

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

Essayez à plusieurs reprises de soustraire Nde l’entrée puis de diviser par 2.

1$2¶1$1,$3

En cas de succès, rappelez-vous de plus que l'entrée de la ligne précédente, incrémentez Nla ligne actuelle et mettez à jour l'entrée avec la nouvelle valeur.

1+,
1

Supprimez Net incrémentez la dernière valeur pour qu'elle soit également indexée sur 1.

1A`

Supprimez l'entrée d'origine incrémentée.

1+
$.&

Convertir les résultats en décimal.

Ruby , 62 octets

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

Essayez-le en ligne!

Surtout volé dans la réponse Python de TFeld.