Hãy tính ...

Đếm đến 2 và quay lại 1
Đếm lên 4 và quay lại 1
Đếm đến 6 và quay lại 1
... ok bạn hiểu rồi ...

đặt tất cả những thứ này lại với nhau và bạn sẽ có được trình tự sau

 {1,2,1,2,3,4,3,2,1,2,3,4,5,6,5,4,3,2,1,2,3,4,5,6,7,8,7,6,5,4,3,2,1,2,3...}

Thử thách
Đưa ra một số nguyên n>0cho 1 chỉ mục (hoặc n>=0cho 0 chỉ mục), xuất ra số hạng thứ n của chuỗi này

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

Input->Output  

1->1  
68->6  
668->20  
6667->63  
10000->84

Quy tắc

chương trình của bạn phải có khả năng tính toán các giải pháp lên tới n = 10000 trong vòng một phút

Đây là mã golf , vì vậy mã ngắn nhất tính bằng byte sẽ thắng!

JavaScript (ES7),  59 ... 44  43 byte

Đã lưu 1 byte nhờ Titus

Đầu vào dự kiến: 1 chỉ mục.

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

Ban đầu lấy cảm hứng từ một công thức cho A004738 , đó là một chuỗi tương tự. Nhưng cuối cùng tôi đã viết lại nó hoàn toàn.

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

let f=

n=>(n-=(r=(~-n/2)**.5|0)*r*2)<++r*2?n:r*4-n

console.log(f(1))     // -> 1
console.log(f(68))    // -> 6
console.log(f(668))   // -> 20
console.log(f(6667))  // -> 63
console.log(f(10000)) // -> 84

Làm sao?

Trình tự có thể được sắp xếp thành một hình tam giác, với phần bên trái theo thứ tự tăng dần và phần bên phải theo thứ tự giảm dần.

Dưới đây là 4 hàng đầu tiên, chứa 32 điều khoản đầu tiên:

            1 | 2
        1 2 3 | 4 3 2
    1 2 3 4 5 | 6 5 4 3 2
1 2 3 4 5 6 7 | 8 7 6 5 4 3 2

Bây giờ, hãy giới thiệu một số biến:

 row  | range   | ascending part              | descending part
 r    | x to y  | 1, 2, ..., i                | 4(r+1)-(i+1), 4(r+1)-(i+2), ...
------+---------+-----------------------------+-----------------------------------------
  0   |  1 -  2 |                           1 | 4-2
  1   |  3 -  8 |                   1   2   3 | 8-4  8-5  8-6
  2   |  9 - 18 |           1   2   3   4   5 | 12-6 12-7 12-8  12-9  12-10
  3   | 19 - 32 |   1   2   3   4   5   6   7 | 16-8 16-9 16-10 16-11 16-12 16-13 16-14

Chúng tôi bắt đầu với 2 yếu tố ở trên cùng và thêm 4 yếu tố trên mỗi hàng mới. Do đó, số phần tử trên hàng r được lập chỉ mục 0 có thể được biểu thị bằng:

a(r) = 4r + 2

Vị trí bắt đầu 1 chỉ số x của hàng r được tính bằng tổng của tất cả các số hạng trước trong chuỗi số học này cộng với một, dẫn đến:

x(r) = r * (2 + a(r - 1)) / 2 + 1
     = r * (2 + 4(r - 1) + 2) / 2 + 1
     = 2r² + 1

Đối ứng, với vị trí 1 chỉ số n trong chuỗi, hàng tương ứng có thể được tìm thấy với:

r(n) = floor(sqrt((n - 1) / 2))

hoặc dưới dạng mã JS:

r = (~-n / 2) ** 0.5 | 0

Khi chúng ta biết r (n) , chúng ta trừ vị trí bắt đầu x (r) trừ đi một từ n :

n -= r * r * 2

Chúng ta so sánh n với a (r) / 2 + 1 = 2r + 2 để tìm hiểu xem chúng ta đang ở phần tăng dần hay trong phần giảm dần:

n < ++r * 2 ?

Nếu biểu thức này là đúng, chúng ta trả về n . Nếu không, chúng ta trả về 4 (r + 1) - n . Nhưng vì r đã được tăng lên trong câu lệnh trước, nên điều này được đơn giản hóa là:

n : r * 4 - n

Haskell , 37 byte

(!!)$do k<-[1,3..];[1..k]++[k+1,k..2]

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

Không có chỉ mục. Tạo danh sách và lập chỉ mục vào đó. Cảm ơn Ørjan Johansen vì đã tiết kiệm 2 byte!

Haskell , 38 byte

(!!)[min(k-r)r|k<-[0,4..],r<-[1..k-2]]

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

Không có chỉ mục. Tạo danh sách và lập chỉ mục vào đó.

Haskell , 39 byte

n%k|n<k=1+min(k-n)n|j<-k+4=(n-k)%j
(%2)

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

Không có chỉ mục. Một phương pháp đệ quy.

Python , 46 byte

f=lambda n,k=2:-~min(n,k-n)*(n<k)or f(n-k,k+4)

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

Không có chỉ mục.

Husk , 8 byte

!…ṁoe1DN

1 chỉ mục. Hãy thử trực tuyến!

Giải trình

!…ṁoe1DN  Implicit input (an integer).
       N  Positive integers: [1,2,3,4,...
  ṁo      Map and concatenate
      D   double: [2,4,6,8,...
    e1    then pair with 1: [1,2,1,4,1,6,1,8,...
 …        Fill gaps with ranges: [1,2,1,2,3,4,3,2,1,2,3,4,5,6,...
!         Index with input.

Perl 6 , 29 byte

{({|(1...$+=2...2)}...*)[$_]}

Dùng thử trực tuyến

Dựa trên 0

Mở rộng:

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

  (
    # generate an outer sequence

    {           # bare block lambda

      |(        # flatten into outer sequence

        # generate an inner sequence

        1       # start at 1

        ...     # go (upward) towards:

        $       # an anonymous state variable (new one for each outer sequence)
          += 2  # increment by 2

        ...     # go (downward) towards:

        2       # stop at 2 (1 will come from the next inner sequence)

      )
    }

    ...         # keep generating the outer sequence until:
    *           # never stop

  )[ $_ ]       # index into outer sequence
}

Trình tự bên trong 1...$+=2...2tạo ra

(1, 2).Seq
(1, 2, 3, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2).Seq
(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 9, 8, 7, 6, 5, 4, 3, 2).Seq
...

Để làm cho nó dựa trên 1, thêm 0,trước thứ hai {hoặc thêm -1sau$_

R, 64 byte

function(n)unlist(sapply(seq(2,n,2),function(x)c(2:x-1,x:2)))[n]

Hàm có một đối số n. Nó tạo ra một vectơ 2:nvới số gia là 2. Với mỗi vectơ này, vectơ 1:(x-1)và x:2được tạo. Điều này trong tổng số sẽ dài hơn n. Chúng tôi unlist, để có được một vectơ và lấy nmục thứ-thứ.

Python 2 , 56 byte

def f(x):n=int((x/2)**.5);print 2*n-abs(2*n*n+2*n+1-x)+2

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

Đây là 0 chỉ mục.

-1 byte nhờ @JustinMariner

Cách thức hoạt động

Chúng tôi lưu ý rằng nhóm 1-indexed n( 1, 2, ... 2n ..., 2, 1) xảy ra từ các phần tử được đánh số 0 được lập chỉ mục 2(n-1)^2thành 2n^2.

Để tìm các phần tử tại chỉ số x, chúng ta có thể tìm số nhóm nđó xlà trong. Từ đó, chúng tôi tính toán khoảng cách từ trung tâm của nhóm đó xlà. (Khoảng cách này là abs(2*n**2+2*n+2-x)).

Tuy nhiên, do các phần tử giảm dần ra khỏi trung tâm của một nhóm, chúng tôi trừ đi khoảng cách từ giá trị tối đa của nhóm.

05AB1E , 8 byte

Mã số:

ÅÈ€1Ÿ¦¹è

Sử dụng mã hóa 05AB1E . Hãy thử trực tuyến!

Giải trình:

ÅÈ           # Get all even numbers until input (0, 2, ..., input)
  €1         # Insert 1 after each element
    Ÿ        # Inclusive range (e.g. [1, 4, 1] -> [1, 2, 3, 4, 3, 2, 1])
     ¦       # Remove the first element
      ¹è     # Retrieve the element at the input index

JavaScript, 39 byte

f=(n,t=2)=>n>t?f(n-t,t+4):n>t/2?t-n+2:n

Thạch , 10 , 9 byte

ḤŒḄṖµ€Fị@

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

Cũng có 1 chỉ số, và kết thúc khá nhanh.

Một byte được lưu nhờ vào @ErikTheOutgolfer!

Giải trình:

Theo giả thuyết, giả sử đầu vào ( a) là 3.

    µ€      # (Implicit) On each number in range(a):
            #
Ḥ           # Double
            #   [2, 4, 6]
            #
 ŒḄ         # Convert to a range, and Bounce
            #   [[1, 2, 1], [1, 2, 3, 4, 3, 2, 1], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]]
            #
   Ṗ        # Pop
            #   [[1, 2], [1, 2, 3, 4, 3, 2], [1, 2, 3, 4, 5, 6, 5, 4, 3, 2]]
            #
     F      # Flatten
            #   [1, 2, 1, 2, 3, 4, 3, 2, 1, 2, 3, 4, 5, 6, 5, 4, 3, 2]
            #
      ị@    # Grab the item[a]
            #   1
            #

MATL , 15 byte

li:"@EZv4L)]vG)

1 dựa.

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

Lần này là thời gian cho các trường hợp thử nghiệm lớn nhất trong TIO, nhưng kết thúc đúng lúc trên máy tính để bàn của tôi (trình biên dịch chạy trên MATLAB R2017a). Để hiển thị thời gian đã trôi qua, thêm Z`vào cuối mã.

>> matl 'li:"@EZv4L)]vG)Z`'
> 10000
84
15.8235379852476

Giải trình

Mã này tạo ra nhiều điều khoản hơn mức cần thiết. Cụ thể, nó tính toán n"các mảnh" của chuỗi, trong đó mỗi mảnh là một số đếm và trở về 1.

l       % Push 1
i       % Push input, n
:       % Range [1 2 ...n]
"       % For each k in that range
  @E    %   Push 2*k
  Zv    %   Symmetric range: [1 2 ... 2*k-1 2*k 2*k-1 ... 2 1]
  4L)   %   Remove last entry: [1 2 ... 2*k-1 2*k 2*k-1 ... 2]
]       % End
v       % Concatenate all stack contents into a column vector
G)      % Get n-th entry. Implicitly display

Husk , 12 10 byte

!ṁ§¤+hḣṫİ0

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

1 chỉ mục, hoạt động khá nhanh

Giải trình

!ṁ§¤+hḣṫİ0
 ṁ      İ0    Map the following function over the even numbers and concatenate the results together
  §   ḣṫ      Get the ranges 1-n and n-1, then... 
   ¤+h         remove the last element from both of them and concatenate them together
!             Return the element of the resulting list at the given index

Toán học, 90 byte

Flatten[{1}~Join~Table[Join[Rest[p=Range@i],Reverse@Most@p],{i,2,Round[2Sqrt@#],2}]][[#]]&

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

Võng mạc , 62 byte

.+
$*
^((^.|\2..)*)\1.
6$*1$2$2;1
(?=.+;(.+))\1(.+).*;\2.*
$.2

Hãy thử trực tuyến! Liên kết bao gồm các trường hợp thử nghiệm. Đầu vào là 1 chỉ mục. Giai đoạn đầu tiên chỉ là thập phân để chuyển đổi đơn phương. Giai đoạn thứ hai tìm thấy số vuông cao nhất sđúng chưa đến một nửa n; $1là s², trong khi $2là 2s-1. Nó tính toán hai giá trị, đầu tiên là số lượng trong lần chạy lên / xuống hiện tại 4(s+1) = 4s+4 = 2$2+6, và thứ hai là vị trí trong lần chạy đó n-2s² = n-(2$1+1)+1 = n-$&+1, điều này chỉ đòi hỏi 1phải bù cho việc 1sử dụng để thực thi bất đẳng thức nghiêm ngặt. Giai đoạn cuối cùng sau đó tính từ vị trí đó đến cả điểm bắt đầu và kết thúc của lần chạy và lấy kết quả thấp hơn và chuyển nó thành số thập phân.

Toán học, 67 byte

(t=z=1;While[(x=3-4t+2t^2)<#,t++;z=x];If[#-z>2t-2,4t-5+z-#,#-z+1])&

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

Perl 5 , 43 + 1 (-p) = 44 byte

$_=($n=2*int sqrt$_/2)+2-abs$n/2*$n+$n+1-$_

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

Tôi đã làm việc trên một công thức để tính trực tiếp phần tử thứ n. Sau đó, tôi thấy rằng @ fireflame241 đã hoàn thành công việc đó và tôi đã chơi nó với Perl.

# Perl 5 , 50 + 1 (-n) = 51 byte

push@r,1..++$",reverse 2..++$"while@r<$_;say$r[$_]

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

Kết quả là 0 được lập chỉ mục.

Haskell , 115 81 byte

y%x=snd(span(<x)$scanl(+)y[y+1,y+3..])!!0
g 1=1
g x|1%x>2%x=1+g(x-1)|1>0=g(x-1)-1

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

Có một số phép thuật đang diễn ra ở đây. Có lẽ có thể ngắn hơn nếu tôi sử dụng một cách tiếp cận bình thường mặc dù.

Giải trình

Đầu tiên chúng tôi xác định %. %là một hàm có hai biến xvà y. Nó xây dựng một danh sách scanl(+)y[y+1,y+3..]và tìm phần tử đầu tiên của danh sách đó lớn hơn x. scanl(+)chỉ cần thực hiện các số tiền lặp, để có được các số tam giác chúng ta sẽ làm scanl(+)0[1..], để có được các số vuông chúng ta sẽ làm scanl(+)0[1,3..]. Hai danh sách cụ thể chúng tôi sẽ xây dựng là scanl(+)2[3,5..]và scanl(+)1[2,4..]đây là những điểm uốn của mẫu.

Bây giờ chúng ta xác định hàm chính gmất một x. Nếu xlà một cái chúng tôi trả lại 1bởi vì đó là giá trị đầu tiên. Mặt khác, chúng tôi kiểm tra hai điểm uốn tiếp theo, nếu biến động xuống lớn hơn, 1%x>2xchúng tôi trả lại người kế thừa g$x-1nếu không chúng tôi sẽ trả lại tiền thân của g$x-1.

Ok nhưng tại sao nó hoạt động?

Trước hết "Cái gì với cách chúng ta tìm thấy đỉnh?". Điều quan trọng cần lưu ý khoảng cách giữa các đỉnh liên tiếp cùng loại. Bạn sẽ nhận thấy rằng sự khác biệt đang tăng lên 2 lần mỗi lần. Điều này có ý nghĩa bởi vì các cơ sở hình tam giác trở nên rộng hơn 2 lần mỗi lần. Chúng tôi có thể tạo một sự khác biệt liên tục của danh sách bằng cách sử dụng một danh sách theo nghĩa đen [2,4..]và chúng tôi sử dụng scanl(+)để biến các danh sách này thành danh sách đỉnh của chúng tôi, dựa trên vị trí của đỉnh đầu tiên và sự khác biệt đầu tiên.

Vì vậy, bây giờ chúng ta có một cách để tìm các đỉnh lên và xuống, chúng ta có thể sử dụng thông tin đó để lấy các giá trị. Chúng tôi nói rằng giá trị đầu tiên là 1nếu không chúng tôi phải lấy người kế nhiệm hoặc người tiền nhiệm. Nếu đỉnh tiếp theo là một đỉnh đi lên, chúng ta muốn lấy tiền thân, nếu không, chúng ta sẽ lấy người kế vị.

Haskell , 56 51 46 byte

Đây là giải pháp tốt hơn của tôi với ít toán học hơn và ít byte hơn.

d x|e<-[1..x-1]=e++map(x+1-)e
(([1..]>>=d)!!0)

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

Pyke , 14 byte

SF}SDtO_+)sQt@

Hãy thử nó ở đây!

S              -    range(1, input)
 F}SDtO_+)     -   for i in ^:
  }            -      ^ * 2
   S           -     range(1, ^)
        +      -    ^ + v
     tO_       -     ^[1:-1:-1]
          s    -  sum(^)
           Qt@ - ^[input-1]

C # (Lõi .NET) , 120 byte

Giải thích: khá đơn giản, vòng lặp lồng đầu tiên leo lên tối đa của chúng tôi, vòng thứ hai leo xuống xuống 2. Lặp lại cho mỗi bội số của 2.

x=>{var a=0;for(int i=2,j=0;j<x;i+=2){for(var b=1;b<=i&j<x;b++,j++){a=b;}for(var c=i-1;c>1&j<x;c--,j++){a=c;}}return a;}

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

Ruby , 78 75 byte

Đã lưu 1 byte nhờ Step Hen

Đã lưu 1 byte nhờ Mr. Xcoder

->n{a=0;b=2;c=1;n.times{if a==b then c=0;b+=2;end;c=1if a<2;a+=c<1?-1:1};a}

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

Hy vọng rằng tôi có thể nhận được một số lời khuyên để kéo bytecount xuống nhiều hơn. Tôi đã cố gắng thực hiện một cách tiếp cận đơn giản.

Java (OpenJDK 8) , 53 byte

n->{int i=2;for(;n>i;i+=4)n-=i;return n>i/2?i-n+2:n;}

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

-2 byte nhờ Nevay.

1 chỉ mục.

TL; DR Chúng tôi chia chuỗi thành các khối thuận tiện, tìm đoạn nđược đặt trong, sau đó tìm nthvị trí trong khối.

Ở đây, chúng ta có thể phân chia chuỗi như thế [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...], cho chúng ta kích thước khối 4i-2. Bắt đầu với i=2, chúng ta trừ itừ n, về cơ bản di chuyển lên một đoạn cùng một lúc. Khi chúng tôi đáp ứng n<=i, chúng tôi biết nbây giờ là vị trí của giá trị chính xác trong khối hiện tại.

Sau đó chúng tôi nhận được giá trị bằng cách so sánh nvới i, kích thước của khối. Điểm giữa của mỗi khối bằng i/2+1; Nếu nít hơn thế này, chúng tôi chỉ cần trở lại n. Nếun lớn hơn, chúng tôi trở lại i-n+2.

Thí dụ

n = 16, i = 2

Is n > i? Yes, n = n - 2 = 14, i = i + 4 = 6
Is n > i? Yes, n = n - 6 = 8, i = i + 4 = 10
Is n > i? No, stop looping.
10 / 2 + 1 = 6
Is n > 6? Yes, return i - n + 2 = 8 - 6 + 2 = 4

Trăn 2 , 5! byte (120 byte: P)

r=range
a=[]
for i in r(2,998,2): 
	for j in r(1,i+1): a.append(j)
	for j in r(i-1,1,-1): a.append(j)
print a[input()-1]

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

Đơn giản, tạo danh sách và sau đó lấy phần tử đầu vào

Python 3 , 184 156 byte

l,n,r=list,next,range
h=lambda x:l(r(1,x))+l(r(x-2,1,-1))
def g():
	x=3
	while True:yield from h(x);x+=2
def f(i):
	x=g()
	for _ in r(i-1):n(x)
	return n(x)

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

chơi với trình tạo Python để đánh giá "lười biếng"

QBIC , 47 byte

g=q{p=p+1~p=:|_Xg\g=g+q~g=1or g>=r|r=r+1┘q=q*-1

Giải trình

g=q         var g is the current value of the sequence; set to 1 at the start
{           DO infinitely
p=p+1       raise the step counter (var p)
~p=:|_Xg    IF p equals the input term a (read from cmd line) THEN QUIT, printing g
\           ELSE
g=g+q       raise (or decrement) g by q (q is 1 at the start of QBIC)
~g=1        IF g is at the lower bound of a subsequence
    or g>=r OR g is at the upper bound (r start as 2 in QBIC)
|r=r+1      THEN increment r (this happens once on lower bound, and once on upper, 
            total of 2 raise per subsequence)
┘q=q*-1     and switch q from 1 to -1

Röda , 54 byte

f n{seq 1,n|{|i|seq 1,2*i;seq 2*i-1,2}_|head n+2|tail}

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

Gọi với: try f(n)

Hàm này trả về nhanh câu trả lời, nhưng sau đó thực hiện một số tính toán không cần thiết và cuối cùng hết bộ nhớ.

Vì hàm trả về câu trả lời thực tế ngay sau khi được gọi (rõ ràng dưới một phút), tôi nghĩ rằng câu trả lời này là hợp lệ.

(Trong các hàm Röda có thể trả về các giá trị trước khi chúng thoát do song song.)

C # (.NET Core) , 99 95 86 byte

n=>{int i=1,t=2,d=0;for(;n>1;){i+=1-2*d;if(i==t){d++;t+=2;}if(i==1)d--;n--;}return i;}

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

Hàm Lambda nhận và trả về một số nguyên. Vòng lặp duy nhất xử lý đếm lên và xuống.

PHP, 65 + 1 byte

for($x=$d=$z=1;--$argn;)$d=($x+=$d)>1?$x>$z?-1:$d:!!$z+=2;echo$x;

Chạy như ống với -Rhoặc thử trực tuyến (hoặc bỏ qua một trong các phiên bản khác).

Một cổng của JavaScript đệ quy tshs mất 66 byte:

function f($n,$t=2){return$t<2*$n?$t<$n?f($n-$t,$t+4):$t-$n+2:$n;}

Một cổng của giải pháp Arnaulds mất 62 + 1:

$n=$argn;echo($n-=($r=(~-$n/2)**.5|0)*$r*2)<++$r*2?$n:$r*4-$n;

Một cổng được đánh gôn của Xanderhall (Java) có mã ngắn nhất cho đến nay (55 + 1 byte):

for($n=$argn;$n+2>$i+=4;)$n-=$i-2;echo$n*2>$i?$i-$n:$n;

Pyth ,  19  18 byte

-yhKs@/Q2 2a*yKhKt

Hãy thử nó ở đây!