Ein Reisender muss n Tage in einem Hotel außerhalb der Stadt bleiben . Er hat kein Geld mehr und seine Kreditkarte ist abgelaufen. Aber er hat eine goldene Kette mit n Gliedern.

Die Regel in diesem Hotel ist, dass die Bewohner ihre Miete jeden Morgen bezahlen sollten. Der Reisende vereinbart mit dem Manager, dass er für jeden Tag ein Glied der goldenen Kette zahlt. Der Manager fordert aber auch, dass der Reisende die Kette so wenig wie möglich beschädigt, während er jeden Tag zahlt. Mit anderen Worten, er muss eine Lösung finden, um so wenig Glieder wie möglich zu schneiden.

Durch das Ausschneiden einer Verknüpfung werden drei Unterketten erstellt: eine, die nur die ausgeschnittene Verknüpfung enthält, und eine auf jeder Seite. Wenn Sie beispielsweise das dritte Glied einer Kette mit der Länge 8 abschneiden, werden Unterketten mit der Länge [2, 1, 5] erstellt. Der Manager nimmt gerne Änderungen vor, sodass der Reisende den ersten Tag mit der Kette der Länge 1 und den zweiten Tag mit der Kette der Länge 2 bezahlen und die erste Kette zurückerhalten kann.

Ihr Code sollte die Länge n eingeben und eine Liste der zu schneidenden Links mit minimaler Länge ausgeben.

Regeln :

• n ist eine ganze Zahl> 0.
• Sie können für die Links entweder eine 0-basierte oder eine 1-basierte Indizierung verwenden.
• Für einige Zahlen ist die Lösung nicht eindeutig. Zum Beispiel, wenn n = 15beide [3, 8]und [4, 8]gültige Ausgaben sind.
• Sie können die Liste entweder zurückgeben oder mit einem geeigneten Trennzeichen drucken.
• Das ist Code-Golf , also gewinnt der kürzeste Code in Bytes.

Testfälle :

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

Ausführliches Beispiel

Für n = 15 führt das Schneiden der Glieder 3 und 8 zu Unterketten mit einer Länge [2, 1, 4, 1, 7]. Dies ist eine gültige Lösung, weil:

 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

Es gibt keine Lösung mit nur einem Schnitt, daher ist dies eine optimale Lösung.

Nachtrag

Beachten Sie, dass dieses Problem mit der Partitionierung ganzer Zahlen zusammenhängt. Wir suchen nach einer Partition P von n, so dass alle ganzen Zahlen von 1 bis n mindestens eine Partition haben, die eine Teilmenge von P ist .

Hier ist ein YouTube-Video zu einem möglichen Algorithmus für dieses Problem.

05AB1E , 23 11 8 Bytes

ΔÍN-;иg=

Probieren Sie es online!

Verwendet eine 0-basierte Indizierung.

Erläuterung:

             # 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

иgEs sieht aus wie ein Noop, macht aber zwei nützliche Dinge: Es schneidet auf eine Ganzzahl ab ( ;gibt einen Float zurück) und stürzt den Interpreter ab, wenn x negativ ist (dies ist die einzige Exit-Bedingung).

Die 23-Byte-Lösung verwendete einen ganz anderen Ansatz, und hier ist es für die Nachwelt: ÅœʒR2äθP}ʒæOê¥P}θ2äθη€O( TIO , Erklärung ).

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

Probieren Sie es online!

Erläuterung:

Bildet eine Folge von 'binären' Blöcken, wobei eine Basisnummer mit der Anzahl der Schnitte übereinstimmt.

Z.B:

63 kann in 3 Schnitten gemacht werden, was eine Partition in Basis 4 bedeutet (da wir 3 einzelne Ringe haben):

Cuts:, 5, 14, 31was Ketten von 4 1 8 1 16 1 32(sortiert :) ergibt 1 1 1 4 8 16 32.

Alle Zahlen können gemacht werden:

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

Andere Beispiele:

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 dank Aaron Hayman

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

Probieren Sie es online!

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

(Die letzte Unterkette muss möglicherweise gekürzt werden, wenn die Gesamtlänge der Kette überschritten wird.)

Ungolfed (basierend auf einer früheren, ähnlichen 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
}

$k$$k$$k$$k+1$$2k+1$$2k+2$$4k+4$$k$$(k+1)\cdot 2^k-1$.)

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

Gelee , 12 Bytes

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

Probieren Sie es online!

Übersetzung 05AB1E Antwort des Grimy so sicher sein , auch , dass man upvote! Etwas enttäuscht kommt dies in einem Byte länger, hat aber zumindest etwas wie ein Emoticon als die ersten drei Bytes!

JavaScript (ES6), 66 Byte

Dies ist eine Portierung von TFelds Antwort .

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

Probieren Sie es online!

C ++, 109 , 107 Bytes

-2 Bytes dank 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<<',';}

Der Algorithmus ähnelt der Antwort von Robin Ryder. Der Code ist in einer kompilierbaren, vollständigen Form geschrieben. Versuch es!

Einzelheiten:

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

Dies hat eine C- Variante mit der gleichen Bytelänge (scheint keine separate Antwort zu benötigen):

#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+
$.&

Probieren Sie es online! 1-indizierter Port von @ Grimys Antwort. Erläuterung:

.+
11,$&$*

Beginnen Sie mit N=2und konvertieren Sie die Eingabe in Unary.

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

Versuchen Sie wiederholt, Nvon der Eingabe zu subtrahieren und dann durch 2 zu dividieren.

1$2¶1$1,$3

Wenn erfolgreich, merken Sie sich 1 mehr als die Eingabe in der vorherigen Zeile, erhöhen Sie Ndie Eingabe in der aktuellen Zeile und aktualisieren Sie die Eingabe auf den neuen Wert.

1+,
1

Entfernen Sie Nden letzten Wert und erhöhen Sie ihn, damit er auch 1-indiziert ist.

1A`

Entfernen Sie die inkrementierte Originaleingabe.

1+
$.&

Konvertieren Sie die Ergebnisse in Dezimalzahlen.

Ruby , 62 Bytes

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

Probieren Sie es online!

Meistens aus TFelds Python-Antwort gestohlen.