SUDSI 서열 ( 스와 m, D ifference, s의 WAP, I ncrement)이 나타날 오히려 혼란 동작을 보이는 것을 호기심 정수 시퀀스이다. 다음과 같이 생성 될 수 있습니다.

S를 자연수의 무한한 목록으로 보자 1 2 3 4 5 6 .... 하자 S가 _나는 한 인덱싱 나타내고 I 의 번째 요소 S . 따라서 초기에 S ₁ 은 1, S ₂ 는 2 등입니다 ( S ₀ 은 없음 ).

S ₁ 및 S _2로 시작 ...

• 합계를 계산하십시오. 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입니다.

다음은 SUDSI 시퀀스의 첫 200 개 용어입니다 (한 줄에 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 을 취하고 SUDSI 시퀀스 의 n 번째 항을 인쇄하거나 리턴 하는 프로그램 또는 함수를 작성하십시오 . 예를 들어, n 이 1이면 출력은 1이고, n 이 2이면 출력은 3이고, n 이 200이면 출력은 363입니다.

일반적인 방법으로 입력하십시오 (stdin / command line / function arg). 바이트 단위
의 최단 답변 이 이깁니다.
(이 사이트는 UTF-8로 인코딩하지만 원하는 기존 인코딩을 사용할 수 있습니다.)

마티 보너스 : (바운티 바운티 가능)

• SUDSI 시퀀스에 대해 자세히 알려주세요. 어떤 숫자가 그 숫자이고 어떤 숫자가 있는지 (그리고 이와 같은 것들)의 기본 패턴은 무엇입니까? (그런데 OEIS에서 SUDSI를 찾을 수 없었습니다 .)

Pyth, 45 41 40 38 바이트

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

(Martin Büttner와 마찬가지로) 순열 단계의 최대 영향 수 k는 2k + 1입니다. 그러나 n - 1단계 만 있으므로 최대 숫자 목록 만 필요합니다 2n - 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]

수학, 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[]
]

일부 분석

시퀀스의 처음 2000 개 요소를 플로팅했습니다 (나중에 더 흥미롭지는 않음).

따라서 시퀀스는 기본적으로 기울기 2와 선형이며 항상 몇 단계가 있습니다. 단계는 플롯하는 점의 수를 늘리면 간신히 눈에 띄기 때문에 단계가 조금씩 좁아지는 것처럼 보입니다 (한계가없는 경우).

우리는 선형 성장을 매우 쉽게 정당화 할 수 있습니다 (이것은 약간 손으로 만들지 만 유도에 의해 엄격한 증거를 유지할 것이라고 생각합니다). 처음에는 순열 단계의 영향을받는 최대 수 n는 n + (n+1) = 2n + 1입니다. 또한이 숫자는 1이후 로 항상 이동합니다 |n - (n+1)| = 1. 따라서 우리가 대략 2n순서대로있는 숫자를 얻는 것은 놀라운 일이 아닙니다 . 그러나 우리는 또한 최대 단계를주의 할 수 N , S _{, N + 1이} 항상 의해 제한되는 N + 1 , 어떤 스와핑 단계보다 모두 큰 두 개의 숫자 바꿀 수 없음을 의미 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";

여기에서 온라인으로 사용해보십시오

하스켈, 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

시퀀스를 목록이나 배열에 저장하지 않습니다. 현재 단계의 두 가지 요소가 바뀐 함수로 ID 함수를 반복해서 업데이트합니다. n단계 후에 매개 변수를 사용하여 결과 함수를 호출합니다 1.

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

여기에서 온라인으로 사용해보십시오.

피스, 55 53 51

아마 더 골프를 칠 수 있습니다. n필요한 배열의 길이를 알아 내고 배열을 사용하는 것이 게으 르기 때문에 크게 느려질 수 n^n있습니다.

Volatility 와 Martin Büttner 에게 최대를 사용할 수 있다고 지적 해 주셔서 감사합니다 3n.

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]

파이썬 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임의의 인덱스를 사용하여 값을 저장 (지도). th 항목을 g(n)반환하는 함수 n입니다. 그런 다음 input-1시간을 반복 하고 첫 번째 항목을 출력합니다.

내 Pyth 답변의 방법을 사용하면 더 짧습니다.

5 바이트를 절약 한 xnor 에게 감사 합니다.

이동 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])}

@ 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

자바, 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];
}

dc, 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는 ... 코드 ( 헐떡 거림 ). 맛을 인용하십시오.

편집 : 당신이 설명을 위해 나를 괴롭히지 않는 한, 나는 결코 그것을 피할 수 없습니다.

펄 5, 131

순진한 솔루션 (즉, 정의의 직접 구현). 서브 루틴, 1원하는 길이의 목록으로 입력을받습니다 .

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

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

온라인으로 사용해보십시오!