Pour ce défi, vous devez sortir le résultat de la somme de certains nombres. Quels sont ces chiffres? Eh bien, on vous donne une entrée, ( a, b), qui sont des entiers (positifs, négatifs ou zéro) a != b, et a < b, et chaque entier à l'intérieur aet b(y compris eux) aura des exposants en fonction des nombres de Fibonacci. C'est déroutant alors voici un exemple:

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

Étant donné que le premier nombre de Fibonacci est représenté par f(0), la formule est:

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

Entrée, traitement, sortie

Pour clarifier ce qui précède, voici quelques cas de test, le traitement de l'entrée et les sorties attendues:

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

Règles

• Aucune échappatoire standard autorisée

• Les exposants doivent être en ordre selon la série de Fibonacci

• Le code doit fonctionner pour les cas de test ci-dessus

• Seule la sortie doit être retournée

Critères gagnants

Le code le plus court gagne!

05AB1E , 9 octets

ŸDg!ÅFsmO

Essayez-le en ligne!

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

Ne fonctionne pas sur TIO pour les écarts importants entre aet b(EG [a..b].length() > 25).

Mais cela semble fonctionner pour de plus grands nombres que la réponse moyenne ici.

Inefficace, car il calcule la séquence de fibonacci jusqu'à n!, ce qui est plus que nécessaire pour calculer la réponse, où nest la longueur de la séquence de a..b.

Mathematica, 38 octets 37 octets 31 octets

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

Ceci est juste la réponse de rahnema1 portée sur Mathematica. Voici ma solution originale:

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

Explication:

##représente la séquence de tous les arguments, #représente le premier argument, #2représente le deuxième argument. Lorsqu'il est appelé avec deux arguments aet b, Range[##]donnera la liste {a, a+1, ..., b}et Range[#2-#+1]donnera la liste de la même longueur {1, 2, ..., b-a+1}. Depuis Fibonacciest Listable, Fibonacci@Range[#2-#+1]donnera la liste des premiers b-a+1nombres de Fibonacci. Depuis Powerest Listable, en l' appelant sur deux listes de longueur égale enfilera le sur les listes. Prend ensuite Trla somme.

Edit: sauvé 1 octet grâce à Martin Ender.

Python , 49 octets

Un lambda récursif qui prend aet bcomme arguments séparés (vous pouvez également définir les deux premiers nombres de fibonacci, xet y, selon ce que vous voulez - pas intentionnel, mais une fonctionnalité intéressante):

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

Essayez-le en ligne! (comprend la suite de tests)

Suggestions de golf bienvenues.

Perl 6 , 32 30 octets

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

$^aet $^bsont les deux arguments de la fonction; $^a..$^best la gamme des nombres de $^avers $^b, qui est compressé avec exponentiation par Z**de la suite de Fibonacci, 1, &[+] ... *.

Merci à Brad Gilbert d'avoir rasé deux octets.

Maxima, 32 octets

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

Pyke, 11 octets

h1:Foh.b^)s

Essayez-le ici!

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

JavaScript (ES7), 42 octets

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

Port simple de l'excellente réponse Python de @ FlipTack.

Haskell, 35 octets

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

Usage:

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

MATL , 23 octets

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

Essayez-le en ligne! Ou vérifiez tous les cas de 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

R, 51 octets

Une fonction anonyme.

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

Gelée , 13 octets

ạµ1+⁸С0
r*çS

Essayez-le en ligne!

Rubis, 46 octets

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

Rien de particulièrement intelligent ou original à voir ici. Désolé.

Java 7, 96 octets

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

Non 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 octets

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

Assez simple. gmp::fibnumest une fonction intégrée plus courte, mais elle ne prend pas en charge le retour de la séquence entière n, ce qui se numbers::fibonaccifait en ajoutant l'argument T.

J'ai d'abord eu une solution plus délicate gmp::fibnumqui a fini par 2 octets de plus que cette solution.

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

dc , 56 octets

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

Termine la saisie [1,30]en 51 secondes. Prend les deux entrées sur deux lignes distinctes une fois exécutées et des nombres négatifs avec un trait de soulignement ( _) au lieu d'un tiret (c'est -4-à- dire serait entré comme _4).

PHP, 77 75 octets

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

prend les limites des arguments de ligne de commande. Courez avec -nr.
présentant à nouveau les variables variables de PHP (et ce que j'ai découvert à leur sujet .

panne

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 réponse de FlipTack portée en PHP a 70 octets:

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

Axiome, 65 octets

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

code de test et résultats

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

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

Essayez-le en ligne!

J'ai trouvé une façon légèrement meilleure de faire la séquence, mais PowerShell ne se compare pas à d'autres langues pour celui-ci :)