एक वेक्टर की बंधी हुई संचयी राशि की गणना करें

Question

एक वेक्टर की संचयी राशि की गणना केवल पिछले सभी तत्वों के योग द्वारा की जाती है। उदाहरण के लिए:

vec =     [1  1  1 -1 -1 -1 -1 -1  1  1  1  1 -1]
cum_vec = [1  2  3  2  1  0 -1 -2 -1  0  1  2  1]

अब, एक ऊपरी और निचली सीमा लागू करें, जिसका अर्थ है कि आप संचयी योग को बढ़ाना बंद कर देते हैं यदि यह ऊपरी सीमा पर है, और कम सीमा पर यह संचयी योग को कम करना बंद कर देता है। एक सरल उदाहरण:

upper_lim = 2
lower_lim = -1
vec =     [1  1  1 -1 -1 -1 -1 -1  1  1  1  1 -1]
cum_vec = [1  2  2  1  0 -1 -1 -1  0  1  2  2  1]

इनपुट वेक्टर में पूर्णांक होते हैं, केवल आवश्यक नहीं 1और -1, सकारात्मक और नकारात्मक दोनों। मान लिया कि upper_lim >= lower_lim। यदि वेक्टर का पहला तत्व सीमा के बाहर है, तो सीधे सीमा पर जाएं (अंतिम उदाहरण देखें)।

एक फ़ंक्शन लिखें जो पूर्णांक के वेक्टर को इनपुट के रूप में लेता है, और दो पूर्णांक जो ऊपरी और निचली सीमाओं का प्रतिनिधित्व करते हैं। जैसा कि ऊपर बताया गया है, संचयी वेक्टर वेक्टर आउटपुट। इनपुट या तो कार्य तर्कों या STDIN से हो सकता है।

मानक कोड गोल्फ नियम लागू होते हैं।

उदाहरण:

upper_lim = 6
lower_lim = -2
vec =     [1  4  3 -10  3  2  2  5 -4]
cum_vec = [1  5  6  -2  1  3  5  6  2]

upper_lim = 100
lower_lim = -100
vec =     [1  1  1  1  1  1]
cum_vec = [1  2  3  4  5  6]

upper_lim = 5
lower_lim = 0
vec =     [10 -4 -3  2]
cum_vec = [5   1  0  2]

upper_lim = 0
lower_lim = 0
vec =     [3  5 -2  1]
cum_vec = [0  0  0  0]

upper_lim = 10
lower_lim = 5
vec =     [1  4  6]
cum_vec = [5  9 10]
           |
           Note, jumped to 5, because 5 is the lower bound.

Answer 1

अजगर, 14 बाइट्स

t.u@S+Q+NY1vwZ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

व्याख्या

t.u@S+Q+NY1vwZ  implicit: Q = first input list [upper_lim, lower_lim]
 .u        vwZ  for each number Y in the next input list, update N = 0 with:
       +NY         N + Y
     +Q            append this to Q
    S              sort this list
   @      1        take the middle element
                .u returns a list with all intermediate values of N
t                  remove the first value, print the rest

Answer 2

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

l~f{\T++$1=:T}`

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

यह सूची को पहले तर्क के रूप में लेता है, और दूसरी 2-तत्व सूची के रूप में ऊपरी / निचली सीमा की जोड़ी। उदाहरण इनपुट:

[1 4 3 -10 3 2 2 5 -4] [6 -2]

नवीनतम संस्करण 1 बाइट को 3 मानों को छाँट कर बचाता है, और अधिकतम और न्यूनतम ऑपरेशन का उपयोग करने के बजाय मध्य मूल्य लेता है। यह जकूबे के समाधान में भी इस्तेमाल किया गया था, साथ ही मार्टिन द्वारा सुझाया गया था।

स्पष्टीकरण:

l~    Get and parse input. This leaves the value and bounds lists on the stack.
f{    Apply block with value (the bounds list).
  \     Swap new value to top.
  T     Get previous value from variable T (which is default initialized to 0).
  +     Add new value and previous value.
  +     Append new value to bounds list, producing a 3 value list.
  $     Sort it...
  1=    And take the middle value.
  :T    Store in variable T for next iteration.
}     End of apply loop.
`     Convert list to string.

Answer 3

जावास्क्रिप्ट (ईएस 6), 43 बाइट्स

(l,u,v,p=0)=>v.map(c=>p=(p+=c)<l?l:p>u?u:p)

एक अनाम फ़ंक्शन को परिभाषित करता है जो प्रारूप में इनपुट लेता है lower bound, upper bound, vector (as JS Array)। मुझे नहीं पता कि यह कोई छोटा हो सकता है, लेकिन मैं कोशिश करूँगा। सुझावों का स्वागत है!

Answer 4

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

u#l=tail.scanl(((min u.max l).).(+))0

प्रयोग उदाहरण: 6 # (-2) $ [1,4,3,-10,3,2,2,5,-4]-> [1,5,6,-2,1,3,5,6,2]।

0सीमा को प्रारंभिक मानों को सीमा से बाहर करने के साथ शुरू करें । tailइसे अंतिम परिणाम से हटाने के लिए लें ।

Answer 5

आर, 61 बाइट्स

function(x,l,u,s=0)sapply(x,function(i)s<<-min(u,max(l,s+i)))

sapplyवेक्टर के प्रत्येक तत्व (यहां x) पर एक फ़ंक्शन को लागू करने के लिए फ़ंक्शन है, लेकिन यह आमतौर पर एक संदर्भ में किया जाता है जहां सभी मूल्यांकन स्वतंत्र और साइड-इफेक्ट के बिना होते हैं। यहाँ, हालाँकि, मैं <<-अभिभावक / कॉलिंग वातावरण में असाइनमेंट बनाने के लिए ऑपरेटर का उपयोग करता हूँ sapplyताकि संचयी योग sको पुनरावृत्त मूल्यांकन के बाहर संग्रहीत किया जा सके। यह बहुत बुरा अभ्यास है ...

Answer 6

मैथेमेटिका, 46 बाइट्स

Rest@FoldList[{a,b}Min[a+b,#2]~Max~#3,0,#]&

मजेदार चरित्र U + F4A1 है \[Function]। यदि पहला तत्व सीमा में माना जा सकता है, तो मैं 7 बाइट्स बचा सकता हूं।

Answer 7

जूलिया, 44 42 38 बाइट्स

f(x,l,u,s=0)=[s=clamp(s+i,l,u)for i=x]

यह एक फ़ंक्शन बनाता है fजो एक सरणी और दो पूर्णांक स्वीकार करता है और एक सरणी देता है।

Ungolfed:

function f(v::Array, u::Int, l::Int, s::Int = 0)
    # The parameter s is the cumulative sum, which begins
    # at 0

    # For each element i of v, define s to be s+i if
    # l ≤ s+i ≤ u, l if s+i < l, or u if s+i > u
    x = [s = clamp(s + i, l, u) for i = v]

    return x
end

एक समारोह पैरामीटर के रूप में संचयी राशि सहित ETHproductions के विचार का उपयोग करके 2 बाइट्स सहेजे गए और 1 बाइट्स ग्लेन ओ के लिए धन्यवाद।

Answer 8

पायथन 2, 67 बाइट्स

lambda u,l,v:reduce(lambda x,y:x+[max(min(x[-1]+y,u),l)],v,[0])[1:]

Answer 9

मिंकोलंग 0.9 , 30 बाइट्स

0I3-[2g+d0c`,3&x0cd1c`3&x1cdN]

यह, एक फ़ंक्शन के रूप में, मान लेता है कि स्टैक को पहले से प्रारंभिक किया गया है high, low, vector। पूरा कार्यक्रम नीचे ( 37 बाइट्स ) है और इनपुट के रूप में लेता है high, low, vector।

(n$I$)0I4-[2g+d0c`,3&x0cd1c`3&x1cdN].

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

व्याख्या

(n$I$)                                   Read in integers from input until empty
      0                                  Initialize cumulative sum
       I4-[                        ]     Loop over vector
           2g+                           Get the next partial sum
              d0c`,3&x0c                 If too high, replace with high
                        d1c`3&x1cd       If too low, replace with low
                                  N      Output as integer
                                    .    Stop

Answer 10

सी 98 बाइट्स

यह लंबा है, लेकिन यह काम करता है

#define P printf(
void c(*v,n,u,l,s,c){P"[");while(c++<n)s+=*v++,s=s<u?s>l?s:l:u,P"%d ",s);P"]");}

उदाहरण का उपयोग करें

#define P printf(
void c(*v,n,u,l,s,c) {
    P"[");
    while(c++<n)
        s+=*v++,s=s<u?s>l?s:l:u,P"%d ",s);
    P"]");
}

int main() {
    int vec[9] = {1, 4, 3, -10, 3, 2, 2, 5, -4};
    int upper = 6, lower = -2, count = 9;
    c(vec, count, upper, lower, 0, 0);
}

आउटपुट होगा

[1 5 6 -2 1 3 5 6 2 ]

Answer 11

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

जैसा कि डेनिस ने चैट में बताया है, \(विस्तार) बाएं से दाएं काम करता है, लेकिन फ़ंक्शन को दाएं से बाएं से विस्तारित किया जा रहा है। तो हम बस नहीं कर सकते 1↓(⎕⌈⎕⌊+)\0,⎕। हम ,\एरे को ले जाकर इसके चारों ओर काम करते हैं , और फिर प्रत्येक सब्रे को अलग-अलग /(गुना) का उपयोग करके संसाधित करते हैं ।

1↓(⎕⌈⎕⌊+)/¨⌽¨,\0,⎕

आदेश में इनपुट array, upper bound, lower bound।