나는 몇 가지 숫자로 놀고 있었고 물론 OEIS에있는 시퀀스를 발견했습니다. 그것은이다 A005823 : 누구의 삼항 확장에는 하나의가없는 숫자 . 간다 :

a (2n) = 3 * a (n) +2

a (2n + 1) = 3 * a (n + 1)

a (1) = 0

a = 0,2,6,8,18,20,24,26,54 ....

인덱스를 이진수로 변환하고 1을 2로 바꾸고 삼항에서 십진수로 변환 하여이 숫자 의 첫 번째 n 을 생성 하는 CJam 프로그램 을 작성했습니다 .

또한 시퀀스에서 두 숫자의 합을 취하여 짝수를 얻을 수 있음을 알았습니다.

도전 과제 :

음수가 아닌 짝수를 입력으로 받으면 두 숫자의 합을 순서대로 출력합니다. (때로는 여러 쌍이 가능합니다.)

규칙:

• 0 또는 1 인덱싱을 사용 중인지 지정하십시오.
• 문자열로 출력하는 경우 두 인덱스 사이에 구분 기호를 넣으십시오.
• 복소수로 출력 할 수 있습니다.
• 원하는 경우 유효한 모든 쌍을 출력 할 수 있습니다.
• 코드 골프 : 최단 답변 승리

테스트 사례

0 인덱싱을 사용합니다. 여기에는 각 입력에 대해 가능한 모든 출력이 나열되어 있지만 하나만 출력하면됩니다.

0 :       [0 0]
 2 :       [1 0]
 4 :       [11]
 6 :       [2 0]
 8 :       [2 1] [3 0]
 10 :      [3 1]
 12 :      [2 2]
 14 :      [3 2]
 16 :      [3 3]
 18 :      [4 0]
 30 :      [6 2]
 32 :      [6 3] [7 2]
 46 :      [7 5]
 50 :      [7 6]
 120 :     [10 10]
 338 :     [19 18]
 428 :     [30 23] [31 22]
 712 :     [33 27] [35 25] [41 19] [43 17] [49 11] [51 9] [57 3] [59 1]
 1016 :    [38 37] [39 36]

관련 : 캔터 세트 내에 있습니까?

껍질 , 21 14 13 바이트

@Neil의 JS 답변 덕분에 -7 바이트

betaveros의 Parradoc 답변 에서 영감을 얻은 -1 바이트

0 인덱싱 사용

mḋTmMo±>ḋ2B3½

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

설명

            ½    Half the input
          B3     Convert to Base 3
   m             Map over the list
    Mo±>ḋ2       Function such that: 0 -> [0,0], 1 -> [0,1], 2 -> [1,1]
        ḋ2       Binary 2, [1,0]
    M            For each in that list
     o±>         check if the argument is greater than it
  T              Transpose
mḋ               Convert each from binary

이전 21 바이트 솔루션

처음으로의 사용을 보았습니다 ».

mḋT»o%2+ȯ?´eḋε%3`-0B3

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

더 이상 내가 운반을 다룰 때

자바 스크립트 (ES6), 75 71 바이트

f=
n=>[1,0].map(i=>parseInt((n/2).toString(3).replace(/./g,c=>+c+i>>1),2))

<input type=number min=0 step=2 oninput=o.textContent=this.value%2?``:f(this.value)><pre id=o>

설명 : 입력과 A005823의 요소를 2로 나누더라도 문제가 변경되지는 않지만, 삼항 표현은 이제 0과 1 만 사용하므로 고려할 운반이 없으므로 솔루션이 더 단순 해집니다. 또한 요소에서 색인으로 변환 할 때 단계를 저장합니다 (각 요소의 삼항은 색인의 2 진입니다). 예 :

                 A005823
                  halved
            n in  values A005823
   n n/2  base 3  base 3 indices
   0   0       0   0   0   0   0  
   2   1       1   1   0   1   0
   4   2       2   1   1   1   1
   6   3      10  10   0   2   0
   8   4      11  11   0   3   0
  10   5      12  11   1   3   1
  12   6      20  10  10   2   2
  14   7      21  11  10   3   2
  16   8      22  11  11   3   3
  18   9     100 100   0   4   0
  30  15     120 110  10   6   2
  32  16     121 111  10   7   2
  46  23     212 111 101   7   5
  50  25     221 111 110   7   6

젤리 , 26, 22 , 21 바이트

ḶBḤḅ3
ÇŒcS=¥Ðf⁸ḢiЀÇT

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

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

설명:

                # Helper link: A005823 to *N* terms
Ḷ               # Lowered range(N)
 B              # Converted to binary
  Ḥ             # Double each digit
   ḅ3           # Converted from base 3 to decimal
                # Main link
Ç               # Last link
 Œc             # All combinations of 2 items (with replacement)
      Ðf        # Remove every combination where this isn't true:
   S=¥          #   The sum of the two items is equal to N
        ⁸Ḣ      # Take the first combination left
          i     # Index of
           Ѐ   # Each element of the combination
             Ç  # In the sequence
              T # Return the truthy indices

파이썬 2 , 51 바이트

f=lambda n:[n and(n/2%3>r)+2*f(n/3)[r]for r in 0,1]

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

작업은 다음과 같이 수행 할 수 있습니다.

1. 입력 절반
2. 삼항 목록으로 변환
3. 이것을 요소별로 합한 두 개의 이진 목록으로 나눕니다.
4. 이진에서 그 목록을 변환

0->0,1->1,2->1하나의 목록 으로 변환하여 (3)에서 나누기를 할 수 있습니다.0->0,1->0,2->1 다른 . 즉, 값을 확인하여 임계 값이 0 또는 1을 초과하는지 확인하십시오.

두 개의 값은 각각의 재귀 함수로 찾을 수 있습니다.

p=lambda n:n and(n/2%3>0)+2*p(n/3)
q=lambda n:n and(n/2%3>1)+2*q(n/3)

함수 f 은이 두 가지를 목록 이해에 결합합니다. 이것은 지수 분기로 인해 비효율적입니다.

복소수를 출력 할 수 있다면 다음과 같이 10 바이트를 절약 할 수 있습니다.

f=lambda n:n and(n%6>1)+n%6/4*1j+2*f(n/3)

J, ₃₅ 32 바이트

($#:I.@,)@(=[:+/~3#.+:@#:@i.@>:)

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

인덱스가 0이고 입력이 모노로 제공됩니다. 값 반환 가능한 모든 합계를 (이 취급 a b하고 b a다른 가능한 합산 등).

부울 행렬에서 인덱스로 변환하는 데는 많은 코드가 필요합니다 ...

왼쪽에있는 포크를 제거하고 싶습니다. 그래서 많은 괄호와 @-ats 를 사용할 필요는 없지만 좋은 방법을 찾을 수는 없습니다 (대체 방법으로 바이트를 저장하지 않습니다) ).

설명

설명 및 언 골핑을 위해 다음과 같은 주요 기능 구성 요소를 고려하십시오.

valid_nums      =. = [: +/~ 3 #. +:@#:@i.@>:
indices_of_ones =. $ #: I.@,

valid_nums 는 인덱스가 합산 된 시퀀스 값의 인덱스 인 부울 행렬을 생성합니다. 해당 지수에 하나가 있으면 두 숫자가 입력 값에 합산됨을 의미합니다.

indices_of_ones 는 임의의 순위 부울 행렬로 좌표를 제공하기위한 J 관용구입니다.

주요 기능은 다음과 같이 매우 간단하게 구성됩니다.

indices_of_ones@valid_nums

valid_nums

= [: +/~ 3 #. +:@#:@i.@>:  Input is n
                 #:@i.@>:  Binary numbers in range [0,n]
              +:           Doubled
         3 #.              Interpreted as ternary
     +/~                   Addition table with self (sum all possible pairs)
=                          Equate to n

indices_of_ones

$ #: I.@,
        ,  Ravel matrix into a single list
     I.    Find the indices of ones in that list
  #:       Convert to the base given by
$          The shape of the matrix

,이 경우 -ravel은 각 행을 다음 행에 결합하여 작동합니다.

   i.3 3
0 1 2
3 4 5
6 7 8
   , i.3 3
0 1 2 3 4 5 6 7 8

이것이 부울 행렬 인 경우, 열악한 독자의 혼란을 돕기 위해 가능한 한 많은 전치사구를 사용하여 행렬 형태의 밑줄에있는 숫자로 해석 된 행렬의 인덱스를 해석하여 좌표를 찾을 수 있습니다. .

MATL , 22 21 19 17 바이트

tQ:qBEI_ZA&+=R&fh

출력은 1 기반입니다. 프로그램은 모든 솔루션 쌍을 생성합니다. 온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

t      % Implicit input: n. Duplicate
Q:q    % Range [0 1 ... n]
B      % Convert to binary. Gives a matrix where each row corresponds to a number
E      % Multiply each entry by 2
I_ZA   % Convert each row from ternary to a number
&+     % Matrix of all pair-wise additions
=      % Does each entry equal n?
R      % Upper triangular matrix
&f     % Push row and column indices of nonzero entries
h      % Concatenate horizontally. Implicit didsplay

피스 , 37 바이트

0 인덱스

물론 골프도 아니었다.

KUQJmi:.Bd\1\23KhfqQ+@JeT@JhTsmm,dkKK

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

Pyth , 29 바이트

이것은 가능한 모든 인덱스 쌍을 반환합니다.

fqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2

여기에서 시도하십시오.

Pyth , 30 바이트

hfqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2

여기에서 시도하십시오.

인덱스 쌍을로 반환합니다 [LowerIndex, HigherIndex].

어떻게 작동합니까?

hfqQ+@Kmi:.Bd\1\23QhT@KeT.cUQ2   Full Program. Q means input throughout the whole explanation.

       m          Q               Map over the range [0, Q) with a variable d.
          .Bd                     Convert to binary.
         :   \1\2                 Replace 1 with 2.
        i        3                Convert it from base 3 to integer.
      K                           Assign the mapped range to a variable K.
                         .cUQ2    All possible two-element combinations of the range [0...Q).
    +@             hT@KeT         Sum of the integers on positions in K of the two-element
                                  combination.
 fqQ                              Filter those that equal the input.
h                                 Optional: Head. Take the first element.
                                  Print the result, implicitly. 

Paradoc (v0.2.10), 11 바이트 (CP-1252)

½3B2>_B™2Bv

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

알고리즘 적으로 Neil의 ES6 답변 과 매우 비슷 합니다. 낮은 수준에서 H.PWiz의 Husk answer 와 매우 유사합니다 . 나는 우리가 3 개의 오버로드를 모두 사용해야한다는 것을 기쁘게 생각 B합니다.

스택에서 정수를 가져 와서 스택에 두 정수 목록을 남깁니다.

설명:

½           .. Halve input
 3B         .. Convert to ternary
   2        .. 2, which will get implicitly coerced to [0,1]
    >_      .. Greater than, as a block
      B     .. "Bimap": take the block and map it over the Cartesian
            .. product of the last two lists to get a matrix
       ™    .. Transpose
        2Bv .. Convert each row from binary

파이썬 3 , 122120 바이트

Mr. Xcoder 덕분에 -2 바이트!

0 인덱스

def f(a):r=range(a);s=[int(bin(x)[2:].replace(*'12'),3)for x in r];return[(i,j)for i in r for j in r if s[i]+s[j]==a][0]

언 골프 드 :

def f(a):
    r=range(a)
    s=[int(bin(x)[2:].replace(*'12'),3)for x in r]
    return[(i,j)for i in r for j in r if s[i]+s[j]==a][0]

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

수학, 94 바이트

(w=#;Position[s,#]&/@#&@@(k=Select)[Tuples[s=k[Range@w,DigitCount[#,3,1]==0&],{2}],Tr@#==w&])& 

1- 색인

자바 스크립트, 120 101 바이트

n=>[(A=[...Array(n+1)].map(Z=(a,b=a)=>b&&3*Z(b/2|0)+b%2*2))[F='findIndex'](a=>z=~A[F](b=>a+b==n)),~z]

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

인덱스가 0입니다.
하나의 인덱스가 가능한 가장 작은 인덱스 쌍을 반환합니다 (예를 428들어을 반환 하는 경우 22,31).

뇌 플랙 , 220 166 바이트

위키에서 모듈러스 함수를 찾아서 -54 바이트

({()<({}[()()])>}{}){({}(<>))<>(()()())({()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>[()])}([]){{}<>(({}){})<>(({}){}{()<({}[()]){<>({}())<>(<{}>)}>}{})([][()])}({}{}<>)

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

인덱스가 0입니다.

설명

다른 많은 솔루션과 마찬가지로, 이것은 3 차 확장을 계산합니다. n/2 두 개의 이진수로 변환합니다.

1 단계 : 입력을 2로 나누기

({()<({}[()()])>}{})

 {              }     until number becomes zero:
     ({}[()()])       subtract two
( ()<          > {})  push number of iterations

2 단계 : 삼항 확장 계산

{({}(<>))<>(()()())({()<(({})){({}[()])<>}{}>}{}<><([{}()]{})>[()])}

 ({}(<>))<>         {   (({})){({}[()])<>}{} }{}<> ([{}()]{})         modulo (from wiki)
           (()()())                                                   use 3 as base
                     ()<                    >                         evaluate as 1 every time the 3 rolls over
                   (                              <          >[()])   push number of rollovers (function is now division with remainder)
{                                                                  }  repeat until quotient is zero, leaving all remainders on stack

3 단계 : 솔루션으로 변환

([]){{}<>(({}){})<>(({}){}{()<({}[()]){<>({}())<>(<{}>)}>}{})([][()])}({}{}<>)

([]){{}                                                      ([][()])}           repeat while stack height > 1:
                                                                                 (loop happens once when initial stack height is 1, but that's fine)
       <>(({}){})                                                                double smaller output number
                 <>(({}){}                                  )                    double larger output number
                          {                              }{}                     if digit in ternary expansion is nonzero:
                           ()<                          >                        add 1 to larger output number
                              ({}[()]){                }                         if digit is 2:
                                       <>({}())<>(<{}>)                          add 1 to smaller output number

자바 스크립트 (ES6), 70 72 바이트

n=>[6,4].map(x=>parseInt((n/2).toString(3).replace(/./g,d=>x>>d&1),2)) // thanks @Neil
n=>[0,1].map(x=>parseInt((n/2).toString(3).replace(/1|2/g,d=>~-d||x),2))

(0 색인화되어 있으며 대답을 보지 못했지만 @Neil과 거의 동일한 솔루션입니다)

프로세스의 반대를 사용하여 숫자에서 인덱스를 다시 가져 오는 것으로 시작했습니다. 기본을 stringify로 바꾸고 모든 것을 2으로 바꾸고 1base 2로 구문 분석하십시오.

두 개의 숫자를 얻으려면 하나의 숫자조차도 입력의 절반에 불과하지만 이제는 1숫자도 발생할 수 있습니다. 따라서 교체 및 구문 분석 단계 전에 0하나의 숫자와 2다른 숫자의 a 로 바꾸어 두 숫자의 합을 변경하지 않습니다. 다음은 내가 생각해 낸 것입니다 (두 단계의 교체 1-> 0 또는 2 및 2-> 1를 한 단계로 수행).

n=>["001","011"].map(x=>parseInt((n/2).toString(3).replace(/./g,d=>x[d]),2))

우리 만 교체하여 배열 리터럴을 단축 할 수 있어야하므로 당연히 두 개의 여분의 맵 (문자열)는, 하나 개의 인덱스에 차이 1와 2함께 d == 2 ? 1 : x. 또는 d-1 || x. -1두 개의 단항 연산자와 동일한 위치는 어디 입니까?

주위에 배열 문자와 괄호를 피하려고 n/2나는 또한 함께했다

n=>Array.from(parseInt,(h=n/2,i)=>parseInt(h.toString(3).replace(/1|2/g,d=>~-d||i),2))

그러나 유익한 결과를 얻지 못했습니다.

Pyth, 22 바이트

J.m}1jb3hQxLJhfqsTQ^J2

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

설명:

J.m}1jb3hQxLJhfqsTQ^J2
        hQ                input + 1 
 .m                       find all values of [0, 1, 2, ..., input], where
     jb3                     value converted to base 3
   }1                        check if it contains the digit 1
                          this boolean ^ is false
J                         store this list in variable J

                   ^J2    every pair of J
              f           filter for pairs with
                sT           sum of pair
               q             equal
                  Q          the input
             h            take the first of these pairs
          xLJ             and find the corresponding indices of J