Find square difference: Difference between revisions

Line 7:

=={{header|11l}}==

<~~lang~~ 11l>L(n) 1..

<syntaxhighlight lang="11l">L(n) 1..

I n^2 - (n - 1)^2 > 1000

print(n)

L.break</~~lang~~>

L.break</syntaxhighlight>

Line 18:

=={{header|Ada}}==

<~~lang~~ ~~Ada~~>with Ada.Text_IO; use Ada.Text_IO;

<syntaxhighlight lang="ada">with Ada.Text_IO; use Ada.Text_IO;

procedure Find_Square_Difference is

Line 34:

end if;

end loop;

end Find_Square_Difference;</~~lang~~>

end Find_Square_Difference;</syntaxhighlight>

<pre>

Line 42:

=={{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.

<~~lang~~ algol68>BEGIN # find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 #

<syntaxhighlight lang="algol68">BEGIN # find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 #

[]INT test = ( 1 000, 32 000, 2 000 000 000 );

FOR i FROM LWB test TO UPB test DO

Line 54:

)

OD

END</~~lang~~>

END</syntaxhighlight>

<pre>

Line 63:

=={{header|ALGOL W}}==

<~~lang~~ pascal>begin % find the lowest positive n where the difference between n^2 and (n-1)^2 is > 1000 %

<syntaxhighlight 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 70:

, " is: ", ( ( requiredDifference + 1 ) div 2 ) + 1

)

end.</~~lang~~>

end.</syntaxhighlight>

<pre>

Line 78:

=={{header|Arturo}}==

<~~lang~~ rebol>i: new 1

<syntaxhighlight lang="rebol">i: new 1

while ø [

if 1000 < (i^2)-(dec i)^2

Line 84:

inc 'i

]

print i</~~lang~~>

print i</syntaxhighlight>

Line 91:

=={{header|Asymptote}}==

<~~lang~~ ~~Asymptote~~>int fpow(int n) {

<syntaxhighlight lang="asymptote">int fpow(int n) {

int i = 0;

while (i^2 - (i-1)^2 < n) ++i;

Line 97:

}

write(fpow(1000));</~~lang~~>

write(fpow(1000));</syntaxhighlight>

=={{header|AutoHotkey}}==

<~~lang~~ ~~AutoHotkey~~>while ((n:=A_Index)**2 - (n-1)**2 < 1000)

<syntaxhighlight lang="autohotkey">while ((n:=A_Index)**2 - (n-1)**2 < 1000)

continue

MsgBox % result := n</~~lang~~>

MsgBox % result := n</syntaxhighlight>

=={{header|AWK}}==

# syntax: GAWK -f FIND_SQUARE_DIFFERENCE.AWK

BEGIN {

Line 117:

exit(0)

}

</syntaxhighlight>

</lang>

<pre>

Line 126:

=={{header|BASIC}}==

==={{header|BASIC256}}===

<~~lang~~ freebasic>function fpow(n)

<syntaxhighlight lang="freebasic">function fpow(n)

i = 0

while i^2 - (i-1)^2 < n

Line 135:

print fpow(1001)

end</~~lang~~>

end</syntaxhighlight>

==={{header|PureBasic}}===

<~~lang~~ ~~PureBasic~~>Procedure fpow(n.i)

<syntaxhighlight lang="purebasic">Procedure fpow(n.i)

Define i.i

While Pow(i, 2) - Pow((i-1), 2) < n

Line 149:

Print(Str(fpow(1001)))

Input()

CloseConsole()</~~lang~~>

CloseConsole()</syntaxhighlight>

==={{header|QBasic}}===

<~~lang~~ qbasic>FUNCTION fpow (n)

<syntaxhighlight lang="qbasic">FUNCTION fpow (n)

WHILE (i * i) - ((i - 1) * (i - 1)) < n

i = i + 1

Line 159:

END FUNCTION

PRINT fpow(1001)</~~lang~~>

PRINT fpow(1001)</syntaxhighlight>

==={{header|Run BASIC}}===

<~~lang~~ lb>function fpow(n)

<syntaxhighlight lang="lb">function fpow(n)

while i^2-(i-1)^2 < n

i = i+1

Line 169:

end function

print fpow(1001)</~~lang~~>

print fpow(1001)</syntaxhighlight>

==={{header|True BASIC}}===

<~~lang~~ qbasic>FUNCTION fpow (n)

<syntaxhighlight lang="qbasic">FUNCTION fpow (n)

DO WHILE i ^ 2 - (i - 1) ^ 2 < n

LET i = i + 1

Line 180:

PRINT fpow(1001)

END</~~lang~~>

END</syntaxhighlight>

==={{Header|Tiny BASIC}}===

<~~lang~~ qbasic> LET N = 1001

<syntaxhighlight lang="qbasic"> LET N = 1001

LET I = 0

Line 191:

GOTO 10

20 PRINT I

END</~~lang~~>

END</syntaxhighlight>

==={{header|Yabasic}}===

<~~lang~~ freebasic>sub fpow(n)

<syntaxhighlight lang="freebasic">sub fpow(n)

while i^2 - (i-1)^2 < n

i = i + 1

Line 202:

print fpow(1001)

end</~~lang~~>

end</syntaxhighlight>

=={{header|C}}==

<~~lang~~ c>#include<stdio.h>

<syntaxhighlight lang="c">#include<stdio.h>

#include<stdlib.h>

Line 218:

printf( "%d\n", f(1000) );

return 0;

}</~~lang~~>

}</syntaxhighlight>

Line 224:

=={{header|C++}}==

The C solution is also idomatic in C++. An alterate approach is to use Ranges from C++20.

<~~lang~~ cpp>#include <iostream>

<syntaxhighlight lang="cpp">#include <iostream>

#include <ranges>

Line 236:

std::cout << answer.front() << '\n';

}

</syntaxhighlight>

</lang>

<pre>

Line 243:

=={{header|Dart}}==

<~~lang~~ dart>import 'dart:math';

<syntaxhighlight lang="dart">import 'dart:math';

int leastSquare(int gap) {

Line 255:

void main() {

print(leastSquare(1000));

}</~~lang~~>

}</syntaxhighlight>

=={{header|F_Sharp|F#}}==

<~~lang~~ fsharp>

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

</syntaxhighlight>

</lang>

<pre>

Line 270:

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

<~~lang~~ factor>USING: math math.functions prettyprint ;

<syntaxhighlight lang="factor">USING: math math.functions prettyprint ;

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

1000 least-sq .</~~lang~~>

1000 least-sq .</syntaxhighlight>

<pre>

Line 281:

=={{header|Fermat}}==

<lang>Func F(n) =

<syntaxhighlight lang="text">Func F(n) =

i:=0;

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

!!F(1000);</~~lang~~>

!!F(1000);</syntaxhighlight>

{{out}}<pre>501</pre>

=={{header|FreeBASIC}}==

<~~lang~~ freebasic>function fpow(n as uinteger) as uinteger

<syntaxhighlight lang="freebasic">function fpow(n as uinteger) as uinteger

dim as uinteger i

while i^2-(i-1)^2 < n

Line 297:

end function

print fpow(1001)</~~lang~~>

print fpow(1001)</syntaxhighlight>

{{out}}<pre>501</pre>

=={{header|Go}}==

<~~lang~~ go>package main

<syntaxhighlight lang="go">package main

import (

Line 314:

func main() {

fmt.Println(squareDiff(1000))

}</~~lang~~>

}</syntaxhighlight>

Line 323:

=={{header|Haskell}}==

The sequence of differences between successive squares is the sequence of odd numbers.

<~~lang~~ haskell>import Data.List (findIndex)

<syntaxhighlight lang="haskell">import Data.List (findIndex)

f = succ . flip div 2

Line 333:

Just i = succ <$> findIndex (> n) [1, 3 ..]

main = mapM_ print $ [f, g] <*> [1000]</~~lang~~>

main = mapM_ print $ [f, g] <*> [1000]</syntaxhighlight>

<pre>501

Line 345:

At the risk of hastening RC's demise, one could offer a jq solution like so:

<~~lang~~ jq>first( range(1; infinite) | select( 2 * . - 1 > 1000 ) )</~~lang~~>

<syntaxhighlight lang="jq">first( range(1; infinite) | select( 2 * . - 1 > 1000 ) )</syntaxhighlight>

Or, for anyone envious of Bitcoin's contribution to global warming:

first( range(1; infinite) | select( .*. - ((.-1) | .*.) > 1000 ) )

</syntaxhighlight>

</lang>

<pre>

Line 356:

=={{header|Julia}}==

<~~lang~~ julia>julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)

<syntaxhighlight lang="julia">julia> findfirst(n -> n*n - (n-1)*(n-1) > 1000, 1:1_000_000)

501

</syntaxhighlight>

</lang>

=={{header|Pari/GP}}==

<~~lang~~ parigp>F(n)=i=0;while(i^2-(i-1)^2<n,i=i+1);return(i);

<syntaxhighlight lang="parigp">F(n)=i=0;while(i^2-(i-1)^2<n,i=i+1);return(i);

print(F(1000))</~~lang~~>

print(F(1000))</syntaxhighlight>

{{out}}<pre>501</pre>

Line 386:

=={{header|Perl}}==

<~~lang~~ perl>#!/usr/bin/perl

<syntaxhighlight lang="perl">#!/usr/bin/perl

use strict; # https://rosettacode.org/wiki/Least_square

Line 393:

my $n = 1;

$n++ until $n ** 2 - ($n-1) ** 2 > 1000;

print "$n\n";</~~lang~~>

print "$n\n";</syntaxhighlight>

<pre>

Line 401:

=={{header|Phix}}==

''Essentially Wren equivalent, but explained in excruciating detail especially for enyone that evidently needs elp, said Eeyore.''

with javascript_semantics

printf(1,"""

Line 412:

n = %d

""",ceil(500.5))

<pre>

Line 424:

</pre>

Or if you prefer, same output:

with javascript_semantics

string e -- equation

Line 441:

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

Line 457:

e = substitute_all(e,{"2*","1001"},{"","500.5"}) -- divide by 2

e = substitute(e,"> 500.5",sprintf("= %d",ceil(500.5))) -- solve

=={{header|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.

<~~lang~~ pli>100H: /* FIND THE LEAST +VE N WHERE N SQUARED - (N-1) SQUARED > 1000 */

<syntaxhighlight 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 497:

CALL PRINT$LEAST( 65000 );

EOF</~~lang~~>

EOF</syntaxhighlight>

<pre>

Line 506:

=={{header|Python}}==

<~~lang~~ python>

import math

print("working...")

Line 524:

print("done...")

print()

</syntaxhighlight>

</lang>

<pre>

Line 534:

=={{header|Quackery}}==

<~~lang~~ ~~Quackery~~> [ dup * ] is squared ( n --> n )

<syntaxhighlight lang="quackery"> [ dup * ] is squared ( n --> n )

0

Line 541:

over 1 - squared -

1000 > until ]

echo</~~lang~~>

echo</syntaxhighlight>

Line 551:

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

<~~lang~~ ~~Quackery~~> 1000 2 / 1+ echo</~~lang~~>

Line 558:

=={{header|Raku}}==

<lang ~~perl6~~>say first { $_² - ($_-1)² > 1000 }, ^Inf;</~~lang~~>

<syntaxhighlight lang="raku" line>say first { $_² - ($_-1)² > 1000 }, ^Inf;</syntaxhighlight>

=={{header|Ring}}==

<~~lang~~ ring>

load "stdlib.ring"

see "working..." + nl

Line 581:

see "done..." + nl

</syntaxhighlight>

</lang>

<pre>

Line 590:

=={{header|Sidef}}==

<~~lang~~ ruby>var N = 1000

<syntaxhighlight lang="ruby">var N = 1000

# Binary search

Line 603:

assert_eq(n, m)

say "#{n}^2 - #{n-1}^2 = #{n**2 - (n-1)**2}"</~~lang~~>

say "#{n}^2 - #{n-1}^2 = #{n**2 - (n-1)**2}"</syntaxhighlight>

<pre>

Line 610:

=={{header|Verilog}}==

<~~lang~~ ~~Verilog~~>module main;

<syntaxhighlight lang="verilog">module main;

integer i, n;

Line 620:

$finish ;

end

endmodule</~~lang~~>

endmodule</syntaxhighlight>

=={{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''.

<~~lang~~ ecmascript>var squareDiff = Fn.new { |k| ((k + 1) * 0.5).ceil }

<syntaxhighlight lang="ecmascript">var squareDiff = Fn.new { |k| ((k + 1) * 0.5).ceil }

System.print(squareDiff.call(1000))</~~lang~~>

System.print(squareDiff.call(1000))</syntaxhighlight>