소개 (무시 될 수 있음)

모든 양수를 규칙적인 순서 (1, 2, 3, ...)로 넣는 것은 약간 지루하지 않습니까? 그래서 여기 모든 양수의 순열 (순환)에 관한 일련의 도전이 있습니다. 이것이이 시리즈의 네 번째 과제입니다 ( 첫 번째 , 두 번째 및 세 번째 도전에 연결됨).

이 도전에서, 우리는 자연수의 순열 하나 가 아니라 순열의 전 세계 를 탐구 할 것입니다 !

2000 년, 클락 킴 벌링은 26에서 문제를 제기 ^일 의 문제 기틀 Mathematicorum , 캐나다 수학 협회에서 발행 수학 과학 저널. 문제는 :

$\text{Sequence }a = \begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{2} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{2} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = 3 a_{n-1}\text{ otherwise} \end{cases}$

이 순서에서 모든 양의 정수가 정확히 한 번 발생합니까?

2004 년 마테우스 Kwasnicki는 같은 저널에 긍정적 인 증거를 제공하고 2008 년에, 그는 출판 더 일반적인 증거 (원래의 질문에 비해)을 더 공식적이고. 그는 매개 변수 와 시퀀스를 공식화했습니다 .$p$$q$

$\begin{cases} a_1 = 1\\ a_n = \lfloor \frac{a_{n-1}}{q} \rfloor\text{ if }\lfloor \frac{a_{n-1}}{q} \rfloor \notin \{0, a_1, ... , a_{n-1}\}\\ a_n = p a_{n-1}\text{ otherwise} \end{cases}$

그는 대해 가 비이성적 인 임의의 시퀀스는 자연수의 순열 임을 증명했다 . 이것이 사실 인 무한한 및 값 이 있기 때문에 , 이것은 실제로 자연수의 순열의 전체 세계 입니다. 우리는 원래의 를 고수 하고 ,이 매개 변수들에 대해 , OEIS에서 시퀀스는 A050000 으로 찾을 수 있습니다 . 처음 20 개 요소는 다음과 같습니다.$p, q>1$$log_p(q)$$p$$q$$(p, q)=(3, 2)$

1, 3, 9, 4, 2, 6, 18, 54, 27, 13, 39, 19, 57, 28, 14, 7, 21, 10, 5, 15

이는 "순수한 시퀀스"문제이므로, 주어진 대한 a 을 입력 으로 출력 것이 좋습니다 . 여기서 은 A050000 입니다.$a(n)$$n$( N )$a(n)$

직무

정수 입력 주어지면 을 정수 형식으로 출력 .$n$$a(n)$

$\begin{cases} a(1) = 1\\ a(n) = \lfloor \frac{a(n-1)}{2} \rfloor\text{ if }\lfloor \frac{a(n-1)}{2} \rfloor \notin \{0, a_1, ... , a(n-1)\}\\ a(n) = 3 a(n-1)\text{ otherwise} \end{cases}$

참고 : 여기서는 1 기반 색인 작성이 가정됩니다. 0 기반 인덱싱을 사용할 수 있으므로 등이 있습니다. 이것을 사용하기로 선택한 경우 답에 언급하십시오.$a(0) = 1; a(1) = 3$

테스트 사례

Input | Output
---------------
1     |  1
5     |  2
20    |  15
50    |  165
78    |  207
123   |  94
1234  |  3537
3000  |  2245
9999  |  4065
29890 |  149853

규칙

• 입력 및 출력은 정수입니다 (프로그램은 1에서 32767까지의 입력 및 출력을 지원해야합니다)
• 유효하지 않은 입력 (0, 부동 수, 문자열, 음수 값 등)으로 인해 예기치 않은 출력, 오류 또는 (정의되지 않은) 동작이 발생할 수 있습니다.
• 기본 I / O 규칙이 적용됩니다.
• 기본 허점 은 금지되어 있습니다.
• 이것은 code-golf 이므로 바이트 단위의 최단 답변이 이깁니다.

Japt , 15 14 바이트

1- 색인.

@[X*3Xz]kZ Ì}g

시도 해봐

@[X*3Xz]kZ Ì}g     :Implicit input of integer U
             g     :Starting with the array [0,1] do the following U times, pushing the result to the array each time
@                  :  Pass the last element X in the array Z through the following function
 [                 :    Build an array containing
  X*3              :      X multiplied by 3
     Xz            :      X floor divided by 2
       ]           :    Close array
        kZ         :    Remove all elements contained in Z
           Ì       :    Get the last element
            }      :  End function
                   :Implicit output of the last element in the array

자바 스크립트 (ES6),  55 51  50 바이트

@EmbodimentofIgnorance 덕분에
1 바이트 절약 @tsh 덕분에 1 바이트 절약

n=>eval("for(o=[p=2];n--;)o[p=o[q=p>>1]?3*p:q]=p")

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

젤리 , 15 바이트

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ

nSTDIN에서 정수 (1부터 시작)를 허용하는 전체 프로그램으로 결과를 인쇄합니다.

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

어떻게?

µ×3żHḞḢḟȯ1Ṫ;µ¡Ḣ - Main Link: no arguments (implicit left argument = 0)
µ           µ¡  - repeat this monadic chain STDIN times (starting with x=0)
                -                   e.g. x = ...  0      [1,0]            [9,3,1,0]
 ×3             -   multiply by 3                 0      [3,0]            [27,9,3,0]
    H           -   halve                         0      [1.5,0]          [4.5,1.5,0.5,0]
   ż            -   zip together                  [0,0]  [[3,1.5],[0,0]]  [[27,4.5],[9,1.5],[3,0.5],[0,0]]
     Ḟ          -   floor                         [0,0]  [[3,1],[0,0]]    [[27,4],[9,1],[3,0],[0,0]]
      Ḣ         -   head                          0      [3,1]            [27,4]
       ḟ        -   filter discard if in x        []     [3]              [27,4]
        ȯ1      -   logical OR with 1             1      [3]              [27,4]
          Ṫ     -   tail                          1      3                4
           ;    -   concatenate with x            [1,0]  [3,1,0]          [4,9,3,1,0]
              Ḣ - head                            1      3                4
                - implicit print

05AB1E , 16 15 바이트

Kevin Cruijssen 덕분에 1 바이트를 절약했습니다 .
인덱스가 0입니다.

¾ˆ$FDˆx3*‚;ï¯Kн

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

설명

n=1예제로 사용

¾ˆ                 # initialize global array as [0]
  $                # initialize stack with 1, input
   F               # input times do:
    Dˆ             # duplicate current item (initially 1) and add one copy to global array
                   # STACK: 1, GLOBAL_ARRAY: [0, 1]
      x            # push Top_of_stack*2
                   # STACK: 1, 2, GLOBAL_ARRAY: [0, 1]
       3*          # multiply by 3
                   # STACK: 1, 6, GLOBAL_ARRAY: [0, 1]
         ‚;ï       # pair and integer divide both by 2
                   # STACK: [0, 3], GLOBAL_ARRAY: [0, 1]
            ¯K     # remove any numbers already in the global array
                   # STACK: [3], GLOBAL_ARRAY: [0, 1]
              н    # and take the head
                   # STACK: 3

펄 6 , 49 바이트

nwellnof 덕분에 -2 바이트

{(1,3,{(3*@_[*-1]Xdiv 6,1).max(*∉@_)}...*)[$_]}

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

순서대로 0 인덱스 요소를 돌려줍니다. 0,1대신 시작 요소를 변경하여 1- 색인으로 변경할 수 있습니다.1,3

설명:

{                                             }  # Anonymous code block
 (                                   ...*)[$_]   # Index into the infinite sequence
  1,3                                            # That starts with 1,3
     ,{                             }            # And each element is
       (                 ).max(    )             # The first of
          @_[*-1]X                               # The previous element
        3*        div 6                          # Halved and floored
        3*        div  ,1                        # Or tripled
                               *∉@_             # That hasn't appeared in the sequence yet

J , 47 40 바이트

[:{:0 1(],<.@-:@{:@](e.{[,3*{:@])])^:[~]

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

언 골프

[: {: 0 1 (] , <.@-:@{:@] (e. { [ , 3 * {:@]) ])^:[~ ]

정의를 J로 직접 변환 ^:합니다. 시작 값에서 필요한 횟수만큼 반복 하여 사용하여 상향식으로 작성됩니다 .

자바 10, 120 99 바이트

n->{var L=" 1 0 ";int r=1,t;for(;n-->0;L+=r+" ")if(L.contains(" "+(r=(t=r)/2)+" "))r=t*3;return r;}

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

설명:

n->{                              // Method with integer as both parameter and return-type
  var L=" 1 0 ";                  //  Create a String that acts as 'List', starting at [1,0]
  int r=1,                        //  Result-integer, starting at 1
      t;                          //  Temp-integer, uninitialized
  for(;n-->0;                     //  Loop the input amount of times:
      L+=r+" "))                  //    After every iteration: add the result to the 'List'
                          t=r     //   Create a copy of the result in `t`
                       r=(...)/2  //   Then integer-divide the result by 2
    if(L.contains(" "+(...)+" ")) //   If the 'List' contains this result//2:
      r=t*3;                      //    Set the result to `t` multiplied by 3 instead
  return r;}                      //  Return the result

하스켈 , 67 65 바이트

(h[1,0]!!)
h l@(a:o)|elem(div a 2)o=a:h(3*a:l)|1>0=a:h(div a 2:l)

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

0 기반 인덱싱을 사용합니다.

편집 : elem대신 notElem조건 을 사용 하고 조건을 전환 하여 2 바이트를 절약했습니다.

젤리 , 21 바이트

Ø.;0ị×3$:2$:2eɗ?Ɗ$⁸¡Ṫ

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

$n$$a(n)$

루비 , 54 52 48 바이트

->n{*s=0;j=2;n.times{s<<j=s==s-[j/2]?j/2:j*3};j}

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

C ++ (gcc) , 189180 바이트

작은 골프에 -9 바이트

#import<vector>
#import<algorithm>
int a(int n){std::vector<int>s={1};for(int i=0;i<n;++i)s.push_back(i&&std::find(s.begin(),s.end(),s[i]/2)==s.end()?s[i]/2:3*s[i]);return s[n-1];}

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

까지 시퀀스를 계산 한 n다음 원하는 요소를 반환합니다. 큰 지수의 경우 속도가 느립니다.

파이썬 2 , 66 바이트

l=lambda n,p=1,s=[0]:p*(n<len(s))or l(n,3*p*(p/2in s)or p/2,[p]+s)

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

0부터 시작하는 인덱싱을 사용합니다. 람다는 시퀀스를 재귀 적으로 구축하고 필요한 인덱스에 도달하자마자 돌아 오는 것 이상을 수행하지 않습니다.

Stax , 14 바이트

üÑα↕○Ü1∟¡f↑ô┬♥

실행 및 디버깅

인덱스가 0입니다.

Wolfram Language (Mathematica) , 63 바이트

(L=Last)@Nest[{##,If[FreeQ[#,x=⌊L@#/2⌋],x,3L@#]}&,{0,1},#]&

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

이것은 색인화되어 있습니다
(TIO에서는 모든 테스트 사례에서 -1을 추가했습니다)

파이썬 2 , 62 바이트

a=lambda n:n<1or a(n-1)*6**(a(n-1)//2in[0]+map(a,range(n)))//2

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

에 대해 반환 True합니다 a(0). 인덱스가 0입니다.

파이썬 (3) , 105 (103) 100 95 83 바이트

agtoever 덕분에 -2 바이트 ArBo 덕분에
-12 바이트

def f(n):
 s=0,1
 while len(s)<=n:t=s[-1]//2;s+=(t in s)*3*s[-1]or t,
 return s[-1]

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

가이아 , 22 20 바이트

2…@⟨:):3פḥ⌋,;D)+⟩ₓ)

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

0부터 시작하는 인덱스

접근에 대한 Shaggy의 신용

2…			| push [0 1]
  @⟨		 ⟩ₓ	| do the following n times:
    :):			| dup the list L, take the last element e, and dup that
       3פḥ⌋,		| push [3*e floor(e/2)]
	     ;D		| take the asymmetric set difference [3*e floor(e/2)] - L
	       )+	| take the last element of the difference and add it to the end of L (end of loop)
		   )	| finally, take the last element and output it

;D

하스켈 , 55 바이트

(1%[0]!!)
a%o|b<-div a 2=a:last(b:[3*a|elem b o])%(a:o)

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

골프 사용자 1472751의 매끄러운 목록 생성 방법 .

같은 길이 :

(1%[0]!!)
a%o=a:[x|x<-[div a 2,a*3],all(/=x)o]!!0%(a:o)

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

루아 , 78 바이트

x,y=1,3 u={}for _=2,...do
u[x]=0
x,y=y,y//2
if u[y]then y=3*x end
end
print(x)

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