Trước khi bất cứ ai nói bất cứ điều gì, tương tự và tương tự . Nhưng đây không phải là một bản dupe.

Một số số nguyên dương có thể được viết dưới dạng tổng của ít nhất hai số nguyên dương liên tiếp. Ví dụ , 9=2+3+4=4+5. Viết hàm lấy một số nguyên dương làm đầu vào của nó và in thành đầu ra chuỗi dài nhất của các số nguyên dương liên tiếp tăng theo nó (bất kỳ định dạng nào cũng được chấp nhận, mặc dù -5 byte nếu đầu ra là chuỗi tăng được phân tách bằng +hình trên Nếu không tồn tại trình tự như vậy, thì số đó sẽ được in.

Đây là mã golf. Quy tắc tiêu chuẩn áp dụng. Mã ngắn nhất trong byte thắng.

Các mẫu (lưu ý rằng định dạng khác nhau)

Input:   9
Output:  2,3,4

Input:   8
Output:  8

Input:   25
Output:  [3,4,5,6,7]

Python, 67 byte

f=lambda n,R=[1]:n-sum(R)and f(n,[R+[R[-1]+1],R[1:]][sum(R)>n])or R

Một chiến lược đơn giản kỳ lạ: tìm kiếm khoảng R với tổng đúng.

• Nếu tổng quá nhỏ, hãy dịch chuyển điểm cuối bên phải của khoảng lên một bằng cách nối thêm số cao nhất tiếp theo.
• Nếu tổng quá lớn, hãy dịch chuyển điểm cuối bên trái bằng cách loại bỏ phần tử nhỏ nhất
• Nếu tổng là chính xác, đầu ra R.

Vì đầu dưới của khoảng chỉ tăng, nên các khoảng dài hơn được tìm thấy trước các khoảng ngắn hơn.

Bình thường, 12 10 byte

j\+hfqsTQ}M^SQ2

Mã này dài 15 byte và đủ điều kiện nhận phần thưởng -5 byte . Hãy thử trực tuyến trong Trình biên dịch Pyth .

Cảm ơn @Jakube đã chơi golf 2 byte!

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

j\+hfqsTQ}M^SQ2    (implicit) Store evaluated input in Q.

            S      Compute [1, ..., Q].
           ^  2    Get all pairs of elements of [1, ..., Q].
         }M        Reduce each pair by inclusive range. Maps [a, b] to [a, ..., b].
    f              Filter; for each pair T:
      sT             Add the integers in T.
     q  Q            Check if the sum equals Q.
                   Keep the pair if it does.
   h               Retrieve the first match.
                   Since the ranges [a, ..., b] are sorted by the value of a,
                   the first will be the longest, in ascending order.
j\+                Join, using '+' as separator.

Toán học, 73 68 65 56 43 byte

Cases[Range~Array~{#,#},i_/;Tr@i==#,{2},1]&

Haskell, 49 48 byte

f n=[[a..b]|a<-[1..n],b<-[a..n],sum[a..b]==n]!!0

MATLAB, 87 79 byte

Tôi biết đã có câu trả lời MATLAB, nhưng cách này khác biệt đáng kể trong cách tiếp cận.

x=input('');m=1:x;n=.5-m/2+x./m;l=max(find(~mod(n(n>0),1)));disp(m(1:l)+n(l)-1)

Điều này cũng hoạt động trên Octave . Bạn có thể thử trực tuyến tại đây . Tôi đã thêm mã consecutiveSum.mvào không gian làm việc được liên kết, vì vậy chỉ cần nhập consecutiveSumtại dấu nhắc lệnh, sau đó nhập giá trị (ví dụ 25).

Tôi vẫn đang làm việc trên làm giảm nó xuống (có lẽ điều chỉnh phương trình sử dụng một chút), nhưng về cơ bản nó tìm thấy giá trị lớn nhất nmà mlà một số nguyên, sau đó hiển thị đầu tiên msố bắt đầu với n.

Vậy tại sao điều này làm việc? Về cơ bản, có một phương trình toán học chi phối tất cả những con số đó. Nếu bạn cho rằng tất cả chúng đều liên tiếp và bắt đầu từ một số điểm, về cơ bản bạn có thể nói:

n+(n+1)+(n+2)+(n+3)+...+(n+p)=x

Bây giờ, từ điều này trở nên rõ ràng rằng chuỗi về cơ bản chỉ là các psố tam giác đầu tiên (bao gồm số 0), được thêm vào p+1rất nhiều n. Bây giờ nếu chúng ta cho phép m=p+1, chúng ta có thể nói:

m*(n+(m-1)/2)==x

Điều này thực sự khá khả thi. Tôi vẫn đang tìm kiếm cách làm mã ngắn nhất, tôi có một số ý tưởng để thử và giảm mã ở trên.

Đối với đầu vào là 25, đầu ra sẽ là:

3     4     5     6     7

Python 2, 94 byte

n=input()
r=int((2*n)**.5)
while r:
 if~r%2*r/2==n%r:print range(n/r-~-r/2,n/r-~r/2);r=1
 r-=1

Đầu vào được lấy từ stdin. Giải pháp này phù hợp cho đầu vào rất lớn.

Điều này lặp lại theo độ dài giải pháp có thể, r , có r ≤ √ (2n) và kiểm tra một giải pháp rõ ràng. Để giải pháp tồn tại, nếu r là số lẻ, n mod r phải bằng 0 và nếu r là chẵn thì n mod r phải là r / 2 .

Sử dụng mẫu

$ echo 8192 | python sum-con-int.py
[8192]

$ echo 1000002 | python sum-con-int.py
[83328, 83329, 83330, 83331, 83332, 83333, 83334, 83335, 83336, 83337, 83338, 83339]

$ echo 1000000006 | python sum-con-int.py
[250000000, 250000001, 250000002, 250000003]

Tôi đã cố tình chọn các ví dụ với đầu ra tương đối nhỏ.

Octave, 89 byte

Đây là điều tốt nhất tôi có thể làm trong Octave. Thuật toán giống như của xnor.

x=input('');k=i=1;while x;s=sum(k:i);if s<x;i++;elseif s>x;k++;else;x=0;end;end;disp(k:1)

Trong MATLAB, đây sẽ là 95 byte:

x=input('');k=1;i=1;while x;s=sum(k:i);if s<x;i=i+1;elseif s>x;k=k+1;else x=0;end;end;disp(k:i)

Trong MATLAB, nó chạy trong khoảng 0,1 giây cho đầu vào 2000000và 1 giây cho đầu vào 1000002.

ôi, 51 byte

{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j

Mã này là 56 byte, trừ 5 byte cho định dạng đầu ra. Tôi đã phải sử dụng thêm 4 byte để tạo định dạng đó, vì vậy tôi thực sự đã lưu 1 byte. Hoan hô! ;)

Đó thực sự là một công việc khó khăn để tổng kết bắt đầu từ 1 cho đến khi tổng lớn hơn đầu vào. Sau đó, nó bắt đầu trừ các số bắt đầu từ 1 cho đến khi số nhỏ hơn đầu vào. Nó liên tục thay đổi số bắt đầu và số kết thúc theo cách này cho đến khi tìm thấy kết quả, sau đó nó sẽ in ra.

Ví dụ sử dụng

echo 303 | awk '{while($0!=s+=s<$0?++j:-++i);while(++i-j)r=r i"+"}$0=r j'

Đầu ra của ví dụ

48 + 49 + 50 + 51 + 52 + 53

Tôi đã thử điều này cho một đầu vào 1e12và nó cho kết quả chính xác ( 464562+...+1488562) gần như ngay lập tức. Mặc dù phải mất một lúc để in, tất nhiên ...

Japt , 33 byte

Cái này sử dụng kỹ thuật Pyth của Dennis , mặc dù nó dài hơn đáng kể ...

1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU

Hãy thử trực tuyến! Cảnh báo: Đối với các đầu vào lớn hơn (<= 20), phải mất một lúc để hoàn thành và đóng băng trình duyệt của bạn cho đến khi có.

Ung dung và giải thích

1oU à2 £    W=Xg o1+Xg1¹ x ¥ U© W} rª  ª U
1oU à2 mXYZ{W=Xg o1+Xg1) x ==U&&W} r|| ||U

          // Implicit: U = input integer
1oU à2    // Generate a range from 1 to U, and take all combinations of length 2.
mXYZ{     // Map each item X in this range to:
W=Xg o    //  Set variable W to the range of integers starting at the first item in X,
1+Xg1)    //  and ending at 1 + the second item in X.
x ==U&&W  //  If the sum of this range equals U, return W; otherwise, return false.
r||       // Reduce the result with the || operator, returning the first non-false value.
||U       // If this is still false, there are no consecutive ranges that sum to U,
          // so resort to U itself.
          // Implicit: output last expression

Phiên bản kiếm tiền thưởng: (38 byte - 5 = 33)

1oU à2 £W=Xg o1+Xg1¹x ¥U©W} rª ªU² q'+

Julia, 92 byte

x->(t=filter(i->all(j->j==1,diff(sort(i))),partitions(x));collect(t)[indmax(map(length,t))])

Đây là một hàm ẩn danh chấp nhận một số nguyên và trả về một mảng. Để gọi nó, đặt tên cho nó, vd f=x->....

Ung dung:

function f(x::Integer)
    # Get all arrays of integers that sum to x
    p = partitions(x)

    # Filter these down to only consecutive runs by checking whether
    # all differences are 1
    t = filter(i -> all(j -> j == 1, diff(sort(i))), p)

    # Find the index of the longest element of t
    i = indmax(map(length, t))

    return collect(t)[i]
end

Ruby, 94 byte

->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}

Ung dung:

-> n {
  ([*1..n].permutation(2).map { |i,j|   # Finds all the possible sets of size 2
     [*i..j] if(i..j).reduce(:+) == n   # Adds a set to an array if sum of the set is n.
   }-[p]                                # Removes nil from the array
  ).max_by { |k|                        # Finds the longest sequence
    k.size
  } || n                                # Returns n if no sequence found.
}

Sử dụng:

->n{([*1..n].permutation(2).map{|i,j|[*i..j]if(i..j).reduce(:+)==n}-[p]).max_by{|k|k.size}||n}[25]
=> [3, 4, 5, 6, 7]

Nghiêm túc, 53 - 5 = 48 byte

,;;;╝`;u@n╟(D;)`n(XXk`iu@u@x;Σ╛=[])Ii`╗`ñ╜M`M;░p@X'+j

Bãi rác Hex

2c3b3b3bbc603b75406ec728443b29606e2858586b60697540754
0783be4be3d5b5d29496960bb60a4bd4d604d3bb0704058272b6a

Dùng thử trực tuyến!

Đó là cách tiếp cận vũ phu, tương tự như Dennis's Pyth.

Mọi thứ kchỉ đọc đầu nvào vào thanh ghi 1 và sau đó tạo danh sách [[1],[2,2],[3,3,3],[4,4,4,4],...]lên đến n n.

Bit tiếp theo ╗là một hàm được lưu trữ trong thanh ghi 0 lấy một cặp, tăng cả hai phần tử, chuyển đổi chúng thành một phạm vi, tìm tổng của phạm vi và kiểm tra xem tổng đó có phải là giá trị trong thanh ghi 1. Nếu là, nó trả về phạm vi tương ứng và nếu không, nó sẽ trả về một danh sách trống.

Phần cho đến lần xuất hiện cuối cùng của Mbản đồ một chức năng trong danh sách ưa thích của các danh sách được mô tả ở trên, thực hiện enumeratetrên mỗi danh sách, sau đó ánh xạ chức năng được lưu trữ qua chức năng đó. Khi hoàn thành, chúng tôi có một danh sách các danh sách mà mỗi danh sách trống hoặc một phạm vi tổng hợp n.

;░xóa các danh sách trống. p@Xlấy danh sách đầu tiên còn lại ( 0@Ecũng sẽ hoạt động). '+jđặt +giữa mỗi số khi nó chuyển đổi danh sách thành một chuỗi cho phần thưởng.

ES6, 72 byte

n=>{for(l=u=1;n;)n>0?n-=u++:n+=l++;return[...Array(u).keys()].slice(l);}

Cổng thẳng của giải pháp awk của @ Cabbie407, nhưng không có phần thưởng định dạng, vì đây là một hình phạt ở đây.

Python 3, 239 236 215 203 byte

Đây là một chút rườm rà. Tôi sẽ phải đánh nó xuống sau.

def x(n):
 r=[n]
 for i in range(2,n):
  t=[]
  if i%2*(n%i<1):t=[j+n//i-i//2for j in range(i)]
  elif i%2<1and n%i==i//2:t=[j+n//i-i//2+1for j in range(i)]
  if t[:1]>[0]*(sum(t)==n):r+=t,
 return r[-1]

Các klà bởi vì nếu bạn kiểm tra t[0]trên một trống t, Python làm cho tiếng ồn thô lỗ với bạn. Một lần nữa, đây là nhu cầu chơi golf. Nhờ t[:1], không còn những tiếng động thô lỗ! Bạn chỉ cần kiểm tra đối với mảng khác.

Jelly , 8 byte (không cạnh tranh)

ẆS⁼¥Ðf⁸Ṫ

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

Nếu tôi hiểu chính xác, đây có thể là phiên bản (11-5 = 6):

ẆS⁼¥Ðf⁸Ṫj”+

05AB1E , 11 - 5 = 6 byte (không cạnh tranh)

Lấy phần thưởng đó tất nhiên :)

LŒʒOQ}é¤'+ý

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

LŒʒOQ}é¤'+ý  Argument: n
LΠ          Sublists of range 1 to n
  ʒOQ}       Filter by total sum equals n
      é¤     Get longest element
        '+ý  Join on '+'

PHP, 70 byte

while(fmod($q=sqrt(2*$argn+(++$p-.5)**2)-.5,1));print_r(range($p,$q));

Chạy như ống với -nR hoặc thử trực tuyến .

gia tăng pcho đến khi tìm thấy một giải pháp số nguyên cho argument==(p+q)*(q-p+1)/2,
sau đó in phạm vi từ pđến q.

VBA Excel, 119 - 5 = 114 byte

Subthường trình lấy đầu vào ncủa số nguyên loại dự kiến ​​và đưa ra chuỗi dài nhất của các số liên tiếp tổng hợp với nó cho ô[A1]

Sub a(n)
For i=1To n
s=0
For j=i To n
s=s+j
If s=n Then:For k=i To j-1:r=r &k &"+":Next:[A1]=r &j:End
Next
Next
End Sub