Izin Abir olması mile ndikdörtgen matris pozitif tamsayı, mve naynı zamanda olan pozitif tamsayılardır.

Sol üst hücrenin Asağ alt hücresine doğru RoD ('Sağ-Aşağı-Aşağı') yollarıyla ilgileniyoruz ; bir RoD yolunda, yolun birbirini izleyen her bir hücresi, bir sağdan bir hücre ya da bir önceki hücreden bir hücre Aşağıdır.

Böyle bir RoD yolu göz önüne alındığında A, o yoldaki hücrelerin toplamını alabiliriz .

Örneğin, 4'e 3 matrisi düşünün:

[ [1, 2, 3, 4],
  [5, 1, 6, 7],
  [8, 2, 1, 1] ]

O zaman RoD yolunu düşünebiliriz:

1 > 2   3   4
    v
5   1   6   7
    v
8   2 > 1 > 1

toplamı vardır 1+2+1+2+1+1=8. Bu yolun, bu matristeki üst soldan alt sağa mümkün olan tüm RoD yollarının en küçük toplamına sahip olduğunu belirtmek gerekir.

Bu nedenle, önerilen zorluk, seçtiğiniz dilde belirli bir matristeki bir RoD yolunun minimum toplamını veren en kısa işlevi / programı sağlamaktır A.

Olağan yasak boşluklar geçerlidir. Girişiniz makul bir formatta olabilir; çıktınız bir tamsayı olmalıdır.

Bu kod golfü; cevaplar bayt sayısına göre puanlanır.

Test Durumları

[ [5] ] -> 5

[ [5, 2] ] -> 7

[ [5], 
  [2] ] -> 7

[ [ 9 , 1 , 12, 3 ],
  [ 12, 11, 6 , 11],
  [ 12, 9 , 2 , 11] ] -> 40

[ [ 6 , 8 , 11, 2 ],
  [ 3 , 6 , 7 , 6 ],
  [ 6 , 2 , 8 , 12] ] -> 37

[ [ 4 , 5 , 8 , 4 ],
  [ 6 , 5 , 9 , 4 ],
  [ 2 , 5 , 6 , 8 ] ] -> 31

[ [ 4 , 5 , 15, 18, 30],
  [ 26, 26, 3 , 4 , 5 ],
  [ 7 , 9 , 29, 25, 14],
  [ 16, 1 , 27, 13, 27],
  [ 23, 11, 25, 24, 12],
  [ 17, 23, 7 , 14, 5 ] ] -> 94

[ [ 10, 15, 7 , 2 , 9 ],
  [ 24, 5 , 2 , 1 , 25],
  [ 2 , 12, 14, 30, 18],
  [ 28, 4 , 12, 22, 14],
  [ 15, 21, 21, 11, 4 ],
  [ 21, 15, 21, 29, 9 ] ] -> 103

J , 42 bayt

v(+}.<.}:)&.>/@{.[:</.(2#v=._1+1#.$){.!._]

Çevrimiçi deneyin!

Nasıl çalışır

v(+}.<.}:)&.>/@{.[:</.(2#v=._1+1#.$){.!._]
                         v=._1+1#.$         Sum of two dimensions - 1; assign to v
                                            (v is a verb)
                      (2#          ){.!._]  Extend the given array in both dimensions
                 [:</.  Extract the antidiagonals as boxed arrays
v             @{.  Take the first `v` antidiagonals
 (       )&.>/     Reduce over unboxed items:
   }.<.}:            Given the right item R, take the minimum of R[1:] and R[:-1]
  +                  Add to the left item

örnekleme

1 2 3 4  Input array, dimensions = 3,4
5 1 6 7
8 2 1 1

1 2 3 4 _ _  Extended to 6,6 with filler _ (infinity)
5 1 6 7 _ _
8 2 1 1 _ _
_ _ _ _ _ _
_ _ _ _ _ _
_ _ _ _ _ _

1            Diagonalize and take first 6 rows
5 2
8 1 3
_ 2 6 4
_ _ 1 7 _
_ _ _ 1 _ _

Reduction: left+min(right[1:], right[:-1])
1                                          1  => 8
5 2                               5  2  => 10 7
8 1 3                   8 1 3  => 12 5 11
_ 2 6 4      _ 2 6 4 => _ 4 8 12
_ _ 1 7 _ => _ _ 2 8 _
_ _ _ 1 _ _

JavaScript (ES6), 78 77 76 bayt

m=>(M=g=s=>(v=(m[y]||0)[x])?g(s+=v,y++)|g(s,x++,y--)*x--|M<s?M:M=s:0)(x=y=0)

Çevrimiçi deneyin!

Yorumlananlar

m => (                      // m[] = input matrix
  M =                       // initialize the minimum M to a non-numeric value
  g = s =>                  // g = recursive function taking the current sum s
    (v = (m[y] || 0)[x]) ?  //   if the current cell v is defined:
      g(s += v, y++) |      //     do a recursive call at (x, y + 1)
      g(s, x++, y--) * x--  //     do a recursive call at (x + 1, y)
      |                     //     if at least one call did not return 0 (which means
                            //     that we haven't reached the bottom-right corner)
      M < s ?               //     or M is less than s (false if M is still non-numeric):
        M                   //       return M unchanged
      :                     //     else:
        M = s               //       update M to s, and return this new value
    :                       //   else (we're outside the bounds of the matrix):
      0                     //     return 0
)(x = y = 0)                // initial call to g with s = x = y = 0

Haskell, 63 57 bayt

f x@((a:_:_):c:d)=a+min(f$c:d)(f$tail<$>x)
f x=sum$id=<<x

Çevrimiçi deneyin!

f x@((a:_:_):c:d)=           -- if it's at least a 2x2 matrix
   a+min                     -- add the top left element to the minimum of the
                             -- path costs of
        f$c:d                --   the matrix with the first row dropped and
        f$tail<$>x           --   the matrix with the first column dropped
f x=                         -- else, i.e. a 1xm or nx1 matrix, i.e. a vector
    sum$id=<<x               -- return the sum of this vector

MATL , 38 36 30 29 bayt

@Giuseppe'ye bir hatayı işaret ettiği için teşekkürler , şimdi düzeltildi.

lyZyqsG&nghZ^Yc!tsGz=Z)Ys)sX<

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

açıklama

l        % Push 1
y        % Input, implicit. Duplicate from below. Pushes the input below
         % the current 1, and a copy of the input on top
Zy       % Size of input. Gives [m, n]
qs       % Subtract 1 element-wise, sum. Gives m+n-2
G        % Push input again
&n       % Push size as two separate numbers. Gives m, n
gh       % Transform n into 1 and concatenate horizontally. Gives [m, 1]
Z^       % Cartesian power of [m, 1] raised to m+n-2. This produces the
         % Cartesian tuples as row of a matrix. A typical tuple may be
         % [1, m, 1, m, m]. This will define a path along the matrix in
         % linear, column-wise indexing (down, then across). So 1 means
         % move 1 step down, and m means move m steps "down", which is
         % actually 1 step to the right
Yc       % Concatenate strcat-like. This prepends the 1 that is at the
         % bottom of the stack to each row
!        % Transpose. Each tuple (extended with initial 1) is now a column
!ts      % Duplicate, sum of each column
Gz       % Number of nonzeros of input. Gives m*n-1
=Z)      % Keep only columns that sum m*n. That means that, starting from
Ys       % Cumulative sum of each column. This defines the path
)        % Index: pick entries specified by the path
s        % Sum of each column
X<       % Minimum
         % Display, implicit

R , 90 bayt

function(m){l=sum(m|1)
if(l>1)for(i in 2:l)m[i]=m[i]+min(m[i-1],m[max(0,i-nrow(m))])
m[l]}

Çevrimiçi deneyin!

Naif çözüm: dizi boyunca yineleme (sütunlar aşağı), her girişi kendi toplamı ve üst ve soldaki komşularının minimum değeriyle değiştirir, varsa son girdiyi döndürür.

Perl 6 , 57 54 bayt

my&f={|.flat&&.[0;0]+min (f(.[1..*]),f $_>>[1..*])||0}

Çevrimiçi deneyin!

açıklama

my&f={                                               }  # Function f
      |.flat&&  # Return empty slip if matrix is empty
              .[0;0]+  # Value at (0,0) plus
                     min  # Minimum of
                          f(.[1..*])   # Rows 1..*
                                     f $_>>[1..*]  # Columns 1..*
                         (          ,            )||0  # Or 0 if empty

Röda , 100 89 bayt

f A{g={|x,y|{g(x-1,y)if[x>0];g(x,y-1)if[y>0];[0]if[x+y=0]}|min|[A[x][y]+_]}g#A-1,#A[0]-1}

Çevrimiçi deneyin!

İnekler quack sayesinde -9 bayt

Python 3 , 108 bayt

def f(A,m,n,i=0,j=0):r=i+1<m and f(A,m,n,i+1,j);d=j+1<n and f(A,m,n,i,j+1);return A[i][j]+min(r or d,d or r)

Çevrimiçi deneyin!

Ungolfed

def f(A, m, n, i=0, j=0):
    right = i + 1 < m and f(A, m, n, i + 1, j)
    down  = j + 1 < n and f(A, m, n, i, j + 1)
    return A[i][j] + min(right or down, down or right)

Jöle , 21 bayt

ZI_.ỊȦ
ŒJŒPÇƇLÐṀœị⁸§Ṃ

Çevrimiçi deneyin!

Nasıl?

ZI_.ỊȦ - Link 1: isDownRight?: List of 2d indices (limited to having no repetitions)
Z      - transpose
 I     - deltas (vectorises)
  _.   - subtract 1/2 (vectorises)
    Ị  - insignificant? (effectively _.Ị here is like "v in {0,1}? 1 : 0")
     Ȧ - any & all (0 if a 0 is present when flattened, else 1)

ŒJŒPÇƇLÐṀœị⁸§Ṃ - Main Link: list of lists of integers, A
ŒJ             - multi-dimensional indices of A
  ŒP           - power-set
     Ƈ         - filter keep only those truthy by:
    Ç          -   last link as a monad
       ÐṀ      - filter keep only those maximal by:
      L        -   length
           ⁸   - chain's left argument, A
         œị    - multi-dimensional index into (vectorises)
            §  - sum each
             Ṃ - minimum

APL (Dyalog Klasik) , 37 32 bayt

{⊃⌽,9e9(⊢⌊⍵+(2⊣⌿⍪)⌊2⊣/,)⍣≡+⍀+\⍵}

Çevrimiçi deneyin!

+⍀+\ yatay ve dikey olarak kısmi toplamlar - bu, her kareye giden yollar için bir ilk fazla tahmin sağlar

9e9(... )⍣≡yakınsamaya kadar "..." uygulayın, her adımda sol argüman olarak çok büyük bir sayı (9 × 10 ⁹ ) geçirin

,9e9geçerli tahminin soluna -s ekle

2⊣/ her bir ardışık hücre çiftinden ilkini alın, son sütunu etkili bir şekilde bırakın

2⊣⌿⍪dikey olarak aynı şey - 9e9üst sıraya koy ve son satırı bırak

(2⊣⌿⍪) ⌊ 2⊣/, minima

⍵+ orijinal matrisi ekle

⊢⌊ bununla ilgili mevcut tahminleri iyileştirmeye çalışın

⊃⌽, sağ alt hücre

Kömür , 46 bayt

≔Ｅ§θ⁰∧κΣ§θ⁰ηＦθ«≔§η⁰ζＦＬι«≔⁺⌊⟦§ηκζ⟧§ικζ§≔ηκζ»»Ｉζ

Çevrimiçi deneyin! Bağlantı, kodun ayrıntılı versiyonudur. Açıklama: Kömürde üç argüman olsaydı, bu muhtemelen daha kısa olurdu reduce.

≔Ｅ§θ⁰∧κΣ§θ⁰η

Çalışma dizisini sıfır olan ilk değer dışında büyük değerlerle doldurun.

Ｆθ«

Giriş satırlarının üzerinden geçin.

≔§η⁰ζ

Geçerli toplamı, çalışma dizisinin ilk öğesiyle başlatın.

ＦＬι«

Girişin sütunlarının üzerinden geçin.

≔⁺⌊⟦§ηκζ⟧§ικζ

Geçerli dizinin ve çalışma dizisinin geçerli öğesinin minimumunu alın ve yeni geçerli toplamı vermek için girişin geçerli öğesini ekleyin.

§≔ηκζ

Ve bunu bir sonraki satıra hazır çalışma dizisinde saklayın.

»»Ｉζ

Giriş tamamen işlendikten sonra toplamı yazdırın.

Jöle , 17 bayt

XL,1ẋLḊŒ!1;ⱮÄịẎ§Ṃ

Çevrimiçi deneyin!

Java 8, 197 193 bayt

m->{int r=m.length-1,c=m[0].length-1,i=r,a;for(;i-->0;m[i][c]+=m[i+1][c]);for(i=c;i-->0;m[r][i]+=m[r][i+1]);for(i=r*c;i-->0;r=m[i/c][i%c+1],m[i/c][i%c]+=a<r?a:r)a=m[i/c+1][i%c];return m[0][0];}

@Ceilingcat sayesinde -4 bayt .

Çevrimiçi deneyin.

Genel açıklama:

Aslında zaten yaklaşık bir yıl önce bu zorluğu yaptığımız Proje Euler # 81 bir kare matrisin yerine ait sınırlıydı hariç Ntarafından Mmatrise. Bu yüzden kodumu arkadan biraz sonra değiştirdim.

İlk önce en son hücreden en alt sütuna ve en sağdaki sütuna geriye doğru toplam. Şimdi meydan okuma örnek matrisini kullanalım:

1, 2, 3, 4
5, 1, 6, 7
8, 2, 1, 1

Son hücre aynı kalır. : Alt sıranın ikinci son hücre toplamı olur 1+1 = 2, ve en sağdaki ikinci son hücre için aynı: 1+7 = 8. Bunu yapmaya devam ediyoruz, bu yüzden şimdi matris şöyle görünüyor:

 1,  2,  3, 12
 5,  1,  6,  8
12,  4,  2,  1

Bunu yaptıktan sonra, kalan tüm satırlara alttan üste ve sağdan sola tek tek bakarız (son sütun / satır hariç) ve her hücreyi hem altındaki hem de sağındaki hücrede ararız hangisi daha küçük.

Böylece sayıyı içeren hücre 6olur 8, çünkü 2aşağıda 8sağdan daha küçüktür . Sonra bir 1sonrakine (solda) bakarız ve aynısını yaparız. Bu 1olur 5, çünkü 4aşağıda 8sağdan daha küçüktür .

Yani sondan ikinci satıra geçtikten sonra, matris şöyle görünür:

 1,  2,  3, 12
10,  5,  8,  8
12,  4,  2,  1

Ve bunu tüm matris için yapmaya devam ediyoruz:

 8,  7, 11, 12
10,  5,  8,  8
12,  4,  2,  1

Şimdi ilk hücre 8bu durumda olan sonucumuzu içerecek .

Kod açıklaması:

m->{                    // Method with integer-matrix input and integer return-type
  int r=m.length-1,     //  Amount of rows minus 1
      c=m[0].length-1,  //  Amount of columns minus 1
      i=r,              //  Index integer
      a;                //  Temp integer
  for(;i-->0;m[i][c]+=m[i+1][c]);
                        //  Calculate the suffix-sums for the rightmost column
  for(i=c;i-->0;m[r][i]+=m[r][i+1]);
                        //  Calculate the suffix-sums for the bottom row
  for(i=r*c;i-->0       //  Loop over the rows and columns backwards
      ;                 //     After every iteration:
       r=m[i/c][i%c+1], //      Set `r` to the value left of the current cell
       m[i/c][i%c]+=a<r?//      If `a` is smaller than `r`:
                 a      //       Add `a` to the current cell
                :       //      Else:
                 r)     //       Add `r` to the current cell
      a=m[i/c+1][i%c];  //    Set `a` to the value below the current cell
  return m[0][0];}      //  Return the value in the cell at index {0,0} as result

Brachylog , 26 25 bayt

∧≜.&{~g~g|hhX&{b|bᵐ}↰+↙X}

Çevrimiçi deneyin!

-1 bayt, çünkü kesim gerekli değildir - boş bir listenin başına geçemezsiniz

Muhtemelen bu golf için çok yer var ama uykuya ihtiyacım var.

Yaklaşım, çıktı için her değeri denemeye kadar kaybolur, ilk önce en küçük olan ( ), bu toplamı ( ) üreten sağ alt köşeye ( ) ∧≜.kadar bir yol bulunana kadar ( ).b|bᵐ~g~ghhX&...↰+↙X

Java (JDK) , 223 bayt

Girişi 2D bir liste olarak alır.

Ek 19 bayt import java.util.*;dahil.

import java.util.*;m->{var l=m.get(0);int s=m.size(),c=l.size(),x=-1>>>1,a=l.get(0);return s*c<2?a:Math.min(s>1?n.n(new Vector(m.subList(1,s))):x,c>1?n.n(new Vector<>(m){{replaceAll(l->new Vector(l.subList(1,c)));}}):x)+a;}

Çevrimiçi deneyin!

Nasıl çalışır

import java.util.*;                                     // Import needed for Vector class
m->{                                                    // Lambda that takes a 2D list of integers
    var r=m.get(0);                                     // Store first row in variable
    int h=m.size(),                                     // Store number of rows
        w=r.size(),                                     // Store number of columns
        x=-1>>>1,                                       // Store int max
        a=r.get(0);                                     // Store the current cell value
    return h*w<2?a:                                     // If matrix is single cell return value
        Math.min(                                       // Otherwise return the minimum of...

            h>1?                                        // If height is more than 1
                n.n(                                    // Recursively call this function with 
                    new Vector(m.subList(1,h))):        // a new matrix, without the top row
                x,                                      // Otherwise use int max as there is no row below this

            w>1?                                        // If width is more than 1
                n.n(new Vector<>(m){{                   // Recursively call this function with a new matrix             
                    replaceAll(                         // where all columns have been replaced with 
                        l->new Vector(l.subList(1,w))   // cloned lists without the leftmost column
                    );
                }}):                                    // Otherwise use int max as there is
                x                                       // no column to the right of this
        )+a;                                            // Add the current cell value to the result before returning
}

Python 2 , 86 bayt

f=lambda A:len(A)>1<len(A[0])and A[0][0]+min(f(zip(*A)[1:]),f(A[1:]))or sum(sum(A,()))

Çevrimiçi deneyin!

Eğer B bir devrik olduğunu A, o zaman sorun tanımı ima f(A)==f(B).

A[1:]Aüst satırında eksik olan dizidir .zip(*A[1:])Aen soldaki sütunu eksik olan ve aktarılan dizidir . sum(sum(A,()))içindeki tüm öğelerin toplamıdır A.

Eğer Asadece tek bir sütun ya da tek sıra vardır, bu yüzden, sadece bir yolu yoktur ftüm unsurların toplamı döndürür A; aksi takdirde biz recurse ve toplamını döndürür A[0][0]küçük + farasında Aüst satırı eksik ve fiçinde Aen soldaki sütun eksik.