Betrachten Sie ein Array Avon Länge n. Das Array enthält nur positive ganze Zahlen. Zum Beispiel A = (1,1,2,2). Definieren wir f(A)als die Summe aller nicht leeren zusammenhängenden Subarrays vonA . In diesem Fall f(A) = {1,2,3,4,5,6}. Die zu erzeugenden Schritte f(A) sind wie folgt:

Die Subarrays von Asind (1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2). Ihre jeweiligen Summen sind 1,1,2,2,2,3,4,4,5,6. Die Menge, die Sie aus dieser Liste erhalten, ist daher {1,2,3,4,5,6}.

Aufgabe

Bei einer Menge von Summen Sin sortierter Reihenfolge, die nur positive ganze Zahlen und eine Arraylänge enthält n, besteht Ihre Aufgabe darin, mindestens ein Array Xso auszugeben, dass f(X) = S.

Zum Beispiel, wenn S = {1,2,3,5,6}und n = 3dann eine gültige Ausgabe ist X = (1,2,3).

Wenn es kein solches Array gibt, sollte XIhr Code einen konstanten Wert ausgeben.

Beispiele

Eingabe:, n=4, S = (1, 3, 4, 5, 6, 8, 9, 10, 13)mögliche Ausgabe:X = (3, 5, 1, 4)

Eingabe:, n=6, S = (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)mögliche Ausgabe:X = (5, 3, 2, 2, 5, 5)

Eingabe:, n=6, S = (2, 4, 6, 8, 10, 12, 16)mögliche Ausgabe:X = (4, 2, 2, 2, 2, 4)

Eingabe:, n=6, S = (1, 2, 3, 4, 6, 7, 8, 10, 14)mögliche Ausgabe:X = (4, 2, 1, 1, 2, 4)

Input: n=10, S = (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)möglicher Ausgang: X = (1, 1, 3, 1, 2, 1, 2, 5, 4, 5).

Input: n=15, S = (1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31)möglicher Ausgang: X = (1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, 3).

Eingabe- und Ausgabeformat

Ihr Code kann Eingaben und Ausgaben in jedem leicht lesbaren Format annehmen, das Sie für bequem halten. Bitte zeigen Sie die Ausgabe des Tests jedoch an den Beispielen in der Frage.

Laufzeit

Sie müssen in der Lage sein, den Code für alle Beispiele in der Frage vollständig auszuführen. Es sollte im Prinzip für nbis zu 1 korrekt sein, 15aber Sie müssen nicht nachweisen, dass es für alle Eingaben schnell genug ist.

Schale , 20 Bytes

ḟȯ⁰¦ṁ∫ṫ!¡Sof~Λ€∫×:¹g

Probieren Sie es online!

Gibt eine Lösung oder eine leere Liste zurück, falls diese nicht vorhanden ist. Der letzte Testfall (n=15 ) endet mit TIO in 3,8 Sekunden.

Erläuterung

Das Programm besteht aus zwei Teilen. Im ersten Teil ( ¡und rechts davon) konstruieren wir eine unendliche Liste, deren kth-Element eine Liste ist, die alle Längenlisten kenthält, deren Slice-Summen in sind S. Wir tun dies induktiv, ausgehend von den 1-Element-Slices von Sund bei jedem Schritt vor jedem Element Sin jeder Liste und unter Beibehaltung derjenigen, deren Präfixsummen in sind S. Im zweiten Teil ( !und links davon) nehmen wir ndas dritte Element der Liste, das Längenlisten nenthält. Von diesen wählen wir die erste aus, deren Scheibensummen tatsächlich jedes Element von enthalten S.

Ersetzen wir im Code zunächst ound ȯ(die zwei und drei Funktionen zu einer zusammensetzen) aus Gründen der Klarheit durch Klammern.

¡S(f~Λ€∫)×:¹g  First part. Input is a list, say S=[1,2,3]
            g  Group equal adjacent elements: [[1],[2],[3]]
¡              Iterate function:
                Argument is a list of lists, say [[1,1],[1,2],[2,1]]
         ×      Mix (combine two lists in all possible ways)
          :     by prepending
           ¹    with the list S: [[1,1,1],[1,1,2],[2,1,1],[1,2,1],[2,1,2],[3,1,1],[2,2,1],[3,1,2],[3,2,1]]
   f            Filter by condition:
        ∫        Cumulative sums: [[1,2,3],[1,2,4],[2,3,4],[1,3,4],[2,3,5],[3,4,5],[2,4,5],[3,4,6],[3,5,6]]
     ~Λ          All of the numbers
 S     €         are elements of S: [[1,1,1]]
                 Only this list remains, since the other cumulative sums contain numbers not from S.
               Result of iteration: [[[1],[2],[3]],[[1,1],[1,2],[2,1]],[[1,1,1]],[],[],[]...

ḟ(⁰¦ṁ∫ṫ)!      Second part. Implicit input, say n=2.
        !      Take nth element of above list: [[1,1],[1,2],[2,1]]
ḟ              Find first element that satisfies this:
                Argument is a list, say [1,2]
      ṫ         Tails: [[1,2],[2]]
    ṁ           Map and concatenate
     ∫          cumulative sums: [1,3,2]
 ȯ ¦            Does it contain all elements of
  ⁰             S? Yes.
               Result is [1,2], print implicitly.

Es gibt einige Teile, die näher erläutert werden müssen. In diesem Programm ⁰¹verweisen beide hochgestellten Zeichen auf das erste Argument S. Wenn αes sich jedoch um eine Funktion handelt, α¹bedeutet dies "Anwenden αauf S" und ⁰α" SAn das zweite Argument von α" anschließen. Die Funktion ¦prüft, ob das erste Argument alle Elemente des zweiten enthält (Multiplizitäten werden gezählt). Dies Ssollte auch das zweite Argument sein.

Im ersten Teil kann die verwendete Funktion ¡als interpretiert werden S(f~Λ€∫)(×:)¹. Der Kombinator Sverhält sich so Sαβγ -> (αγ)(βγ), das heißt, wir können ihn vereinfachen (f~Λ€∫¹)(×:¹). Der zweite Teil ×:¹wird " Sdurch Voranstellen gemischt", und sein Ergebnis wird an den ersten Teil übergeben. Der erste Teil f~Λ€∫¹funktioniert so. Die Funktion ffiltert eine Liste nach einer Bedingung, die in diesem Fall lautet ~Λ€∫¹. Es erhält eine Liste von Listen L, so haben wir ~Λ€∫¹L. Der Kombinator ~verhält sich wie ~αβγδε -> α(βδ)(γε)folgt: Das erste Argument wird an übergeben β, das zweite an γ, und die Ergebnisse werden mit kombiniert α. Das heißt, wir haben Λ(€¹)(∫L). Der letzte Teil ∫List nur die kumulative Summe von L,€¹ist eine Funktion, die die Mitgliedschaft eincheckt S,ΛNimmt eine Bedingung (hier €¹) und eine Liste (hier ∫L) und prüft, ob alle Elemente diese erfüllen. Einfach ausgedrückt, filtern wir die Ergebnisse der Mischung danach, ob ihre kumulativen Summen alle in sind S.

Ruby , 135 Bytes

->a,n{r=w=1;r+=1until w=(s=a[0,r]).product(*[s]*~-n).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

Probieren Sie es online!

Verwenden Sie eine Breitensuche. n = 10 funktioniert mit TIO, n = 15 dauert länger als eine Minute, funktioniert aber auf meinem Computer.

Rubin , 147 Bytes

->a,n{r=w=1;r+=1until w=([a[-1]-a[-2]]).product(*[s=a[0,r]]*~-n).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

Probieren Sie es online!

Optimierte Version, arbeitet mit TIO für n = 15 (~ 20 Sek.)

Tatsächlich ist dies der Beginn eines Non-Brute-Force-Ansatzes. Ich hoffe, jemand wird daran arbeiten und eine vollständige Lösung finden.

Erste Ideen:

• Die Summe des Ausgabearrays ist das letzte Element (maximal) des Eingabearrays.
• Die Summe des Ausgabearrays abzüglich des ersten (oder letzten) Elements ist das vorletzte Element des Eingabearrays.
• Wenn ein Array eine Lösung ist, ist auch das umgekehrte Array eine Lösung. Wir können also annehmen, dass das erste Element die Differenz zwischen den letzten beiden Elementen des Eingabearrays ist.
• Das zweite Element kann die Differenz zwischen dem zweiten und dritten oder dem zweitletzten und viertletzten Element des Eingabearrays sein.

Was uns zur nächsten Optimierung bringt:

Ruby , 175 Bytes

->a,n{r=w=1;r+=1until w=([a[-1]-a[-2]]).product([a[-2]-a[-3],a[-2]-a[-4]],*[s=a[0,r]]*(n-2)).find{|x|x.sum==a.max&&a==[]|(1..n).flat_map{|r|x.each_cons(r).map(&:sum)}.sort};w}

Probieren Sie es online!

~ 8,5 Sekunden bei TIO. Nicht schlecht...

... und so weiter (umzusetzen)

Haskell, 117 111 Bytes

6 Bytes gespart dank @nimi!

f r i n s|n<1=[r|r==[]]|1<2=[y:z|y<-s,t<-[y:map(y+)i],all(`elem`s)t,z<-f[a|a<-r,all(a/=)t]t(n-1)s]
n&s=f s[]n s

Probieren Sie es online!

fr$S$ins

Wenn nNull (Golf bis n<1) ist, muss die Liste fertig sein, also prüfen wir, ob alle Werte gesehen wurden. Wenn nicht, geben wir eine leere Liste zurück, um anzugeben, dass keine Lösungen vorliegen. Anderenfalls geben wir eine Singleton-Liste zurück, die eine leere Liste enthält, der die ausgewählten Elemente vorangestellt werden. Dieser Fall hätte auch mit den zusätzlichen Gleichungen behandelt werden können

f [] _ 0 _=[[]]
f _ _ 0 _=[]

Wenn nnicht Null ist, kehren wir zurück

[y:z|y<-s,t<-[y:map(y+)i],all(`elem`s)t,z<-f[a|a<-r,all(a/=)t]t(n-1)s]
 ^1^ ^2^^ ^......3......^ ^.....4.....^ ^.............5.............^

Dies ist die Liste von (1) Listen, aus denen das erste Element (2) sund der Rest (5) aus dem rekursiven Aufruf stammt, unter der Bedingung (4), dass alle neuen Summen vorhanden sind s. Die neuen Summen werden in (3) berechnet - Notiz, tdie aus einer Singleton-Liste gezogen wird, ein hässlicher Golf-Hack für das, was in Haskell idiomatisch wäre let t=y:map(y+)i. Der rekursive Aufruf (5) erhält als neuer rSatz den alten ohne die Elemente, die in den neuen Summen erscheinen t.

Die Hauptfunktion &ruft die Hilfsfunktion auf und sagt, dass wir noch alle Werte sehen müssen ( r=s) und dass es noch keine Summen gibt ( i=[]).

Für sieben weitere Bytes können wir die Berechnung einschränken, um nur das erste Ergebnis (falls vorhanden) zu erhalten, das viel schneller ist und alle Testfälle in weniger als 2 Sekunden verarbeitet.

Probieren Sie es online! (Dies ist die erste Ergebnisvariante der alten Version)

Sauber , 177 Bytes

import StdEnv,Data.List
$s n=find(\a=sort(nub[sum t\\i<-inits a,t<-tails i|t>[]])==s)(?{#u\\u<-s|u<=(last s)-n}(last s)n)
?e s n|n>1=[[h:t]\\h<-:e|h<=s-n,t<- ?e(s-h)(n-1)]=[[s]]

Probieren Sie es online!

Dauert auf meinem Computer für den n=15Testfall ungefähr 40 Sekunden , bei TIO tritt jedoch eine Zeitüberschreitung auf.

Sauber , 297 Bytes

import StdEnv,Data.List
$s n=find(\a=sort(nub[sum t\\i<-inits a,t<-tails i|t>[]])==s)(~[u\\u<-s|u<=(last s)-n](last s)n(reverse s))
~e s n a|n>4=let u=a!!0-a!!1 in[[u,h:t]\\h<-[a!!1-a!!2,a!!1-a!!3],t<- ?e(s-u-h)(n-2)]= ?e s n
?e s n|n>1=[[h:t]\\h<-e,t<- ?(takeWhile((>=)(s-n-h))e)(s-h)(n-1)]=[[s]]

Probieren Sie es online!

Diese enthält einige Optimierungen, die von GB vorgenommen wurden , sowie einige meiner eigenen. Ich denke, einige von ihnen können allgemeiner gestaltet werden, daher füge ich eine Erklärung hinzu, sobald dies erledigt ist.

Auf meinem Computer dauert es ungefähr 10 Sekunden, auf TIO 40 Sekunden.

Python 3 , 177 Bytes

from itertools import*
s,n=eval(input())
for[*t]in combinations(s[:-2],n-2):
  a=[*map(int.__sub__,t+s[-2:],[0,*t,s[-2]])];
  {sum(a[p//n:p%n+1])for p in range(n*n)}^{0,*s}or-print(a)

Probieren Sie es online!

(einige Zeilenumbrüche / Leerzeichen hinzugefügt, um zu vermeiden, dass Leser den Code scrollen müssen)

Ein direkter Port meiner Jelly-Antwort (mit einigen Änderungen, siehe Abschnitt "Anmerkung" unten)

Ergebnis des lokalen Laufs:

[user202729@archlinux golf]$ printf '%s' "from itertools import*
s,n=eval(input())
for[*t]in combinations(s[:-2],n-2):a=[*map(int.__sub__,t+s[-2:],[0,*t,s[-2]])];{sum(a[p//n:p%n+1])for p in range(n*n)}^{0,*s}or-print(a)" > a.py
[user202729@archlinux golf]$ wc -c a.py
177 a.py
[user202729@archlinux golf]$ time python a.py<<<'([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25], 10)' 2>/dev/null
[1, 4, 1, 1, 1, 1, 1, 7, 7, 1]

real    0m3.125s
user    0m3.119s
sys     0m0.004s
[user202729@archlinux golf]$ time python a.py<<<'([1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31], 15)' 2>/dev/null
[3, 1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1]

real    11m36.093s
user    11m33.941s
sys     0m0.387s
[user202729@archlinux golf]$ 

Ich habe gehört, dass itertoolsdas ausführlich ist, aber meine beste combinationsImplementierung ist noch ausführlicher:

c=lambda s,n,p:s and c(s[1:],n-1,p+s[:1])+c(s[1:],n,p)or[]if n else[p]

Hinweis .

• Die Verwendung von division / modulo in a[p//n:p%n+1]dauert etwa 2x länger, spart jedoch einige Bytes.
• Dies unterscheidet sich ein wenig von der Gelee-Antwort - die Gelee-Antwort wird rückwärts wiederholt.
• Dank der combinationsRückgabe eines Iterators ist dies speicherfreundlicher.

Gelee , 35 Bytes

Ẇ§QṢ⁼³
;³ṫ-¤0;I
ṖṖœcƓ_2¤¹Ṫ©ÇѬƲ¿ṛ®Ç

Probieren Sie es online!

Lokal ausführen: (n = 15 benötigt mehr als 1 GB RAM)

aaa@DESKTOP-F0NL48D MINGW64 ~/jellylanguage (master)
$ time python scripts/jelly fu z '[1,2,3,4,5,6,7,8,9,10,11,12,14,15,16,17,18,19,20,23,24,25]'<<<10
[8, 6, 2, 1, 1, 1, 1, 3, 1, 1]
real    0m1.177s
user    0m0.000s
sys     0m0.015s

aaa@DESKTOP-F0NL48D MINGW64 ~/jellylanguage (master)
$ time python scripts/jelly fu z '[1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 2
6, 27, 28, 30, 31]'<<<15
[3, 1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1]
real    12m24.488s
user    0m0.000s
sys     0m0.015s

(Eigentlich habe ich die UTF8-codierte Version ausgeführt, die mehr als 35 Bytes benötigt, aber das Ergebnis ist trotzdem dasselbe.)

Diese Lösung verwendet Kurzschluss, um die Laufzeit zu reduzieren.

Ohne Kurzschluss dauert dieser Code ungefähr $\binom {|S|-2}{n-2} \times \left( \frac {n^3}6 + n^2\log{n^2} \right)$ Operationen, die ausgewertet werden $\binom {26-2}{15-2} \times \left( \frac {15^3}6 + 15^2\log{15^2} \right) \approx 5.79 \times 10^9$Aufgrund der Ineffizienz von Python und Jelly dauert es jedoch ewig, bis der Vorgang abgeschlossen ist. Dank des Kurzschlusses kann es viel früher beendet werden.

Erläuterung

Wir stellen fest, dass die Summe aller nicht leeren Präfixe in der Eingabe vorhanden ist und sich strikt erhöht. Wir können auch annehmen, dass das größte und zweitgrößte Element eine Präfixsumme ist.

Daher können wir alle Möglichkeiten zur Auswahl in Betracht ziehen $n-2$ verschiedene Elemente von zuerst $|S|-2$ Elemente (es gibt $\binom {|S|-2}{n-2}$solche Listen), berechnen die aufeinanderfolgenden Unterschiede, um die Elemente wiederzugewinnen; dann überprüfe, ob es naiv gültig ist (hol alles)$n^2$Subarrays, berechnen die Summe, eindeutig. Die Gesamtlänge der Subarrays beträgt ungefähr$n^3 \over 6$)

Ungetestet (sollte aber die gleiche Leistung haben)

Jelly , 32 Bytes

Ṫ©ÑẆ§QṢ⁻³
;³ṫ-¤ŻI
ṖṖœcƓ_2¤¹Ñ¿ṛ®Ç

Probieren Sie es online!

Ineffizientere Version (ohne Kurzschluss):

Gelee , 27 Bytes

Ẇ§QṢ⁼³
ṖṖœcƓ_2¤µ;³ṫ-¤0;I)ÑƇ

Probieren Sie es online!

Für den n = 15-Test werden bis zu 2 GB RAM benötigt und nicht nach ~ 37 Minuten beendet.

hinweis : Ẇ§kann durch ersetzt werden ÄÐƤẎ. Es kann effizienter sein.

APL (NARS), Zeichen 758, Bytes 1516

r←H w;i;k;a;m;j
   r←⊂,w⋄→0×⍳1≥k←↑⍴w⋄a←⍳k⋄j←i←1⋄r←⍬⋄→C
A: m←i⊃w⋄→B×⍳(i≠1)∧j=m⋄r←r,m,¨∇w[a∼i]⋄j←m
B: i+←1
C: →A×⍳i≤k

G←{H⍵[⍋⍵]}

r←a d w;i;j;k;b;c
   k←↑⍴w ⋄b←⍬⋄r←0 ⋄j←¯1
A: i←1⋄j+←1⋄→V×⍳(i+j)>k
B: →A×⍳(i+j)>k⋄c←+/w[i..(i+j)]⋄→0×⍳∼c∊a⋄→C×⍳c∊b⋄b←b,c
C: i+←1⋄→B
V: →0×⍳∼a⊆b
   r←1

r←a F w;k;j;b;m;i;q;x;y;c;ii;kk;v;l;l1;i1;v1
   w←w[⍋w]⋄r←a⍴w[1]⋄l←↑⍴w⋄k←w[l]⋄m←8⌊a-2⋄b←¯1+(11 1‼m)⋄j←2⋄i←1⋄x←↑⍴b⋄i1←0⋄v1←⍬
I: i1+←1⋄l1←w[l]-w[l-i1]⋄v1←v1,w[1+l-i1]-w[l-i1]⋄→I×⍳(l1=i1)∧l>i1⋄→B
E: r←,¯1⋄→0
F: i←1⋄q←((1+(a-2)-m)⍴0),(m⍴1),0⋄r+←q
A:   i+←1⋄j+←1⋄→E×⍳j>4000
B:   →F×⍳i>x⋄q←((1+(a-2)-m)⍴0),b[i;],0⋄q+←r⋄v←q[1..(a-1)]⋄→A×⍳0>k-y←+/v
   q[a]←k-y⋄→A×⍳l1<q[a]⋄→A×⍳∼q⊆w⋄→A×⍳∼l1∊q⋄→A×⍳∼v1⊆⍦q⋄c←G q∼⍦v1⋄ii←1⋄kk←↑⍴c⋄→D
C:   →Z×⍳w d v1,ii⊃c⋄ii+←1
D:   →C×⍳ii≤kk
   →A
Z: r←v1,ii⊃c

Die Funktion G in G x (mit Hilfe der H-Funktion) würde alle Permutationen von x finden. Die Funktion d in xdy ermittelt, ob das Array y nach dem Array exercise x einen booleschen Wert zurückgibt. Die Funktion F in x F y würde das Array r der Länge x zurückgeben, so dass ydr wahr ist (= 1) Ein wenig lang wie die Implementierung, aber es ist dieser, der alle Fälle im Test kürzer berechnet ... Der letzte Fall für n = 15 dauert es nur 20 sekunden ... ich muss sagen, dass nicht viele lösungen gefunden werden, es wird nur eine lösung (endlich scheint es so) in kürzerer zeit zurückgegeben (nicht erkundeter test für verschiedene eingaben ...) 16 + 39 + 42 + 8 + 11 + 11 + 18 + 24 + 24 + 54 + 11 + 12 + 7 + 45 + 79 + 69 + 12 + 38 + 26 + 72 + 79 + 27 + 15 + 6 + 13 (758)

  6 F (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)
5 3 2 2 5 5 
  6 F (2, 4, 6, 8, 10, 12, 16)
4 2 2 2 2 4 
  6 F (1, 2, 3, 4, 6, 7, 8, 10, 14)
4 2 1 1 2 4 
  10 F (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)
1 1 3 1 2 3 5 1 3 5 
  15 F (1, 2, 3, 4, 6, 7, 8, 9, 10, 11, 13, 14, 15, 16, 17, 18, 20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 31)
1 2 1 3 3 1 3 3 1 3 3 1 2 1 3 
  ww←(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 15, 16, 17, 18, 19, 20, 23, 24, 25)
  ww≡dx 1 1 3 1 2 3 5 1 3 5 
1