Örtüşmeyen Matris Toplamı

N uzunluğu k dizileri göz önüne alındığında , her dizideki bir eleman kullanılarak mümkün olan en fazla toplamı, iki elemanın aynı dizinden olmayacağı şekilde verin. K <= n olması garanti edilir.

Giriş

Boşluksuz bir tamsayı olmayan dizi dizisi.

Çıktı

Maksimum toplamı temsil eden bir tam sayı.

Örnekler

Input -> Output
[[1]] -> 1
[[1, 3], [1, 3]] -> 4
[[1, 4, 2], [5, 6, 1]] -> 9
[[-2, -21],[18, 2]] -> 0
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] -> 15
[[1, 2, 3, 4], [5, 4, 3, 2], [6, 2, 7, 1]] -> 16
[[-2, -1], [-1, -2]] -> -2

Jöle , 10 6 bayt

ZŒ!ÆṭṀ

Çevrimiçi deneyin!

. (4 bayt Jöle ben edildi yerleşiğini bir "ana diyagonal toplamını" olduğunu belirtti @Dennis tarafından kaydedilen değil o onlardan biri olması bekleniyor; önceki çözüm yerleşiğini kullanmadan operasyonu uygulanan operasyon söz konusu. Æṭ"iz" olarak tanımlandı, ancak iz yalnızca kare matrisler için tanımlandı; Jelly de dikdörtgen matrislere genelleme uygular.)

Diğer cevaplara göre gelişme çoğunlukla daha basit (dolayısıyla ifade etmesi ters) bir algoritmadan; Bu program başlangıçta Brachylog v2 ( {\p\iᶠ∋₎ᵐ+}ᶠot) 'de yazılmıştı , ancak Jelly’in Brachylog’da yazılması gereken bazı bölümleri için bazı yerleşikleri var, bu yüzden bu daha kısa oldu.

açıklama

ZŒ!ÆṭṀ
Z            Swap rows and columns
 Œ!          Find all permutations of rows (thus columns of the original)
   Æṭ        {For each permutation}, take the sum of the main diagonal
     Ṁ       Take the maximum

Sorunun herhangi bir çözümü için, orijinal matrisin sütunlarının bu çözümü ana diyagonal üzerine koymasına izin verebileceğimiz açık olmalıdır. Dolayısıyla bu çözüm basitçe tersine çevirerek, permütasyonların tüm olası ana köşegenlerini bulur.

"Sütunlara izin ver" işleminin geri dönüş için zahmet etmeden "devrik, satırlara izin ver" olarak yapıldığına dikkat edin; algoritmanın geri kalan kısmı ana diyagonal üzerinde simetrik olur, bu yüzden transpozisyonu geri almamız gerekmez ve bu nedenle bir bayt kurtarabiliriz.

J , 28 bayt

>./@({.+1$:@|:\.|:@}.)@[^:]#

Çevrimiçi deneyin!

 >./ @  (   {.   +         1 $:@|:\. |:@}.       )       @[^:] #
(max of (1st row + recursive call on each "minor")) or count of arg if 0

Burada özyinelemeli çağrı, $:onu içeren en büyük anonim işlevi temsil eder. İlkel olması J şanslı x u\. ygeçerli olduğu, uarka arkaya "outfixes" için yuzunlukta ardışık ara ekleri içermemelidir bastırma ile elde edilen xöğe y; burada "küçükleri" elde etmek için art arda gelen sütunları bastırmak istiyoruz, bu yüzden |:alt satırlarını (veya kuyruğunu }.) ydevrediyoruz ve sonra onların dış hatlarının devri üzerine tekrar yapıyoruz.

Python 3 , 94 90 89 84 80 bayt

^{Xnor sayesinde -4 bayt (listeler yerine kümeleri kullanarak)!}

f=lambda x,y={-1}:x>[]and max(e+f(x[1:],y|{i})for(i,e)in enumerate(x[0])if{i}-y)

Çevrimiçi deneyin!

Kabuğu , 12 11 9 bayt

▲mȯΣ►L∂PT

Çevrimiçi deneyin!

Sayesinde BMO bir port öneren ais523 cevabı ve ben daha geliştirmek başardı ve sırayla BMO daha 2 bayt tıraş kurtarış 2-bayt.

Önceki çözüm (14 bayt)

▲moΣz!¹fS=uΠmŀ

Çevrimiçi deneyin!

Test paketi oluşturamadım çünkü bu cevap ilk komut satırı argümanını kullanıyor komutunu açıkça kullanıyor. Ancak Husk, STDIN'i hiç kullanmıyor, bu yüzden tüm test vakalarını orada ekledim, bu yüzden sadece kontrol etmek için argüman alanına yapıştırmayı kopyalayabilirsiniz. Ayrıca, Husk'taki dizilerin girilirken öğeler arasında boşluk bulunmayabileceğini unutmayın.

Nasıl çalışır?

Kod dökümü

▲moΣz!¹fS=uΠmŀ     Full program. Takes a 2D list from CLA 1 and outputs to STDOUT.
            mŀ     Length range of each list. 
           Π       Cartesian product.
       fS=u        Discard those combinations which have at least 1 non-unique element.
 mo                Map over the combinations with the following predicate:
    z!¹            Zip the 2D list input with the current combination and index accordingly.
   Σ               Sum the resulting elements.
▲                  Finally, pick the maximum.

Örnek

Kişi, her biri iki endeks karşılık gelmeyecek şekilde tam olarak bir dizin seçmelidir. Bu nedenle, satırların uzunluk aralıklarını oluşturuyoruz ve bunları yalnızca yinelenmeyenleri koruyarak aşağıdaki kombinasyonları elde ediyoruz (her bir kombinasyon yer kazanmak için bir satır yerine bir sütundur):

Ardından, program giriş listelerinde kombinasyonun her bir elemanı ile indeksler, döndürür:

$9$

JavaScript (ES6),  74  71 bayt

Bir hatayı düzeltmek için kullanılan 2 gereksiz bayt tanımlamak
için @tsh sayesinde @tsh sayesinde 3 bayt kaydedildi

f=([a,...r],k,i=1)=>a?Math.max(...a.map(n=>k&(i+=i)?-1/0:n+f(r,k|i))):0

Çevrimiçi deneyin!

Jöle , 13 12 bayt

ẈŒpQƑƇị"€¹§Ṁ

Çevrimiçi deneyin!

Alternatif sürüm, 11 bayt

ZLœ!Lị"€¹§Ṁ

Bu, œ!belirli bir uzunluktaki tüm permütasyonları üreten yeni eklenen yerleşikleri kullanır .

Çevrimiçi deneyin!

Nasıl çalışır

ẈŒpQƑƇị"€¹§Ṁ  Main link. Argument: M (matrix)

Ẉ             Widths; compute the length of each row.
              For an n×m matrix, this yields an array m copies of n.
 Œp           Cartesian product; promote each n to [1, ..., n], then form all arrays
              that pick one k out of all m copies of [1, ..., n].
   QƑƇ        Comb by fixed unique; keep only arrays that do not change by
              deduplicating their entries.
         ¹    Identity; yield M.
      ị"€     For each of the arrays of unique elements, use its m entries to index
              into the m rows of M.
          §   Take the sums of all resulting vectors.
           Ṁ  Take the maximum.

Haskell , 65 bayt

f(u:v)=maximum[e+f(take i<>drop(i+1)<$>v)|(i,e)<-zip[0..]u]
f _=0

Çevrimiçi deneyin!

Açıklama ve Ungolfed

Fonksiyon take i<>drop(i+1)bir liste alır ve elemanı pozisyonda kaldırır i.

Fonksiyon f, mümkün olan her elemanı epozisyona alır , pozisyondaki ielemanları ikalan elemanlardan kaldırır eve özyinelemeli hesaplama optimumuna ekler :

f(u:v)=maximum[e+f(removeElementAt i<$>v)|(i,e)<-zip[0..]u]

Boş listenin temel örneği ise 0:

f _=0

Brachylog , 18 bayt

{hl⟦kp;?z₀∋₍ᵐ+}ᶠot

Çevrimiçi deneyin!

açıklama

                ot      The output is the biggest result of…
{             }ᶠ        …finding all outputs to the following predicate:
 hl⟦k                     Construct the range [0, …, n-1]
     p                    Take a permutation of that range
      ;?z₀                Zip that permutation with the Input, stopping when all elements of
                            the input are used (important because the range is possibly
                            bigger than the length of the input)
          ∋₍ᵐ             In each element of the zip, take the head'th element of the tail
             +            Sum the result

Perl 6 , 50 49 bayt

{max map *.map({.[$++]}).sum,permutations [Z] $_}

Çevrimiçi deneyin!

Uzun sürmesine rağmen terbiyeli şekilde kısa permutations aramaya . Bu, listelerin listesini alan ve bir sayı döndüren isimsiz bir kod bloğudur.

Açıklama:

{                                               } # Anonymous code block
 max                                              # Finds the maximum
                             permutations         # Of all permutations
                                          [Z] $_  # Of the transposed input
     map                                          # When mapped to
                        .sum # The sum of
         *.map({.[$++]})     # The diagonal of the matrix

K (OK) , 40, 32, 28, 19 bayt

Ngn sayesinde -13 bayt!

{|/+/(prm'x)@''!#x}

Çevrimiçi deneyin!

İlk çözüm:

{|/+/'x./:/:(*t),'/:t:{x~?x}#+!(#x)##*x}

Çevrimiçi deneyin!

Not: İlk test durumu için çalışmıyor [[1]]

Açıklama:

{ } - argümanlı fonksiyon x

                                   #     - creata a list
                               (#x)      - with length number of rows of x
                                    #*x  - of the length of the first row
                              !          - odometer (ranged permutations)
                             +           - transpose
                            #            - filter out the rows
                      {x~?x}             - that have duplicates
                    t:                   - save it to t 
                ,'/:                     - pair up each number in each row with
            (*t)                         - a number from the first row
      x./:/:                             - index x with each of the above
   +/'                                   - find the sum of each row
 |/                                      - reduce by max

Haskell , 65 bayt

([]%)
p%(h:t)=maximum[x+(i:p)%t|(i,x)<-zip[0..]h,all(/=i)p]
p%_=0

Çevrimiçi deneyin!

71 bayt

f m=maximum[sum b|(a,b)<-unzip<$>mapM(zip[0..])m,[x|x<-a,y<-a,x==y]==a]

Çevrimiçi deneyin!

[x|x<-a,y<-a,x==y]==aKontrol elemanları bu afarklıdır. Bu şaşırtıcı sayıda karakter kullanıyor, ancak daha kısa bir yol görmedim.

Pyth, 15 12 bayt

eSms@VQd.plh

Burada çevrimiçi deneyin .

eSms@VQd.plhQ   Implicit: Q=eval(input())
                Trailing Q inferred
          lhQ   Length of first element of Q
        .p      Generate all permutaions of 0 to the above
  m             Map the elements of the above, as d, using:
    @VQd          Vectorised index into Q using d
                    For i in [0-length(Q)), yield Q[i][d[i]]
   s              Take the sum of the above
 S              Sort the result of the map
e               Take the last element of the above, implicit print

Düzenleme: 3 bayt issacg izniyle

05AB1E , 18 13 bayt

нgLœε‚øε`è]OZ

Aşırı uzun olduğu hissine sahibim, ancak 05AB1E'de byte-verimli bir şekilde nasıl indekslenen nasıl vektörleştirildiğinden emin değilim .. Ve gerçekten de çok uzun olduğu konusunda haklıydım .. @Emigna sayesinde -5 bayt .

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

н                # Take the first inner list (of the implicit input list of lists)
 g               # Pop and take its length
  L              # Create a list in the range [1, inner-length]
   œ             # Create each possible permutation of this range-list
    ε            # Map each permutation to:
     ‚           #  Pair it with the (implicit) input
      ø          #  Transpose; swap rows/columns
       ε         #  Map each to:
        `        #   Push both to the stack
         è       #   Index the permutation-nr into the inner list of the input
    ]            # Close both maps
     O           # Take the sum of each inner list
      à          # Pop and push the maximum (and output implicitly)

Örnek çalışma:

• Giriş: [[1,4,2],[5,6,1]]
• 1. adımdan sonra ( нgL):[1,2,3]
• 2. adımdan sonra ( œ):[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
• 3. adımdan sonra ( ε‚):[[[[1,4,2],[5,6,1]],[1,2,3]],[[[1,4,2],[5,6,1]],[1,3,2]],[[[1,4,2],[5,6,1]],[2,1,3]],[[[1,4,2],[5,6,1]],[2,3,1]],[[[1,4,2],[5,6,1]],[3,1,2]],[[[1,4,2],[5,6,1]],[3,2,1]]]
• 4. adımdan sonra ( ø):[[[[1,4,2],1],[[5,6,1],2]],[[[1,4,2],1],[[5,6,1],3]],[[[1,4,2],2],[[5,6,1],1]],[[[1,4,2],2],[[5,6,1],3]],[[[1,4,2],3],[[5,6,1],1]],[[[1,4,2],3],[[5,6,1],2]]]
• Adım 5 (sonra ε`è]:) [[4,1],[4,5],[2,6],[2,5],[1,6],[1,1]](Not: 05AB1E 0 endeksli () otomatik sarımla, bu dizin 3halinde [5,6,1]sonuçlarında5 ).
• 6. adımdan sonra ( O):[5,9,8,7,7,2]
• Çıktı / adım 7 ( à) 'den sonra :9

Haskell, 84 bayt

import Data.List
h l=maximum[sum$snd<$>r|r<-mapM id$zip[1..]<$>l,(==)=<<nub$fst<$>r]

Çevrimiçi deneyin!

Ruby , 74 72 69 bayt

->a{[*0...a[0].size].permutation.map{|x|a.zip(x).sum{|y,z|y[z]}}.max}

Çevrimiçi deneyin!

05AB1E , 7 bayt

øœ€Å\Oà

Port @ ais523 'in Jelly CW cevap , çok emin de onu upvote olun!

Çevrimiçi deneyin veya tüm test durumlarını doğrulayın .

Açıklama:

ø          # Transpose the (implicit) input; swapping row/columns
 œ         # Get all permutations
  ہ\      # Take the main diagonal of each
     O     # Sum each
      à    # Pop and push the maximum (which is output implicitly)