सार सेट करें

Question

परिचय

आइए इस सरणी को देखें [3, 2, 4, 1, 1, 5, 1, 2]:।

प्रत्येक तत्व सबस्ट्रिंग की लंबाई प्रदर्शित करता है जिसे संक्षेप में प्रस्तुत किया जाना चाहिए। आइए उपरोक्त सरणी के पहले तत्व पर एक नज़र डालें:

[3, 2, 4, 1, 1, 5, 1, 2]
 ^

पहले इंडेक्स में तत्व 3 है , इसलिए अब हम एक ही इंडेक्स के साथ लंबाई तीन का एक विकल्प लेते हैं जैसे कि शुरुआती स्थिति:

[3, 2, 4]

जब सारांशित किया जाता है, तो यह 9 में परिणत होता है , इसलिए प्रतिस्थापन सार सेट का पहला तत्व है 9।

हम सरणी में सभी तत्वों के लिए ऐसा करते हैं:

3 -> [3, 2, 4]
2 -> [2, 4]
4 -> [4, 1, 1, 5]
1 -> [1]
1 -> [1]
5 -> [5, 1, 2]
1 -> [1]
2 -> [2]

आप देख सकते हैं कि संख्या 5 एक अजीब मामला है। यह संख्या सरणी की लंबाई से अधिक है:

[3, 2, 4, 1, 1, 5, 1, 2]
                ^  ^  ^  ^  ^

हम हर उस चीज़ को अनदेखा कर देंगे जो सरणी से अधिक है, इसलिए हम बस उपयोग करते हैं [5, 1, 2]।

अंतिम चरण में सब कुछ योग करना है:

[3, 2, 4]     -> 9
[2, 4]        -> 6
[4, 1, 1, 5]  -> 11
[1]           -> 1
[1]           -> 1
[5, 1, 2]     -> 8
[1]           -> 1
[2]           -> 2

और यह वह सरणी है जिसे आउटपुट करने की आवश्यकता है:

[9, 6, 11, 1, 1, 8, 1, 2]

काम

धनात्मक (गैर-शून्य) पूर्णांकों के साथ एक गैर-खाली सरणी को देखते हुए, सबस्ट्रिंग योग सेट को आउटपुट करता है । यह कोड-गोल्फ है , इसलिए सबसे कम संख्या में बाइट्स जीतता है!

परीक्षण के मामलों

[1, 2, 3, 4, 5] -> [1, 5, 12, 9, 5]
[3, 3, 3, 3, 3, 3, 3, 3] -> [9, 9, 9, 9, 9, 9, 6, 3]
[5, 1, 2, 4, 1] -> [13, 1, 6, 5, 1]
[1] -> [1]

Comments

मुझे लगता है कि आपका मतलब "उप-सूची" है, न कि "सबस्ट्रिंग"। कोई तार नहीं है।

— mbomb007

@ mbomb007 मुझे लगता है कि सबस्ट्रिंग का यहां वही अर्थ है जो सबसे लंबी कॉमन सबस्ट्रिंग समस्या में होता है, यानी बाद में जिनके तत्व आसन्न हैं। डेटा प्रकार एक तरफ, एक स्ट्रिंग केवल एक वर्णमाला सेट के तत्वों का एक परिमित अनुक्रम है (इस मामले में, सकारात्मक पूर्णांक)।

— डेनिस

Answer 1

जेली , 6 बाइट्स

ṫJḣ"ḅ1

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

यह काम किस प्रकार करता है

ṫJḣ"ḅ1  Main link. Argument: A (array)

 J      Index; yield the 1-based indices of A.
ṫ       Tail; map k to the postfix of A that begins with the k-th element.
  ḣ"    Vectorized head; for each k in A, truncate the corr. postfix to length k.
    ḅ1  Convert the resulting slices from base 1 to integer.

Answer 2

पायथन, 40 बाइट्स

f=lambda x:x and[sum(x[:x[0]])]+f(x[1:])

Ideone पर इसका परीक्षण करें ।

Comments

मुझे लगा कि एक गोल्फ पुनरावर्ती समाधान होगा, लेकिन आपने मुझे इसके लिए हराया।

— एलेंडिया स्ट्राटन

Answer 3

एक्सेल, 21 बाइट्स

=SUM(OFFSET(A1,,,A1))

एक नई स्प्रेडशीट खोलें, परीक्षण मानों को ए में रखें। बी 1 में सूत्र दर्ज करें और रेंज की सवारी करने के लिए सेल हैंडल पर डबल क्लिक करें।

Comments

यदि आप कर सकते हैं तो मुझे उस डबल-क्लिक ट्रिक के बारे में सिखाने के लिए मैं आपको दूसरा उत्थान दूंगा।

— नील

हालांकि यह काम करता है कि यह धोखाधड़ी का एक सा है क्योंकि निष्पादन के लिए मैनुअल इनपुट की आवश्यकता होती है।

— user3819867

@ user3819867 अधिकांश प्रोग्राम निष्पादन से अधिक महत्वपूर्ण नहीं है, मैं बहस करूँगा। शायद यह और भी अधिक तुलनीय होगा यदि आप एक स्प्रेडशीट को केवल बी 1 में सूत्र से बचाते हैं - फिर खोलें, कॉलम ए में डेटा जोड़ें, और निष्पादित करने के लिए बी 1 पर हैंडल को डबल-क्लिक करें। YMMV बेशक।

— जोफान

Answer 4

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

lambda X:[sum(X[i:i+k])for i,k in enumerate(X)]

बहुत सीधा-सादा क्रियान्वयन। सूची के अंत में जाने वाले स्लाइस के लिए पायथन का डिफ़ॉल्ट व्यवहार यहां बहुत सुविधाजनक था ।

Answer 5

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

f l@(x:y)=sum(take x l):f y
f x=x

एक बाइट निम्मी ने बचाई।

Answer 6

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

a=>a.map((e,i)=>a.slice(i,i+e).reduce((a,b)=>a+b))

सुंदर आत्म-व्याख्यात्मक। यह mapसरणी में प्रत्येक तत्व के ऊपर है, सूचकांक के माध्यम sliceसे उस index से प्राप्त कर रहा है जो कि eलीमेंट का मूल्य है, और reduceजोड़कर आईएनजी।

f=
  a=>a.map((e,i)=>a.slice(i,i+e).reduce((a,b)=>a+b))

;[
  [3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]
].forEach(function(test){
  document.getElementById('p').textContent += test + ' => ' + f(test) + '\n';
});

<pre id="p"></pre>

Answer 7

जे, 11 बाइट्स

+/@{."_1]\.

प्रयोग

   f =: +/@{."_1]\.
   f 3 2 4 1 1 5 1 2
9 6 11 1 1 8 1 2
   f 1 2 3 4 5
1 5 12 9 5

व्याख्या

+/@{."_1]\.  Input: A
        ]\.  Get each suffix of A from longest to shortest
   {."_1     For each value in A, take that many values from its corresponding suffix
+/@          Sum that group of values taken from that suffix
             Return the sums

Answer 8

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

reduce फिर से पीटा!

a=>a.map((v,i)=>eval(a.slice(i,v+i).join`+`))

F=
a=>a.map((v,i)=>eval(a.slice(i,v+i).join`+`))

;[[3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]].forEach(t=>console.log(t+' -> '+F(t)))

Comments

जहां तक ​​मुझे पता है, आप इस जवाबf= में, जैसे ही हटा सकते हैं ।

— लार्सडब्ल्यू

@ लार्स राइट, f=पहले से ही 45 बाइट्स में नहीं गिना जाता है

— edc65

Answer 9

रेटिना , 38 बाइट्स

बाइट गिनती आईएसओ 8859-1 एन्कोडिंग मानती है।

\d+
$*
M!&`\b1(1)*(?<-1>,1+)*
M%`1
¶
,

इनपुट और आउटपुट अल्पविराम से अलग की गई सूची है।

इसे ऑनलाइन आज़माएं! (पहली पंक्ति एक लाइनफ़ीड-पृथक परीक्षण सूट को सक्षम करती है।)

Answer 10

गणितज्ञ 60 55 बाइट्स

Tr@Take[#,UpTo@#&@@#]&/@Drop[#,t-1]~Table~{t,Length@#}&

जैसे

f = %; f /@ {{1, 2, 3, 4, 5}, {3, 3, 3, 3, 3, 3, 3, 3}, {5, 1, 2, 4, 1}, {1}}

(*    {{1, 5, 12, 9, 5}, {9, 9, 9, 9, 9, 9, 6, 3}, {13, 1, 6, 5, 1}, {1}}    *)

धन्यवाद @MartinEnder 5 बाइट्स शेविंग के लिए :)

Comments

यहां तालिका से बचने का एक विचार है: #+Tr@Take[x=Rest@x,UpTo[#-1]]&/@(x=#)&फिर भी यकीन नहीं है कि यह इष्टतम है लेकिन यह 17 बाइट्स बचाता है।

— मार्टिन एंडर

Answer 11

05AB1E, 11 8 बाइट्स

[D¬£Oˆ¦Ž

व्याख्या

[         # infinite loop
 D        # duplicate current list
  ¬       # get head of list
   £      # get that many elements from list
    O     # sum
     ˆ    # add to global array
      ¦   # remove first element of list
       Ž  # break if stack is empty
          # implicitly push and print global array

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

Answer 12

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

.es:Qk+b

परीक्षण सूट।

पायथन में एल के जवाब का अनुवाद ।

Answer 13

एरलैंग, 69 बाइट्स

f(A)->put(1,1),L=lists,[L:sum(L:sublist(A,put(1,get(1)+1),X))||X<-A].

सूचियों के लिए एरलांग के उच्च-क्रम के कार्यों को वर्तमान तत्व का सूचकांक प्राप्त नहीं होता है। यह वर्तमान तत्व के सूचकांक को सेट करने के लिए प्रक्रिया शब्दकोश का उपयोग करता है।

Answer 14

Pyke, 12 7 बाइट्स

FKo>i<s

यहाँ कोशिश करो!

        - o = 0
F       - for i in input:
  o     -    o+=1
   >    -    input[o:]
    i<  -   ^[:i]
      s -  sum(^)

Answer 15

VBA, 160 बाइट्स

Function e(g())
Dim h()
k=LBound(g)
l=UBound(g)
ReDim h(k To l)
On Error Resume Next
For i=k To l
For j=i To i+g(i)-1
h(i)=h(i)+g(j)
Next
Next
e=h
End Function

Answer 16

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

ms<~tQ

परीक्षण सूट

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

स्पष्टीकरण:

ms<~tQ
ms<~tQdQ    Implicit variable introduction
            Implicit: Q = eval(input())
m      Q    Map d over the input, Q
  <  Qd     Take the first d elements of Q
 s          Sum them
   ~tQ      Afterwards, set Q to the tail of Q, removing the first element.

Answer 17

जूलिया, 39 बाइट्स

!x=x!=[]?[take(x,x[])|>sum;!x[2:end]]:x

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

Answer 18

एफ #, 84 82 बाइट्स

let f(A:int[])=[for i in 0..A.Length-1->Seq.skip i A|>Seq.truncate A.[i]|>Seq.sum]

Answer 19

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

एक पुनरावर्ती समाधान जो एरे तरीकों में से किसी का उपयोग नहीं करता है:

f=([a,...t],n)=>a&&n?a+f(t,n-1):0;g=([a,...t],r=[])=>a?g(t,[...r,a+f(t,a-1)]):r

परिक्षण:

f=([a,...t],n)=>a&&n?a+f(t,n-1):0;
g=([a,...t],r=[])=>a?g(t,[...r,a+f(t,a-1)]):r;

[
  [3, 2, 4, 1, 1, 5, 1, 2],
  [1, 2, 3, 4, 5],
  [3, 3, 3, 3, 3, 3, 3, 3,],
  [5, 1, 2, 4, 1],
  [1]
].forEach(a=>console.log(''+g(a)));

Answer 20

सी #, 89 बाइट्स

int[]s(List<int>a)=>a.Select((n,i)=>a.GetRange(i,Math.Min(n,a.Count-i)).Sum()).ToArray();

बहुत सीधा

सुधार विचारों की सराहना की

Answer 21

ब्रेकीलॉग , 27 बाइट्स

.v|h~l(A:Tc?;A?)b:0&~b.h~+A

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

व्याख्या

  .v           Input = Output = []
|            Or
  h~l          A is a list, its length is the value of the first element of the Input
  (
    A:Tc?        The concatenation of A with another list T results in the Input
  ;            Or
    A?           A = Input
  )
  b:0&         Call recursively on Input minus the first element
  ~b.          Output is the output of that call with an extra element at the beginning
  h~+A         That extra element is the sum of the elements of A

Answer 22

दिल्लोग एपीएल, 15 बाइट्स

{+/¨⍵↑∘⌽¨⌽,\⌽⍵}

या

{⌽+/¨(-↑¨,\)⌽⍵}

Answer 23

PHP प्रोग्राम, 72 बाइट्स

<?foreach($a=$_GET[a]as$i=>$v)echo array_sum(array_slice($a,$i,$v)),"
";

के साथ बुलाना php-cgi -f <filename> 'a[]=3&a[]=2&a[]=4...

एक समारोह के रूप में +11:

function f($a){foreach($a as$i=>$v)$r[]=array_sum(array_slice($a,$i,$v));return$r;}

बिना बिल्डरों के +9:

function p($a){foreach($c=$r=$a as$i=>$v)for($k=$i;$k--;)if(--$a[$k]>0)$r[$k]+=$v;return$r;}

($ c मूल मान रखता है, $ प्रत्येक सूचकांक के लिए नीचे गिना जाता है, $ r को रकम मिलती है)

कार्यक्रम के रूप में -3:

<?foreach($a=$r=$c=$_GET[a]as$i=>$v)for($k=$i;$k--;)if(--$c[$k]>0)$r[$k]+=$v;print_r($r);

Answer 24

क्यू (37 बाइट्स)

{sum each(til[count x],'x)sublist\:x}

उदाहरण:

q){sum each(til[count x],'x)sublist\:x}3 2 4 1 1 5 1 2
9 6 11 1 1 8 1 2

Answer 25

मैट्रिक , 25 बाइट्स

हाँ, आखिरकार एक चुनौती के लिए मुझे नई सुविधाओं की आवश्यकता नहीं है!

md{z:l-g:c;+c;q:c;};:1:l;

साथ दौड़ो: python matricks.py substring.txt [[<input>]] 0

स्पष्टीकरण:

m                  :1:l;   #loop over entire input
                           #set each value to...
 d{               }        #the sum of...
   z:l-g:c:+c;q:c;         #the input cropped to
                           #the length of the value in the cell

Answer 26

जावास्क्रिप्ट (बाहरी लाइब्रेरी का उपयोग करके) (66 बाइट्स)

n=>_.From(n).Select((v,i)=>_.From(n).Slice(i,i+v).Sum()).ToArray()

लिंक करने के लिए लिंक: https://github.com/mvegh1/Enumerable

कोड स्पष्टीकरण: _.From लाइब्रेरी में इनपुट सरणी लोड कर रहा है, जो मूल रूप से js के लिए LINQ है। फिर एरे में प्रत्येक आइटम को निम्न विधेय के अनुसार मैप किया जाता है: इनपुट लें, और इसे वर्तमान आइटम इंडेक्स से स्लाइस करें और उस इंडेक्स प्लस को वर्तमान आइटम के मूल्य पर ले जाएं। फिर उस बाद को योग करें। परिणाम को मूल JS सरणी में कनवर्ट करें और इसे वापस करें

Comments

var चर से निकालें , आपको गोल्फ में इसकी आवश्यकता नहीं है। तुम भी बदल सकते हैं .forEachकरने के लिए .mapजो कम बाइट्स खर्च होता है।

— 1

अरे हाँ, आप var के बारे में सही हैं। धन्यवाद! मैं कल फिर से इस जवाब के माध्यम से जाऊँगा। ऐसा लग रहा है कि देशी JS (es6) मेरे समाधान को मारता है

— Applejacks01

Var हटाने पर अच्छा कॉल। मुझे एक और उपाय का भी एहसास हुआ जो बाइट की संख्या को कम करता है और अधिक सहज भी है

— Applejacks01

Answer 27

क्लोजर, 63 बाइट्स

(defn f[[b & r]](concat[(apply + b(take(dec b)r))](if r(f r))))

पहले और बाकी तर्कों में इनपुट तर्क को विघटित करने के लिए पैटर्न के मिलान का उपयोग करता है।

Answer 28

MATL , 17 14 13 बाइट्स

fGy+!-R0<G*!s

व्याख्या

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों (कई इनपुट को संभालने के लिए संशोधित कोड) को सत्यापित करें ।

f     % Take input implicitly. Indices of nonzero elements: this gives [1 2 ... n]
      % where n is input size
G     % Push input again
y     % Push a copy of [1 2 ... n]
+     % Add. Gives [a+1 b+2...] where [a b...] is the input
!     % Transpose into a column vector
-     % Subtraction with broadcast. Gives 2D array
R     % Keep upper triangular part, making the rest of entries 0
0<    % True for negative entries. Each row corresponds to a substring sum.
      % For each row, this gives true for the entries of the input that make up
      % that substring sum. Each row is thus a mask to select entries of the input
G     % Push input again
*     % Multiply with broadcast. This multiplies the input times each row
!s    % Sum of each row. Implicitly display

Answer 29

सी #, 94 बाइट्स

Console.Write(String.Join(",",a.Select((v,i)=>a.Skip(i).Take(v).Sum().ToString()).ToArray()));

जहां एक int [] है जो इनपुट को हल करने का प्रतिनिधित्व करता है।

Comments

आपको यह मानने की अनुमति है कि एक चर पूर्वनिर्धारित है

— downrep_nation

चर एक हल होने वाला इनपुट है।

— ५३ पर सुपरमेकरट