W przypadku tego wyzwania musisz przedstawić wynik sumy niektórych liczb. Co to za liczby? Cóż, masz dane wejściowe, ( a, b), które są liczbami całkowitymi (dodatnimi, ujemnymi lub zerowymi) a != b, i a < b, i każda liczba całkowita w ai b(łącznie z nimi) będzie miała wykładniki zgodnie z liczbami Fibonacciego. To mylące, oto przykład:

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

Biorąc pod uwagę, że pierwsza liczba Fibonacciego jest reprezentowana przez f(0), wzór jest następujący:

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

Wejście, przetwarzanie, wyjście

Aby wyjaśnić powyższe, oto kilka przypadków testowych, przetwarzanie danych wejściowych i oczekiwane wyniki:

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

Zasady

• Niedozwolone są standardowe luki

• Wykładniki muszą być uporządkowane zgodnie z serią Fibonacciego

• Kod musi działać dla powyższych przypadków testowych

• Tylko dane wyjściowe muszą zostać zwrócone

Zwycięskie kryteria

Najkrótszy kod wygrywa!

05AB1E , 9 bajtów

ŸDg!ÅFsmO

Wypróbuj 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.

Nie działa w TIO w przypadku dużych rozbieżności między ai b(EG [a..b].length() > 25).

Ale wydaje się, że działa na większą liczbę niż średnia odpowiedź tutaj.

Nieefektywne, ponieważ oblicza sekwencję Fibonacciego do n!, co jest więcej niż potrzebne do obliczenia odpowiedzi, gdzie njest długość sekwencji a..b.

Mathematica, 38 bajtów 37 bajtów 31 bajtów

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

To tylko odpowiedź rahnema1 przeniesiona do Mathematica. Poniżej znajduje się moje oryginalne rozwiązanie:

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

Wyjaśnienie:

##reprezentuje sekwencję wszystkich argumentów, #reprezentuje pierwszy argument, #2reprezentuje drugi argument. Gdy zostanie wywołany z dwoma argumentami ai b, Range[##]da listę {a, a+1, ..., b}i Range[#2-#+1]da listę o tej samej długości {1, 2, ..., b-a+1}. Ponieważ Fibonaccijest Listable, Fibonacci@Range[#2-#+1]poda listę pierwszych b-a+1liczb Fibonacciego. Ponieważ Powerjest Listableto wywołanie go na dwóch listach o tej samej długości, przeciągnie go na listy. Potem Trbierze sumę.

Edycja: Zapisano 1 bajt dzięki Martinowi Enderowi.

Python , 49 bajtów

Rekurencyjna lambda, która przyjmuje ai bjako osobne argumenty (możesz również ustawić dwie pierwsze liczby Fibonacciego xi y, co chcesz - nie celowe, ale fajna funkcja):

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

Wypróbuj online! (obejmuje pakiet testowy)

Sugestie dotyczące gry w golfa mile widziane.

Perl 6 , 32 30 bajtów

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

$^ai $^bsą dwoma argumentami funkcji; $^a..$^bJest to zakres liczb od $^acelu $^b, który jest suwak z potęgowania przez Z**z sekwencją Fibonacciego 1, &[+] ... *.

Podziękowania dla Brada Gilberta za zgolenie dwóch bajtów.

Maxima, 32 bajty

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

Pyke, 11 bajtów

h1:Foh.b^)s

Wypróbuj tutaj!

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

JavaScript (ES7), 42 bajty

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

Prosty port doskonałej odpowiedzi Python @ FlipTack.

Haskell, 35 bajtów

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

Stosowanie:

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

MATL , 23 bajty

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

Wypróbuj online! Lub sprawdź wszystkie przypadki testowe .

&:      % 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 bajtów

Anonimowa funkcja.

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

Galaretka , 13 bajtów

ạµ1+⁸С0
r*çS

Wypróbuj online!

Rubinowy, 46 bajtów

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

Nie ma tu nic szczególnie sprytnego lub oryginalnego. Przepraszam.

Java 7, 96 bajtów

Gra w golfa:

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

Nie golfowany:

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 bajtów

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

Całkiem proste. gmp::fibnumjest krótszy wbudowany, ale nie obsługuje zwracania całej sekwencji do n, co numbers::fibonaccirobi się przez dodanie argumentu T.

Najpierw miałem trudniejsze rozwiązanie, z gmp::fibnumktórym skończyło się 2 bajty dłużej niż to rozwiązanie.

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

dc , 56 bajtów

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

Kończy wprowadzanie za [1,30]51 sekund. Wykonuje dwa wejścia w dwóch oddzielnych wierszach po wykonaniu i liczby ujemne z wiodącym podkreśleniem ( _) zamiast myślnika (tzn. -4Będzie wprowadzony jako _4).

PHP, 77 75 bajtów

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

bierze granice z argumentów wiersza poleceń. Uruchom z -nr.
pokazując ponownie zmienne PHP (i to, co się o nich dowiedziałem) .

awaria

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

Odpowiedź FlipTacka przeniesiona do PHP ma 70 bajtów:

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

Aksjomat, 65 bajtów

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

kod testowy i wyniki

(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 bajtów

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

Wypróbuj online!

Znalazłem nieco lepszy sposób wykonania sekwencji, ale PowerShell nie porównuje się z innymi językami dla tego :)