# Fibonacci Exponents

For this challenge, you are to output the result of the sum of some numbers. What are these numbers? Well, you are given input, (a, b), which are integers (positive, negative, or zero) , a != b, and a < b , and each integer within a and b (including them) will have exponents according to the Fibonacci numbers. That's confusing so here's an example:

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


Given that the first Fibonacci number is represented by f(0), the formula is:

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


Input, Processing, Output

To clarify the above, here are some test cases, the processing of the input, and the expected outputs:

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


Rules

• No standard loopholes allowed

• Exponents must be in order according to Fibonacci series

• Code must work for above test cases

• Only the output needs to be returned

Winning Criteria

Shortest code wins!

• So 0 is not included in the fibonacci numbers here? Dec 31 '16 at 14:58
• 0 is not a Fibonacci number but is a valid choice for input Dec 31 '16 at 14:59
• 33165 or 33156?
– Neil
Dec 31 '16 at 15:29
• @Neil I think you're right Dec 31 '16 at 18:47
• This above "af(0) + ... + bf(b-a+1) " it is wrong, for example for a=1 and b=2 it would be 1f(0)+2f(2). I think would be af(0) + ... + bf(b-a); here f(0)=0 not 1
– user58988
Apr 17 '17 at 15:16

## Mathematica, 38 bytes37 bytes 31 bytes

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


This is just rahnema1's answer ported to Mathematica. Below is my original solution:

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


Explanation:

## represents the sequence of all the arguments, # represents the first argument, #2 represents the second argument. When called with two arguments a and b, Range[##] will give the list {a, a+1, ..., b} and Range[#2-#+1] will give the list of the same length {1, 2, ..., b-a+1}. Since Fibonacci is Listable, Fibonacci@Range[#2-#+1] will give list of the first b-a+1 Fibonacci numbers. Since Power is Listable, calling it on two lists of equal length will thread it over the lists. Then Tr takes the sum.

Edit: Saved 1 byte thanks to Martin Ender.

• You can use Range@##. Dec 31 '16 at 19:16
• Not as relevant now, but the original approach can be improved 3 bytes to Tr[(r=Range@##)^Fibonacci[r-#+1]]&. Jan 5 '17 at 18:40
• Using Range twice should have been a red flag. Thanks! Jan 5 '17 at 20:12

# Python, 49 bytes

A recursive lambda which takes a and b as separate arguments (you can also set the first two numbers of fibonacci, x and y, to whatever you want - not intentional, but a nice feature):

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


Try it online! (includes test suite)

Golfing suggestions welcome.

• Why -~a and not simply a+1? I think -~a is machine dependant. Jan 6 '17 at 1:19

# Perl 6, 32 30 bytes

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


$^a and $^b are the two arguments to the function; $^a..$^b is the range of numbers from $^a to $^b, which is zipped with exponentiation by Z** with the Fibonacci sequence, 1, &[+] ... *.

Thanks to Brad Gilbert for shaving off two bytes.

• (1,&[+]...*) is one byte shorter, and the space after Z** isn't needed. Jan 1 '17 at 6:47
• @BradGilbertb2gills Cool, I had no idea the Fibonacci sequence could be expressed that way.
– Sean
Jan 1 '17 at 18:55
• Actually it works because &infix:<+> can accept 0,1 or 2 arguments. (&[+] is a short way of writing &infix:<+>). The WhateverCode * + * accepts exactly 2 arguments. (&() == 0 so you have to have the 1 there to start off the sequence) Jan 1 '17 at 19:19

# Maxima , 32 bytes

f(a,b):=sum(x^fib(x-a+1),x,a,b);


## Pyke, 11 bytes

h1:Foh.b^)s


Try it here!

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


## JavaScript (ES7), 42 bytes

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


Straightforward port of @FlipTack's excellent Python answer.

• Nice, turned out even shorter in JavaScript! :) Dec 31 '16 at 22:15

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


Usage:

$ghc fibexps.hs -e '[4..8]?f' 33156  • You can turn the function o into an infix operator, like a#b=sum.... – nimi Jan 2 '17 at 23:49 • Had considered infix like a…b but read the requirement to accept unary (ℤ,ℤ)→ℕ Jan 4 '17 at 11:11 • Many other answers take two separate arguments, so I think it's fine. – nimi Jan 4 '17 at 20:29 • Alrightie already, that brings us up to par with the ECMAscript7 lambda. But if we are allowed to feed (a,b) as a?b then why aren't we allowed to prepare it as immediate [a..b]?f onto (?)=sum.zipWith(^)? Jan 5 '17 at 9:52 • I think this goes too far. The input are two numbers (not necessarily as a pair, two separate arguments will do), but you're feeding a list of numbers and a function to your main function. – nimi Jan 6 '17 at 1:13 # 05AB1E, 9 bytes ŸDg!ÅFsmO  Try it 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.  Doesn't work on TIO for large discrepancies between a and b (E.G. [a..b].length() > 25). But it does seem to work for bigger numbers than the average answer here. Inefficient, because it calculates the fibonacci sequence up to n!, which is more than is needed to compute the answer, where n is the length of the sequence of a..b. • I'm confused as to why this is the accepted answer, it doesn't output the correct result for any of the given testcases. The exponents should be the fibonacci numbers, not the integers in the range. I'm not sure what features were available back then, but ŸDgLÅfmO or just ŸāÅfmO would work instead. – ovs Nov 13 '20 at 16:48 • I was wondering that too. I came up with a 9-byte answer that works, but your alternatives are much better. Nov 13 '20 at 16:57 # MATL, 23 bytes &:ll&Gw-XJq:"yy+]JQ$h^s

&:      % 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
]       % 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  # Husk, 6 bytes Σz^İf…  Try it online! ## Explanation Σz^İf… … rangify the input z^ zip using the power function İf using the fibonacci numbers Σ sum the result  # R, 51 bytes An anonymous function. function(a,b)sum((a:b)^numbers::fibonacci(b-a+1,T))  # Jelly, 13 bytes ạµ1+⁸Ð¡0 r*çS  Try it online! • Nice, the only other answer I've found where an input of f(1,25) works ;). +1 Jan 5 '17 at 19:21 # Whispers v3, 87 bytes > Input > Input > fₙ >> 1…2 >> #4 >> 3ᶠ5 >> L*R >> Each 7 4 6 >> ∑8 >> Output 9  Unfortunately, Whispers v3 isn't on TryItOnline!, so there isn't an online interpreter to test this, aside from downloading the repository and running it locally. # Arn-x, 11 8 bytes gŸ▀<Çúì═  Try it! # Explained Unpacked: .=z^[1 1{+  .= Rangify input (inclusive) z^ Zipped with exponentiation to [1 1{+ The fibonacci sequence, closing }] implied Then take the sum  # Jelly, 9 8 bytes rJÆḞ*@rS  Try it online! -1 byte thanks to ZippyMagician ## How it works rJÆḞ*@rS - Main link. Takes a on the left and b on the right r - Range from a to b J - Length range of that ÆḞ - n'th Fibonacci number of each r - Range from a to b *@ - Raise each to the power of the Fib numbers S - Sum  ## Ruby, 46 bytes ->a,b{n=s=0;m=1;a.upto(b){|x|s+=x**n=m+m=n};s}  Nothing particularly clever or original to see here. Sorry. • For me nonspeaker of Ruby, the ℤ.upto(ℤ) method is a nice reminder of Ruby's all-object behavior beauty. Further golfing the code is left as an exercise to native Ruby speakers. Have you scanned codegolf.stackexchange.com/questions/363/… yet? Jan 5 '17 at 10:14 # Java 7, 96 bytes 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; }  # R, 57 bytes x=scan();sum((x:x)^numbers::fibonacci(diff(x)+1,T))  Pretty straightforward. gmp::fibnum is a shorter built-in, but it doesn't support returning the entire sequence up to n, which numbers::fibonacci does by adding the argument T. First I had a more tricky solution with gmp::fibnum which ended up 2 bytes longer than this solution. x=scan();for(i in x:x)F=F+i^gmp::fibnum((T<-T+1)-1);F  • Using an anonymous function rather than scan() saves 6 bytes; see my posted solution. Jan 5 '17 at 18:06 • ah yeah, silly of me. – JAD Jan 5 '17 at 18:14 # dc, 56 bytes ?sf?sa0dsbsg1sc[lblcdlfrdsb^lg+sg+sclf1+dsfla!<d]dsdxlgp  Finishes for input [1,30] in 51 seconds. Takes the two inputs on two separate lines once executed and negative numbers with a leading underscore (_) instead of a dash (i.e -4 would be input as _4). # PHP, 77 75 bytes for($b=$argv[$$x=1];b<=argv;{x=!x}={""}+{1})s+=b++**$$x;echo$s;


takes boundaries from command line arguments. Run with -nr.
showcasing PHP´s variable variables again (and what I´ve found out about them.

breakdown

for($b=$argv[$$x=0}=1]; # "" to 1st Fibonacci and base to 1st argument b<=argv; # 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  FlipTack´s answer ported to PHP has 70 bytes: function f($a,$b,$x=1,$y=1){return$a>$b?0:$a**$x+f($a+1,$b,$y,$x+$y);}


# Axiom, 65 bytes

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


test code and results

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


# PowerShell, 67 bytes

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


Try it online!

Found a slightly better way to do the sequence, but powershell doesn't compare to other languages for this one :)

# Japt-x, 9 bytes

òV ËpMgEÄ


Try it

# 05AB1E, 10 bytes

ŸvyN>Åfm}O


Try it online! Takes two lines of input, the first line being b and the second line being a.

 v          # for y in...
Ÿ           # [a, ..., b] (implicit input)
m    # push...
y         # current item in list
m    # to the power of...
Åf     # the...
N>       # current index in list...
Åf     # th Fibonacci number
}   # end loop
O  # push sum(stack)
# implicit output