Mari berhitung...

Hitung hingga 2 dan kembali ke 1
Hitung hingga 4 dan kembali ke 1
Hitung hingga 6 dan kembali ke 1
... ok Anda mendapatkannya ...

kumpulkan semuanya dan Anda akan mendapatkan urutan berikut

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

Tantangan
Diberikan bilangan bulat n>0untuk 1-diindeks (atau n>=0untuk 0-diindeks), output istilah ke-n dari urutan ini

Uji kasus

Input->Output  

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

Aturan

program Anda harus dapat menghitung solusi hingga n = 10.000 dalam waktu kurang dari satu menit

Ini adalah kode-golf , jadi kode terpendek dalam byte menang!

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

Disimpan 1 byte berkat Titus

Input yang diharapkan: 1-diindeks.

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

Awalnya terinspirasi oleh formula untuk A004738 , yang merupakan urutan yang sama. Tetapi akhirnya saya menulis ulang seluruhnya.

Uji kasus

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

Bagaimana?

Urutan dapat disusun sebagai segitiga, dengan bagian kiri dalam urutan menaik dan bagian kanan dalam urutan menurun.

Di bawah ini adalah 4 baris pertama, berisi 32 istilah pertama:

            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

Sekarang, mari kita perkenalkan beberapa variabel:

 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

Kami mulai dengan 2 elemen di bagian atas dan menambahkan 4 elemen di setiap baris baru. Oleh karena itu, jumlah elemen pada baris 0-diindeks r dapat dinyatakan sebagai:

a(r) = 4r + 2

Posisi awal 1-diindeks x dari baris r diberikan oleh jumlah dari semua istilah sebelumnya dalam seri aritmatika ini ditambah satu, yang mengarah ke:

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

Secara timbal balik, diberi posisi 1 diindeks n dalam urutan, baris yang sesuai dapat ditemukan dengan:

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

atau sebagai kode JS:

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

Setelah kita tahu r (n) , kita kurangi posisi awal x (r) dikurangi satu dari n :

n -= r * r * 2

Kita membandingkan n dengan (r) / 2 + 1 = 2r + 2 untuk mengetahui apakah kita berada di bagian naik atau di bagian menurun:

n < ++r * 2 ?

Jika ungkapan ini benar, kami mengembalikan n . Kalau tidak, kita mengembalikan 4 (r + 1) - n . Tetapi karena r sudah bertambah dalam pernyataan terakhir, ini disederhanakan sebagai:

n : r * 4 - n

Haskell , 37 byte

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

Cobalah online!

Diindeks nol. Buat daftar dan indeks ke dalamnya. Terima kasih kepada Ørjan Johansen karena telah menghemat 2 byte!

Haskell , 38 byte

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

Cobalah online!

Diindeks nol. Buat daftar dan indeks ke dalamnya.

Haskell , 39 byte

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

Cobalah online!

Diindeks nol. Metode rekursif.

Python , 46 byte

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

Cobalah online!

Nol diindeks.

Sekam , 8 byte

!…ṁoe1DN

1-diindeks. Cobalah online!

Penjelasan

!…ṁ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)}...*)[$_]}

Cobalah online

Berbasis 0

Diperluas:

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

Urutan dalam 1...$+=2...2menghasilkan

(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
...

Untuk menjadikannya berbasis 1, tambahkan 0,sebelum yang kedua {, atau tambahkan -1setelah$_

R, 64 byte

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

Fungsi yang mengambil argumen n. Ini menciptakan vektor 2:ndengan penambahan 2. Untuk masing-masing, vektor 1:(x-1)dan x:2dibuat. Total ini akan lebih lama dari n. Kita unlistitu, untuk mendapatkan vektor dan mengambil nentri -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

Cobalah online!

Ini diindeks 0.

-1 byte terima kasih kepada @JustinMariner

Bagaimana ini Bekerja?

Kami perhatikan bahwa ngrup ke -1 terindeks ( 1, 2, ... 2n ..., 2, 1) muncul dari elemen bernomor 0 2(n-1)^2hingga 2n^2.

Untuk menemukan elemen pada indeks x, kita dapat menemukan nomor grup nyang xada. Dari itu, kita menghitung jarak dari pusat grup itu x. (Jarak ini abs(2*n**2+2*n+2-x)).

Namun, karena elemen berkurang jauh dari pusat grup, kami mengurangi jarak dari nilai maksimum grup.

05AB1E , 8 byte

Kode:

ÅÈ€1Ÿ¦¹è

Menggunakan penyandian 05AB1E . Cobalah online!

Penjelasan:

ÅÈ           # 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

Jelly , 10 , 9 byte

ḤŒḄṖµ€Fị@

Cobalah online!

Juga 1 diindeks, dan selesai cukup cepat.

Satu byte disimpan berkat @ErikTheOutgolfer!

Penjelasan:

Secara hipotesis, katakanlah input ( a) adalah 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)

Berbasis 1.

Cobalah online!

Kali ini untuk kasus uji terbesar di TIO, tetapi selesai dalam waktu pada komputer desktop saya (kompiler berjalan pada MATLAB R2017a). Untuk menampilkan waktu yang telah berlalu, tambahkan Z`di akhir kode.

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

Penjelasan

Kode menghasilkan lebih banyak istilah daripada yang diperlukan. Secara khusus, itu menghitung n"potongan" dari urutan, di mana masing-masing bagian adalah hitungan ke atas dan kembali ke 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

Sekam , 12 10 byte

!ṁ§¤+hḣṫİ0

Cobalah online!

1-diindeks, bekerja cukup cepat

Penjelasan

!ṁ§¤+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

Mathematica, 90 byte

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

Cobalah online!

Retina , 62 byte

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

Cobalah online! Tautan termasuk kasus uji. Input diindeks 1. Tahap pertama hanya konversi desimal ke unary. Tahap kedua menemukan angka kuadrat tertinggi hanya skurang dari setengahnya n; $1adalah s², sementara $2ini 2s-1. Ini menghitung dua nilai, pertama jumlah angka dalam run up / down saat ini, yaitu 4(s+1) = 4s+4 = 2$2+6, dan kedua posisi dalam run itu, yaitu n-2s² = n-(2$1+1)+1 = n-$&+1, yang hanya membutuhkan 1make up untuk 1digunakan untuk menegakkan ketimpangan yang ketat. Tahap akhir kemudian dihitung dari posisi itu untuk awal dan akhir lari dan mengambil hasil yang lebih rendah dan mengubahnya menjadi desimal.

Mathematica, 67 byte

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

Cobalah online!

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

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

Cobalah online!

Saya sedang mengerjakan rumus untuk menghitung elemen ke-n secara langsung. Lalu saya melihat bahwa @ fireflame241 telah melakukan pekerjaan itu, dan saya memasukkannya ke Perl.

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

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

Cobalah online!

Hasil diindeks 0.

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

Cobalah online!

Ada beberapa keajaiban yang terjadi di sini. Mungkin bisa lebih pendek jika saya menggunakan pendekatan normal.

Penjelasan

Pertama kita mendefinisikan %. %adalah fungsi yang mengambil dua variabel x, dan y. Itu membangun daftar scanl(+)y[y+1,y+3..]dan menemukan elemen pertama dari daftar itu lebih besar dari x. scanl(+)hanya melakukan jumlah berulang, untuk mendapatkan angka segitiga yang akan kita lakukan scanl(+)0[1..], untuk mendapatkan angka kuadrat yang akan kita lakukan scanl(+)0[1,3..]. Dua daftar khususnya yang akan kita buat adalah scanl(+)2[3,5..]dan scanl(+)1[2,4..]ini adalah titik belok dari pola.

Sekarang kita mendefinisikan fungsi utama gyang mengambil x. Jika xkita kembali 1karena itulah nilai pertama. Kalau tidak, kita periksa dua titik belok berikutnya, jika belok turun lebih besar 1%x>2xkita kembalikan penerusnya g$x-1kalau tidak kita kembalikan pendahulunya g$x-1.

Ok tapi mengapa itu berhasil?

Pertama-tama "Whats dengan cara kita menemukan simpul?". Penting untuk mencatat jarak antara simpul berurutan dari jenis yang sama. Anda akan melihat bahwa perbedaannya bertambah 2 setiap kali. Ini masuk akal karena basis segitiga menjadi lebih lebar 2 setiap kali. Kita dapat membuat daftar perbedaan konstan menggunakan daftar literal seperti itu [2,4..]dan kita gunakan scanl(+)untuk mengubah daftar ini menjadi daftar simpul kami, berdasarkan lokasi simpul pertama dan perbedaan pertama.

Jadi sekarang kita memiliki cara untuk menemukan simpul ke atas dan ke bawah kita dapat menggunakan informasi itu untuk mendapatkan nilai. Kita mengatakan bahwa nilai pertama adalah 1kalau tidak kita harus mengambil penerus atau pendahulunya. Jika simpul berikutnya adalah yang ke atas kita ingin mengambil pendahulunya, kalau tidak kita mengambil penerus.

Haskell , 56 51 46 byte

Inilah solusi saya yang lebih baik dengan lebih sedikit matematika dan lebih sedikit byte.

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

Cobalah online!

Pyke , 14 byte

SF}SDtO_+)sQt@

Coba di sini!

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

C # (.NET Core) , 120 byte

Penjelasan: cukup sederhana, loop bersarang pertama naik ke maks kami, yang kedua naik kembali ke 2. Pengulangan untuk setiap kelipatan 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;}

Cobalah online!

Ruby , 78 75 byte

Disimpan 1 byte berkat Langkah Hen

Disimpan 1 byte berkat Tn. 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}

Cobalah online!

Semoga saya bisa mendapatkan beberapa tips untuk menarik bytecount lebih banyak. Saya mencoba mengambil pendekatan sederhana.

Java (OpenJDK 8) , 53 byte

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

Cobalah online!

-2 byte terima kasih kepada Nevay.

1-diindeks.

TL; DR Kami membagi urutan menjadi potongan-potongan yang mudah, menemukan potongan ndalam, kemudian menemukan nthposisi dalam potongan.

Di sini, kita dapat membagi urutan seperti [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...], yang memberi kita ukuran potongan 4i-2. Dimulai dengan i=2, kita kurangi idari n, pada dasarnya bergerak ke atas sepotong pada suatu waktu. Setelah kami puas n<=i, kami tahu nsekarang posisi nilai yang benar di chunk saat ini.

Kami kemudian mendapatkan nilai dengan membandingkan nuntuk i, ukuran chunk tersebut. Titik tengah setiap potongan sama dengan i/2+1; jika nkurang dari ini, kami cukup kembali n. Jika nlebih besar, kami kembali i-n+2.

Contoh

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

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

Cobalah online!

Langsung saja, buat daftar lalu ambil elemen input'th

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)

Cobalah online!

golf dengan generator Python untuk evaluasi "malas"

QBIC , 47 byte

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

Penjelasan

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}

Cobalah online!

Telepon dengan: try f(n)

Fungsi ini mengembalikan jawaban dengan cepat, tetapi setelah itu melakukan beberapa perhitungan yang tidak perlu dan akhirnya kehabisan memori.

Karena fungsi mengembalikan jawaban aktual sesaat setelah dipanggil (jelas di bawah satu menit), saya pikir jawaban ini valid.

(Dalam fungsi Röda dapat mengembalikan nilai sebelum keluar karena paralelisme.)

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

Cobalah online!

Fungsi Lambda yang mengambil dan mengembalikan integer. Satu loop yang menangani menghitung naik dan turun.

PHP, 65 +1 byte

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

Jalankan sebagai pipa dengan -Ratau coba online (atau batalkan komentar salah satu versi lain).

Port JavaScript rekursif tsh membutuhkan waktu 66 byte:

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

Port solusi Arnauld membutuhkan 62 + 1:

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

Port golf dari Xanderhall's Java memiliki kode terpendek sejauh ini (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

Coba di sini!