Definição

A sequência de Fibonacci de potência alternada é formada como se segue.

1. Comece com a sequência vazia e defina n como 1 .

2. Calcular f _n , a n ^th não-negativo número de Fibonacci , com repetições.
   0 é o primeiro, 1 é o segundo e o terceiro, 2 é o quarto. Todos os outros são obtidos somando os dois números anteriores na sequência, então 3 = 1 + 2 é o quinto, 5 = 2 + 3 é o sexto, etc.

3. Se n for ímpar, altere o sinal de f _n .

4. Anexe 2 cópias ^n-1 de f _n à sequência.

5. Incremente n e volte para a etapa 2.

Estes são os primeiros cem termos da sequência APF.

 0  1  1 -1 -1 -1 -1  2  2  2  2  2  2  2  2 -3 -3 -3 -3 -3 -3 -3 -3 -3 -3
-3 -3 -3 -3 -3 -3  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5  5
 5  5  5  5  5  5  5  5  5  5  5  5  5 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8
-8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8 -8

Tarefa

Escrever um programa completo ou uma função que leva um número inteiro positivo n como entrada e devolve a gravuras ou n ^th termo da sequência do APF.

Se você preferir a indexação com base em 0, pode pegar um número inteiro não negativo n e imprimir ou retornar o número APF no índice n .

Isso é código-golfe ; pode ganhar o código mais curto em bytes!

Casos de teste (com base em 1)

    1 ->    0
    2 ->    1
    3 ->    1
    4 ->   -1
    7 ->   -1
    8 ->    2
  100 ->   -8
  250 ->   13
  500 ->  -21
 1000 ->   34
11111 ->  233
22222 -> -377
33333 ->  610

Casos de teste (com base em 0)

    0 ->    0
    1 ->    1
    2 ->    1
    3 ->   -1
    6 ->   -1
    7 ->    2
   99 ->   -8
  249 ->   13
  499 ->  -21
  999 ->   34
11110 ->  233
22221 -> -377
33332 ->  610

Gelatina , 5 bytes

BLCÆḞ

Experimente online!

Quão?

Estendendo a série Fibonacci de volta a índices negativos, de modo que a relação f(i) = f(i-2) + f(i-1)ainda se mantenha:

  i   ...   -8  -7  -6  -5  -4  -3  -2  -1   0   1   2   3   4   4   5 ...
f(i)  ...  -21  13  -8   5  -3   2  -1   1   0   1   1   2   3   5   8 ...

Voltando i=0a esses números, precisamos repetir 2 ^n-1 vezes, e o Fibonacci de Jelly embutido ÆḞcalculará isso.

Podemos encontrar o -i(um número positivo) de que precisamos tomando o comprimento de bits ne subtraindo 1.

Desde que nós queremos i(um número negativo), podemos, em vez realizar 1-bitLengthe Jelly tem um átomo para 1-x, C, a Mônada complemento.

BLCÆḞ - Main link: n               e.g.  500
B     - convert n to a binary list      [1,1,1,1,1,0,1,0,0]
 L    - get the length                   9
  C   - complement                      -8
   ÆḞ - Fibonacci                       -21

Python 2 , 30 bytes

f=lambda n:n<1or f(n/4)-f(n/2)

Experimente online!

Um indexado.

A sequência parecia um quebra-cabeça, algo que Dennis gerou por ter uma maneira curta de expressá-la. A potência de duas repetições sugere a repetição por deslocamento de bits (divisão do piso por 2). A recursão de Fibonacci de sinal alternado f(n)=f(n-2)-f(n-1)pode ser adaptada ao deslocamento de bits no lugar de decrementar. O caso base funciona muito bem porque tudo se afunila n=0.

Mathematica, 43 36 24 bytes

Fibonacci@-Floor@Log2@#&

7 bytes salvos graças a @GregMartin e mais 12 graças a @JungHwanMin.

MATL , 19 17 16 11 bytes

lOiB"yy-]x&

A entrada é baseada em 1.

Experimente online! Ou verifique todos os casos de teste .

Como funciona

Para a entrada 1 com base n , seja m o número de dígitos na expansão binária de n . O n- ésimo termo na sequência de saída é o m- ésimo termo na sequência de Fibonacci, possivelmente com seu sinal alterado.

Uma idéia seria iterar m vezes para calcular os termos da sequência de Fibonacci. Isso é fácil com um for eachloop usando a matriz de dígitos binários. Se a sequência de Fibonacci fosse inicializada com 0 e , em seguida, 1 como de costume, a repetição de m resultaria em termos de m + 2 na pilha; portanto, os dois primeiros números teriam que ser excluídos. Em vez disso, inicializamos com 1 e depois com 0 . Dessa forma, os próximos termos gerados são 1 , 1 , 2 , ... e apenas uma exclusão é necessária.

O sinal pode ser tratado usando outro loop para alterar o sinal m vezes. Mas isso é caro. É melhor integrar os dois loops, o que é feito simplesmente subtraindo em vez de adicionar na iteração Fibonacci.

l       % Push 1
O       % Push 0
iB      % Input converted to binary array
"       % For each
  yy    %   Duplicate top two elements
  -     %   Subtract. This computes the new Fibonacci term with the sign changes
]       % End
x       % Delete top number
&       % Specify that implicit display should take only one input
        % Implicitly display the top of the stack

JavaScript (ES6), 33 bytes

f=(n,p=1,c=0)=>n?-f(n>>1,c,p+c):p

1 indexado.

Uma porta da resposta do xnor seria 23:

f=n=>n<1||f(n/4)-f(n/2)

Python 2 , 83 82 79 bytes

def f(n,a=0,b=1):
 l=bin(n)[2:]
 for _ in l:a,b=b,a+b
 return a*-(len(l)%2or-1)

Experimente online!

Geléia , 9 bytes

BLµ’ÆḞN⁸¡

Usa indexação baseada em um.

Experimente online!

Explicação

Este método funciona se a função Fibonacci oferecer suporte apenas a argumentos não negativos.

BLµ’ÆḞN⁸¡  Input: integer n
B          Binary digits of n
 L         Length. len(bin(2)) = floor(log2(n)))
  µ        Start new monadic chain on x = len(bin(2))
   ’       Decrement
    ÆḞ     Get Fibonacci(x-1)
       ⁸¡  Repeat x times on that
      N      Negate.
           Return Fibonacci(x-1) if x is even else -Fibonacci(x-1)

Japonês , 6 bytes

Mg1-¢l

Teste online!

Como funciona

Como mencionado em outras respostas, o n ^º termo na série de Fibonacci alternando-sinal é o mesmo que o -n ^th termo na série regular. n pode ser encontrado pegando o comprimento do bit da entrada e subtraindo um; negar isso resulta em 1 menos o comprimento do bit.

Mg1-¢l
    ¢l  // Calculate the length of the input in binary.
  1-    // Subtract this from 1.
Mg      // Get the Fibonacci number at this index.

05AB1E , 11 10 bytes

Usa indexação baseada em 1

A função Fibonacci de 05AB1E retorna números de fib positivos menores que n , o que significa que teríamos que gerar mais do que o necessário, obter o correto pelo índice e calcular o sinal. Portanto, duvido que qualquer método baseado em que seja mais curto do que calcular os números iterativamente.

Usa a percepção de que podemos inicializar a pilha com 1, 0reverso para lidar com o caso, n=1conforme descrito na resposta MATL de Luis Mendo .

XÎbgG‚D«`-

Experimente online!

Explicação

X             # push 1
 Î            # push 0 and input
  b           # convert input to binary
   g          # get length of binary number
    G         # for N in [1...len(bin(input))-1] do:
     ‚        # pair the top 2 elements of the stack in a list
      D       # duplicate the list 
       «      # concatenate the 2 lists together
        `     # split into separate elements on the stack
         -    # subtract the top 2 elements

Perl 6 , 53 bytes

{flat(((0,1,*+*...*)Z*|<-1 1>xx*)Zxx(1,2,4...*))[$_]}

Implementação direta da sequência, da maneira como foi descrita.
Baseado em zero.

Julia 0,5 , 19 bytes

!n=n<1||!(n/=4)-!2n

Experimente online!

Como funciona

Isso usa a mesma fórmula da resposta Python do @ xnor . A relação de recorrência
g (n) = g (n-2) + g (n-1) gera os termos negativos da sequência de Fibonacci, que igualam os termos positivos com sinais alternados. De qualquer lugar em uma execução de 2 ^k repetições do mesmo número, podemos escolher qualquer repetição da execução anterior de 2 ^k-1 números e da execução de 2 ^k-2 números anteriores àqueles dividindo o índice por 2 e 4 .

Ao invés do simples

f(n)=n<1||f(n÷4)-f(n÷2) # 25 bytes

podemos redefinir um operador para nossos propósitos. Além disso, f funcionará tão bem com flutuadores, então obtemos

!n=n<1||!(n/4)-!(n/2)   # 21 bytes

Finalmente, se atualizarmos n com uma divisão por 4 , o wwe poderá escrever n / 2 como 2n e omitir um par de parênteses, levando à definição da função de 19 bytes nesta resposta.

J , 18 bytes

(%>:-*:)t.@<:@#@#:

Usa indexação baseada em um. Pega um número inteiro de entrada n > 0 e calcula floor(log2(n))encontrando o comprimento de sua representação binária e, em seguida, diminui esse valor em um. Em seguida, ele encontra o coeficiente floor(log2(n))-1^th da função geradora x / (1 + x - x ² ), que é o gf para os valores de Fibonacci indexados negativamente.

Experimente online!

Explicação

(%>:-*:)t.@<:@#@#:  Input: integer n
                #:  Binary
              #@    Length
           <:@      Decrement
(      )            The generating function x/(1+x-x^2)
  >:                  Increment x
     *:               Square x
    -                 Subtract
 %                    Divide x by previous
        t.          Get series coefficient at the index given by previous value