Esponenti di Fibonacci


11

Per questa sfida, devi produrre il risultato della somma di alcuni numeri. Quali sono questi numeri? Bene, ti viene dato input, ( a, b), che sono numeri interi (positivi, negativi o zero) a != b, e a < b, e ogni numero intero all'interno ae b(inclusi quelli) avrà esponenti in base ai numeri di Fibonacci. Questo è confuso, quindi ecco un esempio:

Input: (-2, 2)
Output: -2**1 + (-1**1) + 0**2 + 1**3 + 2**5 =
          -2  +    -1   +   0  +   1  +   32 = 30

Dato che il primo numero di Fibonacci è rappresentato da f(0), la formula è:

a**f(0) + ... + b**f(b-a+1) 

Input, elaborazione, output

Per chiarire quanto sopra, ecco alcuni casi di test, l'elaborazione dell'input e gli output previsti:

Input: (1, 2)
Processing: 1**1 + 2**1
Output: 3

Input: (4, 8)
Processing: 4**1 + 5**1 + 6**2 + 7**3 + 8**5
Output: 33156

Input: (-1, 2)
Processing: -1**1 + 0**1 + 1**2 + 2**3
Output: 8

Input: (-4, -1)
Processing: -4**1 + -3**1 + -2**2 + -1**3
Output: -4

Regole

  • Non sono ammesse scappatoie standard

  • Gli esponenti devono essere in ordine secondo la serie Fibonacci

  • Il codice deve funzionare per i casi di test sopra indicati

  • È necessario restituire solo l'output

Criteri vincenti

Il codice più corto vince!


Quindi 0non è incluso nei numeri di fibonacci qui?
FlipTack

0 non è un numero di Fibonacci ma è una scelta valida per l'input
Anthony Pham,

6
33165 o 33156?
Neil,

@Neil Penso che tu abbia ragione
Anthony Pham il

Questo sopra "a f (0) + ... + b f (b-a + 1)" è sbagliato, ad esempio per a = 1 eb = 2 sarebbe 1 f (0) +2 f (2 ). Penso che sarebbe a f (0) + ... + b f (ba); qui f (0) = 0 non 1
RosLuP

Risposte:


2

05AB1E , 9 byte

ŸDg!ÅFsmO

Provalo online!

Ÿ         # Push [a, ..., b].
 Dg!      # Calculate ([a..b].length())! because factorial grows faster than fibbonacci...
    ÅF    # Get Fibonacci numbers up to FACTORIAL([a..b].length()).
      s   # Swap the arguments because the fibb numbers will be longer.
       m  # Vectorized exponentiation, dropping extra numbers of Fibonacci sequence.
        O # Sum.

Non funziona su TIO per grandi discrepanze tra ae b(EG [a..b].length() > 25).

Ma sembra funzionare per numeri più grandi rispetto alla risposta media qui.

Inefficiente, perché calcola la sequenza di fibonacci fino a n!, che è più del necessario per calcolare la risposta, dov'è nla lunghezza della sequenza di a..b.


5

Mathematica, 38 byte 37 byte 31 byte

Sum[x^Fibonacci[x-#+1],{x,##}]&

Questa è solo la risposta di rahnema1 portata su Mathematica. Di seguito è la mia soluzione originale:

Tr[Range@##^Fibonacci@Range[#2-#+1]]&

Spiegazione:

##rappresenta la sequenza di tutti gli argomenti, #rappresenta il primo argomento, #2rappresenta il secondo argomento. Quando viene chiamato con due argomenti ae b, Range[##]fornirà l'elenco {a, a+1, ..., b}e Range[#2-#+1]fornirà l'elenco della stessa lunghezza {1, 2, ..., b-a+1}. Dal momento che Fibonacciè Listable, Fibonacci@Range[#2-#+1]darà la lista dei primi b-a+1numeri di Fibonacci. Poiché Powerè Listable, chiamando su due elenchi di uguale lunghezza sarà infilarla sugli elenchi. Quindi Trprende la somma.

Modifica: salvato 1 byte grazie a Martin Ender.


3
È possibile utilizzare Range@##.
Martin Ender,

1
Non è così rilevante ora, ma l'approccio originale può essere migliorato di 3 byte a Tr[(r=Range@##)^Fibonacci[r-#+1]]&.
Greg Martin,

Usando Rangedue volte avrebbe dovuto essere una bandiera rossa. Grazie!
ngenesi,

5

Python , 49 byte

Una lambda ricorsiva che accetta ae bcome argomenti separati (puoi anche impostare i primi due numeri di fibonacci xe y, per quello che vuoi - non intenzionale, ma una bella caratteristica):

f=lambda a,b,x=1,y=1:a<=b and a**x+f(a+1,b,y,x+y)

Provalo online! (include la suite di test)

Suggerimenti di golf benvenuti.


Perché -~ae non semplicemente a+1? Penso che -~adipende dalla macchina.
Tito

4

Perl 6 , 32 30 byte

{sum $^a..$^b Z**(1,&[+]...*)}

$^ae $^bsono i due argomenti della funzione; $^a..$^bè l'intervallo di numeri da $^aa $^b, che è compresso con exponentiation dalla Z**con la sequenza di Fibonacci, 1, &[+] ... *.

Grazie a Brad Gilbert per essersi rasato due byte.


(1,&[+]...*)è più corto di un byte e lo spazio dopo Z**non è necessario.
Brad Gilbert b2gills

@ BradGilbertb2gills Cool, non avevo idea che la sequenza di Fibonacci potesse essere espressa in quel modo.
Sean

In realtà funziona perché &infix:<+>può accettare 0,1 o 2 argomenti. ( &[+]è un modo breve di scrivere &infix:<+>). Il qualunque codice * + *accetta esattamente 2 argomenti. ( &[0]() == 0quindi devi avere 1lì per iniziare la sequenza)
Brad Gilbert b2gills


3

Pyke, 11 byte

h1:Foh.b^)s

Provalo qui!

h1:         -   range(low, high+1)
   F     )  -  for i in ^:
    oh      -     (o++)+1
      .b    -    nth_fib(^)
        ^   -   i ** ^
          s - sum(^)

3

JavaScript (ES7), 42 byte

f=(a,b,x=1,y=1)=>a<=b&&a**x+f(a+1,b,y,x+y)

Porta diretta dell'eccellente risposta Python di @ FlipTack.


Bello, si è rivelato ancora più breve in JavaScript! :)
FlipTack il

3

Haskell, 35 byte

f=scanl(+)1(0:f);(?)=sum.zipWith(^)

Uso:

$ ghc fibexps.hs -e '[4..8]?f'
33156

Puoi trasformare la funzione oin un operatore infix, come a#b=sum....
nimi,

Avevo considerato l'infisso come un ... b, ma avevo letto l'obbligo di accettare unario (ℤ, ℤ) → ℕ
Roman Czyborra,

Molte altre risposte prendono due argomenti separati, quindi penso che vada bene.
nimi,

Già Alrightie, questo ci porta alla pari con l'ECMAscript7 lambda. Ma se c'è permesso di mangime (a,b)come a?ballora perché non siamo autorizzati a prepararlo come immediato [a..b]?fsu (?)=sum.zipWith(^)?
Roman Czyborra,

Penso che questo vada troppo lontano. Gli input sono due numeri (non necessariamente come coppia, due argomenti separati lo faranno), ma stai fornendo un elenco di numeri e una funzione alla tua funzione principale.
nimi

2

MATL , 23 byte

&:ll&Gw-XJq:"yy+]JQ$h^s

Provalo online! Oppure verifica tutti i casi di test .

&:      % Binary range between the two implicit inputs: [a a+1 ... b] 
ll      % Push 1, 1. These are the first two Fibonacci numbers
&G      % Push a, b again
w-      % Swap, subtract: gives b-a
XJ      % Copy to cilipboard J
q:      % Array [1 2 ... b-a-1]
"       % For each (repeat b-a-1 times)
  yy    %    Duplicate the top two numbers in the stack
  +     %    Add
]       % End
J       % Push b-a
Q       % Add 1: gives b-a+1
$       % Specify that the next function takes b-a+1 inputs
h       % Concatenate that many elements (Fibonacci numbers) into a row vector
^       % Power, element-wise: each entry in [a a+1 ... b] is raised to the
        % corresponding Fibonacci number
s       % Sum of array. Implicitly display

1

R, 51 byte

Una funzione anonima.

function(a,b)sum((a:b)^numbers::fibonacci(b-a+1,T))


0

Rubino, 46 ​​byte

->a,b{n=s=0;m=1;a.upto(b){|x|s+=x**n=m+m=n};s}

Niente di particolarmente intelligente o originale da vedere qui. Scusate.


Per me non parla di Ruby, il ℤ.upto(ℤ)metodo è un bel promemoria della bellezza comportamentale di tutti gli oggetti di Ruby. Ulteriore golf il codice viene lasciato come esercizio ai madrelingua Ruby. Hai già scansionato codegolf.stackexchange.com/questions/363/… ?
Roman Czyborra,

0

Java 7, 96 byte

golfed:

int n(int a, int b){int x=1,y=1,z=0,s=0;while(a<=b){s+=Math.pow(a++,x);z=x+y;x=y;y=z;}return s;}

Ungolfed:

int n(int a, int b)
{
    int x = 1, y = 1, z = 0, s = 0;
    while (a <= b)
    {
        s += Math.pow(a++, x);
        z = x + y;
        x = y;
        y = z;
    }

    return s;
}

0

R, 57 byte

x=scan();sum((x[1]:x[2])^numbers::fibonacci(diff(x)+1,T))

Abbastanza diretto. gmp::fibnumè un built-in più breve, ma non supporta il ripristino dell'intera sequenza n, cosa che numbers::fibonaccifa aggiungendo l'argomento T.

Innanzitutto ho avuto una soluzione più complicata con la gmp::fibnumquale è risultato 2 byte più lungo di questa soluzione.

x=scan();for(i in x[1]:x[2])F=F+i^gmp::fibnum((T<-T+1)-1);F

L'uso di una funzione anonima anziché scan()salvare 6 byte; vedi la mia soluzione pubblicata.
rturnbull,

ah sì, sciocco da parte mia.
JAD

0

dc , 56 byte

?sf?sa0dsbsg1sc[lblcdlfrdsb^lg+sg+sclf1+dsfla!<d]dsdxlgp

Termina l'immissione [1,30]in 51 secondi. Prende i due input su due righe separate una volta eseguiti e i numeri negativi con un trattino basso iniziale ( _) anziché un trattino (ovvero -4verrebbero inseriti come _4).


0

PHP, 77 75 byte

for($b=$argv[$$x=1];$b<=$argv[2];${$x=!$x}=${""}+${1})$s+=$b++**$$x;echo$s;

prende i confini dagli argomenti della riga di comando. Corri con -nr.
mostrando nuovamente le variabili variabili di PHP (e ciò che ho scoperto su di esse .

abbattersi

for($b=$argv[$$x=0}=1]; # $"" to 1st Fibonacci and base to 1st argument
    $b<=$argv[2];           # loop $b up to argument2 inclusive
    ${$x=!$x}                   # 5. toggle $x,             6. store to $1/$""
        =${""}+${1}             # 4. compute next Fibonacci number
)
    $s+=$b++**                  # 2. add exponential to sum,    3. post-increment base
        $$x;                    # 1. take current Fibonacci from $""/$1 as exponent
echo$s;                     # print result

La risposta di FlipTack portata su PHP ha 70 byte:

function f($a,$b,$x=1,$y=1){return$a>$b?0:$a**$x+f($a+1,$b,$y,$x+$y);}

0

Assioma, 65 byte

f(a,b)==reduce(+,[i^fibonacci(j)for i in a..b for j in 1..b-a+1])

codice di prova e risultati

(74) -> f(1,2)
   (74)  3
                                                   Type: Fraction Integer
(75) -> f(4,8)
   (75)  33156
                                                   Type: Fraction Integer
(76) -> f(-1,2)
   (76)  8
                                                   Type: Fraction Integer
(77) -> f(-4,-1)
   (77)  - 4
                                                   Type: Fraction Integer
(78) -> f(3,1)
   >> Error detected within library code:
   reducing over an empty list needs the 3 argument form
    protected-symbol-warn called with (NIL)

0

PowerShell , 67 byte

$e=1;$args[0]..$args[1]|%{$s+=("$_*"*$e+1|iex);$e,$f=($e+$f),$e};$s

Provalo online!

Ho trovato un modo leggermente migliore per eseguire la sequenza, ma powershell non è paragonabile ad altre lingue per questo :)

Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.