Find square difference
Find square difference 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 and show on this page the least positive integer number n, where difference of n*n and (n-1)*(n-1) greater than 1000.
The result is 501 because 501*501 - 500*500 = 251001 - 250000 = 1001 > 1000.
11l[edit]
L(n) 1..
I n^2 - (n - 1)^2 > 1000
print(n)
L.break- Output:
501
AArch64 Assembly[edit]
/* 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"- Output:
Program 64 bits start. Nombre = 501
Ada[edit]
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;
- Output:
501
ALGOL 68[edit]
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.
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 #
# n^2 - ( n - 1 )^2 is n^2 - n^2 + 2n - 1, i.e. 2n - 1 #
# so 2n - 1 > required difference or n > ( required difference + 1 ) / 2 #
PROC show least square = ( INT required difference )VOID:
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 );
show least square( 32 000 );
show least square( 2 000 000 000 )
END- Output:
Smallest n where n^2 - (n-1)^2 is > 1000 is: 501 Smallest n where n^2 - (n-1)^2 is > 32000 is: 16001 Smallest n where n^2 - (n-1)^2 is > 2000000000 is: 1000000001
ALGOL W[edit]
begin % find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 %
integer requiredDifference;
requiredDifference := 1000;
write( i_w := 1, s_w := 0,
, "Smallest n where n^2 - (n-1)^2 is > ", requiredDifference
, " is: ", ( ( requiredDifference + 1 ) div 2 ) + 1
)
end.
- Output:
Smallest n where n^2 - (n-1)^2 is > 1000 is: 501
ARM Assembly[edit]
/* ARM assembly Raspberry PI */
/* program diffsquare.s */
/* REMARK 1 : this program use routines in a include file
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}
/***************************************************/
/* ROUTINES INCLUDE */
/***************************************************/
.include "../affichage.inc"- Output:
Program 32 bits start. Nombre = 501
Arturo[edit]
i: new 1
while ø [
if 1000 < (i^2)-(dec i)^2
-> break
inc 'i
]
print i
- Output:
501
Asymptote[edit]
int fpow(int n) {
int i = 0;
while (i^2 - (i-1)^2 < n) ++i;
return i;
}
write(fpow(1000));
AutoHotkey[edit]
while ((n:=A_Index)**2 - (n-1)**2 < 1000)
continue
MsgBox % result := n
- Output:
501
AWK[edit]
# syntax: GAWK -f FIND_SQUARE_DIFFERENCE.AWK
BEGIN {
n = 1001
while (i^2-(i-1)^2 < n) {
i++
}
printf("%d\n",i)
exit(0)
}
- Output:
501
BASIC[edit]
BASIC256[edit]
function fpow(n)
i = 0
while i^2 - (i-1)^2 < n
i += 1
end while
Return i
end function
print fpow(1001)
end
PureBasic[edit]
Procedure fpow(n.i)
Define i.i
While Pow(i, 2) - Pow((i-1), 2) < n
i + 1
Wend
ProcedureReturn i
EndProcedure
OpenConsole()
Print(Str(fpow(1001)))
Input()
CloseConsole()
QBasic[edit]
FUNCTION fpow (n)
WHILE (i * i) - ((i - 1) * (i - 1)) < n
i = i + 1
WEND
fpow = i
END FUNCTION
PRINT fpow(1001)
Run BASIC[edit]
function fpow(n)
while i^2-(i-1)^2 < n
i = i+1
wend
fpow = i
end function
print fpow(1001)True BASIC[edit]
FUNCTION fpow (n)
DO WHILE i ^ 2 - (i - 1) ^ 2 < n
LET i = i + 1
LOOP
LET fpow = I
END FUNCTION
PRINT fpow(1001)
END
Tiny BASIC[edit]
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
Yabasic[edit]
sub fpow(n)
while i^2 - (i-1)^2 < n
i = i + 1
wend
Return i
end sub
print fpow(1001)
end
bc[edit]
(1000 + 1) / 2 + 1
- Output:
501
C[edit]
#include<stdio.h>
#include<stdlib.h>
int f(int n) {
int i, i1;
for(i=1;i*i-i1*i1<n;i1=i, i++);
return i;
}
int main(void) {
printf( "%d\n", f(1000) );
return 0;
}
- Output:
501
C++[edit]
The C solution is also idomatic in C++. An alterate approach is to use Ranges from C++20.
#include <iostream>
#include <ranges>
int main()
{
const int maxSquareDiff = 1000;
auto squareCheck = [maxSquareDiff](int i){return 2 * i - 1 > maxSquareDiff;};
auto answer = std::views::iota(1) | // {1, 2, 3, 4, 5, ....}
std::views::filter(squareCheck) | // filter out the ones that are below 1000
std::views::take(1); // take the first one
std::cout << answer.front() << '\n';
}
- Output:
501
Dart[edit]
import 'dart:math';
int leastSquare(int gap) {
for (int n = 1;; n++) {
if (pow(n, 2) - pow((n - 1), 2) > gap) {
return n;
}
}
}
void main() {
print(leastSquare(1000));
}
- Output:
501
dc[edit]
1000 1+2/1+p- Output:
501
Delphi[edit]
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;
- Output:
Smallest Difference N^2: < 1000 is: 501 Smallest Difference N^2: < 32000 is: 16001 Smallest Difference N^2: < 2000000000 is: 1000000001
EasyLang[edit]
repeat
i += 1
square = pow i 2
diffSquare = pow (i - 1) 2
difference = square - diffSquare
until difference > 1000
.
print iEMal[edit]
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))- Output:
501
F#[edit]
let n=1000 in printfn $"%d{((n+1)/2)+1}"
- Output:
501
Factor[edit]
The difference between squares is the odd numbers, so ls(n)=⌈n/2+1⌉.
USING: math math.functions prettyprint ;
: least-sq ( m -- n ) 2 / 1 + ceiling ;
1000 least-sq .
- Output:
501
Fermat[edit]
Func F(n) =
i:=0;
while i^2-(i-1)^2<n do i:=i+1 od; i.;
!!F(1000);
- Output:
501
Forth[edit]
: square dup * ;
: square-diff
0 begin 1+
dup square over 1- square -
1000 > until . ;
square-diff
- Output:
501 ok
FreeBASIC[edit]
function fpow(n as uinteger) as uinteger
dim as uinteger i
while i^2-(i-1)^2 < n
i+=1
wend
return i
end function
print fpow(1001)
- Output:
501
FutureBasic[edit]
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- Output:
501
Go[edit]
package main
import (
"fmt"
"math"
)
func squareDiff(k int) int {
return int(math.Ceil(float64(k+1) * 0.5))
}
func main() {
fmt.Println(squareDiff(1000))
}
- Output:
501
Haskell[edit]
The sequence of differences between successive squares is the sequence of odd numbers.
import Data.List (findIndex)
f = succ . flip div 2
-- Or, with redundant verbosity
g n = i
where
Just i = succ <$> findIndex (> n) [1, 3 ..]
main = mapM_ print $ [f, g] <*> [1000]
- Output:
501 501
J[edit]
Through inspection, we can see that the "square difference' for a number n is (2*n)-1:
(*: - *:&<:) 1 2 3 4 5
1 3 5 7 9
Therefore, we expect that n=501 would give us a "square difference' of 1001. Testing, we can see that this is the case:
(*: - *:&<:) 501
1001
Joy[edit]
1000 succ 2 / succ.- Output:
501
jq[edit]
Works with gojq, the Go implementation of jq
So this question is essentially asking to solve `2n - 1 > 1000`. Wow.
At the risk of hastening RC's demise, one could offer a jq solution like so:
first( range(1; infinite) | select( 2 * . - 1 > 1000 ) )Or, for anyone envious of Bitcoin's contribution to global warming:
first( range(1; infinite) | select( .*. - ((.-1) | .*.) > 1000 ) )- Output:
501
Julia[edit]
julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)
501
OCaml[edit]
let calculate x =
succ (succ x lsr 1)
let () =
Printf.printf "%u\n" (calculate 1000)
- Output:
501
Pari/GP[edit]
F(n)=i=0;while(i^2-(i-1)^2<n,i=i+1);return(i);
print(F(1000))- Output:
501
Pencil and Paper[edit]
Find the smallest positive integer number n, where the difference of n2 and (n - 1)2 is greater than 1000.
r: roots of squares s: successive squares d: differences between successive squares, (a.k.a, the list of positive odd integers) r: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ... s: 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100, ... d: 1, 3, 5, 7, 9, 11, 13, 15, 17, 19, ... r: n s: n * n d: n * 2 + 1 solve for d > 1,000 the first odd integer greater than 1,000 is 1,001 (1,001 + 1) / 2 = 501 ( = n)
Perl[edit]
#!/usr/bin/perl
use strict; # https://rosettacode.org/wiki/Least_square
use warnings;
my $n = 1;
$n++ until $n ** 2 - ($n-1) ** 2 > 1000;
print "$n\n";
- Output:
501
Phix[edit]
Essentially Wren equivalent, but explained in excruciating detail especially for enyone that evidently needs elp, said Eeyore.
with javascript_semantics printf(1,""" n*n - (n - 1)*(n - 1) > 1000 n*n - (n*n - 2*n + 1) > 1000 n*n - n*n + 2*n - 1 > 1000 2*n - 1 > 1000 2*n > 1001 n > 500.5 n = %d """,ceil(500.5))
- Output:
n*n - (n - 1)*(n - 1) > 1000 n*n - (n*n - 2*n + 1) > 1000 n*n - n*n + 2*n - 1 > 1000 2*n - 1 > 1000 2*n > 1001 n > 500.5 n = 501
Or if you prefer, same output:
with javascript_semantics string e -- equation procedure p(string s) e := s -- set/save printf(1,"%s\n",s) end procedure p("n*n - (n - 1)*(n - 1) > 1000") -- original p(substitute(e,"(n - 1)*(n - 1)", "(n*n - 2*n + 1)")) -- expand string{l,m,r} = scanf(e,"%s - (%s)%s")[1] m = substitute_all(m,"-+|","|-+") -- unsign p(sprintf("%s - %s%s",{l,m,r})) p(substitute(e,"n*n - n*n + ","")) -- eliminate p(substitute_all(e,{" - 1","1000"},{"","1001"})) -- add 1 p(substitute_all(e,{"2*","1001"},{"","500.5"})) -- divide by 2 p(substitute(e,"> 500.5",sprintf("= %d",ceil(500.5)))) -- solve
or even:
without js -- (user defined types are not implicitly called) type pstring(string s) printf(1,"%s\n",s) return true end type pstring e -- equation e = "n*n - (n - 1)*(n - 1) > 1000" -- original e = substitute(e,"(n - 1)*(n - 1)", "(n*n - 2*n + 1)") -- expand string{l,m,r} = scanf(e,"%s - (%s)%s")[1] m = substitute_all(m,"-+|","|-+") -- unsign e = sprintf("%s - %s%s",{l,m,r}) e = substitute(e,"n*n - n*n + ","") -- eliminate e = substitute_all(e,{" - 1","1000"},{"","1001"}) -- add 1 e = substitute_all(e,{"2*","1001"},{"","500.5"}) -- divide by 2 e = substitute(e,"> 500.5",sprintf("= %d",ceil(500.5))) -- solve
Phixmonti[edit]
/# 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- Output:
501 === Press any key to exit ===
PL/M[edit]
This can be compiled with the original 8080 PL/M compiler and run under CP/M or an emulator.
Note that the original 8080 PL/M compiler only supports 8 and 16 bit unisgned numbers.
100H: /* FIND THE LEAST +VE N WHERE N SQUARED - (N-1) SQUARED > 1000 */
BDOS: PROCEDURE( FN, ARG ); /* CP/M BDOS SYSTEM CALL */
DECLARE FN BYTE, ARG ADDRESS;
GOTO 5;
END BDOS;
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$NL: PROCEDURE; CALL PR$CHAR( 0DH ); CALL PR$CHAR( 0AH ); 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;
PRINT$LEAST: PROCEDURE( DIFF );
DECLARE DIFF ADDRESS;
CALL PR$STRING( . 'THE LOWEST N WHERE THE SQUARES OF N AND N-1 $' );
CALL PR$STRING( . 'DIFFER BY MORE THAN $' );
CALL PR$NUMBER( DIFF );
CALL PR$STRING( .' IS: $' );
CALL PR$NUMBER( ( ( DIFF + 1 ) / 2 ) + 1 );
CALL PR$NL;
END PRINT$LEAST ;
CALL PRINT$LEAST( 1000 );
CALL PRINT$LEAST( 32000 );
CALL PRINT$LEAST( 65000 );
EOF- Output:
THE LOWEST N WHERE THE SQUARES OF N AND N-1 DIFFER BY MORE THAN 1000 IS: 501 THE LOWEST N WHERE THE SQUARES OF N AND N-1 DIFFER BY MORE THAN 32000 IS: 16001 THE LOWEST N WHERE THE SQUARES OF N AND N-1 DIFFER BY MORE THAN 65000 IS: 32501
Plain English[edit]
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.
Python[edit]
import math
print("working...")
limit1 = 6000
limit2 = 1000
oldSquare = 0
newSquare = 0
for n in range(limit1):
newSquare = n*n
if (newSquare - oldSquare > limit2):
print("Least number is = ", end = "");
print(int(math.sqrt(newSquare)))
break
oldSquare = n*n
print("done...")
print()
- Output:
working... Least number is = 501 done...
Quackery[edit]
[ dup * ] is squared ( n --> n )
0
[ 1+
dup squared
over 1 - squared -
1000 > until ]
echo- Output:
501
Using algebra[edit]
Noting that a²-b² ≡ (a+b)(a-b), and that in this instance a = b+1.
1000 2 / 1+ echo- Output:
501
Raku[edit]
say first { $_² - ($_-1)² > 1000 }, ^Inf;
- Output:
501
Ring[edit]
load "stdlib.ring"
see "working..." + nl
limit1 = 6000
limit2 = 1000
oldPrime = 0
newPrime = 0
for n = 1 to limit1
newPrime = n*n
if newPrime - oldPrime > limit2
see "Latest number is = " + sqrt(newPrime) + nl
exit
ok
oldPrime = n*n
next
see "done..." + nl- Output:
working... Latest number is = 501 done...
RPL[edit]
≪ 1 1
DO
SWAP 1 + DUP SQ
UNTIL DUP 4 ROLL - 1000 > END DROP
≫ EVAL
- Output:
1: 501
The above program takes 16.4 seconds to be executed on a HP-28S.
Algebraic approach[edit]
≪ 'n^2-(n-1)^2-1000' EXPAN COLCT 'n' ISOL CEIL ≫ EVAL
which returns the same result in only 9.2 seconds.
Ruby[edit]
p (1..).detect{|n| n*n - (n-1)*(n-1) > 1000 }
- Output:
501
Sidef[edit]
var N = 1000
# Binary search
var n = bsearch_ge(1, N, {|k|
k**2 - (k-1)**2 <=> N+1
})
# Closed-form
var m = ceil((N + 1 + N&1) / 2)
assert(n**2 - (n-1)**2 > N)
assert_eq(n, m)
say "#{n}^2 - #{n-1}^2 = #{n**2 - (n-1)**2}"
- Output:
501^2 - 500^2 = 1001
Verilog[edit]
module main;
integer i, n;
initial begin
n = 1000;
i = 0;
while (i ** 2 - (i - 1) ** 2 < n) i=i+1;
$display(i);
$finish ;
end
endmodule
Wren[edit]
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.
var squareDiff = Fn.new { |k| ((k + 1) * 0.5).ceil }
System.print(squareDiff.call(1000))
- Output:
501
XPL0[edit]
n^2 - (n - 1)^2 > 1000 n^2 - (n^2 - 2n + 1) > 1000 2n - 1 > 1000 2n > 1001 n > 500.5 n = 501
zig[edit]
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;
}
}
}
- Output:
Result= 501
Categories:
- Pages with syntax highlighting errors
- Draft Programming Tasks
- 11l
- AArch64 Assembly
- Ada
- ALGOL 68
- ALGOL W
- ARM Assembly
- Arturo
- Asymptote
- AutoHotkey
- AWK
- BASIC
- BASIC256
- PureBasic
- QBasic
- Run BASIC
- True BASIC
- Tiny BASIC
- Yabasic
- Bc
- C
- C++
- Dart
- Dc
- Delphi
- SysUtils,StdCtrls
- EasyLang
- EMal
- F Sharp
- Factor
- Fermat
- Forth
- FreeBASIC
- FutureBasic
- Go
- Haskell
- J
- Joy
- Jq
- Julia
- OCaml
- Pari/GP
- Pencil and Paper
- Perl
- Phix
- Phixmonti
- PL/M
- Plain English
- Plain English-output
- Python
- Quackery
- Using algebra
- Raku
- Ring
- RPL
- Ruby
- Sidef
- Verilog
- Wren
- XPL0
- Zig
- Simple