अधिकतम पथ ढूँढना

12

सकारात्मक के एक वर्ग को देखते हुए, प्राकृतिक संख्याएं एक प्रोग्राम लिखती हैं, एक क्षैतिज और एक ऊर्ध्वाधर मार्ग ढूंढती हैं, जिसमें संख्याओं का योग होता है और साथ ही वे अधिकतम होते हैं। एक क्षैतिज पथ पहले कॉलम से आखिरी तक जाता है और प्रत्येक चरण में इसके कॉलम की स्थिति को एक से बढ़ाना होता है। एक ऊर्ध्वाधर पथ पहली पंक्ति से अंतिम तक जाता है और प्रत्येक चरण में इसकी पंक्ति की स्थिति को एक से बढ़ाना होता है। इसके अलावा क्षैतिज मार्ग में पंक्ति की स्थिति समान हो सकती है या दोनों दिशाओं में एक-एक करके बदल सकती है, इसी तरह ऊर्ध्वाधर रास्तों के लिए भी।

वर्णन करने के लिए, निम्नलिखित एक वैध मार्ग हो सकता है:

मान्य पथ का चित्रण

निम्न पथ अमान्य होगा, क्योंकि यह पीछे की ओर बढ़ता है (और कुछ स्थानों पर एक ही पंक्ति पर रहता है):

अमान्य पथ का चित्रण

निम्न पथ समान रूप से अमान्य होगा, क्योंकि यह एक ही चरण में एक से अधिक पंक्ति स्थिति बदलता है:

अमान्य पथ का एक और चित्रण

नोट: समाधान समय की स्वीकार्य मात्रा में चलना चाहिए।

इनपुट

n के साथ इनपुट की तर्ज n अंतरिक्ष से अलग किए धनात्मक पूर्णांक प्रत्येक मानक इनपुट पर दिया जाता है। 2 inated n ≤ 40. हर लाइन को एक लाइन ब्रेक द्वारा समाप्त किया जाता है। संख्या काफी छोटी है कि अधिकतम राशि 32-बिट हस्ताक्षरित पूर्णांक में फिट होती है।

उत्पादन

क्षैतिज और ऊर्ध्वाधर पथ के अधिकतम योग (उस क्रम में) एक ही स्थान से अलग हो जाते हैं।

नमूना इनपुट 1

1 2
1 2

नमूना उत्पादन 1

3 4

नमूना इनपुट 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

नमूना उत्पादन 2

37 35

नमूना इनपुट 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

नमूना आउटपुट 3

4650 4799

आपकी सुविधा के लिए हम में कुछ परीक्षण मामलों तैयार किया है बैश (करने के लिए धन्यवाद Ventero ) और PowerShell जो आप के माध्यम से अपने कार्यक्रम चला सकते हैं। मंगलाचरण है: <test> <command line>तो, कुछ इस तरह ./test python paths.pyया ./test.ps1 paths.exe। मज़े करो :-)

code-golf 
— एक छोटा सा सिक्का
स्रोत
@ जॉय: हमारी प्रतियोगिता में पिछले साल हमने जो प्रयोग किया था, उससे थोड़ा बदला हुआ कार्य :)
— जॉय
bashपरीक्षण स्क्रिप्ट के लिए +10 ! मेरी इच्छा है कि सभी कोड गोल्फ इस तरह के साथ आए।
— माउंटनवार्क मार्क 24'11
@MtnViewMark: हम कोशिश करते हैं :-) व्यक्तिगत रूप से मुझे उन कार्यों से नफरत है जिन्हें पोस्ट किए जाने के बाद बहुत अधिक स्पष्टीकरण की आवश्यकता होती है और मैं आमतौर पर अपनी स्वयं की परीक्षण स्क्रिप्ट वैसे भी लिखता हूं क्योंकि मुझे यह जानने की आवश्यकता है कि जब गोल्फ के लिए प्रयास एक प्रतिगमन का परिचय देता है। इसके अलावा मैंने देखा है कि कुछ लोग स्पष्ट रूप से गलत उत्तर पोस्ट करते हैं। टेस्ट केस सभी को एक ही लाइन पर लाने में मदद करते हैं। प्रत्येक कार्य के लिए सिर्फ एक बार के हैकॉजर के बजाय हर कार्य के लिए काम करने की सुविधा होना स्पष्ट रूप से बेहतर होगा, लेकिन हम अभी तक वहां नहीं हैं;;
— जॉय

जवाबों:

6

GolfScript - 49 एनएबीबी वर्णों को बढ़ाया

५१ अक्षर
५० सख्ती से और पूरी तरह से आवश्यक अक्षर + ३ स्लैकर्स जो केवल ५६ ज्यादातर बेमानी पात्रों का काम करते थे

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

51 समाधान:

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

53 समाधान:

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

यह विधि एक समय में दो लाइनों पर काम करती है, जिसमें से प्रत्येक अधिकतम बिंदु पर पहुंचती है, और अगली पंक्ति में एक होती है।

a / 14: दो बार दोहराएं, प्रत्येक परिणाम के लिए एक बार।
8: इनपुट से पहली लाइन लें और इसे इनपुट ऐरे के पीछे स्विच करें, यह अब अधिकतम रकम का पहला सेट है।
बी / 13: सरणी में प्रत्येक शेष रेखा पर Iterate।
9: अधिकतम रकम की शुरुआत में 0 रखो।
c / 12: पंक्ति के प्रत्येक तत्व पर Iterate।
10: हटाए गए पहले तत्व के साथ अधिकतम रकम की एक प्रति बनाएँ।
11: अधिकतम रकम के पहले 3 तत्वों को लें, उन्हें क्रमबद्ध करें और लाइन के वर्तमान तत्व में सबसे बड़ा जोड़ दें।

56 समाधान:

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

1: 9 अक्षरों में सरणियों के इनपुट से, वास्तव में यह सिर्फ 1 के साथ किया जा सकता था, लेकिन मैंने उस कुंजी को तोड़ दिया, इसलिए यह करना होगा।
2: 4 वर्ण केवल एक प्रतिलिपि बनाई गई प्रतिलिपि बनाने के लिए।
३: ५ अक्षरों में ९९ ० का अंश, यह संभवत: एक तरह से होशियार फैशन हो सकता है, लेकिन मैं यह जानने के लिए बहुत अधिक धूम्रपान करता हूं।
4: अत्यधिक जटिल डबल लूप जो इनपुट के हर एक तत्व पर पुनरावृति करता है और परिणाम का उत्पादन करने के लिए कुछ फजी लॉजिक या ऐसा कुछ करता है। लगभग 3½ वर्णों में नायब संभवत: कुछ समान करेगा।
5: अब तक परिणाम एक सरणी के अंदर है, जो है, कोड का यह मूर्खतापूर्ण टुकड़ा बस इसे बाहर निकालने के लिए है (और बचे हुए टुकड़े को जोड़ दें (और परिणाम को जगह में बदल दें)।
6: यह एक कमांड इतनी सरल है कि इसकी वर्ण गणना शायद एक इष्टतम समाधान में नकारात्मक होगी। 7: इस बिंदु पर कार्यक्रम वास्तव में किया जाता है, लेकिन पूर्ववर्ती कोड में ढिलाई के कारण आउटपुट गलत क्रम में है और इसमें जगह की कमी है, इसलिए यहां नाली के नीचे कुछ और बिट्स जाते हैं।

— aaaaaaaaaaaa
स्रोत
आह, मैंने केवल आकस्मिक रूप से इनपुट को एक नई रेखा के साथ समाप्त नहीं होने दिया। मुझे आश्चर्य है कि यह वास्तव में आंशिक रूप से काम करता है, उस तरह का सामान आमतौर पर पूरी तरह से एक गोल्फस्क्रिप्ट कार्यक्रम को गड़बड़ कर देता है।
— आआआआआआआआआआ आआआआआ आआआआआआ
1
ठीक लगता है, हालाँकि आपको {}*इसके बजाय उपयोग करना चाहिए (\{}%।
— नब्ब
हाँ जो समझ में आता है, धन्यवाद।
— आआआआआआआ आआआआआ आआआआआ
3

जे, 91 ९ ५

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)

मैं अपने स्कोर को नाटकीय रूप से कम करते हुए, आईओ करने के लिए मना करता हूं। परीक्षण हार्नेस में सभी परीक्षण पास करता है (हालांकि यह केवल तभी काम करता है जब इनपुट लाइन समाप्त होने के साथ समाप्त हो जाए, जैसा कि परीक्षण हार्नेस में है)।

मैंने विंडोज लाइन एंडिंग के लिए हैंडलिंग को हटा दिया, क्योंकि क्रिस ने सुझाव दिया कि यह आवश्यक नहीं था। बहु-मंच संस्करण a=:".;._2 toJ(1!:1)3पहली पंक्ति के रूप में होगा ।

स्पष्टीकरण:

  • fपी को सामान्य रूप से कॉल करके और ट्रांसपोज़्ड ( |:) के साथ समाधान जोड़ी देता है ।
  • pप्रत्येक पंक्ति के बीच >./आवेदन करने से पंक्ति-योग का अधिकतम ( ) लेता है c( c/)
  • cदो पंक्तियाँ लेता है (x और y)। यह y में से प्रत्येक में x जोड़ता है, y ने 1 सेल ( 1|.!.0 y) को स्थानांतरित किया, और y ने 1 सेल ( _1|.!.0 y) को नीचे स्थानांतरित कर दिया । फिर यह प्रत्येक पंक्ति के लिए तीन विकल्पों का अधिकतम भाग लेता है। ( >./)। बाकी रैंक [sic] है - मुझे यकीन नहीं है कि मैं इसे सही कर रहा हूं।
— जेसी मिलिकन
स्रोत
4
बिल्कुल सही, अपने स्कोर को कम करने। -1
— आआआआ आआआआआ आआआआआआआ
@eBusiness: क्या आपको यकीन है कि अधूरा समाधान अधूरा समाधान के लिए सही प्रतिक्रिया है?
— जेसी मिलिकन
1
@ जॉय: अपवॉटिंग दूसरा विकल्प नहीं है। मैं उस समय IO करने के लिए बहुत थक गया था, लेकिन मेरा समाधान अन्य J समाधान से इतना अलग है कि मैं वास्तव में इसे किसी भी तरह पोस्ट करना चाहता था। यदि उत्तर को "गैर-भाग लेने" के रूप में चिह्नित करने का एक स्पष्ट तरीका था, या ऐसा कुछ, मेरे पास होगा।
— जेसी मिलिकन
@ जॉय: एक और कारण यह है कि समाधान तय होने पर भी मतों के उलट होने की संभावना नहीं है; मूल उपयोगकर्ता को वापस आना होगा और अपना वोट बदलना होगा। (हटाए गए, एहसास हुआ कि चर्चा कम हुई, और अनिर्धारित। मुझे लगता है कि मैं इसके बजाय "अनुशासित" बैज के लिए शूट करूंगा।)
— जेसी मिलिकन
@ जेसे मिलिकन: हम ऐसा करते हैं। कोई गारंटी नहीं है, लेकिन अगर आप उचित समय के भीतर इस मुद्दे को ठीक करते हैं, तो अधिकांश डाउनवोटर्स को अपने वोटों को रद्द करना चाहिए।
— आआआआआआआआआआआ आआआआ
3

हास्केल: 314 आवश्यक वर्ण

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

नोट: इसके लिए मॉड्यूल Data.Vector की आवश्यकता है । मुझे यकीन नहीं है कि यह हास्केल प्लेटफॉर्म में शामिल है या नहीं।

Ungolfed संस्करण:

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

यह समाधान, संस्मरण के लिए , Data.Vector के साथ मिलकर आलस्य का उपयोग करता है । हर बिंदु के लिए, इसके अंत से अधिकतम पथ के लिए समाधान की गणना की जाती है, फिर वेक्टर की सेल में संग्रहीत किया जाता है mऔर आवश्यकता होने पर पुन: उपयोग किया जाता है।

— जॉय एडम्स
स्रोत
मुझे लगता है कि आप अपने कथन के बाद घुंघराले ब्रेसिज़ को पट्टी कर सकते हैं, यदि आप सभी परिभाषाओं को एक ही पंक्ति में तोड़ते हैं।
— फ्यूजएक्सएक्सएल
2

रूबी 1.9, 155 वर्ण

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

सीधा समाधान जो सभी टेस्टकेस को पास करता है।

— Ventero
स्रोत
2

हास्केल, 154 वर्ण

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
  • संपादित करें: (155 -> 154) इस समारोह में गुना गुना
— MtnViewMark
स्रोत
क्या zipWith3कोड का उपयोग कम होगा ?
— गर्वित हैकेलर
मुझे लगता है कि आप अधिकतम के साथ प्रतिस्थापित कर सकते हैं foldl1 max, जो पात्रों को जोड़ता है लेकिन आपको तहलका 1 और अधिकतम को बाहर करने की अनुमति देता है, जिससे पात्रों को बचाना चाहिए।
— गर्वित हैकेलर
maximum.foldl1, max, और max--vs-- f=foldl1;m=max;, f m.f, m, और m। - या 20 बनाम 22. तो, नहीं, यह नहीं बचाता है।
— मटनवार्कर
सही। और मुझे याद आया कि मोनोमोर्फिज्म प्रतिबंध लिखना बंद कर देगा m=max। ZipWith3 के बारे में क्या?
— गर्वित हैकेलर
1

जे, 109 + 10 = 119 चार्ट

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

साथ चलाएं tr:

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

जे में हमेशा की तरह, अधिकांश कोड इनपुट / आउटपुट के लिए है। "वास्तविक" कोड 65 वर्ण है:

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

सभी परीक्षण मामलों को पारित करता है

— Eelvex
स्रोत
तो हमें एक समाधान के साथ फिर से जेबी की आवश्यकता है जो 10 वर्णों के पार्सिंग को कम करता है? ;-)
— जोय
@ जोय मैं छुट्टी पर हूँ, मेरे पास मुश्किल से इंटरनेट का उपयोग है; गोल्फ के लिए ज्यादा समय नहीं; ;-)
— JB
क्या आप मुझे बता सकते हैं कि आप सीधे मैक्सपथ कैसे चल रहे हैं।
— जेसी मिलिकन
@ जेजे: * निक्स में कुछ #!/usr/bin/env jconsoleफाइल के ऊपर रखा और निष्पादन योग्य झंडा सेट करें।
— बारहवीं
1

अजगर, 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)

यदि मुझे केवल एक ऊर्ध्वाधर या क्षैतिज सबसे छोटे पथ की गणना करनी थी, तो
इसे बाइट्स के लगभग एक तिहाई की बचत के बजाय इन-प्लेस किया जा सकता था।

— hallvabo
स्रोत
1

पायथन, 204 वर्ण

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)
— कीथ रान्डेल
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.