Definizione

La sequenza di Fibonacci a potenza alternata è formata come segue.

1. Inizia con la sequenza vuota e imposta n su 1 .

2. Calcolare f _n , il n ^° non negativo numero di Fibonacci , con ripetizioni.
   0 è il primo, 1 è il secondo e il terzo, 2 è il quarto. Tutti gli altri sono ottenuti sommando i due numeri precedenti nella sequenza, quindi 3 = 1 + 2 è il quinto, 5 = 2 + 3 è il sesto, ecc.

3. Se n è dispari, cambia il segno di f _n .

4. Aggiungi 2 copie ^n-1 di f _n alla sequenza.

5. Incrementa n e torna al passaggio 2.

Questi sono i primi cento termini della sequenza 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

Compito

Scrivere un programma completo o di una funzione che prende un numero intero positivo n come input e stampe o restituisce il n ^° termine della successione APF.

Se si preferisce l'indicizzazione basata su 0, è possibile in alternativa prendere un numero intero non negativo n e stampare o restituire il numero APF all'indice n .

Questo è code-golf ; che vinca il codice più breve in byte!

Casi di test (basati su 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

Casi di test (basato su 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 byte

BLCÆḞ

Provalo online!

Come?

Estensione della serie di Fibonacci in indici negativi in ​​modo tale che la relazione sia f(i) = f(i-2) + f(i-1)ancora valida:

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

A partire i=0dai numeri sono quelli che dobbiamo ripetere 2 ^n-1 volte e Jelly's Fibonacci integrato ÆḞcalcolerà questi.

Possiamo trovare -i(un numero positivo) di cui abbiamo bisogno prendendo la lunghezza in bit ne sottraendo 1.

Dal momento che vogliamo i(un numero negativo) possiamo invece eseguire 1-bitLengthe gelatina ha un atomo per 1-x, C, la monade 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 byte

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

Provalo online!

One-indicizzato.

La sequenza sembrava un enigma, qualcosa che Dennis ha generato avendo un modo breve per esprimerlo. Le potenze di due ripetizioni suggeriscono di ricorrere a bit-shifting (divisione del pavimento per 2). La ricorsione di Fibonacci a segno alternato f(n)=f(n-2)-f(n-1)può essere adattata allo spostamento dei bit al posto del decremento. Il case base funziona bene perché tutto viene incanalato n=0.

Mathematica, 43 36 24 byte

Fibonacci@-Floor@Log2@#&

7 byte salvati grazie a @GregMartin e altri 12 grazie a @JungHwanMin.

MATL , 19 17 16 11 byte

lOiB"yy-]x&

L'input è basato su 1.

Provalo online! O verifica tutti i casi di test .

Come funziona

Per l'ingresso basato su 1 n , sia m il numero di cifre nell'espansione binaria di n . Il n -esimo termine nella sequenza di output è m -esimo termine nella sequenza di Fibonacci, possibilmente con il suo segno modificato.

Un'idea sarebbe quella di ripetere ripetutamente m volte per calcolare i termini della sequenza di Fibonacci. Questo è facile con un for eachciclo usando l'array di cifre binarie. Se la sequenza di Fibonacci fosse inizializzata con 0 , quindi 1 come al solito, iterando m volte comporterebbe m + 2 termini nello stack, quindi i primi due numeri dovrebbero essere eliminati. Invece, inizializziamo con 1 , quindi 0 . In questo modo i termini generati successivi sono 1 , 1 , 2 , ... e solo uno è necessaria cancellazione.

Il segno può essere gestito usando un altro loop per cambiare segno m volte. Ma è costoso. È meglio integrare i due loop, che viene fatto semplicemente sottraendo invece di aggiungere l'iterazione di 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 byte

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

1-indicizzati.

Una porta della risposta di xnor sarebbe 23:

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

Python 2 , 83 82 79 byte

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)

Provalo online!

Gelatina , 9 byte

BLµ’ÆḞN⁸¡

Utilizza l'indicizzazione su una base.

Provalo online!

Spiegazione

Questo metodo funziona se la tua funzione Fibonacci supporta solo argomenti non negativi.

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)

Japt , 6 byte

Mg1-¢l

Provalo online!

Come funziona

Come già detto in altre risposte, il n ^° termine nel alternata segno serie di Fibonacci è la stessa della -n ^° termine della serie regolare. n può essere trovato prendendo la lunghezza in bit dell'input e sottraendone una; la negazione comporta 1 meno la lunghezza in 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 byte

Utilizza l'indicizzazione basata su 1

La funzione Fibonacci di 05AB1E restituisce numeri di fib positivi inferiori a n , il che significa che dovremmo generare più del necessario, ottenere quello corretto per indice e quindi calcolare il segno. Quindi dubito che qualsiasi metodo basato su quello sarà più breve del calcolo dei numeri in modo iterativo.

Utilizza la consapevolezza di poter inizializzare lo stack con 1, 0invertito per gestire il caso, n=1come descritto nella risposta MATL di Luis Mendo .

XÎbgG‚D«`-

Provalo online!

Spiegazione

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 byte

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

Implementazione semplice della sequenza, come è stata descritta.
Zero-based.

Julia 0,5 , 19 byte

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

Provalo online!

Come funziona

Questo utilizza la stessa formula della risposta Python di @ xnor . La relazione di ricorrenza
g (n) = g (n-2) + g (n-1) genera i termini negativi della sequenza di Fibonacci, che equivalgono ai termini positivi con segni alternati. Da qualsiasi punto di una sequenza di 2 ^k ripetizioni dello stesso numero, possiamo scegliere qualsiasi ripetizione della precedente corsa di 2 ^k-1 numeri e della corsa di 2 ^k-2 numeri prima di quelli dividendo l'indice per 2 e 4 .

Piuttosto che semplice

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

possiamo ridefinire un operatore per i nostri scopi. Inoltre, f funzionerà altrettanto bene con i float, quindi otteniamo

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

Infine, se aggiorniamo n con una divisione per 4 , possiamo scrivere n / 2 come 2n e omettere una coppia di parentesi, portando alla definizione della funzione a 19 byte in questa risposta.

J , 18 byte

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

Utilizza l'indicizzazione su una base. Prende un numero intero di input n > 0 e calcola floor(log2(n))trovando la lunghezza della sua rappresentazione binaria e quindi diminuisce quel valore di uno. Trova quindi il coefficiente floor(log2(n))-1^th della funzione generatrice x / (1 + x - x ² ) che è la gf per i valori di Fibonacci con indice negativo.

Provalo online!

Spiegazione

(%>:-*:)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