স্বল্পতম ওজনযুক্ত আরডি পথের ওজন

Question

দিন Aএকটি হতে mদ্বারা nএর আয়তক্ষেত্রাকার ম্যাট্রিক্স ইতিবাচক পূর্ণসংখ্যার, যেখানে mএবং nএছাড়াও ইতিবাচক পূর্ণসংখ্যার।

আমরা RoD ('ডান-বা-ডাউন') এর উপরের-বাম কোষ Aথেকে নীচের ডানদিকে যেতে আগ্রহী; কোনও RoD পাথে, পাথের প্রতিটি ধারাবাহিক ঘরটি হয় একটি ঘর এর ডানদিকে অথবা পূর্ববর্তী ঘর থেকে নীচে একটি ঘর হয়।

এই জাতীয় কোনও RoD পথ দেওয়া, আমরা Aসেই পথে কক্ষগুলির যোগফল নিতে পারি ।

উদাহরণস্বরূপ, 4 বাই 3 ম্যাট্রিক্স বিবেচনা করুন:

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

তারপরে আমরা RoD পথটি বিবেচনা করতে পারি:

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

যার যোগফল রয়েছে 1+2+1+2+1+1=8। এটি লক্ষণীয় যে এই পাথের উপরের বাম থেকে mat ম্যাট্রিক্সের নীচে ডানদিকে নীচে থেকে সমস্ত সম্ভাব্য আরওডি পাথের সবচেয়ে সামান্য সমষ্টি রয়েছে sum

সুতরাং, প্রস্তাবিত চ্যালেঞ্জটি হ'ল আপনার পছন্দের ভাষায় সবচেয়ে সংক্ষিপ্ত ফাংশন / প্রোগ্রাম সরবরাহ করা যা কোনও প্রদত্ত ম্যাট্রিক্সে উপরের বাম থেকে নীচে ডানদিকে কোনও RoD পাথের সর্বনিম্ন যোগফল দেয় A।

সাধারণ নিষিদ্ধ ফাঁকগুলি কার্যকর হয়। আপনার ইনপুট যে কোনও যুক্তিসঙ্গত বিন্যাসে হতে পারে; আপনার আউটপুট অবশ্যই একটি পূর্ণসংখ্যা হতে হবে।

এটি কোড-গল্ফ; উত্তরগুলি বাইট সংখ্যা দ্বারা স্কোর হয়।

পরীক্ষার কেস

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

Answer 1

জে , 42 বাইট

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

এটি অনলাইন চেষ্টা করুন!

কিভাবে এটা কাজ করে

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

চিত্রণ

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

Comments

এটি সত্যিই দুর্দান্ত সমাধান!

— গ্যালেন ইভানভ

Answer 2

জাভাস্ক্রিপ্ট (ES6), 78 77 76 বাইট

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)

এটি অনলাইন চেষ্টা করুন!

মন্তব্য

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

Answer 3

হাস্কেল, 63 57 বাইট

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

এটি অনলাইন চেষ্টা করুন!

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

Answer 4

এমএটিএল , 38 36 30 29 বাইট

এখন ভুল সংশোধন করার জন্য @ জিউস্প্পকে ধন্যবাদ

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

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস যাচাই করুন ।

ব্যাখ্যা

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

Answer 5

আর , 90 বাইট

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

এটি অনলাইন চেষ্টা করুন!

নিষ্পাপ সমাধান: অ্যারের মাধ্যমে পুনরাবৃত্তি করুন (কলামগুলি নীচে), প্রতিটি এন্ট্রি নিজের এবং তার উপরের এবং সর্বনিম্ন এবং বাম প্রতিবেশীদের ন্যূনতম যোগ করে প্রতিস্থাপন করুন, যদি তারা উপস্থিত থাকে তবে শেষ এন্ট্রিটি ফিরিয়ে দিন।

Comments

সম্ভবত সমস্ত পাথের গণনা করা এবং সর্বনিম্ন নির্বাচন করা গল্ফিয়ার।

— জিউসেপ

Answer 6

পার্ল 6 , 57 54 বাইট

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

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

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

Comments

এর$! পরিবর্তে 53 বাইট ব্যবহার করুন&f

— জো কিং

Answer 7

Röda , 100 89 বাইট

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}

এটি অনলাইন চেষ্টা করুন!

-9 বাইট ধন্যবাদ গরুর কোয়েস্টকে

Comments

ওহে! আপনি যদি শেষের স্থান থেকে পুনরাবৃত্তি করেন তবে আপনি 91 বাইট পেতে পারেন ।

— ক্রিটসি লিথোস

Answer 8

পাইথন 3 , 108 বাইট

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)

এটি অনলাইন চেষ্টা করুন!

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)

Answer 9

জেলি , 21 বাইট

ZI_.ỊȦ
ŒJŒPÇƇ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

Answer 10

এপিএল (ডায়ালগ ক্লাসিক) , 37 32 বাইট

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

এটি অনলাইন চেষ্টা করুন!

+⍀+\ আংশিক অঙ্কগুলি অনুভূমিকভাবে এবং উল্লম্বভাবে - এটি প্রতিটি স্কোয়ারের পাথগুলির জন্য প্রাথমিক পর্যালোচনা সরবরাহ করে

9e9(... )⍣≡রূপান্তর না হওয়া পর্যন্ত "..." প্রয়োগ করুন, প্রতিটি ধাপে কিছু খুব বড় সংখ্যক (9 × 10 ⁹ ) বাম আর্গুমেন্ট হিসাবে পাস করে

,9e9বর্তমান অনুমানের বামে অ্যাডগুলি যোগ করুন

2⊣/ পরের কক্ষগুলির প্রতিটি জোড়া থেকে প্রথমটি গ্রহণ করুন, কার্যকরভাবে শেষ কলামটি বাদ দিন

2⊣⌿⍪উল্লম্বভাবে একই জিনিস - 9e9উপরে রাখুন এবং শেষ সারিতে ড্রপ করুন

(2⊣⌿⍪) ⌊ 2⊣/, মিনিমা

⍵+ আসল ম্যাট্রিক্স যুক্ত করুন

⊢⌊ এটি দিয়ে বর্তমান অনুমানগুলি উন্নত করার চেষ্টা করুন

⊃⌽, নীচে ডান ঘর

Comments

আপনি কি নিজের সমাধানের ব্যাখ্যা দিতে পারবেন?

— গ্যালেন ইভানভ

Answer 11

কাঠকয়লা , 46 বাইট

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

এটি অনলাইন চেষ্টা করুন! লিঙ্কটি কোডটির ভার্জোজ সংস্করণ। ব্যাখ্যা: reduceচারকোলে কোনও ত্রি-যুক্তি থাকলে এটি সম্ভবত সংক্ষিপ্ত হবে ।

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

প্রথম শূন্য ব্যতীত বড় মান সহ ওয়ার্কিং অ্যারেটি পূর্বে পূরণ করুন।

Ｆθ«

ইনপুটটির সারিগুলির উপরে লুপ করুন।

≔§η⁰ζ

কার্যকারী অ্যারের প্রথম উপাদান দিয়ে বর্তমান মোট শুরু করুন।

ＦＬι«

ইনপুটটির কলামগুলির উপরে লুপ করুন।

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

কার্যকারী অ্যারেটির সর্বনিম্ন এবং বর্তমান উপাদানটির সর্বনিম্ন নিন এবং নতুন বর্তমান মোট দিতে ইনপুটটির বর্তমান উপাদান যুক্ত করুন।

§≔ηκζ

এবং পরের সারির জন্য প্রস্তুত ওয়ার্কিং অ্যারেটিতে এটি সংরক্ষণ করুন।

»»Ｉζ

ইনপুট সম্পূর্ণ প্রক্রিয়া করা হয়ে গেলে মোট মুদ্রণ করুন।

Answer 12

জেলি , 17 বাইট

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

এটি অনলাইন চেষ্টা করুন!

Answer 13

জাভা 8, 197 193 বাইট

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

-৪ বাইট @ সিলিংক্যাট ধন্যবাদ ।

এটি অনলাইনে চেষ্টা করুন।

সাধারণ ব্যাখ্যা:

আমি আসলে ইতিমধ্যেই প্রায় এক বছর আগে এই প্রতিদ্বন্দ্বিতা করেনি প্রকল্প ইউলার # 81 ছাড়া একটি পরিবর্তে একটি বর্গ-ম্যাট্রিক্স সীমিত ছিল Nদ্বারা Mম্যাট্রিক্স। সুতরাং আমি তার কোডটি পিছনে থেকে আমার কোডটি সামান্য পরিবর্তন করেছি for

আমি প্রথমে নীচের সারিটি এবং সর্বশেষতম ঘরটি থেকে পিছনের দিকে ডানদিকে কলামটি যোগ করছি। সুতরাং আসুন চ্যালেঞ্জের উদাহরণ ম্যাট্রিক্স ব্যবহার করুন:

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

শেষ সেলটি একই থাকে। : নীচে সারির দ্বিতীয় গত সেল সমষ্টি হয়ে 1+1 = 2, এবং ডানদিকের কলামের দ্বিতীয় গত কক্ষের জন্য একই: 1+7 = 8। আমরা এটি চালিয়ে যাচ্ছি, সুতরাং এখন ম্যাট্রিক্স এর মতো দেখাচ্ছে:

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

এটি করার পরে, আমরা অবশিষ্ট সমস্ত সারি নীচে থেকে উপরে এবং ডানে বামে একের পর এক দেখি (শেষ কলাম / সারি বাদে) এবং নীচের অংশে এবং এর ডানদিকে প্রতিটি কক্ষ অনুসন্ধান করি কোনটি ছোট।

সুতরাং নম্বরযুক্ত ঘরটি 6হয়ে যায় 8, কারণ 2নীচে এটি এর 8ডানদিকের চেয়ে ছোট । তারপরে আমরা এর 1পাশের দিকে (বাম দিকে) তাকিয়ে থাকি এবং এটিও করি। এটি 1হয়ে যায় 5, কারণ 4নীচে এটি এর 8ডান থেকে ছোট ।

সুতরাং আমরা দ্বিতীয় থেকে শেষ সারিতে শেষ করার পরে, ম্যাট্রিক্সটি দেখতে এরকম দেখাচ্ছে:

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

এবং আমরা পুরো ম্যাট্রিক্সের জন্য এটি চালিয়ে যাচ্ছি:

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

এখন খুব প্রথম সেলটিতে আমাদের ফলাফল থাকবে যা 8এই ক্ষেত্রে।

কোড ব্যাখ্যা:

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

Answer 14

ব্র্যাচল্যাগ , 26 25 বাইট

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

এটি অনলাইন চেষ্টা করুন!

-1 বাইট কারণ কাটা প্রয়োজনীয় নয় - আপনি খালি তালিকার শীর্ষস্থানীয় নিতে পারবেন না

এটি গল্ফ করার জন্য সম্ভবত অনেক জায়গা আছে তবে আমার ঘুম দরকার।

পদ্ধতির আউটপুট জন্য প্রতি মূল্য চেষ্টা নিচে boils, ক্ষুদ্রতম প্রথম, ( ∧≜.) পর্যন্ত পথ (খুঁজে পাওয়া যেতে পারে b|bᵐ) নীচের অংশে ডানদিকে কোণায় (থেকে ~g~g) যা সমষ্টি উত্পাদন করে ( hhX&...↰+↙X)।

Answer 15

জাভা (জেডিকে) , 223 বাইট

ইনটগুলির 2D তালিকা হিসাবে ইনপুট নেয়।

import java.util.*;অন্তর্ভুক্ত জন্য অতিরিক্ত 19 বাইট ।

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

এটি অনলাইন চেষ্টা করুন!

---

কিভাবে এটা কাজ করে

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
}

Answer 16

পাইথন 2 , 86 বাইট

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,()))

এটি অনলাইন চেষ্টা করুন!

যদি Bস্থানান্তর হয় A, তবে সমস্যার সংজ্ঞাটি বোঝায় f(A)==f(B)।

A[1:]অ্যারেটি Aতার শীর্ষ সারিটি অনুপস্থিত। zip(*A[1:])অ্যারেটি Aতার বামতম কলামটি হারিয়েছে এবং স্থানান্তরিত হয়েছে। sum(sum(A,()))সমস্ত উপাদানের যোগফল A।

যদি Aকেবল একটি একক কলাম বা একক সারি থাকে তবে কেবল একটি পাথ রয়েছে, সুতরাং এতে fসমস্ত উপাদানগুলির যোগফল প্রদান করে A; অন্যথায় আমরা recurse এবং এর সমষ্টি আসতে A[0][0]ছোট + fএর Aশীর্ষ সারিতে অনুপস্থিত এবং fএর Aবামদিকের কলামের অনুপস্থিত।