Square but not cube: Difference between revisions
| Line 704: | Line 704: | ||
<lang basic>100 DIM SC(2):SC=0: REM REMEMBER SQUARE CUBES |
<lang basic>100 DIM SC(2):SC=0: REM REMEMBER SQUARE CUBES |
||
110 PRINT "SQUARES BUT NOT CUBES:" |
110 PRINT "SQUARES BUT NOT CUBES:" |
||
120 I=1: CU=1: SQ=1: RT=1: |
120 I=1: CU=1: SQ=1: RT=1: N=0 |
||
130 IF N=30 THEN 200 |
130 IF N=30 THEN 200 |
||
140 SQ=I*I |
140 SQ=I*I |
||
Revision as of 13:42, 6 September 2021
You are encouraged to solve this task according to the task description, using any language you may know.
- Task
Show the first 30 positive integers which are squares but not cubes of such integers.
Optionally, show also the first 3 positive integers which are both squares and cubes, and mark them as such.
11l
<lang 11l>V n = 1 V count = 0
L count < 30
V sq = n * n
V cr = Int(sq ^ (1/3) + 1e-6)
I cr * cr * cr != sq
count++
print(sq)
E
print(sq‘ is square and cube’)
n++</lang>
8086 Assembly
<lang asm> cpu 8086 org 100h section .text mov si,1 ; Square counter mov di,si ; Current square mov bp,si ; Cube counter mov bx,si ; Current cube xor cx,cx ; Counter loop: cmp di,bx ; Square > cube? jbe check inc bp ; Calculate next cube mov ax,bp mul bp mul bp mov bx,ax jmp loop check: je next ; Square != cube? inc cx ; Then count it mov ax,di call print ; Print it next: inc si ; Next square mov ax,si mul si mov di,ax cmp cx,30 ; Done yet? jb loop ret print: push bx ; Print AX - save registers push cx mov cx,10 mov bx,num ; End of number buffer dgt: xor dx,dx ; Extract digit div cx add dl,'0' dec bx ; Store digit mov [bx],dl test ax,ax ; More digits? jnz dgt ; If so, go get them mov dx,bx ; If not, print string mov ah,9 int 21h pop cx ; Restore registers pop bx ret section .data db '*****' ; Placeholder for number num: db ' $'</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
Ada
<lang Ada>with Ada.Text_IO;
procedure Square_But_Not_Cube is
function Is_Cube (N : in Positive) return Boolean is
Cube : Positive;
begin
for I in Positive loop
Cube := I**3;
if Cube = N then return True;
elsif Cube > N then return False;
end if;
end loop;
raise Program_Error;
end Is_Cube;
procedure Show (Limit : in Natural) is
Count : Natural := 0;
Square : Natural;
use Ada.Text_IO;
begin
for N in Positive loop
Square := N**2;
if not Is_Cube (Square) then
Count := Count + 1;
Put (Square'Image);
exit when Count = Limit;
end if;
end loop;
New_Line;
end Show;
begin
Show (Limit => 30);
end Square_But_Not_Cube;</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
ALGOL 68
Avoids computing cube roots. <lang algol68>BEGIN
# list the first 30 numbers that are squares but not cubes and also #
# show the numbers that are both squares and cubes #
INT count := 0;
INT c := 1;
INT c3 := 1;
FOR s WHILE count < 30 DO
INT sq = s * s;
WHILE c3 < sq DO
c +:= 1;
c3 := c * c * c
OD;
print( ( whole( sq, -5 ) ) );
IF c3 = sq THEN
# the square is also a cube #
print( ( " is also the cube of ", whole( c, -5 ) ) )
ELSE
# square only #
count +:= 1
FI;
print( ( newline ) )
OD
END</lang>
- Output:
1 is also the cube of 1
4
9
16
25
36
49
64 is also the cube of 4
81
100
121
144
169
196
225
256
289
324
361
400
441
484
529
576
625
676
729 is also the cube of 9
784
841
900
961
1024
1089
ALGOL-M
<lang algolm>begin integer function square(x); integer x; square := x * x;
integer function cube(x); integer x; cube := x * x * x;
integer c, s, seen; seen := 0; while seen < 30 do begin
while cube(c) < square(s) do
c := c + 1;
if square(s) <> cube(c) then
begin
if (seen/5 <> (seen-1)/5) then write("");
writeon(square(s));
seen := seen + 1;
end;
s := s + 1;
end; end</lang>
- Output:
4 9 16 25 36
49 81 100 121 144
169 196 225 256 289
324 361 400 441 484
529 576 625 676 784
841 900 961 1024 1089
APL
<lang APL>(×⍨∘⍳ ~ (⊢×⊢×⊢)∘⍳) 33</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
AppleScript
<lang applescript>on run
script listing
on |λ|(x)
set sqr to x * x
set strSquare to sqr as text
if isCube(sqr) then
strSquare & " (also cube)"
else
strSquare
end if
end |λ|
end script
unlines(map(listing, ¬
enumFromTo(1, 33)))
end run
-- isCube :: Int -> Bool on isCube(x)
x = (round (x ^ (1 / 3))) ^ 3
end isCube
-- GENERIC FUNCTIONS -------------------------------------------------
-- 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
return lst
else
return {}
end if
end enumFromTo
-- map :: (a -> b) -> [a] -> [b] on map(f, 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
-- Lift 2nd class handler function into 1st class script wrapper -- mReturn :: First-class m => (a -> b) -> m (a -> b) on mReturn(f)
if class of f is script then
f
else
script
property |λ| : f
end script
end if
end mReturn
-- unlines :: [String] -> String on unlines(xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set str to xs as text
set my text item delimiters to dlm
str
end unlines</lang>
- Output:
1 (also cube) 4 9 16 25 36 49 64 (also cube) 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 (also cube) 784 841 900 961 1024 1089
Arturo
<lang rebol>squares: map 1..100 => [&^2] cubes: map 1..100 => [&^3]
print "Square but not cube:" print first.n:30 select squares => [not? in? & cubes] print "Square and cube:" print first.n:3 select squares => [in? & cubes]</lang>
- Output:
Square but not cube: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 Square and cube: 1 64 729
AutoHotkey
<lang AutoHotkey>cube := [], counter:=0 while counter<30 { cube[(n := A_Index)**3] := true if !cube[n**2] counter++, res .= n**2 " " else res .= "[" n**2 "] " } MsgBox % Trim(res, " ")</lang> square and cube numbers are denoted by square brackets:
Outputs:
[1] 4 9 16 25 36 49 [64] 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 [729] 784 841 900 961 1024 1089
AWK
<lang AWK>
- syntax: GAWK -f SQUARE_BUT_NOT_CUBE.AWK
BEGIN {
while (n < 30) {
sqpow = ++square ^ 2
if (is_cube(sqpow) == 0) {
n++
printf("%4d\n",sqpow)
}
else {
printf("%4d is square and cube\n",sqpow)
}
}
exit(0)
} function is_cube(x, i) {
for (i=1; i<=x; i++) {
if (i ^ 3 == x) {
return(1)
}
}
return(0)
} </lang>
- Output:
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
BASIC
<lang BASIC>10 DEFINT C,S,Q,R,N: C=1: S=1: Q=1: R=1: N=1 20 IF N>30 THEN END 30 S=Q*Q 40 IF S>C THEN R=R+1: C=R*R*R: GOTO 40 50 IF S<C THEN N=N+1: PRINT S; 60 Q=Q+1 70 GOTO 20</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
BCPL
<lang bcpl>get "libhdr"
let square(x) = x * x let cube(x) = x * x * x
let start() be $( let c, s, seen = 1, 1, 0
while seen < 30 do
$( while cube(c) < square(s) do c := c + 1
if square(s) ~= cube(c) then
$( writed(square(s), 5)
seen := seen + 1
if seen rem 5 = 0 then wrch('*N')
$)
s := s + 1
$)
$)</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
C
<lang c>#include <stdio.h>
- include <math.h>
int main() {
int n = 1, count = 0, sq, cr;
for ( ; count < 30; ++n) {
sq = n * n;
cr = (int)cbrt((double)sq);
if (cr * cr * cr != sq) {
count++;
printf("%d\n", sq);
}
else {
printf("%d is square and cube\n", sq);
}
}
return 0;
}</lang>
- Output:
Same as Ring example.
C#
<lang csharp>using System; using System.Collections.Generic; using static System.Console; using static System.Linq.Enumerable;
public static class SquareButNotCube {
public static void Main() {
var squares = from i in Integers() select i * i;
var cubes = from i in Integers() select i * i * i;
foreach (var x in Merge().Take(33)) {
WriteLine(x.isCube ? x.n + " (also cube)" : x.n + "");
}
IEnumerable<int> Integers() {
for (int i = 1; ;i++) yield return i;
}
IEnumerable<(int n, bool isCube)> Merge() {
using (var s = squares.GetEnumerator())
using (var c = cubes.GetEnumerator()) {
s.MoveNext();
c.MoveNext();
while (true) {
if (s.Current < c.Current) {
yield return (s.Current, false);
s.MoveNext();
} else if (s.Current == c.Current) {
yield return (s.Current, true);
s.MoveNext();
c.MoveNext();
} else {
c.MoveNext();
}
}
}
}
}
}</lang>
- Output:
1 (also cube) 4 9 16 25 36 49 64 (also cube) 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 (also cube) 784 841 900 961 1024 1089
C++
<lang cpp>#include <iostream>
- include <cmath>
int main() {
int n = 1; int count = 0; int sq; int cr;
for (; count < 30; ++n) {
sq = n * n;
cr = cbrt(sq);
if (cr * cr * cr != sq) {
count++;
std::cout << sq << '\n';
} else {
std::cout << sq << " is square and cube\n";
}
}
return 0;
}</lang>
- Output:
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
Clojure
<lang clojure>(def squares (map #(* % %) (drop 1 (range)))) (def square-cubes (map #(int (. Math pow % 6)) (drop 1 (range))))
(def squares-not-cubes (filter #(not (= % (first (drop-while (fn [n] (< n %)) square-cubes)))) squares))
(println "Squares but not cubes:") (println (take 30 squares-not-cubes)) (println "Both squares and cubes:") (println (take 15 square-cubes)) </lang>
- Output:
Squares but not cubes: (4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089) Both squares and cubes: (1 64 729 4096 15625 46656 117649 262144 531441 1000000 1771561 2985984 4826809 7529536 11390625)
COBOL
<lang cobol> IDENTIFICATION DIVISION.
PROGRAM-ID. SQUARE-NOT-CUBE.
DATA DIVISION.
WORKING-STORAGE SECTION.
01 COMPUTATION.
02 SQ-ROOT PIC 9999 COMP VALUE 1.
02 CUBE-ROOT PIC 9999 COMP VALUE 1.
02 SQUARE PIC 9999 COMP VALUE 1.
02 CUBE PIC 9999 COMP VALUE 1.
02 SEEN PIC 99 COMP VALUE 0.
01 OUTPUT-FORMAT.
02 OUT-NUM PIC ZZZ9.
PROCEDURE DIVISION.
SQUARE-STEP.
COMPUTE SQUARE = SQ-ROOT ** 2.
CUBE-STEP.
IF SQUARE IS GREATER THAN CUBE
ADD 1 TO CUBE-ROOT
COMPUTE CUBE = CUBE-ROOT ** 3
GO TO CUBE-STEP.
IF SQUARE IS NOT EQUAL TO CUBE
ADD 1 TO SEEN
MOVE SQUARE TO OUT-NUM
DISPLAY OUT-NUM.
ADD 1 TO SQ-ROOT.
IF SEEN IS LESS THAN 30 GO TO SQUARE-STEP.
STOP RUN.</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
Commodore BASIC
<lang basic>100 DIM SC(2):SC=0: REM REMEMBER SQUARE CUBES 110 PRINT "SQUARES BUT NOT CUBES:" 120 I=1: CU=1: SQ=1: RT=1: N=0 130 IF N=30 THEN 200 140 SQ=I*I 150 IF SQ > CU THEN RT=RT+1: CU=RT*RT*RT: GOTO 150 160 IF SQ = CU THEN SC(SC)=SQ:SC=SC+1 170 IF SQ < CU THEN N=N+1:PRINT SQ, 180 I=I+1 190 GOTO 130 200 PRINT: PRINT 210 PRINT "BOTH SQUARES AND CUBES:" 220 FOR I=0 TO SC-1:PRINT SC(I),:NEXT I 230 PRINT</lang>
- Output:
READY. RUN SQUARES BUT NOT CUBES: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 BOTH SQUARES AND CUBES: 1 64 729 READY.
Common Lisp
<lang lisp>(defun cubep (n) (loop for i from 1 to (expt n (/ 1 3))
when (= (* i i i) n) do (return t)
finally (return nil)))
(destructuring-bind (not-cubes cubes)
(loop for n from 1
for s = 1 then (* n n)
until (= 30 (length not-cubes))
if (cubep s) collect s into cubes
if (not (cubep s)) collect s into not-cubes
finally (return (list not-cubes cubes)))
(format t "Squares but not cubes:~%~a~%" not-cubes)
(format t "~%Both squares and cubes:~%~a~%" cubes))</lang>
- Output:
Squares but not cubes: (4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089) Both squares and cubes: (1 64 729)
Cowgol
<lang cowgol>include "cowgol.coh";
var cube: uint16 := 1; var ncube: uint16 := 1; var sqr: uint16 := 1; var nsqr: uint16 := 1;
var seen: uint8 := 0; while seen < 30 loop
sqr := nsqr * nsqr;
while sqr > cube loop
ncube := ncube + 1;
cube := ncube * ncube * ncube;
end loop;
if sqr != cube then
seen := seen + 1;
print_i16(sqr);
print_char(' ');
end if;
nsqr := nsqr + 1;
end loop; print_nl();</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
D
<lang d>import std.algorithm; import std.range; import std.stdio;
auto squareGen() {
struct Gen {
private int add = 3;
private int curr = 1;
bool empty() {
return curr < 0;
}
auto front() {
return curr;
}
void popFront() {
curr += add;
add += 2;
}
}
return Gen();
}
auto cubeGen() {
struct Gen {
private int add1 = 7;
private int add2 = 12;
private int curr = 1;
bool empty() {
return curr < 0;
}
auto front() {
return curr;
}
void popFront() {
curr += add1;
add1 += add2;
add2 += 6;
}
}
return Gen();
}
auto merge() {
struct Gen {
private auto sg = squareGen();
private auto cg = cubeGen();
bool empty() {
return sg.empty || cg.empty;
}
auto front() {
import std.typecons;
if (sg.front == cg.front) {
return tuple!("num", "isCube")(sg.front, true);
} else {
return tuple!("num", "isCube")(sg.front, false);
}
}
void popFront() {
while (true) {
if (sg.front < cg.front) {
sg.popFront();
return;
} else if (sg.front == cg.front) {
sg.popFront();
cg.popFront();
return;
} else {
cg.popFront();
}
}
}
}
return Gen();
}
void main() {
foreach (p; merge.take(33)) {
if (p.isCube) {
writeln(p.num, " (also cube)");
} else {
writeln(p.num);
}
}
}</lang>
- Output:
1 (also cube) 4 9 16 25 36 49 64 (also cube) 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 (also cube) 784 841 900 961 1024 1089
Delphi
<lang Delphi> program Square_but_not_cube;
{$APPTYPE CONSOLE}
uses
System.SysUtils, System.Math;
begin
var count := 0;
var n := 1;
while count < 30 do
begin
var sq := n * n;
var cr := Trunc(Power(sq, 1 / 3));
if cr * cr * cr <> sq then
begin
inc(count);
writeln(sq);
end
else
Writeln(sq, ' is square and cube');
inc(n);
end;
{$IFNDEF UNIX} readln; {$ENDIF}
end.</lang>
F#
<lang fsharp> let rec fN n g φ=if φ<31 then match compare(n*n)(g*g*g) with | -1->printfn "%d"(n*n);fN(n+1) g (φ+1)
| 0->printfn "%d cube and square"(n*n);fN(n+1)(g+1)φ
| 1->fN n (g+1) φ
fN 1 1 1 </lang>
- Output:
1 cube and square 4 9 16 25 36 49 64 cube and square 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 cube and square 784 841 900 961 1024 1089
Factor
<lang factor>USING: combinators interpolate io kernel prettyprint math math.functions math.order pair-rocket ; IN: rosetta-code.square-but-not-cube
- fn ( s c n -- s' c' n' )
dup 31 < [
2over [ sq ] [ 3 ^ ] bi* <=> {
+lt+ => [ [ dup sq . 1 + ] 2dip 1 + fn ]
+eq+ => [ [ dup sq [I ${} cube and squareI] nl 1 + ] [ 1 + ] [ ] tri* fn ]
+gt+ => [ [ 1 + ] dip fn ]
} case
] when ;
1 1 1 fn 3drop</lang>
- Output:
1 cube and square 4 9 16 25 36 49 64 cube and square 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 cube and square 784 841 900 961 1024 1089
FALSE
<lang false>1 1 1 [2O30>~][
[$$*2O$$**>][\1+\]# 1O$$**1O$*>[$$*.@1+@@" "]? 1+
]# %%% 10,</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
FOCAL
<lang FOCAL>01.10 S C=1;S S=1;S Q=1;S R=1;S N=1 01.20 I (N-30)1.3,1.3,1.8 01.30 S S=Q*Q 01.40 I (S-C)1.6,1.7,1.5 01.50 S R=R+1;S C=R*R*R;G 1.4 01.60 S N=N+1;T %4,S,! 01.70 S Q=Q+1;G 1.2 01.80 Q</lang>
- Output:
= 4 = 9 = 16 = 25 = 36 = 49 = 81 = 100 = 121 = 144 = 169 = 196 = 225 = 256 = 289 = 324 = 361 = 400 = 441 = 484 = 529 = 576 = 625 = 676 = 784 = 841 = 900 = 961 = 1024 = 1089
Forth
<lang forth>: square dup * ;
- cube dup dup * * ;
- 30-non-cube-squares
0 1 1
begin 2 pick 30 < while
begin over over square swap cube > while
swap 1+ swap
repeat
over over square swap cube <> if
dup square . rot 1+ -rot
then
1+
repeat
2drop drop
30-non-cube-squares cr bye</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
FreeBASIC
<lang freebasic>function is_pow(n as integer, q as integer) as boolean
'tests if the number n is the q'th power of some other integer
dim as integer r = int( n^(1.0/q) )
for i as integer = r-1 to r+1 'there might be a bit of floating point nonsense, so test adjacent numbers also
if i^q = n then return true
next i
return false
end function
dim as integer count = 0, n = 2 do
if is_pow( n, 2 ) and not is_pow( n, 3 ) then
print n;" ";
count += 1
end if
n += 1
loop until count = 30 print count = 0 n = 2 do
if is_pow( n, 2 ) and is_pow( n, 3 ) then
print n;" ";
count += 1
end if
n += 1
loop until count = 3 print</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 64 729 4096
Go
<lang go>package main
import (
"fmt" "math"
)
func main() {
for n, count := 1, 0; count < 30; n++ {
sq := n * n
cr := int(math.Cbrt(float64(sq)))
if cr*cr*cr != sq {
count++
fmt.Println(sq)
} else {
fmt.Println(sq, "is square and cube")
}
}
}</lang>
- Output:
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
Haskell
<lang haskell>{-# LANGUAGE TupleSections #-}
import Control.Monad (join) import Data.List (partition, sortOn) import Data.Ord (comparing)
SQUARE BUT NOT CUBE ------------------
isCube :: Int -> Bool isCube n = n == round (fromIntegral n ** (1 / 3)) ^ 3
both, only :: [Int] (both, only) = partition isCube $ join (*) <$> [1 ..]
TEST -------------------------
main :: IO () main =
(putStrLn . unlines) $
uncurry ((<>) . show)
<$> sortOn
fst
( ((," (also cube)") <$> take 3 both)
<> ((,"") <$> take 30 only)
)</lang>
Or simply
<lang haskell>import Control.Monad (join)
SQUARE BUT NOT CUBE ------------------
cubeRoot :: Int -> Int cubeRoot = round . (** (1 / 3)) . fromIntegral
isCube :: Int -> Bool isCube = (==) <*> ((^ 3) . cubeRoot)
TEST -------------------------
main :: IO () main =
(putStrLn . unlines) $
((<>) . show <*> cubeNote)
<$> take 33 (join (*) <$> [1 ..])
cubeNote :: Int -> String cubeNote x
| isCube x = " (also cube of " <> show (cubeRoot x) <> ")" | otherwise = []
</lang>
Or, if we prefer a finite series to an infinite one <lang haskell>isCube :: Int -> Bool isCube =
(==) <*> ((^ 3) . round . (** (1 / 3)) . fromIntegral)
squares :: Int -> Int -> [Int] squares m n = (>>= id) (*) <$> [m .. n]
TEST -------------------------
main :: IO () main =
(putStrLn . unlines) $ (<>) . show <*> label <$> squares 1 33
label :: Int -> String label n
| isCube n = " (also cube)" | otherwise = ""</lang>
- Output:
1 (also cube) 4 9 16 25 36 49 64 (also cube) 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 (also cube) 784 841 900 961 1024 1089
IS-BASIC
<lang IS-BASIC>100 PROGRAM "Square.bas" 110 LET SQNOTCB,SQANDCB,SQNUM,CBNUM,CBN,SQN,D1=0:LET SQD,D2=1 120 DO 130 LET SQN=SQN+1:LET SQNUM=SQNUM+SQD:LET SQD=SQD+2 140 IF SQNUM>CBNUM THEN 150 LET CBN=CBN+1:LET CBNUM=CBNUM+D2 160 LET D1=D1+6:LET D2=D2+D1 170 END IF 180 IF SQNUM<>CBNUM THEN 190 PRINT SQNUM:LET SQNOTCB=SQNOTCB+1 200 ELSE 210 PRINT SQNUM,SQN;"*";SQN;"=";CBN;"*";CBN;"*";CBN 220 LET SQANDCB=SQANDCB+1 230 END IF 240 LOOP UNTIL SQNOTCB>=30 250 PRINT SQANDCB;"where numbers are square and cube."</lang>
J
Solution: <lang j>isSqrNotCubeofInt=: (*. -.)/@(= <.)@(2 3 %:/ ]) getN_Indicies=: adverb def '[ ({. I.) [ (] , [: u (i.200) + #@])^:(> +/)^:_ u@]'</lang>
Example Use: <lang j> I. isSqrNotCubeofInt i.1090 NB. If we know the upper limit required to get first 30 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
30 isSqrNotCubeofInt getN_Indicies 0 NB. otherwise iteratively build list until first 30 found
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089</lang>
Alternative Solution:
Breaking up the solution above into smaller chunks with comments... <lang j>isInt=: = <. NB. are numbers integers? sqrcube=: 2 3 %:/ ] NB. table of 2nd and 3rd roots of y isSqrNotCubeofInt=: (*. -.)/@isInt@sqrcube NB. is y the square but not cube of an integer?
getIdx=: {. I. NB. get indicies of first x ones in boolean y
process_more=: adverb def '] , [: u (i.200) + #@]' NB. process the next 200 indicies with u and append to y notEnough=: > +/ NB. is left arg greater than sum of right arg while=: conjunction def 'u^:v^:_' NB. repeat u while v is true
process_until_enough=: adverb def 'u process_more while notEnough u'</lang>
Example Use: <lang j> 30 ([ getIdx isSqrNotCubeofInt process_until_enough) 0 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 </lang>
Java
<lang java>public class SquaresCubes {
public static boolean isPerfectCube(long n) {
long c = (long)Math.cbrt((double)n);
return ((c * c * c) == n);
}
public static void main(String... args) {
long n = 1;
int squareOnlyCount = 0;
int squareCubeCount = 0;
while ((squareOnlyCount < 30) || (squareCubeCount < 3)) {
long sq = n * n;
if (isPerfectCube(sq)) {
squareCubeCount++;
System.out.println("Square and cube: " + sq);
}
else {
squareOnlyCount++;
System.out.println("Square: " + sq);
}
n++;
}
}
}</lang>
- Output:
Square and cube: 1 Square: 4 Square: 9 Square: 16 Square: 25 Square: 36 Square: 49 Square and cube: 64 Square: 81 Square: 100 Square: 121 Square: 144 Square: 169 Square: 196 Square: 225 Square: 256 Square: 289 Square: 324 Square: 361 Square: 400 Square: 441 Square: 484 Square: 529 Square: 576 Square: 625 Square: 676 Square and cube: 729 Square: 784 Square: 841 Square: 900 Square: 961 Square: 1024 Square: 1089
JavaScript
<lang javascript>(() => {
'use strict';
const main = () =>
unlines(map(
x => x.toString() + (
isCube(x) ? (
` (cube of ${cubeRootInt(x)} and square of ${
Math.pow(x, 1/2)
})`
) :
),
map(x => x * x, enumFromTo(1, 33))
));
// isCube :: Int -> Bool
const isCube = n =>
n === Math.pow(cubeRootInt(n), 3);
// cubeRootInt :: Int -> Int const cubeRootInt = n => Math.round(Math.pow(n, 1 / 3));
// GENERIC FUNCTIONS ----------------------------------
// enumFromTo :: Int -> Int -> [Int]
const enumFromTo = (m, n) =>
m <= n ? iterateUntil(
x => n <= x,
x => 1 + x,
m
) : [];
// iterateUntil :: (a -> Bool) -> (a -> a) -> a -> [a]
const iterateUntil = (p, f, x) => {
const vs = [x];
let h = x;
while (!p(h))(h = f(h), vs.push(h));
return vs;
};
// map :: (a -> b) -> [a] -> [b] const map = (f, xs) => xs.map(f);
// unlines :: [String] -> String
const unlines = xs => xs.join('\n');
// MAIN --- return main();
})();</lang>
- Output:
1 (cube of 1 and square of 1) 4 9 16 25 36 49 64 (cube of 4 and square of 8) 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 (cube of 9 and square of 27) 784 841 900 961 1024 1089
jq
Works with gojq, the Go implementation of jq <lang jq>
- Emit an unbounded stream
def squares_not_cubes:
def icbrt: pow(10; log10/3) | round; range(1; infinite) | (.*.) | icbrt as $c | select( ($c*$c*$c) != .);
limit(30; squares_not_cubes) </lang>
- Output:
4 9 16 25 ... 900 961 1024 1089
Julia
<lang Julia> iscube(n) = n == round(Int, cbrt(n))^3
println(collect(Iterators.take((n^2 for n in 1:10^6 if !iscube(n^2)), 30))) </lang>
- Output:
[4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]
Kotlin
<lang scala>// Version 1.2.60
fun main(args: Array<String>) {
var n = 1
var count = 0
while (count < 30) {
val sq = n * n
val cr = Math.cbrt(sq.toDouble()).toInt()
if (cr * cr * cr != sq) {
count++
println(sq)
}
else {
println("$sq is square and cube")
}
n++
}
}</lang>
- Output:
Same as Ring example.
LOLCODE
<lang lolcode>HAI 1.2
I HAS A SkwareKyoobs ITZ A BUKKIT I HAS A NumbarSkwareKyoobs ITZ 0 I HAS A NotKyoobs ITZ 0
I HAS A Index ITZ 1 I HAS A Skware ITZ 1 I HAS A Kyoob ITZ 1 I HAS A Root ITZ 1
VISIBLE "Skwares but not kyoobs::"
IM IN YR Outer UPPIN YR Dummy WILE DIFFRINT NotKyoobs AN 30
Skware R PRODUKT OF Index AN Index
IM IN YR Inner UPPIN YR OtherDummy WILE DIFFRINT Kyoob AN BIGGR OF Skware AN Kyoob
Root R SUM OF Root AN 1
Kyoob R PRODUKT OF PRODUKT OF Root AN Root AN Root
IM OUTTA YR Inner
BOTH SAEM Skware AN Kyoob, O RLY?
YA RLY
SkwareKyoobs HAS A SRS NumbarSkwareKyoobs ITZ Skware
NumbarSkwareKyoobs R SUM OF NumbarSkwareKyoobs AN 1
NO WAI
BOTH SAEM Kyoob AN BIGGR OF Skware AN Kyoob, O RLY?
YA RLY
VISIBLE SMOOSH Skware " " MKAY !
NotKyoobs R SUM OF NotKyoobs AN 1
OIC
OIC
Index R SUM OF Index AN 1
IM OUTTA YR Outer
VISIBLE "" VISIBLE "" VISIBLE "Both skwares and kyoobs::" IM IN YR Output UPPIN YR Index WILE DIFFRINT Index AN NumbarSkwareKyoobs
VISIBLE SMOOSH SkwareKyoobs'Z SRS Index " " MKAY !
IM OUTTA YR Output VISIBLE ""
KTHXBYE</lang>
- Output:
Skwares but not kyoobs: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 Both skwares and kyoobs: 1 64 729
Lua
Calculating cube roots with x^(1/3) caused problems with floating-point 'dust' so the Newton-Raphson method is used instead. <lang Lua>function nthroot (x, n)
local r = 1 for i = 1, 16 do r = (((n - 1) * r) + x / (r ^ (n - 1))) / n end return r
end
local i, count, sq, cbrt = 0, 0 while count < 30 do
i = i + 1 sq = i * i -- The next line should say nthroot(sq, 3), right? But this works. Maths, eh? cbrt = nthroot(i, 3) if cbrt == math.floor(cbrt) then print(sq .. " is square and cube") else print(sq) count = count + 1 end
end</lang>
- Output:
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
MAD
<lang MAD> NORMAL MODE IS INTEGER
CUBE=1
NCUBE=1
SQR=1
NSQR=1
SEEN=0
SQRLP SQR = NSQR*NSQR CUBELP WHENEVER SQR.G.CUBE
NCUBE = NCUBE+1
CUBE = NCUBE*NCUBE*NCUBE
TRANSFER TO CUBELP
END OF CONDITIONAL
WHENEVER SQR.NE.CUBE
SEEN = SEEN+1
PRINT FORMAT FMT,SQR
END OF CONDITIONAL
NSQR = NSQR+1
WHENEVER SEEN.L.30, TRANSFER TO SQRLP
VECTOR VALUES FMT = $I4*$
END OF PROGRAM </lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
Mathematica / Wolfram Language
<lang Mathematica>s = Range[50]^2; c = Range[1, Ceiling[Surd[Max[s], 3]]]^3; Take[Complement[s, c], 30] Intersection[s, c]</lang>
- Output:
{4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089}
{1, 64, 729}
MiniScript
<lang MiniScript>squares = [] tris = [] both = [] for i in range(1, 100)
tris.push i*i*i
if tris.indexOf(i*i) == null then
squares.push i*i
else
both.push i*i
end if
end for
print "Square but not cube:" print squares[:30] print "Both square and cube:" print both[:3]</lang>
- Output:
Square but not cube: [4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089] Both square and cube: [1, 64, 729]
Nim
<lang Nim>var count = 0 var n, c, c3 = 1
while count < 30:
var sq = n * n while c3 < sq: inc c c3 = c * c * c if c3 == sq: echo sq, " is square and cube" else: echo sq inc count inc n</lang>
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
OCaml
<lang ocaml>let rec fN n g phi =
if phi < 31 then match compare (n*n) (g*g*g) with | -1 -> Printf.printf "%d\n" (n*n); fN (n+1) g (phi+1) | 0 -> Printf.printf "%d cube and square\n" (n*n); fN (n+1) (g+1) phi | 1 -> fN n (g+1) phi | _ -> assert false
fN 1 1 1</lang>
Pascal
Only using addition :-) <lang pascal>program SquareButNotCube; var
sqN, sqDelta, SqNum,
cbN, cbDelta1, cbDelta2, CbNum,
CountSqNotCb, CountSqAndCb : NativeUint;
begin
CountSqNotCb := 0;
CountSqAndCb := 0;
SqNum := 0;
CbNum := 0;
cbN := 0;
sqN := 0;
sqDelta := 1;
cbDelta1 := 0;
cbDelta2 := 1;
repeat
inc(sqN);
inc(sqNum,sqDelta);
inc(sqDelta,2);
IF sqNum>cbNum then
Begin
inc(cbN);
cbNum := cbNum+cbDelta2;
inc(cbDelta1,6);// 0,6,12,18...
inc(cbDelta2,cbDelta1);//1,7,19,35...
end;
IF sqNum <> cbNUm then
Begin
writeln(sqNum :25);
inc(CountSqNotCb);
end
else
Begin
writeln(sqNum:25,sqN:10,'*',sqN,' = ',cbN,'*',cbN,'*',cbN);
inc(CountSqANDCb);
end;
until CountSqNotCb >= 30;//sqrt(High(NativeUint));
writeln(CountSqANDCb,' where numbers are square and cube ');
end.</lang>
- Output:
1 1*1 = 1*1*1
4
9
16
25
36
49
64 8*8 = 4*4*4
81
100
121
144
169
196
225
256
289
324
361
400
441
484
529
576
625
676
729 27*27 = 9*9*9
784
841
900
961
1024
1089
3 where numbers are square and cube
// there are 1625 numbers which are square and cube < High(Uint64)
//18412815093994140625 4291015625*4291015625 = 2640625*2640625*2640625
Perl
Hash
Use a hash to track state (and avoid floating-point math). <lang perl>while ($cnt < 30) {
$n++;
$h{$n**2}++;
$h{$n**3}--;
$cnt++ if $h{$n**2} > 0;
}
print "First 30 positive integers that are a square but not a cube:\n"; print "$_ " for sort { $a <=> $b } grep { $h{$_} == 1 } keys %h;
print "\n\nFirst 3 positive integers that are both a square and a cube:\n"; print "$_ " for sort { $a <=> $b } grep { $h{$_} == 0 } keys %h;</lang>
- Output:
First 30 positive integers that are a square but not a cube: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 First 3 positive integers that are both a square and a cube: 1 64 729
Generators
A more general approach involving generators/closures to implement 'lazy' lists as in the Raku example. Using ideas and code from the very similar Generator exponential task. Output is the same as previous.
<lang perl># return an anonymous subroutine that generates stream of specified powers sub gen_pow {
my $m = shift;
my $e = 1;
return sub { return $e++ ** $m; };
}
- return an anonymous subroutine generator that filters output from supplied generators g1 and g2
sub gen_filter {
my($g1, $g2) = @_;
my $v1;
my $v2 = $g2->();
return sub {
while (1) {
$v1 = $g1->();
$v2 = $g2->() while $v1 > $v2;
return $v1 unless $v1 == $v2;
}
};
}
my $pow2 = gen_pow(2); my $pow3 = gen_pow(3); my $squares_without_cubes = gen_filter($pow2, $pow3); print "First 30 positive integers that are a square but not a cube:\n"; print $squares_without_cubes->() . ' ' for 1..30;
my $pow6 = gen_pow(6); print "\n\nFirst 3 positive integers that are both a square and a cube:\n"; print $pow6->() . ' ' for 1..3;</lang>
Phix
integer square = 1, squared = 1*1, cube = 1, cubed = 1*1*1, count = 0 while count<30 do squared = square*square while squared>cubed do cube += 1; cubed = cube*cube*cube end while if squared=cubed then printf(1,"%d: %d == %d^3\n",{square,squared,cube}) else count += 1 printf(1,"%d: %d\n",{square,squared}) end if square += 1 end while printf(1,"\nThe first 15 positive integers that are both a square and a cube: \n") ?sq_power(tagset(15),6)
- Output:
1: 1 == 1^3
2: 4
3: 9
4: 16
5: 25
6: 36
7: 49
8: 64 == 4^3
9: 81
10: 100
11: 121
12: 144
13: 169
14: 196
15: 225
16: 256
17: 289
18: 324
19: 361
20: 400
21: 441
22: 484
23: 529
24: 576
25: 625
26: 676
27: 729 == 9^3
28: 784
29: 841
30: 900
31: 961
32: 1024
33: 1089
The first 15 positive integers that are both a square and a cube:
{1,64,729,4096,15625,46656,117649,262144,531441,1000000,1771561,2985984,4826809,7529536,11390625}
PL/I
<lang pli>squareNotCube: procedure options(main);
square: procedure(n) returns(fixed);
declare n fixed;
return(n * n);
end square;
cube: procedure(n) returns(fixed);
declare n fixed;
return(n * n * n);
end cube;
declare (ci, si, seen) fixed;
ci = 1;
do si = 1 repeat(si + 1) while(seen < 30);
do while(cube(ci) < square(si));
ci = ci + 1;
end;
if square(si) ^= cube(ci) then do;
put edit(square(si)) (F(5));
seen = seen + 1;
if mod(seen,10) = 0 then put skip;
end;
end;
end squareNotCube;</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
PL/M
<lang plm>100H: /* CP/M OUTPUT */ BDOS: PROCEDURE (FN, ARG);
DECLARE FN BYTE, ARG ADDRESS; GO TO 5;
END BDOS;
PRINT$NUMBER: PROCEDURE (N);
DECLARE S (7) BYTE INITIAL ('..... $');
DECLARE (N, P) ADDRESS, C BASED P BYTE;
P = .S(5);
DIGIT:
P = P-1; C = N MOD 10 + '0'; N = N/10; IF N > 0 THEN GO TO DIGIT; CALL BDOS(9, P);
END PRINT$NUMBER;
/* SQUARES */ SQUARE: PROCEDURE (N) ADDRESS;
DECLARE N ADDRESS; RETURN N * N;
END SQUARE;
/* CUBES */ CUBE: PROCEDURE (N) ADDRESS;
DECLARE N ADDRESS; RETURN N * N * N;
END CUBE;
DECLARE (CI, SI) ADDRESS INITIAL (1, 1), SEEN BYTE INITIAL (0); DO WHILE SEEN < 30;
DO WHILE CUBE(CI) < SQUARE(SI);
CI = CI + 1;
END;
IF SQUARE(SI) <> CUBE(CI) THEN DO;
CALL PRINT$NUMBER(SQUARE(SI));
SEEN = SEEN + 1;
END;
SI = SI + 1;
END;
CALL BDOS(0,0); EOF</lang>
- Output:
4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089
PureBasic
<lang PureBasic>OpenConsole() lv=1 Repeat
s+1 : s2=s*s : Flg=#True
For i=lv To s
If s2=i*i*i
tx3$+Space(Len(tx2$)-Len(tx3$))+Str(s2)
tx2$+Space(Len(Str(s2))+1)
Flg=#False : lv=i : c-1 : Break
EndIf
Next
If Flg : tx2$+Str(s2)+" " : EndIf
c+1
Until c>=30 PrintN("s² : "+tx2$) : PrintN("s²&s³: "+tx3$) Input()</lang>
- Output:
s² : 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 s²&s³: 1 64 729
Python
<lang python># nonCubeSquares :: Int -> [(Int, Bool)] def nonCubeSquares(n):
upto = enumFromTo(1)
ns = upto(n)
setCubes = set(x ** 3 for x in ns)
ms = upto(n + len(set(x * x for x in ns).intersection(
setCubes
)))
return list(tuple([x * x, x in setCubes]) for x in ms)
- squareListing :: [(Int, Bool)] -> [String]
def squareListing(xs):
justifyIdx = justifyRight(len(str(1 + len(xs))))(' ')
justifySqr = justifyRight(1 + len(str(xs[-1][0])))(' ')
return list(
'(' + str(1 + idx) + '^2 = ' + str(n) +
' = ' + str(round(n ** (1 / 3))) + '^3)' if bln else (
justifyIdx(1 + idx) + ' ->' +
justifySqr(n)
)
for idx, (n, bln) in enumerate(xs)
)
def main():
print(
unlines(
squareListing(
nonCubeSquares(30)
)
)
)
- GENERIC ------------------------------------------------------------------
- enumFromTo :: Int -> Int -> [Int]
def enumFromTo(m):
return lambda n: list(range(m, 1 + n))
- justifyRight :: Int -> Char -> String -> String
def justifyRight(n):
return lambda cFiller: lambda a: (
((n * cFiller) + str(a))[-n:]
)
- unlines :: [String] -> String
def unlines(xs):
return '\n'.join(xs)
main()</lang>
- Output:
(1^2 = 1 = 1^3) 2 -> 4 3 -> 9 4 -> 16 5 -> 25 6 -> 36 7 -> 49 (8^2 = 64 = 4^3) 9 -> 81 10 -> 100 11 -> 121 12 -> 144 13 -> 169 14 -> 196 15 -> 225 16 -> 256 17 -> 289 18 -> 324 19 -> 361 20 -> 400 21 -> 441 22 -> 484 23 -> 529 24 -> 576 25 -> 625 26 -> 676 (27^2 = 729 = 9^3) 28 -> 784 29 -> 841 30 -> 900 31 -> 961 32 -> 1024 33 -> 1089
Racket
Using a generator it _is_ possible to print the cubes in-line, but I've chosen to show reusing the generator / for / sequence interaction:
<lang racket>#lang racket (require racket/generator)
- generates values
- next square
- cube-root if cube, #f otherwise
(define (make-^2-but-not-^3-generator)
(generator
()
(let loop ((s 1) (c 1))
(let ((s^2 (sqr s)) (c^3 (* c c c)))
(yield s^2 (and (= s^2 c^3) c))
(loop (add1 s) (+ c (if (>= s^2 c^3) 1 0)))))))
(for/list ((x (in-range 1 31))
((s^2 _) (sequence-filter (λ (_ c) (not c)) (in-producer (make-^2-but-not-^3-generator))))) s^2)
(for ((x (in-range 1 4))
((s^2 c) (sequence-filter (λ (s^2 c) c) (in-producer (make-^2-but-not-^3-generator))))) (printf "~a: ~a is also ~a^3~%" x s^2 c))</lang>
- Output:
'(4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089) 1: 1 is also 1^3 2: 64 is also 4^3 3: 729 is also 9^3
Raku
(formerly Perl 6) <lang perl6>my @square-and-cube = map { .⁶ }, 1..Inf;
my @square-but-not-cube = (1..Inf).map({ .² }).grep({ $_ ∉ @square-and-cube[^@square-and-cube.first: * > $_, :k]});
put "First 30 positive integers that are a square but not a cube: \n", @square-but-not-cube[^30];
put "\nFirst 15 positive integers that are both a square and a cube: \n", @square-and-cube[^15];</lang>
- Output:
First 30 positive integers that are a square but not a cube: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 First 15 positive integers that are both a square and a cube: 1 64 729 4096 15625 46656 117649 262144 531441 1000000 1771561 2985984 4826809 7529536 11390625
REXX
Programming note: extra code was added to support an additional output format (see the 2nd output section). <lang rexx>/*REXX pgm shows N ints>0 that are squares and not cubes, & which are squares and cubes.*/ numeric digits 20 /*ensure handling of larger numbers. */ parse arg N . /*obtain optional argument from the CL.*/ if N== | N=="," then N= 30 /*Not specified? Then use the default.*/ sqcb= N<0 /*N negative? Then show squares & cubes*/ N = abs(N) /*define N to be the absolute value. */ w= (length(N) + 3) * 3 /*W: used for aligning output columns.*/ say ' count ' /*display the 1st line of the title. */ say ' ─────── ' /* " " 2nd " " " " */ @.= 0 /*@: stemmed array for computed cubes.*/
#= 0; ##= 0 /*count (integer): squares & not cubes.*/
do j=1 until #==N | ##==N /*loop 'til enough " " " " */
sq= j*j; cube= sq*j; @.cube= 1 /*compute the square of J and the cube.*/
if @.sq then do
##= ## + 1 /*bump the counter of squares & cubes. */
if \sqcb then counter= left(, 12) /*don't show this counter.*/
else counter= center(##, 12) /* do " " " */
say counter right(commas(sq), w) 'is a square and a cube'
end
else do
if sqcb then iterate
#= # + 1 /*bump the counter of squares & ¬ cubes*/
say center(#, 12) right(commas(sq), w) 'is a square and not a cube'
end
end /*j*/
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 input:
count
───────
1 is a square and a cube
1 4 is a square and not a cube
2 9 is a square and not a cube
3 16 is a square and not a cube
4 25 is a square and not a cube
5 36 is a square and not a cube
6 49 is a square and not a cube
64 is a square and a cube
7 81 is a square and not a cube
8 100 is a square and not a cube
9 121 is a square and not a cube
10 144 is a square and not a cube
11 169 is a square and not a cube
12 196 is a square and not a cube
13 225 is a square and not a cube
14 256 is a square and not a cube
15 289 is a square and not a cube
16 324 is a square and not a cube
17 361 is a square and not a cube
18 400 is a square and not a cube
19 441 is a square and not a cube
20 484 is a square and not a cube
21 529 is a square and not a cube
22 576 is a square and not a cube
23 625 is a square and not a cube
24 676 is a square and not a cube
729 is a square and a cube
25 784 is a square and not a cube
26 841 is a square and not a cube
27 900 is a square and not a cube
28 961 is a square and not a cube
29 1,024 is a square and not a cube
30 1,089 is a square and not a cube
- output when using the input of: -55
count
───────
1 1 is a square and a cube
2 64 is a square and a cube
3 729 is a square and a cube
4 4,096 is a square and a cube
5 15,625 is a square and a cube
6 46,656 is a square and a cube
7 117,649 is a square and a cube
8 262,144 is a square and a cube
9 531,441 is a square and a cube
10 1,000,000 is a square and a cube
11 1,771,561 is a square and a cube
12 2,985,984 is a square and a cube
13 4,826,809 is a square and a cube
14 7,529,536 is a square and a cube
15 11,390,625 is a square and a cube
16 16,777,216 is a square and a cube
17 24,137,569 is a square and a cube
18 34,012,224 is a square and a cube
19 47,045,881 is a square and a cube
20 64,000,000 is a square and a cube
21 85,766,121 is a square and a cube
22 113,379,904 is a square and a cube
23 148,035,889 is a square and a cube
24 191,102,976 is a square and a cube
25 244,140,625 is a square and a cube
26 308,915,776 is a square and a cube
27 387,420,489 is a square and a cube
28 481,890,304 is a square and a cube
29 594,823,321 is a square and a cube
30 729,000,000 is a square and a cube
31 887,503,681 is a square and a cube
32 1,073,741,824 is a square and a cube
33 1,291,467,969 is a square and a cube
34 1,544,804,416 is a square and a cube
35 1,838,265,625 is a square and a cube
36 2,176,782,336 is a square and a cube
37 2,565,726,409 is a square and a cube
38 3,010,936,384 is a square and a cube
39 3,518,743,761 is a square and a cube
40 4,096,000,000 is a square and a cube
41 4,750,104,241 is a square and a cube
42 5,489,031,744 is a square and a cube
43 6,321,363,049 is a square and a cube
44 7,256,313,856 is a square and a cube
45 8,303,765,625 is a square and a cube
46 9,474,296,896 is a square and a cube
47 10,779,215,329 is a square and a cube
48 12,230,590,464 is a square and a cube
49 13,841,287,201 is a square and a cube
50 15,625,000,000 is a square and a cube
51 17,596,287,801 is a square and a cube
52 19,770,609,664 is a square and a cube
53 22,164,361,129 is a square and a cube
54 24,794,911,296 is a square and a cube
55 27,680,640,625 is a square and a cube
Ring
<lang ring>
- Project : Square but not cube
limit = 30 num = 0 sq = 0 while num < limit
sq = sq + 1
sqpow = pow(sq,2)
flag = iscube(sqpow)
if flag = 0
num = num + 1
see sqpow + nl
else
see "" + sqpow + " is square and cube" + nl
ok
end
func iscube(cube)
for n = 1 to cube
if pow(n,3) = cube
return 1
ok
next
return 0
</lang> Output:
1 is square and cube 4 9 16 25 36 49 64 is square and cube 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is square and cube 784 841 900 961 1024 1089
Ruby
Class based
<lang ruby>#!/usr/bin/env ruby
class PowIt :next
def initialize @next = 1; end end
class SquareIt < PowIt def next result = @next ** 2 @next += 1 return result end end
class CubeIt < PowIt def next result = @next ** 3 @next += 1 return result end end
squares = [] hexponents = []
squit = SquareIt.new cuit = CubeIt.new
s = squit.next c = cuit.next
while (squares.length < 30 || hexponents.length < 3) if s < c squares.push(s) if squares.length < 30 s = squit.next elsif s == c hexponents.push(s) if hexponents.length < 3 s = squit.next c = cuit.next else c = cuit.next end end
puts "Squares:" puts squares.join(" ")
puts "Square-and-cubes:" puts hexponents.join(" ")</lang>
- Output:
Squares: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 Square-and-cubes: 1 64 729
Enumerator
<lang ruby>squares = Enumerator.new {|y| 1.step{|n| y << n*n} }
puts "Square cubes: %p Square non-cubes: %p" % squares.take(33).partition{|sq| Math.cbrt(sq).to_i ** 3 == sq }</lang>
- Output:
Square cubes: [1, 64, 729] Square non-cubes: [4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089]
Rust
<lang rust>fn main() {
let mut s = 1;
let mut c = 1;
let mut cube = 1;
let mut n = 0;
while n < 30 {
let square = s * s;
while cube < square {
c += 1;
cube = c * c * c;
}
if cube == square {
println!("{} is a square and a cube.", square);
} else {
println!("{}", square);
n += 1;
}
s += 1;
}
}</lang>
- Output:
1 is a square and a cube. 4 9 16 25 36 49 64 is a square and a cube. 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is a square and a cube. 784 841 900 961 1024 1089
Scala
This example uses Spire's SafeLongs for both removing any size limitation and making exponentiation/roots cleaner, at the expense of initializing lists with an iteration vs the simpler .from(n). Both the non-cube-squares and square-cubes are lazily evaluated lists, the former is constructed by making lists of square numbers between each pair of cubes and flattening them into one list, the latter is formed by filtering non-squares out of a list of cubes.
<lang scala>import spire.math.SafeLong import spire.implicits._
def ncs: LazyList[SafeLong] = LazyList.iterate(SafeLong(1))(_ + 1).flatMap(n => Iterator.iterate(n.pow(3).sqrt + 1)(_ + 1).map(i => i*i).takeWhile(_ < (n + 1).pow(3))) def scs: LazyList[SafeLong] = LazyList.iterate(SafeLong(1))(_ + 1).map(_.pow(3)).filter(n => n.sqrt.pow(2) == n)</lang>
- Output:
scala> println(ncs.take(30).mkString(", "))
4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089
scala> println(scs.take(3).mkString(", "))
1, 64, 729
Sidef
<lang ruby>var square_and_cube = Enumerator({|f|
1..Inf -> each {|n| f(n**6) }
})
var square_but_not_cube = Enumerator({|f|
1..Inf -> lazy.map {|n| n**2 }.grep {|n| !n.is_power(3) }.each {|n| f(n) }
})
say "First 30 positive integers that are a square but not a cube:" say square_but_not_cube.first(30).join(' ')
say "First 15 positive integers that are both a square and a cube:" say square_and_cube.first(15).join(' ')</lang>
- Output:
First 30 positive integers that are a square but not a cube: 4 9 16 25 36 49 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 784 841 900 961 1024 1089 First 15 positive integers that are both a square and a cube: 1 64 729 4096 15625 46656 117649 262144 531441 1000000 1771561 2985984 4826809 7529536 11390625
Swift
<lang swift>var s = 1, c = 1, cube = 1, n = 0 while n < 30 {
let square = s * s
while cube < square {
c += 1
cube = c * c * c
}
if cube == square {
print("\(square) is a square and a cube.")
} else {
print(square)
n += 1
}
s += 1
}</lang>
- Output:
1 is a square and a cube. 4 9 16 25 36 49 64 is a square and a cube. 81 100 121 144 169 196 225 256 289 324 361 400 441 484 529 576 625 676 729 is a square and a cube. 784 841 900 961 1024 1089
Visual Basic .NET
Inspired by the F# version, but no longer resembles it. Removed the recursion, multiplying (like the D and Pascal versions, only addition is used to calculate squares and cubes), match (Select Case) statement, and hard-coded limit. <lang vbnet>Module Module1
' flag / mask explanation: ' bit 0 (1) = increment square ' bit 1 (2) = increment cube ' bit 2 (4) = has output
' Checks flag against mask, then advances mask. Function ChkFlg(flag As Integer, ByRef mask As Integer) As Boolean ChkFlg = (flag And mask) = mask : mask <<= 1 End Function
Sub SwoC(limit As Integer)
Dim count, square, delta, cube, d1, d2, flag, mask As Integer, s as string = ""
count = 1 : square = 1 : delta = 1 : cube = 1 : d1 = 1 : d2 = 0
While count <= limit
flag = {5, 7, 2}(1 + square.CompareTo(cube))
If flag = 7 Then s = String. Format(" {0} (also cube)", square)
If flag = 5 Then s = String.Format("{0,-2} {1}", count, square) : count += 1
mask = 1 : If ChkFlg(flag, mask) Then delta += 2 : square += delta
If ChkFlg(flag, mask) Then d2 += 6 : d1 += d2 : cube += d1
If ChkFlg(flag, mask) Then Console.WriteLine(s)
End While
End Sub
Sub Main() SwoC(30) End Sub
End Module</lang>
- Output:
1 (also cube) 1 4 2 9 3 16 4 25 5 36 6 49 64 (also cube) 7 81 8 100 9 121 10 144 11 169 12 196 13 225 14 256 15 289 16 324 17 361 18 400 19 441 20 484 21 529 22 576 23 625 24 676 729 (also cube) 25 784 26 841 27 900 28 961 29 1024 30 1089
Wren
<lang ecmascript>import "/math" for Math import "/fmt" for Fmt
var i = 1 var sqnc = [] // squares not cubes var sqcb = [] // squares and cubes while (sqnc.count < 30 || sqcb.count < 3) {
var sq = i * i
var cb = Math.cbrt(sq).round
if (cb*cb*cb != sq) {
sqnc.add(sq)
} else {
sqcb.add(sq)
}
i = i + 1
} System.print("The first 30 positive integers which are squares but not cubes are:") System.print(sqnc.take(30).toList) System.print("\nThe first 3 positive integers which are both squares and cubes are:") System.print(sqcb.take(3).toList)</lang>
- Output:
The first 30 positive integers which are squares but not cubes are: [4, 9, 16, 25, 36, 49, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324, 361, 400, 441, 484, 529, 576, 625, 676, 784, 841, 900, 961, 1024, 1089] The first 3 positive integers which are both squares and cubes are: [1, 64, 729]
zkl
<lang zkl>println("First 30 positive integers that are a square but not a cube:"); squareButNotCube:=(1).walker(*).tweak(fcn(n){
sq,cr := n*n, sq.toFloat().pow(1.0/3).round(); // cube root(64)<4 if(sq==cr*cr*cr) Void.Skip else sq
}); squareButNotCube.walk(30).concat(",").println("\n");
println("First 15 positive integers that are both a square and a cube:"); println((1).walker(*).tweak((1).pow.unbind().fp1(6)).walk(15));</lang>
- Output:
First 30 positive integers that are a square but not a cube: 4,9,16,25,36,49,81,100,121,144,169,196,225,256,289,324,361,400,441,484,529,576,625,676,784,841,900,961,1024,1089 First 15 positive integers that are both a square and a cube: L(1,64,729,4096,15625,46656,117649,262144,531441,1000000,1771561,2985984,4826809,7529536,11390625
- Programming Tasks
- Solutions by Programming Task
- 11l
- 8086 Assembly
- Ada
- ALGOL 68
- ALGOL-M
- APL
- AppleScript
- Arturo
- AutoHotkey
- AWK
- BASIC
- BCPL
- C
- C sharp
- C++
- Clojure
- COBOL
- Commodore BASIC
- Common Lisp
- Cowgol
- D
- Delphi
- System.SysUtils
- System.Math
- F Sharp
- Factor
- FALSE
- FOCAL
- Forth
- FreeBASIC
- Go
- Haskell
- IS-BASIC
- J
- Java
- JavaScript
- Jq
- Julia
- Kotlin
- LOLCODE
- Lua
- MAD
- Mathematica
- Wolfram Language
- MiniScript
- Nim
- OCaml
- Pascal
- Perl
- Phix
- PL/I
- PL/M
- PureBasic
- Python
- Racket
- Raku
- REXX
- Ring
- Ruby
- Rust
- Scala
- Sidef
- Swift
- Visual Basic .NET
- Wren
- Zkl