Vamos definir f _n (k) como a soma dos primeiros k termos dos números naturais [1, ∞) onde cada número é repetido n vezes.

k       | 0    1    2    3    4    5    6    7    8    9
--------+-------------------------------------------------
f_1(k)  | 0    1    3    6    10   15   21   28   36   45
deltas  |   +1   +2   +3   +4   +5   +6   +7   +8   +9
--------+-------------------------------------------------
f_2(k)  | 0    1    2    4    6    9    12   16   20   25
deltas  |   +1   +1   +2   +2   +3   +3   +4   +4   +5
--------+-------------------------------------------------
f_3(k)  | 0    1    2    3    5    7    9    12   15   18
deltas  |   +1   +1   +1   +2   +2   +2   +3   +3   +3

As anti-diagonais disso, como uma matriz quadrada, são semelhantes à sequência A134546 da OEIS .

Desafio

Escreva um programa / função que utilize dois números inteiros não negativos nek e produza f _n (k) .

Especificações

• Aplicam- se as regras de E / S padrão .
• As brechas padrão são proibidas .
• Sua solução pode ser indexada em 0 ou 1 em n e / ou k, mas especifique qual.
• Esse desafio não é encontrar a abordagem mais curta em todos os idiomas, mas sim encontrar a abordagem mais curta em cada idioma .
• Seu código será pontuado em bytes , geralmente na codificação UTF-8, a menos que especificado de outra forma.
• Funções internas que computam essa sequência são permitidas, mas é recomendável incluir uma solução que não dependa de uma interna.
• Explicações, mesmo para idiomas "práticos", são incentivadas .

Casos de teste

Nesses casos de teste, n é indexado em 1 e k é indexado em 0.

n   k      fn(k)

1   2      3
2   11     36
11  14     17
14  21     28
21  24     27
24  31     38
31  0      0

Em alguns formatos melhores:

1 2
2 11
11 14
14 21
21 24
24 31
31 0

1, 2
2, 11
11, 14
14, 21
21, 24
24, 31
31, 0

Implementação de referência

Isso está escrito em Haskell .

f n k = sum $ take k $ replicate n =<< [1..]

Experimente online!

Esse desafio foi marcado na caixa de areia.

Ruby , 32 28 23 bytes

->n,k{k.step(0,-n).sum}

Experimente online!

Explicação

Vamos visualizar a soma como a área de um triângulo, por exemplo, com n = 3 e k = 10:

*
*
*
**
**
**
***
***
***
****

Em seguida, somamos por coluna em vez de linha: a primeira coluna é k, então k-n, k-2ne assim por diante.

Python 2 , 34 28 bytes

lambda n,k:(k+k%n)*(k/n+1)/2

Experimente online!

Obrigado Martin Ender, Neil e Sr. Xcoder por ajudar.

Casca , 4 bytes

Σ↑ṘN

Experimente online!

Explicação

Isso acaba sendo uma tradução direta da implementação de referência no desafio:

   N  Start from the infinite sequence of all natural numbers.
  Ṙ   Replicate each element n times.
 ↑    Take the first k values.
Σ     Sum them.

APL (Dyalog) , 12 10 8 bytes

+/∘⌈÷⍨∘⍳

Experimente online!

nà esquerda, k(0 indexado) à direita.

Mathematica, 40 bytes

Tr@Sort[Join@@Range@#2~Table~#][[;;#2]]&

Experimente online!

Tr[Range@(s=⌊#2/#⌋)]#+#2~Mod~#(s+1)&

Experimente online!

Mathematica, 18 bytes

por Martin Ender

Tr@Range[#2,0,-#]&

Experimente online!

n~Sum~{n,#2,0,-#}&

Experimente online!

MATL , 12 11 bytes

:iY"Ys0h1G)

Experimente online!

ké 0 indexado. Recebe a entrada na ordem inversa.

Guardado 1 byte graças a @Giuseppe

Gelatina , 5 bytes

Rxḣ³S

Mais um byte do que a solução Jelly do @ Mr.Xcoder, mas esta é a minha primeira submissão em Jelly e ainda estou confuso sobre como a testemunha de Jelly escolhe operandos, por isso ainda estou satisfeito. Observe que a ordem das entradas é kentão n.

Explicação

Rxḣ³S
R           Range: [1,2,...,k]
 x          Times: repeat each element n times: [1,1,1,2,2,2,...,n,n,n]
  ḣ³        Head: take the first k elements. ³ returns the first argument.
    S       Sum

Experimente online!

Gelatina , 4 bytes

Indexado 1

Ḷ:‘S

Experimente online! ou veja uma suíte de testes .

JavaScript (ES6),  24  21 bytes

Recebe entrada na sintaxe de currying (n)(k). Retorna em falsevez de0 .

n=>g=k=>k>0&&k+g(k-n)

Casos de teste

let f =

n=>g=k=>k>0&&k+g(k-n)

console.log(f(1 )(2 )) // 3
console.log(f(2 )(11)) // 36
console.log(f(11)(14)) // 17
console.log(f(14)(21)) // 28
console.log(f(21)(24)) // 27
console.log(f(24)(31)) // 38

Quão?

n =>             // main unamed function taking n
  g = k =>       // g = recursive function taking k
    k > 0 &&     // if k is strictly positive:
      k +        //   add k to the final result
      g(k - n)   //   subtract n from k and do a recursive call

Isso é semelhante a resposta Ruby do @ GB .

O desafio descreve como construir a 'escada' da esquerda para a direita, enquanto essa função recursiva a constrói de baixo para cima. Com n = 2 e k = 11 :

Lote, 34 bytes

@cmd/cset/a(%2+%2%%%1)*(%2/%1+1)/2

Uma fórmula de formulário fechado que eu encontrei. O primeiro argumento né indexado em 1, o segundo argumento ké indexado em 0.

Python 2 , 29 bytes

lambda n,k:sum(range(k,0,-n))

Experimente online!

Graças a totallyhuman por -3 bytes!

Python 2 , 30 bytes

f=lambda n,k:k>0and k+f(n,k-n)

Experimente online!

Haskell , 28 bytes

n#k|m<-k`mod`n=sum[m,m+n..k]

Experimente online!

Uma abordagem que encontrei apenas mexendo com alguns parâmetros de faixa. Definitivamente, não é o mais curto, mas é muito legal como existem tantas abordagens diferentes.

C, 38 34 bytes

Definição recursiva.

-4 bytes graças ao Steadybox .

f(n,k){return k--?1+f(n,k)+k/n:0;}

Experimente online!

32 bytes por Mr. Xcoder , GB

f(n,k){return(k+k%n)*(k/n+1)/2;}

Experimente online!

R , 37 33 31 bytes

-6 bytes graças a Giuseppe

function(n,k)sum(rep(1:k,,k,n))

Experimente online!

Nada chique. Ele [0:k]lida com o caso quando k = 0.

C ++, 53 bytes

Basta usar a fórmula. né indexado em 1 e ké indexado em 0.

[](int n,int k){return k/n*(k/n+1)/2*n+k%n*(k/n+1);};

Experimente online!

J , 13 bytes

1#.]{.(#1+i.)

Como funciona:

O argumento da esquerda é n, o da direita é k.

i. gera uma lista 0..k-1

1+ adiciona um a cada número da lista, resultando em 1,2, ..., k

# forma um gancho com o acima, portanto, n cópias de cada elemento da lista são copiadas.

]{. pegue o primeiro n deles

1#. encontre a soma por conversão base.

Experimente online!

Retina , 29 26 bytes

\d+
$*
(?=.*?(1+)$)\1
$'
1

Experimente online! O link inclui casos de teste e cabeçalho para reformatá-los para sua entrada preferida ( kprimeiro indexado 0 , nsegundo indexado 1 ). Fui inspirado pela resposta Ruby do @ GB. Explicação:

\d+
$*

Converta para unário.

(?=.*?(1+)$)\1
$'

Combine cada sequência de ndentro ke substitua a partida por tudo após a partida. Isto é k-n, k-2n, k-3n, mas né também após o jogo, de modo a obter k, k-n, k-2netc. Isso também corresponde n, que é simplesmente eliminado (ele não é mais necessário).

1

Soma os resultados e converta novamente em decimal.

Pitão , 5 bytes

s%_ES

Experimente aqui!

Resposta do porto de Ruby da GB. Uma porta do meu Jelly seria de 6 bytes:+s/Rvz

Perl 6 , 39 bytes

->\n,\k{(0,{|($_+1 xx n)}...*)[^k].sum}

Teste-o

n e k são ambos um baseado

Expandido:

-> \n, \k { # pointy block lambda with two parameters ｢n｣ and ｢k｣

  ( # generate the sequence

    0,         # seed the sequence (this is why ｢k｣ is 1-based)

    {          # bare block lambda with implicit parameter ｢$_｣
      |(       # slip this into outer sequence
        $_ + 1 # the next number
        xx n   # repeated ｢n｣ times (this is why ｢n｣ is 1-based)
      )
    }

    ...        # keep doing that until

    *          # never stop

  )[ ^k ]      # get the first ｢k｣ values from the sequence
  .sum         # sum them
}

Kotlin , 40 bytes

{n:Int,k:Int->Array(k,{i->i/n+1}).sum()}

Experimente online!

Java (OpenJDK 8) , 23 bytes

n->k->(k+k%n)*(k/n+1)/2

Experimente online!

Porta do Python 2 da GB resposta .

05AB1E , 9 bytes

FL`}){I£O

Experimente online!

Explicação

F           # n times do
 L`         # pop top of stack (initially k), push 1 ... topOfStack
   }        # end loop
    )       # wrap stack in a list
     {      # sort the list
      I£    # take the first k elements
        O   # sum

Python 2 , 44 bytes

f=lambda n,k:sum(sorted(range(1,k+1)*n)[:k])

Experimente online!

Python 2 , 38 bytes

lambda n,k:sum(i/n+1for i in range(k))

Experimente online!

Clojure, 54 bytes

#(nth(reductions +(for[i(rest(range))j(range %)]i))%2)

O segundo argumento ké indexado em 0, assim (f 14 20)como 28.

APL + WIN, 13 bytes

+/⎕↑(⍳n)/⍳n←⎕

Solicita a entrada na tela para ne depois para k. Origem do índice = 1.

Brain-Flak , 78 bytes

(({}<>)<{<>(({})<>){({}[()]<(({}))>)}{}({}[()])}{}<>{}>)({<({}[()])><>{}<>}{})

Experimente online!

Estou certo de que isso pode ser feito melhor, mas é um começo.

Japonês , 7 6 bytes

Originalmente inspirado na solução da GB e evoluído para uma porta!

Toma kcomo a primeira entrada e ncomo a segunda.

õ1Vn)x

Tente

Explicação

Entrada implícita de números inteiros U=k& V=n. Gere uma matriz de números inteiros ( õ) de 1para Ucom uma etapa Vnegada ( n) e reduza-a por adição ( x).

R , 27 bytes

Função anônima que leva ke nnessa ordem. Cria uma lista de comprimento k(terceiro argumento para rep) que é composto 1por k(primeiro argumento para rep), repetindo cada elemento nvezes (quarto argumento para rep). Depois pega a soma dessa lista.

né indexado em 1 e ké indexado em 0. Retorna um erro para n<1.

pryr::f(sum(rep(1:k,,k,n)))

Experimente online!

Befunge, 27 bytes

&::00p&:10p%+00g10g/1+*2/.@

Experimente Online

Leva k e n como entrada. Usa a resposta do GB como base matemática.