ลำดับ SUDSI ( su m, d ifference, s wap, i ncrement) เป็นลำดับเลขจำนวนเต็มอยากรู้อยากเห็นที่ปรากฏขึ้นเพื่อแสดงพฤติกรรมที่ค่อนข้างวุ่นวาย สามารถสร้างได้ดังนี้:

ให้Sเป็นรายการจำนวนธรรมชาติที่ไม่มีที่สิ้นสุด: 1 2 3 4 5 6 .... Let S _ฉันหมายถึงหนึ่งในการจัดทำดัชนีฉันองค์ประกอบของ TH S ดังนั้นเริ่มแรก S ₁คือ 1, S ₂คือ 2 ฯลฯ (ไม่มีS ₀ )

เริ่มต้นด้วยS ₁และS ₂ ...

• คำนวณผลรวมของพวกเขา: sum = S1 + S2
• คำนวณความแตกต่างที่แท้จริงของพวกเขา (อันที่ใหญ่กว่าลบอันที่เล็กกว่า): diff = |S1 - S2|

• สลับสองค่าในSที่ดัชนีของผลรวมและส่วนต่าง:swap(Ssum, Sdiff)

• เพิ่มดัชนีของS ที่คุณกำลังทำงานด้วย ครั้งต่อไปคุณจะคำนวณผลรวมและความแตกต่างของS ₂และS ₃และเวลาหลังจากนั้นจะเป็นS ₃และS ₄เป็นต้น

• ทำซ้ำขั้นตอนนี้ไปเรื่อย ๆ

ต่อไปนี้เป็นขั้นตอนแรกของSเนื่องจากกระบวนการนี้ใช้ วงเล็บเหลี่ยม[]ล้อมรอบสองค่าที่กำลังจะถูกสรุปและแตกต่าง

ต้นฉบับS :

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

หลังจากเปลี่ยนS ₃ ( 3 = 1 + 2) และS ₁ ( 1 = |1 - 2|) แล้ว:

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

หลังจากเปลี่ยนS ₃และS _{1 แล้ว} :

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

หลังจากเปลี่ยนS ₇และS _{1 แล้ว} :

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

หลังจากเปลี่ยนS ₉และS _{1 แล้ว} :

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

หลังจากเปลี่ยนS ₁₁และS _{1 แล้ว} :

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

หลังจากเปลี่ยนS ₇และS _{5 แล้ว} :

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

เป็นต้น

ลำดับ SUDSI ถูกกำหนดเป็นลำดับขององค์ประกอบแรกในแต่ละรายการเหล่านี้ ดังนั้นแง่สองสามตัวแรกของลำดับ SUDSI 1 3 1 7 9 11 11มี

นี่คือ 200 คำแรกของลำดับ SUDSI (20 ต่อบรรทัด):

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

มันไม่ชัดเจน (สำหรับฉันอย่างน้อย) ว่าใครจะทำนายคำศัพท์ในอนาคต เพียงรู้สึกปลอดภัยที่จะบอกว่าคำศัพท์นั้นแปลกเสมอไม่ลด (หลังจากเทอมที่สอง) และมีการทำซ้ำจำนวนมากหลายครั้ง

ท้าทาย

เขียนโปรแกรมหรือฟังก์ชั่นที่รับจำนวนเต็มบวกnแล้วพิมพ์หรือส่งคืนคำที่nของลำดับ SUDSI ตัวอย่างเช่นถ้าnเป็น 1 ออกเป็น1ถ้าnเป็น 2 ผลลัพธ์คือ3ถ้าnเป็น 200 363ผลลัพธ์คือ

รับอินพุตด้วยวิธีปกติ (stdin / command line / function arg)
คำตอบที่สั้นที่สุดเป็นไบต์ชนะ
(ไซต์นั้นเข้ารหัสสิ่งต่าง ๆ ใน UTF-8 แต่คุณสามารถใช้การเข้ารหัสที่มีอยู่ในแบบที่คุณต้องการได้)

โบนัส Mathy: (อาจมีสิทธิ์ได้รับรางวัล)

• บอกฉันเพิ่มเติมเกี่ยวกับลำดับ SUDSI อะไรคือรูปแบบพื้นฐานของตัวเลขที่เป็นส่วนหนึ่งของมันและมีกี่แบบ (และแบบนั้น) (ฉันไม่สามารถหา SUDSI บนOEISได้)

Pyth, 45 41 40 38 ไบต์

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

ผมสังเกตเห็น (เช่นเดียวกับมาร์ตินBüttner) ที่สูงสุดได้รับผลกระทบจำนวนขั้นตอนการเปลี่ยนแปลงที่มีk 2k + 1แต่เนื่องจากเรามีเพียงขั้นตอนเราจะต้องรายการหมายเลขขึ้นไปn - 12n - 1

ลองใช้งานออนไลน์: การสาธิต

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]

Mathematica, 88 ไบต์

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

นี่เป็นโปรแกรมแบบเต็มอ่านอินพุตจากพรอมต์ เป็นการใช้งานคำจำกัดความโดยตรงซึ่งฉันกำลังติดตามลำดับปัจจุบันในf(ซึ่งเป็นค่าf[n]เริ่มต้นn)

นี่เป็นรุ่นที่อ่านได้มากกว่านี้เล็กน้อย:

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

การวิเคราะห์บางอย่าง

ฉันได้วางแผนองค์ประกอบลำดับแรก ๆ 2,000 รายการ (ไม่น่าสนใจมากขึ้นหลังจากนั้น):

ดังนั้นลำดับจึงเป็นเชิงเส้นตรงกับความชัน 2 และมีขั้นตอนบางขั้นตอนเสมอ ดูเหมือนว่าขั้นตอนจะเพิ่มขึ้นแบบไม่เชิงเส้นย่อย (ถ้ามันไม่ได้ถูกล้อมด้วย) เพราะมันแทบจะสังเกตไม่เห็นเมื่อคุณเพิ่มจำนวนคะแนนที่คุณพล็อต

เราสามารถแสดงให้เห็นถึงการเจริญเติบโตเชิงเส้นค่อนข้างง่าย (นี้เป็น handwavy บิต แต่ฉันคิดว่ามันจะถือได้ถึงหลักฐานอย่างเข้มงวดโดยการเหนี่ยวนำ): ตอนแรกที่ได้รับผลกระทบจำนวนสูงสุดของขั้นตอนการเปลี่ยนแปลงที่มีn n + (n+1) = 2n + 1โปรดทราบว่าหมายเลขเหล่านี้จะถูกย้ายไปที่1ตั้งแต่|n - (n+1)| = 1ตลอดเวลา ดังนั้นจึงไม่น่าแปลกใจที่เราได้รับตัวเลขที่อยู่2nในลำดับโดยประมาณ แต่เรายังสามารถทราบว่าขั้นตอนถึงn , S _{1 + n}มีขอบเขตเสมอโดย1 + nซึ่งหมายความว่าไม่มีขั้นตอนการแลกเปลี่ยนสามารถสลับตัวเลขสองซึ่งมีทั้งที่มากกว่าn ดังนั้นตัวเลขที่ยังต้องประมวลผลจะน้อยกว่าหรือเท่ากับค่าเริ่มต้น ดังนั้น2n + 1 ยังเป็นข้อ จำกัด สำหรับลำดับตัวเอง

ฉันคิดว่าการหาข้อโต้แย้งสำหรับความยาวของขั้นตอนจะยากขึ้น

CJam, 45 40 39 ไบต์

เพียงวิธีการไร้เดียงสา สามารถตีกอล์ฟต่อไปได้ ฟังก์ชันการสลับแถวที่ขาดหายไปมากเกินไป

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

มันทำงานอย่างไร:

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";

ลองออนไลน์ได้ที่นี่

Haskell, 95 ไบต์

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

ตัวอย่างการใช้: p 70->139

ฉันจะไม่เก็บลำดับในรายการหรืออาร์เรย์ ฉันปรับปรุงฟังก์ชั่นประจำตัวซ้ำ ๆ ให้กับฟังก์ชั่นโดยเปลี่ยนองค์ประกอบสองขั้นตอนปัจจุบัน หลังจากขั้นตอนที่ผมเรียกว่าฟังก์ชั่นที่เกิดกับพารามิเตอร์ n1

J, 63 ไบต์

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

การใช้งานและการทดสอบ:

   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

ลองออนไลน์ได้ที่นี่

Pyth, 55 53 51

อาจจะสามารถเล่นกอล์ฟต่อไปได้ อาจมีขนาดใหญ่ช้ามากnเพราะฉันขี้เกียจที่จะหาว่าฉันต้องการอาเรย์นานแค่ไหนและใช้ไอเทมเพียงอันn^nเดียว

ขอบคุณกับความผันผวนและมาร์ตินBüttner3nสำหรับการชี้ให้เห็นว่าฉันสามารถใช้สูงสุด

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

คำอธิบาย

                   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]

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

ใช้dict(แผนที่) เพื่อบันทึกค่าเพื่อใช้ดัชนีโดยพลการ g(n)เป็นฟังก์ชั่นคืนnรายการที่ จากนั้นทำซ้ำinput-1ครั้งและส่งออกรายการแรก

ปรากฎว่ามันสั้นลงโดยใช้วิธีการจากคำตอบ Pyth ของฉัน

ขอบคุณxnorสำหรับการบันทึก 5 ไบต์

ไป 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 ไม่มีอะไรยุ่งยากส่วนใหญ่ถูกขโมยจาก @ 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];}

คำอธิบาย

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

กระแสตรง, 134 132 131 ไบต์

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

การใช้งานecho $n $code | dcที่$nเป็นnและ$codeเป็น ... รหัส ( หอบ ) อ้างถึงรสนิยม

แก้ไข: หากคุณรบกวนฉันสำหรับคำอธิบายฉันจะไม่เข้าไปใกล้มัน

Perl 5, 131

โซลูชันไร้เดียงสา (เช่นการนำไปใช้โดยตรงของคำจำกัดความ) รูทีนย่อยจะรับอินพุตเป็นรายการ1s ของความยาวที่ต้องการ

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

print sub...->(1,1,1,1,1)เห็นภาพการส่งออกของตนโดยการเช่น

คำอธิบาย:

map$a[$_]=$_,1..3*@_สร้างอาร์เรย์@aโดยทำดัชนีแต่ละจำนวนเต็มด้วยตัวเองตั้งแต่ 1 ถึง 3 เท่าของขนาด@_(อินพุต)

($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_ซ้ำ switcheroo ซ้ำ (ครั้งหนึ่งน้อยกว่าขนาดของ@_) สลับ$a[$a[$_-1]+$a[$_]]กับ$a[abs($a[$_-1]-$a[$_])]เป็น$_ช่วงที่ 2 @_จากขนาดของ

จากนั้นรูทีนย่อยจะกลับ$a[1]มา

Perl 5 , 90 + 1 (-p) = 91 ไบต์

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

ลองออนไลน์!