Definiamo i "delta moltiplicativi" dei valori come: $[\; a_0, \cdots a_N, \;]$

[a_{1} / a_{0}, \dots, a_{i + 1} / a_{i}, \dots, a_{N} / a_{N - 1}]

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

L'operazione inversa - vale a dire "undelta moltiplicativa" - restituisce valori tali che l'operazione sopra indicata risulta nei valori indicati.

Esempio

Valori dati una soluzione generale all'operazione " undelta moltiplicativa " è: $[\; 1, 5, 3, 2 \;]$

[a_{0}, \underset{a_{1}}{\underset{⏟}{a_{0} \cdot 1}}, \underset{a_{2}}{\underset{⏟}{a_{1} \cdot 5}}, \underset{a_{3}}{\underset{⏟}{a_{2} \cdot 3}}, \underset{a_{4}}{\underset{⏟}{a_{3} \cdot 2}}]

$[\; 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}} \;]$

Una soluzione particolare può essere ottenuta impostando su qualsiasi valore diverso da zero, ad esempio impostando otterremmo: $a_0$ $a_0 := 1$

[1, 1, 5, 15, 30]

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

Sfida

Il tuo compito per questa sfida è implementare l'operazione " undelta moltiplicativa " come definito sopra.

Regole

Gli input sono:

un valore diverso da zero $a_0$
una lista non vuota / matrice / vettore / ... di "diversi da zero delta moltiplicativi "

L'output è un elenco / array / vettore / ... di valori tali che il primo elemento è e per il quale i " delta moltiplicativi " sono l'input. $a_0$

Nota: se la tua lingua non supporta gli interi negativi, puoi sostituire non zero con positivo .

Casi test

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]

code-golf array-manipulation integer

— ბიმო
fonte

Possiamo prendere un unico elenco di lunghezza 1 + numero di delta, in cui il primo elemento è a₀?

— Adám,

@Adám: sto per dire di no perché cambierebbe le cose per le risposte esistenti.

— ბიმო

17

Haskell, 8 byte

scanl(*)

Provalo online!

— Nome del modello
fonte

Stavo controllando se qualcuno avesse scritto questo, e pensavo che nessuno lo avesse scritto e ho detto "fico, allora scriverò" e poi ho visto la tua risposta in fondo alla pagina. upvoted.

— Windmill Cookies

9

APL (Dyalog), 3 byte

×\∊

Provalo online!

Se devo prendere il numero a sinistra e l'array a destra:

-2 grazie a @ H.PWiz

7 5 3 byte

×\,

— Quintec
fonte

2

⊣,⊢può essere solo,

— H.Piz,

@HPWiz grazie, il mio tacito è estremamente debole

— Quintec

Non hai bisogno dei genitori; ×\,valuta una funzione.

— Dennis,

@Dennis Purtroppo non sembra funzionare

— Quintec,

Non è necessario contare le parentesi, perché non sono necessarie in alcune situazioni. f←×\funziona, per esempio. A proposito, (-12 3 -17 1311)dovrebbe essere il tuo permalink (¯12 3 ¯17 1311).

— Dennis,

8

R , 15 byte

cumprod(scan())

Provalo online!

Programma completo. La funzione è più lunga (a meno che non ci sia permesso di "incollare" insieme gli input, in modo che il built-in sia cumprodsufficiente come risposta completa):

R , 28 byte

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

Provalo online!

— Kirill L.
fonte

5

MATL , 3 byte

hYp

Provalo online!

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

La hYpe su MATL è reale.

— Giuseppe
fonte

3

JavaScript (ES6), 27 byte

Accetta input come (m)(a).

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

Provalo online!

— Arnauld
fonte

3

Japt, 3 byte

å*V

Provalo

Spiegazione

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

— ispido
fonte

3

Python 3, 39 byte

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

Approccio alternativo. Restituisce un generatore.

Provalo online!

— Quintec
fonte

2

Gelatina , 3 byte

;×\

Provalo online!

— Erik the Outgolfer
fonte

2

Wolfram Language (Mathematica) , 14 byte

FoldList@Times

Provalo online!

FoldList[Times, a0, {x1, x2, ..., xn}]produce l'output desiderato. FoldList[Times]è la forma al curry che produce una funzione pura ancora in attesa della sua a0e {x1, x2, ..., xn}.

— Misha Lavrov
fonte

2

Perl 6 , 9 byte

{[\*] @_}

Provalo online!

— nwellnhof
fonte

2

ML standard , 32 byte

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

Provalo online!

Ungolfed:

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

— Laikoni
fonte

2

J , 6 5 byte

-1 byte grazie a Gorgogliatore

*/\@,

Provalo online!

Spiegazione:

Un verbo diadico, l'argomento di sinistra è a0, quello giusto - il vettore

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

— Galen Ivanov
fonte

1

*/\@,funziona esattamente allo stesso modo.

— Bubbler,

@Bubbler Sì, certo! Grazie!

— Galen Ivanov,

1

Lotto, 69 byte

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

$a_0$

— Neil
fonte

1

Lisp comune, 67 byte

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

Provalo online!

— Renzo
fonte

1

Buccia , 2 byte

G*

Provalo online!

Ciò equivale alla risposta di Nimi in Haskell: scanl(*)ciò significa ridurre da sinistra usando la moltiplicazione e restituire tutti i risultati parziali.

— Leo
fonte

1

05AB1E , 5 3 byte

šηP

-2 byte grazie a @BMO .

Provalo online o verifica tutti i casi di test .

Spiegazione:

š      # 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]

— Kevin Cruijssen
fonte

1

No, sera lì per ottenere l'altro input. :) sè swap e šsta anteponendo all'inizio dell'elenco. Ad ogni modo, grazie per il -2

— Kevin Cruijssen,

1

Pyth, 6 byte

*FR._s

Prova quello qui!

In alternativa, 7 byte:

.u*NYEQ

Provalo qui!

Il primo accetta input come tupla, il secondo accetta input come due righe separate.

Grazie a @Sok per avermi aiutato a diventare bravo a mappare e salvare 1 byte.

— Steven H.
fonte

1

È possibile salvare un byte implementando la mappa nella seconda soluzione come R, come in *FR._s- dimostrazione

— Visto

@Sok Bella cattura! Avevo provato a Mpensare che avrebbe funzionato, poi avevo avuto un fallimento dell'analisi dello zucchero, soprattutto perché non ricordavo come funzionava l'analisi F <pf2>.

— Steven H.

Sarò onesto, io non capisco come nidificati M, F, L, e Ril lavoro, ho appena provato un mucchio fino a quando uno ha funzionato: o)

— Sok

1

Python 2 , 40 byte

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

Provalo online!

Sorprendentemente, il passaggio a Python 3 e l'uso di generatori consente di salvare solo 1 byte sulla soluzione ricorsiva.

— Steven H.
fonte

1

PowerShell , 29 byte

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

Provalo online!

Ciò presuppone che l'output dei valori sia corretto.

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

Se non va bene, questo in realtà crea l'elenco e quindi lo spinge su String che stampa allo stesso modo.

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

— Veskah
fonte

Le regole sono: Output is a list/array/vector/. Quindi, il primo va bene.

— mazzy,

1

MathGolf , 6 5 byte

\{\o*

Provalo online!

~~Penso che questo potrebbe essere di 5 byte ( \{\o*) ma l' \istruzione sembra un po 'off quando si tratta di input.~~ Questo problema è stato risolto nell'ultima versione.

Spiegazione:

\       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

— Jo King
fonte

Ho riprogettato la gestione di `` con input implicito. Gestisce comunque gli oggetti nello stack allo stesso modo, ma ora fa apparire due elementi dall'input nello stack anziché solo uno. Penso che potrebbe essere utile per questa sfida.

— massimo

0

Python 2 , 47 byte

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

Provalo online!

— Chas Brown
fonte

Potrebbe interessarti che una soluzione Python sia più breve in Python 3 usando i generatori

— Quintec,

0

Carbone , 12 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    Ｎ           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

— Neil
fonte

0

K (oK) , 9 byte

{(*\)x,y}

Provalo online!

Unisce il primo numero al secondo input come un elenco, quindi restituisce i risultati successivi della moltiplicazione

Casi test

Inserisci il tuo input dopo la funzione come sotto e quindi esegui, poiché non sono sicuro di come utilizzare l'input correttamente per questa lingua in TiO

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

— Thaufeki
fonte

0

dc , 13 byte

p[*pz1<A]dsAx

Provalo online!

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

— eush77
fonte

Undelta moltiplicativa

Esempio

Sfida

Regole

Casi test

Haskell, 8 byte

APL (Dyalog), 3 byte

R , 15 byte

R , 28 byte

MATL , 3 byte

JavaScript (ES6), 27 byte

Japt, 3 byte

Spiegazione

Python 3, 39 byte

Gelatina , 3 byte

Wolfram Language (Mathematica) , 14 byte

Perl 6 , 9 byte

ML standard , 32 byte

J , 6 5 byte

Spiegazione:

Lotto, 69 byte

Lisp comune, 67 byte

Buccia , 2 byte

05AB1E , 5 3 byte

Pyth, 6 byte

Python 2 , 40 byte

PowerShell , 29 byte

MathGolf , 6 5 byte

Spiegazione:

Python 2 , 47 byte

Carbone , 12 byte

K (oK) , 9 byte

dc , 13 byte