Hãy xem xét một mảng Achiều dài n. Mảng chỉ chứa số nguyên dương. Ví dụ A = (1,1,2,2). Hãy để chúng tôi định nghĩa f(A)là tập hợp của tất cả các phân đoạn tiếp giáp không trống của A. Trong trường hợp này f(A) = {1,2,3,4,5,6}. Các bước để sản xuất f(A) như sau:

Các subarrays của Alà (1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2). Số tiền tương ứng của họ là 1,1,2,2,2,3,4,4,5,6. Do đó, bộ bạn nhận được từ danh sách này là do {1,2,3,4,5,6}.

Bài tập

Đưa ra một tập hợp Sđược đưa ra theo thứ tự được sắp xếp chỉ chứa các số nguyên dương và độ dài mảng n, nhiệm vụ của bạn là xuất ra ít nhất một mảng Xsao cho f(X) = S.

Ví dụ, nếu S = {1,2,3,5,6}và n = 3sau đó một đầu ra hợp lệ là X = (1,2,3).

Nếu không có mảng như vậy, Xmã của bạn sẽ xuất ra bất kỳ giá trị không đổi.

Ví dụ

Đầu vào : n=4, S = (1, 3, 4, 5, 6, 8, 9, 10, 13), đầu ra có thể:X = (3, 5, 1, 4)

Đầu vào : n=6, S = (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22), đầu ra có thể:X = (5, 3, 2, 2, 5, 5)

Đầu vào : n=6, S = (2, 4, 6, 8, 10, 12, 16), đầu ra có thể:X = (4, 2, 2, 2, 2, 4)

Đầu vào : n=6, S = (1, 2, 3, 4, 6, 7, 8, 10, 14), đầu ra có thể:X = (4, 2, 1, 1, 2, 4)

Đầu vào : 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), đầu ra có thể : X = (1, 1, 3, 1, 2, 1, 2, 5, 4, 5).

Đầu vào : 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), đầu ra có thể : X = (1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, 3).

Định dạng đầu vào và đầu ra

Mã của bạn có thể nhận đầu vào và cung cấp đầu ra ở bất kỳ định dạng dễ đọc nào mà bạn thấy thuận tiện. Tuy nhiên, vui lòng hiển thị đầu ra của thử nghiệm trên các ví dụ trong câu hỏi.

Thời gian chạy

Bạn phải có khả năng chạy mã để hoàn thành tất cả các ví dụ trong câu hỏi. Về nguyên tắc, nó phải chính xác cho nđến tối đa 15nhưng bạn không cần phải chứng minh rằng nó sẽ đủ nhanh cho tất cả các đầu vào.

Husk , 20 byte

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

Hãy thử trực tuyến!

Trả về một giải pháp hoặc một danh sách trống nếu nó không tồn tại. Trường hợp thử nghiệm cuối cùng ( n=15) kết thúc sau 3,8 giây trên TIO.

Giải trình

Chương trình có hai phần. Trong phần đầu tiên ( ¡và bên phải của nó), chúng tôi xây dựng một danh sách vô hạn có kphần tử thứ là một danh sách chứa tất cả các kdanh sách dài có tổng các lát cắt nằm trong S. Chúng tôi thực hiện điều này theo cách tự nhiên, bắt đầu từ các lát 1 phần tử Svà ở mỗi bước chuẩn bị từng phần tử Scho mỗi danh sách và giữ cho các phần có tổng tiền tố nằm trong S. Trong phần thứ hai ( !và ở bên trái của nó), chúng tôi lấy nphần tử thứ của danh sách, chứa ncác danh sách dài. Trong số này, chúng tôi chọn cái đầu tiên có tổng số lát thực sự chứa mọi phần tử của S.

Trong mã, trước tiên hãy thay thế ovà ȯ(bao gồm hai và ba hàm thành một) bằng dấu ngoặc đơn cho rõ ràng.

¡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.

Có một số phần cần giải thích thêm. Trong chương trình này, các siêu ký tự ⁰¹đều đề cập đến đối số đầu tiên S. Tuy nhiên, nếu αlà một hàm, thì α¹có nghĩa là "áp dụng αcho S", trong khi ⁰αcó nghĩa là "cắm Svào đối số thứ hai của α". Hàm ¦kiểm tra xem đối số thứ nhất của nó có chứa tất cả các phần tử của phần tử thứ hai không (tính bội số), do đó, Snên là đối số thứ hai của nó.

Trong phần đầu tiên, chức năng ¡sử dụng có thể được hiểu là S(f~Λ€∫)(×:)¹. Bộ kết hợp Shành xử như thế Sαβγ -> (αγ)(βγ), có nghĩa là chúng ta có thể đơn giản hóa nó (f~Λ€∫¹)(×:¹). Phần thứ hai ×:¹, là "trộn với Sbằng cách trả trước", và kết quả của nó được chuyển sang phần đầu tiên. Phần đầu tiên f~Λ€∫¹, hoạt động như thế này. Hàm flọc một danh sách theo một điều kiện, trong trường hợp này là ~Λ€∫¹. Nó nhận được một danh sách các danh sách L, vì vậy chúng tôi có ~Λ€∫¹L. Bộ kết hợp ~hoạt động như ~αβγδε -> α(βδ)(γε): đối số thứ nhất được truyền cho β, đối số thứ hai γvà kết quả được kết hợp với α. Điều này có nghĩa là chúng ta có Λ(€¹)(∫L). Phần cuối cùng ∫Lchỉ là tổng số tích lũy của L,€¹là một chức năng kiểm tra tư cách thành viên Svà Λlấy một điều kiện (ở đây €¹) và một danh sách (ở đây ∫L) và kiểm tra xem tất cả các yếu tố có thỏa mãn nó không. Nói một cách đơn giản, chúng tôi lọc kết quả của sự pha trộn bằng cách tổng các khoản tiền tích lũy của họ có trong tất cả không S.

Ruby , 135 byte

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

Hãy thử trực tuyến!

Sử dụng tìm kiếm đầu tiên. n = 10 hoạt động trên TIO, n = 15 mất nhiều thời gian hơn một phút, nhưng hoạt động trên máy của tôi.

Ruby , 147 byte

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

Hãy thử trực tuyến!

Phiên bản được tối ưu hóa, hoạt động trên TIO trong n = 15 (~ 20 giây)

Trên thực tế, đây là sự khởi đầu của một cách tiếp cận phi vũ phu. Tôi hy vọng ai đó sẽ làm việc trên nó và tìm ra một giải pháp hoàn chỉnh.

Ý tưởng đầu tiên:

• Tổng của mảng đầu ra là phần tử cuối cùng (tối đa) của mảng đầu vào.
• Tổng của mảng đầu ra trừ phần tử đầu tiên (hoặc cuối cùng), là phần tử cuối cùng thứ hai của mảng đầu vào.
• Nếu một mảng là một giải pháp, thì mảng ngược lại cũng là một giải pháp, vì vậy chúng ta có thể giả sử phần tử đầu tiên là sự khác biệt giữa 2 phần tử cuối cùng của mảng đầu vào.
• Phần tử thứ hai có thể là sự khác biệt giữa phần tử thứ hai và thứ ba hoặc thứ hai và thứ tư cuối cùng của mảng đầu vào.

Điều này đưa chúng ta đến sự tối ưu hóa tiếp theo:

Ruby , 175 byte

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

Hãy thử trực tuyến!

~ 8,5 giây trên TIO. Không tệ...

... và cứ thế (sẽ được thực hiện)

Haskell, 117 111 byte

6 byte được lưu nhờ @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

Hãy thử trực tuyến!

fr$S$ins

Khi nào nsố 0 (được đánh gôn n<1), danh sách phải sẵn sàng, vì vậy chúng tôi kiểm tra xem tất cả các giá trị đã được nhìn thấy chưa. Nếu không, chúng tôi trả về một danh sách trống để cho biết không có giải pháp nào khác, chúng tôi sẽ trả về một danh sách đơn có chứa một danh sách trống, trong đó các phần tử được chọn sẽ được thêm vào. Trường hợp này cũng có thể đã được xử lý với các phương trình bổ sung

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

Nếu nkhông bằng không, chúng tôi trở lại

[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.............^

Đây là danh sách (1) danh sách có yếu tố đầu tiên (2) đến svà phần còn lại (5) đến từ cuộc gọi đệ quy, với điều kiện (4) có tất cả các khoản tiền mới s. Các khoản tiền mới được tính trong (3) - lưu ý tđược rút ra từ một danh sách đơn, một vụ đánh golf xấu xí cho những gì trong Haskell thành ngữ sẽ là let t=y:map(y+)i. Cuộc gọi đệ quy (5) được gọi là cuộc gọi mới rmà không có các yếu tố xuất hiện giữa các khoản tiền mới t.

Hàm chính &gọi hàm helper nói rằng chúng ta vẫn phải xem tất cả các giá trị ( r=s) và chưa có tổng nào ( i=[]).

Đối với bảy byte nữa, chúng ta có thể hạn chế tính toán chỉ đưa ra kết quả đầu tiên (nếu có), nhanh hơn nhiều và xử lý tất cả các trường hợp thử nghiệm trong vòng chưa đầy 2 giây.

Hãy thử trực tuyến! (đây là kết quả đầu tiên chỉ biến thể của phiên bản cũ)

Sạch , 177 byte

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

Hãy thử trực tuyến!

Mất khoảng 40 giây trên máy của tôi cho n=15trường hợp thử nghiệm, nhưng nó hết thời gian trên TIO.

Sạch sẽ , 297 byte

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

Hãy thử trực tuyến!

Điều này bao gồm một số tối ưu hóa được thực hiện bởi GB cũng như một số của riêng tôi. Tôi nghĩ rằng một vài trong số chúng có thể được tạo ra chung chung hơn, vì vậy tôi sẽ thêm một lời giải thích sau khi đã xong.

Mất khoảng 10 giây trên máy của tôi, 40 giây trên TIO.

Python 3 , 177 byte

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)

Hãy thử trực tuyến!

(một số dòng mới / dấu cách được thêm vào để tránh người đọc phải cuộn mã)

Cổng trực tiếp câu trả lời Jelly của tôi (với một số sửa đổi, xem phần "ghi chú" bên dưới)

Kết quả chạy cục bộ:

[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]$ 

Tôi nghe nói đó itertoolslà dài dòng, nhưng cách combinationsthực hiện tốt nhất của tôi thậm chí còn dài dòng hơn:

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]

Lưu ý .

• Sử dụng phép chia / modulo a[p//n:p%n+1]mất nhiều thời gian hơn khoảng 2 lần, nhưng tiết kiệm được một số byte.
• Điều này hơi khác so với câu trả lời Jelly - câu trả lời Jelly lặp đi lặp lại.
• Nhờ combinationstrả lại một iterator, điều này thân thiện với bộ nhớ hơn.

Thạch , 35 byte

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

Hãy thử trực tuyến!

Chạy cục bộ: (n = 15 mất hơn 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

(thực ra tôi đã chạy phiên bản được mã hóa UTF8, mất hơn 35 byte, nhưng kết quả vẫn như vậy)

Giải pháp này sử dụng ngắn mạch để giảm thời gian chạy.

$\binom {|S|-2}{n-2} \times \left( \frac {n^3}6 + n^2\log{n^2} \right)$$\binom {26-2}{15-2} \times \left( \frac {15^3}6 + 15^2\log{15^2} \right) \approx 5.79 \times 10^9$

Giải trình

Chúng tôi lưu ý rằng tổng của tất cả các tiền tố không trống có mặt trong đầu vào và chúng đang tăng nghiêm ngặt. Chúng ta cũng có thể giả sử rằng phần tử lớn nhất và lớn thứ hai là tổng tiền tố.

$n-2$$|S|-2$$\binom {|S|-2}{n-2}$$n^2$$n^3 \over 6$

Chưa được kiểm tra (nhưng phải có hiệu suất giống hệt nhau)

Thạch , 32 byte

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

Hãy thử trực tuyến!

Phiên bản kém hiệu quả hơn (không có ngắn mạch):

Thạch , 27 byte

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

Hãy thử trực tuyến!

Đối với thử nghiệm n = 15, phải mất tới 2GB RAM và không chấm dứt sau ~ 37 phút.

lưu ý : Ẇ§có thể được thay thế bằng ÄÐƤẎ. Nó có thể hiệu quả hơn.

APL (NARS), ký tự 758, byte 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

Hàm G trong G x (với sự trợ giúp của hàm H) sẽ tìm thấy tất cả các hoán vị của x. Hàm d trong xdy find nếu mảng y tạo sau mảng bài tập x trả về giá trị Boolean. Hàm F trong x F y sẽ trả về mảng r có độ dài x, sao cho ydr là đúng (= 1) Một chút thời gian thực hiện, nhưng đây là hàm tính toán tất cả các trường hợp trong thời gian thử nghiệm ít hơn ... Trường hợp cuối cùng với n = 15, nó chỉ chạy 20 giây ... tôi phải nói rằng không tìm thấy nhiều giải pháp, chỉ trả lại một giải pháp (cuối cùng có vẻ như vậy) trong thời gian ngắn hơn (không khám phá thử nghiệm cho các đầu vào khác nhau ...) 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