SUDSI sekansı ( su m, d farklılığı, s wap, i ncrement ) oldukça kaotik davranış sergileyen meraklı bir tamsayı sekansıdır. Aşağıdaki gibi üretilebilir:

Let S doğal sayıların sonsuz liste be: 1 2 3 4 5 6 .... Let S _i bir endeksli ifade i inci elemanı S . Yani başlangıçta S ₁ 1, S ₂ 2 vb. ( S ₀ yoktur ).

S ₁ ile Başlayanlar ve S _2'den ...

• Toplamlarını hesapla: sum = S1 + S2
• Mutlak farklarını hesaplayın (daha büyük olan eksi daha küçük olanı): diff = |S1 - S2|

• İçindeki iki değeri değiştirin S toplamı ve farkı endeksleri de:swap(Ssum, Sdiff)

• Üzerinde çalıştığınız S indekslerini artırın . Bu yüzden bir dahaki sefere toplamını ve farkını hesaplamak olacak S ₂ ve S ₃ öyle olacak bundan sonra, ve saati S ₃ ve S ₄ , vb

• Bu işlemi süresiz olarak tekrarlayın.

İşte bu süreç uygulandığında S'nin ilk birkaç aşaması . Parantezler [], toplanmak ve farklılaştırılmak üzere olan iki değeri çevreler.

Orijinal S :

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

Sonra , S ₃ ( 3 = 1 + 2) ve S ₁ ( 1 = |1 - 2|) takas edilir:

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

Sonra S ₃ ve S ₁ takas edilir:

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

Sonra S ₇ ve S ₁ takas edilir:

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

Sonra S ₉ ve S ₁ takas edilir:

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

Sonra , S ₁₁ ve S ₁ takas edilir:

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

S ₇ ve S _5'ten sonra takas edilir:

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

vb.

SUDSI dizisi, bu listelerin her birindeki ilk öğelerin dizisi olarak tanımlanır.Yani SUDSI dizisinin ilk birkaç terimi 1 3 1 7 9 11 11.

SUDSI dizisinin ilk 200 terimi (satır başına 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

Gelecekteki terimleri nasıl tahmin edebileceği belirsiz (en azından benim için). Sadece terimlerin her zaman garip, azalmayan (ikinci terimden sonra) olduğunu ve bazı sayıların birçok kez tekrarlandığını söylemek güvenlidir.

Meydan okuma

Pozitif tamsayı alan bir program ya da işlev Yazın , n ve baskılar veya döner n SUDSI dizisinin inci terimi. Örneğin, n 1 olduğunda, çıkış 1ise, n, 2'dir çıkışı, 3eğer, n, 200, çıkış 363.

Girişi normal şekilde alın (stdin / komut satırı / işlev arg). Bayt cinsinden
en kısa cevap kazanır.
(Bu site UTF-8'deki şeyleri kodlar, ancak istediğiniz herhangi bir lanet kodlamayı kullanabilirsiniz.)

Matematik bonusu: (potansiyel olarak ödül için uygun)

• Bana SUDSI dizisi hakkında daha fazla bilgi verin. Hangi sayıların bir parçası olduğunun ve kaç tanesinin (ve bunun gibi şeylerin) altında yatan model nedir? (Ben SUDSI bulamadık OEIS bu arada.)

Pyth, 45 41 40 38 bayt

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

(Martin BÜTTNER yaptığı gibi) bir permütasyon adımının maksimum etkilenen sayısının az olduğu fark kolduğunu 2k + 1. Ama sadece n - 1adımlara sahip olduğumuzdan, sadece sayıların bir listesine ihtiyacımız var 2n - 1.

Çevrimiçi deneyin: Gösteri

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 bayt

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

Bu, komut isteminden girişi okuyan tam bir programdır. Şu anki diziyi takip ettiğim tanımın çok doğrudan bir uygulaması.f (değerleri f[n]varsayılan olarak n) .

İşte biraz daha okunabilir versiyon:

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

Bazı analizler

Dizinin ilk 2000 elemanını çizdim (daha sonra gerçekten daha ilginç olmaz):

Yani dizi esas olarak eğim 2 ile doğrusaldır ve her zaman bu adımlardan birkaçına sahiptir. Görünüşe göre adımlar alt çizgide büyüyor (hatta sınırlandırılmamışlarsa), çizdiğiniz puan sayısını artırdıkça zar zor farkedilir hale geliyorlar.

Biz (bu biraz handwavy, ama o indüksiyon tarafından titiz bir kanıtı kadar yapacağını düşünüyorum) oldukça kolay lineer büyümeyi haklı: başlangıçta bir permütasyon adımının maksimum etkilenen sayısı az nolduğu n + (n+1) = 2n + 1. Ayrıca bu rakamlar daima taşınacak unutmayın 1beri |n - (n+1)| = 1. Bu yüzden, yaklaşık 2nsırada olan sayıları almamız şaşırtıcı değildir . Bununla birlikte, aynı zamanda kadar adımlar için dikkat olabilir n , S _{, n + 1} her tarafından sınırlanmaktadır , n + 1 , burada bir takas aşaması göre hem daha büyük olan iki numara takas olabilir araçlar da sekansının kendisinin sınırıdır. n . Bu nedenle, hala işlenmesi gereken sayılar başlangıç ​​değerlerinden küçük veya ona eşit olacaktır. Bu nedenle,2n + 1

Bence adımların uzunluğu için bir argüman bulmak daha zor olacak.

CJam, 45 40 39 bayt

Sadece saf bir yaklaşım. Daha fazla golf yapılabilir. Dizi takas işlevi çok fazla eksik.

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

Nasıl çalışır:

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

Buradan çevrimiçi deneyin

Haskell, 95 bayt

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

Kullanım örneği: p 70->139

Diziyi bir liste veya dizide saklamıyorum. Kimlik işlevini, geçerli adımın iki öğesi değiştirilmiş bir işleve art arda güncelleştiririm. nAdımlardan sonra sonuç fonksiyonunu parametre ile çağırırım 1.

J, 63 bayt

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

Kullanım ve testler:

   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

Burada çevrimiçi deneyin.

Pyth, 55 53 51

Muhtemelen daha fazla golf olabilir. nİhtiyacım olan bir dizinin ne kadar uzun olduğunu ve sadece bir n^ntane kullandığımı anlamak için tembel olduğum için gerçekten büyük olabilir .

Volatility ve Martin Büttner'e teşekkür ederim 3n.

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

açıklama

                   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]

dictRasgele dizinler kullanmak üzere değerleri kaydetmek için bir (harita) kullanır . öğeyi g(n)döndüren bir işlevdir n. Sonra sadece süreyi yineler input-1ve ilk öğeyi çıktılar.

Pyth cevabımdaki yöntemleri kullanarak daha kısa çıkıyor.

Xnor sayesinde5 bayt kaydettiği .

Git 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, zor bir şey, çoğunlukla @ Pietu1998'den çalındı

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

açıklama

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

dC, 134 132 131 bayt

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

Kullanım echo $n $code | dc, $nbir n ve $codebir ... kodu ( gasp ). Tatmak için alıntı.

Düzenleme: Bir açıklama için beni rahatsız etmedikçe, ben asla etrafında almak olmaz.

Perl 5, 131

Saf bir çözüm (yani, tanımın doğrudan uygulanması). Bir altyordam, girdiyi 1istenen uzunlukta bir liste olarak alır .

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

Çıktısını örn print sub...->(1,1,1,1,1).

Açıklama:

map$a[$_]=$_,1..3*@_diziyi oluşturur, @aher tamsayıyı kendisinin @_(giriş) boyutunun 1 ila 3 katı kadar indeksler .

($a[$a[$_-1]+$a[$_]],$a[abs($a[$_-1]-$a[$_])])=($a[abs($a[$_-1]-$a[$_])],$a[$a[$_-1]+$a[$_]])for 2..@_arka arkaya şaşırtıcı değişim (boyutundan daha az bir kez tekrar @_geçiş) $a[$a[$_-1]+$a[$_]]ile $a[abs($a[$_-1]-$a[$_])]olduğu gibi $_aralıklarda 2'den boyutuna @_.

Ve sonra altyordam geri döner $a[1].

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

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

Çevrimiçi deneyin!