Cho một hình vuông có số dương, các số tự nhiên viết một chương trình tìm một đường ngang và dọc với tổng các số dọc theo chúng là cực đại. Một đường ngang đi từ cột đầu tiên đến cột cuối cùng và phải tăng vị trí cột của nó thêm một trong mỗi bước. Một đường thẳng đứng đi từ hàng đầu tiên đến hàng cuối cùng và phải tăng vị trí hàng của nó thêm một trong mỗi bước. Hơn nữa, vị trí hàng trong một đường ngang có thể giữ nguyên hoặc thay đổi theo một hướng, tương tự như vậy đối với các đường thẳng đứng.

Để minh họa, sau đây có thể là một đường dẫn hợp lệ:

Đường dẫn sau sẽ không hợp lệ, vì nó lùi lại (và vẫn nằm trên cùng một hàng ở một số nơi):

Đường dẫn sau sẽ không hợp lệ như nhau, vì nó thay đổi vị trí hàng nhiều hơn một bước trong một bước:

Lưu ý: Giải pháp nên chạy trong một khoảng thời gian chấp nhận được.

Đầu vào

n dòng đầu vào với n số nguyên dương được phân tách bằng dấu cách được đặt trên đầu vào tiêu chuẩn. 2 ≤ n 40. Mỗi dòng được kết thúc bằng ngắt dòng. Các số này đủ nhỏ để tổng tối đa khớp với số nguyên có chữ ký 32 bit.

Đầu ra

Các khoản tiền tối đa của các đường ngang và dọc (theo thứ tự đó) cách nhau bởi một khoảng trắng.

Mẫu đầu vào 1

1 2
1 2

Sản lượng mẫu 1

3 4

Mẫu đầu vào 2

1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
2 1 4 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 4 1 3 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 4 1 2 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 5 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

Sản lượng mẫu 2

37 35

Mẫu đầu vào 3

683 671 420 311 800 936
815 816 123 142 19 831
715 588 622 491 95 166
885 126 262 900 393 898
701 618 956 865 199 537
226 116 313 822 661 214

Sản lượng mẫu 3

4650 4799

Để thuận tiện cho bạn, chúng tôi đã chuẩn bị một vài trường hợp thử nghiệm trong bash (nhờ Ventero ) và PowerShell mà bạn có thể chạy chương trình của mình thông qua. Cầu nguyện là : <test> <command line>, vì vậy một cái gì đó như ./test python paths.pyhoặc ./test.ps1 paths.exe. Chúc vui vẻ :-)

GolfScript - 49 nhân vật được tăng cường Nabb

51 ký tự
50 ký tự nghiêm ngặt và hoàn toàn cần thiết + 3 ký tự chậm chạp chỉ thực hiện công việc của 1
56 nhân vật chủ yếu là thừa

n%{~]}%.zip{{0@+\{\.1>\3<$-1=@+}%\;}*$-1=\}2*' '@

51 giải pháp:

n%{~]}%.zip{(\{0@+\{\.1>\3<$-1=@+}%\}%;$-1=\}2*' '@

53 giải pháp:

n/{~]}%);.zip{(\{0@+\{\.1>\3<$-1=@+}%\}%;$-1=\}2*' '@
             a8_b9___c10___11______12 13      14_

Phương thức này hoạt động trên hai dòng tại một thời điểm, một dòng chứa tổng tối đa đạt được tại mỗi điểm và một dòng chứa dòng tiếp theo.

a / 14: Lặp lại hai lần, một lần cho mỗi kết quả.
8: Lấy dòng đầu tiên từ đầu vào và chuyển nó phía sau mảng đầu vào, đây là bộ tổng tối đa đầu tiên.
b / 13: Lặp lại từng dòng còn lại trong mảng.
9: Đặt 0 vào đầu các khoản tiền tối đa.
c / 12: Lặp lại qua từng phần tử của dòng.
10: Tạo một bản sao của các khoản tiền tối đa với phần tử đầu tiên được loại bỏ.
11: Lấy 3 phần tử đầu tiên của tổng tiền tối đa, sắp xếp chúng và thêm phần tử lớn nhất vào phần tử hiện tại của dòng.

Giải pháp 56:

n/{~]}%);.zip{1,99*\{{\.1>\3<$-1=@+}%0\+\}%;$-1=\}2*' '@
1________2___ 3____ 4______________________5_____ 6_7___

1: Từ đầu vào đến mảng mảng trong 9 ký tự, thực tế nó có thể được thực hiện chỉ với 1, nhưng tôi đã phá vỡ khóa đó vì vậy điều này sẽ phải làm.
2: 4 ký tự chỉ để tạo một bản sao chuyển đổi.
3: Mảng 99 0 trong 5 ký tự, có thể được thực hiện theo cách thông minh hơn, nhưng tôi hút quá nhiều cỏ dại để tìm ra cách.
4: Vòng lặp kép quá phức tạp lặp đi lặp lại trên mọi yếu tố duy nhất của đầu vào và thực hiện một số logic mờ hoặc một cái gì đó tương tự để tạo ra kết quả. Nabb có thể sẽ tạo ra thứ gì đó tương đương với khoảng 3½ ký tự.
5: Đến bây giờ kết quả đã có, bên trong một mảng, đoạn mã ngớ ngẩn này chỉ ở đó để lấy nó ra (và bỏ đi một phần thức ăn thừa (và chuyển kết quả vào vị trí)).
6: Đây là một lệnh đơn giản đến mức số ký tự của nó có thể bị âm trong một giải pháp tối ưu. 7: Tại thời điểm này, chương trình đã thực sự được thực hiện, nhưng do sự chậm chạp trong mã trước đó, đầu ra không đúng thứ tự và thiếu một khoảng trống, vì vậy ở đây sẽ mất thêm một vài bit.

J, 91 95

a=:".;._2(1!:1)3
c=:4 :'>./x+"1|:y,.(1|.!.0 y),._1|.!.0 y'
p=:[:>./c/
(":(p|:a),p a)1!:2(4)

Tôi từ chối làm IO, hạ thấp điểm số của tôi một cách đáng kể. Vượt qua tất cả các thử nghiệm trong khai thác thử nghiệm (mặc dù nó chỉ hoạt động nếu đầu vào kết thúc bằng một kết thúc dòng, như trong khai thác thử nghiệm).

Tôi đã loại bỏ việc xử lý các kết thúc dòng Windows, vì Chris cho rằng điều đó là không cần thiết. Phiên bản đa nền tảng sẽ có a=:".;._2 toJ(1!:1)3dòng đầu tiên.

Giải trình:

• fđưa ra cặp giải pháp bằng cách gọi p bình thường và với đầu vào được chuyển ( |:).
• plấy tối đa ( >./) của tổng số hàng từ áp dụng cgiữa mỗi hàng ( c/)
• cmất hai hàng (x và y). Nó thêm x vào mỗi y, y chuyển lên 1 ô ( 1|.!.0 y) và y chuyển xuống 1 ô ( _1|.!.0 y). Sau đó, nó mất tối đa của ba lựa chọn thay thế cho mỗi hàng. ( >./). Phần còn lại là thứ hạng [sic] - Tôi không chắc liệu mình có làm đúng hay không.

Haskell: 314 ký tự cần thiết

import Data.Vector(fromList,generate,(!))
import List
l=fromList
x=maximum
g=generate
p a=show$x[m!i!0|i<-[0..h-1]]where{
w=length$head a;h=length$a;n=l$map l a;
m=g h$ \i->g w$ \j->n!i!j+x[k#(j+1)|k<-[i-1..i+1]];
i#j|i<0||i>=h||j>=w=0|1>0=m!i!j;}
q a=p a++' ':(p.transpose)a
main=interact$q.map(map read.words).lines

Lưu ý: điều này đòi hỏi mô-đun Data.Vector . Tôi không chắc liệu nó có được bao gồm trong nền tảng Haskell hay không.

Phiên bản bị đánh cắp:

import Data.Vector(fromList,generate,(!))
import Data.List

-- horizontal; we use transpose for the vertical case
max_path :: [[Integer]] -> Integer
max_path numbers = maximum [m ! i ! 0 | i <- [0..h-1]] where
    w = length (head numbers)
    h = length numbers
    n = fromList $ map fromList numbers
    m = generate h $ \i -> generate w $ \j ->
        n ! i ! j + maximum [f i' (j+1) | i' <- [i-1..i+1]]
    f i j | i < 0 || i >= h || j >= w = 0
    f i j = m ! i ! j

max_paths :: [[Integer]] -> String
max_paths numbers = (show . max_path) numbers ++ " " ++
                    (show . max_path . transpose) numbers

main = interact $ max_paths . map (map read . words) . lines

Giải pháp này sử dụng sự lười biếng, song song với Data.Vector , để ghi nhớ. Đối với mọi điểm, giải pháp cho đường dẫn tối đa từ điểm cuối đến điểm cuối được tính toán, sau đó được lưu trữ trong ô của Vector mvà được sử dụng lại khi cần.

Ruby 1.9, 155 ký tự

f=->t{(1...l=t.size).map{|a|l.times{|b|t[a][b]+=t[a-1][(b>0?b-1:0)..b+1].max}};t[-1].max};q=[*$<].map{|a|a.split.map &:to_i};puts [f[q.transpose],f[q]]*" ""

Giải pháp đơn giản mà vượt qua tất cả các testcase.

Haskell, 154 ký tự

import List
z=zipWith
f=show.maximum.foldl1(\a->z(+)$z max(tail a++[0])$z max(0:a)a)
q a=f(transpose a)++' ':f a
main=interact$q.map(map read.words).lines

• Chỉnh sửa: (155 -> 154) nội dung chức năng được gấp lại

J, ^{109 + 10 =} 119 ký tự

y=:0".(1!:1)3
N=:%:#y
y=:y$~N,N
r=:(((1&{)(+(3>./\0,0,~]))(0&{)),2&}.)^:(<:N)
(":([:>./"1([:r|:),r)y)(1!:2)4

Chạy với tr:

cat << EOF | tr \\n ' ' | ./maxpath.ijs

Như thường lệ trong J, hầu hết các mã dành cho đầu vào / đầu ra. Mã "thực tế" là 65 ký tự:

r=:(((1&{)(+(3>./\0,0,~]))(0&{)),2&}.)^:(<:#y)
([:>./"1([:r|:),r)y

Vượt qua tất cả các trường hợp thử nghiệm

Con trăn, 149

import sys
def f(g,t=[]):
 for r in g:t=[int(e)+max(t[i-1:i+2]+[0])for i,e in enumerate(r)]
 print max(t),
g=map(str.split,sys.stdin)
f(zip(*g)),f(g)

Nếu tôi chỉ tính toán một con đường ngắn nhất theo chiều dọc hoặc ngang,
thì nó có thể được thực hiện tại chỗ thay vào đó, tiết kiệm khoảng một phần ba byte.

Con trăn, 204 ký tự

import sys
I=sys.stdin.read()
n=I.count('\n')
A=map(int,I.split())
R=range(n)
X=lambda h,a:[a[i]+max(([0]+h)[i:i+3])for i in R]
h=v=[0]*n
for i in R:h=X(h,A[i*n:i*n+n]);v=X(v,A[i::n])
print max(v),max(h)