Bei einem Quadrat aus positiven, natürlichen Zahlen findet ein Programm einen horizontalen und einen vertikalen Pfad, wobei die Summe der Zahlen maximal ist. Ein horizontaler Pfad geht von der ersten bis zur letzten Spalte und muss seine Spaltenposition in jedem Schritt um eins erhöhen. Ein vertikaler Pfad geht von der ersten bis zur letzten Zeile und muss seine Zeilenposition in jedem Schritt um eins erhöhen. Außerdem kann die Zeilenposition in einem horizontalen Pfad gleich bleiben oder sich in beiden Richtungen um eins ändern, ebenso für vertikale Pfade.

Zur Veranschaulichung kann Folgendes ein gültiger Pfad sein:

Der folgende Pfad ist ungültig, da er rückwärts verläuft (und an einigen Stellen in derselben Zeile verbleibt):

Der folgende Pfad wäre ebenfalls ungültig, da er die Zeilenposition in einem einzigen Schritt um mehr als eins ändert:

Hinweis: Die Lösung sollte in einer akzeptablen Zeit ausgeführt werden.

Eingang

Bei der Standardeingabe werden n Eingabezeilen mit jeweils n durch Leerzeichen getrennten positiven Ganzzahlen angegeben. 2 ≤ n ≤ 40. Jede Zeile wird durch einen Zeilenumbruch abgeschlossen. Die Zahlen sind klein genug, dass die maximale Summe in eine 32-Bit-Ganzzahl mit Vorzeichen passt.

Ausgabe

Die maximale Summe der horizontalen und vertikalen Pfade (in dieser Reihenfolge), die durch ein einzelnes Leerzeichen getrennt sind.

Probeneingabe 1

1 2
1 2

Beispielausgabe 1

3 4

Probeneingabe 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

Beispielausgabe 2

37 35

Probeneingabe 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

Beispielausgabe 3

4650 4799

Zu Ihrer Bequemlichkeit haben wir einige Testfälle in Bash (dank Ventero ) und PowerShell vorbereitet, über die Sie Ihr Programm ausführen können. Aufruf ist:, <test> <command line>also sowas wie ./test python paths.pyoder ./test.ps1 paths.exe. Habe Spaß :-)

GolfScript - 49 Nabb verbesserte Zeichen

51 Zeichen
50 absolut notwendige Zeichen + 3 Faulpelze, die nur die Aufgabe von 1 56 meist redundanten Zeichen erfüllten

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

51 Lösung:

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

53 Lösung:

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

Die Methode arbeitet auf zwei Zeilen gleichzeitig, wobei eine die an jedem Punkt maximal erreichten Summen und eine die nächste Zeile enthält.

a / 14: Für jedes Ergebnis zweimal wiederholen.
8: Nehmen Sie die erste Zeile vom Eingang und schalten Sie sie hinter das Eingangsarray, dies ist jetzt der erste Satz von Höchstsummen.
b / 13: Durchlaufen Sie jede verbleibende Zeile im Array.
9: Setzen Sie 0 am Anfang der Höchstsummen.
c / 12: Iteriere über jedes Element der Zeile.
10: Erstellen Sie eine Kopie der maximalen Summen, wobei das erste Element entfernt wird.
11: Nimm die ersten 3 Elemente der maximalen Summe, sortiere sie und addiere das größte zum aktuellen Element der Linie.

56 Lösung:

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

1: Von der Eingabe bis zum Array von Arrays mit 9 Zeichen hätte es eigentlich mit nur 1 getan werden können, aber ich habe diesen Schlüssel gebrochen, damit dies getan werden muss.
2: 4 Zeichen, um eine transponierte Kopie zu erstellen.
3: Array von 99 0s in 5 Zeichen, es könnte wahrscheinlich intelligenter gemacht werden, aber ich rauche zu viel Gras, um herauszufinden, wie.
4: Übermäßig komplizierte Doppelschleife, die jedes einzelne Element der Eingabe durchläuft und Fuzzy-Logik oder ähnliches ausführt, um das Ergebnis zu erzielen. Nabb wird wahrscheinlich in ungefähr 3½ Zeichen etwas Äquivalentes machen.
5: Jetzt ist das Ergebnis da, in einem Array, das heißt, dieses alberne Stück Code ist nur da, um es rauszuholen (und ein Stück Reste zu verschwenden (und das Ergebnis an die richtige Stelle zu bringen)).
6: Dies ist ein Befehl, der so einfach ist, dass seine Zeichenanzahl in einer optimalen Lösung wahrscheinlich negativ wäre. 7: Zu diesem Zeitpunkt ist das Programm wirklich fertig, aber aufgrund der Schlamperei im vorhergehenden Code ist die Ausgabe in der falschen Reihenfolge und es fehlt ein Leerzeichen.

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)

Ich lehne es ab, IO zu machen, was meine Punktzahl dramatisch verringert. Besteht alle Tests im Testkabelbaum ( funktioniert jedoch nur, wenn die Eingabe wie im Testkabelbaum mit einem Zeilenende endet).

Ich habe die Behandlung für Windows-Zeilenenden entfernt, da Chris vorgeschlagen hat, dass dies nicht notwendig ist. Die Multi-Plattform-Version hätte a=:".;._2 toJ(1!:1)3als erste Zeile.

Erläuterung:

• fgibt das Lösungspaar durch normalen Aufruf von p und transponierte Eingabe ( |:) an.
• pNimmt das Maximum ( >./) der Zeilensummen aus der Anwendung czwischen den einzelnen Zeilen ( c/)
• cdauert zwei Zeilen (x und y). Es addiert x zu y, wobei y um 1 Zelle nach oben ( 1|.!.0 y) und y um 1 Zelle nach unten ( _1|.!.0 y) verschoben wird . Dann werden die Maximalwerte der drei Alternativen für jede Zeile verwendet. ( >./). Der Rest ist Rang - ich bin nicht sicher, ob ich es richtig mache.

Haskell: 314 notwendige Zeichen

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

Hinweis: Dies erfordert das Modul Data.Vector . Ich bin nicht sicher, ob es in der Haskell-Plattform enthalten ist oder nicht.

Ungolfed-Version:

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

Bei dieser Lösung wird Faulheit in Verbindung mit Data.Vector zum Speichern verwendet. Für jeden Punkt wird die Lösung für den maximalen Pfad von diesem bis zum Ende berechnet, dann in der Zelle von Vector gespeichert mund bei Bedarf wiederverwendet.

Ruby 1.9, 155 Zeichen

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

Einfache Lösung, die alle Testfälle besteht.

Haskell, 154 Zeichen

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

• Bearbeiten: (155 -> 154) hat die Funktion umgeklappt

J, ^{109 + 10 =} 119 Zeichen

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

Laufen mit tr:

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

Wie in J üblich, ist der größte Teil des Codes für die Ein- / Ausgabe bestimmt. Der "tatsächliche" Code ist 65 Zeichen:

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

Besteht alle Testfälle

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

Wenn ich nur einen vertikalen oder horizontalen kürzesten Pfad berechnen würde,
könnte dies stattdessen an Ort und Stelle erfolgen und etwa ein Drittel der Bytes einsparen.

Python, 204 Zeichen

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)