गुणक undelta

Question

आइए हम मानों के "गुणात्मक डेल्टा" को परिभाषित करें$[\; a_0, \cdots a_N, \;]$ जैसा:

$$[\; a_1 / a_0, \cdots, a_{i+1} / a_i, \cdots, a_N / a_{N-1} \;]$$

रिवर्स ऑपरेशन - अर्थात् "गुणात्मक undelta" - मानों को ऐसे लौटाता है कि ऊपर दिए गए ऑपरेशन के परिणाम दिए गए मान हैं।

उदाहरण

मान दिया $[\; 1, 5, 3, 2 \;]$" गुणक undelta " ऑपरेशन के लिए एक सामान्य समाधान है:

$$[\; a_0, \quad \underset{a_1}{\underbrace{a_0 \cdot 1}}, \quad \underset{a_2}{\underbrace{a_1 \cdot 5}}, \quad \underset{a_3}{\underbrace{a_2 \cdot 3}}, \quad \underset{a_4}{\underbrace{a_3 \cdot 2}} \;]$$

सेटिंग द्वारा एक विशेष समाधान प्राप्त किया जा सकता है $a_0$ शून्य के अलावा किसी भी मूल्य के लिए, उदाहरण के लिए सेटिंग द्वारा $a_0 := 1$ हमें मिलेगा:

$$[\; 1, 1, 5, 15, 30 \;]$$

चुनौती

इस चुनौती के लिए आपका काम ऑपरेशन " गुणात्मक undelta " को लागू करना है जैसा कि ऊपर बताया गया है।

नियम

इनपुट हैं:

• एक शून्य-शून्य मान $a_0$
• एक गैर-रिक्त सूची / सरणी / वेक्टर / ... गैर-शून्य " गुणक डेल्टा "

आउटपुट एक सूची / सरणी / वेक्टर / ... मान है जैसे कि पहला तत्व है $a_0$और जिसके लिए " गुणक डेल्टा " इनपुट हैं।

नोट: यदि आपकी भाषा में नकारात्मक पूर्णांक का समर्थन नहीं है, तो आप गैर-शून्य को सकारात्मक द्वारा प्रतिस्थापित कर सकते हैं ।

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

2 [21] -> [2,42]
1 [1,5,3,2] -> [1,1,5,15,30]
-1 [1,5,3,2] -> [-1,-1,-5,-15,-30]
7 [1,-5,3,2] -> [7,7,-35,-105,-210]
2 [-12,3,-17,1311] -> [2,-24,-72,1224,1604664]
-12 [7,-1,-12,4] -> [-12,-84,84,-1008,-4032]
1 [2,2,2,2,2,2,2,2] -> [1,2,4,8,16,32,64,128,256]

Comments

क्या हम डेल्टास की लंबाई 1 + संख्या की एक सूची ले सकते हैं, जहां पहला आइटम a list है?

— अड्म

@ Adám: मैं नहीं कह रहा हूँ क्योंकि यह मौजूदा उत्तरों के लिए चीजों को बदल देगा।

— ბიმო

Answer 1

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

scanl(*)

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

Comments

मैं जाँच कर रहा था कि क्या किसी ने यह लिखा है, और मुझे लगा कि किसी ने इसे नहीं लिखा है और मैंने कहा "अच्छा है, तो मैं लिखूंगा" और फिर पृष्ठ के निचले भाग में आपका उत्तर देखा। upvoted।

— विंडमिल कुकीज

Answer 2

एपीएल (डायलॉग), 3 बाइट्स

×\∊

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

अगर मुझे बाईं ओर संख्या और दाईं ओर सरणी लेना है:

-2 @ H.PWiz को धन्यवाद

7 5 3 बाइट्स

×\,

Comments

⊣,⊢बस हो सकता है,

— H.PWiz

@ H.PWiz धन्यवाद, मेरा टैटिट बहुत कमजोर है

— क्विंटेक

आपको परनों की आवश्यकता नहीं है; ×\,एक फ़ंक्शन का मूल्यांकन करता है।

— डेनिस

@ डेनिस दुर्भाग्य से काम नहीं कर रहे हैं

— क्विंटेक

आपको Parens की गिनती करने की आवश्यकता नहीं है, क्योंकि उन्हें कुछ स्थितियों में ज़रूरत नहीं है। f←×\उदाहरण के लिए, काम करता है। Btw, (-12 3 -17 1311)आपके permalink में होना चाहिए (¯12 3 ¯17 1311)।

— डेनिस

Answer 3

आर , 15 बाइट्स

cumprod(scan())

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

पूरा कार्यक्रम। फ़ंक्शन लंबा है (जब तक हमें इनपुट को "गोंद" करने की अनुमति नहीं दी गई थी, ताकि बिल्ट-इन cumprodएक पूर्ण उत्तर के रूप में पर्याप्त हो):

आर , 28 बाइट्स

function(i,x)cumprod(c(i,x))

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

Answer 4

MATL , 3 बाइट्स

hYp

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

            #implicit input, x_0 and A
h           #horizontally concatenate
Yp          #cumulative product
            #implicit output

hYpMatl के बारे में ई वास्तविक है।

Answer 5

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

के रूप में इनपुट लेता है (m)(a)।

m=>a=>[m,...a.map(x=>m*=x)]

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

Answer 6

जाप, 3 बाइट्स

å*V

कोशिश करो

---

व्याख्या

        :Implicit input of array U and integer V
å       :Cumulatively reduce U
 *      :By multiplication
  V     :With an initial value of V

Answer 7

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

def f(a,b):
    for x in[1]+b:a*=x;yield a

वैकल्पिक दृष्टिकोण। एक जेनरेटर लौटाता है।

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

Answer 8

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

;×\

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

Answer 9

वोल्फ्राम भाषा (गणितज्ञ) , 14 बाइट्स

FoldList@Times

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

FoldList[Times, a0, {x1, x2, ..., xn}]वांछित उत्पादन करता है। FoldList[Times]curried रूप है कि एक शुद्ध समारोह अभी भी के लिए इंतज़ार कर अपनी उत्पादन होता है a0और {x1, x2, ..., xn}।

Answer 10

पर्ल 6 , 9 बाइट्स

{[\*] @_}

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

Answer 11

मानक एमएल , 32 बाइट्स

fun f(x::r)a=a::f r(a*x)|f&a=[a]

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

Ungolfed:

fun f (x::xr) a = a :: f xr (a*x)
  | f    _    a = [a]

Answer 12

जे , 6 5 बाइट्स

-1 बटलर थैंक्स टू बटलर

*/\@,

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

स्पष्टीकरण:

एक तिर्यक क्रिया, बाएं तर्क, कठोर a0एक - सदिश है

     @, - append the vector to a0 and 
  */\   - find the running product

Comments

*/\@,ठीक वैसा ही काम करता है।

— बब्बलर

@ बब्बर हां, बिल्कुल! धन्यवाद!

— गैलेन इवानोव

Answer 13

बैच, 69 बाइट्स

@set/pa=
@echo %a%
@for %%d in (%*) do @set/aa*=%%d&call echo %%a%%

का इनपुट लेता है $a_0$ एसटीडीआईएन और डेल्टा पर कमांड-लाइन तर्क के रूप में।

Answer 14

आम लिस्प, 67 बाइट्स

(lambda(a l &aux(y 1))(mapcar(lambda(x)(setf y(* y x)))(cons a l)))

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

Answer 15

भूसी , 2 बाइट्स

G*

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

यह हास्केल में नीमी के जवाब के बराबर है : scanl(*)जिसका अर्थ है कि गुणा का उपयोग करते हुए बाईं ओर से कम करना, और सभी आंशिक परिणाम वापस करना।

Answer 16

05AB1E , 5 3 बाइट्स

šηP

-2 बाइट्स @ बीएमओ को धन्यवाद ।

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

स्पष्टीकरण:

š      # Prepend the (implicit) input-integer at the start of the (implicit) input-list
       #  i.e. -12 and [7,-1,-12,4] → ["-12",7,-1,-12,4]
 η     # Prefixes of this new list
       #  i.e. ["-12",7,-1,-12,4]
       #   → [["-12"],["-12",7],["-12",7,-1],["-12",7,-1,-12],["-12",7,-1,-12,4]]
  P    # Take the product of each inner list (and output implicitly)
       #  i.e. [["-12"],["-12",7],["-12",7,-1],["-12",7,-1,-12],["-12",7,-1,-12,4]]
       #   → [-12,-84,84,-1008,-4032]

Comments

नहीं, sअन्य इनपुट प्राप्त करने के लिए वहाँ था। :) sस्वैप है, और šसूची की शुरुआत में प्रीपेड है। किसी भी तरह, -2 के लिए धन्यवाद

— केविन क्रूज़सेन

Answer 17

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

*FR._s

परीक्षण है कि यहाँ एक!

वैकल्पिक रूप से, 7 बाइट्स:

.u*NYEQ

इसे यहाँ टेस्ट करें!

पहला इनपुट को टुपल के रूप में लेता है, दूसरा इनपुट को दो अलग-अलग लाइनों के रूप में लेता है।

मैपिंग में अच्छी मदद करने और 1 बाइट बचाने के लिए @Sok का धन्यवाद।

Comments

आप नक्शे को दूसरे समाधान में लागू करके एक बाइट को बचा सकते हैं R, जैसे कि *FR._s- प्रदर्शन

— सोक

@Sok अच्छा पकड़! मैंने Mयह मानकर काम करने की कोशिश की थी , तब चीनी की पार्स विफलता मिली - ज्यादातर क्योंकि मुझे याद नहीं था कि कैसे F <pf2>काम करने के लिए पार्सिंग किया गया था।

— स्टीवन एच।

मैं ईमानदार हो जाएगा, मैं सच में समझ में नहीं आता कि कैसे नेस्ट M, F, L, और Rकाम करते हैं, मैं तो बस एक गुच्छा की कोशिश की जब तक एक काम किया: ओ)

— सोक

Answer 18

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

f=lambda a,b:[a]+(b and f(a*b[0],b[1:]))

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

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

Answer 19

पॉवरशेल , 29 बाइट्स

param($a,$b)$a;$b|%{($a*=$_)}

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

यह मान लिया गया है कि मानों का उत्पादन ठीक है।

> .\scratch.ps1 1 (1,5,3,2)
1
1
5
15
30

अगर यह ठीक नहीं है, तो यह वास्तव में सूची बनाता है और फिर उसे आगे बढ़ाता है जो उसी तरह प्रिंट करता है।

param($a,$b)$c=,$a;$b|%{$c+=$_*$c[-1]};$c #41 bytes

Comments

नियम हैं: Output is a list/array/vector/। तो, पहले ठीक है।

— mazzy

Answer 20

मठगोल्फ , 6 5 बाइट्स

\{\o*

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

मुझे लगता है कि यह 5 बाइट्स हो सकता है ( \{\o*) लेकिन \इनपुट के साथ काम करते समय निर्देश थोड़ा हटकर लगता है। यह अब नवीनतम संस्करण में तय हो गया है।

स्पष्टीकरण:

\       Swap arguments, pushing both to stack
 {      Foreach loop over second argument
  \o    Output counter with newline
    *   Multiply counter by current element
        Implicitly output the last element

Comments

मैंने अंतर्निहित इनपुट के साथ `` की हैंडलिंग को फिर से डिजाइन किया है। यह अभी भी उसी तरह से स्टैक पर आइटम को संभालता है, लेकिन अब यह केवल एक के बजाय स्टैक पर इनपुट से दो तत्वों को पॉप करता है। मुझे लगता है कि यह इस चुनौती के लिए उपयोगी हो सकता है।

— अधिकतम

Answer 21

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

lambda n,A:reduce(lambda a,c:a+[a[-1]*c],A,[n])

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

Comments

यह आप के लिए ब्याज की हो सकती है कि एक अजगर समाधान जनरेटर 3 का उपयोग करके अजगर 3 में छोटा है

— क्विंटेक

Answer 22

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

ＩＥ⁺⟦Ｎ⟧ＡΠ⊞Ｏυι

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

    Ｎ           Input a₀
   ⟦ ⟧          Wrap in a list
      Ａ         Input deltas as a list
  ⁺              Concatenate lists
 Ｅ              Map over elements
           ι    Current element
          υ     Predefined empty list variable
        ⊞Ｏ      Push and return updated list
       Π        Product
Ｉ               Cast to string
                Implicitly print each value on its own line

Answer 23

के (ओके) , 9 बाइट्स

{(*\)x,y}

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

एक सूची के रूप में दूसरे इनपुट में पहले नंबर से जुड़ता है, और फिर गुणन के क्रमिक परिणाम देता है

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

नीचे दिए गए फ़ंक्शन के बाद अपना इनपुट दर्ज करें और फिर चलाएं, क्योंकि मैं अनिश्चित हूं कि इस भाषा के लिए ठीक से इनपुट का उपयोग कैसे करें

{(*\)x,y}[1;1 5 3 2]

Answer 24

डीसी , 13 बाइट्स

p[*pz1<A]dsAx

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

p[*pz1<A]dsAx
p               # Print the first element
  *p            # Multiply top elements on the stack
 [  z1<A]dsAx   # until only one element is left