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)

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

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.

## ALGOL 68

Using the same school maths ( or math for those in the US ) in the Wren version but using a calculation.
Also showng the least positive integer where the difference between n^2 and (n-1)^2 is greater than 32 000 and 2 000 000 000 - using only 32 bit integers.

`BEGIN # find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 #    INT required diff =         1 000;    INT medium diff   =        32 000;    INT larger diff   = 2 000 000 000;    # return s space-separated into groups of 3 digits #    PROC space separate = ( STRING unformatted )STRING:         BEGIN            STRING result      := "";            INT    ch count    := 0;            FOR c FROM UPB unformatted BY -1 TO LWB unformatted DO                IF   ch count <= 2 THEN ch count +:= 1                ELSE                    ch count  := 1; " " +=: result                FI;                unformatted[ c ] +=: result            OD;            result         END # space separate # ;    # n^2 - ( n - 1 )^2 is n^2 - n^2 + 2n - 1, i.e. 2n - 1 #    # so 2n - 1 > 1000 or n > 1001/2 #    print( ( "Smallest n where n^2 - (n-1)^2 is > ", space separate( whole( required diff, -12 ) ), ": "           , space separate( whole( ( ( required diff + 1 ) OVER 2 ) + 1, -12 ) )           , newline           )         );    print( ( "Smallest n where n^2 - (n-1)^2 is > ", space separate( whole( medium diff, -12 ) ), ": "           , space separate( whole( ( ( medium diff + 1 ) OVER 2 ) + 1, -12 ) )           , newline           )         );    print( ( "Smallest n where n^2 - (n-1)^2 is > ", space separate( whole( larger diff, -12 ) ), ": "           , space separate( whole( ( ( larger diff + 1 ) OVER 2 ) + 1, -12 ) )           , newline           )         )END`
Output:
```Smallest n where n^2 - (n-1)^2 is >           1 000:             501
Smallest n where n^2 - (n-1)^2 is >          32 000:          16 001
Smallest n where n^2 - (n-1)^2 is >   2 000 000 000:   1 000 000 001
```

## AWK

` # syntax: GAWK -f FIND_SQUARE_DIFFERENCE.AWKBEGIN {    n = 1001    while (i^2-(i-1)^2 < n) {      i++    }    printf("%d\n",i)    exit(0)} `
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`

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

## FreeBASIC

`function fpow(n as uinteger) as uinteger    dim as uinteger i    while i^2-(i-1)^2 < n        i+=1    wend    return iend function print fpow(1001)`
Output:
`501`

## Julia

`julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)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_squareuse warnings; my \$n = 1;\$n++ until \$n ** 2 - (\$n-1) ** 2 > 1000;print "\$n\n";`
Output:
```501
```

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

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

## Python

` import mathprint("working...")limit1 = 6000limit2 = 1000oldSquare = 0newSquare = 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...
```

## Raku

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

## Ring

` load "stdlib.ring"see "working..." + nllimit1 = 6000limit2 = 1000oldPrime = 0newPrime = 0 for n = 1 to limit1    newPrime = n*n    if newPrime - oldPrime > limit2       see "Latest number is = " + sqrt(newPrime) + nl       exit    ok    oldPrime = n*nnext see "done..." + nl `
Output:
```working...
Latest number is = 501
done...
```

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