Steady squares: Difference between revisions
Added Oberon-07
(Added Oberon-07) |
|||
| (13 intermediate revisions by 7 users not shown) | |||
Line 4:
<br>
The 3-digit number 376 in the decimal numbering system is an example of numbers with the special property that its square ends with the same digits: '''376*376 = 141376'''. Let's call a number with this property a steady square. Find steady squares under '''10.000'''
=={{header|ABC}}==
<syntaxhighlight lang="abc">
HOW TO REPORT n is.steady.square.below power.of.ten:
REPORT ( n * n ) mod power.of.ten = n
HOW TO MIGHT n BE A STEADY SQUARE BELOW power.of.ten:
IF n is.steady.square.below power.of.ten:
WRITE ( ( ( n << 1 ) ^ "^2 = " ) >> 10 ) ^ ( ( n * n ) >> 1 ) /
PUT 10 IN power.of.ten
PUT -10 IN n
FOR i IN { 0 .. 1000 }:
PUT n + 10 IN n
IF n = power.of.ten:
PUT power.of.ten * 10 IN power.of.ten
MIGHT ( n + 1 ) BE A STEADY SQUARE BELOW power.of.ten
MIGHT ( n + 5 ) BE A STEADY SQUARE BELOW power.of.ten
MIGHT ( n + 6 ) BE A STEADY SQUARE BELOW power.of.ten
</syntaxhighlight>
{{out}}
<pre>
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376
</pre>
=={{header|Action!}}==
Line 786 ⟶ 817:
<br>
Everything is Euler is an expression (apart from new/label/formal) and returns a value (although the value of a "goto" can't be used), so the "else" part of an "if" is not optional, hence the "else 0"s appearing in the code below.
'''begin'''
'''new''' maxNumber; '''new''' powerOfTen; '''new''' lastDigit; '''new''' n;
'''new''' while;
while <- ` '''formal''' condition; '''formal''' loopBody;
'''begin'''
again: '''if''' condition '''then''' '''begin''' loopBody; '''goto''' again '''end''' '''else''' 0
maxNumber <- 10 000;
lastDigit <- ( 1, 5, 6 );
while( ` [ n <- n + 10 ] <= maxNumber '
'''if''' n = powerOfTen '''then''' powerOfTen <- powerOfTen * 10
d
while( ` [ d
'''if''' n2
'''end'''
$
{{out}}
<pre>
Line 1,139 ⟶ 1,168:
625 -> 390625
9376 -> 87909376</pre>
=={{header|Haxe}}==
<syntaxhighlight lang="haxe">
class Main // steady squares
{
static inline var MAX_NUMBER = 10000;
static function main()
{
var powerOfTen = 10;
var pad = ' ';
var lastDigit = [ 1, 5, 6 ]; // possible final digits
var n = -10;
for ( n10 in 0...Math.floor( MAX_NUMBER / 10 ) + 1 ) {
n += 10;
if( n == powerOfTen ) { // the number of digits just increased
powerOfTen *= 10;
pad = pad.substr( 1 );
}
for( d in 0...lastDigit.length ){
var nd = n + lastDigit[ d ];
var n2 = nd * nd;
if( n2 % powerOfTen == nd ){ // have a steady square
Sys.println( '$pad$nd^2 = $n2' );
}
}
}
}
}
</syntaxhighlight>
{{out}}
<pre>
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376
</pre>\
=={{header|J}}==
Line 1,308 ⟶ 1,379:
=={{header|Lua}}==
{{Trans|ALGOL W}}
Uses the fact the final digit can only be 1, 5 or 6 (see the talk page).
<syntaxhighlight lang="lua">
do --[[ find steady squares - numbers whose square ends in the number
e.g.: 376^2 = 141 376
--]]
-- checks wheher n^2 mod p10 = n, i.e. n is a steady square and displays
-- a message if it is
local function possibleSteadySuare ( n, p10 )
if ( n * n ) % p10 == n then
io.write( string.format( "%4d", n ), "^2: ", n * n, "\n" )
end
end
local powerOfTen = 10
-- note the final digit must be 1, 5 or 6
for p = 0,10000,10 do
if p == powerOfTen then
-- number of digits has increased
powerOfTen = powerOfTen * 10
end
possibleSteadySuare( p + 1, powerOfTen )
possibleSteadySuare( p + 5, powerOfTen )
possibleSteadySuare( p + 6, powerOfTen )
end
end</syntaxhighlight>
{{out}}
<pre>
1^2: 1
5^2: 25
6^2: 36
25^2: 625
76^2: 5776
376^2: 141376
625^2: 390625
9376^2: 87909376
</pre>
=={{header|MAD}}==
Line 1,354 ⟶ 1,466:
625^2 = 390625
9376^2 = 87909376</pre>
=={{header|Nim}}==
<syntaxhighlight lang="Nim">import std/[algorithm, strutils]
var ends = @["1", "5", "6"]
var steady = @[1, 5, 6]
while ends.len != 0:
var newEnds: seq[string]
for e in ends:
for d in '1'..'9':
let s = d & e
let n = parseInt(s)
if n >= 10_000: break
if ($(n * n)).endsWith(s):
steady.add n
newEnds.add s
ends = newEnds
echo "Steady squares under 10_000: "
for n in sorted(steady):
echo n, "² = ", n * n
</syntaxhighlight>
{{out}}
<pre>Steady squares under 10_000:
1² = 1
5² = 25
6² = 36
25² = 625
76² = 5776
376² = 141376
625² = 390625
9376² = 87909376
</pre>
=={{header|Oberon-07}}==
<syntaxhighlight lang="modula2">
(* find some steady squares - numbers whose squares end in the number *)
(* e.g. 376^2 = 141 376 *)
MODULE SteadySquares;
IMPORT Out;
CONST maxNumber = 10000;
VAR n, powerOfTen :INTEGER;
PROCEDURE PossibleSteadySquare( r: INTEGER );
VAR r2: INTEGER;
BEGIN
r2 := r * r;
IF ( r2 MOD powerOfTen ) = r THEN
Out.Int( r, 6 );Out.String( "^2 = " );Out.Int( r2, 1 );Out.Ln
END
END PossibleSteadySquare;
BEGIN
powerOfTen := 10;
FOR n := 0 TO maxNumber BY 10 DO
IF n = powerOfTen THEN
(* the number of digits has increased *)
powerOfTen := powerOfTen * 10
END;
PossibleSteadySquare( n + 1 );
PossibleSteadySquare( n + 5 );
PossibleSteadySquare( n + 6 )
END
END SteadySquares.
</syntaxhighlight>
{{out}}
<pre>
1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376
</pre>
=={{header|Perl}}==
Line 2,086 ⟶ 2,277:
(90625 8212890625)
(109376 11963109376)</pre>
=={{header|Quackery}}==
<syntaxhighlight lang="Quackery"> [ 1 swap
[ 10 / dup while
dip 1+ again ]
drop ] is digitcount ( n --> n )
[ dup 2 **
over digitcount
10 swap **
mod = ] is steady ( n --> b )
[]
10000 times
[ i^ steady if [ i^ join ] ]
echo</syntaxhighlight>
{{out}}
<pre>[ 0 1 5 6 25 76 376 625 9376 ]</pre>
=={{header|Refal}}==
<syntaxhighlight lang="refal">$ENTRY Go {
= <FindSteady 1 9999>;
};
FindSteady {
s.N s.Max, <Compare s.N s.Max>: '+' = ;
s.N s.Max, <Steady <Symb s.N>>: F = <FindSteady <+ s.N 1> s.Max>;
s.N s.Max = <ShowSteady s.N> <FindSteady <+ s.N 1> s.Max>;
};
ShowSteady {
s.N = <Prout <Symb s.N> '^2 = ' <* s.N s.N>>;
};
Steady {
e.N, <Symb <* <Numb e.N> <Numb e.N>>>: e.X e.N = T;
e.N = F;
};</syntaxhighlight>
{{out}}
<pre>1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376</pre>
=={{header|REXX}}==
Line 2,183 ⟶ 2,424:
== {{header|Ruby}} ==
<syntaxhighlight lang="ruby">p (0..10_000).select{|n| (n*n).to_s.end_with? n.to_s }
</syntaxhighlight>
{{out}}
<pre>[0, 1, 5, 6, 25, 76, 376, 625, 9376]
</pre>
=={{header|Rust}}==
<syntaxhighlight lang="rust">
fn is_steady_square(n: u32) -> bool {
fn iter(n: u32, m: u32) -> u64 {
if m <= n {iter(n, 10 * m)}
else {m as u64}
}
let nl = n as u64;
nl * nl % iter(n, 1) == nl
}
fn main() {
let start = std::time::Instant::now();
let limit = 10_000_000;
let list5 = (5..=limit).step_by(10)
.flat_map(|n|[n, n+1])
.filter(|&n| is_steady_square(n));
let list: Vec<u32> = (0..2).into_iter().chain(list5).collect();
let max = *list.iter().last().unwrap();
let maxl = max as u64;
let duration = start.elapsed().as_millis();
let max_len = max.to_string().len();
let sqr_len = (maxl*maxl).to_string().len();
println!("{:>max_len$} {:>sqr_len$}", "num", "square");
for n in list {
let nl = n as u64;
println!("{:max_len$} {:sqr_len$}", n, nl*nl);
}
println!("time(ms): {duration}");
}
</syntaxhighlight>
{{out}}
<pre>
num square
0 0
1 1
5 25
6 36
25 625
76 5776
376 141376
625 390625
9376 87909376
90625 8212890625
109376 11963109376
890625 793212890625
2890625 8355712890625
7109376 50543227109376
time(ms): 50
</pre>
=={{header|Scala}}==
Line 2,237 ⟶ 2,528:
time(ms): 7
</pre>
=={{header|SETL}}==
<syntaxhighlight lang="setl">program steady_squares;
loop for n in [1..10000] | steady n do
print(str n + "^2 = " + str (n**2));
end loop;
op steady(n);
return n**2 mod 10**#str n = n;
end op;
end program;</syntaxhighlight>
{{out}}
<pre>1^2 = 1
5^2 = 25
6^2 = 36
25^2 = 625
76^2 = 5776
376^2 = 141376
625^2 = 390625
9376^2 = 87909376</pre>
== {{header|TypeScript}} ==
Line 2,297 ⟶ 2,608:
{{libheader|Wren-fmt}}
Although it hardly matters for a small range such as this, one can cut down the numbers to be examined by observing that a steady square must end in 1, 5 or 6.
<syntaxhighlight lang="
System.print("Steady squares under 10,000:")
| |||