Bir Auzunluk dizisi düşünün n. Dizi yalnızca pozitif tamsayılar içerir. Örneğin A = (1,1,2,2). f(A)Boş olmayan bitişik alt dizilerin toplamları kümesi olarak tanımlayalım A. Bu durumda f(A) = {1,2,3,4,5,6}. Üretilecek adımlar f(A) aşağıdaki gibidir:

Alt dizileri Avardır (1), (1), (2), (2), (1,1), (1,2), (2,2), (1,1,2), (1,2,2), (1,1,2,2). Onların toplamları 1,1,2,2,2,3,4,4,5,6. Bu nedenle bu listeden aldığınız set {1,2,3,4,5,6}.

Görev

SYalnızca pozitif tamsayılar ve bir dizi uzunluğu içeren sıralı bir şekilde verilen toplamlar kümesi göz önüne alındığında n, göreviniz en az bir dizi çıkışı Xolacak şekilde f(X) = S.

Örneğin, geçerli bir çıktı ise S = {1,2,3,5,6}ve n = 3sonra X = (1,2,3).

Böyle bir dizi Xyoksa, kodunuz sabit bir değer vermelidir.

Örnekler

Giriş: n=4, S = (1, 3, 4, 5, 6, 8, 9, 10, 13)olası çıkış:X = (3, 5, 1, 4)

Giriş: n=6, S = (2, 3, 4, 5, 7, 8, 9, 10, 12, 14, 17, 22)olası çıkış:X = (5, 3, 2, 2, 5, 5)

Giriş: n=6, S = (2, 4, 6, 8, 10, 12, 16)olası çıkış:X = (4, 2, 2, 2, 2, 4)

Giriş: n=6, S = (1, 2, 3, 4, 6, 7, 8, 10, 14)olası çıkış:X = (4, 2, 1, 1, 2, 4)

Giriş:, 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)olası çıkış:X = (1, 1, 3, 1, 2, 1, 2, 5, 4, 5) .

Giriş:, 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)olası çıkış:X = (1, 2, 1, 3, 3, 1, 3, 3, 1, 3, 3, 1, 2, 1, 3) .

Giriş ve çıkış formatı

Kodunuz giriş yapabilir ve uygun bulduğunuz herhangi bir insan okuma biçiminde çıktı verebilir. Ancak, lütfen testin çıktısını sorudaki örneklerde gösterin.

Çalışma süresi

Sorudaki tüm örnekler için kodu tamamlayabilmeniz gerekir. Bu prensipte için doğru olmalıdır niçin yukarı 15ama bunun tüm girişler için yeterince hızlı olacağını kanıtlamak gerekmez.

Kabuk , 20 bayt

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

Çevrimiçi deneyin!

Bir çözüm veya yoksa boş bir liste döndürür. Son test durumu (n=15 ) TIO'da 3,8 saniye içinde biter.

açıklama

Program iki bölümden oluşmaktadır. İlk kısımda ( ¡ve sağında), d köğesi ktoplamları içinde olan tüm uzunluk listelerini içeren bir liste olan sonsuz bir liste oluştururuz S. Bunu indüktif olarak, Sher bir elementin her elemanına 1 elementli dilimlerinden başlayarak ve her adımda Sönek toplamlarını içeride tutarak yaparız S. İkinci bölümde ( !ve solunda), nuzunluk nlistelerini içeren listenin th öğesini alırız . Bunlardan, dilim toplamları aslında her öğesini içeren ilkini seçiyoruz S.

Kodda, netlik için önce ove ȯ(iki ve üç işlevi bir araya getiren) parantezlerle değiştirelim.

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

Daha fazla açıklama gerektiren bazı kısımlar var. Bu programda, üst yazıların ⁰¹her ikisi de ilk bağımsız değişkeni ifade eder S. Bununla birlikte, αbir fonksiyonudur, o zaman α¹"uygulamak anlamına αiçin Sise," ⁰αaraçlar "çıkışı Sikinci bağımsız değişken için α". İşlev ¦, ilk argümanının ikincinin tüm öğelerini içerip içermediğini (çoklukları sayar) kontrol eder, dolayısıyla Sikinci argümanı da olmalıdır.

İlk bölümde, kullanılan işlev ¡olarak yorumlanabilir S(f~Λ€∫)(×:)¹. Kombinatör Sgibi davranır Sαβγ -> (αγ)(βγ), yani basitleştirebiliriz (f~Λ€∫¹)(×:¹). İkinci bölüm, ×:¹" Shazırlayarak karıştır" dır ve sonucu ilk bölüme geçirilir. İlk bölüm, f~Λ€∫¹böyle çalışır. İşlev, fbir listeyi bu durumda olan bir koşula göre filtreler ~Λ€∫¹. Bir liste listesi alır L, bu yüzden bizde var ~Λ€∫¹L. Birleştirici şu şekilde ~davranır ~αβγδε -> α(βδ)(γε): ilk argüman, βikincisine iletilir γve sonuçlar birleştirilir α. Bu demek oluyor ki Λ(€¹)(∫L). Son bölüm ∫L, sadece toplamları L,€¹ , üyeliği kontrol eden SveΛbir koşul (burada €¹) ve bir liste (burada ∫L) alır ve tüm öğelerin bunu karşılayıp karşılamadığını kontrol eder. Basitçe söylemek gerekirse, karıştırma sonuçlarını kümülatif toplamlarının içeri girip girmediğine göre filtreliyoruz S.

Ruby , 135 bayt

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

Çevrimiçi deneyin!

Önce bir genişlik araması kullanın. n = 10 TIO üzerinde çalışıyor, n = 15 bir dakikadan uzun sürüyor, ancak makinemde çalışıyor.

Ruby , 147 bayt

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

Çevrimiçi deneyin!

Optimize edilmiş sürüm, n = 15 (~ 20 sn) için TIO'da çalışır

Aslında bu, kaba-kuvvet-olmayan bir yaklaşımın başlangıcıdır. Umarım birisi üzerinde çalışır ve tam bir çözüm bulur.

İlk fikirler:

• Çıkış dizisinin toplamı, giriş dizisinin son öğesidir (maks.).
• Çıktı dizisinin toplamı eksi ilk (veya son) öğe, giriş dizisinin ikinci son öğesidir.
• Bir dizi çözümse, ters dizi de bir çözümdür, bu nedenle ilk öğenin giriş dizisinin son 2 öğesi arasındaki fark olduğunu varsayabiliriz.
• İkinci eleman, girdi dizisinin ikinci ve üçüncü veya ikinci ve dördüncü son elemanı arasındaki fark olabilir.

Bu da bizi bir sonraki optimizasyona getiriyor:

Yakut , 175 bayt

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

Çevrimiçi deneyin!

TIO'da ~ 8.5 saniye. Fena değil...

... vb. (uygulanacak)

Haskell, 117111 bayt

@Nimi sayesinde 6 byte tasarruf!

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

Çevrimiçi deneyin!

Bu, tüm çözümleri hesaplar. Helper işlevi fonları kademeli olarak oluşturur, rargüman$S$ins

Ne zaman nsıfır (hiç golfed edilir n<1) tüm değerler görülmüş olup olmadığını kontrol ettiğimiz bu yüzden liste, hazır olmalıdır. Değilse, çözüm olmadığını belirtmek için boş bir liste döndürürüz, aksi takdirde seçilen öğelerin ekleneceği boş bir liste içeren tek bir liste döndürürüz. Bu dava ek denklemlerle de ele alınmış olabilir

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

nSıfır değilse , geri döneriz

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

Bu, ilk elemanın (2) geldiği (1) listelerin listesidir. s ve geri kalanı (5) tüm yeni meblağların bulunduğu koşul (4) altında tekrarlanan çağrıdan geldiğis . Yeni meblağlar (3) 'te hesaplanmıştır - ttek bir listeden, idiomatik Haskell'de ne olacağı için çirkin bir golf hackinden alınmıştır let t=y:map(y+)i. Yinelemeli çağrı (5) r, yeni toplamlar arasında görünen unsurlar olmadan eskisini yeni ayarlart .

Ana işlev &, hala tüm değerleri ( r=s) görmek zorunda olduğumuzu ve henüz toplamlar olmadığını (i=[] ) .

Yedi bayt daha için, hesaplamayı yalnızca daha hızlı olan ve tüm test senaryolarını 2 saniyeden daha kısa sürede işleyen ilk sonucu (varsa) verecek şekilde kısıtlayabiliriz.

Çevrimiçi deneyin! (bu sadece eski sürümün ilk sonucudur)

Temiz , 177 bayt

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

Çevrimiçi deneyin!

Makinemde yaklaşık 40 saniye sürüyor n=15Test çantası , ancak TIO'da zaman aşımına uğradı.

Temiz , 297 bayt

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

Çevrimiçi deneyin!

Bu GB tarafından yapılan bazı optimizasyonları içerir yanı sıra . Bence bunlardan birkaçı daha genel hale getirilebilir, bu yüzden bittiğinde bir açıklama ekleyeceğim.

Makinemde yaklaşık 10 saniye, TIO'da 40 saniye sürüyor.

Python 3 , 177 bayt

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)

Çevrimiçi deneyin!

(okuyucuların kodu kaydırmasını önlemek için bazı yeni satırlar / boşluklar eklendi)

Jelly cevabımın doğrudan bağlantı noktası (bazı değişikliklerle, aşağıdaki "not" bölümüne bakın)

Yerel çalıştırma sonucu:

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

Bunun itertoolsayrıntılı olduğunu duydum , ancak en iyi combinationsuygulamam daha da ayrıntılı:

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]

Not .

• Division / modulo kullanma a[p//n:p%n+1] yaklaşık 2 kat daha uzun sürer, ancak bazı bayt tasarruf sağlar.
• Bu, Jelly cevabından biraz farklıdır - Jelly cevabı geriye doğru tekrar eder.
• combinationsBir yineleyici döndürme sayesinde , bu daha bellek dostu.

Jöle , 35 bayt

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

Çevrimiçi deneyin!

Yerel olarak çalıştır: (n = 15, 1 GB'den fazla RAM alır)

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

(aslında 35 bayttan fazla süren UTF8 kodlu sürümü çalıştırdım, ancak sonuç yine de aynı)

Bu çözüm, çalışma süresini azaltmak için kısa devre kullanır.

Kısa devre olmadan, bu kod kabaca alır $\binom {|S|-2}{n-2} \times \left( \frac {n^3}6 + n^2\log{n^2} \right)$ değerlendiren işlemler $\binom {26-2}{15-2} \times \left( \frac {15^3}6 + 15^2\log{15^2} \right) \approx 5.79 \times 10^9$ancak Python ve Jelly'in verimsizliği nedeniyle tamamlanması sonsuza kadar sürer. Kısa devre sayesinde çok daha erken bitebilir.

açıklama

Girişte boş olmayan tüm öneklerin toplamlarının bulunduğunu ve kesinlikle arttığını not ediyoruz. Ayrıca, en büyük ve ikinci en büyük öğenin bir önek toplamı olduğunu varsayabiliriz.

Bu nedenle, tüm seçim yollarını düşünebiliriz $n-2$ ilkinden farklı unsurlar $|S|-2$ elemanları (var $\binom {|S|-2}{n-2}$bu tür listeler), öğeleri kurtarmak için ardışık farklılıkları hesaplayın; sonra saf olarak geçerli olup olmadığını kontrol edin (hepsini alın$n^2$altdiziler, toplamı hesapla, benzersiz kıl. Alt dizilerin toplam uzunluğu yaklaşık$n^3 \over 6$)

Test edilmemiş (ancak aynı performansa sahip olmalıdır)

Jöle , 32 bayt

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

Çevrimiçi deneyin!

Daha verimsiz versiyon (kısa devre olmadan):

Jöle , 27 bayt

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

Çevrimiçi deneyin!

N = 15 testi için 2GB RAM alır ve ~ 37 dakika sonra sona ermez.

not : Ẇ§ile değiştirilebilir ÄÐƤẎ. Daha verimli olabilir.

APL (NARS), karakter 758, bayt 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

Gx'teki G fonksiyonu (H fonksiyonunun yardımıyla) x'in tüm permütasyonlarını bulur. Xdy'deki d işlevi, y dizisinin Boole değeri döndüren alıştırma dizisi x'in ardından oluşturulup oluşturulmadığını bulur. X F y'deki F işlevi, x uzunluğundaki r dizisini döndürür, böylece ydr true olur (= 1) Uygulama olarak biraz uzun, ancak testteki tüm durumları daha kısa sürede hesaplayan budur ... Son durum n = 15 için sadece 20 saniye çalıştırın ... bu çok fazla çözüm bulamaman gerektiğini söylemeliyim, daha kısa sürede (son olarak öyle görünüyor) sadece bir çözüm döndür (farklı girişler için test edilmemiş ...) 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