Lý lịch

Hãy xem xét một chuỗi được xác định như sau:

• Phần tử đầu tiên là 0;
• Phần tử thứ hai là 4;
• Từ phần tử thứ ba trở đi, giá trị của nó có thể được tính bằng:
  • Lấy tập hợp các số nguyên từ 0 cho đến phần tử trước của chuỗi (bao gồm hoặc độc quyền, không thành vấn đề);
  • Xóa mọi số nguyên đã xuất hiện trước đó trong chuỗi khỏi tập hợp;
  • Cộng các yếu tố còn lại của tập hợp; đó là giá trị bạn muốn

Thật thú vị, trình tự này dường như chưa có trên OEIS .

Nhiệm vụ

Viết chương trình hoặc hàm lấy số nguyên n làm đầu vào và xuất phần tử thứ n của chuỗi.

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

Một vài yếu tố đầu tiên của chuỗi là:

• 0
• 4
• 6 (1 + 2 + 3)
• 11 (1 + 2 + 3 + 5)
• 45 (1 + 2 + 3 + 5 + 7 + 8 + 9 + 10)
• 969 (1 + 2 + 3 + 5 + 7 Sự 10 + 12 Sự 44)
• 468930 (1 + 2 + 3 + 5 + 7 Sự 10 + 12 Sự 44 + 46 Sự 968)

Làm rõ

• Về lý thuyết, chương trình của bạn sẽ có thể xử lý n tùy ý nếu chạy trên một biến thể ngôn ngữ của bạn có số nguyên lớn không giới hạn và truy cập vào một lượng bộ nhớ không giới hạn. (Các ngôn ngữ không có bignums dường như không thể vượt quá 468930, nhưng đó không phải là lý do để mã hóa các câu trả lời.)
• Bạn có thể chọn lập chỉ mục dựa trên 0 hoặc dựa trên 1 cho chuỗi (ví dụ: tùy thuộc vào việc n = 1 trả về phần tử đầu tiên, n = 2 phần tử thứ hai, v.v. hoặc liệu n = 0 có trả về phần tử đầu tiên không , n = 1 phần tử thứ hai, v.v.).
• Không có yêu cầu về thuật toán bạn sử dụng, cũng như về hiệu quả của nó; bạn có thể trực tiếp thực hiện định nghĩa của chuỗi (mặc dù nó thực sự không hiệu quả) và bạn cũng có thể thực hiện một thuật toán khác dẫn đến cùng một kết quả.

Điều kiện chiến thắng

Đây là môn đánh gôn , vì vậy chương trình đúng ngắn nhất, được đo bằng byte, sẽ thắng.

Thạch , 13 12 9 byte

rSạo4¥ð@¡

Sử dụng lập chỉ mục dựa trên 0.

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

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

rSạo4¥ð@¡  Main link. No arguments. Implicit argument: 0

      ð    Collect everything to the left into a chain and start a new, dyadic one.
           The arity of the first chain is unknown at this point, as it isn't
           prefixed by ø, µ, or ð.
       @   Swap the arguments of the first chain. Swapping  arguments is only
           implemented for dyadic links, so this makes the chain dyadic.
        ¡  Read an integer n from STDIN and execute the chain n times. Taking the
           argument swap into account, the chain is executed first with 0 as left
           and right argument, then with the previous right argument as left
           argument and the previous return value as right argument.
           The return value of the last call is the return value of the quicklink
           and becomes the implicit output.

           Let's call the left argument x and the right argument y.
r            Range; yield [x, ..., y].
 S           Compute the sum of all integers in the range.
     ¥       Convert the two atoms to the left into a dyadic chain, and call that
             chain with arguments x and y.
   o4          Take the logical OR of x and 4, replacing a 0 with 4 and leaving
               positive integers untouched.
  ạ          Take the absolute difference of the sum to the left and the result of
             the logical OR to the right.

Python, 66 60 byte

Cảm ơn @Dennis đã cạo sạch 6 byte!

f=lambda n:n>2and(f(n-1)-~f(n-2))*(f(n-1)-f(n-2))/2or(5-n)*n

Nó không phải là đoạn mã đẹp nhất từ ​​trước đến nay, nhưng nó sử dụng một công thức mà tôi đã tạo ra:

Ở xphía bên tay phải là f(n - 1), và ylà f(n - 2).

Giải trình:

Tổng các số nguyên liên tục từ ađến b(bao gồm) có thể được mô tả theo công thức này:

amount * average

Trong đó amount(số lượng số) được mô tả như vậy:

((a - b) - 1)

Và average(trung bình của tất cả các số) được mô tả như vậy:

(a + b) / 2

Vì vậy, công thức đầy đủ là bây giờ:

  ((a - b) - 1)(a + b) / 2
= (a - b - 1)(a + b) / 2

Cách chúng ta thực hiện công thức này vào công thức cuối cùng là để thay thế acho f(n - 1), bcho f(n - 2), mà về cơ bản tính toán tổng của tất cả các điều khoản mới, và thêm một f(n - 1)(mà bây giờ atrên), mà là tổng của tất cả các điều khoản trước đó.

Kết hợp điều đó lại với nhau, chúng ta có được:

  a + ((a - b - 1)(a + b) / 2)
= a + ((a^2 + ab - ab - b^2 - a - b) / 2)
= a + ((a^2 - b^2 - a - b) / 2)
= (a^2 - b^2 - a - b + 2a) / 2
= (a^2 - b^2 + a - b) / 2
= ((a + b)(a - b) + (a - b)) / 2
= (a + b + 1)(a - b) / 2

Thay thế abằng xvà bvới y, và hey thế, bạn phải công thức ở trên.

Python 2 , 58 54 50 byte

r=t=0
exec'r,t=t+r*~-r/2or 4,t-r;'*input()
print r

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

Toán học, 49 48 byte

±2=4;±1=0;±n_:=Tr@Range@±(n-1)-Tr@Array[±#&,n-1]
(* or *)
±2=4;±1=0;±n_:=-Tr@Array[(k=±#)&,n-1]+Tr@Range@k

Sử dụng mã hóa CP-1252. Xác định hàm PlusMinus (±). 1 chỉ mục.

Giải trình

±2=4;±1=0;±n_:=Tr@Range@±(n-1)-Tr@Array[±#&,n-1]

±2=4;±1=0;                                        (* Define ±1 and ±2 *)
          ±n_:=                                   (* ±n equals ... *)
               Tr@Range@±(n-1)                    (* Sum of (1, 2, ..., ±(n-1)) ... *)
                              -Tr@Array[±#&,n-1]  (* Minus the sum of previous terms *)

Ốc đảo , 11 byte

Mã số:

+>bc-*2/640

Giải trình:

Để hình dung mối quan hệ của f _n , hãy lấy ví dụ f ₅ . Để tính f ₅ , chúng ta hãy xem tổng sau:

1 + 2 + 3 + 5 + 7 + 8 + 9 + 10

Phần in đậm chỉ giống như f ₄ . Phần 7 + 8 + 9 + 10 là phạm vi [f _n-2 + 1, f _n-1 - 1] . Điều đó làm cho công thức f _n-1 + [f _n-2 + 1 ... f _n-1 - 1] ( liên kết Wolfram ):

f _n = 0,5 × (f _n-1 ² - f _n-2 ² + f _n-1 - f _n-2 )

Mà có thể được viết lại thành:

f _n = 0,5 × ((f _n-1 - f _n-2 ) (f _n-1 + f _n-2 ) + (f _n-1 - f _n-2 ))

f _n = 0,5 × ((f _n-1 - f _n-2 ) (f _n-1 + f _n-2 + 1))

Đó là công thức mà chúng tôi sẽ sử dụng trong mã:

Giải thích mã

Phần này 640cho chúng ta các trường hợp cơ bản:

a(0) = 0
a(1) = 4
a(2) = 6

Mã sẽ được thực thi (xác định a (n) ):

+>bc-*2/

+          # Add a(n + 1) and a(n + 2) implicitly
 >         # Add one to get a(n + 1) + a(n + 2) + 1
  b        # Push a(n + 1)
   c       # Push a(n + 2)
    -      # Subtract from each other
     *     # Multiply with the previous result
      2/   # Halve the result

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

Julia, 39 33 32 byte

!n=n<3?5n-n^2:sum(!(n-2)+1:!~-n)

Dựa trên 0

Nhờ @Dennis, đã lưu 6 byte.

Nhờ @GlenO, đã lưu một byte.

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

Câu trả lời trước 1- dựa:

!n=n<4?2(n>1)n:sum(!(n-2)+1:!~-n)

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

Câu trả lời không đúng trước đây dựa trên 1:

f(n)=n<4?n<2?0:n*2:sum(f(n-2)+1:f(n-1))

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

JavaScript (ES6), 47 byte

f=(n,b=4,a=6)=>n?--n?f(n,a,(a+b+1)*(a-b)/2):b:0

Sử dụng mối quan hệ lặp lại mà f(n) = sum(range(f(n-2) + 1, f(n-1) + 1))cho n> 2.

PowerShell , 84 89 88 87 byte

$OFS='+'
for($a=0,4;$a.Count-le($n="$args")){$a+=("$(1..$a[-1])"|iex)-("$a"|iex)}$a[$n]

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

Giải trình

Lập chỉ mục dựa trên 0. Chỉ hoạt động thông qua n = 6(trên máy Windows của tôi, nó gặp sự cố với tràn ngăn xếp n = 7).

Sử dụng phương pháp tương tự như câu trả lời của JungHwan Min (tổng của phạm vi trừ tổng của các điều khoản trước đó).

Tóm tắt một phạm vi / mảng trong PowerShell là dài, vì vậy tôi đang sử dụng thủ thuật nối một mảng với +để tạo một biểu thức dài (như 1+2+3+4...etc) và sau đó gửi nó qua iex( Invoke-Expression).

Vì tôi cần thực hiện hai lần, thay vì sử dụng -joinTôi đang đặt biến đặc biệt $OFS, viết tắt của dấu tách trường đầu ra. Khi bạn xâu chuỗi một mảng, đây là ký tự được sử dụng để nối các phần tử; Nó mặc định là một khoảng trắng. Vì vậy, bằng cách đặt nó thành +(một lần), tôi có thể thay thế một cái gì đó như $a-join'+'|iexbằng "$a"|iex.

Một forvòng lặp đơn giản tiếp tục cho đến khi số thứ tự nhỏ hơn hoặc bằng số nguyên đầu vào, sau đó tôi trả về $nphần tử thứ.

MATL , 17 16 byte

OKi:"tP:yX-sv]G)

1lập chỉ mục dựa trên được sử dụng. Mã này rất không hiệu quả. Đối với n = 6nó đã vượt quá giới hạn bộ nhớ của trình biên dịch trực tuyến.

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

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

O       % Push 0
K       % Push 4
i       % Input n
:"      % Do the following n times
  t     %   Push a copy of the top array (or number)
  P:    %   Range from 1 to the last element of array
  y     %   Push a copy of the second-top number/array
  X-    %   Set difference
  s     %   Sum
  v     %   Concatenate everything into a column vector
]       % End
G)      % Get n-th entry of the array. Implicity display

Đối với 20 byte , phiên bản sau sẽ tránh giới hạn bộ nhớ. Nhưng vẫn còn giới hạn loại dữ liệu ( doubleloại chỉ có thể đảm bảo rằng số nguyên được thể hiện chính xác đến 2^53), do đó, kết quả chỉ có giá trị n = 8.

OKi:"t0)tQ*2/ys-v]G)

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

Haskell , 42 byte

f 0=0
f 1=4
f 2=6
f n=sum[1+f(n-2)..f$n-1]

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

Điều này trực tiếp thực hiện các mục lặp lại cho n>2, f(n)bằng f(n-1)cộng với tổng các khoảng thời gian mở cửa từ f(n-2)để f(n-1)mà một lần nữa là bằng tổng của khoảng nửa mở cửa từ f(n-2)để f(n-1)toàn diện.

f(0) = 0
f(1) = 4
f(2) = 6 = 1+2+3
f(3) = 11 = 1+2+3+5 = 6 + 5 = 6 + sum]4,6[ = f(2)+ sum]f(1),f(2)[ = sum]f(1),f(2)]
...
f(n) = sum]f(n-2),f(n-1)] = sum[f(n-2)+1,f(n-1)]

Haskell, 31 byte

m#s=m:s#sum[m+1..s]
((0:4#6)!!)

Ví dụ sử dụng: ((0:4#6)!!) 6-> 468930. Hãy thử trực tuyến! .

Đệ quy đơn giản, theo dõi các phần tử tối đa mcho đến nay và giá trị tiếp theo s.

JavaScript, 123 119 byte

(a,i=x=y=0)=>{r=[0,4];while(r.length<a){x++;y=0;for(i=0;i<r[x];i++){if(!r.includes(i)){y+=i;}}r.push(y)}return r[a-1];}

Hãy thử trực tuyến! Giải pháp này dựa trên 1 , f(1) => 0.

Perl 6 ,  52 49 44  35 byte

{(|(0,4 X 0),{[+](^.[0])-.[1],.[0]+.[1]}...*)[$_;0]}

Thử nó

{(0,(4,0),{[+](^.[0])-.[1],.[0]+.[1]}...*)[$_;0]}

Thử nó

{(0,(4,0),{[+](^.[0])-.[1],.sum}...*)[$_;0]}

Thử nó

{(0,4,6,{[+] $^a^..$^b}...*)[$_]}

Thử nó

Mở rộng:

{ # bare block lambda with implicit parameter ｢$_｣

  (
    # generate a sequence

    0, 4, 6,      # seed the sequence

    {             # lambda with placeholder parameters ｢$a｣ ｢$b｣
      [+]         # reduce with ｢&infix:<+>｣
          $^a     # n-2
          ^..     # Range that excludes the first value
          $^b     # n-1
    }
    ...           # keep generating values until
    *             # never stop

  )[ $_ ]         # get the value that was asked for (0 based index)
}

PowerShell , 77 73 byte

param($n)$a=0,4;1..$n|%{$a+=(0..$a[-1]|?{$_-notin$a})-join'+'|iex};$a[$n]

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

Thực hiện thuật toán như được định nghĩa và được lập chỉ mục 0. Đầu vào của 6quá nhiều cho TIO để xử lý.

Đặt $athành một mảng [0,4]. Vòng lặp từ 1lên đến đầu vào $n. Trong vòng lặp, chúng tôi lấy phạm vi số từ 0tối đa đến số lớn nhất chúng tôi có $a[-1]và sử dụng Where-Objectmệnh đề |?{...}để chỉ rút ra những số chưa có. Mảng số đó được -joined cùng với +s, và sau đó được đưa vào iex(viết tắt Invoke-Expressionvà tương tự eval). Giá trị đó sau đó được nối với nhau vào cuối $a. Cuối cùng, chúng tôi thoát khỏi vòng lặp của chúng tôi và lấy $nsố thứ trong mảng của chúng tôi. Con số đó được để lại trên đường ống và đầu ra là ẩn.

Python 2 , 85 byte

def g(n):
 if n<2:return n*4
 s=set(map(g,range(n)));return sum(set(range(max(s)))-s)

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

Mẻ, 108 byte

@if %1==0 echo 0&exit/b
@set/ab=4,a=6
@for /l %%i in (2,1,%1)do @set/ac=(a+b+1)*(a-b)/2,b=a,a=c
@echo %b%

Cổng câu trả lời JavaScript của tôi.

dc , 47 byte

?d1-scd/4*dd[d1+*2/r-dsn+dlnlc1-dsc0<x]sxlc0<xp

Hoạt động với số nguyên lớn như bạn muốn, cho đến dung lượng bộ nhớ của máy tính.

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

Lập chỉ mục dựa trên 0, đầu vào trên stdin, đầu ra trên thiết bị xuất chuẩn. (Ngoài ra còn có đầu ra trên thiết bị lỗi chuẩn, sẽ bị bỏ qua.)

Chạy mẫu:

$ for ((j=0;j<12;j++)){ echo -n "$j ";dc -f sumseq.dc <<<"$j";echo;} 2>/dev/null
0 0

1 4

2 6

3 11

4 45

5 969

6 468930

7 109947436950

8 6044219445882138462810

9 18266294354989892462984673364511343859409730

10 166828754731567805766174036610844675771635260155825966927845486666328\
837158267993261860

11 139159167026428037700805570917048711514125048327321592278500415852500\
422178720517080334552793040951056255170819719745908378102737875659900\
61575545777065220385544711322919415

Điều này sử dụng thuật toán tương tự như giải pháp sau trong bash, dễ đọc hơn một chút:

Bash thuần, 60 byte

for((n=s=$1?4:0,k=1;k<$1;k++,s+=(n=n++*n/2-s))){ :;}
echo $n

Nhưng chương trình bash chỉ hoạt động cho đầu vào tối đa 7, vì nó chạm tràn số nguyên vượt quá mức đó.

Pyth - 15 byte

ePu+Gs-UeGGQ,Z4

Phòng thử nghiệm .

C # - 74 byte

int A(int f){int e=4,i=1,s=0;for(;i++<f;)e=e*-~e/2-(s+=e);return f>0?e:0;}

Ung dung:

int A(int f)
{
    int e = 4, 
        i = 1, 
        s = 0; // e is the last element, s is the sum of all previous elements
    for (; i++ < f; ) // calculate for indexes 1 through max (don't need the index, just a correct number of loop cycles)
        e = e * -~e / 2 - (s += e); // -~e => (e + 1), higher precedence to remove parentheses
    return f > 0 ? e : 0; //handle input 0 as a special case, which is 0
}

Có lẽ có một cách để chuyển đổi nó thành lambda để tiết kiệm hơn nữa, hoặc một cái gì đó bằng cách sử dụng Hàm .Aggregate. Mặc dù hiện tại tôi không có hàng nhập khẩu, vậy có lẽ nó đã phát triển?

> <> , 43 + 3 = 46 byte

Sử dụng công thức được trình bày trong câu trả lời của Adnan và Qwerp-Derp .

:2(?^&46v
}v?=&:&l<,2*{-$@:}+1+@:{::
*>n;>4

Yêu cầu đầu vào có mặt trên ngăn xếp, vì vậy +3 byte cho -vcờ.

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