Rosetta Code

Find square difference: Difference between revisions

Page Discussion

Find square difference (view source)

Revision as of 11:44, 5 December 2023

15,100 bytes added ,  5 months ago
m
→‎{{header|Wren}}: Changed to Wren S/H
m (→‎{{header|Wren}}: Changed to Wren S/H)
 
(30 intermediate revisions by 17 users not shown)
Line 7:
 
=={{header|11l}}==
<langsyntaxhighlight lang="11l">L(n) 1..
I n^2 - (n - 1)^2 > 1000
print(n)
L.break</langsyntaxhighlight>
 
{{out}}
<pre>
501
</pre>
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits <br> or android 64 bits with application Termux }}
<syntaxhighlight lang AArch64 Assembly>
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program diffsquare64.s */
 
/************************************/
/* Constantes */
/************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeConstantesARM64.inc"
.equ MAXI, 10000
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessNotFind: .asciz "No soluce !! "
szMessResult: .asciz "Nombre = "
szMessStart: .asciz "Program 64 bits start.\n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: // entry of program
ldr x0,qAdrszMessStart
bl affichageMess
mov x5,#2 // init start number
ldr x3,iMAXI
1: // begin loop
mul x2,x5,x5 // n * n
sub x4,x5,#1 // n - 1
mul x6,x4,x4 // (n - 1) * (n - 1)
sub x0,x2,x6 // difference
cmp x0,#1000 // > 1000
bgt 2f
add x5,x5,#1 // increment number
cmp x5,x3 // maxi limit ?
blt 1b
ldr x0,qAdrszMessNotFind // display not find
bl affichageMess
b 100f
2: // display result
mov x0,x5
ldr x1,qAdrsZoneConv
bl conversion10 // decimal conversion
mov x0,#3 // number string to display
ldr x1,qAdrszMessResult
ldr x2,qAdrsZoneConv // insert conversion in message
ldr x3,qAdrszCarriageReturn
bl displayStrings // display message
100: // standard end of the program
mov x0, #0 // return code
mov x8,EXIT
svc #0 // perform the system call
qAdrszCarriageReturn: .quad szCarriageReturn
qAdrsZoneConv: .quad sZoneConv
qAdrszMessResult: .quad szMessResult
qAdrszMessNotFind: .quad szMessNotFind
qAdrszMessStart: .quad szMessStart
iMAXI: .quad MAXI
/***************************************************/
/* display multi strings */
/* new version 24/05/2023 */
/***************************************************/
/* x0 contains number strings address */
/* x1 address string1 */
/* x2 address string2 */
/* x3 address string3 */
/* x4 address string4 */
/* x5 address string5 */
/* x6 address string5 */
displayStrings: // INFO: displayStrings
stp x7,lr,[sp,-16]! // save registers
stp x2,fp,[sp,-16]! // save registers
add fp,sp,#32 // save paraméters address (4 registers saved * 8 bytes)
mov x7,x0 // save strings number
cmp x7,#0 // 0 string -> end
ble 100f
mov x0,x1 // string 1
bl affichageMess
cmp x7,#1 // number > 1
ble 100f
mov x0,x2
bl affichageMess
cmp x7,#2
ble 100f
mov x0,x3
bl affichageMess
cmp x7,#3
ble 100f
mov x0,x4
bl affichageMess
cmp x7,#4
ble 100f
mov x0,x5
bl affichageMess
cmp x7,#5
ble 100f
mov x0,x6
bl affichageMess
100:
ldp x2,fp,[sp],16 // restaur registers
ldp x7,lr,[sp],16 // restaur registers
ret
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
/* for this file see task include a file in language AArch64 assembly*/
.include "../includeARM64.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 64 bits start.
Nombre = 501
</pre>
=={{header|Ada}}==
<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;
 
procedure Find_Square_Difference is
Last : Natural := 0;
Square : Positive;
Diff : Positive;
begin
for N in 1 .. Positive'Last loop
Square := N ** 2;
Diff := Square - Last;
Last := Square;
if Diff > 1000 then
Put_Line (N'Image);
exit;
end if;
end loop;
end Find_Square_Difference;</syntaxhighlight>
{{out}}
<pre>
501
</pre>
 
=={{header|ALGOL 68}}==
Also shows the least positive integer where the difference between n^2 and (n-1)^2 is greater than 32 000 and 2 000 000 000.
<langsyntaxhighlight lang="algol68">BEGIN # find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 #
# shows the smalled square n where n^2 - (n-1)^2 is greater than required difference #
[]INT test = ( 1 000, 32 000, 2 000 000 000 );
# n^2 - ( n - 1 )^2 is n^2 - n^2 + 2n - 1, i.e. 2n - 1 #
FOR i FROM LWB test TO UPB test DO
# INT so 2n - 1 > required difference =or n > ( required difference + 1 ) / 2 test[ i ];#
PROC show least square = ( INT required difference )VOID:
# n^2 - ( n - 1 )^2 is n^2 - n^2 + 2n - 1, i.e. 2n - 1 #
# so 2n - 1 > reuired difference or n > reuired difference / 2 #
print( ( "Smallest n where n^2 - (n-1)^2 is > ", whole( required difference, -12 )
, " is: ", whole( ( ( required difference + 1 ) OVER 2 ) + 1, -12 )
, newline
)
);
show least square( 1 000 );
OD
show least square( 32 000 );
END</lang>
show least square( 2 000 000 000 )
END
</syntaxhighlight>
{{out}}
<pre>
Line 40 ⟶ 189:
 
=={{header|ALGOL W}}==
<langsyntaxhighlight lang="pascal">begin % find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 %
integer requiredDifference;
requiredDifference := 1000;
Line 47 ⟶ 196:
, " is: ", ( ( requiredDifference + 1 ) div 2 ) + 1
)
end.</langsyntaxhighlight>
{{out}}
<pre>
Smallest n where n^2 - (n-1)^2 is > 1000 is: 501
</pre>
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi <br> or android 32 bits with application Termux}}
<syntaxhighlight lang ARM Assembly>
/* ARM assembly Raspberry PI */
/* program diffsquare.s */
 
/* REMARK 1 : this program use routines in a include file
=={{header|Arturo}}==
see task Include a file language arm assembly
for the routine affichageMess conversion10
see at end of this program the instruction include */
/* for constantes see task include a file in arm assembly */
/************************************/
/* Constantes */
/************************************/
.include "../constantes.inc"
.equ MAXI, 10000
/*********************************/
/* Initialized data */
/*********************************/
.data
szMessNotFind: .asciz "No soluce !! "
szMessResult: .asciz "Nombre = "
szMessStart: .asciz "Program 32 bits start.\n"
szCarriageReturn: .asciz "\n"
/*********************************/
/* UnInitialized data */
/*********************************/
.bss
sZoneConv: .skip 24
/*********************************/
/* code section */
/*********************************/
.text
.global main
main: @ entry of program
ldr r0,iAdrszMessStart
bl affichageMess
mov r5,#2 @ init start number
ldr r3,iMAXI
1: @ begin loop
mul r2,r5,r5 @ n * n
sub r4,r5,#1 @ n - 1
mul r6,r4,r4 @ (n - 1) * (n - 1)
sub r0,r2,r6 @ difference
cmp r0,#1000 @ > 1000
bgt 2f
add r5,r5,#1 @ increment number
cmp r5,r3 @ maxi limit ?
blt 1b
ldr r0,iAdrszMessNotFind @ display not find
bl affichageMess
b 100f
2: @ display result
mov r0,r5
ldr r1,iAdrsZoneConv
bl conversion10 @ decimal conversion
mov r3,#0 @ zero final
strb r3,[r1,r0]
mov r0,#3 @ number string to display
ldr r1,iAdrszMessResult
ldr r2,iAdrsZoneConv @ insert conversion in message
ldr r3,iAdrszCarriageReturn
bl displayStrings @ display message
100: @ standard end of the program
mov r0, #0 @ return code
mov r7, #EXIT @ request to exit program
svc #0 @ perform the system call
iAdrszCarriageReturn: .int szCarriageReturn
iAdrsZoneConv: .int sZoneConv
iAdrszMessResult: .int szMessResult
iAdrszMessNotFind: .int szMessNotFind
iAdrszMessStart: .int szMessStart
iMAXI: .int MAXI
/***************************************************/
/* display multi strings */
/***************************************************/
/* r0 contains number strings address */
/* r1 address string1 */
/* r2 address string2 */
/* r3 address string3 */
/* other address on the stack */
/* thinck to add number other address * 4 to add to the stack */
displayStrings: @ INFO: displayStrings
push {r1-r4,fp,lr} @ save des registres
add fp,sp,#24 @ save paraméters address (6 registers saved * 4 bytes)
mov r4,r0 @ save strings number
cmp r4,#0 @ 0 string -> end
ble 100f
mov r0,r1 @ string 1
bl affichageMess
cmp r4,#1 @ number > 1
ble 100f
mov r0,r2
bl affichageMess
cmp r4,#2
ble 100f
mov r0,r3
bl affichageMess
cmp r4,#3
ble 100f
mov r3,#3
sub r2,r4,#4
1: @ loop extract address string on stack
ldr r0,[fp,r2,lsl #2]
bl affichageMess
subs r2,#1
bge 1b
100:
pop {r1-r4,fp,pc}
 
/***************************************************/
<lang rebol>i: new 1
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"
</syntaxhighlight>
{{Out}}
<pre>
Program 32 bits start.
Nombre = 501
</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">i: new 1
while ø [
if 1000 < (i^2)-(dec i)^2
Line 61 ⟶ 332:
inc 'i
]
print i</langsyntaxhighlight>
 
{{out}}
Line 68 ⟶ 339:
 
=={{header|Asymptote}}==
<langsyntaxhighlight Asymptotelang="asymptote">int fpow(int n) {
int i = 0;
while (i^2 - (i-1)^2 < n) ++i;
Line 74 ⟶ 345:
}
 
write(fpow(1000));</langsyntaxhighlight>
 
=={{header|AutoHotkey}}==
<langsyntaxhighlight AutoHotkeylang="autohotkey">while ((n:=A_Index)**2 - (n-1)**2 < 1000)
continue
MsgBox % result := n</langsyntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f FIND_SQUARE_DIFFERENCE.AWK
BEGIN {
Line 94 ⟶ 365:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
501
</pre>
 
 
=={{header|BASIC}}==
==={{header|BASIC256}}===
<langsyntaxhighlight lang="freebasic">function fpow(n)
i = 0
while i^2 - (i-1)^2 < n
Line 112 ⟶ 382:
 
print fpow(1001)
end</langsyntaxhighlight>
 
==={{header|PureBasic}}===
<langsyntaxhighlight PureBasiclang="purebasic">Procedure fpow(n.i)
Define i.i
While Pow(i, 2) - Pow((i-1), 2) < n
Line 126 ⟶ 396:
Print(Str(fpow(1001)))
Input()
CloseConsole()</langsyntaxhighlight>
 
==={{header|QBasic}}===
<langsyntaxhighlight lang="qbasic">FUNCTION fpow (n)
WHILE (i * i) - ((i - 1) * (i - 1)) < n
i = i + 1
Line 136 ⟶ 406:
END FUNCTION
 
PRINT fpow(1001)</langsyntaxhighlight>
 
==={{header|Run BASIC}}===
<syntaxhighlight lang="lb">function fpow(n)
while i^2-(i-1)^2 < n
i = i+1
wend
fpow = i
end function
print fpow(1001)</syntaxhighlight>
 
==={{header|True BASIC}}===
<langsyntaxhighlight lang="qbasic">FUNCTION fpow (n)
DO WHILE i ^ 2 - (i - 1) ^ 2 < n
LET i = i + 1
Line 147 ⟶ 427:
 
PRINT fpow(1001)
END</syntaxhighlight>
END
 
</lang>
==={{Header|Tiny BASIC}}===
<syntaxhighlight lang="qbasic"> LET N = 1001
 
LET I = 0
10 LET R = I*I - (I-1)*(I-1)
IF R >= N THEN GOTO 20
IF R < N THEN LET I = I + 1
GOTO 10
20 PRINT I
END</syntaxhighlight>
 
==={{header|Yabasic}}===
<langsyntaxhighlight lang="freebasic">sub fpow(n)
while i^2 - (i-1)^2 < n
i = i + 1
Line 159 ⟶ 449:
 
print fpow(1001)
end</langsyntaxhighlight>
 
 
=={{header|bc}}==
<syntaxhighlight lang="bc">(1000 + 1) / 2 + 1</syntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|C}}==
<langsyntaxhighlight lang="c">#include<stdio.h>
#include<stdlib.h>
 
Line 175 ⟶ 470:
printf( "%d\n", f(1000) );
return 0;
}</langsyntaxhighlight>
{{out}}
<pre>501</pre>
Line 181 ⟶ 476:
=={{header|C++}}==
The C solution is also idomatic in C++. An alterate approach is to use Ranges from C++20.
<langsyntaxhighlight lang="cpp">#include <iostream>
#include <ranges>
 
Line 193 ⟶ 488:
std::cout << answer.front() << '\n';
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 200 ⟶ 495:
 
=={{header|Dart}}==
<langsyntaxhighlight lang="dart">import 'dart:math';
 
int leastSquare(int gap) {
Line 212 ⟶ 507:
void main() {
print(leastSquare(1000));
}</langsyntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|dc}}==
<syntaxhighlight lang="dc">1000 1+2/1+p</syntaxhighlight>
{{out}}
<pre>501</pre>
 
 
=={{header|Delphi}}==
{{works with|Delphi|6.0}}
{{libheader|SysUtils,StdCtrls}}
 
<syntaxhighlight lang="Delphi">
procedure LeastSquareDiff(Memo: TMemo; Limit: integer);
var N: integer;
var S: string;
begin
for N:=1 to High(integer) do
if (N*N)-((N-1)*(N-1))>Limit then break;
S:=Format('Smallest Difference N^2: <%12d is: %12d',[Limit,N]);
Memo.Lines.Add(S);
end;
 
 
procedure ShowLeastSquareDiff(Memo: TMemo);
begin
LeastSquareDiff(Memo,1000);
LeastSquareDiff(Memo,32000);
LeastSquareDiff(Memo,2000000000);
end;
 
</syntaxhighlight>
{{out}}
<pre>
Smallest Difference N^2: < 1000 is: 501
Smallest Difference N^2: < 32000 is: 16001
Smallest Difference N^2: < 2000000000 is: 1000000001
</pre>
 
 
=={{header|EasyLang}}==
<syntaxhighlight lang="easylang">
repeat
i += 1
a = i * i
b = (i - 1) * (i - 1)
until a - b > 1000
.
print i
</syntaxhighlight>
 
=={{header|EMal}}==
<syntaxhighlight lang="emal">
fun leastSquare = int by int gap
for int n = 1; ; ++n
if n ** 2 - (n - 1) ** 2 > gap do return n end
end
end
writeLine(leastSquare(1000))
</syntaxhighlight>
{{out}}
<pre>
501
</pre>
 
=={{header|F_Sharp|F#}}==
<langsyntaxhighlight lang="fsharp">
let n=1000 in printfn $"%d{((n+1)/2)+1}"
</syntaxhighlight>
</lang>
{{out}}
<pre>
501
</pre>
 
 
=={{header|Factor}}==
The difference between squares is the odd numbers, so ls(n)=&#8968;n/2+1&#8969;.
{{works with|Factor|0.99 2021-06-02}}
<langsyntaxhighlight lang="factor">USING: math math.functions prettyprint ;
 
: least-sq ( m -- n ) 2 / 1 + ceiling ;
 
1000 least-sq .</langsyntaxhighlight>
{{out}}
<pre>
Line 238 ⟶ 598:
 
=={{header|Fermat}}==
<syntaxhighlight lang="text">Func F(n) =
i:=0;
while i^2-(i-1)^2<n do i:=i+1 od; i.;
 
!!F(1000);</langsyntaxhighlight>
{{out}}<pre>501</pre>
 
=={{header|Forth}}==
{{works with|gforth|0.7.3}}
{{trans|Quackery}}
 
<syntaxhighlight lang="Forth">: square dup * ;
: square-diff
0 begin 1+
dup square over 1- square -
1000 > until . ;
 
square-diff</syntaxhighlight>
{{out}}<pre>501 ok</pre>
 
 
=={{header|FreeBASIC}}==
<langsyntaxhighlight lang="freebasic">function fpow(n as uinteger) as uinteger
dim as uinteger i
while i^2-(i-1)^2 < n
Line 254 ⟶ 628:
end function
 
print fpow(1001)</langsyntaxhighlight>
{{out}}<pre>501</pre>
 
 
=={{header|FutureBasic}}==
<syntaxhighlight lang="futurebasic">
local fn fpow( n as NSUInteger ) as NSUInteger
NSUInteger i = 0
while ( i^2 - (i-1)^2 < n ) : i++ : wend
end fn = i
 
print fn fpow( 1001 )
 
HandleEvents
</syntaxhighlight>
{{output}}
<pre>
501
</pre>
 
 
 
 
 
 
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 271 ⟶ 668:
func main() {
fmt.Println(squareDiff(1000))
}</langsyntaxhighlight>
 
{{out}}
Line 280 ⟶ 677:
=={{header|Haskell}}==
The sequence of differences between successive squares is the sequence of odd numbers.
<langsyntaxhighlight lang="haskell">import Data.List (findIndex)
 
f = succ . flip div 2
Line 286 ⟶ 683:
-- Or, with redundant verbosity
 
g n = i
where
let Just i = findIndex (> n) [1, 3..]
Just i = succ <$> findIndex (> n) [1, 3 ..]
in succ i
 
main = mapM_ print $ [f, g] <*> [1000]</syntaxhighlight>
main = do
print $ f 1000
print $ g 1000</lang>
{{Out}}
<pre>501
501</pre>
 
=={{header|J}}==
Through inspection, we can see that the "square difference' for a number <code>n</code> is <code>(2*n)-1</code>:
<syntaxhighlight lang=J> (*: - *:&<:) 1 2 3 4 5
1 3 5 7 9</syntaxhighlight>
 
Therefore, we expect that n=501 would give us a "square difference' of 1001. Testing, we can see that this is the case:
 
<syntaxhighlight lang=J> (*: - *:&<:) 501
1001</syntaxhighlight>
 
=={{header|Joy}}==
<syntaxhighlight lang="joy">1000 succ 2 / succ.</syntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|jq}}==
Line 304 ⟶ 714:
 
At the risk of hastening RC's demise, one could offer a jq solution like so:
<langsyntaxhighlight lang="jq">first( range(1; infinite) | select( 2 * . - 1 > 1000 ) )</langsyntaxhighlight>
Or, for anyone envious of Bitcoin's contribution to global warming:
<syntaxhighlight lang="jq">
<lang jq>
first( range(1; infinite) | select( .*. - ((.-1) | .*.) > 1000 ) )
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 315 ⟶ 725:
 
=={{header|Julia}}==
<langsyntaxhighlight lang="julia">julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)
501
</syntaxhighlight>
</lang>
 
=={{header|OCaml}}==
<syntaxhighlight lang="ocaml">let calculate x =
succ (succ x lsr 1)
 
let () =
Printf.printf "%u\n" (calculate 1000)</syntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|Pari/GP}}==
<langsyntaxhighlight lang="parigp">F(n)=i=0;while(i^2-(i-1)^2<n,i=i+1);return(i);
print(F(1000))</langsyntaxhighlight>
{{out}}<pre>501</pre>
 
Line 345 ⟶ 764:
 
=={{header|Perl}}==
<langsyntaxhighlight lang="perl">#!/usr/bin/perl
 
use strict; # https://rosettacode.org/wiki/Least_square
Line 352 ⟶ 771:
my $n = 1;
$n++ until $n ** 2 - ($n-1) ** 2 > 1000;
print "$n\n";</langsyntaxhighlight>
{{out}}
<pre>
Line 360 ⟶ 779:
=={{header|Phix}}==
<small>''Essentially Wren equivalent, but explained in excruciating detail especially for enyone that evidently needs elp, said Eeyore.''</small>
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</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;">"""
Line 371 ⟶ 790:
n = %d
"""</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">ceil</span><span style="color: #0000FF;">(</span><span style="color: #000000;">500.5</span><span style="color: #0000FF;">))</span>
<!--</langsyntaxhighlight>-->
{{out}}
<pre>
Line 383 ⟶ 802:
</pre>
Or if you prefer, same output:
<!--<langsyntaxhighlight Phixlang="phix">(phixonline)-->
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
<span style="color: #004080;">string</span> <span style="color: #000000;">e</span> <span style="color: #000080;font-style:italic;">-- equation</span>
Line 400 ⟶ 819:
<span style="color: #000000;">p</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"2*"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1001"</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"500.5"</span><span style="color: #0000FF;">}))</span> <span style="color: #000080;font-style:italic;">-- divide by 2</span>
<span style="color: #000000;">p</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&gt; 500.5"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"= %d"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">ceil</span><span style="color: #0000FF;">(</span><span style="color: #000000;">500.5</span><span style="color: #0000FF;">))))</span> <span style="color: #000080;font-style:italic;">-- solve</span>
<!--</langsyntaxhighlight>-->
or even:
<!--<langsyntaxhighlight Phixlang="phix">-->
<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (user defined types are not implicitly called)</span>
<span style="color: #008080;">type</span> <span style="color: #000000;">pstring</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">s</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;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">return</span> <span style="color: #004600;">true</span> <span style="color: #008080;">end</span> <span style="color: #008080;">type</span>
Line 416 ⟶ 835:
<span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute_all</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,{</span><span style="color: #008000;">"2*"</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"1001"</span><span style="color: #0000FF;">},{</span><span style="color: #008000;">""</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"500.5"</span><span style="color: #0000FF;">})</span> <span style="color: #000080;font-style:italic;">-- divide by 2</span>
<span style="color: #000000;">e</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">substitute</span><span style="color: #0000FF;">(</span><span style="color: #000000;">e</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"&gt; 500.5"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">sprintf</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"= %d"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">ceil</span><span style="color: #0000FF;">(</span><span style="color: #000000;">500.5</span><span style="color: #0000FF;">)))</span> <span style="color: #000080;font-style:italic;">-- solve</span>
<!--</langsyntaxhighlight>-->
 
=={{header|Phixmonti}}==
<syntaxhighlight lang="Phixmonti">/# Rosetta Code problem: http://rosettacode.org/wiki/Find_square_difference
by Galileo, 10/2022 #/
 
def >1000
dup dup * over 1 - dup * - 1001 <
enddef
 
0 true while 1 + >1000 endwhile print</syntaxhighlight>
{{out}}
<pre>501
=== Press any key to exit ===</pre>
 
=={{header|PL/M}}==
This can be compiled with the original 8080 PL/M compiler and run under CP/M or an emulator.
<br>Note that the original 8080 PL/M compiler only supports 8 and 16 bit unisgned numbers.
<langsyntaxhighlight lang="pli">100H: /* FIND THE LEAST +VE N WHERE N SQUARED - (N-1) SQUARED > 1000 */
 
BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */
Line 456 ⟶ 888:
CALL PRINT$LEAST( 65000 );
 
EOF</langsyntaxhighlight>
{{out}}
<pre>
Line 463 ⟶ 895:
THE LOWEST N WHERE THE SQUARES OF N AND N-1 DIFFER BY MORE THAN 65000 IS: 32501
</pre>
 
=={{header|Plain English}}==
{{libheader|Plain English-output}}
<syntaxhighlight lang="text">
To run:
Start up.
Put 1 into a counter.
Loop.
If the counter does have a square difference, write the counter to the output; break.
Bump the counter.
Repeat.
Wait for the escape key.
Shut down.
 
To decide if a number does have a square difference:
Put the number into another number.
Raise the other number to 2.
Put the number into a third number.
Subtract 1 from the third number.
Raise the third number to 2.
If the other number minus the third number is greater than 1000, say yes.
Say no.
</syntaxhighlight>
 
=={{header|Python}}==
<langsyntaxhighlight lang="python">
import math
print("working...")
Line 483 ⟶ 938:
print("done...")
print()
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 492 ⟶ 947:
 
=={{header|Quackery}}==
<syntaxhighlight lang="quackery"> [ dup * ] is squared ( n --> n )
 
<lang Quackery> [ dup * ] is squared ( n --> n )
0
Line 500 ⟶ 954:
over 1 - squared -
1000 > until ]
echo</langsyntaxhighlight>
 
{{out}}
Line 507 ⟶ 961:
 
==={{header|Using algebra}}===
 
Noting that a²-b² ≡ (a+b)(a-b), and that in this instance a = b+1.
 
<langsyntaxhighlight Quackerylang="quackery"> 1000 2 / 1+ echo</langsyntaxhighlight>
 
{{out}}
Line 517 ⟶ 970:
 
=={{header|Raku}}==
<syntaxhighlight lang="raku" perl6line>say first { $_² - ($_-1)² > 1000 }, ^Inf;</langsyntaxhighlight>
{{out}}
<pre>501</pre>
 
=={{header|Ring}}==
<langsyntaxhighlight lang="ring">
load "stdlib.ring"
see "working..." + nl
Line 540 ⟶ 993:
 
see "done..." + nl
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 548 ⟶ 1,001:
</pre>
 
=={{header|RPL}}==
≪ 1 1
'''DO'''
SWAP 1 + DUP SQ
'''UNTIL''' DUP 4 ROLL - 1000 > '''END''' DROP
≫ EVAL
{{out}}
<pre>
1: 501
</pre>
The above program takes 16.4 seconds to be executed on a HP-28S.
===Algebraic approach===
≪ 'n^2-(n-1)^2-1000'
EXPAN COLCT 'n' ISOL CEIL
≫ EVAL
which returns the same result in only 9.2 seconds.
 
=={{header|Ruby}}==
<syntaxhighlight lang="ruby">p (1..).detect{|n| n*n - (n-1)*(n-1) > 1000 }</syntaxhighlight>
{{out}}
<pre>501
</pre>
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">var N = 1000
 
# Binary search
Line 562 ⟶ 1,037:
assert_eq(n, m)
 
say "#{n}^2 - #{n-1}^2 = #{n**2 - (n-1)**2}"</langsyntaxhighlight>
{{out}}
<pre>
Line 569 ⟶ 1,044:
 
=={{header|Verilog}}==
<langsyntaxhighlight Veriloglang="verilog">module main;
integer i, n;
Line 579 ⟶ 1,054:
$finish ;
end
endmodule</langsyntaxhighlight>
 
=={{header|Wren}}==
The solution '''n''' for some non-negative integer '''k''' needs to be such that: ''n² - (n² - 2n + 1) > k'' which reduces to: ''n > (k + 1)/2''.
<langsyntaxhighlight ecmascriptlang="wren">var squareDiff = Fn.new { |k| ((k + 1) * 0.5).ceil }
System.print(squareDiff.call(1000))</langsyntaxhighlight>
 
{{out}}
Line 599 ⟶ 1,074:
n > 500.5
n = 501
</pre>
=={{header|zig}}==
<syntaxhighlight lang="zig">
const std = @import("std");
const print = @import("std").debug.print;
 
 
pub fn main() !void {
var number: u64 = 2;
while(true) {
const sq= number * number;
const number1= number - 1;
const sq1= number1 * number1;
if (sq - sq1 > 1000 ) {
print("Result= {}\n", .{ number });
break;
}
number += 1;
if (number > 10000) {
print("No find ! \n",.{});
break;
}
}
}
</syntaxhighlight>
{{Out}}
<pre>
Result= 501
</pre>
[[Category:Simple]]
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/317674...355222"