Sum of first n cubes: Difference between revisions
m →{{header|QBASIC}}: changed header QBASIC -> QBasic |
Ada version |
||
Line 4: | Line 4: | ||
Find and show sum of first '''n''' cubes, where '''n < 50''' (ie show 50 entries for n=0..49) |
Find and show sum of first '''n''' cubes, where '''n < 50''' (ie show 50 entries for n=0..49) |
||
<br><br> |
<br><br> |
||
=={{header|Ada}}== |
|||
<lang Ada>with Ada.Text_Io; |
|||
procedure Sum_Of_First_N_Cubes is |
|||
Columns : constant := 10; |
|||
Width : constant := 8; |
|||
package Natural_Io is new Ada.Text_Io.Integer_Io (Natural); |
|||
use Ada.Text_Io, Natural_Io; |
|||
Sum : Natural := 0; |
|||
begin |
|||
for N in 0 .. 49 loop |
|||
Sum := Sum + N ** 3; |
|||
Put (Sum, Width => Width); |
|||
if N mod Columns = Columns - 1 then |
|||
New_Line; |
|||
end if; |
|||
end loop; |
|||
New_Line; |
|||
end Sum_Of_First_N_Cubes;</lang> |
|||
{{out}} |
|||
<pre> |
|||
0 1 9 36 100 225 441 784 1296 2025 |
|||
3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 |
|||
44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 |
|||
216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 |
|||
672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 |
|||
</pre> |
|||
=={{header|ALGOL 68}}== |
=={{header|ALGOL 68}}== |
Revision as of 21:18, 7 November 2021
- Task
Find and show sum of first n cubes, where n < 50 (ie show 50 entries for n=0..49)
Ada
<lang Ada>with Ada.Text_Io;
procedure Sum_Of_First_N_Cubes is
Columns : constant := 10; Width : constant := 8;
package Natural_Io is new Ada.Text_Io.Integer_Io (Natural); use Ada.Text_Io, Natural_Io;
Sum : Natural := 0;
begin
for N in 0 .. 49 loop Sum := Sum + N ** 3; Put (Sum, Width => Width); if N mod Columns = Columns - 1 then New_Line; end if; end loop; New_Line;
end Sum_Of_First_N_Cubes;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
ALGOL 68
As noted in the second factor example, the sum of the cubes to n is (n(n + 1))/2)^2, i.e. the square of the sum of the numbers to n. <lang algol68># show the sums of the first n cubes where 0 <= n < 50 # FOR i FROM 0 TO 49 DO
INT sum = ( i * ( i + 1 ) ) OVER 2; print( ( whole( sum * sum, -8 ) ) ); IF i MOD 10 = 9 THEN print( ( newline ) ) FI
OD</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
ALGOL W
<lang algolw>begin % show the sums of the cubes of n for 0 <= n < 50 %
integer cubeSum; cubeSum := 0; for n := 0 until 49 do begin cubeSum := cubeSum + ( n * n * n ); writeon( i_w := 8, s_w := 0, cubeSum ); if n rem 10 = 9 then write() end for_n
end.</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
APL
<lang APL>10 5⍴+\0,(⍳49)*3</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
AppleScript
<lang applescript>------------------- SUM OF FIRST N CUBES -----------------
-- sumsOfFirstNCubes :: Int -> [Int] on sumsOfFirstNCubes(n)
script go on |λ|(a, x) a + (x ^ 3) as integer end |λ| end script scanl(go, 0, enumFromTo(1, n - 1))
end sumsOfFirstNCubes
TEST -------------------------
on run
table(5, sumsOfFirstNCubes(50))
end run
GENERIC ------------------------
-- enumFromTo :: Int -> Int -> [Int] on enumFromTo(m, n)
if m ≤ n then set lst to {} repeat with i from m to n set end of lst to i end repeat lst else {} end if
end enumFromTo
-- scanl :: (b -> a -> b) -> b -> [a] -> [b]
on scanl(f, startValue, xs)
tell mReturn(f) set v to startValue set lng to length of xs set lst to {startValue} repeat with i from 1 to lng set v to |λ|(v, item i of xs, i, xs) set end of lst to v end repeat return lst end tell
end scanl
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper. if script is class of f then f else script property |λ| : f end script end if
end mReturn
FORMATTING ----------------------
-- table :: Int -> [String] -> String on table(n, xs)
-- A list of strings formatted as -- right-justified rows of n columns. set vs to map(my str, xs) set w to length of last item of vs unlines(map(my unwords, ¬ chunksOf(n, map(justifyRight(w, space), vs))))
end table
-- chunksOf :: Int -> [a] -> a
on chunksOf(k, xs)
script on go(ys) set ab to splitAt(k, ys) set a to item 1 of ab if {} ≠ a then {a} & go(item 2 of ab) else a end if end go end script result's go(xs)
end chunksOf
-- justifyRight :: Int -> Char -> String -> String
on justifyRight(n, cFiller)
script on |λ|(txt) if n > length of txt then text -n thru -1 of ((replicate(n, cFiller) as text) & txt) else txt end if end |λ| end script
end justifyRight
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f -- to each element of xs. tell mReturn(f) set lng to length of xs set lst to {} repeat with i from 1 to lng set end of lst to |λ|(item i of xs, i, xs) end repeat return lst end tell
end map
-- Egyptian multiplication - progressively doubling a list, appending
-- stages of doubling to an accumulator where needed for binary
-- assembly of a target length
-- replicate :: Int -> String -> String
on replicate(n, s)
-- Egyptian multiplication - progressively doubling a list, -- appending stages of doubling to an accumulator where needed -- for binary assembly of a target length script p on |λ|({n}) n ≤ 1 end |λ| end script script f on |λ|({n, dbl, out}) if (n mod 2) > 0 then set d to out & dbl else set d to out end if {n div 2, dbl & dbl, d} end |λ| end script set xs to |until|(p, f, {n, s, ""}) item 2 of xs & item 3 of xs
end replicate
-- splitAt :: Int -> [a] -> ([a], [a])
on splitAt(n, xs)
if n > 0 and n < length of xs then if class of xs is text then {items 1 thru n of xs as text, ¬ items (n + 1) thru -1 of xs as text} else {items 1 thru n of xs, items (n + 1) thru -1 of xs} end if else if n < 1 then {{}, xs} else {xs, {}} end if end if
end splitAt
-- str :: a -> String
on str(x)
x as string
end str
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation -- of a list of strings with the newline character. set {dlm, my text item delimiters} to ¬ {my text item delimiters, linefeed} set s to xs as text set my text item delimiters to dlm s
end unlines
-- until :: (a -> Bool) -> (a -> a) -> a -> a
on |until|(p, f, x)
set v to x set mp to mReturn(p) set mf to mReturn(f) repeat until mp's |λ|(v) set v to mf's |λ|(v) end repeat v
end |until|
-- unwords :: [String] -> String
on unwords(xs)
set {dlm, my text item delimiters} to ¬ {my text item delimiters, space} set s to xs as text set my text item delimiters to dlm return s
end unwords</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Arturo
<lang rebol>sumCubes: 0 loop split.every: 10 map 0..49 => [sumCubes: <= sumCubes + & ^ 3] 'a ->
print map a => [pad to :string & 7]</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
AutoHotkey
<lang AutoHotkey>pn := 0, result := "" loop 50 { n := SubStr(" " ((A_Index-1)**3 + pn), -6) result .= n (Mod(A_Index, 10)?"`t":"`n") pn := n } MsgBox % result</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
AWK
<lang AWK>
- syntax: GAWK -f SUM_OF_FIRST_N_CUBES.AWK
BEGIN {
start = 0 stop = 49 for (i=start; i<=stop; i++) { sum += i * i * i printf("%7d%1s",sum,++count%10?"":"\n") } printf("\nSum of cubes %d-%d: %d\n",start,stop,count) exit(0)
} </lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 Sum of cubes 0-49: 50
BASIC
BASIC256
<lang BASIC256> fila = 0 lenCubos = 49
cls print "Suma de N cubos para n = [0..49]" + chr(10)
for n = 0 to lenCubos sumCubos = 0 for m = 1 to n sumCubos += int(m ^ 3) next m fila += 1 print "" + sumCubos + " "; #Print Using " ####### "; sumCubos; if (fila % 5) = 0 then print next n
print chr(13) + "Encontrados " & fila & " cubos." end </lang>
FreeBASIC
<lang freebasic> Dim As Integer fila = 0, lenCubos = 49, sumCubos
CLs Print !"Suma de N cubos para n = [0..49]\n"
For n As Integer = 0 To lenCubos
sumCubos = 0 For m As Integer = 1 To n sumCubos += (m ^3) Next m fila += 1 'Print "" & sumCubos & " "; Print Using " ####### "; sumCubos; If fila Mod 5 = 0 Then Print
Next n
Print !"\nEncontrados " & fila & " cubos." Sleep </lang>
- Output:
Suma de N cubos para n = [0..49] 0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 Encontrados 50 cubos.
GW-BASIC
<lang gwbasic>10 FOR N=0 TO 49 20 C#=C#+N^3 30 PRINT C#; 40 NEXT N</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884
164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 138297
6 1500625
QBasic
<lang qbasic>DEFLNG A-Z
fila = 0 lenCubos = 49
CLS PRINT "Suma de N cubos para n = [0..49]" + CHR$(10)
FOR n = 0 TO lenCubos
sumCubos = 0 FOR m = 1 TO n sumCubos = sumCubos + (m ^ 3) NEXT m fila = fila + 1 PRINT USING " ####### "; sumCubos; IF fila MOD 5 = 0 THEN PRINT
NEXT n
PRINT CHR$(13) + "Encontrados"; fila; "cubos." END</lang>
Tiny BASIC
Limited to 0 through 19 because integers only go up to 32767. <lang tinybasic>10 LET C = 0 20 LET N = 0 30 LET C = C + N*N*N 40 PRINT C 50 LET N = N + 1 60 IF N = 19 THEN END 70 GOTO 30</lang>
Yabasic
<lang Yabasic> fila = 0 lenCubos = 49
clear screen print "Suma de N cubos para n = [0..49]\n"
for n = 0 to lenCubos
sumCubos = 0 for m = 1 to n sumCubos = sumCubos + (m ^3) next m fila = fila + 1 print "", sumCubos, " "; if mod(fila, 5) = 0 then print : fi
next n
print "\nEncontrados ", fila, " cubos.\n" end </lang>
BQN
<lang bqn>∘‿5⥊+`(↕50)⋆3</lang>
- Output:
┌─ ╵ 0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 ┘
C
<lang c>#include <stdio.h>
int main() {
for (int i = 0, sum = 0; i < 50; ++i) { sum += i * i * i; printf("%7d%c", sum, (i + 1) % 5 == 0 ? '\n' : ' '); } return 0;
}</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
C#
No multiplication or exponentiation, just addition. <lang csharp>using System; using static System.Console; class Program { static void Main(string[] args) {
for (int i=0,j=-6,k=1,c=0,s=0;s<1600000;s+=c+=k+=j+=6) Write("{0,-7}{1}",s, (i+=i==3?-4:1)==0?"\n":" "); } }</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
C++
<lang cpp>#include <array>
- include <cstdio>
- include <numeric>
void PrintContainer(const auto& vec) {
int count = 0; for(auto value : vec) { printf("%7d%c", value, ++count % 10 == 0 ? '\n' : ' '); }
}
int main() {
// define a lambda that cubes a value auto cube = [](auto x){return x * x * x;};
// create an array and use iota to fill it with {0, 1, 2, ... 49} std::array<int, 50> a; std::iota(a.begin(), a.end(), 0);
// transform_inclusive_scan will cube all of the values in the array and then // perform a partial sum from index 0 to n and place the result back into the // array at index n std::transform_inclusive_scan(a.begin(), a.end(), a.begin(), std::plus{}, cube); PrintContainer(a);
}</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
COBOL
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. SUM-OF-CUBES.
DATA DIVISION. WORKING-STORAGE SECTION. 01 VARIABLES. 03 STEP PIC 99. 03 CUBE PIC 9(7). 03 CUBE-SUM PIC 9(7) VALUE 0. 01 OUTPUT-FORMAT. 03 OUT-LINE PIC X(40) VALUE SPACES. 03 OUT-PTR PIC 99 VALUE 1. 03 OUT-NUM PIC Z(7)9.
PROCEDURE DIVISION. BEGIN. PERFORM ADD-CUBE VARYING STEP FROM 0 BY 1 UNTIL STEP IS EQUAL TO 50. STOP RUN.
ADD-CUBE. COMPUTE CUBE = STEP ** 3. ADD CUBE TO CUBE-SUM. MOVE CUBE-SUM TO OUT-NUM. STRING OUT-NUM DELIMITED BY SIZE INTO OUT-LINE WITH POINTER OUT-PTR. IF OUT-PTR IS EQUAL TO 41, DISPLAY OUT-LINE, MOVE 1 TO OUT-PTR.</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Cowgol
<lang cowgol>include "cowgol.coh";
sub cube(n: uint32): (r: uint32) is
r := n * n * n;
end sub;
var i: uint8 := 0; var sum: uint32 := 0; while i < 50 loop
sum := sum + cube(i as uint32); print_i32(sum); i := i + 1; if i % 10 == 0 then print_nl(); else print_char(' '); end if;
end loop;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Excel
LAMBDA
Binding the names SUMNCUBES and BINCOEFF to the following lambda expressions in the Name Manager of the Excel WorkBook:
(See LAMBDA: The ultimate Excel worksheet function)
<lang lisp>SUMNCUBES =LAMBDA(n,
BINCOEFF(1 + n)(2) ^ 2
)
BINCOEFF =LAMBDA(n,
LAMBDA(k, IF(n < k, 0, QUOTIENT(FACT(n), FACT(k) * FACT(n - k)) ) )
)</lang>
The single formula in cell B2 below defines a dynamic array which populates the whole B2:K6 grid:
- Output:
fx | =SUMNCUBES( SEQUENCE(5, 10, 0, 1) ) | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|
A | B | C | D | E | F | G | H | I | J | K | ||
1 | Sum of N cubes for n = [0..49] | |||||||||||
2 | 0 | 1 | 9 | 36 | 100 | 225 | 441 | 784 | 1296 | 2025 | ||
3 | 3025 | 4356 | 6084 | 8281 | 11025 | 14400 | 18496 | 23409 | 29241 | 36100 | ||
4 | 44100 | 53361 | 64009 | 76176 | 89401 | 105625 | 123201 | 142129 | 164025 | 189225 | ||
5 | 216225 | 245025 | 278784 | 313600 | 352836 | 396900 | 443556 | 492804 | 549081 | 608400 | ||
6 | 670761 | 739600 | 815409 | 894916 | 980100 | 1069156 | 1168561 | 1270129 | 1382976 | 1500625 |
F#
<lang fsharp> // Sum of cubes: Nigel Galloway. May 20th., 2021 let fN g=g*g*g in Seq.initInfinite((+)1>>fN)|>Seq.take 49|>Seq.scan((+))(0)|>Seq.iter(printf "%d "); printfn "" </lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Factor
<lang factor>USING: grouping math math.functions prettyprint sequences ;
50 <iota> 0 [ 3 ^ + ] accumulate* 10 group simple-table.</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Alternatively, this is the same as the triangular numbers squared, where the triangular numbers are given by
Tn = n(n + 1) / 2
<lang factor>USING: grouping kernel math prettyprint sequences ;
- triangular ( n -- m ) dup 1 + * 2/ ;
50 <iota> [ triangular sq ] map 10 group simple-table.</lang>
- Output:
As above.
Fermat
<lang fermat>c:=0 for n = 0 to 49 do
c:=c+n^3; !(c,' ');
od;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Forth
<lang forth>: sum-cubes ( n -- )
0 swap 0 do i i i * * + dup 7 .r i 1+ 5 mod 0= if cr else space then loop drop ;
50 sum-cubes bye</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Go
<lang go>package main
import (
"fmt" "rcu"
)
func main() {
fmt.Println("Cumulative sums of the first 50 cubes:") sum := 0 for n := 0; n < 50; n++ { sum += n * n * n fmt.Printf("%9s ", rcu.Commatize(sum)) if n%10 == 9 { fmt.Println() } } fmt.Println()
</lang>
- Output:
Cumulative sums of the first 50 cubes: 0 1 9 36 100 225 441 784 1,296 2,025 3,025 4,356 6,084 8,281 11,025 14,400 18,496 23,409 29,241 36,100 44,100 53,361 64,009 76,176 90,000 105,625 123,201 142,884 164,836 189,225 216,225 246,016 278,784 314,721 354,025 396,900 443,556 494,209 549,081 608,400 672,400 741,321 815,409 894,916 980,100 1,071,225 1,168,561 1,272,384 1,382,976 1,500,625
Haskell
<lang haskell>import Data.List (intercalate, transpose) import Data.List.Split (chunksOf) import Text.Printf (printf)
SUM OF FIRST N CUBES -----------------
sumOfFirstNCubes :: Integer -> Integer sumOfFirstNCubes =
(^ 2) . flip binomialCoefficient 2 . succ
TEST -------------------------
main :: IO () main =
putStrLn $ table " " $ chunksOf 10 $ show . sumOfFirstNCubes <$> [0 .. 49]
GENERIC ------------------------
binomialCoefficient :: Integer -> Integer -> Integer binomialCoefficient n k
| n < k = 0 | otherwise = div (factorial n) (factorial k * factorial (n - k))
factorial :: Integer -> Integer factorial = product . enumFromTo 1
DISPLAY ------------------------
table :: String -> String -> String table gap rows =
let ws = maximum . fmap length <$> transpose rows pw = printf . flip intercalate ["%", "s"] . show in unlines $ intercalate gap . zipWith pw ws <$> rows</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Or, in terms of scanl:
<lang haskell>import Data.List (intercalate, scanl, transpose)
import Data.List.Split (chunksOf)
import Text.Printf (printf)
SUM OF FIRST N CUBES -----------------
sumsOfFirstNCubes :: Int -> [Int] sumsOfFirstNCubes n =
scanl (\a x -> a + x ^ 3) 0 [1 .. pred n]
TEST -------------------------
main :: IO () main =
(putStrLn . table " " . chunksOf 5) $ show <$> sumsOfFirstNCubes 50
DISPLAY ------------------------
table :: String -> String -> String table gap rows =
let ws = maximum . fmap length <$> transpose rows pw = printf . flip intercalate ["%", "s"] . show in unlines $ intercalate gap . zipWith pw ws <$> rows</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
J
<lang J>10 5$+/\(i.^3:)50x</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
JavaScript
<lang javascript>(() => {
"use strict";
// -------------- SUM OF FIRST N CUBES ---------------
// sumsOfFirstNCubes :: Int -> [Int] const sumsOfFirstNCubes = n => // Cumulative sums of first n cubes. scanl( a => x => a + (x ** 3) )(0)( enumFromTo(1)(n - 1) );
// ---------------------- TEST ----------------------- // main :: IO () const main = () => table(" ")(justifyRight)( chunksOf(5)( sumsOfFirstNCubes(50) .map(x => `${x}`) ) );
// --------------------- GENERIC ---------------------
// enumFromTo :: Int -> Int -> [Int] const enumFromTo = m => n => Array.from({ length: 1 + n - m }, (_, i) => m + i);
// scanl :: (b -> a -> b) -> b -> [a] -> [b] const scanl = f => startValue => xs => // The series of interim values arising // from a catamorphism. Parallel to foldl. xs.reduce((a, x) => { const v = f(a[0])(x);
return [v, a[1].concat(v)]; }, [startValue, [startValue]])[1];
// ------------------- FORMATTING --------------------
// chunksOf :: Int -> [a] -> a const chunksOf = n => { // xs split into sublists of length n. // The last sublist will be short if n // does not evenly divide the length of xs . const go = xs => { const chunk = xs.slice(0, n);
return 0 < chunk.length ? ( [chunk].concat( go(xs.slice(n)) ) ) : []; };
return go; };
// compose (<<<) :: (b -> c) -> (a -> b) -> a -> c const compose = (...fs) => // A function defined by the right-to-left // composition of all the functions in fs. fs.reduce( (f, g) => x => f(g(x)), x => x );
// flip :: (a -> b -> c) -> b -> a -> c const flip = op => // The binary function op with // its arguments reversed. 1 < op.length ? ( (a, b) => op(b, a) ) : (x => y => op(y)(x));
// intercalate :: String -> [String] -> String const intercalate = s => // The concatenation of xs // interspersed with copies of s. xs => xs.join(s);
// justifyRight :: Int -> Char -> String -> String const justifyRight = n => // The string s, preceded by enough padding (with // the character c) to reach the string length n. c => s => Boolean(s) ? ( s.padStart(n, c) ) : "";
// maximum :: Ord a => [a] -> a const maximum = xs => ( // The largest value in a non-empty list. ys => 0 < ys.length ? ( ys.slice(1).reduce( (a, y) => y > a ? ( y ) : a, ys[0] ) ) : undefined )(xs);
// table :: String -> // (Int -> Char -> String -> String) -> // String -> String const table = gap => // A tabulation of rows of string values, // with a specified gap between columns, // and choice of cell alignment function // (justifyLeft | center | justifyRight) alignment => rows => { const colWidths = transpose(rows).map( row => maximum(row.map(x => x.length)) );
return rows.map( compose( intercalate(gap), zipWith( flip(alignment)(" ") )(colWidths) ) ).join("\n"); };
// transpose :: a -> a const transpose = rows => { // If any rows are shorter than those that follow, // their elements are skipped: // > transpose [[10,11],[20],[],[30,31,32]] // == [[10,20,30],[11,31],[32]] const go = xss => 0 < xss.length ? (() => { const h = xss[0], t = xss.slice(1);
return 0 < h.length ? [ [h[0]].concat(t.reduce( (a, xs) => a.concat( 0 < xs.length ? ( [xs[0]] ) : [] ), [] )) ].concat(go([h.slice(1)].concat( t.map(xs => xs.slice(1)) ))) : go(t); })() : [];
return go(rows); };
// zipWith :: (a -> b -> c) -> [a] -> [b] -> [c] const zipWith = f => // A list constructed by zipping with a // custom function, rather than with the // default tuple constructor. xs => ys => xs.map( (x, i) => f(x)(ys[i]) ).slice( 0, Math.min(xs.length, ys.length) );
// MAIN --- return main();
})();</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
jq
Works with gojq, the Go implementation of jq <lang jq>
- For the sake of stream-processing efficiency:
def add(s): reduce s as $x (0; . + $x);
def sum_of_cubes: add(range(0;.) | .*.*.);</lang> The task <lang jq> range(0;50) | sum_of_cubes as $sum | "\(.) => \($sum)"</lang>
- Output:
0 => 0 1 => 0 2 => 1 3 => 9 4 => 36 5 => 100 ... 45 => 980100 46 => 1071225 47 => 1168561 48 => 1272384 49 => 1382976
Using gojq, the Go implementation of jq, unbounded-precision integer arithmetic allows e.g.
1000000 | sum_of_cubes #=> 249999500000250000000000
Julia
<lang julia>cubesumstil(N = 49, s = 0) = (foreach(n -> print(lpad(s += n^3, 8), n % 10 == 9 ? "\n" : ""), 0:N))
cubesumstil()
</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Alternatively, and using the REPL, note that recent versions of Julia implement the accumulate function: <lang julia> julia> println(accumulate((x, y) -> x + y^3, 0:49))
[0, 1, 9, 36, 100, 225, 441, 784, 1296, 2025, 3025, 4356, 6084, 8281, 11025, 14400, 18496, 23409, 29241, 36100, 44100, 53361, 64009, 76176, 90000, 105625, 123201, 142884, 164836, 189225, 216225, 246016, 278784, 314721, 354025, 396900, 443556, 494209, 549081, 608400, 672400, 741321, 815409, 894916, 980100, 1071225, 1168561, 1272384, 1382976, 1500625] </lang>
MAD
<lang mad> NORMAL MODE IS INTEGER
SUM = 0 THROUGH LOOP, FOR STEP = 0, 1, STEP.GE.50 SUM = SUM + STEP * STEP * STEP
LOOP PRINT FORMAT FMT, SUM
VECTOR VALUES FMT = $I9*$ END OF PROGRAM </lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Mathematica /Wolfram Language
<lang Mathematica>Accumulate[Range[0, 49]^3]</lang>
- Output:
{0,1,9,36,100,225,441,784,1296,2025,3025,4356,6084,8281,11025,14400,18496,23409,29241,36100,44100,53361,64009,76176,90000,105625,123201,142884,164836,189225,216225,246016,278784,314721,354025,396900,443556,494209,549081,608400,672400,741321,815409,894916,980100,1071225,1168561,1272384,1382976,1500625}
Nim
<lang Nim>import strutils
var s = 0 for n in 0..49:
s += n * n * n stdout.write ($s).align(7), if (n + 1) mod 10 == 0: '\n' else: ' '</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
PARI/GP
<lang parigp>c=0;for(n=0,49,c=c+n^3;print(c))</lang>
Perl
<lang perl>#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Sum_of_first_n_cubes use warnings;
my $sum = 0; printf "%10d%s", $sum += $_ ** 3, $_ % 5 == 4 && "\n" for 0 .. 49;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Phix
The commented out line is based on the Factor entry, and is clearly a much faster way to get the same results.
function sum_first_n_cubes(integer n) return sum(sq_power(tagset(n),3)) end function --function sum_first_n_cubes(integer n) return power(n*(n+1)/2,2) end function sequence res = apply(tagset(49,0),sum_first_n_cubes) printf(1,"%s\n",{join_by(apply(true,sprintf,{{"%,9d"},res}),1,10)})
- Output:
0 1 9 36 100 225 441 784 1,296 2,025 3,025 4,356 6,084 8,281 11,025 14,400 18,496 23,409 29,241 36,100 44,100 53,361 64,009 76,176 90,000 105,625 123,201 142,884 164,836 189,225 216,225 246,016 278,784 314,721 354,025 396,900 443,556 494,209 549,081 608,400 672,400 741,321 815,409 894,916 980,100 1,071,225 1,168,561 1,272,384 1,382,976 1,500,625
Plain English
<lang plainenglish>To run: Start up. Show the sums of cubes given 49. Wait for the escape key. Shut down.
To show the sums of cubes given a number: If a counter is past the number, exit. Put the counter plus 1 times the counter into a result number. Cut the result in half. Raise the result to 2. Write the result then " " on the console without advancing. If the counter is evenly divisible by 5, write "" on the console. Repeat.</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
PL/I
<lang pli>cubeSum: procedure options(main);
declare (i, csum) fixed decimal(7); csum = 0; do i=0 to 49; csum = csum + i * i * i; put list(csum); if mod(i,5) = 4 then put skip; end;
end cubeSum;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
PL/M
The original 8080 PL/M compiler only supported 8 and 16 bit unsigned arithmetic, so this sample only shows the sums < 65536. <lang pli>100H: /* SHOW THE SUMS OF THE FIRST N CUBES, 0 <= N < 23 */
/* CP/M BDOS SYSTEM CALL */ BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5; END; /* I/O ROUTINES */ PRINT$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END; PRINT$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END; PRINT$NUMBER: PROCEDURE( N ); DECLARE N ADDRESS; DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE; N$STR( W := LAST( N$STR ) ) = '$'; N$STR( W := W - 1 ) = '0' + ( ( V := N ) MOD 10 ); DO WHILE( W > 0 ); N$STR( W := W - 1 ) = ' '; IF V > 0 THEN DO; IF ( V := V / 10 ) > 0 THEN N$STR( W ) = '0' + ( V MOD 10 ); END; END; CALL PRINT$STRING( .N$STR ); END PRINT$NUMBER;
/* SHOW SUMS OF CUBES */ DECLARE ( I, SUM ) ADDRESS; DO I = 0 TO 22; SUM = ( I * ( I + 1 ) ) / 2; CALL PRINT$CHAR( ' ' ); CALL PRINT$NUMBER( SUM * SUM ); IF I MOD 10 = 9 THEN CALL PRINT$STRING( .( 0DH, 0AH, '$' ) ); END;
EOF</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009
Python
Python :: Procedural
<lang python> def main():
fila = 0 lenCubos = 51
print("Suma de N cubos para n = [0..49]\n")
for n in range(1, lenCubos): sumCubos = 0 for m in range(1, n): sumCubos = sumCubos + (m ** 3) fila += 1 print(f'{sumCubos:7} ', end=) if fila % 5 == 0: print(" ")
print(f"\nEncontrados {fila} cubos.")
if __name__ == '__main__': main() </lang>
- Output:
Suma de N cubos para n = [0..49] 0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 Encontrados 50 cubos.
Python :: Functional
<lang python>Sum of first N cubes
from math import factorial
- sumOfFirstNCubes :: Int -> Int
def sumOfFirstNCubes(n):
The sum of the first n cubes. return binomialCoefficient(1 + n)(2) ** 2
- ------------------------- TEST -------------------------
- main :: IO ()
def main():
First fifty values (N drawn from [0 .. 49]) print( table(10)([ str(sumOfFirstNCubes(n)) for n in range(0, 1 + 49) ]) )
- ----------------------- GENERIC ------------------------
- binomialCoefficient :: Int -> Int -> Int
def binomialCoefficient(n):
The coefficient of the term x^k in the polynomial expansion of the binomial power (1 + x)^n def go(k): return 0 if n < k else factorial(n) // ( factorial(k) * factorial(n - k) ) return go
- ----------------------- DISPLAY ------------------------
- chunksOf :: Int -> [a] -> a
def chunksOf(n):
A series of lists of length n, subdividing the contents of xs. Where the length of xs is not evenly divisible, the final list will be shorter than n. def go(xs): return ( xs[i:n + i] for i in range(0, len(xs), n) ) if 0 < n else None return go
- table :: Int -> [String] -> String
def table(n):
A list of strings formatted as right-justified rows of n columns. def go(xs): w = len(xs[-1]) return '\n'.join( ' '.join(row) for row in chunksOf(n)([ s.rjust(w, ' ') for s in xs ]) ) return go
- MAIN ---
if __name__ == '__main__':
main()</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
or, as a scanning accumulation:
<lang python>Sum of first N cubes
from itertools import accumulate
- sumsOfFirstNCubes :: Int -> [Int]
def sumsOfFirstNCubes(n):
Cumulative sums of the first N cubes. def go(a, x): return a + x ** 3
return accumulate(range(0, n), go)
- ------------------------- TEST -------------------------
- main :: IO ()
def main():
Cumulative sums of first 50 cubes print( table(5)([ str(n) for n in sumsOfFirstNCubes(50) ]) )
- ---------------------- FORMATTING ----------------------
- chunksOf :: Int -> [a] -> a
def chunksOf(n):
A series of lists of length n, subdividing the contents of xs. Where the length of xs is not evenly divisible, the final list will be shorter than n. def go(xs): return ( xs[i:n + i] for i in range(0, len(xs), n) ) if 0 < n else None return go
- table :: Int -> [String] -> String
def table(n):
A list of strings formatted as right-justified rows of n columns. def go(xs): w = len(xs[-1]) return '\n'.join( ' '.join(row) for row in chunksOf(n)([ s.rjust(w, ' ') for s in xs ]) ) return go
- MAIN ---
if __name__ == '__main__':
main()</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Quackery
<lang Quackery> $ "" 0
50 times [ i^ 3 ** + dup dip [ number$ join space join ] ] drop nest$ 65 wrap$</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
R
This only takes one line. <lang R>cumsum((0:49)^3)</lang>
- Output:
[1] 0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 [17] 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 [33] 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 [49] 1382976 1500625
Raku
<lang perl6>my @sums_of_all_cubes = [\+] ^Inf X** 3;
say .fmt('%7d') for @sums_of_all_cubes.head(50).batch(10);</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
REXX
<lang rexx>/*REXX program finds and displays a number of sums of the first N cubes, where N < 50 */ parse arg n cols . /*obtain optional argument from the CL.*/ if n== | n=="," then n= 50 /*Not specified? Then use the default.*/ if cols== | cols=="," then cols= 10 /* " " " " " " */ w= 12 /*width of a number in any column. */
title= ' cube sums, where N < ' commas(n)
say ' index │'center(title, 1 + cols*(w+1) ) say '───────┼'center("" , 1 + cols*(w+1), '─') found= 0; idx= 0 /*initialize the number for the index. */ $=; sum= 0 /*a list of the sum of N cubes. . */
do j=0 for n; sum= sum + j**3 /*compute the sum of this cube + others*/ found= found + 1 /*bump the number of sums shown. */ c= commas(sum) /*maybe add commas to the number. */ $= $ right(c, max(w, length(c) ) ) /*add a sum of N cubes to the $ list.*/ if found//cols\==0 then iterate /*have we populated a line of output? */ say center(idx, 7)'│' substr($, 2); $= /*display what we have so far (cols). */ idx= idx + cols /*bump the index count for the output*/ end /*j*/
if $\== then say center(idx, 7)"│" substr($, 2) /*possible display residual output.*/ say '───────┴'center("" , 1 + cols*(w+1), '─') say say 'Found ' commas(found) title exit 0 /*stick a fork in it, we're all done. */ /*──────────────────────────────────────────────────────────────────────────────────────*/ commas: parse arg ?; do jc=length(?)-3 to 1 by -3; ?=insert(',', ?, jc); end; return ?</lang>
- output when using the default inputs:
(Shown at five-sixth size.)
index │ cube sums, where N < 50 ───────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── 0 │ 0 1 9 36 100 225 441 784 1,296 2,025 10 │ 3,025 4,356 6,084 8,281 11,025 14,400 18,496 23,409 29,241 36,100 20 │ 44,100 53,361 64,009 76,176 90,000 105,625 123,201 142,884 164,836 189,225 30 │ 216,225 246,016 278,784 314,721 354,025 396,900 443,556 494,209 549,081 608,400 40 │ 672,400 741,321 815,409 894,916 980,100 1,071,225 1,168,561 1,272,384 1,382,976 1,500,625 ───────┴─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── Found 50 cube sums, where N < 50
Ring
<lang ring> see "working..." + nl see "Sum of first n cubes:" + nl row = 0 lenCubes = 49
for n = 0 to lenCubes
sumCubes = 0 for m = 1 to n sumCubes = sumCubes + pow(m,3) next row = row + 1 see "" + sumCubes + " " if row%5 = 0 see nl ok
next
see "Found " + row + " cubes" + nl see "done..." + nl </lang>
- Output:
working... Sum of first n cubes: 0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625 Found 50 cubes done...
Rust
<lang rust>fn main() {
(0..50) .scan(0, |sum, x| { *sum += x * x * x; Some(*sum) }) .enumerate() .for_each(|(i, n)| { print!("{:7}", n); if (i + 1) % 5 == 0 { println!(); } else { print!(" "); } });
}</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Seed7
<lang seed7>$ include "seed7_05.s7i";
const proc: main is func
local var integer: n is 0; begin for n range 0 to 49 do write((n * (n + 1) >> 1) ** 2 lpad 8); if n rem 5 = 4 then writeln; end if; end for; end func;</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Sidef
<lang ruby>0..49 -> map { .faulhaber_sum(3) }.slices(5).each { .join(' ').say }</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Wren
<lang ecmascript>import "/fmt" for Fmt
System.print("Cumulative sums of the first 50 cubes:") var sum = 0 for (n in 0..49) {
sum = sum + n * n * n Fmt.write("$,9d ", sum) if ((n % 10) == 9) System.print()
} System.print()</lang>
- Output:
Cumulative sums of the first 50 cubes: 0 1 9 36 100 225 441 784 1,296 2,025 3,025 4,356 6,084 8,281 11,025 14,400 18,496 23,409 29,241 36,100 44,100 53,361 64,009 76,176 90,000 105,625 123,201 142,884 164,836 189,225 216,225 246,016 278,784 314,721 354,025 396,900 443,556 494,209 549,081 608,400 672,400 741,321 815,409 894,916 980,100 1,071,225 1,168,561 1,272,384 1,382,976 1,500,625
X86 Assembly
<lang asm> 1 ;Assemble with: tasm, tlink /t
2 0000 .model tiny 3 0000 .code 4 .386 5 org 100h ;.com program starts here 6 7 ; eax: working register 8 ; ebx: 10 for divide 9 ; cx: numout digit counter 10 ; edx: divide remainder 11 ; esi: Sum 12 ; edi: N 13 ; bp: column position for tab 14 15 0100 66| 33 F6 start: xor esi, esi ;Sum:= 0 16 0103 33 ED xor bp, bp ;reset column position 17 0105 66| 33 FF xor edi, edi ;N:= 0 18 0108 66| 8B C7 sum: mov eax, edi ;Sum:= N^3 + Sum 19 010B 66| F7 EF imul edi ;eax:= edi^3 + esi 20 010E 66| F7 EF imul edi 21 0111 66| 03 C6 add eax, esi 22 23 0114 66| 8B F0 mov esi, eax 24 0117 66| BB 0000000A mov ebx, 10 ;output number in eax 25 011D 33 C9 xor cx, cx ;digit counter 26 011F 66| 99 no10: cdq ;edx:= 0 (extend sign of eax into edx) 27 0121 66| F7 FB idiv ebx ;(edx:eax)/ebx 28 0124 52 push dx ;save remainder 29 0125 41 inc cx ;count digit 30 0126 66| 85 C0 test eax, eax ;loop for all digits 31 0129 75 F4 jne no10 32 33 012B 58 no20: pop ax ;get remainder 34 012C 04 30 add al, '0' ;convert to ASCII 35 012E CD 29 int 29h ;output digit 36 0130 45 inc bp ;bump column position 37 0131 E2 F8 loop no20 ;loop for cx digits 38 39 0133 B0 20 tab: mov al, 20h ;output spaces until tab stop 40 0135 CD 29 int 29h 41 0137 45 inc bp ;bump column position 42 0138 F7 C5 0007 test bp, 7 ;loop until it's a multiple of 8 43 013C 75 F5 jne tab 44 45 013E 8B C7 mov ax, di ;if remainder(di/5) = 4 then CR LF 46 0140 D4 05 aam 5 ;ah:= al/5; al:= remainder 47 0142 3C 04 cmp al, 4 48 0144 75 0A jne next 49 0146 B0 0D mov al, 0Dh ;CR 50 0148 CD 29 int 29h 51 014A 33 ED xor bp, bp ;reset column position 52 014C B0 0A mov al, 0Ah ;LF 53 014E CD 29 int 29h 54 0150 47 next: inc di ;next N 55 0151 83 FF 32 cmp di, 50 ;loop until done 56 0154 7C B2 jl sum 57 0156 C3 ret 58 59 end start</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
XPL0
<lang XPL0>int N, S; [S:= 0; for N:= 0 to 49 do
[S:= S + N*N*N; IntOut(0, S); ChOut(0, 9\tab\); if rem(N/5) = 4 then CrLf(0); ];
]</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
Zig
<lang zig>pub fn main() !void {
const stdout = @import("std").io.getStdOut().writer(); var sum: u32 = 0; var i: u32 = 0;
while (i < 50) : (i += 1) { sum += i * i * i; try stdout.print("{d:8}", .{sum}); if (i % 5 == 4) try stdout.print("\n", .{}); }
}</lang>
- Output:
0 1 9 36 100 225 441 784 1296 2025 3025 4356 6084 8281 11025 14400 18496 23409 29241 36100 44100 53361 64009 76176 90000 105625 123201 142884 164836 189225 216225 246016 278784 314721 354025 396900 443556 494209 549081 608400 672400 741321 815409 894916 980100 1071225 1168561 1272384 1382976 1500625
- Draft Programming Tasks
- Ada
- ALGOL 68
- ALGOL W
- APL
- AppleScript
- Arturo
- AutoHotkey
- AWK
- BASIC
- BASIC256
- FreeBASIC
- GW-BASIC
- QBasic
- Tiny BASIC
- Yabasic
- BQN
- C
- C sharp
- C++
- COBOL
- Cowgol
- Excel
- F Sharp
- Factor
- Fermat
- Forth
- Go
- Go-rcu
- Haskell
- J
- JavaScript
- Jq
- Julia
- MAD
- Mathematica
- Wolfram Language
- Nim
- PARI/GP
- Perl
- Phix
- Plain English
- PL/I
- PL/M
- Python
- Quackery
- R
- Raku
- REXX
- Ring
- Rust
- Seed7
- Sidef
- Wren
- X86 Assembly
- XPL0
- Zig