Alength 배열 을 고려하십시오 n. 배열은 양의 정수만 포함합니다. 예를 들면 A = (1,1,2,2). f(A)비어 있지 않은 연속 된 모든 하위 배열의 합 집합을 정의합시다 A. 이 경우 f(A) = {1,2,3,4,5,6}. 생산 단계 f(A) 는 다음과 같습니다.

의 하위 배열은 A입니다 (1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2). 각각의 합계는 1,1,2,2,2,3,4,4,5,6입니다. 따라서이 목록에서 얻는 세트는 {1,2,3,4,5,6}입니다.

직무

S양의 정수와 배열 길이 만 포함하는 정렬 된 순서로 주어진 일련의 합계가 주어지면 n작업은 최소한 하나 이상의 배열을 출력 X하는 것 f(X) = S입니다.

예를 들어 if S = {1,2,3,5,6}및 n = 3유효한 출력은 X = (1,2,3)입니다.

그러한 배열이 없으면 X코드는 상수 값을 출력해야합니다.

예

입력 : n=4, S = (1, 3, 4, 5, 6, 8, 9, 10, 13)가능한 출력 :X = (3, 5, 1, 4)

입력 : n=6, S = (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)가능한 출력 :X = (5, 3, 2, 2, 5, 5)

입력 : n=6, S = (2, 4, 6, 8, 10, 12, 16)가능한 출력 :X = (4, 2, 2, 2, 2, 4)

입력 : n=6, S = (1, 2, 3, 4, 6, 7, 8, 10, 14)가능한 출력 :X = (4, 2, 1, 1, 2, 4)

입력 : 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), 가능한 출력 : X = (1, 1, 3, 1, 2, 1, 2, 5, 4, 5).

입력 : 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), 가능한 출력 : X = (1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, 3).

입력 및 출력 형식

코드는 사용자가 편리하다고 생각하는 사람이 쉽게 읽을 수있는 형식으로 입력하고 출력 할 수 있습니다. 그러나 문제의 예에서 테스트 결과를 보여주십시오.

시간을 실행

질문의 모든 예제에 대해 코드를 실행하여 완료 할 수 있어야합니다. 이 원칙에 대한 정확해야 n최대 15하지만 당신은 모든 입력에 대해 충분히 빨리 될 것이다 입증 할 필요가 없습니다.

껍질 , 20 바이트

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

온라인으로 사용해보십시오!

하나의 솔루션을 반환하거나 존재하지 않는 경우 빈 목록을 반환합니다. 마지막 테스트 사례 ( n=15)는 TIO에서 3.8 초 안에 완료됩니다.

설명

이 프로그램에는 두 부분이 있습니다. 첫 번째 부분 ( ¡및 오른쪽)에서 슬라이스 k요소가에있는 모든 길이리스트를 포함하는리스트 인 무한리스트를 구성합니다 . 우리는 1 요소 조각부터 시작 하여 각 단계 앞에 각 요소를 추가 하고 접두사 합계가에있는 요소를 유지하면서 이를 유도 적으로 수행합니다 . 두 번째 부분 ( 및 왼쪽)에서 길이 목록 을 포함하는 목록 의 th 요소를 가져옵니다 . 이 중 슬라이스 합계에 실제로의 모든 요소가 포함 된 첫 번째 것을 선택합니다 .kSSSS!nnS

코드에서 명확성을 위해 괄호로 먼저 (2와 3 함수를 하나로 구성) 대체 o하고 봅시다 ȯ.

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

더 많은 설명이 필요한 부분이 있습니다. 이 프로그램에서 위첨자 ⁰¹모두 첫 번째 인수를 나타 S냅니다. 그러나, α함수는 다음 α¹"적용 수단 α에 S있지만," ⁰α"플러그 S번째 인수 α". 이 함수 ¦는 첫 번째 인수에 두 번째의 모든 요소가 포함되어 있는지 확인합니다 (다수 계산) S.

첫 번째 부분에서 사용하는 함수 ¡는로 해석 될 수 있습니다 S(f~Λ€∫)(×:)¹. 콤비 S네이터는 다음과 같이 동작 Sαβγ -> (αγ)(βγ)하므로 단순화 할 수 (f~Λ€∫¹)(×:¹)있습니다. 두 번째 부분 ×:¹은 " S앞에 추가 하여 혼합 "이며 결과는 첫 번째 부분으로 전달됩니다. 첫 번째 부분 f~Λ€∫¹은 다음과 같이 작동합니다. 이 함수 f는 조건에 따라 목록을 필터링합니다 (이 경우에는) ~Λ€∫¹. 그것은리스트의리스트를 받는다 . L그래서 우리는 가지고있다 ~Λ€∫¹L. 콤비 ~행동한다에는 동일한 ~αβγδε -> α(βδ)(γε): 첫번째 인수에 전달 β하는 두 번째 γ, 그 결과와 결합된다 α. 이것은 우리가 가지고 있음을 의미합니다 Λ(€¹)(∫L). 마지막 부분 ∫L은 누적 합계입니다 L.€¹그 기능의 확인의 구성원 S, 및 Λ조건 (여기서 소요 €¹) 및리스트 (여기에서 ∫L모든 요소를 만족시키는)를 체크한다. 간단히 말해서, 누적 합이 모두에 속하는지 여부에 따라 혼합 결과를 필터링합니다 S.

루비 , 135 바이트

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

온라인으로 사용해보십시오!

너비 우선 검색을 사용하십시오. n = 10은 TIO에서 작동하고 n = 15는 1 분 이상 걸리지 만 내 컴퓨터에서는 작동합니다.

루비 , 147 바이트

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

온라인으로 사용해보십시오!

최적화 된 버전, n = 15 (~ 20 초) 동안 TIO에서 작동

실제로, 이것은 무브 러트 강제 접근법의 시작입니다. 누군가가 그 일을하고 완전한 해결책을 찾을 수 있기를 바랍니다.

첫 번째 아이디어 :

• 출력 배열의 합은 입력 배열의 마지막 요소 (최대)입니다.
• 출력 배열에서 첫 번째 (또는 마지막) 요소를 뺀 합계는 입력 배열의 두 번째 마지막 요소입니다.
• 배열이 솔루션이면 리버스 배열도 솔루션이므로 첫 번째 요소가 입력 배열의 마지막 두 요소의 차이라고 가정 할 수 있습니다.
• 두 번째 요소는 입력 배열의 두 번째와 세 번째 또는 두 번째와 네 번째 마지막 요소의 차이 일 수 있습니다.

다음 최적화로 우리를 가져옵니다.

루비 , 175 바이트

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

온라인으로 사용해보십시오!

TIO에서 ~ 8.5 초 나쁘지 않다...

... 등 (구현 될)

하스켈, 117111 바이트

@nimi 덕분에 6 바이트가 절약되었습니다!

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

온라인으로 사용해보십시오!

fr$S$ins

n이 0 일 때 (로 골프 n<1) 목록이 준비되어야하므로 모든 값이 표시되었는지 확인합니다. 그렇지 않은 경우 빈 목록을 반환하여 솔루션이 없음을 나타내며, 그렇지 않으면 빈 목록이 포함 된 단일 목록을 반환합니다.이 목록에는 선택한 요소가 앞에 추가됩니다. 이 경우는 추가 방정식으로도 처리 될 수 있습니다

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

n0이 아닌 경우 반환

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

이것은 s모든 새로운 합이에 속하는 조건 (4) 에서 첫 번째 요소 (2) 가오 고 나머지 (5)가 재귀 호출에서 나오는 (1) 목록의 목록 입니다 s. 새로운 합은 (3)으로 계산됩니다. t이는 단조로운 목록에서 도출 된 것으로, 관용적 Haskell의 기능에 대한 추악한 골프 핵입니다 let t=y:map(y+)i. 재귀 호출 (5)은 r새로운 합계로 나타나는 요소가없는 이전 세트 를 새로 설정합니다 t.

메인 함수 &는 헬퍼 함수를 호출하여 여전히 모든 값을보아야하고 ( r=s) 아직 합계가 없다고 말합니다 (i=[] 냅니다 ).

7 바이트가 더 있으면 계산이 첫 번째 결과 (있는 경우) 만 제공하도록 제한 할 수 있습니다.이 결과는 훨씬 빠르며 2 초 이내에 모든 테스트 사례를 처리합니다.

온라인으로 사용해보십시오! (이것은 이전 버전의 첫 번째 결과 변형입니다)

클린 , 177 바이트

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

온라인으로 사용해보십시오!

n=15테스트 케이스에 대해 내 컴퓨터에서 약 40 초가 걸리지 만 TIO에서는 시간이 초과됩니다.

클린 , 297 바이트

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

온라인으로 사용해보십시오!

여기에는 GB 에서 만든 일부 최적화 와 내 자체의 최적화가 포함됩니다 . 나는 그들 중 몇 가지가 더 일반적으로 만들어 질 수 있다고 생각합니다.

내 컴퓨터에서는 약 10 초, TIO에서는 40 초가 걸립니다.

파이썬 3 , 177 바이트

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)

온라인으로 사용해보십시오!

(리더가 코드를 스크롤하지 않도록 일부 줄 바꿈 / 공백 추가)

Jelly 답변의 직접 포트 (일부 수정 한 경우 아래 "참고"섹션 참조)

로컬 런 결과 :

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

나는 그것이 itertools장황 하다고 들었지만 , 최선의 combinations구현은 훨씬 장황합니다.

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]

참고 .

• 나누기 / 모듈로를 사용하면 a[p//n:p%n+1]약 2 배 더 오래 걸리지 만 일부 바이트는 절약됩니다.
• 이것은 젤리 답변과 약간 다릅니다. 젤리 답변은 거꾸로 반복됩니다.
• combinations이터레이터 를 반환함으로써 메모리 친화적입니다.

젤리 , 35 바이트

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

온라인으로 사용해보십시오!

로컬로 실행 : (n = 15는 1GB 이상의 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

(실제로 나는 UTF8로 인코딩 된 버전을 실행했는데 35 바이트 이상이 걸리지 만 결과는 같습니다.)

이 솔루션은 단락을 사용하여 런타임을 줄입니다.

단락없이이 코드는 대략 $\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$그러나 Python과 Jelly의 비 효율성으로 인해 완료하는 데 시간이 오래 걸립니다. 단락으로 인해 훨씬 ​​빨리 완료 될 수 있습니다.

설명

비어 있지 않은 모든 접두사의 합계가 입력에 존재하며 엄격하게 증가하고 있습니다. 또한 가장 큰 요소와 두 번째로 큰 요소가 접두사 합계라고 가정 할 수 있습니다.

따라서 우리는 모든 선택 방법을 고려할 수 있습니다 $n-2$ 처음과 구별되는 요소 $|S|-2$ 요소 (있다 $\binom {|S|-2}{n-2}$이러한 목록), 연속적인 차이를 계산하여 요소를 복구합니다. 그런 다음 순진하게 유효한지 확인하십시오 (모두 가져 오기)$n^2$부분 배열, 합을 계산하여 균일화합니다. 하위 배열의 총 길이는 약$n^3 \over 6$)

테스트되지 않음 (그러나 동일한 성능을 가져야 함)

젤리 , 32 바이트

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

온라인으로 사용해보십시오!

더 비효율적 인 버전 (단락없이) :

젤리 , 27 바이트

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

온라인으로 사용해보십시오!

n = 15 테스트의 경우 최대 2GB RAM이 사용되며 ~ 37 분 후에 종료되지 않습니다.

참고 : Ẇ§로 대체 될 수 있습니다 ÄÐƤẎ. 더 효율적일 수 있습니다.

APL (NARS), 문자 758, 바이트 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

G x의 함수 G (H 함수의 도움으로)는 x의 모든 순열을 찾습니다. xdy의 함수 d는 y 배열이 운동 배열 x를 따라 생성되어 부울 값을 반환하는지 찾습니다. x F y의 함수 F는 길이가 x 인 배열 r을 반환하여 ydr이 true가되도록합니다 (= 1) 구현 기간이 조금 길지만 테스트에서 모든 경우를 더 적게 계산하는 것은이 경우입니다 ... 마지막 경우 n = 15의 경우 20 초만 실행됩니다 ...이 방법은 많은 솔루션을 찾지 못하고 짧은 시간에 하나의 솔루션 만 반환합니다 (다른 입력에 대한 테스트를 탐색하지 않음 ...) 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