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

Odd and square numbers

From Rosetta Code
Odd and square numbers is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.
Task


Find odd and square numbers (>99) under 1.000

ALGOL 68[edit]

BEGIN # print odd suares between 100 and 1000 #
# if 2m + 1 and 2m - 1 are consecutive odd numbers, the difference between their squares is 8m #
INT to next := 8;
INT odd square := 1;
WHILE odd square < 1000 DO
IF odd square > 99 THEN
print( ( " ", whole( odd square, 0 ) ) )
FI;
odd square +:= to next;
to next +:= 8
OD
END
Output:
 121 169 225 289 361 441 529 625 729 841 961

ALGOL W[edit]

Translation of: PL/M
which is based on the Algol 68 sample.
begin % print odd squares between 100 and 1000 %
integer oddSquare, nextGap;
oddSquare := 1;
nextGap  := 8;
while oddSquare < 100 do begin
oddSquare := oddSquare + nextGap;
nextGap  := nextGap + 8
end while_oddSuare_lt_100 ;
while oddSquare < 1000 do begin
writeon( i_w := s_w := 1, oddSquare );
oddSquare := oddSquare + nextGap;
nextGap  := nextGap + 8
end while_oddSquare_lt_1000
end.
Output:
121 169 225 289 361 441 529 625 729 841 961

AWK[edit]

 
# syntax: GAWK -f ODD_AND_SQUARE_NUMBERS.AWK
BEGIN {
start = 100
stop = 999
i = n = 1
while (n <= stop) {
if (n >= start) {
printf("%5d%1s",n,++count%10?"":"\n")
}
n += 8 * i++
}
printf("\nOdd and square numbers %d-%d: %d\n",start,stop,count)
exit(0)
}
 
Output:
  121   169   225   289   361   441   529   625   729   841
  961
Odd and square numbers 100-999: 11

F#[edit]

 
// Odd and square numbers. Nigel Galloway: November 23rd., 2021
Seq.initInfinite((*)2>>(+)11)|>Seq.map(fun n->n*n)|>Seq.takeWhile((>)1000)|>Seq.iter(printfn "%d")
 
Output:
121
169
225
289
361
441
529
625
729
841
961

Factor[edit]

Works with: Factor version 0.99 2021-06-02
USING: io math math.functions math.ranges prettyprint sequences ;
 
11 1000 sqrt 2 <range> [ bl ] [ sq pprint ] interleave nl
Output:
121 169 225 289 361 441 529 625 729 841 961

Fermat[edit]

Func Oddsq(j)=(2*j-1)^2.;
i:=1;
n:=1;
while n<1000 do
if n>100 then !!n fi;
i:+;
n:=Oddsq(i);
od;

FreeBASIC[edit]

Squares without squaring.

dim as integer i=1, n=1
while n<1000
if n>100 then print n
n+=8*i
i+=1
wend

Julia[edit]

Translation of: FreeBASIC
julia> i = n = 1
1
 
julia> while n < 1000
n > 100 && println(n)
n += 8i
i += 1
end
121
169
225
289
361
441
529
625
729
841
961
 

Perl[edit]

Library: ntheory
#!/usr/bin/perl
 
use strict;
use warnings;
use ntheory qw( is_square );
 
print join( ' ', grep $_ & 1 && is_square($_), 100 .. 999 ), "\n";
Output:
121 169 225 289 361 441 529 625 729 841 961

Phix[edit]

with javascript_semantics
pp(sq_power(tagset(floor(sqrt(1000)),11,2),2))
Output:
{121,169,225,289,361,441,529,625,729,841,961}

PL/M[edit]

Based on the Algol 68 sample.

100H: /* PRINT ODD SQUARES BETWEEN 100 AND 1000 */
 
/* CP/M BDOS SYSTEM CALL */
BDOS: PROCEDURE( FN, ARG ); DECLARE FN BYTE, ARG ADDRESS; GOTO 5;END;
/* CONSOLE OUTPUT ROUTINES */
PR$CHAR: PROCEDURE( C ); DECLARE C BYTE; CALL BDOS( 2, C ); END;
PR$STRING: PROCEDURE( S ); DECLARE S ADDRESS; CALL BDOS( 9, S ); END;
PR$NUMBER: PROCEDURE( N );
DECLARE N ADDRESS;
DECLARE V ADDRESS, N$STR( 6 ) BYTE, W BYTE;
V = N;
W = LAST( N$STR );
N$STR( W ) = '$';
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
DO WHILE( ( V := V / 10 ) > 0 );
N$STR( W := W - 1 ) = '0' + ( V MOD 10 );
END;
CALL PR$STRING( .N$STR( W ) );
END PR$NUMBER;
 
/* TASK */
DECLARE ( NEXT$GAP, ODD$SQUARE ) ADDRESS;
NEXT$GAP = 8;
ODD$SQUARE = 1;
DO WHILE( ODD$SQUARE < 100 );
ODD$SQUARE = ODD$SQUARE + NEXT$GAP;
NEXT$GAP = NEXT$GAP + 8;
END;
DO WHILE( ODD$SQUARE < 1000 );
CALL PR$CHAR( ' ' );
CALL PR$NUMBER( ODD$SQUARE );
ODD$SQUARE = ODD$SQUARE + NEXT$GAP;
NEXT$GAP = NEXT$GAP + 8;
END;
 
EOF
Output:
 121 169 225 289 361 441 529 625 729 841 961

Python[edit]

 
iimport math
szamok=[]
limit = 1000
 
for i in range(1,int(math.ceil(math.sqrt(limit))),2):
num = i*i
if (num < 1000 and num > 99):
szamok.append(num)
 
print(szamok)
 
Output:
[121, 169, 225, 289, 361, 441, 529, 625, 729, 841, 961]

Raku[edit]

Vote for deletion: trivial. But if we gotta keep it, at least make it slightly interesting.

for 1..5 {
my $max = exp $_, 10;
put "\n{+$_} odd squares from {$max / 10} to $max:\n{ .batch(10).join: "\n" }"
given ({(2 × $++ + 1)²}* > $max).grep: $max / 10*$max
}
Output:
2 odd squares from 1 to 10:
1 9

3 odd squares from 10 to 100:
25 49 81

11 odd squares from 100 to 1000:
121 169 225 289 361 441 529 625 729 841
961

34 odd squares from 1000 to 10000:
1089 1225 1369 1521 1681 1849 2025 2209 2401 2601
2809 3025 3249 3481 3721 3969 4225 4489 4761 5041
5329 5625 5929 6241 6561 6889 7225 7569 7921 8281
8649 9025 9409 9801

108 odd squares from 10000 to 100000:
10201 10609 11025 11449 11881 12321 12769 13225 13689 14161
14641 15129 15625 16129 16641 17161 17689 18225 18769 19321
19881 20449 21025 21609 22201 22801 23409 24025 24649 25281
25921 26569 27225 27889 28561 29241 29929 30625 31329 32041
32761 33489 34225 34969 35721 36481 37249 38025 38809 39601
40401 41209 42025 42849 43681 44521 45369 46225 47089 47961
48841 49729 50625 51529 52441 53361 54289 55225 56169 57121
58081 59049 60025 61009 62001 63001 64009 65025 66049 67081
68121 69169 70225 71289 72361 73441 74529 75625 76729 77841
78961 80089 81225 82369 83521 84681 85849 87025 88209 89401
90601 91809 93025 94249 95481 96721 97969 99225

Ring[edit]

 
see "working..." + nl
limit = 1000
list = []
 
for i = 1 to ceil(sqrt(limit)) step 2
num = pow(i,2)
if (num < 1000 and num > 99)
add(list,num)
ok
next
 
showArray(list)
 
see nl + "done..." + nl
 
func showArray(array)
txt = ""
see "["
for n = 1 to len(array)
txt = txt + array[n] + ","
next
txt = left(txt,len(txt)-1)
txt = txt + "]"
see txt
 
Output:
working...
[121,169,225,289,361,441,529,625,729,841,961]
done...

Wren[edit]

Library: Wren-trait
Library: Wren-seq
import "./trait" for Stepped
import "./seq" for Lst
 
var pow = 1
for (p in 0..4) {
var low = pow.sqrt.ceil
if (low % 2 == 0) low = low + 1
pow = pow * 10
var high = pow.sqrt.floor
var oddSq = Stepped.new(low..high, 2).map { |i| i * i }.toList
System.print("%(oddSq.count) odd squares from %(pow/10) to %(pow):")
for (chunk in Lst.chunks(oddSq, 10)) System.print(chunk.join(" "))
System.print()
}
Output:
2 odd squares from 1 to 10:
1 9

3 odd squares from 10 to 100:
25 49 81

11 odd squares from 100 to 1000:
121 169 225 289 361 441 529 625 729 841
961

34 odd squares from 1000 to 10000:
1089 1225 1369 1521 1681 1849 2025 2209 2401 2601
2809 3025 3249 3481 3721 3969 4225 4489 4761 5041
5329 5625 5929 6241 6561 6889 7225 7569 7921 8281
8649 9025 9409 9801

108 odd squares from 10000 to 100000:
10201 10609 11025 11449 11881 12321 12769 13225 13689 14161
14641 15129 15625 16129 16641 17161 17689 18225 18769 19321
19881 20449 21025 21609 22201 22801 23409 24025 24649 25281
25921 26569 27225 27889 28561 29241 29929 30625 31329 32041
32761 33489 34225 34969 35721 36481 37249 38025 38809 39601
40401 41209 42025 42849 43681 44521 45369 46225 47089 47961
48841 49729 50625 51529 52441 53361 54289 55225 56169 57121
58081 59049 60025 61009 62001 63001 64009 65025 66049 67081
68121 69169 70225 71289 72361 73441 74529 75625 76729 77841
78961 80089 81225 82369 83521 84681 85849 87025 88209 89401
90601 91809 93025 94249 95481 96721 97969 99225

XPL0[edit]

int N2, N;
[for N2:= 101 to 999 do
[N:= sqrt(N2);
if N*N=N2 & (N&1)=1 then
[IntOut(0, N2); ChOut(0, ^ )];
];
]
Output:
121 169 225 289 361 441 529 625 729 841 961