Sayalım ...

2'ye kadar sayın ve 1'e geri dönün
4'e
kadar sayın ve 1'e geri dönün 6'ya kadar sayın ve 1'e geri dönün
... tamam anladım ...

hepsini bir araya getirin ve aşağıdaki sıralamayı elde edin

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

Mücadelesi 1 indeksli (veya 0 indeksli) için
bir tamsayı verildiğinde , bu dizinin nt terimini çıkar. n>0n>=0

Test durumları

Input->Output  

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

kurallar

Programınız bir dakika içinde n = 10000'e kadar olan çözümleri hesaplayabilmelidir.

Bu kod-golf , yani bayttaki en kısa kod kazanır!

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

Titus sayesinde 1 bayt kaydedildi

Beklenen giriş: 1 indeksli.

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

Başlangıçta , benzer bir dizi olan A004738 formülü ile ilham alınmıştır . Ama tamamen yeniden yazdım.

Test durumları

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

Nasıl?

Sıra, sol kısım artan sırada ve sağ kısım azalan sırada olacak şekilde üçgen şeklinde düzenlenebilir.

İlk 32 terimi içeren ilk 4 satır aşağıdadır:

            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

Şimdi bazı değişkenleri tanıtalım:

 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

Üstte 2 element ile başlıyoruz ve her yeni satıra 4 element ekliyoruz. Bu nedenle, 0 indeksli satırdaki r elemanların sayısı şöyle ifade edilebilir:

a(r) = 4r + 2

1 endeksli başlangıç konumu X sıranın r Bu aritmetik seri artı bir, potansiyel için bütün önceki terimlerin toplamı ile elde edilir:

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

Karşılıklı olarak, dizideki 1 indeksli bir pozisyon n verildiğinde , karşılık gelen satır ile bulunabilir:

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

veya JS kodu olarak:

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

R (n) 'yi öğrendikten sonra , başlangıç ​​pozisyonunu x (r) eksi n'den çıkarırız :

n -= r * r * 2

Bu karşılaştırma , n ile bir (r) / 2 + 1 = 2r + 2 biz artan kısmen veya inen kısmı olup olmadığını anlamaya:

n < ++r * 2 ?

Bu ifade doğruysa, n değerini döndürürüz . Aksi takdirde, 4 (r + 1) - n değerini döndürürüz . Ancak r , son ifadede zaten artırıldığından, bu basitleştirildi:

n : r * 4 - n

Haskell , 37 bayt

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

Çevrimiçi deneyin!

Sıfır endekslendi. Listeyi oluşturur ve içine indeksler. Ørjan Johansen'a 2 bayt kaydettiğin için teşekkürler!

Haskell , 38 bayt

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

Çevrimiçi deneyin!

Sıfır endekslendi. Listeyi oluşturur ve içine indeksler.

Haskell , 39 bayt

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

Çevrimiçi deneyin!

Sıfır endekslendi. Özyinelemeli bir yöntem.

Python , 46 bayt

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

Çevrimiçi deneyin!

Sıfır indekslendi.

Kabuğu , 8 bayt

!…ṁoe1DN

1 endeksli. Çevrimiçi deneyin!

açıklama

!…ṁ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 bayt

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

Çevrimiçi deneyin

0 tabanlı

Expanded:

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

İç dizi 1...$+=2...2üretir

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

1 tabanlı olmasını sağlamak için 0,, saniyeden önce {ekleyin veya -1sonra ekleyin.$_

R, 64 bayt

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

Bir argüman alan işlev n. 2'lik 2:nartışlarla bir vektör oluşturur. Bunların her biri için vektör 1:(x-1)ve x:2oluşturulur. Toplamda bundan daha uzun olacaktır n. Biz unlist, bir vektör elde etmek ve- ngiriş almak.

Python 2 , 56 bayt

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

Çevrimiçi deneyin!

Bu 0 indeksli.

@JustinMariner sayesinde -1 bayt

Bu nasıl çalışır?

Bu 1-endeksli dikkat nıncı grubun ( 1, 2, ... 2n ..., 2, 1elemanlar 0 endeksli sayılı gelen) oluşur 2(n-1)^2için 2n^2.

Endeksi de eleman bulmak için x, biz grup numarası bulabilirsiniz içindedir. O, biz grubun merkezine uzaklığı hesaplamak olduğunu. (Bu mesafe ).nxxabs(2*n**2+2*n+2-x)

Elemanları Ancak, azaltmak daha uzakta bir grubun merkezi biz grubun maksimum değerden mesafeyi çıkarınız.

05AB1E , 8 bayt

Kod:

ÅÈ€1Ÿ¦¹è

05AB1E kodlamasını kullanır . Çevrimiçi deneyin!

Açıklama:

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

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

Jöle , 10 , 9 bayt

ḤŒḄṖµ€Fị@

Çevrimiçi deneyin!

Ayrıca 1 endekslendi ve oldukça hızlı bir şekilde bitiyor.

@ErikTheOutgolfer sayesinde bir bayt kurtarıldı!

Açıklama:

Varsayımsal olarak, diyelim ki ( a) giriş 3'tür.

    µ€      # (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 bayt

li:"@EZv4L)]vG)

1 tabanlı.

Çevrimiçi deneyin!

Bu, TIO'daki en büyük test senaryoları için zaman aşımına uğradı, ancak masaüstü bilgisayarımda (MATLAB R2017a'da çalışan derleyici) zamanla sona erdi. Geçen süreyi görüntülemek Z`için kodun sonuna ekleyin .

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

açıklama

Kod gerekenden çok daha fazla terim üretir. Spesifik olarak, ndizinin "parçalarını" hesaplar , burada her bir parça sayılır ve 1'e geri döner.

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

Kabuğu , 12 10 bayt

!ṁ§¤+hḣṫİ0

Çevrimiçi deneyin!

1 indeksli, oldukça hızlı çalışıyor

açıklama

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

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

Çevrimiçi deneyin!

Retina , 62 bayt

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

Çevrimiçi deneyin! Link, test durumlarını içerir. Giriş 1 indeksli. İlk aşama, unary dönüşüm için sadece ondalıktır. İkinci aşama en yüksek kare sayısını skesinlikle yarısından daha az bulur n; $1olduğu s², süre $2ise 2s-1. İki değeri hesaplar, ilk önce mevcut yukarı / aşağı akışındaki sayıların sayısı 4(s+1) = 4s+4 = 2$2+6, ve ikinci olarak da bu eşitsizliği zorlamak için kullanılanın telafi edilmesini n-2s² = n-(2$1+1)+1 = n-$&+1gerektiren bu çalışma içindeki pozisyon . Son aşama, o konumdan koşunun hem başlangıcına hem de sonuna kadar sayılır ve daha düşük sonucu alır ve ondalık basamağa dönüştürür.11

Mathematica, 67 bayt

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

Çevrimiçi deneyin!

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

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

Çevrimiçi deneyin!

N'inci öğeyi doğrudan hesaplamak için bir formül üzerinde çalışıyordum. Sonra @ fireflame241'in bu işi yaptığını gördüm ve onu Perl'de golf oynadım.

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

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

Çevrimiçi deneyin!

Sonuçlar 0 dizinlenmiştir.

Haskell , 115 81 bayt

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

Çevrimiçi deneyin!

Burada biraz sihir var. Yine de normal bir yaklaşım kullanırsam muhtemelen daha kısa olabilirdi.

açıklama

İlk önce tanımlarız %. %iki değişkeni alan bir işlevdir xve y. Bir liste oluşturur scanl(+)y[y+1,y+3..]ve o listenin ilk öğesini ondan daha büyük bulur x. scanl(+)sadece yinelemeli toplamları yapar, yapacağımız üçgen sayıları elde etmek için, yapacağımız scanl(+)0[1..]kare sayılarını almak için scanl(+)0[1,3..]. Özellikle inşa edeceğimiz iki liste scanl(+)2[3,5..]ve scanl(+)1[2,4..]bunlar da desenin bükülme noktalarıdır.

Şimdi ana işlev tanımlamak gbir sürer x. Eğer xbiriyse geri döneriz 1çünkü bu ilk değer. Aksi takdirde, sonraki iki çekim noktasını kontrol ederiz, eğer aşağı çekim daha büyükse 1%x>2x, halefi döndürür, g$x-1aksi takdirde selefine döneriz.g$x-1 .

Tamam ama bu neden işe yarıyor?

Öncelikle "Köşeleri bulma şeklimiz nedir?". Aynı tipteki ardışık köşeler arasındaki mesafeyi not etmek önemlidir. Farklılıkların her seferinde 2 arttığını fark edeceksiniz. Bu mantıklı çünkü üçgenlerin tabanları her seferinde 2 kat daha genişliyor. Bu gibi bir listeyi kullanarak bir listeyi sabit bir fark yaratabiliriz [2,4..]ve scanl(+)bu listeleri ilk verteksin konumuna ve ilk farkına dayanarak verteks listelerimize dönüştürmek için kullanırız.

Şimdi yukarı ve aşağı doğru köşeleri bulma şeklimiz olduğundan, bu bilgileri değerleri elde etmek için kullanabiliriz. İlk değerin, 1halefi veya selefi almamız gerektiğini söylüyoruz . Bir sonraki tepe noktası yukarı doğru ise selefi almak istiyoruz, yoksa halefi alırız.

Haskell , 56 51 46 bayt

İşte benim daha az matematik ve daha az bayt ile daha iyi bir çözüm.

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

Çevrimiçi deneyin!

Pyke , 14 bayt

SF}SDtO_+)sQt@

Burada dene!

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 bayt

Açıklama: Oldukça basit, ilk iç içe döngü maksimize, ikincisi 2'ye geri tırmanıyor. Her iki için de tekrar.

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

Çevrimiçi deneyin!

Ruby , 78 75 bayt

Step Hen sayesinde 1 bayt kaydedildi

Bay Xcoder sayesinde 1 bayt kaydedildi

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

Çevrimiçi deneyin!

Umarım bayt sayısını daha aşağı çekmek için bazı ipuçları alabilirim. Basit bir yaklaşım almaya çalıştım.

Java (OpenJDK 8) , 53 bayt

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

Çevrimiçi deneyin!

Nevay sayesinde -2 bayt.

1 endeksli.

TL; DR Diziyi uygun parçalara ayırır, topağın içinde nolduğunu bulur, sonra nthda topaktaki konumu buluruz .

Burada, [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...]bize yığın boyutlarını veren dizisini bölebiliriz 4i-2. Başlangıçtan , her seferinde bir yığın kadar yukarı doğru hareket ederek i=2çıkarırız . Bir kez tatmin olduğumuzda , şu anki öbek içindeki doğru değerin pozisyonu olduğunu biliyoruz .inn<=in

Daha sonra karşılaştırarak değer elde netmek iyığın boyutu. Her bir yığının orta noktası i/2+1; eğer nbundan daha azsa, basitçe geri döneriz n. Eğer ndaha büyükse, geri döneriz i-n+2.

Örnek

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! bayt (120 bayt: 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]

Çevrimiçi deneyin!

Basit, listeyi yapar ve daha sonra input'th öğesini alır

Python 3 , 184 156 bayt

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)

Çevrimiçi deneyin!

"Tembel" değerlendirme için Python jeneratör ile golf oynadı

QBIC , 47 bayt

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

açıklama

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 bayt

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

Çevrimiçi deneyin!

İle ara: try f(n)

Bu işlev hızlı bir şekilde cevabı döndürür, ancak bundan sonra bazı gereksiz hesaplamalar yapar ve sonunda hafızası tükenir.

İşlev çağrıldıktan kısa bir süre sonra gerçek cevabı döndürdüğü için (açıkça bir dakikadan az), bu cevabın geçerli olduğunu düşünüyorum.

(Röda'da fonksiyonlar paralellik nedeniyle çıkmadan önce değerleri döndürebilir.)

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

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

Çevrimiçi deneyin!

Bir tamsayı alıp döndüren Lambda işlevi. Sayma ve aşağı sayma işleyen tek döngü.

PHP, 65 + 1 bayt

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

Pipe ile çalıştırın -Rveya çevrimiçi deneyin (ya da diğer sürümlerden birini yorumlayın).

Tsh´s özyinelemeli JavaScript bir liman 66 bayt alır:

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

Arnauld’un çözümünün limanı 62 + 1’dir:

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

Golf sahası Xanderhall's Java kısa kod şimdiye kadar (55 + 1 bayt) vardır:

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

Pyth ,  19  18 bayt

-yhKs@/Q2 2a*yKhKt

Burada dene!