Introdução

Obviamente, temos muitos desafios de sequência , então aqui está outro.

A sequência de Kimberling ( A007063 ) é a seguinte:

1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, ...

Isso é produzido baralhando a iteração normal:

[1] 2  3  4  5  6  7  8

O primeiro termo da sequência é 1. Depois disso, reorganizamos a sequência até que todos os termos à esquerda sejam usados. O embaralhamento tem o padrão right - left - right - left - .... Como não há termos à esquerda do 1, não há embaralhamento. Temos o seguinte:

 2 [3] 4  5  6  7  8  9

No i ^th iteração, descartar o i ^th item e colocar isso na nossa seqüência. Esta é a segunda iteração, então descartamos o segundo item. A sequência torna-se: 1, 3. Para a nossa próxima iteração, vamos embaralhar a iteração atual com o padrão acima. Tomamos o primeiro item não utilizado à direita do i- ^ésimo item. Isso acontece ser 4. Vamos anexar isso à nossa nova iteração:

 4

Agora, pegaremos o primeiro item não utilizado à esquerda do i- ^ésimo item. Isto é 2. Vamos anexar isso à nossa nova iteração:

 4  2

Como não há itens à esquerda do i- ^ésimo item, apenas anexaremos o restante da sequência à nova iteração:

 4  2 [5] 6  7  8  9  10  11  ...

Esta é a nossa terceira iteração, então vamos descartar o terceiro item, que é 5. Este é o terceiro item da nossa sequência:

 1, 3, 5

Para obter a próxima iteração, basta repetir o processo. Eu fiz um gif se não estiver claro:

^{O gif me levou mais tempo do que escrever a postagem real}

Tarefa

• Dado um número inteiro não negativo n , produza os primeiros n termos da sequência
• Você pode fornecer uma função ou um programa
• Isso é código-golfe , então a submissão com a menor quantidade de bytes ganha!

Casos de teste:

Input: 4
Output: 1, 3, 5, 4

Input: 8
Output: 1, 3, 5, 4, 10, 7, 15, 8

Input: 15
Output: 1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28

Nota: As vírgulas na saída não são necessárias. Você pode, por exemplo, usar novas linhas ou gerar uma lista, etc.

Pitão, 22 bytes

JS*3QVQ@JN=J.i>JhN_<JN

Experimente online: Demonstração

Simplesmente executa a técnica de embaralhamento descrita no OP.

Explicação:

JS*3QVQ@JN=J.i>JhN_<JN
JS*3Q                    assign the list [1, 2, ..., 3*input-1] to J
     VQ                  for N in range(Q):
       @JN                  print J[N]
            .i              interleave 
              >JhN             J[N+1:] with
                  _<JN         reverse J[:N]
          =J                assign the resulting list to J

Julia, 78 71 bytes

n->[(i=j=x;while j<2i-3 j=i-(j%2>0?1-j:j+2)÷2;i-=1end;i+j-1)for x=1:n]

Esta é uma função sem nome que aceita um número inteiro e retorna uma matriz inteira. Para chamá-lo, atribua-o a uma variável.

A abordagem aqui é a mesma descrita na OEIS.

Ungolfed:

# This computes the element of the sequence
function K(x)
    i = j = x
    while j < 2i - 3
        j = i - (j % 2 > 0 ? 1 - j : j + 2)÷2
        i -= 1
    end
    return i + j - 1
end

# This gives the first n terms of the sequence
n -> [K(i) for i = 1:n]

Economizou 7 bytes graças a Mauris!

Mathematica 130 bytes

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&

Começamos com uma lista que consiste no intervalo de 1até 3x, onde xé o número desejado de termos de sequência de Kimberling.

A cada passo, n, TakeDropquebra a lista atual em uma lista frente de 2n+1termos (onde o trabalho é feito) e lista traseira (que será mais tarde se juntou com o reformulado lista frontal). A lista da frente corresponde ao seguinte padrão, em {t___,z,r___}que z é o termo de Kimberling no centro da lista da frente. ré Rifflemarcado com o reverso de te, em seguida, a lista traseira é anexada. zé removido e anexado a ( AppendTo) a crescente sequência de Kimberling.

né incrementado 1e a lista atual é processada pela mesma função viaNest.

Exemplo

(n=0;s={};Nest[(n++;AppendTo[s,z=#[[n]]];Flatten[TakeDrop[#,1+2(n-1)]/.{t___,z,r___}:> 
Riffle[{r},Reverse@{t}]])&,Range[3*#],#];s)&[100]

{1, 3, 5, 4, 10, 7, 15, 8, 20, 9, 18, 24, 31, 14, 28, 22, 42, 35, 33, 46, 53, 6, 36, 23, 2 , 55, 62, 59, 76, 65, 54, 11, 34, 48, 70, 79, 99, 95, 44, 97, 58, 84, 25, 13, 122, 83, 26, 115, 82, 91 , 52, 138, 67, 90, 71, 119, 64, 37, 81, 39, 169, 88, 108, 141, 38, 16, 146, 41, 21, 175, 158, 165, 86, 191, 45 , 198, 216, 166, 124, 128, 204, 160, 12, 232, 126, 208, 114, 161, 156, 151, 249, 236, 263, 243, 101, 121, 72, 120, 47, 229 }

Python 2, 76 bytes

for a in range(input()):
 b=a+1
 while-~b<2*a:b=a-(b^b%-2)/2;a-=1
 print a+b

Explicação

Esta é a fórmula OEIS após muitas transformações de golfe! Funcionou lindamente . O código original era

i=b=a+1
while b<2*i-3:b=i-(b+2,1-b)[b%2]/2;i-=1
print i+b-1

Eu me livrei i, substituindo-o por a+1todos os lugares e expandindo as expressões:

b=a+1
while b<2*a-1:b=a+1-(b+2,1-b)[b%2]/2;a-=1
print a+b

Em seguida, reescreva b<2*a-1como -~b<2*asalvar um byte de espaço em branco e mova o +1para a seleção, a divisão por 2 e a negação:

while-~b<2*a:b=a-(b,-b-1)[b%2]/2;a-=1

Então, -b-1é justo ~b, para que possamos escrever (b,~b)[b%2]. Isso é equivalente a b^0 if b%2 else b^-1usar o operador XOR ou, alternativamente b^b%-2,.

while-~b<2*a:b=a-(b^b%-2)/2;a-=1

Pitão, 29 25 bytes

VQ+.W<hHyN-~tN/x%Z_2Z2hNN

Jakube salvou 4 bytes, mas não tenho mais idéia de como ler o código.

Aqui está a solução antiga:

VQKhNW<hKyN=K-~tN/x%K_2K2)+KN

Tradução da minha resposta em Python. Eu não sou muito bom em Pyth, então talvez ainda haja maneiras de reduzir isso.

VQ                              for N in range(input()):
  KhN                             K = N+1
     W<hKyN                       while 1+K < 2*N:
           =K-~tN/x%K_2K2)         K = (N--) - (K%-2 xor K) / 2
                          +KN     print K + N

APL, 56 44 bytes

{⍵<⍺+⍺-3:(⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵⋄⍺+⍵-1}⍨¨⍳

Este é um trem monádico sem nome que aceita um número inteiro à direita e retorna uma matriz. É mais ou menos a mesma abordagem que minha resposta de Julia .

A função mais interna é uma função recursiva dyadic que retorna o n th prazo na sequência Kimberling, dado n como argumentos certos idênticos e esquerdo.

{⍵<⍺+⍺-3:                                    ⍝ If ⍵ < 2⍺ - 3
         (⍺-1)∇⍺-4÷⍨3+(1+2×⍵)ׯ1*⍵           ⍝ Recurse, incrementing a and setting
                                             ⍝ ⍵ = ⍺ - (3 + (-1)^⍵ * (1 + 2⍵))/4
                                   ⋄⍺+⍵-1}   ⍝ Otherwise return ⍺ + ⍵ - 1

Com isso em mãos, podemos obter termos individuais da sequência. No entanto, o problema passa a ser que essa é uma função diádica , o que significa que exige argumentos de ambos os lados. Entre no ⍨operador! Dada uma função fe uma entrada x, f⍨xé o mesmo que x f x. Assim, no nosso caso, referindo-se à função mencionada como f, podemos construir o seguinte trem monádico:

f⍨¨⍳

Nós aplicamos f a cada número inteiro de 1 à entrada, produzindo uma matriz.

Economizou 12 bytes graças a Dennis!