अधिकतम उप-सरणी

21

किसी दिए गए सरणी के "अधिकतम उप-सरणी" को "एक (लगातार) उप-सरणी के रूप में परिभाषित करें जिसमें सबसे बड़ी राशि हो"। ध्यान दें कि कोई "गैर-शून्य" आवश्यकता नहीं है। आउटपुट जो योग।

यदि संभव हो तो अपने कोड का विवरण दें।

नमूना इनपुट 1:

1 2 3 -4 -5 6 7 -8 9 10 -11 -12 -13 14

नमूना आउटपुट 1: 24

विवरण 1:
सबसे बड़ी राशि को काटकर 6 7 -8 9 10और संक्षेप में निकाला जाता है।

नमूना इनपुट 2: -1 -2 -3
नमूना आउटपुट 2: 0
विवरण 2: यह सरल है :) एक खाली उपश्रेणी "सबसे बड़ी" है।

आवश्यकता:

  • स्टडिन को छोड़कर कुछ भी न पढ़ें, और आउटपुट को स्टडआउट जाना चाहिए।
  • मानक कमियां प्रतिबंध लागू होते हैं।

रैंकिंग: सबसे छोटा कार्यक्रम इस कोड-गोल्फ को जीतता है ।

code-golf  array-manipulation 
— iBug
स्रोत
5
एक प्रोग्राम लिखें जो यथासंभव छोटा हो। मैं इस आवश्यकता को दूर करने की सलाह दूंगा क्योंकि इसके लिए हमें अपनी भाषा में हर संभव कार्यक्रम की जाँच करनी होगी और सुनिश्चित करना होगा कि हम सबसे कम प्रयोग कर रहे हैं।
— ओकेक्स
आवश्यकता 2 भी अस्पष्ट है। क्या इसका मतलब पुस्तकालयों से है? कस्टम लाइब्रेरी? कार्यक्रम आउटसोर्सिंग? उत्तरार्द्ध पहले से ही मानक खामियों से निषिद्ध है।
— लीक
14
स्टडिन के अलावा कुछ भी न पढ़ें, और स्टडआउट के अलावा कहीं भी न लिखें। - क्यूं कर?
— श्री Xcoder
2
बहुत समान है , संभवतः एक डुबकी। साथ ही बहुत समान ।
— xnor

जवाबों:

6

पायथन 3 , 61 बाइट्स

a=b=0
for x in eval(input()):a=max(x,a+x);b=max(a,b)
print(b)

इसे ऑनलाइन आज़माएं!

विकिपीडिया से एल्गोरिथम चोरी ।

— लीक नन
स्रोत
3
यह पायथन 2 में 7 बाइट्स छोटा होगा (यदि आप अभी भी प्राचीन भाषा के संस्करणों का उपयोग करते हैं)
— श्री एक्सकोडर
4

पायथ , 8 बाइट्स

eS+0sM.:

इसे ऑनलाइन आज़माएं!

कैसे?

ईएस + 0 एस एम।: क्यू - क्यू निहित है, जिसका अर्थ है इनपुट। मान लीजिए कि यह [-1, -2, -3] है।

      :: - सभी सन्निहित गैर-रिक्त उपविज्ञानी। हमारे पास [[-1], [-2], [-3], [-1, -2], [-2, -3], [-1, -2, -3]] हैं।
    sM - प्रत्येक सबलिस्ट का योग प्राप्त करें। [-1, -2, -3, -3, -5, -6]
  +0 - योग सूची में 0 जोड़ दें। [0, -1, -2, -3, -3, -5, -6]
ईएस - अधिकतम तत्व। एस हमें [-6, -5, -3, -3, -2, -1, 0] देता है, जबकि ई रिटर्न 0, अंतिम तत्व है।
— श्री Xcoder
स्रोत
4

05AB1E , 4 बाइट्स

Ό0M

इसे ऑनलाइन आज़माएं!

-1 अदनान को धन्यवाद ।

— आउटगोल्फर को एरिक करें
स्रोत
ओकेक्स के जवाब के साथ ही टिप: ÎŒOM4 बाइट्स के लिए काम करना चाहिए।
— अदनान
@ अदनान धन्यवाद मुझे लगा कि केवल "1 और इनपुट" बिलिन है ... प्रतीक्षा करें ... क्या यह है? क्या उन्हें संघटित या कुछ नहीं होना चाहिए?
— आउटगॉल्फ
नहींं, Mढेर के चपटा संस्करण में सबसे बड़ी संख्या के लिए खोज करता है।
— अदनान
@ अदनान ठीक है ... यह मेरे लिए समाचार है
— एरिक द आउटग्राफर
3

सी ++, 197 195 187 बाइट्स

-10 बाइट्स Zacharý को धन्यवाद

#include<vector>
#include<numeric>
int f(std::vector<int>v){int i=0,j,t,r=0;for(;i<v.size();++i)for(j=i;j<v.size();++j){t=std::accumulate(v.begin()+i,v.begin()+j,0);if(t>r)r=t;}return r;}
— HatsuPointerKun
स्रोत
क्या आप लूप के लिए पहले के बाद ब्रेसिज़ निकाल सकते हैं?
— ज़ाचारि
इसके अलावा, आपके पास lऔर hरास्ते क्यों हैं ?
— ज़ाचारि
@ Zacharý l और h उप सरणी के आरंभ और अंत सूचकांक के लिए था
— HatsuPointerKun
3

आर , 54 बाइट्स

a=b=0;for(x in scan()){a=max(x,a+x);b=max(a,b)};cat(b)

इसे ऑनलाइन आज़माएं!

से लिया गया एल्गोरिथम: अधिकतम सबर्रे समस्या

आर , 65 बाइट्स

y=seq(x<-scan());m=0;for(i in y)for(j in y)m=max(m,sum(x[i:j]));m

इसे ऑनलाइन आज़माएं!

  • xस्टडिन से पढ़ें ।
  • के yसूचकांक के रूप में सेट करें x।
  • सभी संभव nonempty सबसेट पर दो बार Iterate।
  • m(प्रारंभ में m=0) के साथ सबसेट की राशि की तुलना करें ।
  • में अधिकतम मूल्य स्टोर करें m।
  • का प्रिंट मूल्य m।

आर , 72 बाइट्स

n=length(x<-scan());m=0;for(i in 1:n)for(j in i:n)m=max(m,sum(x[i:j]));m

इसे ऑनलाइन आज़माएं!

  • xस्टडिन से पढ़ें ।
  • सभी संभव nonempty सबसेट पर एक पूर्ण खोज करें।
  • m(प्रारंभ में m=0) के साथ सबसेट की राशि की तुलना करें ।
  • में अधिकतम मूल्य स्टोर करें m।
  • का प्रिंट मूल्य m।

अन्य असफल विचार

58 बाइट्स

Reduce(max,lapply(lapply(seq(x<-scan()),tail,x=x),cumsum))

63 बाइट्स

Reduce(max,lapply(seq(x<-scan()),function(i)cumsum(tail(x,i))))

72 बाइट्स

m=matrix(x<-scan(),n<-length(x),n);max(apply(m*lower.tri(m,T),2,cumsum))
— djhurio
स्रोत
1
a=b=0काम भी करता है। साथ ही, आपको आउटपुट की प्रिंटिंग को संभालने की आवश्यकता है। जब पूर्ण प्रोग्राम के रूप में चलाया जाता है (तब source) यह कुछ भी प्रिंट नहीं करता है।
— JAD
@JarkoDubbeldam, मैंने जोड़ा है cat(b), लेकिन अगर echo=TRUEइसके साथ खटास है तो bप्रिंटआउट के लिए कॉल करना पर्याप्त है ।
— djhurio
मुझे लगता है कि आर में पूर्ण कार्यक्रम कैसे चलाए जाते हैं इसकी स्पष्ट परिभाषा नहीं है। कमांडलाइन में rscript है, और आर में ही स्रोत है। लेकिन आमतौर पर स्क्रिप्ट चलाने के दौरान झंडे की जरूरत होती है जो कि बाइटकाउंट में शामिल होती है। (मैं व्यक्तिगत रूप से स्कैन के साथ अच्छी तरह से काम करने के लिए rscript प्राप्त करने में कामयाब नहीं हुआ, लेकिन एक और बात है।
— JAD
आप उपयोग कर सकते हैं T=Fके बजाय a=b=0, दो बाइट्स को बचाने के लिए क्योंकि maxविवश होगा bकरने के लिए numeric।
— Giuseppe
3

हास्केल , 28 बाइट्स

maximum.scanl((max<*>).(+))0

इसे ऑनलाइन आज़माएं!

— H.PWiz
स्रोत
अधिकतम हमेशा अंतिम तत्व नहीं होगा जिसमें से लौटा है scanl? तो foldl((max<*>).(+))0??
— Matthias
NVM मैं अपनी गलती देखता हूँ!
— matthias
@matthias यदि आप संपादित इतिहास देखते हैं, तो आप देखेंगे कि मैंने sma गलती की है। :-)
— एच.पी.विज़
2

हास्केल , 41 33 बाइट्स

import Data.List
g=maximum.concatMap(map sum.inits).tails
maximum.(scanl(+)0=<<).scanr(:)[]

इसे ऑनलाइन आज़माएं! लायकोनी को धन्यवाद

— michi7x7
स्रोत
1
अनाम कार्यों को सबमिशन के रूप में अनुमति दी जाती है, इसलिए आप इसे छोड़ सकते हैं g=। concatMapआप के बजाय =<<सूची से उपयोग कर सकते हैं monad: यह ऑनलाइन कोशिश करो! (33 बाइट्स)।
— लकोनी
1

जाप , 11 बाइट्स

£ãY mxÃc rw

इसे ऑनलाइन आज़माएं!

व्याख्या

£ãY mxÃc rw
m@ãY mx} c rw   // Ungolfed
m@     }        // Map the input array by the following function, with Y=index
  ãY            //   Get all subsections in input array length Y
     mx         //   Sum each subsection
         c rw   // Flatten and get max

वैकल्पिक विधि, 11 बाइट्स

@ETHproductions से; ब्रूट फोर्सेस के हुस्क जवाब पर आधारित ।

£sY å+Ãc rw

इनपुट सरणी और संचयी रूप से प्रत्येक के सभी पूंछ हो जाता है। फिर सरणी को समतल करता है और अधिकतम हो जाता है।

इसे ऑनलाइन आज़माएं!

— जस्टिन मेरिनर
स्रोत
अच्छा, बहुत अच्छा। मैंने इस चुनौती को लागू करने की कोशिश नहीं की, जब मैंने इसे पहले देखा था, लेकिन मैंने एक अलग तकनीक के बारे में सोचा और उम्मीद की कि यह लगभग 15 बाइट्स से बाहर आ जाएगी, इसलिए यह बहुत अच्छा है।
— ETHproductions
भूसी के उत्तर को देखते हुए, एक और कुशल तरीका है: £sY å+Ãc rw(11 बाइट्स भी)
— ETHproductions
@ETHproductions बहुत अच्छा है, मैं इस जवाब को एक वैकल्पिक विधि के रूप में जोड़ूंगा। हो सकता है कि कम / समतल के कुछ संयोजन के साथ सुधार किया जा सकता है, वह भी हुस जवाब की तरह?
— जस्टिन
1

रूबी, ६१ ५ ९ 57 बाइट्स

मैंने अभी रूबी को सीखना शुरू किया है, इसलिए मैं यही पर आया हूं।

s=0
p [gets.split.map{|i|s=[j=i.to_i,s+j].max}.max,0].max

मैंने पहली बार इस एल्गोरिथ्म को इस अधूरी किताब के फिनिश संस्करण में देखा । यह पृष्ठ 23 पर बहुत अच्छी तरह से समझाया गया है।

इसे ऑनलाइन आज़माएं!

— Yytsi
स्रोत
1

जावास्क्रिप्ट, 58 बाइट्स

m=Math.max;x=y=>eval("a=b=0;for(k of y)b=m(a=m(a+k,k),b)")

कडेन के एल्गोरिथ्म के गोल्फ जेएस कार्यान्वयन। जितना संभव हो उतना कम बनाया। रचनात्मक सुझावों के लिए खुला!

मैंने इस पद से जो सीखा है: रिटर्न वैल्यू ऑफ़ eval- जब इसकी आखिरी क़िस्मत एक forलूप है - मूल रूप से अंदर मौजूद आखिरी वैल्यू है से लूप के । ठंडा!

EDIT: जस्टिन और हरमन के सुझावों की बदौलत चार बाइट्स बचाए।

— गौरांग टंडन
स्रोत
आप बच सकते हैं returnकी जगह {...;return b;}के साथ eval("...;b")के बाद से eval पिछले बयान देता है।
— जस्टिन मेरिनर
@JustinMariner धन्यवाद! मैं हमेशा यहां कुछ नया सीख रहा हूं :)
— गौरांग टंडन
आप इसे हटाकर दो और बाइट्स निकाल सकते हैं ;b, क्योंकि यह लूप के लिए लौटा है
— हरमन एल
@HermanLauenstein ओह, वाह, धन्यवाद, यह उपयोगी है!
— गौरांग टंडन
0

अजगर 2 , 52 51 बाइट्स

f=lambda l:len(l)and max(sum(l),f(l[1:]),f(l[:-1]))

इसे ऑनलाइन आज़माएं!

— Sisyphus
स्रोत
1
यह संघर्ष (अन्यथा अनावश्यक) आवश्यकता के लिए प्रतीत होता है स्टड के अलावा कुछ भी न पढ़ें, और स्टडआउट को छोड़कर कहीं भी न लिखें।
— श्री एक्सकोडर
0

एपीएल, 31 29 27 बाइट्स

⌈/∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕

इसे ऑनलाइन आज़माएं! (संशोधित है तो यह TryAPL पर चलेगा)

कैसे?

  • ∊∘.{+/W[X/⍨⍺≤X←⍳⍵]}⍨⍳⍴W←⎕ सबवेक्टरों की रकम बनाएँ
  • ⌈/ ज्यादा से ज्यादा
— जाकारी
स्रोत
0

सीजेएम, 24 बाइट्स

q~:A,{)Aew{:+}%}%e_0+:e>

फ़ंक्शन जो इनपुट के रूप में संख्याओं की सरणी लेता है।

इसे ऑनलाइन आज़माएं

q~:A   e# Store array in 'A' variable
,{)Aew e# Get every possible sub-array of the array
{:+}%  e# Sum every sub array
}e_    e# flatten array of sums
0+     e# Add zero to the array
:e>    e# Return max value in array
— geokavel
स्रोत
0

MY , 11 बाइट्स

⎕𝟚35ǵ'ƒ⇹(⍐↵

इसे ऑनलाइन आज़माएं! MY अब TIO पर है! वू हू!

कैसे?

  • ⎕ = मूल्यांकित इनपुट
  • 𝟚 = उप-चिकित्सक
  • 35ǵ'= chr(0x53)(Sum, सम)
  • ƒ = स्ट्रिंग एक MY फ़ंक्शन के रूप में
  • ⇹ = नक्शा
  • ( = लागू करें
  • ⍐ = अधिकतम
  • ↵ = एक नई लाइन के साथ आउटपुट।

0इसके लिए कार्य करने के लिए सम राशि ( रिक्त सरणियों पर) तय की गई थी । उत्पाद भी तय हो गया।

— जाकारी
स्रोत
0

जे, 12 बाइट्स

[:>./@,+/\\.

Zgrep के K समाधान के समान: सभी प्रत्ययों की स्कैन राशि (एक मैट्रिक्स पैदा करता है), रेज़, अधिकतम लें

इसे ऑनलाइन आज़माएं!

ध्यान दें

बहुत अधिक बाइट्स के लिए नहीं, आप एक कुशल समाधान प्राप्त कर सकते हैं (19 बाइट्स गोल्फ):

[: >./ [: ({: - <./)\ +/\
— जोनाह
स्रोत
0

Axiom, 127 बाइट्स

f(a:List INT):Complex INT==(n:=#a;n=0=>%i;r:=a.1;for i in 1..n repeat for j in i..n repeat(b:=reduce(+,a(i..j));b>r=>(r:=b));r)

यह ओ (# ए ^ 3) एल्गो होगा; मैं इसे C ++ एक ... परिणाम से कॉपी करता हूं

(3) -> f([1,2,3,-4,-5,6,7,-8,9,10,-11,-12,-13,14])
   (3)  24
                                                    Type: Complex Integer
(4) -> f([])
   (4)  %i
                                                    Type: Complex Integer
(5) -> f([-1,-2,3])
   (5)  3
                                                    Type: Complex Integer
— RosLuP
स्रोत
0

स्काला, 105 बाइट्स

val l=readLine.split(" ").map(_.toInt);print({for{b<-l.indices;a<-0 to b+2}yield l.slice(a,b+1).sum}.max)

मुझे उप सूची सरणियों को उत्पन्न करने का कोई बेहतर तरीका नहीं मिला ।

— 6infinity8
स्रोत
0

जावा 8, 242 बाइट्स

import java.util.*;v->{List a=new Stack();for(String x:new Scanner(System.in).nextLine().split(" "))a.add(new Long(x));int r=0,l=a.size(),i=l,j,k,s;for(;i-->0;)for(j=l;--j>1;r=s>r?s:r)for(s=0,k=i;k<j;)s+=(long)a.get(k++);System.out.print(r);}

इसे यहाँ आज़माएँ।

STDIN / STDOUT आवश्यकता का उपयोग किए बिना 106 बाइट्स ..>।>

a->{int r=0,l=a.length,i=l,j,k,s;for(;i-->0;)for(j=l;--j>1;r=s>r?s:r)for(s=0,k=i;k<j;s+=a[k++]);return r;}

इसे यहाँ आज़माएँ।

स्पष्टीकरण:

import java.util.*;      // Required import for List, Stack and Scanner

v->{                     // Method with empty unused parameter and no return-type
  List a=new Stack();    //  Create a List
  for(String x:new Scanner(System.in).nextLine().split(" "))
                         //  Loop (1) over the STDIN split by spaces as Strings
    a.add(new Long(x));  //   Add the String converted to a number to the List
                         //  End of loop (1) (implicit / single-line body)
  int r=0,               //  Result-integer
      l=a.size(),        //  Size of the List
      i=l,j,k,           //  Index-integers
      s;                 //  Temp sum-integer
  for(;i-->0;)           //  Loop (2) from `l` down to 0 (inclusive)
    for(j=l;--j>1;       //   Inner loop (3) from `l-1` down to 1 (inclusive)
        r=               //     After every iteration: change `r` to:
          s>r?           //      If the temp-sum is larger than the current `r`:
           s             //       Set `r` to the temp-sum
          :              //      Else:
           r)            //       Leave `r` the same
      for(s=0,           //    Reset the temp-sum to 0
          k=i;k<j;)      //    Inner loop (4) from `i` to `j` (exclusive)
        s+=(long)a.get(k++);
                         //     Add the number at index `k` in the List to this temp-sum
                         //    End of inner loop (4) (implicit / single-line body)
                         //   End of inner loop (3) (implicit / single-line body)
                         //  End of loop (2) (implicit / single-line body)
  System.out.print(r);   //  Print the result to STDOUT
}                        // End of method
— केविन क्रूज़सेन
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.