{{task}}

There is a conjecture in mathematics that held for over two hundred years before it was disproved by the finding of a counterexample in 1966 by [http://www.ams.org/journals/mcom/1967-21-097/S0025-5718-1967-0220669-3/S0025-5718-1967-0220669-3.pdf Lander and Parkin].

;Euler's (disproved) sum of powers [[wp:Euler's sum of powers conjecture|conjecture]]: At least k positive k^th powers are required to sum to a k^th power, except for the trivial case of one k^th power: y^k = y^k

Lander and Parkin are known to have used a brute-force search on a [[wp:CDC_6600|CDC 6600]] computer restricting numbers to those less than 250.

;Task: Write a program to search for an integer solution for: : x05 + x15 + x25 + x35 == y5 Where all xi's and y are distinct integers between '''0''' and '''250''' (exclusive).

Show an answer here.

;Related tasks:

• [[Pythagorean quadruples]].
• [[Pythagorean triples]].

11l

{{trans|Python}}

F eulers_sum_of_powers()
   V max_n = 250
   V pow_5 = (0 .< max_n).map(n -> Int64(n ^ 5))
   V pow5_to_n = Dict(0 .< max_n, n -> (Int64(n ^ 5), n))

   L(x0) 1 .< max_n
      L(x1) 1 .< x0
         L(x2) 1 .< x1
            L(x3) 1 .< x2
               V pow_5_sum = pow_5[x0] + pow_5[x1] + pow_5[x2] + pow_5[x3]
               I pow_5_sum C pow5_to_n
                  V y = pow5_to_n[pow_5_sum]
                  R (x0, x1, x2, x3, y)

V r = eulers_sum_of_powers()
print(‘#.^5 + #.^5 + #.^5 + #.^5 = #.^5’.format(r[0], r[1], r[2], r[3], r[4]))

{{out}}

133^5 + 110^5 + 84^5 + 27^5 = 144^5

360 Assembly

This program could have been run in 1964. Here, for maximum compatibility, we use only the basic 360 instruction set. Macro instruction XPRNT can be replaced by a WTO.

EULERCO  CSECT
         USING  EULERCO,R13
         B      80(R15)
         DC     17F'0'
         DC     CL8'EULERCO'
         STM    R14,R12,12(R13)
         ST     R13,4(R15)
         ST     R15,8(R13)
         LR     R13,R15
         ZAP    X1,=P'1'
LOOPX1   ZAP    PT,MAXN            do x1=1 to maxn-4
         SP     PT,=P'4'
         CP     X1,PT
         BH     ELOOPX1
         ZAP    PT,X1
         AP     PT,=P'1'
         ZAP    X2,PT
LOOPX2   ZAP    PT,MAXN            do x2=x1+1 to maxn-3
         SP     PT,=P'3'
         CP     X2,PT
         BH     ELOOPX2
         ZAP    PT,X2
         AP     PT,=P'1'
         ZAP    X3,PT
LOOPX3   ZAP    PT,MAXN            do x3=x2+1 to maxn-2
         SP     PT,=P'2'
         CP     X3,PT
         BH     ELOOPX3
         ZAP    PT,X3
         AP     PT,=P'1'
         ZAP    X4,PT
LOOPX4   ZAP    PT,MAXN            do x4=x3+1 to maxn-1
         SP     PT,=P'1'
         CP     X4,PT
         BH     ELOOPX4
         ZAP    PT,X4
         AP     PT,=P'1'
         ZAP    X5,PT              x5=x4+1
         ZAP    SUMX,=P'0'         sumx=0
         ZAP    PT,X1              x1
         BAL    R14,POWER5
         AP     SUMX,PT
         ZAP    PT,X2              x2
         BAL    R14,POWER5
         AP     SUMX,PT
         ZAP    PT,X3              x3
         BAL    R14,POWER5
         AP     SUMX,PT
         ZAP    PT,X4              x4
         BAL    R14,POWER5
         AP     SUMX,PT            sumx=x1**5+x2**5+x3**5+x4**5
         ZAP    PT,X5              x5
         BAL    R14,POWER5
         ZAP    VALX,PT            valx=x5**5
LOOPX5   CP     X5,MAXN            while x5<=maxn & valx<=sumx
         BH     ELOOPX5
         CP     VALX,SUMX
         BH     ELOOPX5
         CP     VALX,SUMX          if valx=sumx
         BNE    NOTEQUAL
         MVI    BUF,C' '
         MVC    BUF+1(79),BUF      clear buffer
         MVC    WC,MASK
         ED     WC,X1              x1
         MVC    BUF+0(8),WC+8
         MVC    WC,MASK
         ED     WC,X2              x2
         MVC    BUF+8(8),WC+8
         MVC    WC,MASK
         ED     WC,X3              x3
         MVC    BUF+16(8),WC+8
         MVC    WC,MASK
         ED     WC,X4              x4
         MVC    BUF+24(8),WC+8
         MVC    WC,MASK
         ED     WC,X5              x5
         MVC    BUF+32(8),WC+8
         XPRNT  BUF,80             output x1,x2,x3,x4,x5
         B      ELOOPX1
NOTEQUAL ZAP    PT,X5
         AP     PT,=P'1'
         ZAP    X5,PT              x5=x5+1
         ZAP    PT,X5
         BAL    R14,POWER5
         ZAP    VALX,PT            valx=x5**5
         B      LOOPX5
ELOOPX5  AP     X4,=P'1'
         B      LOOPX4
ELOOPX4  AP     X3,=P'1'
         B      LOOPX3
ELOOPX3  AP     X2,=P'1'
         B      LOOPX2
ELOOPX2  AP     X1,=P'1'
         B      LOOPX1
ELOOPX1  L      R13,4(0,R13)
         LM     R14,R12,12(R13)
         XR     R15,R15
         BR     R14
POWER5   ZAP    PQ,PT              ^1
         MP     PQ,PT              ^2
         MP     PQ,PT              ^3
         MP     PQ,PT              ^4
         MP     PQ,PT              ^5
         ZAP    PT,PQ
         BR     R14
MAXN     DC     PL8'250'
X1       DS     PL8
X2       DS     PL8
X3       DS     PL8
X4       DS     PL8
X5       DS     PL8
SUMX     DS     PL8
VALX     DS     PL8
PT       DS     PL8
PQ       DS     PL8
WC       DS     CL17
MASK     DC     X'40',13X'20',X'212060'  CL17
BUF      DS     CL80
         YREGS
         END

{{out}}

      27      84     110     133     144

Ada

with Ada.Text_IO;

procedure Sum_Of_Powers is

   type Base is range 0 .. 250; -- A, B, C, D and Y are in that range
   type Num is range 0 .. 4*(250**5); -- (A**5 + ... + D**5) is in that range
   subtype Fit is Num range 0 .. 250**5; -- Y**5 is in that range

   Modulus: constant Num := 254;
   type Modular is mod Modulus;

   type Result_Type is array(1..5) of Base; -- this will hold A,B,C,D and Y

   type Y_Type is array(Modular) of Base;
   type Y_Sum_Type is array(Modular) of Fit;

   Y_Sum: Y_Sum_Type := (others => 0);
   Y: Y_Type := (others => 0);
      -- for I in 0 .. 250, we set Y_Sum(I**5 mod Modulus) := I**5
      --                       and Y(I**5 mod Modulus) := I
      -- Modulus has been chosen to avoid collisions on (I**5 mod Modulus)
      -- later we will compute Sum_ABCD := A**5 + B**5 + C**5 + D**5
      -- and check if Y_Sum(Sum_ABCD mod modulus) = Sum_ABCD

   function Compute_Coefficients return Result_Type is

      Sum_A: Fit;
      Sum_AB, Sum_ABC, Sum_ABCD: Num;
      Short: Modular;

   begin
      for A in Base(0) .. 246 loop
         Sum_A := Num(A) ** 5;
         for B in A .. 247 loop
            Sum_AB := Sum_A + (Num(B) ** 5);
            for C in Base'Max(B,1) .. 248 loop -- if A=B=0 then skip C=0
               Sum_ABC := Sum_AB + (Num(C) ** 5);
               for D in C .. 249 loop
                  Sum_ABCD := Sum_ABC + (Num(D) ** 5);
                  Short    := Modular(Sum_ABCD mod Modulus);
                  if Y_Sum(Short) = Sum_ABCD then
                     return A & B & C & D & Y(Short);
                  end if;
               end loop;
            end loop;
         end loop;
      end loop;
      return 0 & 0 & 0 & 0 & 0;
   end Compute_Coefficients;

   Tmp: Fit;
   ABCD_Y: Result_Type;

begin -- main program

   -- initialize Y_Sum and Y
   for I in Base(0) .. 250 loop
      Tmp := Num(I)**5;
      if Y_Sum(Modular(Tmp mod Modulus)) /= 0 then
         raise Program_Error with "Collision: Change Modulus and recompile!";
      else
         Y_Sum(Modular(Tmp mod Modulus)) := Tmp;
         Y(Modular(Tmp mod Modulus)) := I;
      end if;
   end loop;

   -- search for a solution (A, B, C, D, Y)
   ABCD_Y := Compute_Coefficients;

   -- output result
   for Number of ABCD_Y loop
      Ada.Text_IO.Put(Base'Image(Number));
   end loop;
   Ada.Text_IO.New_Line;

end Sum_Of_Powers;

{{output}}

 27 84 110 133 144

ALGOL 68

{{works with|ALGOL 68G|Any - tested with release 2.8.win32}}

# max number will be the highest integer we will consider                    #
INT max number = 250;

# Construct a table of the fifth powers of 1 : max number                    #
[ max number ]LONG INT fifth;
FOR i TO max number DO
    LONG INT i2 =  i * i;
    fifth[ i ] := i2 * i2 * i
OD;

# find the first a, b, c, d, e such that a^5 + b^5 + c^5 + d^5 = e^5         #
# as the fifth powers are in order, we can use a binary search to determine  #
# whether the value is in the table                                          #
BOOL found := FALSE;
FOR a TO max number WHILE NOT found DO
    FOR b FROM a TO max number WHILE NOT found DO
        FOR c FROM b TO max number WHILE NOT found DO
            FOR d FROM c TO max number WHILE NOT found DO
                LONG INT sum   = fifth[a] + fifth[b] + fifth[c] + fifth[d];
                INT      low  := d;
                INT      high := max number;
                WHILE low < high
                  AND NOT found
                DO
                    INT e := ( low + high ) OVER 2;
                    IF fifth[ e ] = sum
                    THEN
                        # the value at e is a fifth power                    #
                        found := TRUE;
                        print( ( ( whole( a, 0 ) + "^5 + " + whole( b, 0 ) + "^5 + "
                                 + whole( c, 0 ) + "^5 + " + whole( d, 0 ) + "^5 = "
                                 + whole( e, 0 ) + "^5"
                                 )
                               , newline
                               )
                             )
                    ELIF sum < fifth[ e ]
                    THEN high := e - 1
                    ELSE low  := e + 1
                    FI
                OD
            OD
        OD
    OD
OD

Output:

27^5 + 84^5 + 110^5 + 133^5 = 144^5

ALGOL W

As suggested by the REXX solution, we find a solution to a^5 + b^5 + c^5 = e^5 - d^5 which results in a significant reduction in run time.

Algol W integers are 32-bit only, so we simulate the necessary 12 digit arithmetic with pairs of integers.

begin
    % find a, b, c, d, e such that a^5 + b^5 + c^5 + d^5 = e^5                              %
    %                        where 1 <= a <= b <= c <= d <= e <= 250                        %
    % we solve this using the equivalent equation a^5 + b^5 + c^5 = e^5 - d^5               %
    % 250^5 is 976 562 500 000 - too large for a 32 bit number so we will use pairs of      %
    % integers and constrain their values to be in 0..1 000 000                             %
    % Note only positive numbers are needed                                                 %
    integer MAX_NUMBER, MAX_V;
    MAX_NUMBER := 250;
    MAX_V      := 1000000;
    begin
        % quick sorts the fifth power differences table                                     %
        procedure quickSort5 ( integer value lb, ub ) ;
            if ub > lb then begin
                % more than one element, so must sort                                       %
                integer left, right, pivot, pivotLo, pivotHi;
                left    := lb;
                right   := ub;
                % choosing the middle element of the array as the pivot %
                pivot   := left + ( ( ( right + 1 ) - left ) div 2 );
                pivotLo := loD( pivot );
                pivotHi := hiD( pivot );
                while begin
                    while left  <= ub
                      and begin integer cmp;
                                cmp := hiD( left ) - pivotHi;
                                if cmp = 0 then cmp := loD( left ) - pivotLo;
                                cmp < 0
                          end
                    do left := left + 1;
                    while right >= lb
                      and begin integer cmp;
                                cmp := hiD( right ) - pivotHi;
                                if cmp = 0 then cmp := loD( right ) - pivotLo;
                                cmp > 0
                          end
                    do right := right - 1;
                    left <= right
                end do begin
                    integer swapLo, swapHi, swapD, swapE;
                    swapLo       := loD( left  );
                    swapHi       := hiD( left  );
                    swapD        := Dd(  left  );
                    swapE        := De(  left  );
                    loD( left  ) := loD( right );
                    hiD( left  ) := hiD( right );
                    Dd(  left  ) := Dd(  right );
                    De(  left  ) := De(  right );
                    loD( right ) := swapLo;
                    hiD( right ) := swapHi;
                    Dd(  right ) := swapD;
                    De(  right ) := swapE;
                    left         := left  + 1;
                    right        := right - 1
                end while_left_le_right ;
                quickSort5( lb,   right );
                quickSort5( left, ub    )
            end quickSort5 ;
        % table of fifth powers                                                             %
        integer array lo5, hi5         ( 1 :: MAX_NUMBER );
        % table if differences between fifth powers                                         %
        integer array loD, hiD, De, Dd ( 1 :: MAX_NUMBER * MAX_NUMBER );
        integer dUsed, dPos;
        % compute fifth powers                                                              %
        for i := 1 until MAX_NUMBER do begin
            lo5( i ) := i * i; hi5( i ) := 0;
            for p := 3 until 5 do begin
                integer carry;
                lo5( i ) := lo5( i ) * i;
                carry    := lo5( i ) div MAX_V;
                lo5( i ) := lo5( i ) rem MAX_V;
                hi5( i ) := hi5( i ) * i;
                hi5( i ) := hi5( i ) + carry
            end for_p
        end for_i ;
        % compute the differences between fifth powers e^5 - d^5, 1 <= d < e <= MAX_NUMBER  %
        dUsed := 0;
        for e := 2 until MAX_NUMBER do begin
            for d := 1 until e - 1  do begin
                dUsed := dUsed + 1;
                De(  dUsed ) := e;
                Dd(  dUsed ) := d;
                loD( dUsed ) := lo5( e ) - lo5( d );
                hiD( dUsed ) := hi5( e ) - hi5( d );
                if loD( dUsed ) < 0 then begin
                    loD( dUsed ) := loD( dUsed ) + MAX_V;
                    hiD( dUsed ) := hiD( dUsed ) - 1
                end if_need_to_borrow
            end for_d
        end for_e;
        % sort the fifth power differences                                                  %
        quickSort5( 1, dUsed );
        % attempt to find a^5 + b^5 + c^5 = e^5 - d^5                                       %
        for a := 1 until MAX_NUMBER do begin
            integer loA, hiA;
            loA := lo5( a ); hiA := hi5( a );
            for b := a until MAX_NUMBER do begin
                integer loB, hiB;
                loB := lo5( b ); hiB := hi5( b );
                for c := b until MAX_NUMBER do begin
                    integer low, high, loSum, hiSum;
                    loSum :=                       loA + loB + lo5( c );
                    hiSum := ( loSum div MAX_V ) + hiA + hiB + hi5( c );
                    loSum :=   loSum rem MAX_V;
                    % look for hiSum,loSum in hiD,loD                                       %
                    low   := 1;
                    high  := dUsed;
                    while low < high do begin
                        integer mid, cmp;
                        mid := ( low + high ) div 2;
                        cmp := hiD( mid ) - hiSum;
                        if cmp = 0 then cmp := loD( mid ) - loSum;
                        if cmp = 0 then begin
                            % the value at mid is the difference of two fifth powers        %
                            write( i_w := 1, s_w := 0
                                 , a, "^5 + ", b, "^5 + ", c, "^5 + "
                                 , Dd( mid ), "^5 = ", De( mid ), "^5"
                                 );
                            go to found
                            end
                        else if cmp > 0 then high := mid - 1
                        else                 low  := mid + 1
                    end while_low_lt_high
                end for_c
            end for_b
        end for_a ;
found :
    end
end.

{{out}}

27^5 + 84^5 + 110^5 + 133^5 = 144^5

AWK

# syntax: GAWK -f EULERS_SUM_OF_POWERS_CONJECTURE.AWK
BEGIN {
    start_int = systime()
    main()
    printf("%d seconds\n",systime()-start_int)
    exit(0)
}
function main(  sum,s1,x0,x1,x2,x3) {
    for (x0=1; x0<=250; x0++) {
      for (x1=1; x1<=x0; x1++) {
        for (x2=1; x2<=x1; x2++) {
          for (x3=1; x3<=x2; x3++) {
            sum = (x0^5) + (x1^5) + (x2^5) + (x3^5)
            s1 = int(sum ^ 0.2)
            if (sum == s1^5) {
              printf("%d^5 + %d^5 + %d^5 + %d^5 = %d^5\n",x0,x1,x2,x3,s1)
              return
            }
          }
        }
      }
    }
}

{{out}}

133^5 + 110^5 + 84^5 + 27^5 = 144^5
15 seconds

C

The trick to speed up was the observation that for any x we have x^5=x modulo 2, 3, and 5, according to the Fermat's little theorem. Thus, based on the Chinese Remainder Theorem we have x^5==x modulo 30 for any x. Therefore, when we have computed the left sum s=a^5+b^5+c^5+d^5, then we know that the right side e^5 must be such that s==e modulo 30. Thus, we do not have to consider all values of e, but only values in the form e=e0+30k, for some starting value e0, and any k. Also, we follow the constraints 1<=a<b<c<d<e<N in the main loop.

// Alexander Maximov, July 2nd, 2015
#include <stdio.h>
#include <time.h>
typedef long long mylong;

void compute(int N, char find_only_one_solution)
{	const int M = 30;   /* x^5 == x modulo M=2*3*5 */
	int a, b, c, d, e;
	mylong s, t, max, *p5 = (mylong*)malloc(sizeof(mylong)*(N+M));

	for(s=0; s < N; ++s)
		p5[s] = s * s, p5[s] *= p5[s] * s;
	for(max = p5[N - 1]; s < (N + M); p5[s++] = max + 1);

	for(a = 1; a < N; ++a)
	for(b = a + 1; b < N; ++b)
	for(c = b + 1; c < N; ++c)
	for(d = c + 1, e = d + ((t = p5[a] + p5[b] + p5[c]) % M); ((s = t + p5[d]) <= max); ++d, ++e)
	{	for(e -= M; p5[e + M] <= s; e += M); /* jump over M=30 values for e>d */
		if(p5[e] == s)
		{	printf("%d %d %d %d %d\r\n", a, b, c, d, e);
			if(find_only_one_solution) goto onexit;
		}
	}
onexit:
	free(p5);
}

int main(void)
{
	int tm = clock();
	compute(250, 0);
	printf("time=%d milliseconds\r\n", (int)((clock() - tm) * 1000 / CLOCKS_PER_SEC));
	return 0;
}

{{output}} The fair way to measure the speed of the code above is to measure it's run time to find all possible solutions to the problem, given N (and not just a single solution, since then the time may depend on the way and the order we organize for-loops).

27 84 110 133 144
time=235 milliseconds

Another test with N=1000 produces the following results:

27 84 110 133 144
54 168 220 266 288
81 252 330 399 432
108 336 440 532 576
135 420 550 665 720
162 504 660 798 864
time=65743 milliseconds

PS: The solution for C++ provided below is actually quite good in its design idea behind. However, with all proposed tricks to speed up, the measurements for C++ solution for N=1000 showed the execution time 81447ms (+23%) on the same environment as above for C solution (same machine, same compiler, 64-bit platform). The reason that C++ solution is a bit slower is, perhaps, the fact that the inner loops over rs have complexity ~N/2 steps in average, while with the modulo 30 trick that complexity can be reduced down to ~N/60 steps, although one "expensive" extra %-operation is still needed.

C++

The simplest brute-force find is already reasonably quick:

#include <iostream>
#include <cmath>
#include <set>
using namespace std;

bool find()
{
	const auto MAX = 250;
	vector<double> pow5(MAX);
	for (auto i = 1; i < MAX; i++)
		pow5[i] = (double)i * i * i * i * i;
	for (auto x0 = 1; x0 < MAX; x0++) {
		for (auto x1 = 1; x1 < x0; x1++) {
			for (auto x2 = 1; x2 < x1; x2++) {
				for (auto x3 = 1; x3 < x2; x3++) {
					auto sum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3];
					if (binary_search(pow5.begin(), pow5.end(), sum))
					{
						cout << x0 << " " << x1 << " " << x2 << " " << x3 << " " << pow(sum, 1.0 / 5.0) << endl;
						return true;
					}
				}
			}
		}
	}
	// not found
	return false;
}

int main(void)
{
	int tm = clock();
	if (!find())
		cout << "Nothing found!\n";
	printf("time=%d milliseconds\r\n", (int)((clock() - tm) * 1000 / CLOCKS_PER_SEC));
	return 0;
}

{{output}}

133 110 84 27 144
time=234 milliseconds

We can accelerate this further by creating a parallel std::set p5s containing the elements of the std::vector pow5, and using it to replace the call to std::binary_search:

	set<double> pow5s;
	for (auto i = 1; i < MAX; i++)
	{
		pow5[i] = (double)i * i * i * i * i;
		pow5s.insert(pow5[i]);
	}
	//...
        if (pow5s.find(sum) != pow5s.end())

This reduces the timing to 125 ms on the same hardware.

A different, more effective optimization is to note that each successive sum is close to the previous one, and use a bidirectional linear search with memory. We also note that inside the innermost loop, we only need to search upward, so we hoist the downward linear search to the loop over x2.

bool find()
{
	const auto MAX = 250;
	vector<double> pow5(MAX);
	for (auto i = 1; i < MAX; i++)
		pow5[i] = (double)i * i * i * i * i;
	auto rs = 5;
	for (auto x0 = 1; x0 < MAX; x0++) {
		for (auto x1 = 1; x1 < x0; x1++) {
			for (auto x2 = 1; x2 < x1; x2++) {
				auto s2 = pow5[x0] + pow5[x1] + pow5[x2];
				while (rs > 0 && pow5[rs] > s2) --rs;
				for (auto x3 = 1; x3 < x2; x3++) {
					auto sum = s2 + pow5[x3];
					while (rs < MAX - 1 && pow5[rs] < sum) ++rs;
					if (pow5[rs] == sum)
					{
						cout << x0 << " " << x1 << " " << x2 << " " << x3 << " " << pow(sum, 1.0 / 5.0) << endl;
						return true;
					}
				}
			}
		}
	}
	// not found
	return false;
}

This reduces the timing to around 25 ms. We could equally well replace rs with an iterator inside pow5; the timing is unaffected.

For comparison with the C code, we also check the timing of an exhaustive search up to MAX=1000. (Don't try this in Python.) This takes 87.2 seconds on the same hardware, comparable to the results found by the C code authors, and supports their conclusion that the mod-30 trick used in the C solution leads to better scalability than the iterator optimizations.

Fortunately, we can incorporate the same trick into the above code, by inserting a forward jump to a feasible solution mod 30 into the loop over x3:

				for (auto x3 = 1; x3 < x2; x3++)
				{
					// go straight to the first appropriate x3, mod 30
					if (int err30 = (x0 + x1 + x2 + x3 - rs) % 30)
						x3 += 30 - err30;
					if (x3 >= x2)
						break;
					auto sum = s2 + pow5[x3];

With this refinement, the exhaustive search up to MAX=1000 takes 16.9 seconds.

Thanks, C guys!

Second version

We can create a more efficient method by using the idea (taken from the EchoLisp listing below) of precomputing difference between pairs of fifth powers. If we combine this with the above idea of using linear search with memory, this still requires asymptotically O(N^4) time (because of the linear search within diffs), but is at least twice as fast as the solution above using the mod-30 trick. Exhaustive search up to MAX=1000 took 6.2 seconds for me (64-bit on 3.4GHz i7). It is not clear how it can be combined with the mod-30 trick.

The asymptotic behavior can be improved to O(N^3 ln N) by replacing the linear search with an increasing-increment "hunt" (and the outer linear search, which is also O(N^4), with a call to std::upper_bound). With this replacement, the first solution was found in 0.05 seconds; exhaustive search up to MAX=1000 took 2.80 seconds; and the second nontrivial solution (discarding multiples of the first solution), at y==2615, was found in 94.6 seconds. Note: there is no solution 2615, because 645^5 + 1523^5 + 1722^5 +2506^5 = 122 280 854 808 884 376, but 2615^5=122 280 854 808 884 375. This is an error due to limitation in mantissa of double type (52 bits). 128 bit type is required for the next solution 85359.

template<class C_, class LT_> C_ Unique(const C_& src, const LT_& less)
{
	C_ retval(src);
	std::sort(retval.begin(), retval.end(), less);
	retval.erase(unique(retval.begin(), retval.end()), retval.end());
	return retval;
}

template<class I_, class P_> I_ HuntFwd(const I_& hint, const I_& end, const P_& less)	// if less(x) is false, then less(x+1) must also be false
{
	I_ retval(hint);
	int step = 1;
	// expanding phase
	while (end - retval > step)
	{
		I_ test = retval + step;
		if (!less(test))
			break;
		retval = test;
		step <<= 1;
	}
	// contracting phase
	while (step > 1)
	{
		step >>= 1;
		if (end - retval <= step)
			continue;
		I_ test = retval + step;
		if (less(test))
			retval = test;
	}
	if (retval != end && less(retval))
		++retval;
	return retval;
}

bool DPFind(int how_many)
{
	const int MAX = 1000;
	vector<double> pow5(MAX);
	for (int i = 1; i < MAX; i++)
		pow5[i] = (double)i * i * i * i * i;
	vector<pair<double, int>> diffs;
	for (int i = 2; i < MAX; ++i)
	{
		for (int j = 1; j < i; ++j)
			diffs.emplace_back(pow5[i] - pow5[j], j);
	}
	auto firstLess = [](const pair<double, int>& lhs, const pair<double, int>& rhs) { return lhs.first < rhs.first; };
	diffs = Unique(diffs, firstLess);

	for (int x4 = 4; x4 < MAX - 1; ++x4)
	{
		for (int x3 = 3; x3 < x4; ++x3)
		{
			// if (133 * x3 == 110 * x4) continue;	// skip duplicates of first solution
			const auto s2 = pow5[x4] + pow5[x3];
			auto pd = upper_bound(diffs.begin() + 1, diffs.end(), make_pair(s2, 0), firstLess) - 1;
			for (int x2 = 2; x2 < x3; ++x2)
			{
				const auto sum = s2 + pow5[x2];
				pd = HuntFwd(pd, diffs.end(), [&](decltype(pd) it){ return it->first < sum; });
				if (pd != diffs.end() && pd->first == sum && pd->second < x3)	// find each solution only once
				{
					const double y = pow(pd->first + pow5[pd->second], 0.2);
					cout << x4 << " " << x3 << " " << x2 << " " << pd->second << " -> " << static_cast<int>(y + 0.5) << "\n";
					if (--how_many <= 0)
						return true;
				}
			}
		}
	}
	return false;
}

Thanks, EchoLisp guys!

C#

{{trans|Java}}

using System;

namespace EulerSumOfPowers {
    class Program {
        const int MAX_NUMBER = 250;

        static void Main(string[] args) {
            bool found = false;
            long[] fifth = new long[MAX_NUMBER];

            for (int i = 1; i <= MAX_NUMBER; i++) {
                long i2 = i * i;
                fifth[i - 1] = i2 * i2 * i;
            }

            for (int a = 0; a < MAX_NUMBER && !found; a++) {
                for (int b = a; b < MAX_NUMBER && !found; b++) {
                    for (int c = b; c < MAX_NUMBER && !found; c++) {
                        for (int d = c; d < MAX_NUMBER && !found; d++) {
                            long sum = fifth[a] + fifth[b] + fifth[c] + fifth[d];
                            int e = Array.BinarySearch(fifth, sum);
                            found = e >= 0;
                            if (found) {
                                Console.WriteLine("{0}^5 + {1}^5 + {2}^5 + {3}^5 = {4}^5", a + 1, b + 1, c + 1, d + 1, e + 1);
                            }
                        }
                    }
                }
            }
        }
    }
}

===Paired Powers, Mod 30, etc...=== {{trans|vbnet}}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;

namespace Euler_cs
{
    class Program
    {
        struct Pair
        {
            public int a, b;
            public Pair(int x, int y)
            {
                a = x; b = y;
            }
        }

        static int min = 1, max = 250;
        static ulong[] p5;
        static SortedDictionary<ulong, Pair>[] sum2 =
                   new SortedDictionary<ulong, Pair>[30];

        static string Fmt(Pair p)
        {
            return string.Format("{0}^5 + {1}^5", p.a, p.b);
        }

        public static void InitM()
        {
            for (int i = 0; i <= 29; i++)
                sum2[i] = new SortedDictionary<ulong, Pair>();
            p5 = new ulong[max + 1];
            p5[min] = Convert.ToUInt64(min) * Convert.ToUInt64(min);
            p5[min] *= p5[min] * Convert.ToUInt64(min);
            for (int i = min; i <= max - 1; i++)
            {
                for (int j = i + 1; j <= max; j++)
                {
                    p5[j] = Convert.ToUInt64(j) * Convert.ToUInt64(j);
                    p5[j] *= p5[j] * Convert.ToUInt64(j);
                    if (j == max) continue;
                    ulong x = p5[i] + p5[j];
                    sum2[x % 30].Add(x, new Pair(i, j));
                }
            }
        }

        static List<string> CalcM(int m)
        {
            List<string> res = new List<string>();
            for (int i = max; i >= min; i--)
            {
                ulong p = p5[i]; int pm = i % 30, mp = (pm - m + 30) % 30;
                foreach (var s in sum2[m].Keys)
                {
                    if (p <= s) break;
                    ulong t = p - s;
                    if (sum2[mp].Keys.Contains(t) && sum2[mp][t].a > sum2[m][s].b)
                        res.Add(string.Format("  {1} + {2} = {0}^5",
                            i, Fmt(sum2[m][s]), Fmt(sum2[mp][t])));
                }
            }
            return res;
        }

        static int Snip(string s)
        {
            int p = s.IndexOf("=") + 1;
            return Convert.ToInt32(s.Substring(p, s.IndexOf("^", p) - p));
        }

        static int CompareRes(string x, string y)
        {
            int res = Snip(x).CompareTo(Snip(y));
            if (res == 0) res = x.CompareTo(y);
            return res;
        }

        static int Validify(int def, string s)
        {
            int res = def, t = 0; int.TryParse(s, out t);
            if (t >= 1 && t < Math.Pow((double)(ulong.MaxValue >> 1), 0.2))
                res = t;
            return res;
        }

        static void Switch(ref int a, ref int b)
        {
            int t = a; a = b; b = t;
        }

        static void Main(string[] args)
        {
            if (args.Count() > 1)
            {
                min = Validify(min, args[0]);
                max = Validify(max, args[1]);
                if (max < min) Switch(ref max, ref min);
            }
            else if (args.Count() == 1)
                max = Validify(max, args[0]);
            Console.WriteLine("Mod 30 shortcut with threading, checking from {0} to {1}...", min, max);
            List<string> res = new List<string>();
            DateTime st = DateTime.Now;
            List<Task<List<string>>> taskList = new List<Task<List<string>>>();
            InitM();
            for (int j = 0; j <= 29; j++)
            {
                var jj = j;
                taskList.Add(Task.Run(() => CalcM(jj)));
            }
            Task.WhenAll(taskList);
            foreach (var item in taskList.Select(t => t.Result))
                res.AddRange(item);
            res.Sort(CompareRes);
            foreach (var item in res)
                Console.WriteLine(item);
            Console.WriteLine("  Computation time to check entire space was {0} seconds",
                (DateTime.Now - st).TotalSeconds);
            if (System.Diagnostics.Debugger.IsAttached)
                Console.ReadKey();
        }
    }
}

{{out}}(no command line arguments)

Mod 30 shortcut with threading, checking from 1 to 250...
27^5 + 84^5 + 110^5 + 133^5 = 144^5
Computation time to check entire space was 0.0838058 seconds

(command line argument = "1000")

Mod 30 shortcut with threading, checking from 1 to 1000...
  27^5 + 84^5 + 110^5 + 133^5 = 144^5
  54^5 + 168^5 + 220^5 + 266^5 = 288^5
  81^5 + 252^5 + 330^5 + 399^5 = 432^5
  108^5 + 336^5 + 440^5 + 532^5 = 576^5
  135^5 + 420^5 + 550^5 + 665^5 = 720^5
  162^5 + 504^5 + 660^5 + 798^5 = 864^5
  Computation time to check entire space was 5.4109744 seconds

Clojure

(ns test-p.core
  (:require [clojure.math.numeric-tower :as math])
  (:require [clojure.data.int-map :as i]))

(defn solve-power-sum [max-value max-sols]
  " Finds solutions by using method approach of EchoLisp
    Large difference is we store a dictionary of all combinations
    of y^5 - x^5 with the x, y value so we can simply lookup rather than have to search "
  (let [pow5 (mapv #(math/expt % 5) (range 0 (* 4 max-value)))                  ; Pow5 = Generate Lookup table for x^5
        y5-x3 (into (i/int-map) (for [x (range 1 max-value)                     ; For x0^5 + x1^5 + x2^5 + x3^5  = y^5
                                      y (range (+ 1 x) (* 4 max-value))]        ; compute y5-x3 = set of all possible differnences
                                  [(- (get pow5 y) (get pow5 x)) [x y]])) ; note: (get pow5 y) is closure for: pow5[y]
        solutions-found (atom 0)]

    (for [x0 (range 1 max-value)                                    ; Search over x0, x1, x2 for sums equal y5-x3
          x1 (range 1 x0)
          x2 (range 1 x1)
          :when (< @solutions-found max-sols)
          :let [sum (apply + (map pow5 [x0 x1 x2]))]         ; compute sum of items to the 5th power
          :when (contains? y5-x3 sum)]                       ; check if sum is in set of differences
      (do
        (swap! solutions-found inc)                          ; increment counter for solutions found
        (concat [x0 x1 x2] (get y5-x3 sum))))))              ; create result (since in set of differences)

; Output results with numbers in ascending order placing results into a set (i.e. #{}) so duplicates are discarded
                                                            ; CPU i7 920 Quad Core @2.67 GHz clock Windows 10
(println (into #{} (map sort (solve-power-sum 250 1))))   ; MAX = 250, find only 1 value: Duration was 0.26 seconds
(println (into #{} (map sort (solve-power-sum 1000 1000))));MAX = 1000, high max-value so all solutions found: Time = 4.8 seconds

Output

1st Solution with MAX = 250 (Solution Time: 260 ms CPU i7 920 Quad Core)
#{(27 84 110 133 144))

All Solutions with MAX = 1000 (Solution Time: 4.8 seconds CPU i7 920 Quad Core)
#{(27 84 110 133 144)
(162 504 660 798 864)
(135 420 550 665 720)
(108 336 440 532 576)
(189 588 770 931 1008)
(54 168 220 266 288)
(81 252 330 399 432)}

COBOL

       IDENTIFICATION DIVISION.
       PROGRAM-ID. EULER.
       DATA DIVISION.
       FILE SECTION.
       WORKING-STORAGE SECTION.
       1   TABLE-LENGTH CONSTANT 250.
       1   SEARCHING-FLAG     PIC 9.
        88  FINISHED-SEARCHING VALUE IS 1
                               WHEN SET TO FALSE IS 0.
       1  CALC.
        3  A               PIC 999 USAGE COMPUTATIONAL-5.
        3  B               PIC 999 USAGE COMPUTATIONAL-5.
        3  C               PIC 999 USAGE COMPUTATIONAL-5.
        3  D               PIC 999 USAGE COMPUTATIONAL-5.
        3  ABCD            PIC 9(18) USAGE COMPUTATIONAL-5.
        3  FIFTH-ROOT-OFFS PIC 999 USAGE COMPUTATIONAL-5.
        3  POWER-COUNTER   PIC 999 USAGE COMPUTATIONAL-5.
        88 POWER-MAX       VALUE TABLE-LENGTH.

       1   PRETTY.
        3  A               PIC ZZ9.
        3  FILLER          VALUE "^5 + ".
        3  B               PIC ZZ9.
        3  FILLER          VALUE "^5 + ".
        3  C               PIC ZZ9.
        3  FILLER          VALUE "^5 + ".
        3  D               PIC ZZ9.
        3  FILLER          VALUE "^5 = ".
        3  FIFTH-ROOT-OFFS PIC ZZ9.
        3  FILLER          VALUE "^5.".

       1   FIFTH-POWER-TABLE   OCCURS TABLE-LENGTH TIMES
                               ASCENDING KEY IS FIFTH-POWER
                               INDEXED BY POWER-INDEX.
        3  FIFTH-POWER PIC 9(18) USAGE COMPUTATIONAL-5.


       PROCEDURE DIVISION.
       MAIN-PARAGRAPH.
           SET FINISHED-SEARCHING TO FALSE.
           PERFORM POWERS-OF-FIVE-TABLE-INIT.
           PERFORM VARYING
               A IN CALC
               FROM 1 BY 1 UNTIL A IN CALC = TABLE-LENGTH

               AFTER B IN CALC
               FROM 1 BY 1 UNTIL B IN CALC = A IN CALC

               AFTER C IN CALC
               FROM 1 BY 1 UNTIL C IN CALC = B IN CALC

               AFTER D IN CALC
               FROM 1 BY 1 UNTIL D IN CALC = C IN CALC

               IF FINISHED-SEARCHING
                   STOP RUN
               END-IF

               PERFORM POWER-COMPUTATIONS

           END-PERFORM.

       POWER-COMPUTATIONS.

           MOVE ZERO TO ABCD IN CALC.

           ADD FIFTH-POWER(A IN CALC)
               FIFTH-POWER(B IN CALC)
               FIFTH-POWER(C IN CALC)
               FIFTH-POWER(D IN CALC)
                   TO ABCD IN CALC.

           SET POWER-INDEX TO 1.

           SEARCH ALL FIFTH-POWER-TABLE
               WHEN FIFTH-POWER(POWER-INDEX) = ABCD IN CALC
                      MOVE POWER-INDEX TO FIFTH-ROOT-OFFS IN CALC
                      MOVE CORRESPONDING CALC TO PRETTY
                      DISPLAY PRETTY END-DISPLAY
                      SET FINISHED-SEARCHING TO TRUE
           END-SEARCH

           EXIT PARAGRAPH.

       POWERS-OF-FIVE-TABLE-INIT.
           PERFORM VARYING POWER-COUNTER FROM 1 BY 1 UNTIL POWER-MAX
               COMPUTE FIFTH-POWER(POWER-COUNTER) =
                   POWER-COUNTER *
                   POWER-COUNTER *
                   POWER-COUNTER *
                   POWER-COUNTER *
                   POWER-COUNTER
               END-COMPUTE
           END-PERFORM.
           EXIT PARAGRAPH.

       END PROGRAM EULER.

Output

133^5 + 110^5 +  84^5 +  27^5 = 144^5.

Common Lisp

(ql:quickload :alexandria)
(let ((fifth-powers (mapcar #'(lambda (x) (expt x 5))
                            (alexandria:iota 250))))
  (loop named outer for x0 from 1 to (length fifth-powers) do
    (loop for x1 from 1 below x0 do
      (loop for x2 from 1 below x1 do
        (loop for x3 from 1 below x2 do
          (let ((x-sum (+ (nth x0 fifth-powers)
                          (nth x1 fifth-powers)
                          (nth x2 fifth-powers)
                          (nth x3 fifth-powers))))
            (if (member x-sum fifth-powers)
                  (return-from outer (list x0 x1 x2 x3 (round (expt x-sum 0.2)))))))))))

{{out}}

(133 110 84 27 144)

D

First version

{{trans|Rust}}

import std.stdio, std.range, std.algorithm, std.typecons;

auto eulersSumOfPowers() {
    enum maxN = 250;
    auto pow5 = iota(size_t(maxN)).map!(i => ulong(i) ^^ 5).array.assumeSorted;

    foreach (immutable x0; 1 .. maxN)
        foreach (immutable x1; 1 .. x0)
            foreach (immutable x2; 1 .. x1)
                foreach (immutable x3; 1 .. x2) {
                    immutable powSum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3];
                    if (pow5.contains(powSum))
                        return tuple(x0, x1, x2, x3, pow5.countUntil(powSum));
                }
    assert(false);
}

void main() {
    writefln("%d^5 + %d^5 + %d^5 + %d^5 == %d^5", eulersSumOfPowers[]);
}

{{out}}

133^5 + 110^5 + 84^5 + 27^5 == 144^5

Run-time about 0.64 seconds. A Range-based Haskell-like solution is missing because of Issue 14833.

Second version

{{trans|Python}}

void main() {
    import std.stdio, std.range, std.algorithm, std.typecons;

    enum uint MAX = 250;
    uint[ulong] p5;
    Tuple!(uint, uint)[ulong] sum2;

    foreach (immutable i; 1 .. MAX) {
        p5[ulong(i) ^^ 5] = i;
        foreach (immutable j; i .. MAX)
            sum2[ulong(i) ^^ 5 + ulong(j) ^^ 5] = tuple(i, j);
    }

    const sk = sum2.keys.sort().release;
    foreach (p; p5.keys.sort())
        foreach (immutable s; sk) {
            if (p <= s)
                break;
            if (p - s in sum2) {
                writeln(p5[p], " ", tuple(sum2[s][], sum2[p - s][]));
                return; // Finds first only.
            }
        }
}

{{out}}

144 Tuple!(uint, uint, uint, uint)(27, 84, 110, 133)

Run-time about 0.10 seconds.

Third version

{{trans|C++}} This solution is a brutal translation of the iterator-based C++ version, and it should be improved to use more idiomatic D Ranges.

import core.stdc.stdio, std.typecons, std.math, std.algorithm, std.range;

alias Pair = Tuple!(double, int);
alias PairPtr = Pair*;

// If less(x) is false, then less(x + 1) must also be false.
PairPtr huntForward(Pred)(PairPtr hint, const PairPtr end, const Pred less) pure nothrow @nogc {
    PairPtr result = hint;
    int step = 1;

    // Expanding phase.
    while (end - result > step) {
        PairPtr test = result + step;
        if (!less(test))
            break;
        result = test;
        step <<= 1;
    }

    // Contracting phase.
    while (step > 1) {
        step >>= 1;
        if (end - result <= step)
            continue;
        PairPtr test = result + step;
        if (less(test))
            result = test;
    }
    if (result != end && less(result))
        ++result;
    return result;
}


bool dPFind(int how_many) nothrow {
    enum MAX = 1_000;

    double[MAX] pow5;
    foreach (immutable i; 1 .. MAX)
        pow5[i] = double(i) ^^ 5;

    Pair[] diffs0; // Will contain (MAX-1) * (MAX-2) / 2 pairs.
    foreach (immutable i; 2 .. MAX)
        foreach (immutable j; 1 .. i)
            diffs0 ~= Pair(pow5[i] - pow5[j], j);

    // Remove pairs with duplicate first items.
    diffs0.length -= diffs0.sort!q{ a[0] < b[0] }.uniq.copy(diffs0).length;
    auto diffs = diffs0.assumeSorted!q{ a[0] < b[0] };

    foreach (immutable x4; 4 .. MAX - 1) {
        foreach (immutable x3; 3 .. x4) {
            immutable s2 = pow5[x4] + pow5[x3];
            auto pd0 = diffs[1 .. $].upperBound(Pair(s2, 0));
            PairPtr pd = &pd0[0] - 1;
            foreach (immutable x2; 2 .. x3) {
                immutable sum = s2 + pow5[x2];
                const PairPtr endPtr = &diffs[$ - 1] + 1;
                // This lambda heap-allocates.
                pd = huntForward(pd, endPtr, (in PairPtr p) pure => (*p)[0] < sum);
                if (pd != endPtr && (*pd)[0] == sum && (*pd)[1] < x3) { // Find each solution only once.
                    immutable y = ((*pd)[0] + pow5[(*pd)[1]]) ^^ 0.2;
                    printf("%d %d %d %d : %d\n", x4, x3, x2, (*pd)[1], cast(int)(y + 0.5));
                    if (--how_many <= 0)
                        return true;
                }
            }
        }
    }

    return false;
}


void main() nothrow {
    if (!dPFind(100))
        printf("Search finished.\n");
}

{{out}}

133 110 27 84 : 144
133 110 84 27 : 144
266 220 54 168 : 288
266 220 168 54 : 288
399 330 81 252 : 432
399 330 252 81 : 432
532 440 108 336 : 576
532 440 336 108 : 576
665 550 135 420 : 720
665 550 420 135 : 720
798 660 162 504 : 864
798 660 504 162 : 864
Search finished.

Run-time about 7.1 seconds.

EchoLisp

To speed up things, we search for x0, x1, x2 such as x0^5 + x1^5 + x2^5 = a difference of 5-th powers.

(define dim 250)

;; speed up n^5
(define (p5 n) (* n n n n n))
(remember 'p5) ;; memoize

;; build vector of all  y^5 - x^5 diffs - length 30877
(define all-y^5-x^5
	(for*/vector
		[(x (in-range 1 dim))  (y (in-range (1+ x) dim))]
		(- (p5 y) (p5 x))))

;; sort to use vector-search
(begin (vector-sort! <  all-y^5-x^5) 'sorted)

 ;; find couple (x y) from y^5 - x^5
(define (x-y y^5-x^5)
	(for*/fold (x-y null)
	[(x (in-range 1 dim)) (y (in-range (1+ x ) dim))]
		(when
			(= (- (p5 y) (p5 x)) y^5-x^5)
			(set! x-y (list x y))
			(break #t)))) ; stop on first

;; search
(for*/fold  (sol null)
	[(x0 (in-range 1 dim)) (x1 (in-range (1+ x0) dim)) (x2 (in-range (1+ x1) dim))]
	(set! sol (+ (p5 x0) (p5 x1) (p5 x2)))
 	(when
 		(vector-search sol all-y^5-x^5)  ;; x0^5 + x1^5 + x2^5 = y^5 - x3^5 ???
 		(set! sol (append (list x0 x1 x2) (x-y  sol))) ;; found
 		(break #t))) ;; stop on first

  →   (27 84 110 133 144) ;; time 2.8 sec

Elixir

{{trans|Ruby}}

defmodule Euler do
  def sum_of_power(max \\ 250) do
    {p5, sum2} = setup(max)
    sk = Enum.sort(Map.keys(sum2))
    Enum.reduce(Enum.sort(Map.keys(p5)), Map.new, fn p,map ->
      sum(sk, p5, sum2, p, map)
    end)
  end

  defp setup(max) do
    Enum.reduce(1..max, {%{}, %{}}, fn i,{p5,sum2} ->
      i5 = i*i*i*i*i
      add = for j <- i..max, into: sum2, do: {i5 + j*j*j*j*j, [i,j]}
      {Map.put(p5, i5, i), add}
    end)
  end

  defp sum([], _, _, _, map), do: map
  defp sum([s|_], _, _, p, map) when p<=s, do: map
  defp sum([s|t], p5, sum2, p, map) do
    if sum2[p - s],
      do:   sum(t, p5, sum2, p, Map.put(map, Enum.sort(sum2[s] ++ sum2[p-s]), p5[p])),
      else: sum(t, p5, sum2, p, map)
  end
end

Enum.each(Euler.sum_of_power, fn {k,v} ->
  IO.puts Enum.map_join(k, " + ", fn i -> "#{i}**5" end) <> " = #{v}**5"
end)

{{out}}

27**5 + 84**5 + 110**5 + 133**5 = 144**5

ERRE

PROGRAM EULERO

CONST MAX=250

!$DOUBLE

FUNCTION POW5(X)
    POW5=X*X*X*X*X
END FUNCTION

!$INCLUDE="PC.LIB"

BEGIN
   CLS
   FOR X0=1 TO MAX DO
     FOR X1=1 TO X0 DO
        FOR X2=1 TO X1 DO
           FOR X3=1 TO X2 DO
              LOCATE(3,1) PRINT(X0;X1;X2;X3)
              SUM=POW5(X0)+POW5(X1)+POW5(X2)+POW5(X3)
              S1=INT(SUM^0.2#+0.5#)
              IF SUM=POW5(S1) THEN PRINT(X0,X1,X2,X3,S1) END IF
           END FOR
        END FOR
     END FOR
   END FOR
END PROGRAM

{{output}}

133 110 84 27 144

=={{header|F_Sharp|F#}}==

//Find 4 integers whose 5th powers sum to the fifth power of an integer (Quickly!) - Nigel Galloway: April 23rd., 2015
let G =
  let GN = Array.init<float> 250 (fun n -> (float n)**5.0)
  let rec gng (n, i, g, e) =
    match (n, i, g, e) with
    | (250,_,_,_) -> "No Solution Found"
    | (_,250,_,_) -> gng (n+1, n+1, n+1, n+1)
    | (_,_,250,_) -> gng (n, i+1, i+1, i+1)
    | (_,_,_,250) -> gng (n, i, g+1, g+1)
    | _ -> let l = GN.[n] + GN.[i] + GN.[g] + GN.[e]
           match l with
           | _ when l > GN.[249]           -> gng(n,i,g+1,g+1)
           | _ when l = round(l**0.2)**5.0 -> sprintf "%d**5 + %d**5 + %d**5 + %d**5 = %d**5" n i g e (int (l**0.2))
           | _                             -> gng(n,i,g,e+1)
  gng (1, 1, 1, 1)

{{out}}

"27**5 + 84**5 + 110**5 + 133**5 = 144**5"

Factor

This solution uses Factor's backtrack vocabulary (based on continuations) to simplify the reduction of the search space. Each time xn is called, a new summand is introduced which can only take on a value as high as the previous summand - 1. This also creates a checkpoint for the backtracker. fail causes the backtracking to occur.

USING: arrays backtrack kernel literals math.functions
math.ranges prettyprint sequences ;

CONSTANT: pow5 $[ 0 250 [a,b) [ 5 ^ ] map ]

: xn ( n1 -- n2 n2 ) [1,b) amb-lazy dup ;

250 xn xn xn xn drop 4array dup pow5 nths sum dup pow5
member? [ pow5 index suffix . ] [ 2drop fail ] if

{{out}}

{ 133 110 84 27 144 }

Forth

{{trans|Go}}

: sq  dup * ;
: 5^  dup sq sq * ;

create pow5 250 cells allot
:noname
   250 0 DO  i 5^  pow5 i cells + !  LOOP ; execute

: @5^  cells pow5 + @ ;

: solution? ( n -- n )
   pow5 250 cells bounds DO
      dup i @ = IF  drop i pow5 - cell / unloop EXIT  THEN
   cell +LOOP drop 0 ;

\ GFORTH only provides 2 index variables: i, j
\ so the code creates locals for two outer loop vars, k & l

: euler  ( -- )
   250 4 DO i { l }
      l 3 DO i { k }
         k 2 DO
            i 1 DO
               i @5^ j @5^ + k @5^ + l @5^ + solution?
               dup IF
                  l . k . j . i . . cr
                  unloop unloop unloop unloop EXIT
               ELSE
                  drop
               THEN
            LOOP
         LOOP
      LOOP
   LOOP ;

euler
bye

{{out}}

$ gforth-fast ./euler.fs
133 110 84 27 144

Fortran

FORTRAN IV

To solve this problem, we must handle integers up 2505 ~= 9.8*1011 . So we need integers with at less 41 bits. In 1966 all Fortrans were not equal. On IBM360, INTEGER was a 32-bit integer; on CDC6600, INTEGER was a 60-bit integer. And Leon J. Lander and Thomas R. Parkin used the CDC6600.

C EULER SUM OF POWERS CONJECTURE - FORTRAN IV
C FIND I1,I2,I3,I4,I5 : I1**5+I2**5+I3**5+I4**5=I5**5
      INTEGER I,P5(250),SUMX
      MAXN=250
      DO 1 I=1,MAXN
   1  P5(I)=I**5
      DO 6 I1=1,MAXN
      DO 6 I2=1,MAXN
      DO 6 I3=1,MAXN
      DO 6 I4=1,MAXN
      SUMX=P5(I1)+P5(I2)+P5(I3)+P5(I4)
      I5=1
   2  IF(I5-MAXN) 3,3,6
   3  IF(P5(I5)-SUMX) 5,4,6
   4  WRITE(*,300) I1,I2,I3,I4,I5
      STOP
   5  I5=I5+1
      GOTO 2
   6  CONTINUE
 300  FORMAT(5(1X,I3))
      END

{{out}}

  27  84 110 133 144

Fortran 95

{{works with|Fortran|95 and later}}

program sum_of_powers
  implicit none

  integer, parameter :: maxn = 249
  integer, parameter :: dprec = selected_real_kind(15)
  integer :: i, x0, x1, x2, x3, y
  real(dprec) :: n(maxn), sumx

  n = (/ (real(i, dprec)**5, i = 1, maxn) /)

outer: do x0 = 1, maxn
         do x1 = 1, maxn
           do x2 = 1, maxn
             do x3 = 1, maxn
               sumx = n(x0)+ n(x1)+ n(x2)+ n(x3)
               y = 1
               do while(y <= maxn .and. n(y) <= sumx)
                 if(n(y) == sumx) then
                   write(*,*) x0, x1, x2, x3, y
                   exit outer
                 end if
                 y = y + 1
               end do
             end do
           end do
         end do
       end do outer

end program

{{out}}

          27          84         110         133         144

FreeBASIC

' version 14-09-2015
' compile with: fbc -s console

' some constants calculated when the program is compiled

Const As UInteger max = 250
Const As ULongInt pow5_max = CULngInt(max) * max * max * max * max
' limit x1, x2, x3
Const As UInteger limit_x1 = (pow5_max / 4) ^ 0.2
Const As UInteger limit_x2 = (pow5_max / 3) ^ 0.2
Const As UInteger limit_x3 = (pow5_max / 2) ^ 0.2

' ------=< MAIN >=------

Dim As ULongInt pow5(max), ans1, ans2, ans3
Dim As UInteger x1, x2, x3, x4, x5 , m1, m2

Cls : Print

For x1 = 1 To max
    pow5(x1) = CULngInt(x1) * x1 * x1 * x1 * x1
Next x1

For x1 = 1 To limit_x1
    For x2 = x1 +1 To limit_x2
        m1 = x1 + x2
        ans1 = pow5(x1) + pow5(x2)
        If ans1 > pow5_max Then Exit For
        For x3 = x2 +1 To limit_x3
            ans2 = ans1 + pow5(x3)
            If ans2 > pow5_max Then Exit For
            m2 = (m1 + x3) Mod 30
            If m2 = 0 Then m2 = 30
            For x4 = x3 +1 To max -1
                ans3 = ans2 + pow5(x4)
                If ans3 > pow5_max Then Exit For
                For x5 = x4 + m2 To max Step 30
                    If ans3 < pow5(x5) Then Exit For
                    If ans3 = pow5(x5) Then
                        Print x1; "^5 + "; x2; "^5 + "; x3; "^5 + "; _
                              x4; "^5 = "; x5; "^5"
                        Exit For, For
                    EndIf
                Next x5
            Next x4
        Next x3
    Next x2
Next x1

Print
Print "done"

' empty keyboard buffer
While Inkey <> "" : Wend
Print : Print "hit any key to end program"
Sleep
End

{{out}}

27^5 + 84^5 + 110^5 + 133^5 = 144^5

Go

{{trans|Python}}

package main

import (
	"fmt"
	"log"
)

func main() {
	fmt.Println(eulerSum())
}

func eulerSum() (x0, x1, x2, x3, y int) {
	var pow5 [250]int
	for i := range pow5 {
		pow5[i] = i * i * i * i * i
	}
	for x0 = 4; x0 < len(pow5); x0++ {
		for x1 = 3; x1 < x0; x1++ {
			for x2 = 2; x2 < x1; x2++ {
				for x3 = 1; x3 < x2; x3++ {
					sum := pow5[x0] +
						pow5[x1] +
						pow5[x2] +
						pow5[x3]
					for y = x0 + 1; y < len(pow5); y++ {
						if sum == pow5[y] {
							return
						}
					}
				}
			}
		}
	}
	log.Fatal("no solution")
	return
}

{{output}}

133 110 84 27 144

Haskell

import Data.List
import Data.List.Ordered

main :: IO ()
main = print $ head [(x0,x1,x2,x3,x4) |
                                        -- choose x0, x1, x2, x3
                                        -- so that 250 < x3 < x2 < x1 < x0
                                        x3 <- [1..250-1],
                                        x2 <- [1..x3-1],
                                        x1 <- [1..x2-1],
                                        x0 <- [1..x1-1],

                                        let p5Sum = x0^5 + x1^5 + x2^5 + x3^5,

                                        -- lazy evaluation of powers of 5
                                        let p5List = [i^5|i <- [1..]],

                                        -- is sum a power of 5 ?
                                        member p5Sum p5List,

                                        -- which power of 5 is sum ?
                                        let Just x4 = elemIndex p5Sum p5List ]

{{output}}

(27,84,110,133,144)

Or, using dictionaries of powers and sums, and thus rather faster: {{Trans|Python}}

import qualified Data.Map.Strict as M
import Data.List (find, intercalate)
import Data.Maybe (maybe)

iFrom, iTo :: Int
iFrom = 1

iTo = 249

xs :: [Int]
xs = [iFrom .. iTo]

powerMap :: M.Map Int Int
powerMap = M.fromList (zip ((^ 5) <$> xs) xs)

sumMap :: M.Map Int (Int, Int)
sumMap =
  M.fromList
    [ ((x ^ 5) + (y ^ 5), (x, y))
    | x <- xs
    , y <- tail xs
    , x > y ]

mbExample :: Maybe (Int, Int)
mbExample =
  find
    (\(p, s) -> M.member (p - s) sumMap)
    (M.keys powerMap >>=
     (\p -> takeWhile (< p) (M.keys sumMap) >>= (\s -> [(p, s)])))

showExample :: (Int, Int) -> String
showExample (p, s) =
  let (a, b) = sumMap M.! (p - s)
      (c, d) = sumMap M.! s
  in "a counter-example in range " ++
     rangeString xs ++
     ":\n\n" ++
     intercalate "^5 + " (show <$> [a, b, c, d]) ++
     "^5 = " ++ show (powerMap M.! p) ++ "^5"

rangeString :: [Int] -> String
rangeString [] = "[]"
rangeString (x:xs) = '[' : show x ++ " .. " ++ show (last xs) ++ "]"

main :: IO ()
main =
  putStrLn $
  "Euler's sum of powers conjecture – " ++
  maybe
    ("no counter-example found in the range " ++ rangeString xs)
    showExample
    mbExample

{{Out}}

Euler's sum of powers conjecture – a counter-example in range [1 .. 249]:

133^5 + 110^5 + 84^5 + 27^5 = 144^5

J

   require 'stats'
   (#~ (= <.)@((+/"1)&.:(^&5)))1+4 comb 248
27 84 110 133

Explanation:

 finds all the possibilities for our four arguments.

Then,
```J
(#~ (= <.)@((+/"1)&.:(^&5)))

discards the cases we are not interested in. (It only keeps the case(s) where the fifth root of the sum of the fifth powers is an integer.)

Only one possibility remains.

Here's a significantly faster approach (about 100 times faster), based on the echolisp implementation:

find5=:3 :0
  y=. 250
  n=. i.y
  p=. n^5
  a=. (#~ 0&<),-/~p
  s=. /:~a
  l=. (i.*:y)(#~ 0&<),-/~p
  c=. 3 comb <.5%:(y^5)%4
  t=. +/"1 c{p
  x=. (t e. s)#t
  |.,&<&~./|:(y,y)#:l#~a e. x
)

Use:

   find5''
┌─────────────┬───┐
│27 84 110 133│144│
└─────────────┴───┘

Note that this particular implementation is a bit hackish, since it relies on the solution being unique for the range of numbers being considered. If there were more solutions it would take a little extra code (though not much time) to untangle them.

Java

{{trans|ALGOL 68}} Tested with Java 6.

public class eulerSopConjecture
{

    static final int    MAX_NUMBER = 250;

    public static void main( String[] args )
    {
        boolean found = false;
        long[]  fifth = new long[ MAX_NUMBER ];

        for( int i = 1; i <= MAX_NUMBER; i ++ )
        {
            long i2 =  i * i;
            fifth[ i - 1 ] = i2 * i2 * i;
        } // for i

        for( int a = 0; a < MAX_NUMBER && ! found ; a ++ )
        {
            for( int b = a; b < MAX_NUMBER && ! found ; b ++ )
            {
                for( int c = b; c < MAX_NUMBER && ! found ; c ++ )
                {
                    for( int d = c; d < MAX_NUMBER && ! found ; d ++ )
                    {
                        long sum  = fifth[a] + fifth[b] + fifth[c] + fifth[d];
                        int  e = java.util.Arrays.binarySearch( fifth, sum );
                        found  = ( e >= 0 );
                        if( found )
                        {
                            // the value at e is a fifth power
                            System.out.print( (a+1) + "^5 + "
                                            + (b+1) + "^5 + "
                                            + (c+1) + "^5 + "
                                            + (d+1) + "^5 = "
                                            + (e+1) + "^5"
                                            );
                        } // if found;;
                    } // for d
                } // for c
            } // for b
        } // for a
    } // main

} // eulerSopConjecture

Output:

27^5 + 84^5 + 110^5 + 133^5 = 144^5

JavaScript

ES5

var eulers_sum_of_powers = function (iMaxN) {

    var aPow5 = [];
    var oPow5ToN = {};

    for (var iP = 0; iP <= iMaxN; iP++) {
        var iPow5 = Math.pow(iP, 5);
        aPow5.push(iPow5);
        oPow5ToN[iPow5] = iP;
    }

    for (var i0 = 1; i0 <= iMaxN; i0++) {
        for (var i1 = 1; i1 <= i0; i1++) {
            for (var i2 = 1; i2 <= i1; i2++) {
                for (var i3 = 1; i3 <= i2; i3++) {
                    var iPow5Sum = aPow5[i0] + aPow5[i1] + aPow5[i2] + aPow5[i3];
                    if (typeof oPow5ToN[iPow5Sum] != 'undefined') {
                        return {
                            i0: i0,
                            i1: i1,
                            i2: i2,
                            i3: i3,
                            iSum: oPow5ToN[iPow5Sum]
                        };
                    }
                }
            }
        }
    }

};

var oResult = eulers_sum_of_powers(250);

console.log(oResult.i0 + '^5 + ' + oResult.i1 + '^5 + ' + oResult.i2 +
    '^5 + ' + oResult.i3 + '^5 = ' + oResult.iSum + '^5');

{{Out}} 133^5 + 110^5 + 84^5 + 27^5 = 144^5 '''This'''{{trans|D}} that verify: a^5 + b^5 + c^5 + d^5 = x^5

var N=1000, first=false
var ns={}, npv=[]
for (var n=0; n<=N; n++) {
	var np=Math.pow(n,5); ns[np]=n; npv.push(np)
}
loop:
for (var a=1;   a<=N; a+=1)
for (var b=a+1; b<=N; b+=1)
for (var c=b+1; c<=N; c+=1)
for (var d=c+1; d<=N; d+=1) {
	var x = ns[ npv[a]+npv[b]+npv[c]+npv[d] ]
	if (!x) continue
	print( [a, b, c, d, x] )
	if (first) break loop
}
function print(c) {
	var e='<sup>5</sup>', ep=e+' + '
	document.write(c[0], ep, c[1], ep, c[2], ep, c[3], e, ' = ', c[4], e, '
')
}

'''Or this'''{{trans|C}} that verify: a^5 + b^5 + c^5 + d^5 = x^5

var N=1000, first=false
var npv=[], M=30 // x^5 == x modulo M (=2*3*5)
for (var n=0; n<=N; n+=1) npv[n]=Math.pow(n, 5)
var mx=1+npv[N]; while(n<=N+M) npv[n++]=mx

loop:
for (var a=1;   a<=N; a+=1)
for (var b=a+1; b<=N; b+=1)
for (var c=b+1; c<=N; c+=1)
for (var t=npv[a]+npv[b]+npv[c], d=c+1, x=t%M+d; (n=t+npv[d])<mx; d+=1, x+=1) {
	while (npv[x]<=n) x+=M; x-=M // jump over M=30 values for x>d
	if (npv[x] != n) continue
	print( [a, b, c, d, x] )
	if (first) break loop;
}
function print(c) {
	var e='<sup>5</sup>', ep=e+' + '
	document.write(c[0], ep, c[1], ep, c[2], ep, c[3], e, ' = ', c[4], e, '
')
}

'''Or this'''{{trans|EchoLisp}} that verify: a^5 + b^5 + c^5 = x^5 - d^5

var N=1000, first=false
var dxs={}, pow=Math.pow
for (var d=1; d<=N; d+=1)
	for (var dp=pow(d,5), x=d+1; x<=N; x+=1)
		dxs[pow(x,5)-dp]=[d,x]
loop:
for (var a=1; a<N; a+=1)
for (var ap=pow(a,5), b=a+1; b<N; b+=1)
for (var abp=ap+pow(b,5), c=b+1; c<N; c+=1) {
	var dx = dxs[ abp+pow(c,5) ]
	if (!dx || c >= dx[0]) continue
	print( [a, b, c].concat( dx ) )
	if (first) break loop
}
function print(c) {
	var e='<sup>5</sup>', ep=e+' + '
	document.write(c[0], ep, c[1], ep, c[2], ep, c[3], e, ' = ', c[4], e, '
')
}

'''Or this'''{{trans|Python}} that verify: a^5 + b^5 = x^5 - (c^5 + d^5)

var N=1000, first=false
var is={}, ipv=[], ijs={}, ijpv=[], pow=Math.pow
for (var i=1; i<=N; i+=1) {
	var ip=pow(i,5); is[ip]=i; ipv.push(ip)
	for (var j=i+1; j<=N; j+=1) {
		var ijp=ip+pow(j,5); ijs[ijp]=[i,j]; ijpv.push(ijp)
	}
}
ijpv.sort( function (a,b) {return a - b } )
loop:
for (var i=0, ei=ipv.length; i<ei; i+=1)
for (var xp=ipv[i], j=0, je=ijpv.length; j<je; j+=1) {
	var cdp = ijpv[j]
	if (cdp >= xp) break
	var cd = ijs[xp-cdp]
	if (!cd) continue
	var ab = ijs[cdp]
	if (ab[1] >= cd[0]) continue
	print( [].concat(ab, cd, is[xp]) )
	if (first) break loop
}
function print(c) {
	var e='<sup>5</sup>', ep=e+' + '
	document.write(c[0], ep, c[1], ep, c[2], ep, c[3], e, ' = ', c[4], e, '
')
}

{{incorrect|lang ES6}} {{output}} 27⁵ + 84⁵ + 110⁵ + 133 = 144⁵ 54⁵ + 168⁵ + 220⁵ + 266 = 288⁵ 81⁵ + 252⁵ + 330⁵ + 399 = 432⁵ 108⁵ + 336⁵ + 440⁵ + 532 = 576⁵ 135⁵ + 420⁵ + 550⁵ + 665 = 720⁵ 162⁵ + 504⁵ + 660⁵ + 798 = 864⁵

ES6

=Procedural=

(() => {
    'use strict';

    const eulersSumOfPowers = intMax => {
        const
            pow = Math.pow,
            xs = range(0, intMax)
            .map(x => pow(x, 5)),
            dct = xs.reduce((a, x, i) =>
                (a[x] = i,
                    a
                ), {});

        for (let a = 1; a <= intMax; a++) {
            for (let b = 2; b <= a; b++) {
                for (let c = 3; c <= b; c++) {
                    for (let d = 4; d <= c; d++) {
                        const sumOfPower = dct[xs[a] + xs[b] + xs[c] + xs[d]];
                        if (sumOfPower !== undefined) {
                            return [a, b, c, d, sumOfPower];
                        }
                    }
                }
            }
        }
        return undefined;
    };

    // range :: Int -> Int -> [Int]
    const range = (m, n) =>
        Array.from({
            length: Math.floor(n - m) + 1
        }, (_, i) => m + i);

    // TEST
    const soln = eulersSumOfPowers(250);
    return soln ? soln.slice(0, 4)
        .map(x => `${x}^5`)
        .join(' + ') + ` = ${soln[4]}^5` : 'No solution found.'

})();

{{Out}}

133^5 + 110^5 + 84^5 + 27^5 = 144^5

=Functional=

Using dictionaries of powers and sums, and a little faster than the procedural version above: {{Trans|Python}} {{Trans|Haskell}}

(() => {
    'use strict';

    const main = () => {

        const
            iFrom = 1,
            iTo = 249,
            xs = enumFromTo(1, 249),
            p5 = x => Math.pow(x, 5);

        const
            // powerMap :: Dict Int Int
            powerMap = mapFromList(
                zip(map(p5, xs), xs)
            ),
            // sumMap :: Dict Int (Int, Int)
            sumMap = mapFromList(
                bind(
                    xs,
                    x => bind(
                        tail(xs),
                        y => Tuple(
                            p5(x) + p5(y),
                            Tuple(x, y)
                        )
                    )
                )
            );

        // mbExample :: Maybe (Int, Int)
        const mbExample = find(
            tpl => member(fst(tpl) - snd(tpl), sumMap),
            bind(
                map(x => parseInt(x, 10),
                    keys(powerMap)
                ),
                p => bind(
                    takeWhile(
                        x => x < p,
                        map(x => parseInt(x, 10),
                            keys(sumMap)
                        )
                    ),
                    s => [Tuple(p, s)]
                )
            )
        );

        // showExample :: (Int, Int) -> String
        const showExample = tpl => {
            const [p, s] = Array.from(tpl);
            const [a, b] = Array.from(sumMap[p - s]);
            const [c, d] = Array.from(sumMap[s]);
            return 'Counter-example found:\n' + intercalate(
                '^5 + ',
                map(str, [a, b, c, d])
            ) + '^5 = ' + str(powerMap[p]) + '^5';
        };

        return maybe(
            'No counter-example found',
            showExample,
            mbExample
        );
    };

    // GENERIC FUNCTIONS ----------------------------------

    // Just :: a -> Maybe a
    const Just = x => ({
        type: 'Maybe',
        Nothing: false,
        Just: x
    });

    // Nothing :: Maybe a
    const Nothing = () => ({
        type: 'Maybe',
        Nothing: true,
    });

    // Tuple (,) :: a -> b -> (a, b)
    const Tuple = (a, b) => ({
        type: 'Tuple',
        '0': a,
        '1': b,
        length: 2
    });

    // bind (>>=) :: [a] -> (a -> [b]) -> [b]
    const bind = (xs, mf) => [].concat.apply([], xs.map(mf));

    // concat :: [[a]] -> [a]
    // concat :: [String] -> String
    const concat = xs =>
        0 < xs.length ? (() => {
            const unit = 'string' !== typeof xs[0] ? (
                []
            ) : '';
            return unit.concat.apply(unit, xs);
        })() : [];


    // enumFromTo :: (Int, Int) -> [Int]
    const enumFromTo = (m, n) =>
        Array.from({
            length: 1 + n - m
        }, (_, i) => m + i);

    // find :: (a -> Bool) -> [a] -> Maybe a
    const find = (p, xs) => {
        for (let i = 0, lng = xs.length; i < lng; i++) {
            if (p(xs[i])) return Just(xs[i]);
        }
        return Nothing();
    };

    // fst :: (a, b) -> a
    const fst = tpl => tpl[0];

    // intercalate :: [a] -> [[a]] -> [a]
    // intercalate :: String -> [String] -> String
    const intercalate = (sep, xs) =>
        0 < xs.length && 'string' === typeof sep &&
        'string' === typeof xs[0] ? (
            xs.join(sep)
        ) : concat(intersperse(sep, xs));

    // intersperse(0, [1,2,3]) -> [1, 0, 2, 0, 3]

    // intersperse :: a -> [a] -> [a]
    // intersperse :: Char -> String -> String
    const intersperse = (sep, xs) => {
        const bln = 'string' === typeof xs;
        return xs.length > 1 ? (
            (bln ? concat : x => x)(
                (bln ? (
                    xs.split('')
                ) : xs)
                .slice(1)
                .reduce((a, x) => a.concat([sep, x]), [xs[0]])
            )) : xs;
    };

    // keys :: Dict -> [String]
    const keys = Object.keys;

    // Returns Infinity over objects without finite length.
    // This enables zip and zipWith to choose the shorter
    // argument when one is non-finite, like cycle, repeat etc

    // length :: [a] -> Int
    const length = xs =>
        (Array.isArray(xs) || 'string' === typeof xs) ? (
            xs.length
        ) : Infinity;

    // map :: (a -> b) -> [a] -> [b]
    const map = (f, xs) =>
        (Array.isArray(xs) ? (
            xs
        ) : xs.split('')).map(f);

    // mapFromList :: [(k, v)] -> Dict
    const mapFromList = kvs =>
        kvs.reduce(
            (a, kv) => {
                const k = kv[0];
                return Object.assign(a, {
                    [
                        (('string' === typeof k) && k) || JSON.stringify(k)
                    ]: kv[1]
                });
            }, {}
        );

    // Default value (v) if m.Nothing, or f(m.Just)

    // maybe :: b -> (a -> b) -> Maybe a -> b
    const maybe = (v, f, m) =>
        m.Nothing ? v : f(m.Just);

    // member :: Key -> Dict -> Bool
    const member = (k, dct) => k in dct;

    // snd :: (a, b) -> b
    const snd = tpl => tpl[1];

    // str :: a -> String
    const str = x => x.toString();

    // tail :: [a] -> [a]
    const tail = xs => 0 < xs.length ? xs.slice(1) : [];

    // take :: Int -> [a] -> [a]
    // take :: Int -> String -> String
    const take = (n, xs) =>
        'GeneratorFunction' !== xs.constructor.constructor.name ? (
            xs.slice(0, n)
        ) : [].concat.apply([], Array.from({
            length: n
        }, () => {
            const x = xs.next();
            return x.done ? [] : [x.value];
        }));

    // takeWhile :: (a -> Bool) -> [a] -> [a]
    // takeWhile :: (Char -> Bool) -> String -> String
    const takeWhile = (p, xs) =>
        xs.constructor.constructor.name !==
        'GeneratorFunction' ? (() => {
            const lng = xs.length;
            return 0 < lng ? xs.slice(
                0,
                until(
                    i => lng === i || !p(xs[i]),
                    i => 1 + i,
                    0
                )
            ) : [];
        })() : takeWhileGen(p, xs);


    // until :: (a -> Bool) -> (a -> a) -> a -> a
    const until = (p, f, x) => {
        let v = x;
        while (!p(v)) v = f(v);
        return v;
    };

    // Use of `take` and `length` here allows for zipping with non-finite
    // lists - i.e. generators like cycle, repeat, iterate.

    // zip :: [a] -> [b] -> [(a, b)]
    const zip = (xs, ys) => {
        const lng = Math.min(length(xs), length(ys));
        return Infinity !== lng ? (() => {
            const bs = take(lng, ys);
            return take(lng, xs).map((x, i) => Tuple(x, bs[i]));
        })() : zipGen(xs, ys);
    };

    // MAIN ---
    return main();
})();

{{Out}}

Counter-example found:
133^5 + 110^5 + 84^5 + 27^5 = 144^5

jq

{{works with | jq | 1.4 }} This version finds all non-decreasing solutions within the specified bounds, using a brute-force but not entirely blind approach.

# Search for y in 1 .. maxn (inclusive) for a solution to SIGMA (xi ^ 5) = y^5
# and for each solution with x0<=x1<=...<x3, print [x0, x1, x3, x3, y]
#
def sum_of_powers_conjecture(maxn):
  def p5: . as $in | (.*.) | ((.*.) * $in);
  def fifth: log / 5 | exp;

  # return the fifth root if . is a power of 5
  def integral_fifth_root: fifth | if . == floor then . else false end;

  (maxn | p5) as $uber
  | range(1; maxn) as $x0
  | ($x0 | p5) as $s0
  | if $s0 < $uber then range($x0; ($uber - $s0 | fifth) + 1) as $x1
    | ($s0 + ($x1 | p5)) as $s1
    | if $s1 < $uber then range($x1; ($uber - $s1 | fifth) + 1) as $x2
      | ($s1 + ($x2 | p5)) as $s2
        | if $s2 < $uber then range($x2; ($uber - $s2 | fifth) + 1) as $x3
          | ($s2 + ($x3 | p5)) as $sumx
	  | ($sumx | integral_fifth_root)
	  | if . then [$x0,$x1,$x2,$x3,.] else empty end
	  else empty
	  end
      else empty
      end
    else empty
    end ;

'''The task:'''

sum_of_powers_conjecture(249)

{{out}}

$ jq -c -n -f Euler_sum_of_powers_conjecture_fifth_root.jq
[27,84,110,133,144]

Julia

const lim = 250
const pwr = 5
const p = [i^pwr for i in 1:lim]

x = zeros(Int, pwr-1)
y = 0

for a in combinations(1:lim, pwr-1)
    b = searchsorted(p, sum(p[a]))
    0 < length(b) || continue
    x = a
    y = b[1]
    break
end

if y == 0
    println("No solution found for power = ", pwr, " and limit = ", lim, ".")
else
    s = [@sprintf("%d^%d", i, pwr) for i in x]
    s = join(s, " + ")
    println("A solution is ", s, " = ", @sprintf("%d^%d", y, pwr), ".")
end

{{out}}

A solution is 27^5 + 84^5 + 110^5 + 133^5 = 144^5.

Kotlin

fun main(args: Array<String>) {
    val p5 = LongArray(250){ it.toLong() * it * it * it * it }
    var sum: Long
    var y: Int
    var found = false
    loop@ for (x0 in 0 .. 249)
        for (x1 in 0 .. x0 - 1)
            for (x2 in 0 .. x1 - 1)
                for (x3 in 0 .. x2 - 1) {
                    sum = p5[x0] + p5[x1] + p5[x2] + p5[x3]
                    y = p5.binarySearch(sum)
                    if (y >= 0) {
                        println("$x0^5 + $x1^5 + $x2^5 + $x3^5 = $y^5")
                        found = true
                        break@loop
                    }
                }
    if (!found) println("No solution was found")
}

{{out}}

133^5 + 110^5 + 84^5 + 27^5 = 144^5

Lua

Brute force but still takes under two seconds with LuaJIT.

-- Fast table search (only works if table values are in order)
function binarySearch (t, n)
    local start, stop, mid = 1, #t
    while start < stop do
        mid = math.floor((start + stop) / 2)
        if n == t[mid] then
            return mid
        elseif n < t[mid] then
            stop = mid - 1
        else
            start = mid + 1
        end
    end
    return nil
end

-- Test Euler's sum of powers conjecture
function euler (limit)
    local pow5, sum = {}
    for i = 1, limit do pow5[i] = i^5 end
    for x0 = 1, limit do
        for x1 = 1, x0 do
            for x2 = 1, x1 do
                for x3 = 1, x2 do
                    sum = pow5[x0] + pow5[x1] + pow5[x2] + pow5[x3]
                    if binarySearch(pow5, sum) then
                        print(x0 .. "^5 + " .. x1 .. "^5 + " .. x2 .. "^5 + " .. x3 .. "^5 = " .. sum^(1/5) .. "^5")
                        return true
                    end
                end
            end
        end
    end
    return false
end

-- Main procedure
if euler(249) then
    print("Time taken: " .. os.clock() .. " seconds")
else
    print("Looks like he was right after all...")
end

{{out}}

133^5 + 110^5 + 84^5 + 27^5 = 144^5
Time taken: 1.247 seconds

Mathematica

Sort[FindInstance[
   x0^5 + x1^5 + x2^5 + x3^5 == y^5 && x0 > 0 && x1 > 0 && x2 > 0 &&
    x3 > 0, {x0, x1, x2, x3, y}, Integers][[1, All, -1]]]

{{out}}

{27,84,110,133,144}

Microsoft Small Basic

' Euler sum of powers conjecture - 03/07/2015
  'find: x1^5+x2^5+x3^5+x4^5=x5^5
  '-> x1=27 x2=84 x3=110 x4=133 x5=144
  maxn=250
  For i=1 to maxn
	p5[i]=Math.Power(i,5)
  EndFor
  For x1=1 to maxn-4
    For x2=x1+1 to maxn-3
      'TextWindow.WriteLine("x1="+x1+", x2="+x2)
      For x3=x2+1 to maxn-2
        'TextWindow.WriteLine("x1="+x1+", x2="+x2+", x3="+x3)
        For x4=x3+1 to maxn-1
          'TextWindow.WriteLine("x1="+x1+", x2="+x2+", x3="+x3+", x4="+x4)
          x5=x4+1
          valx=p5[x5]
          sumx=p5[x1]+p5[x2]+p5[x3]+p5[x4]
          While x5<=maxn and valx<=sumx
            If valx=sumx Then
              TextWindow.WriteLine("Found!")
              TextWindow.WriteLine("-> "+x1+"^5+"+x2+"^5+"+x3+"^5+"+x4+"^5="+x5+"^5")
              TextWindow.WriteLine("x5^5="+sumx)
              Goto EndPgrm
            EndIf
            x5=x5+1
            valx=p5[x5]
          EndWhile 'x5
        EndFor 'x4
      EndFor 'x3
    EndFor 'x2
  EndFor 'x1
 EndPgrm:

{{out}}

Found!
-> 27^5+84^5+110^5+133^5=144^5
x5^5=61917364224

=={{header|Modula-2}}== {{output?|Modula-2}}

MODULE EulerConjecture;
FROM FormatString IMPORT FormatString;
FROM Terminal IMPORT WriteString,WriteLn,ReadChar;

PROCEDURE Pow5(a : LONGINT) : LONGINT;
BEGIN
    RETURN a * a * a * a * a
END Pow5;

VAR
    buf : ARRAY[0..63] OF CHAR;
    a,b,c,d,e,sum,curr : LONGINT;
BEGIN
    FOR a:=0 TO 250 DO
        FOR b:=a TO 250 DO
            IF b=a THEN CONTINUE END;
            FOR c:=b TO 250 DO
                IF (c=a) OR (c=b) THEN CONTINUE END;
                FOR d:=c TO 250 DO
                    IF (d=a) OR (d=b) OR (d=c) THEN CONTINUE END;
                    sum := Pow5(a) + Pow5(b) + Pow5(c) + Pow5(d);
                    FOR e:=d TO 250 DO
                        IF (e=a) OR (e=b) OR (e=c) OR (e=d) THEN CONTINUE END;
                        curr := Pow5(e);
                        IF (sum#0) AND (sum=curr) THEN
                            FormatString("%l^5 + %l^5 + %l^5 + %l^5 = %l^5\n", buf, a, b, c, d, e);
                            WriteString(buf)
                        ELSIF curr > sum THEN
                            BREAK
                        END
                    END;
                END;
            END;
        END;
    END;

    WriteString("Done");
    WriteLn;
    ReadChar
END EulerConjecture.

Nim

{{trans|PureBasic}}

# Brute force approach

import times

# assumes an array of non-decreasing positive integers
proc binarySearch(a : openArray[int], target : int) : int =
  var left, right, mid : int
  left = 0
  right = len(a) - 1
  while true :
    if left > right : return 0  # no match found
    mid = (left + right) div 2
    if a[mid] < target :
      left = mid + 1
    elif a[mid] > target :
      right = mid - 1
    else :
      return mid  # match found

var
  p5 : array[250, int]
  sum = 0
  y, t1 : int

let t0 = cpuTime()

for i in 1 .. 249 :
  p5[i] = i * i * i * i * i

for x0 in 1 .. 249 :
  for x1 in 1 .. x0 - 1 :
    for x2 in 1 .. x1 - 1 :
      for x3 in 1 .. x2 - 1 :
        sum = p5[x0] + p5[x1] + p5[x2] + p5[x3]
        y = binarySearch(p5, sum)
        if y > 0 :
          t1 = int((cputime() - t0) * 1000.0)
          echo "Time : ", t1, " milliseconds"
          echo  $x0 & "^5 + " & $x1 & "^5 + " & $x2 & "^5 + " & $x3 & "^5 = " & $y & "^5"
          quit()

if y == 0 :
  echo "No solution was found"

{{out}}

Time : 156 milliseconds
133^5 + 110^5 + 84^5 + 27^5 = 144^5

Oforth

: eulerSum
| i j k l ip jp kp |
   250 loop: i [
      i 5 pow ->ip
      i 1 + 250 for: j [
         j 5 pow ip + ->jp
         j 1 + 250 for: k [
            k 5 pow jp + ->kp
            k 1 + 250 for: l [
               kp l 5 pow + 0.2 powf dup asInteger == ifTrue: [ [ i, j, k, l ] println ]
              ]
            ]
         ]
      ] ;

{{out}}

>eulerSum
[27, 84, 110, 133]

PARI/GP

Naive script:

forvec(v=vector(4,i,[0,250]), if(ispower(v[1]^5+v[2]^5+v[3]^5+v[4]^5,5,&n), print(n" "v)), 2)

{{out}}

144 [27, 84, 110, 133]

Naive + caching (setbinop):

{
v2=setbinop((x,y)->[min(x,y),max(x,y),x^5+y^5],[0..250]); \\ sums of two fifth powers
for(i=2,#v2,
  for(j=1,i-1,
    if(v2[i][2]<v2[j][2] && ispower(v2[i][3]+v2[j][3],5,&n) && #(v=Set([v2[i][1],v2[i][2],v2[j][1],v2[j][2]]))==4,
      print(n" "v)
    )
  )
)
}

{{out}}

144 [27, 84, 110, 133]

Pascal

{{works with|Free Pascal}} slightly improved.Reducing calculation time by temporary sum and early break.

program Pot5Test;
{$IFDEF FPC} {$MODE DELPHI}{$ELSE]{$APPTYPE CONSOLE}{$ENDIF}
type
  tTest = double;//UInt64;{ On linux 32Bit double is faster than  Uint64 }
var
  Pot5 : array[0..255] of tTest;
  res,tmpSum : tTest;
  x0,x1,x2,x3, y : NativeUint;//= Uint32 or 64 depending on OS xx-Bit
  i : byte;
BEGIN
  For i := 1 to 255 do
    Pot5[i] := (i*i*i*i)*Uint64(i);

  For x0 := 1 to 250-3 do
    For x1 := x0+1 to 250-2 do
      For x2 := x1+1 to 250-1 do
      Begin
        //set y here only, because pot5 is strong monoton growing,
        //therefor the sum is strong monoton growing too.
        y := x2+2;// aka x3+1
        tmpSum := Pot5[x0]+Pot5[x1]+Pot5[x2];
        For x3 := x2+1 to 250 do
        Begin
          res := tmpSum+Pot5[x3];
          while (y< 250) AND (res > Pot5[y]) do
            inc(y);
          IF y > 250 then BREAK;
          if res = Pot5[y] then
            writeln(x0,'^5+',x1,'^5+',x2,'^5+',x3,'^5 = ',y,'^5');
        end;
      end;
END.