Nhiệm vụ

Đưa ra một số nguyên dương đầu vào n(từ 1 đến giới hạn ngôn ngữ của bạn, bao gồm), trả lại hoặc xuất số lượng tối đa các số nguyên dương khác biệt tổng hợp thành n.

Các trường hợp thử nghiệm

Hãy fxác định một hàm hợp lệ theo nhiệm vụ:

Trình tự cho f, bắt đầu từ 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, ...

Như một trường hợp thử nghiệm lớn hơn:

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

Mã kiểm tra

Đối với bất kỳ trường hợp thử nghiệm nào không được cung cấp rõ ràng, đầu ra của mã của bạn phải khớp với kết quả sau:

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));
    }
}

Hãy thử trực tuyến!

05AB1E , 4 byte

ÅTg<

Hãy thử trực tuyến!

Công cụ hoàn hảo cho công việc.

ÅTsản lượng các danh sách Å sẽ T số riangular lên đến và bao gồm N (không may bao gồm 0 quá, nếu không nó sẽ là 3 byte), g<nhận được len g thứ và decrements nó.

Thạch , 6 5 byte

R+\»ċ

Hãy thử trực tuyến!

Hơi hiệu quả. Chuỗi này tăng theo số tam giác, vì vậy điều này chỉ tính có bao nhiêu số tam giác nhỏ hơn n .

Giải trình:

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

-2 byte nhờ H.PWiz.

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

Hãy thử trực tuyến!

Điều này trả về phần tử thứ n của toàn bộ số trong đó mỗi i được sao chép i + 1 lần.

Brain-Flak , 36 byte

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

Hãy thử trực tuyến!

Điều này sử dụng cấu trúc tương tự như thuật toán phân chia tiêu chuẩn, ngoại trừ "ước số" được tăng lên mỗi khi nó được đọc.

Pari / GP , 19 byte

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

Hãy thử trực tuyến!

Brain-Flak , 82 byte

Khoảng trắng được thêm cho "Khả năng đọc"

(())

{
    {}

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

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

}{}{}{}

([]<>)

Hãy thử trực tuyến!

Thạch , 7 byte

×8‘½’:2

Hãy thử trực tuyến!

Thạch , 9 byte

Ḥ+4ݤ½_.Ḟ

Hãy thử trực tuyến!

Cái này dài hơn Dennis và DJ, nhưng lần này là có chủ đích . Rất, rất hiệu quả .

R , 28 byte

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

Hãy thử trực tuyến!

Tạo vectơ của thời gian 1lặp lại 2, thời gian 2lặp lại 3, ..., thời gian nlặp lại n+1và lấy nthphần tử. Điều này sẽ xảy ra lỗi bộ nhớ vì 1:nquá lớn hoặc do danh sách lặp lại với n*(n+1)/2 - 1các phần tử quá lớn.

R , 29 byte

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

Hãy thử trực tuyến!

Tính toán giá trị trực tiếp, sử dụng công thức tìm thấy trong câu trả lời của alephalpha . Điều này sẽ chạy không có vấn đề, ngoài khả năng chính xác số.

R , 30 byte

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

Hãy thử trực tuyến!

Đếm các số tam giác nhỏ hơn hoặc bằng n. Điều này có thể sẽ có lỗi bộ nhớ nếu 1:nđủ lớn - ví dụ, tại 1e9nó ném Error: cannot allocate vector of size 3.7 Gb.

APL (Dyalog) , 8 byte

+/+\∘⍳<⊢

Hãy thử trực tuyến!

TI-Basic, 12 byte

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

JavaScript (Node.js) , 18 byte

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

Hãy thử trực tuyến!

Japt , 8 byte

Giải pháp công thức khép kín.

*8Ä ¬É z

Thử nó

Giải trình

Nhân với 8, thêm 1 ( Ä), lấy căn bậc hai ( ¬), trừ 1 ( É) và chia sàn cho kết quả cho 2 ( z).

Thay thế, 8 byte

Cổng giải pháp Jelly của DJMcMayhem .

õ å+ è§U

Thử nó

Tạo một mảng các số nguyên ( õ) từ 1 đến đầu vào, cộng dồn ( å) bằng cách thêm ( +) và đếm ( è) các phần tử nhỏ hơn hoặc bằng ( §) đầu vào ( U).

Befunge, 32 20 byte

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

Hãy thử trực tuyến!

Brain-Flak , 70 56 48 byte

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

Hãy thử trực tuyến!

Giải trình

Phần chính của phần này là đoạn trích sau mà tôi đã viết:

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

Điều này sẽ không làm gì nếu ĐKDV tích cực và sẽ chuyển đổi ngăn xếp khác. Nó là siêu ngăn xếp ô uế nhưng nó hoạt động. Bây giờ phần chính của chương trình trừ số lượng ngày càng lớn từ đầu vào cho đến khi đầu vào không tích cực. Chúng tôi bắt đầu bộ tích lũy ở mức 1 mỗi lần trừ đi 1 bộ tích lũy từ đầu vào.

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

Chúng ta có thể đặt nó bên trong đoạn trích ở trên

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

Điều đó được đặt trong một vòng lặp để nó thực thi cho đến khi chúng ta chuyển đổi ngăn xếp. Khi vòng lặp kết thúc, chúng tôi lấy lại bộ tích lũy bằng cách chuyển đổi ngăn xếp và loại bỏ rác.

Bình thường , 7 byte

lh{I#./

Hãy thử trực tuyến!

Bộ lọc giữ các phân vùng số nguyên không bị Itrùng lặp, lấy head và lấy nól ength .

Bằng chứng hiệu lực

_{^{Không khắt khe cũng không nói tốt.}}

Hãy để A = một ₁ + a ₂ + ... + a _n và B = b ₁ + b ₂ + ... + b _m có hai phân vùng riêng biệt của số nguyên cùng tồn . Chúng tôi sẽ giả định rằng A là phân vùng duy nhất dài nhất. Sau khi chúng tôi deduplicate B , có nghĩa là, thay thế nhiều lần xuất hiện của số nguyên cùng với chỉ một trong số họ, chúng ta biết rằng tổng của B nhỏ hơn N . Nhưng chúng ta cũng biết rằng kết quả hàm đang tăng (không nghiêm ngặt), vì vậy chúng ta có thể suy ra rằng phân vùng duy nhất dài nhất A luôn có ít nhất cùng một lượng phần tử với số lượng vật phẩm duy nhất trong các phân vùng khác.

Hình tam giác , 49 byte

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

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Tam giác yêu cầu mã phải có phân bố tam giác của các chấm. Nghĩa là, độ dài của mỗi hàng phải bằng số hàng nhân với 2 và giảm dần và mỗi hàng phải có (ở mỗi bên) một số dấu chấm bằng với vị trí của nó trong chương trình (hàng dưới cùng là hàng 0, cái ở trên nó là hàng 1 và cứ thế). Chỉ có một vài lệnh và bất kỳ ký tự nào ngoài các lệnh được liệt kê trên trang 'Wiki / Lệnh' được coi là không có (các dấu chấm không liên quan sẽ không ảnh hưởng đến chương trình theo bất kỳ cách nào, miễn là hình dạng tổng thể của chương trình vẫn là hình chữ nhật).

Lưu ý rằng đối với các lệnh hai đối số, tôi đã sử dụng a và b trong suốt phần giải thích. Hãy ghi nhớ điều đó, hãy xem chương trình thực tế làm gì, sau khi loại bỏ tất cả các ký tự không liên quan tạo nên phần đệm:

)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.

Một giải pháp thay thế và ngắn hơn nếu không cần đệm:

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

Hãy thử trực tuyến!

PowerShell 3.0, 45 byte

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

Cuộc gọi toán học bị tổn thương và làm tròn số ngân hàng của PS là ma quỷ thực sự (do đó cần regex để cắt bớt để tiết kiệm một byte) nhưng điều này có vẻ khá ổn.

Java (JDK) , 28 byte

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

Hãy thử trực tuyến!

Bởi vì ví dụ thực sự không được chơi tốt: p

Tín dụng

• -2 byte nhờ Kevin Cruijssen

Thạch , 7 byte

ŒPfŒṗṪL

Chạy thô trong thời gian O (2 ⁿ ) .

Hãy thử trực tuyến!

Làm thế nào nó hoạt động

Œ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 byte

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

-3 byte nhờ vào ETHproductions.

Thử nó

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>

Giải trình

Nhân số đầu vào với 8 và thêm 1, tăng giá trị đó lên 0,5, cho ta căn bậc hai, trừ đi 1 và chia nhỏ kết quả ngay bằng 1.

Python 2/3, 32 byte

Python thực hiện công thức dạng đóng

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

Phép chia số nguyên làm //2tròn về 0, do đó không floor( )yêu cầu

Haskell , 28 byte

Hơi nhàm chán, nhưng nó khá ngắn hơn so với giải pháp Haskell khác và có một biểu thức pointfree thực sự tốt đẹp. Thật không may, tôi không thể có được nó ngắn hơn mà không có hệ thống loại cản trở:

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

Hãy thử trực tuyến!

Pointfree, 33 byte

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

Ngoài ra, 33 byte

Cùng chiều dài với phiên bản pointfree, nhưng thú vị hơn nhiều.

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

Dải ngân hà , 12 byte

'8*1+g1-2/v!

Giải trình

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 byte

Đř△>Ʃ

Giải trình:

                      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)

Nhanh hơn, nhưng cách lâu hơn

Pyt , 11 9 byte

Đ2*√⌈ř△>Ʃ

Giải trình:

Đ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

Cách khác - cổng câu trả lời của Shaggy

Pyt , 8 7 byte

8*⁺√⁻2÷

J , 11 byte

2&!inv<.@-*

Hãy thử trực tuyến!

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

Khoảng trắng , 111 byte

[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]

Chữ cái S(dấu cách), T(tab) và N(dòng mới) được thêm vào dưới dạng chỉ tô sáng.
[..._some_action]chỉ thêm vào giải thích.

Dùng thử trực tuyến (chỉ có khoảng trắng, tab và dòng mới).

Giải thích bằng mã giả:

Sử dụng công thức:

LƯU Ý: Khoảng trắng không có nội dung căn bậc hai, vì vậy chúng tôi phải thực hiện việc này một cách thủ công.

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 byte

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

Hãy thử trực tuyến!

Cũng có thể thêm đóng góp của riêng tôi vào hỗn hợp. Điều này ngắn hơn giải pháp lặp phân vùng trong Vitsy.

Ốc đảo , 14 byte

n8*1+1tm1%_b+0

Hãy thử trực tuyến!

Làm sao?

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

             0  f(0) is 0

Đây là một giải pháp đệ quy làm tăng kết quả khi gặp chỉ số tam giác, bắt đầu bằng 0 cho đầu vào 0.

Perl 5 -p , 19 (++) byte

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

Hãy thử trực tuyến!

Ruby , 27 byte

Ba cho giá của một. Tôi thất vọng vì tôi không thể đi ngắn hơn.

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

Hãy thử trực tuyến! (để chọn hàm, thêm f = vào trước hàm)