Find square difference

From Rosetta Code
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

L(n) 1..
   I n^2 - (n - 1)^2 > 1000
      print(n)
      L.break
Output:
501

AArch64 Assembly

Works with: as version Raspberry Pi 3B version Buster 64 bits
or android 64 bits with application Termux
/* 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

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

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

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

Works with: as version Raspberry Pi
or android 32 bits with application Termux
/* 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

i: new 1
while ø [
    if 1000 < (i^2)-(dec i)^2
        -> break
    inc 'i
]
print i
Output:
501

Asymptote

int fpow(int n) {
  int i = 0;
  while (i^2 - (i-1)^2 < n) ++i;
  return i;
}

write(fpow(1000));

AutoHotkey

while ((n:=A_Index)**2 - (n-1)**2 < 1000)
    continue
MsgBox % result := n
Output:
501

AWK

# 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

BASIC256

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

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

FUNCTION fpow (n)
    WHILE (i * i) - ((i - 1) * (i - 1)) < n
        i = i + 1
    WEND
    fpow = i
END FUNCTION

PRINT fpow(1001)

Run BASIC

function fpow(n)
    while i^2-(i-1)^2 < n
        i = i+1
    wend
    fpow = i
end function
 
print fpow(1001)

SmallBASIC

While n^2 - (n-1)^2 < 1000 do n++
print n

True BASIC

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

    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

sub fpow(n)
    while i^2 - (i-1)^2 < n
        i = i + 1
    wend
    Return i
end sub

print fpow(1001)
end


bc

(1000 + 1) / 2 + 1
Output:
501

C

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

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

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

1000 1+2/1+p
Output:
501


Delphi

Works with: Delphi version 6.0
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

repeat
   i += 1
   a = i * i
   b = (i - 1) * (i - 1)
   until a - b > 1000
.
print i

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))
Output:
501

F#

let n=1000 in printfn $"%d{((n+1)/2)+1}"
Output:
501


Factor

The difference between squares is the odd numbers, so ls(n)=⌈n/2+1⌉.

Works with: Factor version 0.99 2021-06-02
USING: math math.functions prettyprint ;

: least-sq ( m -- n ) 2 / 1 + ceiling ;

1000 least-sq .
Output:
501

Fermat

Func F(n) =
    i:=0;
    while i^2-(i-1)^2<n do i:=i+1 od; i.;

!!F(1000);
Output:
501

Forth

Works with: gforth version 0.7.3
Translation of: Quackery
: square dup * ;
: square-diff
  0 begin 1+
  dup square over 1- square -
  1000 > until . ;

square-diff
Output:
501  ok


FreeBASIC

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

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

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

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

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

1000 succ 2 / succ.
Output:
501

jq

Works with: jq

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

julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)
501

OCaml

let calculate x =
  succ (succ x lsr 1)

let () =
  Printf.printf "%u\n" (calculate 1000)
Output:
501

Pari/GP

F(n)=i=0;while(i^2-(i-1)^2<n,i=i+1);return(i);
print(F(1000))
Output:
501

Pencil and Paper

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

#!/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

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

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

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

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

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

  [ dup * ] is squared ( n --> n )
  
  0 
  [ 1+
    dup squared 
    over 1 - squared - 
    1000 > until ]
  echo
Output:
501

Using algebra

Noting that a²-b² ≡ (a+b)(a-b), and that in this instance a = b+1.

  1000 2 / 1+ echo
Output:
501

Raku

say first { $_² - ($_-1)² > 1000 }, ^Inf;
Output:
501

Ring

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

≪ 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

≪ 'n^2-(n-1)^2-1000'
   EXPAN COLCT 'n' ISOL CEIL
≫ EVAL

which returns the same result in only 9.2 seconds.

Ruby

p (1..).detect{|n| n*n - (n-1)*(n-1) > 1000 }
Output:
501

Sidef

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

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

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

n^2 - (n - 1)^2 > 1000
n^2 - (n^2 - 2n + 1) > 1000
2n - 1 > 1000
2n > 1001
n > 500.5
n = 501

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;
       }
    }
}
Output:
Result= 501