aparler/RosettaCodeData
1
0
Fork 0
Code Issues 12 Pull requests 3 Projects Releases Packages Wiki Activity Actions

Data commit

Browse source
This commit is contained in:
Ingy döt Net 2023-07-01 11:58:00 -04:00
parent 7387c8f97b
commit cb5bb5e222
199093 changed files with 3378972 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Task/Square-but-not-cube/00-META.yaml Normal file
View file

@ -0,0 +1,2 @@
---
from: http://rosettacode.org/wiki/Square_but_not_cube

6
Task/Square-but-not-cube/00-TASK.txt Normal file
View file

@ -0,0 +1,6 @@
;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.
<br><br>

12
Task/Square-but-not-cube/11l/square-but-not-cube.11l Normal file
View file

@ -0,0 +1,12 @@
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++

47
Task/Square-but-not-cube/8086-Assembly/square-but-not-cube.8086 Normal file
View file

@ -0,0 +1,47 @@
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 ' $'

23
Task/Square-but-not-cube/ALGOL-68/square-but-not-cube.alg Normal file
View file

@ -0,0 +1,23 @@
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

24
Task/Square-but-not-cube/ALGOL-M/square-but-not-cube.alg Normal file
View file

@ -0,0 +1,24 @@
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

1
Task/Square-but-not-cube/APL/square-but-not-cube.apl Normal file
View file

@ -0,0 +1 @@
(×⍨∘⍳ ~ (⊢×⊢×⊢)∘⍳) 33

22
Task/Square-but-not-cube/AWK/square-but-not-cube.awk Normal file
View file

@ -0,0 +1,22 @@
# 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)
}

42
Task/Square-but-not-cube/Action-/square-but-not-cube.action Normal file
View file

@ -0,0 +1,42 @@
BYTE FUNC IsCube(INT n)
INT i,c
i=1
DO
c=i*i*i
IF c=n THEN
RETURN (1)
FI
i==+1
UNTIL c>n
OD
RETURN (0)
PROC Main()
INT n,sq,count
PrintE("First 30 squares but not cubes:")
n=1 count=0
WHILE count<30
DO
sq=n*n
IF IsCube(sq)=0 THEN
PrintF("%I ",sq)
count==+1
FI
n==+1
OD
PutE() PutE()
PrintE("First 3 squares and cubes:")
n=1 count=0
WHILE count<3
DO
sq=n*n
IF IsCube(sq) THEN
PrintF("%I ",sq)
count==+1
FI
n==+1
OD
RETURN

35
Task/Square-but-not-cube/Ada/square-but-not-cube.ada Normal file
View file

@ -0,0 +1,35 @@
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;

71
Task/Square-but-not-cube/AppleScript/square-but-not-cube.applescript Normal file
View file

@ -0,0 +1,71 @@
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

7
Task/Square-but-not-cube/Arturo/square-but-not-cube.arturo Normal file
View file

@ -0,0 +1,7 @@
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]

9
Task/Square-but-not-cube/AutoHotkey/square-but-not-cube.ahk Normal file
View file

@ -0,0 +1,9 @@
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, " ")

7
Task/Square-but-not-cube/BASIC/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,7 @@
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

28
Task/Square-but-not-cube/BASIC256/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,28 @@
cont = 0 : n = 2
do
if is_pow(n, 2) and not is_pow(n, 3) then
print n; " ";
cont += 1
end if
n += 1
until cont = 30
print
cont = 0 : n = 2
do
if is_pow(n, 2) and is_pow(n, 3) then
print n; " ";
cont += 1
end if
n += 1
until cont = 3
end
function is_pow(n, q)
#tests if the number n is the q'th power of some other integer
r = int(n^(1.0/q))
for i = 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

17
Task/Square-but-not-cube/BCPL/square-but-not-cube.bcpl Normal file
View file

@ -0,0 +1,17 @@
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
$)
$)

1
Task/Square-but-not-cube/BQN/square-but-not-cube.bqn Normal file
View file

@ -0,0 +1 @@
∘‿5⥊ ((⊢⋆3˙)((¬∊)/⊢)⊢⋆2˙) ↕34

22
Task/Square-but-not-cube/C++/square-but-not-cube.cpp Normal file
View file

@ -0,0 +1,22 @@
#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;
}

41
Task/Square-but-not-cube/C-sharp/square-but-not-cube.cs Normal file
View file

@ -0,0 +1,41 @@
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();
}
}
}
}
}
}

18
Task/Square-but-not-cube/C/square-but-not-cube.c Normal file
View file

@ -0,0 +1,18 @@
#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;
}

27
Task/Square-but-not-cube/CLU/square-but-not-cube.clu Normal file
View file

@ -0,0 +1,27 @@
square_not_cube = iter () yields (int)
cube_root: int := 1
square_root: int := 1
while true do
while cube_root ** 3 < square_root ** 2 do
cube_root := cube_root + 1
end
if square_root ** 2 ~= cube_root ** 3 then
yield(square_root ** 2)
end
square_root := square_root + 1
end
end square_not_cube
start_up = proc ()
amount = 30
po: stream := stream$primary_output()
n: int := 0
for i: int in square_not_cube() do
stream$putright(po, int$unparse(i), 5)
n := n + 1
if n // 10 = 0 then stream$putl(po, "") end
if n = amount then break end
end
end start_up

29
Task/Square-but-not-cube/COBOL/square-but-not-cube.cobol Normal file
View file

@ -0,0 +1,29 @@
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.

9
Task/Square-but-not-cube/Clojure/square-but-not-cube.clj Normal file
View file

@ -0,0 +1,9 @@
(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))

12
Task/Square-but-not-cube/Comal/square-but-not-cube.comal Normal file
View file

@ -0,0 +1,12 @@
0010 ZONE 5
0020 cube_n#:=0;square_n#:=0;seen#:=0
0030 WHILE seen#<30 DO
0040 WHILE cube_n#^3<square_n#^2 DO cube_n#:+1
0050 IF cube_n#^3<>square_n#^2 THEN
0060 PRINT square_n#^2,
0070 seen#:+1
0080 IF seen# MOD 5=0 THEN PRINT
0090 ENDIF
0100 square_n#:+1
0110 ENDWHILE
0120 END

17
Task/Square-but-not-cube/Commodore-BASIC/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,17 @@
100 DIM SC(2): SC = 0: REM REMEMBER SQUARE CUBES
110 PRINT "SQUARES BUT NOT CUBES:"
120 N = 0: REM NUMBER OF NON-CUBE SQUARES FOUND
130 SR = 1: REM CURRENT SQUARE ROOT
140 CR = 1: CU = 1: REM CURRENT CUBE ROOT AND CUBE
150 REM BEGIN LOOP
160 : IF N >= 30 THEN 230
170 : SQ = SR * SR
180 : IF SQ > CU THEN CR = CR + 1: CU = CR*CR*CR: GOTO 180
190 : IF SQ = CU THEN SC(SC) = SQ: SC = SC + 1
200 : IF SQ < CU THEN N = N + 1:PRINT SQ,
210 : SR = SR + 1
220 GOTO 160: REM END LOOP
230 PRINT: PRINT
240 PRINT "BOTH SQUARES AND CUBES:"
250 FOR I=0 TO SC-1: PRINT SC(I),: NEXT I
260 PRINT

17
Task/Square-but-not-cube/Common-Lisp/square-but-not-cube.lisp Normal file
View file

@ -0,0 +1,17 @@
(defun cubep (n)
(loop for i from 1
for c = (* i i i)
while (<= c n)
when (= c n) do (return t)
finally (return nil)))
(defparameter squares (let ((n 0)) (lambda () (incf n) (* n n))))
(destructuring-bind (noncubes cubes)
(loop for s = (funcall squares) then (funcall squares)
while (< (length noncubes) 30)
if (cubep s) collect s into cubes
if (not (cubep s)) collect s into noncubes
finally (return (list noncubes cubes)))
(format t "Squares but not cubes:~%~A~%~%" noncubes)
(format t "Both squares and cubes:~%~A~%~%" cubes))

22
Task/Square-but-not-cube/Cowgol/square-but-not-cube.cowgol Normal file
View file

@ -0,0 +1,22 @@
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();

96
Task/Square-but-not-cube/D/square-but-not-cube.d Normal file
View file

@ -0,0 +1,96 @@
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);
}
}
}

66
Task/Square-but-not-cube/Dc/square-but-not-cube.dc Normal file
View file

@ -0,0 +1,66 @@
[n = # of non-cube squares found; we stop when it hits 30]sz
[b = # found that are both squares and cubes]sz
0 d sn sb
[c = current cube, s = current square,
r = current cube root, q = current square root,
f = "first" flag, to control comma delimiting]sz
1 d sc d ss d sq d sr sf
[M = main loop]sz
[
lq d * d ss [square q into s]sz
lc r >I [if s > c then call Increment]sz
lc ls <F [if s < c then s is a non-cube square; call Found]sz
lc ls =R [if s = c then s is a cubic square; call Remember]sz
lq 1 + sq [increment q]sz
ln 30 >M [loop if n is still < 30]sz
]sM
[I = Increment. Bump r and c=r^3 until c >= s]sz
[
lr 1 + d sr
d d * * d sc
ls >I
]sI
[C = Comma. Print a comma and a space]sz
[
44P 32P
]sC
[F = Found. Print s and increment n]sz
[
ln 1 + sn
lf 0 =C 0 sf [print ", " if f is not set; clear f]sz
ls n
]sF
[R = Remember. Save s in array l for later.]sz
[
lb d ls r :l
1 + sb
]sR
[B = print Both. Print out the values saved in array l.]sz
[
lf 0 =C 0 sf [print ", " if f is not set; clear f]sz
li d ;l n
1 + d si
lb r <B
]sB
[Print label and newline]sz
[Squares but not cubes:]n 10P
[Run main loop]sz
lMx
[Print two more newlines]sz
10 d P P
[Print second label and newline]sz
[Both squares and cubes:]n 10P
[initialize i to 0, set f again, and call B to print out the values in l]sz
0 si 1 sf lBx 10P

27
Task/Square-but-not-cube/Delphi/square-but-not-cube.delphi Normal file
View file

@ -0,0 +1,27 @@
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.

21
Task/Square-but-not-cube/Draco/square-but-not-cube.draco Normal file
View file

@ -0,0 +1,21 @@
proc main() void:
word sqrt, cbrt, sq, cb, seen;
sqrt := 1;
cbrt := 1;
seen := 0;
while seen < 30 do
sq := sqrt * sqrt;
while
cb := cbrt * cbrt * cbrt;
sq > cb
do
cbrt := cbrt + 1
od;
if sq /= cb then
seen := seen + 1;
write(sq:5);
if seen % 10 = 0 then writeln() fi
fi;
sqrt := sqrt + 1
od
corp

4
Task/Square-but-not-cube/F-Sharp/square-but-not-cube.fs Normal file
View file

@ -0,0 +1,4 @@
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

8
Task/Square-but-not-cube/FALSE/square-but-not-cube.false Normal file
View file

@ -0,0 +1,8 @@
1 1 1
[2O30>~][
[$$*2O$$**>][\1+\]#
1O$$**1O$*>[$$*.@1+@@" "]?
1+
]#
%%%
10,

8
Task/Square-but-not-cube/FOCAL/square-but-not-cube.focal Normal file
View file

@ -0,0 +1,8 @@
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

14
Task/Square-but-not-cube/Factor/square-but-not-cube.factor Normal file
View file

@ -0,0 +1,14 @@
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

17
Task/Square-but-not-cube/Forth/square-but-not-cube.fth Normal file
View file

@ -0,0 +1,17 @@
: 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

29
Task/Square-but-not-cube/FreeBASIC/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,29 @@
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

19
Task/Square-but-not-cube/Go/square-but-not-cube.go Normal file
View file

@ -0,0 +1,19 @@
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")
}
}
}

26
Task/Square-but-not-cube/Haskell/square-but-not-cube-1.hs Normal file
View file

@ -0,0 +1,26 @@
{-# 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)
)

21
Task/Square-but-not-cube/Haskell/square-but-not-cube-2.hs Normal file
View file

@ -0,0 +1,21 @@
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 = []

18
Task/Square-but-not-cube/Haskell/square-but-not-cube-3.hs Normal file
View file

@ -0,0 +1,18 @@
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 = ""

16
Task/Square-but-not-cube/IS-BASIC/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,16 @@
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."

2
Task/Square-but-not-cube/J/square-but-not-cube-1.j Normal file
View file

@ -0,0 +1,2 @@
isSqrNotCubeofInt=: (*. -.)/@(= <.)@(2 3 %:/ ])
getN_Indicies=: adverb def '[ ({. I.) [ (] , [: u (i.200) + #@])^:(> +/)^:_ u@]'

4
Task/Square-but-not-cube/J/square-but-not-cube-2.j Normal file
View file

@ -0,0 +1,4 @@
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

11
Task/Square-but-not-cube/J/square-but-not-cube-3.j Normal file
View file

@ -0,0 +1,11 @@
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'

3
Task/Square-but-not-cube/J/square-but-not-cube-4.j Normal file
View file

@ -0,0 +1,3 @@
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

24
Task/Square-but-not-cube/Java/square-but-not-cube.java Normal file
View file

@ -0,0 +1,24 @@
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++;
}
}
}

50
Task/Square-but-not-cube/JavaScript/square-but-not-cube.js Normal file
View file

@ -0,0 +1,50 @@
(() => {
'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();
})();

9
Task/Square-but-not-cube/Jq/square-but-not-cube.jq Normal file
View file

@ -0,0 +1,9 @@
# 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)

3
Task/Square-but-not-cube/Julia/square-but-not-cube.julia Normal file
View file

@ -0,0 +1,3 @@
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)))

18
Task/Square-but-not-cube/Kotlin/square-but-not-cube.kotlin Normal file
View file

@ -0,0 +1,18 @@
// 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++
}
}

21
Task/Square-but-not-cube/Ksh/square-but-not-cube.ksh Normal file
View file

@ -0,0 +1,21 @@
#!/bin/ksh
# First 30 positive integers which are squares but not cubes
# also, the first 3 positive integers which are both squares and cubes
######
# main #
######
integer n sq cr cnt=0
for (( n=1; cnt<30; n++ )); do
(( sq = n * n ))
(( cr = cbrt(sq) ))
if (( (cr * cr * cr) != sq )); then
(( cnt++ ))
print ${sq}
else
print "${sq} is square and cube"
fi
done

47
Task/Square-but-not-cube/LOLCODE/square-but-not-cube.lol Normal file
View file

@ -0,0 +1,47 @@
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

21
Task/Square-but-not-cube/Lua/square-but-not-cube.lua Normal file
View file

@ -0,0 +1,21 @@
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

23
Task/Square-but-not-cube/MAD/square-but-not-cube.mad Normal file
View file

@ -0,0 +1,23 @@
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

4
Task/Square-but-not-cube/Mathematica/square-but-not-cube.math Normal file
View file

@ -0,0 +1,4 @@
s = Range[50]^2;
c = Range[1, Ceiling[Surd[Max[s], 3]]]^3;
Take[Complement[s, c], 30]
Intersection[s, c]

16
Task/Square-but-not-cube/MiniScript/square-but-not-cube.mini Normal file
View file

@ -0,0 +1,16 @@
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]

16
Task/Square-but-not-cube/Miranda/square-but-not-cube.miranda Normal file
View file

@ -0,0 +1,16 @@
main :: [sys_message]
main = [Stdout (lay (map show squarenotcube))]
where squarenotcube = take 30 (squares $notin cubes)
squares :: [num]
squares = map (^ 2) [1..]
cubes :: [num]
cubes = map (^ 3) [1..]
|| Values in as not in bs, assuming as and bs are sorted
notin :: [num] -> [num] -> [num]
notin as [] = as
notin (a:as) (b:bs) = a:notin as (b:bs), if a < b
= notin as bs, if a = b
= notin (a:as) bs, if a > b

31
Task/Square-but-not-cube/Modula-2/square-but-not-cube.mod2 Normal file
View file

@ -0,0 +1,31 @@
MODULE SquareNotCube;
FROM InOut IMPORT WriteString, WriteCard, WriteLn;
CONST
Amount = 30;
VAR
CubeRoot, SquareRoot,
Cube, Square,
Seen: CARDINAL;
BEGIN
Seen := 0;
SquareRoot := 1;
CubeRoot := 1;
Square := 1;
Cube := 1;
REPEAT
SquareRoot := SquareRoot + 1;
Square := SquareRoot * SquareRoot;
WHILE Square > Cube DO
CubeRoot := CubeRoot + 1;
Cube := CubeRoot * CubeRoot * CubeRoot;
END;
IF Square # Cube THEN
Seen := Seen + 1;
WriteCard(Square, 4);
WriteLn();
END;
UNTIL Seen = Amount
END SquareNotCube.

14
Task/Square-but-not-cube/Nim/square-but-not-cube.nim Normal file
View file

@ -0,0 +1,14 @@
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

10
Task/Square-but-not-cube/OCaml/square-but-not-cube.ocaml Normal file
View file

@ -0,0 +1,10 @@
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

20
Task/Square-but-not-cube/PILOT/square-but-not-cube.pilot Normal file
View file

@ -0,0 +1,20 @@
C :sqr=1
C :cbr=1
C :sq=1
C :cb=1
C :n=0
*square
U (sq>cb):*cube
C (sq<cb):n=n+1
T (sq<cb):#sq
C :sqr=sqr+1
C :sq=sqr*#sqr
J (n<30):*square
E :
*cube
C :cbr=cbr+1
C :cb=(cbr*#cbr)*#cbr
J (sq>cb):*cube
E :

26
Task/Square-but-not-cube/PL-I/square-but-not-cube.pli Normal file
View file

@ -0,0 +1,26 @@
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;

44
Task/Square-but-not-cube/PL-M/square-but-not-cube.plm Normal file
View file

@ -0,0 +1,44 @@
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

48
Task/Square-but-not-cube/Pascal/square-but-not-cube.pas Normal file
View file

@ -0,0 +1,48 @@
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.

12
Task/Square-but-not-cube/Perl/square-but-not-cube-1.pl Normal file
View file

@ -0,0 +1,12 @@
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;

30
Task/Square-but-not-cube/Perl/square-but-not-cube-2.pl Normal file
View file

@ -0,0 +1,30 @@
# 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;

20
Task/Square-but-not-cube/Phix/square-but-not-cube.phix Normal file
View file

@ -0,0 +1,20 @@
(phixonline)-->
<span style="color: #004080;">integer</span> <span style="color: #000000;">square</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">squared</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">cube</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">cubed</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1</span><span style="color: #0000FF;">*</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">0</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">count</span><span style="color: #0000FF;"><</span><span style="color: #000000;">30</span> <span style="color: #008080;">do</span>
<span style="color: #000000;">squared</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">square</span><span style="color: #0000FF;">*</span><span style="color: #000000;">square</span>
<span style="color: #008080;">while</span> <span style="color: #000000;">squared</span><span style="color: #0000FF;">></span><span style="color: #000000;">cubed</span> <span style="color: #008080;">do</span> <span style="color: #000000;">cube</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span><span style="color: #0000FF;">;</span> <span style="color: #000000;">cubed</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">cube</span><span style="color: #0000FF;">*</span><span style="color: #000000;">cube</span><span style="color: #0000FF;">*</span><span style="color: #000000;">cube</span> <span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #008080;">if</span> <span style="color: #000000;">squared</span><span style="color: #0000FF;">=</span><span style="color: #000000;">cubed</span> <span style="color: #008080;">then</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %d == %d^3\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">square</span><span style="color: #0000FF;">,</span><span style="color: #000000;">squared</span><span style="color: #0000FF;">,</span><span style="color: #000000;">cube</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">else</span>
<span style="color: #000000;">count</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%d: %d\n"</span><span style="color: #0000FF;">,{</span><span style="color: #000000;">square</span><span style="color: #0000FF;">,</span><span style="color: #000000;">squared</span><span style="color: #0000FF;">})</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>
<span style="color: #000000;">square</span> <span style="color: #0000FF;">+=</span> <span style="color: #000000;">1</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">while</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"\nThe first 15 positive integers that are both a square and a cube: \n"</span><span style="color: #0000FF;">)</span>
<span style="color: #0000FF;">?</span><span style="color: #7060A8;">sq_power</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">tagset</span><span style="color: #0000FF;">(</span><span style="color: #000000;">15</span><span style="color: #0000FF;">),</span><span style="color: #000000;">6</span><span style="color: #0000FF;">)</span>
<!--

16
Task/Square-but-not-cube/PureBasic/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,16 @@
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()

55
Task/Square-but-not-cube/Python/square-but-not-cube.py Normal file
View file

@ -0,0 +1,55 @@
# 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()

20
Task/Square-but-not-cube/Quackery/square-but-not-cube.quackery Normal file
View file

@ -0,0 +1,20 @@
[ swap - -1 1 clamp 1+ ] is <=> ( n n --> n )
[ dup * ] is squared ( n --> n )
[ dup squared * ] is cubed ( n --> n )
0 0 []
[ unrot
over squared
over cubed <=>
[ table
1+
[ 1+ dip 1+ ]
[ dip
[ tuck squared
join swap 1+ ] ] ]
do
rot dup size 30 = until ]
dip 2drop
echo

28
Task/Square-but-not-cube/REXX/square-but-not-cube.rexx Normal file
View file

@ -0,0 +1,28 @@
/*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 ?

21
Task/Square-but-not-cube/Racket/square-but-not-cube.rkt Normal file
View file

@ -0,0 +1,21 @@
#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))

7
Task/Square-but-not-cube/Raku/square-but-not-cube.raku Normal file
View file

@ -0,0 +1,7 @@
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];

24
Task/Square-but-not-cube/Ring/square-but-not-cube.ring Normal file
View file

@ -0,0 +1,24 @@
# 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

53
Task/Square-but-not-cube/Ruby/square-but-not-cube-1.rb Normal file
View file

@ -0,0 +1,53 @@
#!/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(" ")

4
Task/Square-but-not-cube/Ruby/square-but-not-cube-2.rb Normal file
View file

@ -0,0 +1,4 @@
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 }

20
Task/Square-but-not-cube/Rust/square-but-not-cube.rust Normal file
View file

@ -0,0 +1,20 @@
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;
}
}

5
Task/Square-but-not-cube/Scala/square-but-not-cube.scala Normal file
View file

@ -0,0 +1,5 @@
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)

13
Task/Square-but-not-cube/Sidef/square-but-not-cube.sidef Normal file
View file

@ -0,0 +1,13 @@
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(' ')

15
Task/Square-but-not-cube/Swift/square-but-not-cube.swift Normal file
View file

@ -0,0 +1,15 @@
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
}

24
Task/Square-but-not-cube/Tcl/square-but-not-cube.tcl Normal file
View file

@ -0,0 +1,24 @@
proc squaregen {{i 0}} {
proc squaregen "{i [incr i]}" [info body squaregen]
expr $i * $i
}
proc is_cube {n} {
for {set i 1} {($i * $i * $i) < $n} {incr i} { }
expr ($i * $i * $i) == $n
}
set cubes {}
set noncubes {}
for {set s [squaregen]} {[llength $noncubes] < 30} {set s [squaregen]} {
if [is_cube $s] {
lappend cubes $s
} else {
lappend noncubes $s
}
}
puts "Squares but not cubes:"
puts $noncubes
puts {}
puts "Both squares and cubes:"
puts $cubes

19
Task/Square-but-not-cube/UNIX-Shell/square-but-not-cube-1.sh Normal file
View file

@ -0,0 +1,19 @@
# First 30 positive integers which are squares but not cubes
# also, the first 3 positive integers which are both squares and cubes
######
# main #
######
integer n sq cr cnt=0
for (( n=1; cnt<30; n++ )); do
(( sq = n * n ))
(( cr = cbrt(sq) ))
if (( (cr * cr * cr) != sq )); then
(( cnt++ ))
print ${sq}
else
print "${sq} is square and cube"
fi
done

28
Task/Square-but-not-cube/UNIX-Shell/square-but-not-cube-2.sh Normal file
View file

@ -0,0 +1,28 @@
#!/usr/bin/env bash
main() {
local non_cubes=()
local cubes=()
local cr=1 cube=1 i square
for (( i=1; $#non_cubes < 30; ++i )); do
(( square = i * i ))
while (( square > cube )); do
(( cr+=1, cube=cr*cr*cr ))
done
if (( square == cube )); then
cubes+=($square)
else
non_cubes+=($square)
fi
done
printf 'Squares but not cubes:\n'
printf $non_cubes[1]
printf ', %d' "${(@)non_cubes[2,-1]}"
printf '\n\nBoth squares and cubes:\n'
printf $cubes[1]
printf ', %d' "${(@)cubes[2,-1]}"
printf '\n'
}
main "$@"

12
Task/Square-but-not-cube/VTL-2/square-but-not-cube.vtl-2 Normal file
View file

@ -0,0 +1,12 @@
10 N=0
20 S=1
30 C=1
40 #=60
50 C=C+1
60 #=C*C*C<(S*S)*50
70 #=C*C*C=(S*S)*110
80 N=N+1
90 ?=S*S
100 $=32
110 S=S+1
120 #=N<30*60

30
Task/Square-but-not-cube/Visual-Basic-.NET/square-but-not-cube.vb Normal file
View file

@ -0,0 +1,30 @@
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

20
Task/Square-but-not-cube/Wren/square-but-not-cube.wren Normal file
View file

@ -0,0 +1,20 @@
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)

15
Task/Square-but-not-cube/XPL0/square-but-not-cube.xpl0 Normal file
View file

@ -0,0 +1,15 @@
int C, N, N2, T;
[C:= 0; N:= 1;
loop [N2:= N*N;
IntOut(0, N2);
T:= fix(Pow(float(N2), 1./3.));
if T*T*T # N2 then
[ChOut(0, ^ );
C:= C+1;
if C >= 30 then quit;
]
else Text(0, "* ");
N:= N+1;
];
Text(0, "^m^j* are both squares and cubes.^m^j");
]

32
Task/Square-but-not-cube/Yabasic/square-but-not-cube.basic Normal file
View file

@ -0,0 +1,32 @@
// Rosetta Code problem: https://rosettacode.org/wiki/Square_but_not_cube
// by Jjuanhdez, 10/2022
count = 0 : n = 2
repeat
if isPow(n, 2) and not isPow(n, 3) then
print n, " ";
count = count + 1
fi
n = n + 1
until count = 30
print
count = 0 : n = 2
repeat
if isPow(n, 2) and isPow(n, 3) then
print n, " ";
count = count + 1
fi
n = n + 1
until count = 3
print
end
sub isPow(n, q)
//tests if the number n is the q'th power of some other integer
r = int(n^(1.0/q))
for i = r-1 to r+1 //there might be a bit of floating point nonsense, so test adjacent numbers also
if i^q = n return true
next i
return false
end sub

9
Task/Square-but-not-cube/Zkl/square-but-not-cube.zkl Normal file
View file

@ -0,0 +1,9 @@
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));