Undelta multiplicativo

9

Definamos los "deltas multiplicativos" de los valores $[\; a_0, \cdots a_N, \;]$ como:

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

La operación inversa, a saber, "undelta multiplicativa" , devuelve valores tales que la operación anterior da como resultado los valores dados.

Ejemplo

Valores dados una solución general para la operación " undelta multiplicativa " es: $[\; 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}} \;]$

Se puede obtener una solución particular configurando $a_0$ a cualquier valor que no sea cero, por ejemplo, configurando $a_0 := 1$ obtendríamos:

[1, 1, 5, 15, 30]

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

Desafío

Su tarea para este desafío es implementar la operación " multiplicativa undelta " como se definió anteriormente.

Reglas

Las entradas son:

un valor distinto de cero $a_0$
una lista no vacía / matriz / vector / ... de no-cero " deltas multiplicativos "

La salida es una lista / matriz / vector / ... de valores de modo que el primer elemento es $a_0$ y para el cual los " deltas multiplicativos " son la entrada.

Nota: si su idioma no admite números enteros negativos, puede reemplazar un valor distinto de cero por positivo .

Casos de prueba

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

— ბიმო
fuente

¿Podemos tomar una sola lista de longitud 1 + número de deltas, donde el primer elemento es a₀?

— Adám

@ Adám: Voy a decir que no a eso porque cambiaría las cosas para las respuestas existentes.

— ბიმო

Respuestas:

17

Haskell, 8 bytes

scanl(*)

Pruébalo en línea!

— nimi
fuente

Estaba comprobando si alguien escribió esto, y pensé que nadie lo escribió y dije "genial, entonces escribiré" y luego vi su respuesta al final de la página. Votado

— Windmill Cookies

9

APL (Dyalog), 3 bytes

×\∊

Pruébalo en línea!

Si tengo que tomar el número a la izquierda y la matriz a la derecha:

-2 gracias a @ H.PWiz

7 5 3 bytes

×\,

— Quintec
fuente

2

⊣,⊢puede ser solo,

— H.PWiz

@ H.PWiz gracias, mi tácito es extremadamente débil

— Quintec

No necesitas los parens; ×\,evalúa a una función.

— Dennis

@Dennis no parece funcionar desafortunadamente

— Quintec

No es necesario contar los padres, porque no son necesarios en algunas situaciones. f←×\funciona, por ejemplo. Por cierto, el (-12 3 -17 1311)en su enlace permanente debería ser (¯12 3 ¯17 1311).

— Dennis

8

R , 15 bytes

cumprod(scan())

Pruébalo en línea!

Programa completo La función es más larga (a menos que se nos permita "pegar" las entradas juntas, de modo quecumprod sería suficiente como respuesta completa):

R , 28 bytes

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

Pruébalo en línea!

— Kirill L.
fuente

5

MATL , 3 bytes

hYp

Pruébalo en línea!

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

La hYpinformación sobre MATL es real.

— Giuseppe
fuente

3

JavaScript (ES6), 27 bytes

Toma entrada como (m)(a).

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

Pruébalo en línea!

— Arnauld
fuente

3

Japt, 3 bytes

å*V

Explicación

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

— Lanudo
fuente

3

Python 3, 39 bytes

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

Enfoque alternativo. Devuelve un generador.

Pruébalo en línea!

— Quintec
fuente

2

Jalea , 3 bytes

;×\

Pruébalo en línea!

— Erik el Outgolfer
fuente

2

Wolfram Language (Mathematica) , 14 bytes

FoldList@Times

Pruébalo en línea!

FoldList[Times, a0, {x1, x2, ..., xn}]produce la salida deseada. FoldList[Times]es la forma curry que produce una función pura que todavía espera su a0y {x1, x2, ..., xn}.

— Misha Lavrov
fuente

2

Perl 6 , 9 bytes

{[\*] @_}

Pruébalo en línea!

— nwellnhof
fuente

2

ML estándar , 32 bytes

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

Pruébalo en línea!

Sin golf:

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

— Laikoni
fuente

2

J , 6 5 bytes

-1 byte gracias a Bubbler

*/\@,

Pruébalo en línea!

Explicación:

Un verbo diadico, el argumento de la izquierda es a0, el derecho: el vector

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

— Galen Ivanov
fuente

1

*/\@,Funciona exactamente igual.

— Bubbler

@Bubbler ¡Sí, por supuesto! ¡Gracias!

— Galen Ivanov

1

Lote, 69 bytes

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

$a_0$

— Neil
fuente

1

Lisp común, 67 bytes

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

Pruébalo en línea!

— Renzo
fuente

1

Casco , 2 bytes

G*

Pruébalo en línea!

Esto es equivalente a la respuesta de nimi en Haskell: lo scanl(*)que significa reducir desde la izquierda usando la multiplicación y devolver todos los resultados parciales.

— León
fuente

1

05AB1E , 5 3 bytes

šηP

-2 bytes gracias a @BMO .

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

1

No, sestaba allí para obtener la otra entrada. :) ses swap y šestá precediendo al comienzo de la lista. De cualquier manera, gracias por el -2

— Kevin Cruijssen

1

Pyth, 6 bytes

*FR._s

¡Prueba esa aquí!

Alternativamente, 7 bytes:

.u*NYEQ

¡Pruébalo aquí!

El primero toma la entrada como una tupla, el segundo toma la entrada como dos líneas separadas.

Gracias a @Sok por ayudarme a mejorar el mapeo y guardar 1 byte.

— Steven H.
fuente

1

Puede guardar un byte implementando el mapa en la segunda solución como R, como en *FR._s- demostración

— Sok

@Sok ¡Buena captura! Intenté Msuponer que funcionaría, luego obtuve un fallo de análisis de azúcar, principalmente porque no recordaba cómo funcionaba el análisis F <pf2>.

— Steven H.

Voy a ser honesto, realmente no entiendo cómo anidado M, F, L, y Rel trabajo, que acaba de intentar un montón hasta que se trabajó: o)

— Sok

1

Python 2 , 40 bytes

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

Pruébalo en línea!

Sorprendentemente, el cambio a Python 3 y el uso de generadores allí solo ahorran 1 byte sobre la solución recursiva.

— Steven H.
fuente

1

PowerShell , 29 bytes

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

Pruébalo en línea!

Esto supone que simplemente generar los valores está bien.

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

Si eso no está bien, esto realmente construye la lista y luego la empuja a toString, que se imprime de la misma manera.

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

— Veskah
fuente

Las reglas son: Output is a list/array/vector/. Entonces, el primero está bien.

— mazzy

1

MathGolf , 6 5 bytes

\{\o*

Pruébalo en línea!

~~Creo que esto podría ser 5 bytes ( \{\o*) pero la \instrucción parece un poco apagada cuando se trata de entrada.~~ Esto ahora está arreglado en la última versión.

Explicación:

\       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
fuente

He rediseñado el manejo de `` con entrada implícita. Todavía maneja elementos en la pila de la misma manera, pero ahora muestra dos elementos de la entrada en la pila en lugar de solo uno. Creo que podría ser útil para este desafío.

— maxb

0

Python 2 , 47 bytes

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

Pruébalo en línea!

— Chas Brown
fuente

Puede interesarle que una solución de Python sea más corta en Python 3 usando generadores

— Quintec

0

Carbón de leña , 12 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

    Ｎ           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
fuente

0

K (oK) , 9 bytes

{(*\)x,y}

Pruébalo en línea!

Une el primer número a la segunda entrada como una lista y luego devuelve resultados sucesivos de multiplicación

Casos de prueba

Ingrese su entrada después de la función como se muestra a continuación y luego ejecute, ya que no estoy seguro de cómo usar la entrada correctamente para este idioma en TiO

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

— Thaufeki
fuente

0

cc , 13 bytes

p[*pz1<A]dsAx

Pruébalo en línea!

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
fuente

Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.

Licensed under cc by-sa 3.0 with attribution required.