Para este desafío, debe generar el resultado de la suma de algunos números. ¿Qué son estos números? Bueno, se le da entrada, ( a, b), que son enteros (positivo, negativo o cero) a != b, y a < b, y cada entero dentro ay b(incluyéndolos) tendrá exponentes de acuerdo con los números de Fibonacci. Eso es confuso, así que aquí hay un ejemplo:

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

Dado que el primer número de Fibonacci está representado por f(0), la fórmula es:

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

Entrada, procesamiento, salida

Para aclarar lo anterior, aquí hay algunos casos de prueba, el procesamiento de la entrada y las salidas esperadas:

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

Reglas

• No se permiten lagunas estándar

• Los exponentes deben estar en orden de acuerdo con la serie de Fibonacci

• El código debe funcionar para los casos de prueba anteriores

• Solo la salida necesita ser devuelta

Criterios ganadores

¡El código más corto gana!

05AB1E , 9 bytes

ŸDg!ÅFsmO

Pruébalo en línea!

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

No funciona en TIO para grandes discrepancias entre ay b(EG [a..b].length() > 25).

Pero parece funcionar para números más grandes que la respuesta promedio aquí.

Ineficiente, porque calcula la secuencia de Fibonacci hasta n!, que es más de lo necesario para calcular la respuesta, donde nestá la longitud de la secuencia de a..b.

Mathematica, 38 bytes 37 bytes 31 bytes

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

Esta es solo la respuesta de rahnema1 portada a Mathematica. A continuación se muestra mi solución original:

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

Explicación:

##representa la secuencia de todos los argumentos, #representa el primer argumento, #2representa el segundo argumento. Cuando se llama con dos argumentos ay b, Range[##]dará la lista {a, a+1, ..., b}y Range[#2-#+1]dará la lista de la misma longitud {1, 2, ..., b-a+1}. Como Fibonaccies Listable, Fibonacci@Range[#2-#+1]dará una lista de los primeros b-a+1números de Fibonacci. Como Poweres Listable, llamarlo en dos listas de igual longitud lo enhebrará sobre las listas. Luego Trtoma la suma.

Editar: Guardado 1 byte gracias a Martin Ender.

Python , 49 bytes

Una lambda recursiva que toma ay bcomo argumentos separados (también puede establecer los dos primeros números de fibonacci xy y, a lo que quiera, no intencional, sino una buena característica):

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

Pruébalo en línea! (incluye suite de pruebas)

Sugerencias de golf bienvenidas.

Perl 6 , 32 30 bytes

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

$^ay $^bson los dos argumentos de la función; $^a..$^bes el rango de números de $^aa $^b, que es comprimido con exponenciación por Z**con la secuencia de Fibonacci, 1, &[+] ... *.

Gracias a Brad Gilbert por reducir dos bytes.

Máxima, 32 bytes

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

Pyke, 11 bytes

h1:Foh.b^)s

Pruébalo aquí!

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)

Puerto directo de la excelente respuesta de Python de @ FlipTack.

Haskell, 35 bytes

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

Uso:

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

MATL , 23 bytes

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

Pruébalo en línea! O verificar todos los casos de prueba .

&:      % 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

R, 51 bytes

Una función anónima.

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

Jalea , 13 bytes

ạµ1+⁸С0
r*çS

Pruébalo en línea!

Ruby, 46 bytes

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

Nada particularmente inteligente u original para ver aquí. Lo siento.

Java 7, 96 bytes

Golfizado:

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;}

Sin golf:

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[1]:x[2])^numbers::fibonacci(diff(x)+1,T))

Muy claro. gmp::fibnumes una versión incorporada más corta, pero no admite devolver toda la secuencia n, lo que numbers::fibonaccihace agregando el argumento T.

Primero tuve una solución más complicada con la gmp::fibnumque terminé 2 bytes más que esta solución.

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

cc , 56 bytes

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

Termina para la entrada [1,30]en 51 segundos. Toma las dos entradas en dos líneas separadas una vez ejecutadas y los números negativos con un guión bajo ( _) en lugar de un guión (es decir -4, se ingresarán como _4).

PHP, 77 75 bytes

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

toma límites de los argumentos de la línea de comando. Corre con -nr.
mostrando nuevamente las variables variables de PHP (y lo que he descubierto sobre ellas) .

Descompostura

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 respuesta de FlipTack portada a PHP tiene 70 bytes:

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

Axioma, 65 bytes

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

código de prueba y resultados

(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[0]..$args[1]|%{$s+=("$_*"*$e+1|iex);$e,$f=($e+$f),$e};$s

Pruébalo en línea!

Encontré una forma ligeramente mejor de hacer la secuencia, pero powershell no se compara con otros idiomas para este :)