让我们将f _n（k）定义为自然数[1，∞）的前k个项的和，其中每个数字重复n次。

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

作为正方形阵列的反对角线类似于OEIS序列A134546。

挑战

编写一个接受两个非负整数n和k并输出f _n（k）的程序/函数。

技术指标

适用标准I / O规则。
标准的漏洞被禁止。
您的解决方案可以是n和/或k的0索引或1索引，但是请指定。
挑战并不是要找到所有语言中最短的方法，而是要找到每种语言中最短的方法。
除非另有说明，否则您的代码将以字节计分，通常采用UTF-8编码。
允许使用内置函数来计算此序列，但鼓励使用不依赖内置函数的解决方案。
鼓励甚至对“实用”语言进行解释。

测试用例

在这些测试用例中，n为1索引，k为0索引。

n   k      f_n(k)

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

有几种更好的格式：

参考实施

这是用Haskell编写的。

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

在线尝试！

这个挑战被沙盒化了。

— 全人类
source

您认为我的编辑可以改善格式，还是仅在浏览器上？

— user202729

@ user202729呵呵...它在我的浏览器上看起来不对，但是我怀疑我的格式在大多数浏览器上看起来都不错...我只是保持那样，它不会失去任何意义。看起来很奇怪。：P

— totallyhuman

我们需要处理的情况下f_n(0) = 0为k0索引？

— Cinaski

9

“ 很酷的无标题序列很麻烦 ”大声笑，我不是唯一一个很难为我编造的序列命名的人..；）

— Kevin Cruijssen

3

@Fabian不，您只求和k重复自然数列表中的第一n*k项，而不是第一项。

— 马丁·恩德

12

红宝石，32 28 23字节

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

在线尝试！

说明

让我们将总和可视化为三角形的面积，例如n = 3和k = 10：

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

然后我们总结柱，而不是行：第一列是k，那么k-n，k-2n等等。

— 国标
source

8

Python 2中，34 28个字节

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

在线尝试！

感谢Martin Ender，Neil和Xcoder先生的帮助。

— 国标
source

1

k/n无论如何，您实际上并不需要- k-(k/n)*n只是k%n。请参阅我的批处理答案。

— 尼尔

28位元组

— Xcoder先生17年

谢谢。我不认为它会变得如此简单。

— GB

8

外壳，4个字节

Σ↑ṘN

在线尝试！

说明

这最终只是挑战中参考实现的直接翻译：

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

— 马丁·恩德
source

5

APL（Dyalog），12 10 8字节

+/∘⌈÷⍨∘⍳

在线尝试！

n在左侧，k（索引为0）在右侧。

— 尤里尔
source

5

Mathematica，40个字节

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

在线尝试！

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

在线尝试！

Mathematica，18个字节

马丁·恩德（Martin Ender）

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

在线尝试！

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

在线尝试！

— J42161217
source

2

Tr@Range[#2,0,-#]&或n~Sum~{n,#2,0,-#}&使用GB的Ruby答案中的技巧。

— 马丁·恩德

5

MATL，12 11字节

:iY"Ys0h1G)

在线尝试！

k索引为0。以相反的顺序输入。

@Giuseppe节省了1个字节

— 西纳斯基
source

5

果冻，5个字节

Rxḣ³S

比@ Mr.Xcoder的Jelly解决方案多了一个字节，但这是我在Jelly中的第一个提交，而且我仍然对Jelly的默认性如何选择操作数感到困惑，因此我仍然感到满意。需要注意的输入的顺序是k那么n。

说明

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

在线尝试！

— Dylnan
source

4

果冻，4字节

1索引

Ḷ:‘S

在线尝试！或查看测试套件。

— Xcoder先生
source

您可以进行0索引Ḷ:S

— 编制，

@dylnan实际上，我认为这不是0索引的含义。我回滚了，我们会看到

— Xcoder先生17年

@dylnan除以零是错误。

— 暴民埃里克（Erik the Outgolfer）

4

JavaScript（ES6）， 24个 21字节

以currying语法接受输入(n)(k)。返回false而不是0。

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

测试用例

显示代码段

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

展开摘要

怎么样？

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

这类似于@GB的Ruby答案。

挑战描述了如何从左至右构建“楼梯”，而此递归函数从下至上进行构建。当n = 2且k = 11时：

— Arnauld
source

3

批次，34个字节

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

我发现的一个封闭式公式。第一个参数n为1索引，第二个参数k为0索引。

— 尼尔
source

3

Python 2，29个字节

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

在线尝试！

多亏了totalhuman的-3个字节！

Python 2，30个字节

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

在线尝试！

— Xcoder先生
source

3

Haskell，28个字节

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

在线尝试！

我通过拧紧一些范围参数发现了一种方法。绝对不是最短的，但是有这么多种方法是很酷的。

— 全人类
source

3

C，38 34字节

递归定义。

-4字节，感谢Steadybox。

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

在线尝试！

32个字节的Xcoder先生，GB

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

在线尝试！

— 苏
source

Python中34字节，C中36字节

— Xcoder先生，2017年

1

使用GB的方法，32字节

— Xcoder先生，2017年

tio.run/…- > 28字节

— GB

1

34个字节（递归版本）：f(n,k){return k--?1+f(n,k)+k/n:0;} 在线尝试！

— Steadybox '17

3

R，37 33 31字节

-6字节归功于Giuseppe

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

在线尝试！

没有什么花哨。~~所述[0:k]手柄的情况下k = 0时。~~

— NofP
source

1

您可以在这里摆脱括号。如果您使用的有序参数rep.default，则可以[0:k]通过使用摆脱，rep(1:k,,k,n)但是您的答案基本上是rturnbull的，但基数为R而不是R + pryr

— Giuseppe

1

您仍然可以摆脱括号！{}

— 朱塞佩

[0：k]替代让我忘了大括号:)

— NofP

2

C ++，53个字节

只需使用公式。n是1索引和k0索引。

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

在线尝试！

— 苏
source

滥用~操作员可以节省几个字节。[](int n,int k){return-k/n*~(k/n)/2*n-k%n*~(k/n);};

— ceilingcat '17

2

J，13个字节

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

怎么运行的：

左边的参数是n，右边的参数是k。

i. 生成列表0..k-1

1+ 在列表的每个数字上加一个，即1,2，...，k

# 与上面的内容形成一个钩子，因此将复制列表的每个元素的n个副本。

]{. 拿他们的第一个

1#. 通过基本转换找到它们的总和。

在线尝试！

— 加伦·伊万诺夫（Galen Ivanov）
source

我喜欢钩子。

— cole

2

视网膜，29 26字节

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

在线尝试！链接包括测试用例和标头，以将它们重新格式化为其首选输入（k第一个索引为0 ，n第二个索引为1 ）。@GB的Ruby回答启发了我。说明：

\d+
$*

转换为一元。

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

比赛的每一字符串n内k，并与赛后都更换了比赛。这是k-n，k-2n，k-3n，但n也是比赛结束后，让你得到k，k-n，k-2n等，这也匹配n，这是简单的删除（它不再需要）。

对结果求和，然后转换回十进制。

— 尼尔
source

2

Pyth，5个字节

s%_ES

在这里尝试！

GB的Ruby答案端口。我的果冻一个端口将是6个字节：+s/Rvz

— Xcoder先生
source

2

Perl 6，39个字节

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

测试一下

n和 k都基于1

展开：

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

— 布拉德·吉尔伯特b2gills
source

2

Kotlin，40个字节

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

在线尝试！

— 阿尔维斯
source

2

Java（OpenJDK 8），23字节

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

在线尝试！

GB的Python 2答案端口。

— 奥利维尔·格雷戈尔（OlivierGrégoire）
source

1

05AB1E，9个字节

FL`}){I£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

— 艾米尼亚
source

1

Python 2，44字节

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

在线尝试！

— 场
source

1

Python 2，38个字节

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

在线尝试！

— 竿
source

1

Clojure，54个字节

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

第二个参数k是0索引，所以(f 14 20)28。

— 尼古妮
source

1

APL + WIN，13个字节

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

提示输入n，然后输入k。索引原点= 1。

— 格雷厄姆
source

1

Brain-Flak，78个字节

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

在线尝试！

我敢肯定这可以做得更好，但这是一个开始。

— 小麦巫师
source

1

Japt，7 6字节

最初受到GB解决方案的启发演变为端口！

取k作为第一输入和n作为第二参数。

õ1Vn)x

尝试一下

说明

整数U=k＆的隐式输入V=n。õ从步骤1到生成整数数组（），并U加一个V负号（n），并通过加法（x）对其进行归约。

— 毛茸茸
source

1

R，27个字节

匿名函数，它k和n该命令。创建一个长度为k（的第三个参数rep）的列表，该列表由1直通k（的第一个参数rep）组成，并重复每个元素n次（的第四个参数为rep）。然后取该列表的总和。

n是1索引和k0索引。返回的错误n<1。

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

在线尝试！

— 土拨鼠
source

1

Befunge，27字节

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

在线试用

取k，然后取n作为输入。使用GB的答案作为其数学基础。

— 乔·金
source