任务

给定输入正整数n（从1到您的语言限制，包括1），返回或输出相加为的最大不同正整数的最大数量n。

测试用例

让我们f根据任务定义一个有效的函数：

的序列f，从1开始：

1, 1, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6, ...

作为较大的测试用例：

>>> f(1000000000) // Might not be feasible with brute-forcers
44720

测试代码

对于未明确给出的任何测试用例，代码的输出应与以下结果相匹配：

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int x = sc.nextInt();
        System.out.println((int) Math.floor(Math.sqrt(2*x + 1./4) - 1./2));
    }
}

在线尝试！

05AB1E，4个字节

ÅTg<

在线尝试！

完美的工作工具。

ÅT产量列表埃会Ť riangular数至多并包括Ñ（不幸的是包括0太，否则这将是3个字节），g<得到LEN 克次和递减它。

果冻，6 5字节

R+\»ċ

在线尝试！

有点效率。该序列以三角数递增，因此仅计算有多少个三角数小于 n的。

说明：

        # Main link
R       # Range, generate [1..n]
 +\     # Cumulative sum (returns the first n triangular numbers)
   »    # For each element, return the maximum of that element and 'n'
    ċ   # How many elements are 'n'? (implicit right argument is n)

Haskell，26个字节

-2个字节感谢H.PWiz。

(!!)$do x<-[0..];x<$[0..x]

在线尝试！

这将返回整数的第n个元素，其中每个i被复制i +1次。

Brain-Flak，36个字节

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

在线尝试！

它使用与标准除法算法相同的结构，不同之处在于，每次读取“除数”时都会增加“除数”。

Pari / GP，19字节

n->((8*n+1)^.5-1)\2

在线尝试！

Brain-Flak，82字节

为“可读性”添加了空格

(())

{
    {}

    ((({})[[]]))

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

}{}{}{}

([]<>)

在线尝试！

果冻，7个字节

×8‘½’:2

在线尝试！

果冻，9个字节

Ḥ+4ݤ½_.Ḟ

在线尝试！

这比Dennis和DJ的时间更长，但这是有意的。非常非常有效率。

R，28个字节

function(n)rep(1:n,1:n+1)[n]

在线尝试！

创建1重复2次数，2重复3次数，...，n重复n+1次数的向量，并采用nth元素。这可能是由于1:n太大或由于包含n*(n+1)/2 - 1元素的重复列表太大而导致的内存错误。

R，29个字节

function(n)((8*n+1)^.5-1)%/%2

在线尝试！

使用alephalpha的答案中的公式直接计算值。除了可能的数值精度外，这应该没有问题。

R，30个字节

function(n)sum(cumsum(1:n)<=n)

在线尝试！

计算小于或等于的三角数n。如果1:n足够大，则可能会发生内存错误-例如，1e9抛出异常Error: cannot allocate vector of size 3.7 Gb。

APL（Dyalog），8字节

+/+\∘⍳<⊢

在线尝试！

TI基本（12字节）

int(√(2Ans+1/4)-.5

JavaScript（Node.js），18字节

x=>(x-~x)**.5-.5|0

在线尝试！

杰普特，8字节

封闭式解决方案。

*8Ä ¬É z

尝试一下

说明

乘以8，加1（Ä），得到平方根（¬），减去1（É），然后将结果除以2（z）。

备用，8字节

DJMcMayhem的Jelly解决方案端口。

õ å+ è§U

尝试一下

生成一个õ从1到输入的整数（）数组，å通过加法（+）累计减少（）并计数（è）小于或等于§输入（U）的元素。

Befunge，32个 20字节

1+::1+*2/&#@0#.-`#1_

在线尝试！

Brain-Flak，70 56 48字节

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

在线尝试！

说明

其中的主要部分是我编写的以下代码段：

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

如果TOS为正，这将无济于事，否则将切换堆栈。它是超级堆栈不干净，但是可以工作。现在，程序的主要部分从输入中减去越来越多的数字，直到输入为非正数为止。每次从1开始累加器，从输入中减去累加器1多。

({}[({}())()])

我们可以将其放在上面的代码片段中

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

将其放入循环中，以便执行直到交换堆栈。循环结束后，我们通过切换堆栈并删除垃圾来检索累加器。

Pyth，7个字节

lh{I#./

在线尝试！

过滤保留I重复数据删除不变的整数分区，抓住head并获得其l强度。

有效性证明

_{^{不是很严格，也不是措辞不错。}}

令A = a ₁ + a ₂ + ... + a _n和B = b ₁ + b ₂ + ... + b _m是相同整数N的两个不同的分区。我们将假定A是最长的唯一分区。我们重复数据删除后乙，也就是更换其中只有一个相同的整数的多次出现，我们知道的和乙小于ñ。但是我们也知道函数的结果在增加（非严格），因此我们可以推断出最长的唯一分区 A 元素的数量始终至少与其他分区中唯一项的数量相同。

三角性，49字节

....)....
...2)2...
..)1/)8..
.)1/)IE/.
@^)1_+/i.

在线尝试！

怎么运行的

三角性要求代码具有点的三角形分布。也就是说，每行的长度必须等于行数乘以2并递减，并且每行（在每一侧上）必须具有等于其在程序中位置的点数（最底行是第0行，上方的是第1行，依此类推）。只有几个命令，“ Wiki /命令”页面上列出的字符以外的任何字符都被视为无操作字符（只要整体形状完整，点状的点就不会以任何方式影响程序程序保持矩形）。

请注意，对于两个参数的命令，在整个说明中都使用了a和b。记住这一点，让我们看一下实际程序在删除组成填充的所有无关字符之后的作用：

)2)2)1/)8)1/)IE/@^)1_+/i | Input from STDIN and output to STDOUT.

)                        | Push a 0 onto the stack. Must precede integer literals.
 2                       | Push ToS * 10 + 2 (the literal 2, basically).
  )2                     | Again, push a 2 onto the stack. This can be replaced by D
                         | (duplicate), but then the padding would discard the saving.
    )1                   | Literal 1.
      /                  | Division. Push b / a (1 / 2).
       )8)1              | The literal 8 and the literal 1 (lots of these!).
           /             | Division. Push b / a (1 / 8).
            )IE          | Get the 0th input from STDIN and evaluate it.
               /         | Divide it by 1 / 8 (multiply by 8, but there isn't any
                         | operand for multiplication, and I'm not willing to add one).
                @        | Add 1 to the result.
                 ^       | Exponentiation. Here, it serves as a square too.
                  )1_+   | Decrement (add literal -1).
                      /  | Divide (by 2).
                       i | Cast to an integer.

一种替代解决方案，如果不需要填充，则缩短：

....)....
...2)1...
../DD)I..
.E/)4)1/.
+^s_+i...

在线尝试！

PowerShell 3.0，45个字节

[math]::Sqrt(2*$args[0]+.25)-.5-replace'\..*'

数学运算受到伤害，PS的银行家四舍五入是实际的魔鬼（因此需要使用正则表达式截断以节省字节），但这似乎还不错。

Java（JDK），28个字节

n->~-(int)Math.sqrt(8*n+1)/2

在线尝试！

因为这个例子真的不好打：p

学分

• -2个字节，感谢Kevin Cruijssen

果冻，7个字节

ŒPfŒṗṪL

大约在O（2 ⁿ）时间运行。

在线尝试！

怎么运行的

ŒPfŒṗṪL  Main link. Argument: n

ŒP       Powerset; yield all subarrays of [1, ..., n], sorted by length.
   Œṗ    Yield all integer partitions of n.
  f      Filter; keep subarrays that are partitions.
     Ṫ   Tail; extract the last result.
      L  Compute its length.

JavaScript（ES7），22个 19字节

n=>(8*n+1)**.5-1>>1

-3个字节感谢ETHproductions。

尝试一下

o.innerText=(f=
n=>(8*n+1)**.5-1>>1
)(i.value=1000000000);oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

说明

将输入乘以8并加1，将其乘以0.5的幂，得到平方根，减去1并将结果右移1。

Python 2 / 3，32个字节

封闭式公式的Python实现

lambda n:int((sqrt(1+8*n)-1)//2)

整数除法将//2舍入为零，因此floor( )不需要

Haskell，28个字节

有点令人厌烦，但是它比其他Haskell解决方案要短得多，并且具有非常好的无点表达。不幸的是，如果没有类型系统的阻碍，我将无法再缩短它：

g x=floor$sqrt(2*x+0.25)-0.5

在线尝试！

无点，33个字节

ceiling.(-0.5+).sqrt.(0.25+).(2*)

或者，33个字节

与无点版本相同，但更有趣。

g n=sum[1|x<-scanl1(+)[1..n],n>x]

银河系，12字节

'8*1+g1-2/v!

说明

code         explanation       value

'            push input        n          
 8*          push 8, multiply  8n
   1+        add 1             8n+1
     g       square root       sqrt(8n+1)
      1-     subtract 1        sqrt(8n+1)-1
        2/   divide by 2       (sqrt(8n+1)-1)/2
          v  floor             floor((sqrt(8n+1)-1)/2)
           ! output

Pyt，7 5 字节

Đř△>Ʃ

说明：

                      Implicit input
Đř△                   Gets a list of the first N triangle numbers
   >                  Is N greater than each element in the list? (returns an array of True/False)
    Ʃ                 Sums the list (autoconverts booleans to ints)

更快但更长的路

Pyt，11 9 字节

Đ2*√⌈ř△>Ʃ

说明：

Đ2*√⌈ř△           Gets a list of triangle numbers up to the ceiling(sqrt(2*N))-th
       >          Is N greater than each element of the list? (returns an array of True/False)
        Ʃ         Sums the array

另类方法-Shaggy的答案端口

Pyt，8 7 字节

8*⁺√⁻2÷

J，11个字节

2&!inv<.@-*

在线尝试！

2&!inv       solve [x choose 2 = input]
         -*  minus 1
      <.     and floor

空格，111字节

[S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   T   _Read_integer_from_STDIN][T T   T   _Retrieve_input][S S S T    S S S N
_Push_8][T  S S N
_Multiply][S S S T  N
_Push_1][T  S S S _Add][S S T   T   N
_Push_n=-1][N
S S N
_Create_Label_SQRT_LOOP][S S S T    N
_Push_1][T  S S S _Add][S N
S _Duplicate_n][S N
S _Duplicate_n][T   S S N
Multiply][S T   S S T   S N
_Copy_0-based_2nd_(the_input)][S S S T  N
_Push_1][T  S S S _Add][T   S S T   _Subtract][N
T   T   N
_If_negative_jump_to_Label_SQRT_LOOP][S S S T   S N
_Push_2][T  S S T   _Subtract][S S S T  S N
_Push_2][T  S T S _Integer_divide][T    N
S T _Print_integer]

字母S（空格），T（制表符）和N（换行符）仅作为突出显示而添加。
[..._some_action]仅作为说明添加。

在线尝试（仅使用空格，制表符和换行符）。

伪代码中的解释：

使用公式：

注意：空格没有内置平方根，因此我们必须手动执行此操作。

Integer i = read STDIN as integer
i = i * 8 + 1
Integer n = -1
Start SQRT_LOOP:
  n = n + 1
  If(n*n < i+1):
    Go to next iteration of SQRT_LOOP
n = (n - 2) integer-divided by 2
Print n as integer to STDOUT

Vitsy，16字节

2*14/+12/^12/-_N

在线尝试！

可能还要添加我自己的贡献。这比Vitsy中的分区迭代解决方案要短。

绿洲，14字节

n8*1+1tm1%_b+0

在线尝试！

怎么样？

n8*1+           8n + 1
     1tm        sqrt
        1%_     integer?
           b+   add f(n-1)

             0  f(0) is 0

这是一种递归解决方案，当遇到三角索引（输入0以0开头）时，递增结果。

Perl 5，19 -p（++）字节

$_=0|-.5+sqrt$_*2+1

在线尝试！

红宝石，27个字节

价格为三。我不能再矮了，我很失望。

->n{a=0;n-=a+=1while n>a;a}

->n{((8*n+1)**0.5-1).div 2}

->n{((n-~n)**0.5-0.5).to_i}

在线尝试！（要选择功能，请在其前面添加f =）