I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Digit fifth powers

Digit fifth powers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

Task desciption is taken from Project Euler (https://projecteuler.net/problem=30)
Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

Even though 15 = 1, it is not expressed as a sum (a sum being the summation of a list of two or more numbers), and is therefore not included.

## 8080 Assembly

putch:	equ	2 		; CP/M syscall to print a characterputs:	equ	9		; CP/M syscall to print a string	org	100h	;	Find the sum of the 5-powers of the digits	;	of the current numbersum5:	mvi	b,6		; There are 6 digits	lxi 	h,dps		; Set the accumulator to zero	call 	dgzero 	lxi	d,cur		; Load the start of the current numberaddpow:	ldax	d 		; Get current digit	mov	c,a		; Multiply by 6 (width of table)	add	a	add 	c	add	a	mvi 	h,0		; HL = index of table entry	mov	l,a	push	d		; Keep pointer to current digit	lxi	d,pow5		; Add start address of pow5 table	dad	d 	xchg			; Let [DE] = n^5	lxi 	h,dps		; Get accumulator	call	dgadd		; Add the current power to it	pop	d		; Restore pointer to current digit	inx	d	dcr 	b		; If we're not done yet, do the next digit	jnz 	addpow 	lxi	d,cur 		; Is the result the same as the current number?	call	dgcmp	jnz	next		; If not, try the next number	lxi 	h,total		; But if so, it needs to be added to the total	call	dgadd	xchg			; As well as printed 	call	dgoutnext:	lxi 	h,cur		; Increment the current number	call	dginc	lxi	d,max		; Have we reached the end yet?	call	dgcmp	jnz	sum5		; If not, keep going	lxi	d,stot	mvi	c,puts	call	5	lxi	h,total	jmp	dgout	;;;;;;; Program data ;;;;;;;	;	Table of powers of 5, stored as digits in low-endian orderpow5:	db	0,0,0,0,0,0	; 0 ^ 5	db	1,0,0,0,0,0	; 1 ^ 5	db	2,3,0,0,0,0	; 2 ^ 5	db	3,4,2,0,0,0	; 3 ^ 5	db	4,2,0,1,0,0	; 4 ^ 5	db	5,2,1,3,0,0	; 5 ^ 5	db	6,7,7,7,0,0	; 6 ^ 5	db	7,0,8,6,1,0	; 7 ^ 5	db	8,6,7,2,3,0	; 8 ^ 5	db	9,4,0,9,5,0	; 9 ^ 5	; 	End of the search space (9^5 * 6)max:	db	4,9,2,4,5,3	;	Variablestotal:	db	0,0,0,0,0,0	; Total of all matching numbersdps:	db	0,0,0,0,0,0	; Current sum of 5-powers of digitscur:	db	2,0,0,0,0,0	; Current number to test (start at 2)	;	Stringsnl:	db	13,10,'$' ; Newlinestot: db 'Total:$'	;;;;;;; Math routines ;;;;;;	;	Zero out [HL]dgzero:	push	b		; Keep BC and HL	push 	h 	xra	a	mvi	b,6dgzl:	mov	m,a	inx	h	dcr	b	jnz	dgzl	pop 	h		; Restore HL and BC	pop 	b 		ret 	;	Increment [HL]dginc:	push 	h 		; Keep HLdgincl:	inr	m		; Increment current digit	mov	a,m		; Load it into the accumulator	sui	10		; Subtract 10 from it	jc	dginco		; If there is no carry, we're done	mov	m,a		; Otherewise, write it back 	inx	h		; And go increment the next digit	jmp	dgincldginco:	pop 	h		; Restore HL	ret		; 	Print the number in [HL]dgout:	push 	b		; Keep all registers	push 	d	push 	h	lxi	b,6		; Move to the last digit	dad	bdzero:	dcr	c		; Skip leading zeroes	jm	restor 		; Don't bother handling 0 case	dcx	h		; Go back	mov	a,m		; Get digit	ana	a	jz	dzero		; Keep going until we find a nonzero digitdgprn:	adi	'0'		; Write the digit	mov	e,a	push	b		; CP/M syscall destroys registers	push 	h	mvi	c,putch	call 	5 	pop 	h	pop 	b	dcx 	h	mov	a,m	dcr	c	jp	dgprn	mvi	c,puts		; Finally, print a newline	lxi	d,nl	call	5restor:	pop 	h		; And restore the registers	pop 	d	pop 	b	ret	;	Compare [DE] to [HL]dgcmp:	push 	b		; Keep the registers	push 	d	push 	h 	mvi	b,6dgcmpl:	ldax	d		; Get [DE]	cmp	m		; Compare to [HL]	jnz	restor		; If unequal, this is the result	inx	d		; Otherwise, compare next pair	inx	h	dcr 	b	jnz	dgcmpl	jmp	restor	;	Add [DE] to [HL]dgadd:	push	b	push 	d	push 	h	lxi	b,600h 		; B = counter, C = carrydgaddl:	ldax	d		; Get digit from [DE]	add	m 		; Add digit from [HL]	add	c		; Carry the one	cpi	10		; Is the result 10 or higher?	mvi 	c,0		; Assume there will be no carry	jc	dgwr		; If not, handle next digit	sui	10		; But if so, subtract 10,	inr	c 		; And set the carry flag for the next digitdgwr:	mov	m,a		; Store the resulting digit in [HL]	inx	d		; Move the pointers	inx	h	dcr	b		; Any more digits?	jnz	dgaddl	jmp	restor
Output:
4150
4151
54748
92727
93084
194979
Total: 443839

with Ada.Text_Io; procedure Digit_Fifth_Powers is    subtype Number is Natural range 000_002 .. 999_999;    function Sum_5 (N : Natural) return Natural   is      Pow_5 : constant array (0 .. 9) of Natural :=        (0 => 0**5, 1 => 1**5, 2 => 2**5, 3 => 3**5, 4 => 4**5,         5 => 5**5, 6 => 6**5, 7 => 7**5, 8 => 8**5, 9 => 9**5);   begin      return (if N = 0              then 0              else Pow_5 (N mod 10) + Sum_5 (N / 10));   End Sum_5;    use Ada.Text_Io;   Sum : Natural := 0;begin   for N in Number loop      if N = Sum_5 (N) then         Sum := Sum + N;         Put_Line (Number'Image (N));      end if;   end loop;   Put ("Sum: ");   Put_Line (Natural'Image (Sum));end Digit_Fifth_Powers;
Output:
 4150
4151
54748
92727
93084
194979
Sum:  443839

## ALGOL 68

As noted by the Julia sample, we need only consider up to 6 digit numbers.
Also note, the digit fifth power sum is independent of the order of the digits.

BEGIN    []INT fifth = []INT( 0, 1, 2^5, 3^5, 4^5, 5^5, 6^5, 7^5, 8^5, 9^5 )[ AT 0 ];    # as observed by the Julia sample, 9^5 * 7 has only 6 digits whereas 9^5 * 6 has 6 digits #    # so only up to 6 digit numbers need be considered #    # also, the digit fifth power sum is independent ofg the order of the digits #     [ 1 : 100 ]INT sums; FOR i TO UPB sums DO sums[ i ] := 0 OD;    [ 0 :   9 ]INT used; FOR i FROM 0 TO 9 DO used[ i ] := 0 OD;    INT s count := 0;    FOR d1 FROM 0 TO 9 DO        INT s1 = fifth[ d1 ];        used[ d1 ] +:= 1;        FOR d2 FROM d1 TO 9 DO            INT s2 = fifth[ d2 ] + s1;            used[ d2 ] +:= 1;            FOR d3 FROM d2 TO 9 DO                INT s3 = fifth[ d3 ] + s2;                used[ d3 ] +:= 1;                FOR d4 FROM d3 TO 9 DO                    INT s4 = fifth[ d4 ] + s3;                    used[ d4 ] +:= 1;                    FOR d5 FROM d4 TO 9 DO                        INT s5 = fifth[ d5 ] + s4;                        used[ d5 ] +:= 1;                        FOR d6 FROM d5 TO 9 DO                            INT s6 = fifth[ d6 ] + s5;                            used[ d6 ] +:= 1;                            # s6 is the sum of the fifth powers of the digits #                            # check it it is composed of the digits d1 - d6   #                            [ 0 : 9 ]INT check; FOR i FROM 0 TO 9 DO check[ i ] := 0 OD;                            INT v := s6;                            FOR i TO 6 DO                                check[ v MOD 10 ] +:= 1;                                v OVERAB 10                            OD;                            BOOL same := TRUE;                            FOR i FROM 0 TO 9 WHILE ( same := used[ i ] = check[ i ] ) DO SKIP OD;                            IF same THEN                                # found a number that is the sum of the fifth powers of its digits #                                sums[ s count +:= 1 ] := s6                            FI;                            used[ d6 ] -:= 1                        OD # d6 # ;                        used[ d5 ] -:= 1                    OD # d5 # ;                    used[ d4 ] -:= 1                OD # d4 # ;                used[ d3 ] -:= 1            OD # d3 # ;            used[ d2 ] -:= 1        OD # d2 # ;        used[ d1 ] -:= 1    OD # d1 # ;    # sum and print the sums - ignore 0 and 1 #    INT total := 0;    print( ( "Numbers that are the sums of the fifth powers of their digits: " ) );    FOR i TO s count DO        IF sums[ i ] > 1 THEN            print( ( " ", whole( sums[ i ], 0 ) ) );            total +:= sums[ i ]        FI    OD;    print( ( newline ) );    print( ( "Total: ", whole( total, 0 ), newline ) )END
Output:
Numbers that are the sums of the fifth powers of their digits:  4150 4151 93084 92727 54748 194979
Total: 443839


## APL

Works with: Dyalog APL
+/(⊢(/⍨)(⊢=(+/5*⍨⍎¨∘⍕))¨)1↓⍳6×9*5
Output:
443839

## BASIC

### FreeBASIC

function dig5( n as uinteger ) as uinteger    dim as string ns = str(n)    dim as uinteger ret = 0    for i as ubyte = 1 to len(ns)        ret += val(mid(ns,i,1))^5    next i    return retend function dim as uinteger i, sum = 0 for i = 2 to 999999    if i = dig5(i) then         print i        sum += i    end ifnext i print "Their sum is ", sum
Output:

4150
4151
54748
92727
93084
194979

Their sum is  443839

# Output: an array of i^5 for i in 0 .. 9 inclusivedef dp5: [range(0;10) | power(5)]; def task:  dp5 as $dp5 | ($dp5[9] * 6) as $limit | sum( range(2;$limit + 1)         | sum( digits | $dp5[.] ) as$s         | select(. == $s) ) ; "The sum of all numbers that can be written as the sum of the 5th powers of their digits is:", task Output: The sum of all numbers that can be written as the sum of the 5th powers of their digits is: 443839  ## Julia In base 10, the largest digit is 9. If n is the number of digits, as n increases, 9^5 * n < 10^n. So we do not have to look beyond 9^5 * 6 since 9^5 * 6 < 1,000,000. println("Numbers > 1 that can be written as the sum of fifth powers of their digits:")arr = [i for i in 2 : 9^5 * 6 if mapreduce(x -> x^5, +, digits(i)) == i]println(join(arr, " + "), " = ", sum(arr))  Output: Numbers > 1 that can be written as the sum of fifth powers of their digits: 4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839  ## MAD  NORMAL MODE IS INTEGER INTERNAL FUNCTION(X) ENTRY TO POW5. FUNCTION RETURN X * X * X * X * X END OF FUNCTION INTERNAL FUNCTION(N) ENTRY TO SUM5. CUR = N SUM = 0LOOP WHENEVER CUR.G.0 NEXT = CUR / 10 SUM = SUM + POW5.(CUR - NEXT*10) CUR = NEXT TRANSFER TO LOOP END OF CONDITIONAL FUNCTION RETURN SUM END OF FUNCTION LIMIT = POW5.(9) * 6 TOTAL = 0 THROUGH TEST, FOR I = 2, 1, I.GE.LIMIT WHENEVER SUM5.(I).E.I TOTAL = TOTAL + I PRINT FORMAT NUM, I END OF CONDITIONALTEST CONTINUE PRINT FORMAT TOT, TOTAL VECTOR VALUES NUM =$S7,I6*$VECTOR VALUES TOT =$7HTOTAL: ,I6*$END OF PROGRAM  Output:  4150 4151 54748 92727 93084 194979 TOTAL: 443839 ## PARI/GP sumfp(n)=if(n<10,n^5,(n%10)^5+sumfp(n\10));s=0;for(i=2,999999,if(i==sumfp(i),s=s+i;print(i)));print("Total: ",s); Output: 4150 4151 54748 92727 93084 194979 Total: 443839 ## Pascal slightly modified Own_digits_power_sum checks decimals up to power 19. program PowerOwnDigits2;{$IFDEF FPC}  {$R+,O+} {$MODE DELPHI}{$OPTIMIZATION ON,ALL}{$COPERATORS ON}{$ELSE} {$APPTYPE CONSOLE}{$ENDIF}uses SysUtils,StrUtils;const CPU_hz = 1000*1000*1000;const MAXBASE = 10; MaxDgtVal = MAXBASE - 1; MaxDgtCount = 19;type tDgtCnt = 0..MaxDgtCount; tValues = 0..MaxDgtVal; tUsedDigits = array[tValues] of Int8; tpUsedDigits = ^tUsedDigits; tPower = array[tValues] of Uint64;var PowerDgt: tPower; gblUD : tUsedDigits; CombIdx : array of Int8; Numbers : array of Uint64; rec_cnt : NativeInt; function GetCPU_Time: Uint64; type TCpu = record HiCpu, LoCpu : Dword; end; var Cput : TCpu; begin {$ASMMODE INTEL}    asm    RDTSC;    MOV Dword Ptr [CpuT.LoCpu],EAX;  MOV Dword Ptr [CpuT.HiCpu],EDX    end;    with Cput do  result := Uint64(HiCPU) shl 32 + LoCpu;  end;   function InitCombIdx(ElemCount: Byte): pbyte;  begin    setlength(CombIdx, ElemCount + 1);    Fillchar(CombIdx[0], sizeOf(CombIdx[0]) * (ElemCount + 1), #0);    Result := @CombIdx[0];    Fillchar(gblUD[0], sizeOf(tUsedDigits), #0);    gblUD[0]:= 1;  end;   function Init(ElemCount:byte;Expo:byte):pByte;  var    pP1 : pUint64;    p: Uint64;    i,j: Int32;  begin    pP1 := @PowerDgt[0];    for i in tValues do    Begin      p := 1;      for j := 1 to Expo do        p *= i;      pP1[i] := p;    end;    result := InitCombIdx(ElemCount);    gblUD[0]:= 1;  end;   function GetPowerSum(minpot:nativeInt;digits:pbyte;var UD :tUsedDigits):NativeInt;  var    res,r  : Uint64;    dgt :Int32;  begin    dgt := minpot;    res := 0;    repeat      dgt -=1;      res += PowerDgt[digits[dgt]];    until dgt=0;    result := 0;    //convert res into digits    repeat      r := res DIV MAXBASE;      result+=1;      dgt := res-r*MAXBASE;      //substract from used digits      UD[dgt] -= 1;      res := r;    until r = 0;  end;   procedure calcNum(minPot:Int32;digits:pbyte);  var    UD :tUsedDigits;    res: Uint64;    i: nativeInt;  begin    UD := gblUD;    i:= GetPowerSum(minpot,digits,UD);    if i = minPot then    Begin      //don't check 0      i := 1;      repeat        If UD[i] <> 0 then          Break;        i +=1;      until i > MaxDgtVal;       if i > MaxDgtVal then      begin        res := 0;        for i := minpot-1 downto 0 do          res += PowerDgt[digits[i]];        setlength(Numbers, Length(Numbers) + 1);        Numbers[high(Numbers)] := res;      end;    end;  end;   function NextCombWithRep(pComb: pByte;pUD :tpUsedDigits;MaxVal, ElemCount: UInt32): boolean;  var    i,dgt: NativeInt;  begin    i := -1;    repeat      i += 1;      dgt := pComb[i];      if dgt < MaxVal then        break;      dec(pUD^[dgt]);    until i >= ElemCount;    Result := i >= ElemCount;     if i = 0 then    begin      dec(pUD^[dgt]);      dgt +=1;      pComb[i] := dgt;      inc(pUD^[dgt]);    end    else    begin      dec(pUD^[dgt]);      dgt +=1;      pUD^[dgt]:=i+1;      repeat        pComb[i] := dgt;        i -= 1;      until i < 0;    end;  end; var  digits : pByte;  T0,T1 : UInt64;  tmp : Uint64;  Pot,dgtCnt,i, j : Int32; begin  T0 := GetCPU_Time;  For pot := 2 to MaxDgtCount do  begin    Write('Exponent : ',Pot,' used ');    T1 := GetCPU_Time;    digits := Init(MaxDgtCount,pot);    rec_cnt := 0;    // i > 0    For dgtCnt := 2 to pot+1 do    Begin      digits := InitCombIdx(Pot);      repeat        calcnum(dgtCnt,digits);        inc(rec_cnt);      until NextCombWithRep(digits,@gblUD,MaxDgtVal,dgtCnt);    end;    writeln(rec_cnt,' recursions in ',(GetCPU_Time-T1)/CPU_hz:0:6,' GigaCyles');    If length(numbers) > 0 then    Begin      //sort      for i := 0 to High(Numbers) - 1 do        for j := i + 1 to High(Numbers) do          if Numbers[j] < Numbers[i] then          begin            tmp := Numbers[i];            Numbers[i] := Numbers[j];            Numbers[j] := tmp;          end;       tmp := 0;      for i := 0 to High(Numbers)-1 do      begin        write(Numb2USA(IntToStr(Numbers[i])),' + ');        tmp +=Numbers[i];      end;      write(Numb2USA(IntToStr(Numbers[High(Numbers)])),' = ');      tmp +=Numbers[High(Numbers)];      writeln('sum to ',Numb2USA(IntToStr(tmp)));    end;    writeln;    setlength(Numbers,0);  end;  T0 := GetCPU_Time-T0;  Writeln('Max Uint64 ',Numb2USA(IntToStr(High(Uint64))));  writeln('Total runtime : ',T0/CPU_hz:0:6,' GigaCyles');  {$IFDEF WINDOWS} readln; {$ENDIF}  setlength(CombIdx,0);end.
Output @ Tio.run:
TIO.RUN User time: 12.905 s //Total runtime : 29.470650 GigaCyles estimated ~2,28 Ghz
Exponent : 2 used 275 recursions in 0.000030 GigaCyles

Exponent : 3 used 990 recursions in 0.000161 GigaCyles
153 + 370 + 371 + 407 = sum to 1,301

Exponent : 4 used 2992 recursions in 0.000367 GigaCyles
1,634 + 8,208 + 9,474 = sum to 19,316

Exponent : 5 used 7997 recursions in 0.001193 GigaCyles // /2.28 -> 523 µs
4,150 + 4,151 + 54,748 + 92,727 + 93,084 + 194,979 = sum to 443,839

Exponent : 6 used 19437 recursions in 0.003013 GigaCyles
548,834 = sum to 548,834

Exponent : 7 used 43747 recursions in 0.007827 GigaCyles
1,741,725 + 4,210,818 + 9,800,817 + 9,926,315 + 14,459,929 = sum to 40,139,604

Exponent : 8 used 92367 recursions in 0.017619 GigaCyles
24,678,050 + 24,678,051 + 88,593,477 = sum to 137,949,578

Exponent : 9 used 184745 recursions in 0.037308 GigaCyles
146,511,208 + 472,335,975 + 534,494,836 + 912,985,153 = sum to 2,066,327,172

Exponent : 10 used 352705 recursions in 0.090797 GigaCyles
4,679,307,774 = sum to 4,679,307,774

Exponent : 11 used 646635 recursions in 0.207819 GigaCyles
32,164,049,650 + 32,164,049,651 + 40,028,394,225 + 42,678,290,603 + 44,708,635,679 + 49,388,550,606 + 82,693,916,578 + 94,204,591,914 = sum to 418,030,478,906

Exponent : 12 used 1144055 recursions in 0.295691 GigaCyles

Exponent : 13 used 1961245 recursions in 0.532789 GigaCyles
564,240,140,138 = sum to 564,240,140,138

Exponent : 14 used 3268749 recursions in 0.937579 GigaCyles
28,116,440,335,967 = sum to 28,116,440,335,967

Exponent : 15 used 5311724 recursions in 1.623457 GigaCyles

Exponent : 16 used 8436274 recursions in 2.680338 GigaCyles
4,338,281,769,391,370 + 4,338,281,769,391,371 = sum to 8,676,563,538,782,741

Exponent : 17 used 13123099 recursions in 4.432118 GigaCyles
233,411,150,132,317 + 21,897,142,587,612,075 + 35,641,594,208,964,132 + 35,875,699,062,250,035 = sum to 93,647,847,008,958,559

Exponent : 18 used 20029999 recursions in 7.169892 GigaCyles

Exponent : 19 used 30045004 recursions in 11.431518 GigaCyles
1,517,841,543,307,505,039 + 3,289,582,984,443,187,032 + 4,498,128,791,164,624,869 + 4,929,273,885,928,088,826 = sum to 14,234,827,204,843,405,766

Max Uint64 18,446,744,073,709,551,615
Total runtime : 29.470650 GigaCyles

## Perl

use strict;use warnings;use feature 'say';use List::Util 'sum'; for my $power (3..6) { my @matches; for my$n (2 .. 9**$power *$power) {        push @matches, $n if$n == sum map { $_**$power } split '', $n; } say "\nSum of powers of n**$power: " . join(' + ', @matches) . ' = ' . sum @matches;}
Output:
Sum of powers of n**3: 153 + 370 + 371 + 407 = 1301
Sum of powers of n**4: 1634 + 8208 + 9474 = 19316
Sum of powers of n**5: 4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839
Sum of powers of n**6: 548834 = 548834

## Phix

with javascript_semantics
function sum5(integer n)
return iff(n<10?power(n,5):power(remainder(n,10),5) + sum5(floor(n/10)))
end function

integer total = 0
sequence res = {}
for i=2 to power(9,5)*6 do
if i=sum5(i) then
res = append(res,sprint(i))
total += i
end if
end for
printf(1,"%s = %d\n",{join(res," + "),total})

Output:
4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839


## PILOT

C :max=9*(9*(9*(9*(9*6))))  :sum=0  :n=2*numberC :dps=0  :cur=n*digitC :next=cur/10  :d=cur-(next*10)  :dps=dps+d*(d*(d*(d*#d)))  :cur=nextJ (cur>0):*digitT (dps=n):#nC (dps=n):sum=sum+n  :n=n+1J (n<max):*numberT :Total: #sumE :
Output:
4150
4151
54748
92727
93084
194979
Total: 443839

## PL/M

100H:/* BDOS ROUTINES */BDOS: PROCEDURE (F,A); DECLARE F BYTE, A ADDRESS; GO TO 5; END BDOS;EXIT: PROCEDURE; CALL BDOS(0,0); END EXIT;PUT$CHAR: PROCEDURE (C); DECLARE C BYTE; CALL BDOS(2,C); END PUT$CHAR;PRINT: PROCEDURE (S); DECLARE S ADDRESS; CALL BDOS(9,S); END PRINT;NEW$LINE: PROCEDURE; CALL PRINT(.(13,10,'$')); END NEW$LINE; /* THE NATIVE INTEGER TYPES ARE NOT BIG ENOUGH, SO WE NEED TO MAKE OUR OWN */DECLARE DGT$SIZE LITERALLY '6';MAKE$DEC: PROCEDURE (N, BUF) ADDRESS; DECLARE (N, BUF) ADDRESS, (I, D BASED BUF) BYTE; DO I=0 TO DGT$SIZE-1;        D(I) = N MOD 10;        N = N/10;    END;    RETURN BUF;END MAKE$DEC; ADD: PROCEDURE (ACC, ADDEND) ADDRESS; DECLARE (ACC, ADDEND) ADDRESS; DECLARE (I, C, A BASED ACC, D BASED ADDEND) BYTE; C = 0; DO I=0 TO DGT$SIZE-1;        A(I) = A(I) + D(I) + C;        IF A(I) < 10 THEN            C = 0;        ELSE DO;            A(I) = A(I) - 10;            C = 1;        END;    END;    RETURN ACC;END ADD; INCR: PROCEDURE (N);    DECLARE N ADDRESS, (I, D BASED N) BYTE;    DO I=0 TO DGT$SIZE-1; IF (D(I) := D(I) + 1) < 10 THEN RETURN; ELSE D(I) = 0; END;END INCR; EQUAL: PROCEDURE (A, B) BYTE; DECLARE (A, B) ADDRESS, (DA BASED A, DB BASED B, I) BYTE; DO I=0 TO DGT$SIZE-1;        IF DA(I) <> DB(I) THEN RETURN 0;    END;    RETURN 0FFH;END EQUAL; PRINT$NUM: PROCEDURE (N); DECLARE N ADDRESS, (I, D BASED N) BYTE; I = DGT$SIZE-1;    DO WHILE I <> -1 AND D(I) = 0;        I = I-1;    END;     DO WHILE I <> -1;        CALL PUT$CHAR('0' + D(I)); I = I-1; END;END PRINT$NUM; /* GENERATE A TABLE OF DIGIT POWERS BEFOREHAND */DECLARE NATIVE$POWER$5 (10) ADDRESS INITIAL     (0, 1, 32, 243, 1024, 3125, 7776, 16807, 32768, 59049);DECLARE POWER$5 (10) ADDRESS;DECLARE POWER$BUF (60) BYTE;DECLARE P BYTE;DO P=0 TO 9;    POWER$5(P) = MAKE$DEC(NATIVE$POWER$5(P), .POWER$BUF(DGT$SIZE * P));END; /* DIGITS OF SEARCH LIMIT (9**5 * 6) IN LOW ENDIAN ORDER */DECLARE MAX (DGT$SIZE) BYTE INITIAL (4,9,2,4,5,3); /* SUM THE 5-POWERS OF THE DIGITS OF N */SUM$5: PROCEDURE (N, BUF) ADDRESS;    DECLARE (N, BUF) ADDRESS, (I, D BASED N) BYTE;     BUF = MAKE$DEC(0, BUF); DO I=0 TO DGT$SIZE-1;        BUF = ADD(BUF, POWER$5(D(I))); END; RETURN BUF;END SUM$5; DECLARE CUR (DGT$SIZE) BYTE INITIAL (2,0,0,0,0,0);DECLARE TOTAL$BUF (DGT$SIZE) BYTE;DECLARE TOTAL ADDRESS;TOTAL = MAKE$DEC(0, .TOTAL$BUF); /* TEST EACH NUMBER */DO WHILE NOT EQUAL(.CUR, .MAX); IF EQUAL(SUM5(.CUR, .MEMORY), .CUR) THEN DO; TOTAL = ADD(TOTAL, .CUR); CALL PRINT$NUM(.CUR);        CALL NEWLINE;    END;    CALL INCR(.CUR);END; CALL PRINT(.'TOTAL: $');CALL PRINT$NUM(TOTAL);CALL NEWLINE;CALL EXIT;EOF
Output:
4150
4151
54748
92727
93084
194979
TOTAL: 443839

## Python

Comparing conventional vs. faster.

from time import time # conventionalst = time()print(sum([n for n in range(2, 6*9**5) if sum(int(i)**5 for i in str(n)) == n]), "  ", (time() - st) * 1000, "ms") # fasterst = time()nums = list(range(10))nu = list(range(((6 * 9**5) // 100000) + 1))numbers = []p5 = []for i in nums: p5.append(i**5)for i in nu:    im = i * 100000    ip = p5[i]    for j in nums:        jm = im + 10000 * j        jp = ip + p5[j]        for k in nums:            km = jm + 1000 * k            kp = jp + p5[k]            for l in nums:                lm = km + 100 * l                lp = kp + p5[l]                for m in nums:                    mm = lm + 10 * m                    mp = lp + p5[m]                    for n in nums:                        nm = mm + n                        np = mp + p5[n]                        if np == nm:                            if nm > 1: numbers.append(nm)print(sum(numbers), "  ", (time() - st) * 1000, "ms", end = "")
Output @ Tio.run:
443839    195.04594802856445 ms
443839    22.282838821411133 ms
Around eight times faster.

## Raku

print q:to/EXPANATION/;Sum of all integers (except 1 for some mysterious reason ¯\_(ツ)_/¯),for which the individual digits to the nth power sum to itself.EXPANATION sub super($i) {$i.trans('0123456789' => '⁰¹²³⁴⁵⁶⁷⁸⁹') } for 3..8 -> $power { print "\nSum of powers of n{super$power}: ";    my $threshold = 9**$power * $power; put .join(' + '), ' = ', .sum with cache (2..$threshold).race.map: {        state %p = ^10 .map: { $_ =>$_ ** $power };$_ if %p{.comb}.sum == \$_    }}
Output:
Sum of all integers (except 1 for some mysterious reason ¯\_(ツ)_/¯),
for which the individual digits to the nth power sum to itself.

Sum of powers of n³: 153 + 370 + 371 + 407 = 1301

Sum of powers of n⁴: 1634 + 8208 + 9474 = 19316

Sum of powers of n⁵: 4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839

Sum of powers of n⁶: 548834 = 548834

Sum of powers of n⁷: 1741725 + 4210818 + 9800817 + 9926315 + 14459929 = 40139604

Sum of powers of n⁸: 24678050 + 24678051 + 88593477 = 137949578

## REXX

/* numbers that are equal to the sum of their digits raised to the power 5 */ maximum = 9**5 * 6total = 0out = ''do i = 2 to maximum     if sum5(i) = i then do        if out \= '' then out = out || ' + '        out = out || i        total = total + i    endendsay out || ' = ' || total exit sum5: procedure     arg num    result = 0    do i = 1 to length(num)        result = result + substr(num, i, 1) ** 5    end    return result
Output:
4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839

## Ring

### Conventional

? "working..." sumEnd = 0sumList = "" pow5 = []for i = 1 to 9    add(pow5, pow(i, 5))next limitStart = 2limitEnd = 6 * pow5[9] for n = limitStart to limitEnd    sum = 0    m = n    while m > 0        d = m % 10        if d > 0 sum += pow5[d] ok        m = unsigned(m, 10, "/")    end    if sum = n       sumList += "" + n + " + "       sumEnd += n    oknext ? "The sum of all the numbers that can be written as the sum of fifth powers of their digits:"? substr(sumList, 1, len(sumList) - 2) + "= " + sumEnd? "done..."
Output:
working...
The sum of all the numbers that can be written as the sum of fifth powers of their digits:
4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839
done...


### Faster

Around six times faster than the conventional version.

st = clock()lst9 = 1:10 lst3 = 1:4p5 = [] m5 = [] m4 = [] m3 = [] m2 = [] m1 = []for i in lst9  add(p5, pow(i - 1, 5)) add(m1, (i - 1) * 10) add(m2, m1[i] * 10)  add(m3, m2[i] * 10) add(m4, m3[i] * 10) add(m5, m4[i] * 10)next s = 0 t = ""for i in lst3 ip = p5[i] im = m5[i]  for j in lst9 jp = ip + p5[j] jm = im + m4[j]    for k in lst9 kp = jp + p5[k] km = jm + m3[k]      for l in lst9 lp = kp + p5[l] lm = km + m2[l]        for m in lst9 mp = lp + p5[m] mm = lm + m1[m]          for n in lst9 np = mp + p5[n] nm = mm + n - 1            if nm = np and nm > 1              if t != "" t += " + " ok              s += nm t += nm            oknext next next next next nextet = clock()put t + " = " + s + "  " + (et - st) / clockspersecond() + " sec"
Output @ Tio.run:
4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839  4.90 sec

## Wren

Library: Wren-math

Using the Julia entry's logic to arrive at an upper bound:

import "./math" for Int // cache 5th powers of digitsvar dp5 = (0..9).map { |d| d.pow(5) }.toList System.print("The sum of all numbers that can be written as the sum of the 5th powers of their digits is:")var limit = dp5[9] * 6var sum = 0for (i in 2..limit) {    var digits = Int.digits(i)    var totalDp = digits.reduce(0) { |acc, d| acc + dp5[d] }    if (totalDp == i) {        System.write((sum > 0) ? " + %(i)" : i)        sum = sum + i    }}System.print(" = %(sum)")
Output:
The sum of all numbers that can be written as the sum of the 5th powers of their digits is:
4150 + 4151 + 54748 + 92727 + 93084 + 194979 = 443839


## XPL0

Since 1 is not actually a sum, it should not be included. Thus the answer should be 443839.

\upper bound: 6*9^5 = 354294\7*9^5 is still only a 6-digit number, so 6 digits are sufficient int     A, B, C, D, E, F,       \digits, A=LSD        A5, B5, C5, D5, E5, F5, \digits to 5th power        A0, B0, C0, D0, E0, F0, \digits multiplied by their decimal place        N,              \number that can be written as the sum of its 5th pwrs        S;              \sum of all numbers [S:= 0; for A:= 0, 9 do                 \for all digits  [A5:= A*A*A*A*A;  A0:= A;  for B:= 0, 9 do    [B5:= B*B*B*B*B;    B0:= B*10;    for C:= 0, 9 do      [C5:= C*C*C*C*C;      C0:= C*100;      for D:= 0, 9 do        [D5:= D*D*D*D*D;        D0:= D*1000;        for E:= 0, 9 do          [E5:= E*E*E*E*E;          E0:= E*10000;          for F:= 0, 3 do            [F5:= F*F*F*F*F;            F0:= F*100000;                [N:= F0 + E0 + D0 + C0 + B0 + A0;                if N = A5 + B5 + C5 + D5 + E5 + F5 then                        [S:= S + N;                        IntOut(0, N);                        CrLf(0);                        ];                ];            ];          ];        ];      ];    ];  ];CrLf(0);IntOut(0, S);CrLf(0);]
Output:
0
4150
1
4151
93084
92727
54748
194979

443840


## Zig

const std = @import("std"); fn sum5(n: u32) u32 {    var i = n;    var r: u32 = 0;    while (i != 0) : (i /= 10)       r += std.math.pow(u32, i%10, 5);    return r;} pub fn main() !void {    const stdout = std.io.getStdOut().writer();    const max = std.math.pow(u32,9,5) * 6;     var n: u32 = 2;    var total: u32 = 0;    while (n <= max) : (n += 1) {        if (sum5(n) == n) {            try stdout.print("{d:6}\n", .{n});            total += n;        }    }     try stdout.print("Total: {d:6}\n", .{total});}
Output:
  4150
4151
54748
92727
93084
194979
Total: 443839