Undelta multiplicativo

9

Vamos definir os "deltas multiplicativos" dos 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} \;]$

A operação reversa - ou seja, "undelta multiplicativo" - retorna valores de forma que a operação acima resulte nos valores fornecidos.

Exemplo

Valores fornecidos $[\; 1, 5, 3, 2 \;]$ uma solução geral para aoperação "undelta multiplicativa" é:

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

A solução particular pode ser obtido através da criação $a_0$ a qualquer valor diferente de zero, por exemplo através da criação $a_0 := 1$ obteríamos:

[1, 1, 5, 15, 30]

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

Desafio

Sua tarefa para este desafio é implementar a operação " undelta multiplicativo ", conforme definido acima.

Regras

As entradas são:

um valor diferente de zero $a_0$
uma lista não-vazia / array / vetor / ..., de "não-zero de deltas multiplicativos "

A saída é uma lista / matriz / vetor / ... de valores, de modo que o primeiro elemento seja $a_0$ e para o qual os " deltas multiplicativos " são a entrada.

Nota: Se o seu idioma não suportar números inteiros negativos, você poderá substituir diferente de zero por positivo .

Casos de teste

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

Podemos fazer uma lista única de comprimento 1 + número de deltas, onde o primeiro item é a₀?

— Adám 9/10/18

@ Adám: vou dizer não a isso, porque isso mudaria as respostas existentes.

— ბიმო

Respostas:

17

Haskell, 8 bytes

scanl(*)

Experimente online!

— nimi
fonte

Eu estava checando se alguém escreveu isso, e achei que ninguém havia escrito e eu disse "legal, então eu vou escrever" e então vi sua resposta na parte inferior da página. votado.

— 9338 Windmill Cookies

9

APL (Dyalog), 3 bytes

×\∊

Experimente online!

Se eu tiver que pegar o número à esquerda e a matriz à direita:

-2 graças a @ H.PWiz

7 5 3 bytes

×\,

— Quintec
fonte

2

⊣,⊢pode apenas ser #,

— 2140 H.PWiz

@ H.PWiz obrigado, meu tácito é extremamente fraco

— Quintec

Você não precisa dos parênteses; ×\,avalia como uma função.

— Dennis

@Dennis Não parece funcionar infelizmente

— Quintec

Você não precisa contar os parênteses, porque eles não são necessários em algumas situações. f←×\funciona, por exemplo. Btw, o (-12 3 -17 1311)em seu link permanente deve ser (¯12 3 ¯17 1311).

— Dennis

8

R , 15 bytes

cumprod(scan())

Experimente online!

Programa completo. A função é mais longa (a menos que tenhamos permissão para "colar" as entradas, para que a built-in cumprodseja suficiente como resposta completa):

R , 28 bytes

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

Experimente online!

— Kirill L.
fonte

5

MATL , 3 bytes

hYp

Experimente online!

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

O hYpe sobre MATL é real.

— Giuseppe
fonte

3

JavaScript (ES6), 27 bytes

Toma entrada como (m)(a).

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

Experimente online!

— Arnauld
fonte

3

Japonês, 3 bytes

å*V

Explicação

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

— Shaggy
fonte

3

Python 3, 39 bytes

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

Abordagem alternativa. Retorna um gerador.

Experimente online!

— Quintec
fonte

2

Gelatina , 3 bytes

;×\

Experimente online!

— Erik, o Outgolfer
fonte

2

Língua Wolfram (Mathematica) , 14 bytes

FoldList@Times

Experimente online!

FoldList[Times, a0, {x1, x2, ..., xn}]produz a saída desejada. FoldList[Times]é a forma ao curry que produz uma função pura ainda aguardando seu a0e {x1, x2, ..., xn}.

— Misha Lavrov
fonte

2

Perl 6 , 9 bytes

{[\*] @_}

Experimente online!

— Nwellnhof
fonte

2

ML padrão , 32 bytes

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

Experimente online!

Ungolfed:

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

— Laikoni
fonte

2

J , 6 5 bytes

-1 byte graças a Bubbler

*/\@,

Experimente online!

Explicação:

Um verbo diadico, o argumento da esquerda a0, o primeiro - o vetor

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

— Galen Ivanov
fonte

11

*/\@,funciona exatamente da mesma maneira.

— Bubbler

@Bblbler Sim, claro! Obrigado!

— Galen Ivanov

1

Lote, 69 bytes

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

$a_0$

— Neil
fonte

1

Lisp comum, 67 bytes

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

Experimente online!

— Renzo
fonte

1

Casca , 2 bytes

G*

Experimente online!

Isso é equivalente à resposta de nimi em Haskell:, scanl(*)que significa reduzir da esquerda usando multiplicação e retornar todos os resultados parciais.

— Leo
fonte

1

05AB1E , 5 3 bytes

šηP

-2 bytes graças a @BMO .

Experimente online ou verifique todos os casos de teste .

Explicação:

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

11

Não, o sestava lá para obter a outra entrada. :) sé swap e šestá sendo anexado no início da lista. De qualquer maneira, obrigado pelo -2

— Kevin Cruijssen 08/10

1

Pitão, 6 bytes

*FR._s

Teste esse aqui!

Como alternativa, 7 bytes:

.u*NYEQ

O primeiro recebe a entrada como uma tupla, o segundo recebe a entrada como duas linhas separadas.

Obrigado à @Sok por me ajudar a melhorar o mapeamento e economizar 1 byte.

— Steven H.
fonte

11

Você pode salvar um byte através da implementação do mapa na segunda solução como R, como em *FR._s- demonstração

— Sok

@Sok captura agradável! Eu tentei Msupor que funcionaria e depois tive uma falha na análise de açúcar - principalmente porque não me lembrava como a análise F <pf2>funcionava.

— Steven H.

Eu vou ser honesto, eu realmente não entendo como aninhados M, F, L, e Rtrabalho, eu apenas tentei um monte até que um trabalhou: o)

— Sok

1

Python 2 , 40 bytes

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

Experimente online!

Surpreendentemente, a mudança para o Python 3 e o uso de geradores lá economizam apenas 1 byte sobre a solução recursiva.

— Steven H.
fonte

1

PowerShell , 29 bytes

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

Experimente online!

Isso pressupõe que apenas a saída dos valores esteja correta.

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

Se isso não for bom, isso realmente cria a lista e a envia para aString que imprime da mesma maneira.

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

— Veskah
fonte

As regras são: Output is a list/array/vector/. Então, o primeiro está bem.

— Mazzy

1

MathGolf , 6 5 bytes

\{\o*

Experimente online!

~~Eu acho que isso pode ser 5 bytes ( \{\o*), mas\ instrução parece um pouco desligada ao lidar com entrada.~~ Agora isso foi corrigido na versão mais recente.

Explicaçã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

— Brincadeira
fonte

Redesenhei a manipulação de `` com entrada implícita. Ele ainda lida com itens da pilha da mesma maneira, mas agora lança dois elementos da entrada na pilha em vez de apenas um. Eu acho que poderia ser útil para esse desafio.

— maxb

0

Python 2 , 47 bytes

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

Experimente online!

— Chas Brown
fonte

Pode ser do seu interesse que uma solução python seja mais curta no python 3 usando geradores

— Quintec

0

Carvão , 12 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

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

{(*\)x,y}

Experimente online!

Une o primeiro número à segunda entrada como uma lista e retorna resultados sucessivos de multiplicação

Casos de teste

Digite sua entrada após a função como abaixo e execute, pois não tenho certeza de como usar a entrada corretamente para esse idioma no TiO

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

— Thaufeki
fonte

0

dc , 13 bytes

p[*pz1<A]dsAx

Experimente 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

Ao utilizar nosso site, você reconhece que leu e compreendeu nossa Política de Cookies e nossa Política de Privacidade.

Licensed under cc by-sa 3.0 with attribution required.