Trình tự SUDSI ( su m, d ifference, s wap, i ncrement) là một chuỗi số nguyên gây tò mò xuất hiện để thể hiện hành vi khá hỗn loạn. Nó có thể được tạo ra như sau:

Đặt S là danh sách vô hạn các số tự nhiên : 1 2 3 4 5 6 .... Hãy S _i biểu thị một lập chỉ mục i th yếu tố của S . Vì vậy, ban đầu, S ₁ là 1, S ₂ là 2, v.v. (không có S ₀ ).

Bắt đầu với S ₁ và S ₂ ...

• Tính tổng của họ: sum = S1 + S2
• Tính toán sự khác biệt tuyệt đối của chúng (cái lớn hơn trừ đi cái nhỏ hơn): diff = |S1 - S2|

• Hoán đổi hai giá trị trong S tại các chỉ số của tổng và hiệu:swap(Ssum, Sdiff)

• Tăng các chỉ số của S bạn đang làm việc. Vì vậy, lần tới, bạn sẽ tính tổng và hiệu của S ₂ và S ₃ , và thời gian sau đó sẽ là S ₃ và S ₄ , v.v.

• Lặp lại quá trình này vô thời hạn.

Dưới đây là một vài giai đoạn đầu tiên của S khi quy trình này được áp dụng. Dấu ngoặc []bao quanh hai giá trị sắp được tổng hợp và phân biệt.

S gốc :

[1 2] 3 4 5 6 7 8 9 10 11 12 ...

Sau khi S ₃ ( 3 = 1 + 2) và S ₁ ( 1 = |1 - 2|) được hoán đổi:

3 [2 1] 4 5 6 7 8 9 10 11 12 ...

Sau khi S ₃ và S ₁ được hoán đổi:

1 2 [3 4] 5 6 7 8 9 10 11 12 ...

Sau khi S ₇ và S ₁ được hoán đổi:

7 2 3 [4 5] 6 1 8 9 10 11 12 ...

Sau khi S ₉ và S ₁ được hoán đổi:

9 2 3 4 [5 6] 1 8 7 10 11 12 ...

Sau khi S ₁₁ và S ₁ được hoán đổi:

11 2 3 4 5 [6 1] 8 7 10 9 12 ...

Sau khi S ₇ và S ₅ được hoán đổi:

11 2 3 4 1 6 [5 8] 7 10 9 12 ...

Vân vân.

Trình tự SUDSI được định nghĩa là trình tự của các phần tử đầu tiên trong mỗi danh sách này. Vì vậy, một vài điều khoản đầu tiên của chuỗi SUDSI là 1 3 1 7 9 11 11.

Dưới đây là 200 điều khoản đầu tiên của chuỗi SUDSI (20 trên mỗi dòng):

1 3 1 7 9 11 11 11 15 15 19 19 19 19 19 19 19 19 19 19 
19 19 19 19 19 19 19 19 57 59 59 59 59 59 59 59 59 59 77 79 
81 83 85 87 89 91 91 91 91 91 91 91 91 91 91 91 91 91 115 115 
121 123 125 127 127 127 127 127 137 139 141 143 145 147 147 147 147 147 147 147 
147 147 147 147 167 167 167 167 167 167 167 167 167 167 167 167 167 167 167 167 
167 167 167 167 209 211 211 211 211 211 221 223 223 223 223 223 223 223 223 223 
223 223 243 243 243 243 243 243 257 259 261 263 263 263 263 263 263 263 263 263 
263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 263 
263 263 325 327 329 331 331 331 331 331 331 331 331 331 349 351 351 351 351 351 
361 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363 363

Không rõ ràng (với tôi ít nhất) làm thế nào một người có thể dự đoán các điều khoản trong tương lai. Nó chỉ cảm thấy an toàn khi nói rằng các điều khoản luôn luôn lẻ, không giảm (sau thuật ngữ thứ hai) và một số số được lặp lại rất nhiều lần.

Thử thách

Viết chương trình hoặc hàm lấy số nguyên dương n và in hoặc trả về số hạng thứ n của chuỗi SUDSI. Ví dụ: nếu n là 1, thì đầu ra là 1, nếu n là 2, đầu ra là 3, nếu n là 200, thì đầu ra là 363.

Lấy đầu vào theo bất kỳ cách thông thường nào (stdin / dòng lệnh / hàm arg).
Câu trả lời ngắn nhất trong byte thắng.
(Trang web đó mã hóa mọi thứ trong UTF-8, nhưng bạn có thể sử dụng bất kỳ mã hóa hiện có nào bạn muốn.)

Phần thưởng toán học: (có khả năng đủ điều kiện nhận tiền thưởng)

• Cho tôi biết thêm về trình tự SUDSI. Mô hình cơ bản cho những con số nào là một phần của nó và có bao nhiêu trong số chúng (và những thứ như vậy)? (Nhân tiện, tôi không thể tìm thấy SUDSI trên OEIS .)

Bình thường, 45 41 40 38 byte

MXGH_HhugGm@Gtd,s<>GH2.a-@GH@GhHtQr1yQ

Tôi nhận thấy (cũng như Martin Büttner), rằng số lượng ảnh hưởng tối đa của bước hoán vị tại k là 2k + 1. Nhưng vì chúng tôi chỉ có n - 1, các bước, chúng tôi chỉ cần một danh sách các số lên đến 2n - 1.

Dùng thử trực tuyến: Trình diễn

M                       define a function g(G, H): return
                        (G is the list of numbers, H is a tuple)
 XGH_H                     a translation of G
                           (replaces the elements in H with the elements in reversed H)
                           in this application it swaps two values in the list G


                        implicit: Q = input()
 u     tQr1yQ           reduce, G = [1, 2, ..., 2*Q-1]
                        for each H in [0, 1, ..., Q - 2]:
                           G = 
  gG...                        g(G, ...)
h                       print the first element of the resulting list

And the second argument ... of the function call g is:

     ,                  create the tuple (
      s<>GH2               sum(G[H:][:2]), 
            .a-@GH@GhH     abs(G[H],G[H+1])
                        )
m@Gtd                   and map each value d to G[d - 1]

Toán học, 88 byte

Last[f@n_:=n;(r=f@1;{f@a,f@b}={f[b=+##],f[a=Abs[#-#2]]};r)&@@f/@{#,#+1}&/@Range@Input[]]

Đây là một chương trình đầy đủ, đọc đầu vào từ một dấu nhắc. Đó là một cách thực hiện trực tiếp của định nghĩa, trong đó tôi đang theo dõi chuỗi hiện tại trongf (có giá trị f[n]mặc định n).

Đây là một phiên bản dễ đọc hơn một chút:

Last[
  f@n_ := n;
  (
    r = f@1;
    {f@a,f@b} = {f[b=+##],f[a=Abs[#-#2]]};
    r
  ) & @@ f /@ {#,#+1} & /@ Range @ Input[]
]

Một số phân tích

Tôi đã vẽ 2000 yếu tố đầu tiên của chuỗi (nó không thực sự trở nên thú vị hơn sau đó):

Vì vậy, chuỗi về cơ bản là tuyến tính với độ dốc 2 và luôn có một vài bước trong số đó. Có vẻ như các bước phát triển theo chiều dọc (nếu chúng thậm chí không bị ràng buộc), vì chúng hầu như không đáng chú ý khi bạn tăng số điểm bạn vẽ.

Chúng ta có thể biện minh cho sự tăng trưởng tuyến tính khá dễ dàng (đây là một chút sóng gió, nhưng tôi nghĩ rằng nó sẽ giữ được bằng chứng nghiêm ngặt bằng cảm ứng): ban đầu, số lượng ảnh hưởng tối đa của bước hoán vị nlà n + (n+1) = 2n + 1. Cũng lưu ý rằng những con số này sẽ luôn được chuyển đến 1, kể từ đó |n - (n+1)| = 1. Vì vậy, không có gì đáng ngạc nhiên khi chúng tôi nhận được các số xấp xỉ 2ntrong chuỗi. Tuy nhiên, chúng ta cũng có thể lưu ý rằng đối với các bước lên tới n , S _{n + 1} luôn bị giới hạn bởi n + 1 , điều đó có nghĩa là không có bước hoán đổi nào có thể hoán đổi hai số có giá trị lớn hơn n . Do đó, các số vẫn cần được xử lý sẽ nhỏ hơn hoặc bằng giá trị ban đầu của chúng. Vì thế,2n + 1 cũng là ràng buộc cho chính trình tự.

Tôi nghĩ rằng việc tìm một đối số cho độ dài của các bước sẽ khó khăn hơn.

CJam, 45 40 39 byte

Chỉ là một cách tiếp cận ngây thơ. Có thể được chơi gôn hơn nữa. Thiếu một chức năng trao đổi mảng quá nhiều.

ri_K*,\{\:L>2<L1$:+:S@:-z:DL=tDSL=t}/1=

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

ri_                             "Read the input, convert to integer and copy it";
   K*,                          "Multiply the copy by 20 and get 0 to 20*input-1 array";
      \{ ... }/1=               "Swap and put input on stack and run the loop that many";
                                "times. After the loop, take the second element as";
                                "we have a 0 based array while series is 1 based";
{\:L>2<L1$:+:S@:-z:DL=tDSL=t}
 \:L                            "Swap to put iteration index behind the array";
                                "and store array in L";
    >2<                         "In each loop, the iteration index will be on stack";
                                "Get the two elements from the array starting at that";
       L1$                      "Put the array on stack and copy the tuple";
          :+:S                  "Get the sum and store it in S";
              @:-z:D            "Get the absolute difference of the tuple and store in D";
                    L=t         "Put the element at S diff at sum index";
                       DSL=t    "Put the element at S sum at diff index";

Dùng thử trực tuyến tại đây

Haskell, 95 byte

f#n=let b=f$n+1;l=f n+b;r=abs$f n-b;y x|x==l=f r|x==r=f l|1<2=f x in y
p n=foldl(#)id[1..n-1]$1

Ví dụ sử dụng: p 70->139

Tôi không lưu trữ chuỗi trong một danh sách hoặc mảng. Tôi liên tục cập nhật chức năng nhận dạng thành một chức năng với hai yếu tố của bước hiện tại được hoán đổi. Sau ncác bước tôi gọi hàm kết quả với tham số 1.

J, 63 byte

3 :'{.>((1-~{(+,|@-)]{~1+[)|.@:{`[`]}])&.>/(<"*i.1-y),<>:i.3*y'

Sử dụng và kiểm tra:

   f=.3 :'{.>((1-~{(+,|@-)]{~1+[)|.@:{`[`]}])&.>/(<"*i.1-y),<>:i.3*y'

   f 5
9
   f every 1+i.20
1 3 1 7 9 11 11 11 15 15 19 19 19 19 19 19 19 19 19 19

Hãy thử trực tuyến tại đây.

Bình thường 55 53 51

Có lẽ có thể được chơi golf hơn nữa. Có thể trở nên rất chậm vì lớn nvì tôi lười tìm hiểu thời gian của một mảng tôi cần và chỉ sử dụng một mảng n^n.

Cảm ơn Biến động và Martin Büttner đã chỉ ra rằng tôi có thể sử dụng tối đa 3n.

KU*3QFNr1QJ@KN=G@tKNAJG,+JG.a-JG=Y@KJ XXKJ@KGGY)@K1

Giải trình

                   Q = input (implicit)
KU*3Q              K = range(3 * Q)
FNr1Q              for N in range(1, Q):
 J@KN               J = K[N]
 =G@tKN             G = K[1:][N]
 AJG,+JG.a-JG       J, G = J + G, abs(J - G)
 =Y@KJ              Y = K[J]
 XXKJ@KGGY          K[J], K[G] = K[G], Y
)
@K1                print K[1]

Con trăn 2 117 106 101

j=input();a=range(3*j)
for i in range(1,j):b,c=a[i:i+2];d=abs(b-c);a[b+c],a[d]=a[d],a[b+c]
print a[1]

Sử dụng một dict (bản đồ) để lưu các giá trị để sử dụng các chỉ số tùy ý. g(n)là một hàm trả về nmục thứ. Sau đó chỉ cần lặp lại input-1lần và xuất ra mục đầu tiên.

Hóa ra nó ngắn hơn bằng cách sử dụng các phương pháp từ câu trả lời Pyth của tôi.

Cảm ơn xnor vì đã tiết kiệm 5 byte.

Đi 150

func f(j int){a:=make([]int,j*2);for i:=range a{a[i]=i};for i:=1;i<j;i++{b,c:=a[i],a[i+1];v:=b-c;if v<0{v*=-1};a[b+c],a[v]=a[v],a[b+c]};println(a[1])}

Ungolfed, không có gì khó khăn, chủ yếu là bị đánh cắp từ @ Pietu1998

func f(j int) {
    a := make([]int, j*2) // Build the array we will be working on
    for i := range a {
        a[i] = i
    }
    for i := 1; i < j; i++ {
        b, c := a[i], a[i+1]
        v := b - c
        if v < 0 {
            v *= -1
        }
        a[b+c], a[v] = a[v], a[b+c]
    }
    println(a[1])
}

http://play.golang.org/p/IWkT0c4Ev5

Java, 162

int f(int n){int a[]=new int[2*n],s,d,x,t;for(x=0;x<2*n;)a[x]=++x;for(x=0;++x<n;){s=a[x]+a[x-1]-1;d=Math.abs(a[x]-a[x-1])-1;t=a[s];a[s]=a[d];a[d]=t;}return a[0];}

Giải trình

int f(int n) {
    int a[] = new int[2 * n], sum, diff, x, temp;
    for (x = 0; x < 2 * n;) {
        a[x] = ++x;  // set initial array
    }
    for (x = 0; ++x < n;) {
        sum = a[x] + a[x - 1] - 1;
        diff = Math.abs(a[x] - a[x - 1]) - 1;
        temp = a[sum];
        a[sum] = a[diff];
        a[diff] = temp;
    }
    return a[0];
}

đc 134 132 131 byte

[_1*]sOdsn2*ddslsSsa[ladd:S1-dsa0<P]dsPx1d0rsN:N[la1+dsad;SdS@r1+;SdS@rL@L@r+Ss-d0>Od;SrLsdSsrLs;Sr:S:S1;SladsN:Nlaln>G]dsGxln1-;Nf

Sử dụng echo $n $code | dc, ở đâu $nlà n và $codelà ... mã ( gasp ). Trích dẫn hương vị.

Chỉnh sửa: Trừ khi bạn làm phiền tôi để giải thích, tôi sẽ không bao giờ nhận được nó.

Perl 5, 131

Một giải pháp ngây thơ (tức là thực hiện trực tiếp định nghĩa). Một chương trình con, nó lấy đầu vào là một danh sách các 1độ dài mong muốn.

{map$a[$_]=$_,1..3*@_;($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_;$a[1]}

Hình dung đầu ra của nó bằng ví dụ print sub...->(1,1,1,1,1).

Giải trình:

map$a[$_]=$_,1..3*@_xây dựng mảng @a, lập chỉ mục cho mỗi số nguyên từ 1 đến 3 lần kích thước của @_(đầu vào).

($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_lặp lại nhiều lần switcheroo (một lần ít hơn kích thước của @_), chuyển đổi $a[$a[$_-1]+$a[$_]]với $a[abs($a[$_-1]-$a[$_])]như $_dao động từ 2 đến kích thước của @_.

Và sau đó chương trình con trở lại $a[1].

Perl 5 , 90 + 1 (-p) = 91 byte

@a=0..3*$_;$_=(map{@a[$d,$s]=@a[$s=$a[$_]+$a[$_-1],$d=abs$a[$_]-$a[$_-1]];$a[1]}1..$_)[-1]

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