Square but not cube: Difference between revisions

{{trans|C}}

V count = 0

E

print(sq‘ is square and cube’)

=={{header|8086 Assembly}}==

org 100h

section .text

section .data

db '*****' ; Placeholder for number

{{out}}

=={{header|Action!}}==

INT i,c

n==+1

OD

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Square_but_not_cube.png Screenshot from Atari 8-bit computer]

=={{header|Ada}}==

procedure Square_But_Not_Cube is

begin

Show (Limit => 30);

{{out}}

=={{header|ALGOL 68}}==

Avoids computing cube roots.

# list the first 30 numbers that are squares but not cubes and also #

# show the numbers that are both squares and cubes #

print( ( newline ) )

OD

{{out}}

<pre>

=={{header|ALGOL-M}}==

integer function square(x);

integer x;

s := s + 1;

end;

{{out}}

=={{header|APL}}==

{{out}}

=={{header|AppleScript}}==

script listing

on |λ|(x)

set my text item delimiters to dlm

str

{{Out}}

<pre>1 (also cube)

=={{header|Arturo}}==

cubes: map 1..100 => [&^3]

print first.n:30 select squares => [not? in? & cubes]

print "Square and cube:"

{{out}}

=={{header|AutoHotkey}}==

while counter<30 {

cube[(n := A_Index)**3] := true

res .= "[" n**2 "] "

}

square and cube numbers are denoted by square brackets:

Outputs:<pre>

=={{header|AWK}}==

# syntax: GAWK -f SQUARE_BUT_NOT_CUBE.AWK

BEGIN {

return(0)

}

{{out}}

<pre>

=={{header|BASIC}}==

20 IF N>30 THEN END

30 S=Q*Q

50 IF S<C THEN N=N+1: PRINT S;

60 Q=Q+1

{{out}}

=={{header|BCPL}}==

let square(x) = x * x

s := s + 1

$)

{{out}}

<pre> 4 9 16 25 36

841 900 961 1024 1089</pre>

=={{header|BQN}}==

{{out}}

<pre>┌─

=={{header|C}}==

#include <math.h>

}

return 0;

{{out}}

=={{header|C sharp}}==

using System.Collections.Generic;

using static System.Console;

}

{{out}}

<pre style="height:30ex;overflow:scroll">

=={{header|C++}}==

{{trans|C}}

#include <cmath>

return 0;

{{out}}

<pre>1 is square and cube

=={{header|Clojure}}==

{{trans|Raku}}

(def square-cubes (map #(int (. Math pow % 6)) (drop 1 (range))))

(println "Both squares and cubes:")

(println (take 15 square-cubes))

{{Out}}

<pre>Squares but not cubes:

=={{header|CLU}}==

cube_root: int := 1

square_root: int := 1

if n = amount then break end

end

{{out}}

<pre> 4 9 16 25 36 49 81 100 121 144

=={{header|COBOL}}==

PROGRAM-ID. SQUARE-NOT-CUBE.

ADD 1 TO SQ-ROOT.

IF SEEN IS LESS THAN 30 GO TO SQUARE-STEP.

{{out}}

<pre style='height:50ex;'> 4

=={{header|Comal}}==

0020 cube_n#:=0;square_n#:=0;seen#:=0

0030 WHILE seen#<30 DO

0100 square_n#:+1

0110 ENDWHILE

{{out}}

<pre>4 9 16 25 36

=={{header|Commodore BASIC}}==

{{trans|BASIC}}

110 PRINT "SQUARES BUT NOT CUBES:"

120 N = 0: REM NUMBER OF NON-CUBE SQUARES FOUND

240 PRINT "BOTH SQUARES AND CUBES:"

250 FOR I=0 TO SC-1: PRINT SC(I),: NEXT I

{{works with|Commodore BASIC|3.5,7.0}}

=={{header|Common Lisp}}==

(loop for i from 1

for c = (* i i i)

finally (return (list noncubes cubes)))

(format t "Squares but not cubes:~%~A~%~%" noncubes)

{{Out}}

=={{header|Cowgol}}==

var cube: uint16 := 1;

nsqr := nsqr + 1;

end loop;

{{out}}

=={{header|D}}==

{{trans|C#}}

import std.range;

import std.stdio;

}

}

{{out}}

<pre>1 (also cube)

=={{header|dc}}==

{{trans|BASIC}}

[n = # of non-cube squares found; we stop when it hits 30]sz

[b = # found that are both squares and cubes]sz

[initialize i to 0, set f again, and call B to print out the values in l]sz

{{Out}}

{{libheader| System.Math}}

{{Trans|Go}}

program Square_but_not_cube;

{$IFNDEF UNIX} readln; {$ENDIF}

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

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

{{out}}

<pre>

=={{header|Factor}}==

{{trans|F#}}

math.functions math.order pair-rocket ;

IN: rosetta-code.square-but-not-cube

] when ;

{{out}}

<pre>

=={{header|FALSE}}==

[2O30>~][

[$$*2O$$**>][\1+\]#

]#

%%%

{{out}}

=={{header|FOCAL}}==

01.20 I (N-30)1.3,1.3,1.8

01.30 S S=Q*Q

01.60 S N=N+1;T %4,S,!

01.70 S Q=Q+1;G 1.2

{{out}}

=={{header|Forth}}==

: cube dup dup * * ;

: 30-non-cube-squares

;

{{out}}

=={{header|FreeBASIC}}==

'tests if the number n is the q'th power of some other integer

dim as integer r = int( n^(1.0/q) )

n += 1

loop until count = 3

{{out}}

<pre> 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

=={{header|Go}}==

import (

}

}

{{out}}

=={{header|Haskell}}==

import Control.Monad (join)

( ((," (also cube)") <$> take 3 both)

<> ((,"") <$> take 30 only)

Or simply

------------------- SQUARE BUT NOT CUBE ------------------

| isCube x = " (also cube of " <> show (cubeRoot x) <> ")"

| otherwise = []

Or, if we prefer a finite series to an infinite one

isCube =

(==)

label n

| isCube n = " (also cube)"

{{Out}}

<pre>1 (also cube)

=={{header|IS-BASIC}}==

110 LET SQNOTCB,SQANDCB,SQNUM,CBNUM,CBN,SQN,D1=0:LET SQD,D2=1

120 DO

230 END IF

240 LOOP UNTIL SQNOTCB>=30

=={{header|J}}==

'''Solution:'''

'''Example Use:'''

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

'''Alternative Solution:'''

Breaking up the solution above into smaller chunks with comments...

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?

while=: conjunction def 'u^:v^:_' NB. repeat u while v is true

'''Example Use:'''

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

=={{header|Java}}==

public static boolean isPerfectCube(long n) {

long c = (long)Math.cbrt((double)n);

}

}

{{out}}

<pre>

=={{header|JavaScript}}==

'use strict';

// MAIN ---

return main();

{{Out}}

<pre>1 (cube of 1 and square of 1)

{{works with|jq}}

'''Works with gojq, the Go implementation of jq'''

# Emit an unbounded stream

def squares_not_cubes:

limit(30; squares_not_cubes)

{{out}}

<pre>

=={{header|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)))

{{Out}}

[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]

=={{header|Kotlin}}==

fun main(args: Array<String>) {

n++

}

{{output}}

=={{header|Ksh}}==

#!/bin/ksh

print "${sq} is square and cube"

fi

{{out}}<pre>

1 is square and cube

=={{header|LOLCODE}}==

{{trans|Commodore BASIC}}

I HAS A SkwareKyoobs ITZ A BUKKIT

VISIBLE ""

{{Out}}

=={{header|Lua}}==

Calculating cube roots with x^(1/3) caused problems with floating-point 'dust' so the Newton-Raphson method is used instead.

local r = 1

for i = 1, 16 do

count = count + 1

end

{{out}}

<pre>1 is square and cube

=={{header|MAD}}==

CUBE=1

VECTOR VALUES FMT = $I4*$

{{out}}

=={{header|Mathematica}} / {{header|Wolfram Language}}==

c = Range[1, Ceiling[Surd[Max[s], 3]]]^3;

Take[Complement[s, c], 30]

{{out}}

<pre>{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}

=={{header|MiniScript}}==

tris = []

both = []

print squares[:30]

print "Both square and cube:"

{{out}}

<pre>Square but not cube:

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

FROM InOut IMPORT WriteString, WriteCard, WriteLn;

END;

UNTIL Seen = Amount

{{out}}

<pre> 4

=={{header|Nim}}==

var n, c, c3 = 1

echo sq

inc count

<pre>

1 is square and cube

=={{header|OCaml}}==

{{trans|F#}}

if phi < 31 then

match compare (n*n) (g*g*g) with

;;

=={{header|Pascal}}==

Only using addition :-)

var

sqN,

until CountSqNotCb >= 30;//sqrt(High(NativeUint));

writeln(CountSqANDCb,' where numbers are square and cube ');

{{out}}

<pre> 1 1*1 = 1*1*1

==== Hash ====

Use a hash to track state (and avoid floating-point math).

$n++;

$h{$n**2}++;

print "\n\nFirst 3 positive integers that are both a square and a cube:\n";

{{out}}

<pre>First 30 positive integers that are a square but not a cube:

Output is the same as previous.

sub gen_pow {

my $m = shift;

my $pow6 = gen_pow(6);

print "\n\nFirst 3 positive integers that are both a square and a cube:\n";

=={{header|Phix}}==

<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: #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>

{{out}}

<pre>

=={{header|PILOT}}==

C :cbr=1

C :sq=1

C :cb=(cbr*#cbr)*#cbr

J (sq>cb):*cube

{{out}}

<pre>4

=={{header|PL/I}}==

square: procedure(n) returns(fixed);

end;

end;

{{out}}

<pre> 4 9 16 25 36 49 81 100 121 144

=={{header|PL/M}}==

BDOS: PROCEDURE (FN, ARG);

DECLARE FN BYTE, ARG ADDRESS;

CALL BDOS(0,0);

{{out}}

<pre>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</pre>

=={{header|PureBasic}}==

lv=1

Repeat

Until c>=30

PrintN("s² : "+tx2$) : PrintN("s²&s³: "+tx3$)

{{out}}

<pre>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

=={{header|Python}}==

def nonCubeSquares(n):

upto = enumFromTo(1)

{{Out}}

<pre>(1^2 = 1 = 1^3)

=={{header|Quackery}}==

[ dup * ] is squared ( n --> n )

rot dup size 30 = until ]

dip 2drop

{{out}}

Using a generator it _is_ possible to print the cubes in-line, but I've chosen to show reusing the generator / for / sequence interaction:

(require racket/generator)

(for ((x (in-range 1 4))

((s^2 c) (sequence-filter (λ (s^2 c) c) (in-producer (make-^2-but-not-^3-generator)))))

{{out}}

=={{header|Raku}}==

(formerly Perl 6)

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];

{{out}}

<pre>First 30 positive integers that are a square but not a cube:

=={{header|REXX}}==

Programming note: &nbsp; extra code was added to support an additional output format &nbsp; (see the 2^nd '''output''' section).

numeric digits 20 /*ensure handling of larger numbers. */

parse arg N . /*obtain optional argument from the CL.*/

exit 0 /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the default input:}}

<pre>

=={{header|Ring}}==

# Project : Square but not cube

next

return 0

Output:

<pre>

=={{header|Ruby}}==

==== Class based ====

class PowIt

puts "Square-and-cubes:"

{{out}}

<pre>Squares:

1 64 729</pre>

==== Enumerator ====

puts "Square cubes: %p

{{out}}

<pre>Square cubes: [1, 64, 729]

=={{header|Rust}}==

let mut s = 1;

let mut c = 1;

s += 1;

}

{{out}}

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.

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)))

{{out}}

=={{header|Sidef}}==

{{trans|Raku}}

1..Inf -> each {|n| f(n**6) }

})

say "First 15 positive integers that are both a square and a cube:"

{{out}}

<pre>

=={{header|Swift}}==

while n < 30 {

let square = s * s

}

s += 1

{{out}}

=={{header|Tcl}}==

{{trans|Common Lisp}}

proc squaregen "{i [incr i]}" [info body squaregen]

expr $i * $i

puts {}

puts "Both squares and cubes:"

{{Out}}

{{works with|Korn Shell}}

Ksh has a built-in cube root function, making this a little simpler:

# also, the first 3 positive integers which are both squares and cubes

print "${sq} is square and cube"

fi

{{Out}}

The Zsh solution is virtually identical to the Bash one, the main difference being the array syntax and base index.

main() {

}

{{Out}}

=={{header|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.

' flag / mask explanation:

End Sub

{{out}}

<pre> 1 (also cube)

=={{header|VTL-2}}==

20 S=1

30 C=1

100 $=32

110 S=S+1

{{out}}

<pre>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</pre>

=={{header|Wren}}==

import "/fmt" for Fmt

System.print(sqnc.take(30).toList)

System.print("\nThe first 3 positive integers which are both squares and cubes are:")

{{out}}

=={{header|XPL0}}==

[C:= 0; N:= 1;

loop [N2:= N*N;

];

Text(0, "^m^j* are both squares and cubes.^m^j");

{{out}}

=={{header|zkl}}==

squareButNotCube:=(1).walker(*).tweak(fcn(n){

sq,cr := n*n, sq.toFloat().pow(1.0/3).round(); // cube root(64)<4

println("First 15 positive integers that are both a square and a cube:");

{{out}}

<pre>