私はいくつかの数字で遊んでいて、もちろんOEISにあるシーケンスを見つけました。それはあるA005823：その三拡張なし1つのが含まれていない数字。それは行く：

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

最初のnを生成するCJamプログラムを作成しましたインデックスをバイナリに変換し、1を2に置き換え、3進数から10進数に変換することにより、これらの数値の。

また、シーケンス内の2つの数値（場合によってはそれ自体の数値）の合計を取ることで、偶数を取得できることにも気付きました。

チャレンジ：

入力として負でない偶数を指定すると、合計するシーケンス内の2つの数値のインデックスを出力します。（複数のペアが可能な場合があることに注意してください。）

ルール：

• 0または1のインデックスを使用するかどうかを指定します。
• 文字列として出力する場合は、2つのインデックスの間に区切り文字を入れます。
• 複素数として出力できます。
• 必要に応じて、すべての有効なペアを出力できます。
• コードゴルフ：最短回答が勝ちます

テストケース

0インデックスを使用します。ここでは、各入力に対して可能なすべての出力をリストしますが、出力する必要があるのは1つだけです。

0：       [0 0]
 2：       [1 0]
 4：       [1 1]
 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]

関連：Cantorセット内ですか？

殻、 21 14 13バイト

-7バイト、@ NeilのJS回答のおかげ

betaverosに触発された-1バイト Parradoc回答に

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

オンラインでお試しください！

長く、キャリーを扱っていたので

JavaScript（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で除算しても問題は変わりませんが、3進表現では0と1のみが使用されるため、考慮する必要がないため、ソリューションが簡単になります。また、要素からそのインデックスに変換するときのステップを節約します（各要素の3進数は、そのインデックスの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

Python 2、51バイト

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

オンラインでお試しください！

タスクは次のように実行できます。

1. 入力を半分にする
2. 三項リストに変換
3. それを要素単位で合計する2つのバイナリリストに分割します
4. それらのリストをバイナリから変換します

0->0,1->1,2->11つのリストともう1つのリストを変換することにより、（3）で分割できます0->0,1->0,2->1。つまり、値が0または1のしきい値を超えているかどうかを確認します。

2つの値は、それぞれの再帰関数で見つけることができます。

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は、リスト内包表記でこれら2つを組み合わせます。これにより、指数分岐により非効率になります。

複素数を出力できる場合、次のようにして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は、インデックスが合計されたシーケンス値のインデックスであるブール行列を生成します。これらのインデックスに1つある場合、2つの数値が合計されて入力値になることを意味します。

index_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

index_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

これがブール行列である場合、貧弱な読者を混乱させるのを助けるためにできるだけ多くの前置詞句を使用して、解かれた行列のインデックスをその行列の形状の底の数字として解釈することにより、1の座標を見つけることができることがわかります。

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

Pyth、37バイト

0インデックス付き

確かにゴルフはできませんでした。

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

オンラインでお試しください！

パイス、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回答にも驚くほど似ています。の3つすべてのオーバーロードを使用しなければならなかったのは面白いB。

スタック上の整数を取り、スタック上の2つの整数のリストを残します。

説明：

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

Pythonの3、122 120バイト

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

オンラインでお試しください！

Mathematica、94バイト

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

1インデックス付き

JavaScript、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インデックス。
1つのインデックスが可能な限り小さいインデックスのペアを返します（たとえば、を428返す場合22,31）。

ブレインフラック、220 166バイト

-54バイト、wikiのモジュロ関数を検索して、構造的な変更を可能にします

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

オンラインでお試しください！

0インデックス付き。

説明

他の多くのソリューションと同様に、これは次の3進展開を計算します n/2それを2つの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

JavaScript（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とほぼ同じソリューションです）

プロセスの逆を使用して、数値からインデックスを取得することから始め2ました。1、ベース2で解析します。

2つの数字を取得するために、1つでも1数字を入力するために、入力の半分だけを入力しますが、数字も発生する可能性があります。そのため、置換と解析のステップの前0に、1つの数字のaともう一方の数字のa に置き換えます2。これは、2つの合計を変更しません。ここに私が思いついたものがあります（2つの置換、1-> 0-or-2と2-> 1を1つのステップで行う）：

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

もちろん、2つの置換マップ（文字列）は1つのインデックスのみが異なるため、1と2を置換するだけで配列リテラルを短縮できるはずd == 2 ? 1 : xです。またはd-1 || x。どこ-1が2つの単項演算子と同じしかし、彼らはもっと怖いようです:-)

配列リテラルと括弧を回避しようとすると、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