cool untitled sequence thingy

Question

Let's define f_n(k) as the sum of the first k terms of the natural numbers [1, ∞) where each number is repeated n times.

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

The anti-diagonals of this as a square array is similar to OEIS sequence A134546.

Challenge

Write a program/function that takes two non-negative integers n and k and outputs f_n(k).

Specifications

• Standard I/O rules apply.
• Standard loopholes are forbidden.
• Your solution can either be 0-indexed or 1-indexed for n and/or k but please specify which.
• This challenge is not about finding the shortest approach in all languages, rather, it is about finding the shortest approach in each language.
• Your code will be scored in bytes, usually in the encoding UTF-8, unless specified otherwise.
• Built-in functions that compute this sequence are allowed but including a solution that doesn't rely on a built-in is encouraged.
• Explanations, even for "practical" languages, are encouraged.

Test cases

In these test cases, n is 1-indexed and k is 0-indexed.

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

In a few better formats:

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

Reference implementation

This is written in Haskell.

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

Try it online!

This challenge was sandboxed.

Answer 1

Ruby, 32 28 23 bytes

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

Try it online!

Explanation

Let's visualize the sum as the area of a triangle, for example with n=3 and k=10:

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

Then we sum by column instead of row: the first column is k, then k-n, k-2n and so on.

Answer 2

Python 2, 34 28 bytes

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

Try it online!

Thanks Martin Ender, Neil and Mr Xcoder for helping.

Answer 3

Husk, 4 bytes

Σ↑ṘN

Try it online!

Explanation

This just ends up being a direct translation of the reference implementation in the challenge:

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

Answer 4

APL (Dyalog), 12 10 8 bytes

+/∘⌈÷⍨∘⍳

Try it online!

n on the left, k (0 indexed) on the right.

Answer 5

Mathematica, 40 bytes

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

Try it online!

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

Try it online!

Mathematica, 18 bytes

by Martin Ender

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

Try it online!

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

Try it online!

Answer 6

MATL, 12 11 bytes

:iY"Ys0h1G)

Try it online!

k is 0-indexed. Takes input in reverse order.

Saved 1 byte thanks to @Giuseppe

Answer 7

Jelly, 5 bytes

Rxḣ³S

One more byte than @Mr.Xcoder's Jelly solution but this is my first ever submission in Jelly and I'm still confused about how the tacitness of Jelly chooses operands so I'm still satisfied. Note the order of the inputs are k then n.

Explanation

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

Try it online!

Answer 8

Jelly, 4 bytes

1-indexed

Ḷ:‘S

Try it online! or see a test suite.

Answer 9

JavaScript (ES6),  24  21 bytes

Takes input in currying syntax (n)(k). Returns false instead of 0.

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

Test cases

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

How?

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

This is similar to @GB's Ruby answer.

The challenge describes how to build the 'staircase' from left to right, whereas this recursive function builds it from bottom to top. With n = 2 and k = 11:

Answer 10

Batch, 34 bytes

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

A closed-form formula that I found. First argument n is 1-indexed, second argument k is 0-indexed.

Answer 11

Python 2, 29 bytes

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

Try it online!

Thanks to totallyhuman for -3 bytes!

---

Python 2, 30 bytes

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

Try it online!

Answer 12

Haskell, 28 bytes

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

Try it online!

An approach I found just by screwing around with some range parameters. Most definitely not the shortest but it's pretty cool how there's so many different approaches.

Answer 13

C, 38 34 bytes

Recursive definition.

-4 bytes thanks to Steadybox.

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

Try it online!

---

32 bytes by Mr. Xcoder, G B

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

Try it online!

Answer 14

R, 37 33 31 bytes

-6 bytes thanks to Giuseppe

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

Try it online!

Nothing fancy. The [0:k] handles the case when k=0.

Answer 15

C++, 53 bytes

Just use the formula. n is 1-indexed and k is 0-indexed.

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

Try it online!

Answer 16

J, 13 bytes

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

How it works:

The left argument is n, the right is k.

i. generates a list 0..k-1

1+ adds one to each number of the list, yealding 1,2,...,k

# forms a hook with the above, so n copies of each elements of the list are copied.

]{. take the first n of them

1#. find their sum by base conversion.

Try it online!

Answer 17

Retina, 29 26 bytes

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

Try it online! Link includes test cases and header to reformat them to its preferred input (0-indexed k first, 1-indexed n second). I was inspired by @GB's Ruby answer. Explanation:

\d+
$*

Convert to unary.

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

Match every string of n within k, and replace the match with everything after the match. This is k-n, k-2n, k-3n, but n is also after the match, so you get k, k-n, k-2n etc. This also matches n, which is simply deleted (it's no longer needed).

1

Sum the results and convert back to decimal.

Answer 18

Pyth, 5 bytes

s%_ES

Try it here!

Port of G B's Ruby answer. A port of my Jelly one would be 6 bytes: +s/Rvz

Answer 19

Perl 6, 39 bytes

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

Test it

n and k are both 1 based

Expanded:

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

Answer 20

Kotlin, 40 bytes

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

Try it online!

Answer 21

Java (OpenJDK 8), 23 bytes

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

Try it online!

Port of G B's Python 2 answer.

Answer 22

05AB1E, 9 bytes

FL`}){I£O

Try it online!

Explanation

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

Answer 23

Python 2, 44 bytes

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

Try it online!

Answer 24

Python 2, 38 bytes

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

Try it online!

Answer 25

Clojure, 54 bytes

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

2nd argument k is 0-indexed, so (f 14 20) is 28.

Answer 26

APL+WIN, 13 bytes

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

Prompts for screen input for n and then for k. Index origin = 1.

Answer 27

Brain-Flak, 78 bytes

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

Try it online!

I'm certain this can be done better, but it's a start.

Answer 28

Japt, 7 6 bytes

Originally inspired by GB's solution and evolved to a port!

Takes k as the first input and n as the second.

õ1Vn)x

Try it

---

Explanation

Implicit input of integers U=k & V=n. Generate an array of integers (õ) from 1 to U with a step of V negated (n) and reduce it by addition (x).

Answer 29

R, 27 bytes

Anonymous function that takes k and n in that order. Creates a list of length k (third argument to rep) that is composed of 1 through k (first argument to rep), repeating each element n times (fourth argument to rep). Then takes the sum of that list.

n is 1-indexed and k is 0-indexed. Returns an error for n<1.

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

Try it online!

Answer 30

Befunge, 27 Bytes

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

Try It Online

Takes k then n as input. Uses G B's answer as its mathematical basis.