मेरे चक्रीय उत्तराधिकारियों के योग से मुझे प्रतिस्थापित करें!

25

मेरे पास इस समय आपके लिए एक सरल चुनौती है। धनात्मक पूर्णांक की एक सरणी को देखते हुए एक (या अपनी भाषा में समकक्ष), प्रत्येक प्रविष्टि की जगह एक मैं अगले की राशि के साथ एक मैं के तत्वों एक , शुरू से ही वापस साइकिल अगर वहाँ पर्याप्त आइटम नहीं हैं।

हमेशा की तरह, आप किसी भी प्रोग्रामिंग भाषा में प्रतिस्पर्धा कर सकते हैं और इनपुट ले सकते हैं और किसी भी मानक विधि के माध्यम से और किसी भी उचित प्रारूप में आउटपुट प्रदान कर सकते हैं , जबकि ध्यान दें कि इन खामियों को डिफ़ॉल्ट रूप से मना किया गया है। आप वैकल्पिक रूप से A का आकार इनपुट के रूप में भी ले सकते हैं। यह कोड-गोल्फ है , इसलिए हर भाषा के लिए सबसे कम सबमिशन (बाइट्स में) जीतता है।

उदाहरण / परीक्षण मामले

यह देखते हुए [1,3,4,5], अपने कोड उत्पादन करना चाहिए [3,10,13,14], क्योंकि 1ले लेती है 3, 3की जगह 4+5+1=10है (ध्यान दें कि यह कैसे शुरू से ही वापस लिपटे), 4द्वारा 5+1+3+4=13और 5द्वारा 1+3+4+5+1=14।

यह देखते हुए [3,2,1,9], आपके कार्यक्रम का उत्पादन होना चाहिए [12,10,9,33], क्योंकि हम , के साथ , के साथ और ( साथ में हम एक बार से अधिक शुरुआत से कैसे लिपटे हैं) के साथ स्थानापन्न 3करते हैं ।2+1+9=1221+9=101993+2+1+9+3+2+1+9+3=33

आपके लिए चुनने के लिए कुछ और परीक्षण मामले:

[4,3,2,1]                       -> [10,7,5,4]
[3,2,1,9]                       -> [12,10,9,33]
[1,3,4,5]                       -> [3,10,13,14]
[4,4,3,2,2]                     -> [11,11,8,6,8]
[3,5,3,2,1]                     -> [10,14,6,4,3]
[3,2,4,3,2,1,1]                 -> [9,7,7,4,2,1,3]
[7,8,6,5,4,3,2,1,5]             -> [29,33,20,15,11,8,6,5,30]
[28,2,4,2,3,2,3,4,5,3]          -> [137,6,10,5,9,7,12,38,39,34]
[1,2,3,4,5,4,3,2,1,2,3,4,3,2,1] -> [2,7,13,14,12,8,5,3,2,7,9,7,4,2,1]
code-golf  array-manipulation  integer 
— श्री Xcoder
स्रोत

जवाबों:

8

MATL , 10 9 बाइट्स

"G@:X@+)s

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

	% implicit input
"	% for loop, iterate over the input array 
G	% push input x
@	% push for loop index, x[i]
:	% range, push [1,...,x[i]]
X@	% push for loop index, i
+	% sum, so stack holds [i+1,...,i+x[i]]
)	% index, modularly, so gets the cyclic successors
s	% sum cyclic successors, leaving the sum on the stack
	% implicit end of for loop
	% implicit output of stack
— ग्यूसेप
स्रोत
6

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

ṙJṁS¥"

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

— आउटगोल्फर को एरिक करें
स्रोत
... आह निंजाएड :(
— जोनाथन एलन
@JonathanAllan TBF, मैं पहले से ही एक या दो मिनट के लिए झूठ बोल रहा था, जब आपने अपना पोस्ट किया था (मुझे लगा कि पूर्णांक को भी शामिल किया जाना था, इसलिए +अंत में एक अतिरिक्त के साथ )। इसके अलावा, एह, शायद आप अगली बार मुझे निन्जा देंगे। :)
— एरिक आउटगॉल्फ
6

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

lambda a:[sum((-~v*a)[i:i+v])for i,v in enumerate(a,1)]

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

— जोनाथन एलन
स्रोत
अजगर के साथ भी परिचित नहीं हैं क्या आप राशि के बाद परेंस में भाग की व्याख्या कर सकते हैं?
— योना
2
सबसे पहले ~ऑपरेटर एक बिटवाइज़ है, यह प्रभावी रूप से शॉर्टहैंड है -1-v, इसलिए -~vशॉर्टहैंड है -(-1-v)जिसके लिए बस 1+v(लेकिन जैसे कोष्ठक से बचा जाता है (1+v)*a)। दूसरे पायथन में एक सूची को दोहराने के लिए एक पूर्णांक द्वारा एक सूची को गुणा कर सकते हैं (उदाहरण के ['a','b']*3लिए ['a','b','a','b','a','b'])। -~v*aद्वारा प्रतिस्थापित किया जा सकता है a+v*aएक ही बाइट गिनती के लिए। अंत में केवल (0-अनुक्रमित) के लिए [i:i+v]तत्वों iको रखते हुए एक स्लाइस इंडेक्सिंग है i+v-1।
— जोनाथन एलन
6

जे, 33 बाइट्स

[:({.+/@{.}.)"1 i.@#|."{($~>./*#)

ungolfed

[: ({. +/@{. }.)"1 i.@# |."0 _ ($~ (>./ * #))

व्याख्या

यहाँ छवि विवरण दर्ज करें

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

— जोनाह
स्रोत
फैंसी स्पष्टीकरण: ओ
— कॉनर ओ'ब्रायन
1
वहाँ पर शांत चित्र, लेकिन मैं पाठ के रूप में भी स्पष्टीकरण डालने की सलाह देता हूं, क्योंकि छवियां हमेशा के लिए नहीं रह सकती हैं। ;)
— २१:४१ बजे
7
यह रॉगुलाइक गेम की तरह दिखता है।
— एस्केलर
यदि आप J में मेरे K समाधान को फिर से लिखेंगे तो स्कोर क्या होगा ?
— स्ट्रीटस्टर
6

सी (जीसीसी) , 86 85 बाइट्स

  • जेकब के लिए एक बाइट को धन्यवाद दिया ।
C(y,c,l,i,k)int*y;{for(l=~0;++l<c;printf("%d,",k))for(k=i=0;i++<y[l];k+=y[(l+i)%c]);}

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

— जोनाथन फ्रेच
स्रोत
-1 बाइट:for(k=i=0;i++<y[l];)k+=y[(l+i)%c];
— जैकब
1
के लिए मेरा उत्थान है C(y,c,l,i,k)।
— जोनास श्फर
6

हास्केल, 50 47 44 बाइट्स

zipWith((sum.).take)<*>scanr(:)[].tail.cycle

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

                    -- <*> in function context is Haskell's S combinator, i.e.
                    --     (zipWith ... <*> scanr ...) arg
                    -- resovles to
                    --     zipWith ... arg (scanr ... arg)
zipWith             -- so we zip
                    --   the input list and
 scanr(:)[]         --   the tails (tails of [1,2,3] are [[1,2,3],[2,3],[3],[]])
      tail          --   of the tail of
          cycle     --   and infinite cycle of the input list
                    -- with the function
 (sum.).take        --   take that many elements given by the element
                    --   of the input list from the list given by the inits
                    --   and sum it
— nimi
स्रोत
अच्छी नौकरी! वास्तव में, स्कैनर (:) [] पूंछ है
— डेमियन
@ डैमियन: पूंछ। सही! धन्यवाद!
— नीम
4

K4 / K (oK) , 20 19 बाइट्स

समाधान:

+/'x#'1_(1+2##x)#x:

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

उदाहरण:

q)k)+/'x#'1_(1+2##x)#x:1 3 4 5
3 10 13 14
q)k)+/'x#'1_(1+2##x)#x:4 3 2 1
10 7 5 4
q)k)+/'x#'1_(1+2##x)#x:3 2 4 3 2 1 1
9 7 7 4 2 1 3
q)k)+/'x#'1_(1+2##x)#x:1 2 3 4 5 4 3 2 1 2 3 4 3 2 1
2 7 13 14 12 8 5 3 2 7 9 7 4 2 1

स्पष्टीकरण:

इनपुट रीसेट करें, पहले ड्रॉप करें, प्रत्येक की x लंबाई लें, योग करें।

+/'x#'1_(1+2##x)#x: / the solution
                 x: / store input as x
                #   / reshape
        (      )    / do this together
             #x     / count x
           2#       / duplicate (2-take)
         1+         / add 1
      1_            / 1 drop (_), remove first element
   x#'              / x take each-both
+/'                 / sum (+/) each
— streetster
स्रोत
3

अटैची , 26 बाइट्स

{Sum=>_[(_2+1:_)%#_]}#Iota

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

व्याख्या

यह दो कार्यों का एक कांटा है:

  • {Sum=>_[(_2+1:_)%#_]}
  • Iota

इसका मतलब यह है कि, सही टाइन Iotaको तर्क पर लागू किया जाता है xऔर इसे केंद्र टाइन (पहला फ़ंक्शन) के दूसरे तर्क के रूप में पारित किया जाता है। तो यह इनपुट के लिए बन जाता है x:

{Sum=>_[(_2+1:_)%#_]}[x, Iota[x]]

उन लोगों को प्रतिस्थापित करना _और _2:

Sum => x[(Iota[x] + 1:x) % #x]

Iota[x]के सूचकांकों की एक सरणी देता है x। इसके बराबर है 0...#x। #xका आकार कहने का एक छोटा तरीका है x, या Size[x]। संक्षेप में, यह फ़ंक्शन Sumदूसरी अभिव्यक्ति पर फ़ंक्शन को मैप कर रहा है :

x[(Iota[x] + 1:x) % #x]

बाहरी x[...]बिट का मतलब है कि ...चुने जाने वाले सूचकांकों की एक श्रृंखला उत्पन्न होगी x। सूचकांक बनाने का सबसे महत्वपूर्ण हिस्सा यह है:

Iota[x] + 1:x

यह अभिव्यक्ति थोड़ा वैश्वीकरण का उपयोग करती है। यह कल्पना करने के लिए, मान लीजिए कि इनपुट है x := [1, 3, 4, 5]। तब, यह अभिव्यक्ति इसके बराबर है:

Iota[[1, 3, 4, 5]] + 1:[1, 3, 4, 5]
[0, 1, 2, 3] + [1:1, 1:3, 1:4, 1:5]
[0, 1, 2, 3] + [[1], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5]]
[0 + [1], 1 + [1, 2, 3], 2 + [1, 2, 3, 4], 3 + [1, 2, 3, 4, 5]]
[[0 + 1], [1 + 1, 1 + 2, 1 + 3], [2 + 1, 2 + 2, 2 + 3, 2 + 4], [3 + 1, 3 + 2, 3 + 3, 3 + 4, 3 + 5]]
[[1], [2, 3, 4], [3, 4, 5, 6], [4, 5, 6, 7, 8]]

यह सूचकांक की एक सूची है जो मॉड Nमें अगले तत्वों के सूचकांकों का प्रतिनिधित्व करती है । पुनर्प्राप्ति के लिए उन्हें सुरक्षित बनाने के लिए, हम इस सरणी मॉड को लेते हैं :x#x#x

(Iota[x] + 1:x) % #x

यह हमें उचित संकेत देता है, जो तब से प्राप्त किए जाते हैं xऔर उचित परिणाम देते हुए प्रत्येक सरणी को सारांशित किया जाता है।

अन्य प्रयास

36 बाइट्स: {Sum@_&Get=>((_2+1.._2+_)%#_)}#Iota - मैं x[...]पूरी तरह से भूल गया , ताकि यह बन जाए:

30 बाइट्स: {Sum=>_[(_2+1.._2+_)%#_]}#Iota - लेकिन फिर मुझे एहसास हुआ कि _2+इनर रेंज में फैक्टर आउट किया जा सकता है, जिसका मतलब है कि हम करंट वर्जन को बचाने के :बजाय कोष्ठक को बचा सकते हैं .., जिससे हमें वर्तमान वर्जन मिल सके।

— कोनोर ओ ब्रायन
स्रोत
3

आर , 89 64 बाइट्स

j=rep(x<-scan(),max(x));Map(function(u,v)sum(j[v+1:u]),x,seq(x))

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

मुख्य विचार एक तरह से लंबे समय तक पर्याप्त साइकिल सूचकांक वेक्टर उत्पन्न करने के लिए है जिसका उपयोग आप इनपुट वेक्टर से आवश्यक तत्वों को प्राप्त करने के लिए कर सकते हैं।

मूल संस्करण:

function(x,i=seq(x),j=rep(i,max(x))){for(k in i){T=c(T,sum(x[j[(k+1):(k+x[k])]]))};T[-1]}

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

— एन जी एम
स्रोत
चूंकि यह एक अतिरिक्त तर्क के रूप में लंबाई लेने की अनुमति देता है ... 75
— JayCe
1
69 मजाकिया मैंने कुछ इसी तरह की शुरुआत की थी, लेकिन कम्सुम का उपयोग करके और इस प्रक्रिया में खो गया ... अच्छा समाधान!
— JayCe
66 (मैप का उपयोग करते हुए। आउटपुट थोड़ा बदसूरत है इसलिए TIO लिंक इसे अन लिस्ट करता है। मुझे लगता है कि एक पूर्ण कार्यक्रम और भी छोटा होगा!
— JayCe
— JayCe
— JayCe
3

आर , 62 58 बाइट्स

function(a,l)diag(diffinv(matrix(a,max(a)*l+1,l))[a+2,])-a

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

अन्य आर समाधान का एक विकल्प । टिप्पणियों में JayCe ने इस बात का उल्लेखcumsum किया कि मेरे दिमाग में किस चीज का उपयोग करने के लिए ट्रिगर किया गया था diffinvऔर इसके बजाय मैट्रिक्स रीसाइक्लिंग rep।

स्पष्टीकरण:

दिए गए इनपुट ऐरे a, चलो M=max(a)और l=length(a)।

गौर करें कि M+lअधिकतम संभव सूचकांक हम पहुँच करने की आवश्यकता होगी, और वह यह है कि M+l<=M*l+1, के बाद से अगर M,l>1, M+l<=M*l(समानता के साथ ही जब M=l=2) और यदि l==1या M==1, फिर M+l==M*l+1।

उदाहरण के तौर पर, आइए a=c(4,3,2,1)। तब M=l=4।

हम M*l+1 x lआर द्वारा मैट्रिक्स का निर्माण करते हैं matrix(a,max(a)*l+1,l)। क्योंकि आर a-कॉलम प्रमुख क्रम में पुनरावृत्ति करता है, हम एक मैट्रिक्स को समाप्त करते हैं aजैसे कि तत्वों को दोहराते हैं:

      [,1] [,2] [,3] [,4]
 [1,]    4    3    2    1
 [2,]    3    2    1    4
 [3,]    2    1    4    3
 [4,]    1    4    3    2
 [5,]    4    3    2    1
 [6,]    3    2    1    4
 [7,]    2    1    4    3
 [8,]    1    4    3    2
 [9,]    4    3    2    1
[10,]    3    2    1    4
[11,]    2    1    4    3
[12,]    1    4    3    2
[13,]    4    3    2    1
[14,]    3    2    1    4
[15,]    2    1    4    3
[16,]    1    4    3    2
[17,]    4    3    2    1

प्रत्येक स्तंभ के प्रत्येक तत्व की चक्रीय उत्तराधिकारियों है a, साथ aपहली पंक्ति में; यह उस तरीके के कारण है जो आर मैट्रिक्स में अपने तर्कों को पुन: उपयोग करता है।

अगला, हम उलटा "व्युत्पन्न" लेते हैं diffinv, अनिवार्य रूप से प्रत्येक स्तंभ के संचयी योग 0को पहली पंक्ति के रूप में एक अतिरिक्त , मैट्रिक्स उत्पन्न करते हैं।

      [,1] [,2] [,3] [,4]
 [1,]    0    0    0    0
 [2,]    4    3    2    1
 [3,]    7    5    3    5
 [4,]    9    6    7    8
 [5,]   10   10   10   10
 [6,]   14   13   12   11
 [7,]   17   15   13   15
 [8,]   19   16   17   18
 [9,]   20   20   20   20
[10,]   24   23   22   21
[11,]   27   25   23   25
[12,]   29   26   27   28
[13,]   30   30   30   30
[14,]   34   33   32   31
[15,]   37   35   33   35
[16,]   39   36   37   38
[17,]   40   40   40   40
[18,]   44   43   42   41

पहले कॉलम में, एंट्री 6=4+2बराबर है 14=4 + (3+2+1+4), जो चक्रीय उत्तराधिकारी राशि (सीएसएस) प्लस एक अग्रणी है 4। इसी तरह, दूसरे कॉलम में, एंट्री 5=3+2इसके बराबर 10=3 + (4+1+2)और आगे है।

तो कॉलम में i, a[i]+2nd प्रविष्टि समान है CSS(i)+a[i]। इसलिए, हम a+2एक वर्ग मैट्रिक्स की उपज द्वारा अनुक्रमित पंक्तियों को लेते हैं :

     [,1] [,2] [,3] [,4]
[1,]   14   13   12   11
[2,]   10   10   10   10
[3,]    9    6    7    8
[4,]    7    5    3    5

विकर्ण के साथ प्रविष्टियाँ चक्रीय उत्तराधिकारी रकम के बराबर होती हैं a, इसलिए हम विकर्ण को हटाते हैं और घटाते हैं a, जिसके परिणामस्वरूप चक्रीय उत्तराधिकारी रकम लौटता है।

— ग्यूसेप
स्रोत
स्पष्टीकरण के लिए इंतजार नहीं कर सकता!
— JayCe
@JayCe गयी! जैसा कि अक्सर होता है, यह समझाते हुए एक और गोल्फ का नेतृत्व किया; मैं हमेशा एक स्पष्टीकरण जोड़ने की सलाह देता हूं ताकि आप या पीछे चलने वाले अन्य लोग एक और दृष्टिकोण पा सकें, हालांकि मेरे पास ऐसा करने के लिए हमेशा समय नहीं है, हाहा।
— ग्यूसेप
1
दोनों समाधानों के लिए सामान्य तत्व सूचकांक या स्वयं तत्वों की एक लंबी-पर्याप्त रीसाइक्लिंग की कुशल पीढ़ी है, क्योंकि 1-अनुक्रमित भाषाएं सरणी की शुरुआत में वापस आने के लिए मॉड्यूलर अंकगणितीय का उपयोग नहीं कर सकती हैं।
— एनसीएम
@ngm हाँ, निश्चित रूप से। मुझे आपका उपयोग पसंद है Map, और मूल रूप से यह 68 बाइट्स जैसा था इससे पहले कि मुझे लगा कि मैं lएक इनपुट के रूप में ले सकता हूं !
— ग्यूसेप
2

पायथ, 13 11 बाइट्स

.esm@Q+dkSb

2 एक्स बाइट्स को श्री एक्सकोडर के लिए धन्यवाद।
इसे यहाँ आज़माएँ

व्याख्या

.esm@Q+dkSb
.e         Q   For each index k and value b in (implicit) input...
         Sb    ... get the list [1, ..., b]...
   m  +dk      ... add k to each...
    @Q         ... and index into the input...
  s            ... then take the sum.
— श्री एक्सकोडर
2

चारकोल , 12 बाइट्स

ＩＥθΣＥι§θ⊕⁺κλ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  θ             Input array
 Ｅ              Map over elements
     ι          Current element
    Ｅ           Map over implicit range
           λ    Inner index
          κ     Outer index
         ⁺      Sum
        ⊕       Increment
       θ        Input array
      §         Cyclically index
   Σ            Sum
Ｉ               Cast to string
                Implicitly print on separate lines
— नील
स्रोत
2

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

a=>a.map((x,y)=>{for(s=0,i=y;i<y+x;)s+=a[++i%a.length];return s})

सीधा हल। Ungolfed:

a => a.map((x,y) => {
    var s = 0;
    for (i = y; i < y + x; i++) {
        s += a[i % a.length];
    }
    return s;
});

जावास्क्रिप्ट का map()कार्य नौकरी के लिए एकदम सही है, यह प्रत्येक तत्व के खिलाफ दिए गए कॉलबैक को चलाता है और कॉलबैक के परिणाम से इसे बदल दिया है। कॉलबैक दो मापदंडों को प्राप्त करता है, पहलाx मूल्य है और दूसरा yसूचकांक है। मापांक लेने से i % a.lengthहम आसानी से सरणी पर लूप कर सकते हैं, यदि आवश्यक हो तो कई बार।

टेस्ट स्निपेट

(इनपुट को JSON नोटेशन के रूप में रखें)

कोड स्निपेट दिखाएं

— पेड्रो ए
स्रोत
2

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

एक int[]सूची और intलंबाई लेने वाला एक करीबी शून्य लैंबडा ।

l->s->{for(int i=-1,j,t;++i<s;System.out.println(t))for(j=t=0;j++<l[i];)t+=l[(i+j)%s];}

यह ऑनलाइन की कोशिश करो । ध्यान दें कि मैंने System.outप्रीटीयर प्रिंटिंग के लिए परिणाम हड़पने के लिए इस कार्यक्रम में छाया हुआ है।

— जेकब
स्रोत
2

जूलिया 0.6 , 63 55 53 बाइट्स

A->[sum(repmat(A,v+1)[i+1:i+v])for(i,v)=enumerate(A)]

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

पुराना समाधान:

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

A->(l=length(A);[sum(A[mod1(j,l)]for j∈i+1:i+A[i])for i∈1:l])

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

एक और समाधान। Bytecount से महान नहीं है, लेकिन मुझे यह पसंद है, और यह संभवतः अन्य दो की तुलना में अधिक कुशल है, खासकर अगर इनपुट में बड़ी संख्या है।

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

A->(l=length(A);[sum([A;A][i+1:i+A[i]%l])+A[i]÷l*sum(A)for i∈1:l])

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

— sundar - मोनिका को बहाल करना
स्रोत
1

QBasic 1.1 , 115 बाइट्स

INPUT L
DIM A(L)
FOR I=0TO L-1
INPUT C
A(I)=C
NEXT
FOR I=0TO L-1
S=0
FOR C=I+1TO I+A(I)
S=S+A(C MOD L)
NEXT
?S
NEXT

पहला इनपुट लंबाई एल है , फिर एल बाद के इनपुट क्रम में तत्व हैं। एल आउटपुट परिणामी सरणी का प्रतिनिधित्व करते हैं, उनके द्वारा प्रस्तुत क्रम में तत्वों के साथ।

— आउटगोल्फर को एरिक करें
स्रोत
1

एपीएल + विन, 37 बाइट्स

इनपुट के लिए संकेत:

+/¨v↑¨⊂[2](⍳⍴v)⌽((⍴v),⍴n)⍴n←(+/v)⍴v←⎕

इसे ऑनलाइन आज़माएं! दरोगल क्लासिक के सौजन्य से

स्पष्टीकरण:

n←(+/v)⍴v←⎕ prompts for input and creates a repeating vector of length max v

((⍴v),⍴n)⍴n converts n to a matrix of length v x length n

(⍳⍴v)⌽ rotates each row of n by the size of each element of v

⊂[2] converts each row of m to an element in a nested vector

+/¨v↑¨ selects the number of elements from each element of the nested vector according to v and sums
— ग्राहम
स्रोत
1

जावास्क्रिप्ट, 65 बाइट्स 3̶0̶0̶ ̶b̶y̶t̶e̶s by

golfed

n=>n.map((z,x)=>{for(s=0,i=x;i<z+x;)s+=n[++i%n.length];return s})

ungolfed

     f = n=>n.map((z,x)=>{
            for(s=0,i=x;i<z+x;)s+=n[++i%n.length];
            return s
            }
        );
console.log(f(process.argv[2].slice(1, -1).split(", ").map(x=>+x)))

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

(ऊपर ungolfed संस्करण) मैं इस कोडगुल्फ चीज़ के लिए नया हूँ!

* अद्यतन! टिप्पणियों में प्रदान किए गए उपयोगी लिंक के लिए धन्यवाद, मैं आकार को 65 बाइट्स तक कम करने में कामयाब रहा!

— ArashSM79
स्रोत
साइट पर आपका स्वागत है। ऐसे कुछ तरीके हैं जिनसे इसमें सुधार किया जा सकता है। आप एकल वर्ण चर नामों का उपयोग कर सकते हैं, और आप अतिरिक्त-सफेद स्थान निकाल सकते हैं। (ऑपरेटरों को रिक्त स्थान से घिरे रहने की आवश्यकता नहीं है।)
— गेहूं जादूगर
कैट विजार्ड की युक्तियों से परे, हमारे पास जावास्क्रिप्ट में गोल्फिंग के लिए टिप्स का एक संग्रह है । जैसा कि आप कहते हैं कि आप गोल्फ के लिए नए हैं, तो आपको <सभी भाषाओं> में भी गोल्फ के लिए सामान्य टिप्स दिलचस्प लग सकते हैं।
— मैनटवर्क
आप ungolfed एक से पहले golfed संस्करण जोड़ना चाहिए
— Sefa
आप मान रहे हैं कि सरणी को O पूर्वनिर्धारित चर ( n) सौंपा गया है , जिसे हम अनुमति नहीं देते हैं। PPCG में आपका स्वागत है, हालांकि :)
— झबरा
— झबरा
0

पिप -rn , 14 बाइट्स

$+g@(_+\,B)MEg

स्टड की क्रमिक लाइनों पर इनपुट नंबर लेता है; स्टडआउट की क्रमिक लाइनों पर आउटपुट नंबर देता है।इसे ऑनलाइन आज़माएं!

व्याख्या

             g  List of lines of stdin (from -r flag)
           ME   Enumerate and map this function to the (index, value) pairs:
       \,B       One-based range(value)
     _+          To each element, add the index of that value
  g@(     )      Use the resulting range to slice into the original list g
                 (cyclical indexing is built in)
$+               Sum the numbers in the slice
                Output the list of results one per line (from -n flag)

या, काम किए गए उदाहरण का उपयोग कर:

             g  [1 3 4 5]
           ME   
       \,B      [(1,2) (1,4) (1,5) (1,6)]
     _+         [(1,2) (2,5) (3,7) (4,9)]
  g@(     )     [[3] [4 5 1] [5 1 3 4] [1 3 4 5 1]]
$+              [3 10 13 14]
— DLosc
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.