세어 보자 ...

2까지 세고 1
까지 다시 4까지
세고 1 까지 다시 6까지
세고 1까지 ... ... 알았어 ...

이 모든 것을 합치면 다음과 같은 순서를 얻을 수 있습니다

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

Challenge 1- 인덱싱 (또는 0- 인덱싱)에
정수 n>0가 주어지면 n>=0이 시퀀스의 n 번째 항을 출력합니다

테스트 사례

Input->Output  

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

규칙

프로그램은 1 분 안에 최대 n = 10000의 솔루션을 계산할 수 있어야합니다.

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 이깁니다!

자바 스크립트 (ES7),  59 ... 44  43 바이트

Titus 덕분에 1 바이트 절약

예상 입력 : 1- 색인.

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

처음에는 비슷한 순서 인 A004738 의 공식에서 영감을 얻었습니다 . 그러나 나는 그것을 완전히 다시 작성했습니다.

테스트 사례

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

방법?

순서는 삼각형으로 배열 될 수 있으며 왼쪽 부분은 오름차순으로, 오른쪽 부분은 내림차순으로 정렬됩니다.

아래는 처음 32 개의 용어를 포함하는 처음 4 개의 행입니다.

            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

이제 몇 가지 변수를 소개하겠습니다 :

 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

맨 위에서 2 개의 요소로 시작하여 각각의 새 행에 4 개의 요소를 추가합니다. 따라서 0 인덱스 행 r 의 요소 수는 다음과 같이 표현할 수 있습니다.

a(r) = 4r + 2

행 r 의 1- 인덱싱 된 시작 위치 x 는 이 산술 시리즈의 모든 이전 항의 합에 1을 더한 값으로 주어집니다.

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

순서대로 1- 인덱싱 된 위치 n이 주어지면 해당 행을 다음과 같이 찾을 수 있습니다.

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

또는 JS 코드로 :

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

r (n) 을 알면 시작 위치 x (r) 에서 n 에서 1을 뺀 값을 뺍니다 .

n -= r * r * 2

n 을 a (r) / 2 + 1 = 2r + 2 와 비교 하여 오름차순 부분인지 내림차순 부분인지 알아냅니다.

n < ++r * 2 ?

이 표현식이 참이면 n 을 반환 합니다. 그렇지 않으면 4 (r + 1)-n을 반환 합니다. 그러나 마지막 명령문에서 r 이 이미 증가되었으므로 다음과 같이 단순화됩니다.

n : r * 4 - n

하스켈 , 37 바이트

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

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

인덱스가 0입니다. 목록을 생성하고 색인을 생성합니다. 2 바이트를 절약 한 Ørjan Johansen에게 감사합니다!

하스켈 , 38 바이트

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

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

인덱스가 0입니다. 목록을 생성하고 색인을 생성합니다.

하스켈 , 39 바이트

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

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

인덱스가 0입니다. 재귀 적 방법.

파이썬 , 46 바이트

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

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

인덱스가 0입니다.

껍질 , 8 바이트

!…ṁoe1DN

1- 색인. 온라인으로 사용해보십시오!

설명

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

펄 6 , 29 바이트

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

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

0 기반

넓히는:

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

내부 시퀀스 1...$+=2...2는

(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 기반으로 만들 0,려면 초 앞에 {추가하거나 -1뒤에 추가하십시오.$_

R, 64 바이트

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

인수를 취하는 함수 n. 그것은 벡터 생성 2:n이들 각각에 대해 2 씩 증가를, 벡터 1:(x-1)및이 x:2생성된다. 이 총계는보다 깁니다 n. 우리 unlist는 벡터를 얻고 n-th 엔트리를 취합니다 .

파이썬 2 , 56 바이트

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

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

이것은 0 인덱스입니다.

@JustinMariner 덕분에 -1 바이트

작동 원리

1 인덱싱 된 n그룹 ( 1, 2, ... 2n ..., 2, 1)은 0으로 번호가 매겨진 요소부터 2(n-1)^2~까지 2n^2입니다.

index에서 요소를 x찾으려면 그룹 번호 n를 찾을 수 있습니다 x. 그로부터 그룹 중심으로부터의 거리를 계산합니다 x. (이 거리는입니다 abs(2*n**2+2*n+2-x)).

그러나 요소 가 그룹 중심에서 멀어 질수록 그룹의 최대 값에서 거리를 뺍니다.

05AB1E , 8 바이트

암호:

ÅÈ€1Ÿ¦¹è

05AB1E 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

설명:

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

자바 스크립트, 39 바이트

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

젤리 , 10 , 9 바이트

ḤŒḄṖµ€Fị@

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

또한 1 인덱스, 꽤 빨리 마무리합니다.

@ErikTheOutgolfer 덕분에 1 바이트가 절약되었습니다!

설명:

가설 적으로 입력 ( a)이 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 바이트

li:"@EZv4L)]vG)

1 기반.

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

이것은 TIO에서 가장 큰 테스트 사례에 대한 시간 초과이지만 데스크탑 컴퓨터 (MATLAB R2017a에서 실행되는 컴파일러)에서 시간이 끝납니다. 경과 시간을 표시하려면 Z`코드 끝에 추가하십시오 .

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

설명

이 코드는 필요한 것보다 더 많은 용어를 생성합니다. 특히, n시퀀스의 "조각"을 계산 합니다. 여기서 각 조각은 카운트 업되어 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

껍질 , 12 10 바이트

!ṁ§¤+hḣṫİ0

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

1- 색인, 매우 빠르게 작동

설명

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

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

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

레티 나 , 62 바이트

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

온라인으로 사용해보십시오! 링크에는 테스트 사례가 포함됩니다. 입력은 1 인덱스입니다. 첫 번째 단계는 십진에서 단항으로의 변환입니다. 두 번째 단계는 가장 높은 제곱 수를 s절반 이하로 엄격하게 찾습니다 n. $1인 s²반면이 $2있다 2s-1. 이 두 값이며, 현재의 위 / 아래 실행에 번호의 첫 숫자를 계산 4(s+1) = 4s+4 = 2$2+6하고, 그 실행, 내 두 번째 위치 n-2s² = n-(2$1+1)+1 = n-$&+1단지를 필요로 1을 만회하기 위해 1엄격한 불평등을 적용하는 데 사용됩니다. 그런 다음 최종 단계는 해당 위치에서 런의 시작과 끝으로 계산되며 더 낮은 결과를 가져 와서 10 진수로 변환합니다.

수학, 67 바이트

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

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

Perl 5 , 43 + 1 (-p) = 44 바이트

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

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

나는 n 번째 요소를 직접 계산하는 공식을 연구하고있었습니다. 그런 다음 @ fireflame241이 해당 작업을 수행 한 것을보고 Perl로 골프를 쳤습니다.

# Perl 5 , 50 + 1 (-n) = 51 바이트

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

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

결과는 0으로 색인화됩니다.

하스켈 , 115 81 바이트

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

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

여기에 약간의 마술이 있습니다. 그래도 정상적인 접근 방식을 사용하면 더 짧을 수 있습니다.

설명

먼저을 정의 %합니다. %두 변수를 취하는 함수이다 x하고 y. 목록을 구성하고 해당 목록 scanl(+)y[y+1,y+3..]의 첫 번째 요소를보다 큽니다 x. scanl(+)반복적 인 합을 수행하여 삼각형 숫자 scanl(+)0[1..]를 얻고, 사각형 숫자를 얻습니다 scanl(+)0[1,3..]. 우리가 건설됩니다 특히 두 목록은 scanl(+)2[3,5..]하고 scanl(+)1[2,4..]이러한 패턴의 변곡점이다.

이제 우리는 주요 함수 g를 정의합니다 x. x하나 인 경우 1첫 번째 값이므로 반환 합니다. 그렇지 않으면 다음 두 변곡점을 확인하고, 아래쪽 변곡이 더 크면 1%x>2x후속 작업을 g$x-1반환하고 그렇지 않으면 의 후속 작업을 반환합니다 g$x-1.

그래, 왜 그게 효과가 있니?

우선 "정점을 찾는 방법은 무엇입니까?". 동일한 유형의 연속 정점 사이의 거리를 기록하는 것이 중요합니다. 매번 차이가 2 씩 증가하고 있음을 알 수 있습니다. 이것은 삼각형베이스가 매번 2 씩 넓어지기 때문에 의미가 있습니다. 리스트 리터럴을 사용하여리스트를 일정한 차이로 만들 수 있으며 , 첫번째 꼭지점의 위치와 첫번째 차이에 따라리스트를 정점리스트로 변환하는 데 [2,4..]사용 scanl(+)합니다.

이제 정점과 정점을 찾는 방법을 찾았으므로 해당 정보를 사용하여 값을 얻을 수 있습니다. 우리는 첫 번째 가치는 1그렇지 않으면 후계자 또는 전임자를 취해야 한다고 말합니다 . 다음 정점이 상향 정점 인 경우 선행 작업을 수행하고, 그렇지 않으면 후속 작업을 수행합니다.

하스켈 , 56 51 46 바이트

수학과 바이트 수가 적은 더 나은 솔루션이 있습니다.

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

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

파이크 , 14 바이트

SF}SDtO_+)sQt@

여기 사용해보십시오!

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 코어) , 120 바이트

설명 : 매우 간단합니다. 첫 번째 중첩 루프가 최대로 올라가고 두 번째 루프가 다시 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;}

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

루비 , 78 75 바이트

Step Hen 덕분에 1 바이트 절약

Mr. Xcoder 덕분에 1 바이트 절약

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

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

바라건대 바이트 수를 더 낮추는 몇 가지 팁을 얻을 수 있기를 바랍니다. 나는 간단한 접근을 시도했다.

자바 (OpenJDK 8) , 53 바이트

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

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

Nevay 덕분에 -2 바이트

1- 색인.

TL; DR 시퀀스를 편리한 청크로 분할하고 청크 n가있는 nth위치 를 찾은 다음 청크 에서 위치 를 찾습니다 .

여기서, 우리는 [[1,2],[1,2,3,4,3,2],[1,2,3,4,5,6,5,4,3,2],...]청크 크기를 제공하는 것처럼 시퀀스를 분할 할 수 있습니다 4i-2. 시작 i=2, 우리는 뺄셈 i에서 n기본적으로 한 번에 위쪽으로 덩어리를 이동. 일단 만족 하면 현재 청크에서 올바른 값의 위치 n<=i임을 알 수 n있습니다.

우리는 다음 비교하여 값을 얻을 n로 i청크의 크기. 각 청크의 중간 점은 같습니다 i/2+1. 경우 n덜 이것보다, 우리는 단순히 반환 n. 경우 n보다, 우리는 반환 i-n+2.

예

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

파이썬 2 , 5! 바이트 (120 바이트 : 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]

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

간단하고 목록을 만든 다음 입력 요소를 가져옵니다.

파이썬 3 , 184,156 바이트

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)

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

"게으른"평가를 위해 Python 생성기로 골프

QBIC , 47 바이트

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

설명

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

로다 , 54 바이트

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

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

전화 : try f(n)

이 함수는 신속하게 답변을 반환하지만 그 후에 불필요한 계산이 수행되어 결국 메모리가 부족합니다.

함수가 호출 된 직후 (분당 1 분 미만) 실제 답변을 반환 하므로이 답변이 유효하다고 생각합니다.

Röda 함수는 병렬 처리로 인해 종료되기 전에 값을 리턴 할 수 있습니다.

C # (. NET 코어) , 99 95 86 바이트

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

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

정수를 가져 와서 반환하는 Lambda 함수 카운트 다운을 처리하는 단일 루프.

PHP, 65 + 1 바이트

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

파이프로 실행 -R하거나 온라인으로 시도하십시오 (또는 다른 버전 중 하나의 주석 처리를 제거하십시오).

tsh의 재귀 JavaScript 포트 는 66 바이트를 사용합니다.

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

Arnauld의 솔루션 포트 는 62 + 1이 걸립니다 :

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

Xanderhall 자바 의 골프 포트는 지금까지 가장 짧은 코드를 가지고있다 (55 + 1 바이트) :

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

Pyth ,  19  18 바이트

-yhKs@/Q2 2a*yKhKt

여기 사용해보십시오!