Eu estava brincando com alguns números e encontrei uma sequência que, é claro, está no OEIS. É A005823 : Números cuja expansão ternária não contém 1's . Vai:

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

Escrevi um programa CJam que gera o primeiro n desses números convertendo o índice em binário, substituindo o 1 por 2 e convertendo de ternário para decimal.

Também notei que qualquer número par pode ser obtido pela soma de dois números na sequência (às vezes o número em si).

O desafio:

Dado qualquer número par não negativo como entrada, produza os índices de dois números na sequência que soma a ele. (Observe que às vezes vários pares são possíveis.)

As regras:

• Especifique se você está usando a indexação 0 ou 1.
• Se você estiver produzindo como uma sequência, coloque um delimitador entre os dois índices.
• Você tem permissão para emitir como um número complexo.
• Se desejar, você pode gerar todos os pares válidos.
• Code Golf: menor resposta ganha

Casos de teste

Eu uso a indexação 0. Aqui, listo todas as saídas possíveis para cada entrada, mas você só precisa produzir uma.

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]

Relacionado: Está dentro do conjunto Cantor?

Husk , 21 14 13 bytes

-7 bytes, graças à resposta JS de @ Neil

-1 byte inspirado na resposta Parradoc da betaveros

Usa indexação 0

mḋTmMo±>ḋ2B3½

Experimente online!

Explicação

            ½    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

Solução anterior de 21 bytes

Primeira vez que vi um uso para ».

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

Experimente online!

Mais tempo, como eu estava lidando com carrega

JavaScript (ES6), 75 71 bytes

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>

Explicação: Dividir a entrada e os elementos de A005823 por 2 não altera o problema, no entanto, torna a solução mais simples, pois as representações ternárias agora usam apenas 0s e 1s e, portanto, não há nada a considerar. Ele também salva uma etapa ao converter do elemento para seu índice (o ternário de cada elemento é duas vezes o binário de seu índice). Exemplos:

                 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

Gelatina , 26, 22 , 21 bytes

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

Experimente online!

Um byte economizado graças a @JonathanAllan!

Explicação:

                # 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 bytes

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

Experimente online!

A tarefa pode ser feita assim:

1. Metade da entrada
2. Converter em lista ternária
3. Divida isso em duas listas binárias que somam elemento a ele
4. Converta essas listas de binários

Podemos fazer a divisão em (3) convertendo 0->0,1->1,2->1para uma lista e 0->0,1->0,2->1para a outra. Ou seja, ao verificar se o valor está acima de um limite de 0 ou 1.

Os dois valores podem ser encontrados pelas respectivas funções recursivas:

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)

A função fcombina os dois em uma lista de compreensão. Isso o torna ineficiente devido à ramificação exponencial.

Se números complexos pudessem ser gerados, poderíamos economizar 10 bytes com:

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

J, ₃₅ 32 bytes

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

Experimente online!

Indexado a 0 e a entrada é fornecida monadicamente. Retorna todas as somas possíveis para o valor (ele trata a be b acomo diferentes somas possíveis).

A conversão de uma matriz booleana em índices requer muito código ...

Também gostaria de remover o garfo à esquerda, para não precisar usar tantos parênteses e @-ats, mas não consigo descobrir uma boa maneira de fazer isso (minha abordagem alternativa não salva bytes )

Explicação

Para propósitos de explicação e desatenção, considere os seguintes componentes da função principal

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

valid_nums produz uma matriz booleana em que os índices são os índices dos valores da sequência somada. Se houver um nesses índices, significa que os dois números somam o valor de entrada.

indices_of_ones é um idioma J para fornecer as coordenadas daquelas em uma matriz booleana de classificação arbitrária

A função principal é composta simplesmente como

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 funciona nesse caso, juntando cada linha à próxima.

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

Podemos ver que, se essa fosse uma matriz booleana, as coordenadas de uma podem ser encontradas interpretando os índices da matriz deslocada como números na base da forma dessa matriz, usando o maior número possível de frases posicionais para ajudar a confundir o pobre leitor. .

MATL , 22 21 19 17 bytes

tQ:qBEI_ZA&+=R&fh

A saída é baseada em 1. O programa produz todos os pares de soluções. Experimente online! Ou verifique todos os casos de teste .

Explicação

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

Pitão , 37 bytes

Indexado a 0

Certamente não jogava tão bem quanto poderia ser.

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

Experimente online!

Pitão , 29 bytes

Este retorna todos os pares possíveis de índices.

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

Experimente aqui.

Pitão , 30 bytes

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

Experimente aqui.

Isso retorna os pares de índices como [LowerIndex, HigherIndex] .

Como é que isso funciona?

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 bytes (CP-1252)

½3B2>_B™2Bv

Experimente online!

Algoritmicamente, é muito parecido com a resposta ES6 de Neil . Em um nível inferior, também notavelmente semelhante à resposta Husk de H.PWiz . Estou divertido por termos usado todas as três sobrecargas deB .

Pega um número inteiro na pilha, deixa uma lista de dois números inteiros na pilha.

Explicação:

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

-2 bytes graças ao Sr. Xcoder!

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

Ungolfed:

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]

Experimente online!

Mathematica, 94 bytes

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

Indexado 1

JavaScript, 120 101 bytes

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]

Experimente online!

Indexado a 0.
Ele retorna o par de índices em que um índice é o menor possível (por exemplo, no caso de 428retornar 22,31).

Flak cerebral , 220 166 bytes

-54 bytes consultando a função modulo no wiki, permitindo algumas mudanças estruturais

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

Experimente online!

Indexado a 0.

Explicação

Como muitas das outras soluções, isso calcula a expansão ternária n/2e a converte em dois números binários.

Etapa 1: Divida a entrada por 2

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

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

Etapa 2: calcular a expansão ternária

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

 ({}(<>))<>         {   (({})){({}[()])<>}{} }{}<> ([{}()]{})         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

Etapa 3: converter para solução

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

([]){{}                                                      ([][()])}           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 bytes

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

(Indexado com 0 e aparentemente quase a mesma solução que o @Neil, mesmo que eu não tivesse visto a resposta dele)

Comecei com o retorno do índice de um número usando o inverso do processo: stringify com base 3, substitua every 2por 1, analise com base 2.

Para obter dois números, e para cada um, temos apenas metade da entrada - mas agora também 1podem ocorrer dígitos. Portanto, substituí-lo por um 0no número e um 2no outro número, que não altera a soma dos dois, antes da etapa de substituição e análise. Aqui está o que eu criei (fazendo as duas substituições, 1-> 0 ou 2 e 2-> 1em uma etapa):

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

Obviamente, os dois mapas de substituição (strings) diferem apenas em um índice, portanto, devemos ser capazes de reduzir o literal da matriz apenas substituindo 1e 2por d == 2 ? 1 : x. Or d-1 || x. Onde -1faz o mesmo que os dois operadores unários - mas eles parecem mais assustadores :-)

Tentando evitar a matriz literal e os parênteses n/2, também inventei

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

mas não resultou frutífero.

Pitão, 22 bytes

J.m}1jb3hQxLJhfqsTQ^J2

Experimente online: Demonstração

Explicação:

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