Pythagorean quadruples: Difference between revisions

{{trans|Python}}

 

V r = [0B] * top

V ab = [0B] * (top * 2)^2

R enumerate(r).filter((i, val) -> !val & i).map((i, val) -> i)

 

 

{{out}}

=={{header|ALGOL 68}}==

As with the optimised REXX solution, we find the values of d for which there are no a^2 + b^2 = d^2 - c^2.

# find values of d where d^2 =/= a^2 + b^2 + c^2 for any integers a, b, c #

# where d in [1..2200], a, b, c =/= 0 #

OD;

print( ( newline ) )

{{out}}

<pre>

1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

</pre>

 

=={{header|AppleScript}}==

on double(x)

x + x

end if

end if

{{Out}}

<pre>{1, 2, 4, 5, 8, 10, 16, 20, 32, 40, 64, 80, 128, 160, 256, 320, 512, 640, 1024, 1280, 2048}</pre>

 

=={{header|AWK}}==

# syntax: GAWK -f PYTHAGOREAN_QUADRUPLES.AWK

# converted from Go

exit(0)

}

{{out}}

<pre>

===Version 1===

Five seconds on my Intel Linux box.

#include <math.h>

#include <string.h>

if(!r[a]) printf("%d ",a); // print non solution

printf("\n");

{{out}}

<pre>

===Version 2 (much faster)===

Translation of second version of FreeBASIC entry. Runs in about 0.15 seconds.

#include <stdio.h>

#include <string.h>

free(ab);

return 0;

{{out}}

<pre>

=={{header|C sharp|C#}}==

{{trans|Java}}

 

namespace PythagoreanQuadruples {

}

}

{{out}}

<pre>The values of d <= 2200 which can't be represented:

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

{{trans|D}}

#include <vector>

 

 

return 0;

{{out}}

<pre>The values of d <= 2200 which can't be represented:

=={{header|Crystal}}==

{{trans|Ruby}}

l_add, l = Hash(Int32, Bool).new(false), Hash(Int32, Bool).new(false)

(1..n).each do |x|

end

 

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

</pre>

 

=={{header|D}}==

{{trans|C}}

import std.stdio;

 

}

writeln;

 

{{out}}

<pre>The values of d <= 2200 which can't be represented:

1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048</pre>

 

=={{header|FreeBASIC}}==

===From the Wikipedia page===

[https://en.wikipedia.org/wiki/Pythagorean_quadruple Alternate parametrization, second version both A and B even.]Time just less then 0.7 second on a AMD Athlon II X4 645 3.34GHz win7 64bit. Program uses one core. When the limit is set to 576 (abs. minimum for 2200), the time is about 0.85 sec.

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048</pre>

===Brute force===

Based on the second REXX version: A^2 + B^2 = D^2 - C^2. Faster then the first version, about 0.2 second

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048</pre>

 

=={{header|Go}}==

{{trans|FreeBASIC}}

 

import "fmt"

}

fmt.Println()

 

{{out}}

 

=={{header|Haskell}}==

powersOfTwo = iterate (2 *) 1

 

main = do

putStrLn "The values of d <= 2200 which can't be represented."

{{out}}

<pre>The values of d <= 2200 which can't be represented.

=={{header|J}}==

Approach: generate the set of all triple sums of squares, then select the legs for which there aren't any squared "d"s. The solution is straightforward interactive play.

 

Filter =: (#~`)(`:6)

1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

 

 

=={{header|Java}}==

 

Compute sequence directly.

import java.util.ArrayList;

import java.util.List;

 

}

 

{{out}}

=={{header|JavaScript}}==

{{Trans|Haskell}}

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>[1,2,4,5,8,10,16,20,32,40,64,80,128,160,256,320,512,640,1024,1280,2048]</pre>

be accomplished in jq without `foreach`. Notice also how

`first/1` is used in `is_pythagorean_quad/0` to avoid unnecessary computation.

def is_pythagorean_quad:

. as $d

# The specific task:

 

 

'''Invocation and Output'''

{{trans|C}}

 

r = falses(N)

ab = falses(2N ^ 2)

end

 

 

{{out}}

===Version 1 ===

This uses a similar approach to the REXX optimized version. It also takes advantage of a hint in the C entry that there is no solution if both a and b are odd (confirmed by Wikipedia article). Runs in about 7 seconds on my modest laptop which is more than 4 times faster than the brute force version would have been:

 

const val MAX = 2200

for (i in 1..MAX) if (!found[i]) print("$i ")

println()

 

{{out}}

 

One thing I've noticed about the resulting sequence is that it appears to be an interleaving of the two series 2 ^ n and 5 * (2 ^ n) for n >= 0 though whether it's possible to prove this mathematically I don't know.

 

const val MAX = 2200

for (d in 1..MAX) if (!found[d]) print("$d ")

println()

 

{{out}}

 

=={{header|Lua}}==

local N = 2200

local ar = {}

end

end

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048</pre>

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

maxsq = max^2;

d = Range[max]^2;

{a, Floor[maxsq^(1/2)]}

]

{{out}}

<pre>{1, 2, 4, 5, 8, 10, 16, 20, 32, 40, 64, 80, 128, 160, 256, 320, 512, 640, 1024, 1280, 2048}</pre>

=={{header|Modula-2}}==

{{trans|C}}

FROM FormatString IMPORT FormatString;

FROM RealMath IMPORT sqrt;

 

ReadChar

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048 </pre>

 

===Version 1===

 

const N = 2_200

for i in 1..N:

if not r[I]: stdout.write i, " "

 

{{out}}

 

===Version 2===

const N2 = N * N * 2

 

 

for d in 1..N:

 

{{out}}

Brute froce, but not as brute as [http://rosettacode.org/mw/index.php?title=Pythagorean_quadruples#Ring Ring].Did it ever run?<BR>

Stopping search if limit is reached<BR>

//find phythagorean Quadrupel up to a,b,c,d <= 2200

//a^2 + b^2 +c^2 = d^2

writeln(CheckCnt,' checks were done');

end.

{{out}}

<pre>

a^2 + b^2 is like moving/jumping a rake with tines at a^2 from tine(1) to tine(MaxFactor) and mark their positions<BR>

Quite fast.

//find phythagorean Quadrupel up to a,b,c,d <= 2200

//a^2 + b^2 +c^2 = d^2

writeln;

end.

{{Out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

push @sq, $_**2 for 0 .. $N;

my @not = (0) x $N;

$result .= "$_ " unless $not[$_]

}

{{out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048</pre>

 

=={{header|Phix}}==

{{out}}

<pre>

=={{header|PicoLisp}}==

{{trans|C}}

(let (AB NIL S 3 R)

(for A N

(or (idx 'R A) (link A)) ) ) ) )

 

 

{{out}}

<pre>(1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048)</pre>

 

=={{header|Python}}==

===Search===

{{trans|Julia}}

r = [False] * top

ab = [False] * (top * 2)**2

if __name__ == '__main__':

n = 2200

 

{{out}}

{{Trans|JavaScript}}

{{Trans|AppleScript}}

 

from itertools import islice, takewhile

# MAIN ---

if __name__ == '__main__':

{{Out}}

<pre>[1, 2, 4, 5, 8, 10, 16, 20, 32, 40, 64, 80, 128, 160, 256, 320, 512, 640, 1024, 1280, 2048]</pre>

 

=={{header|Racket}}==

{{trans|Python}}

 

 

(require data/bit-vector)

(printf "Those values of d in 1..~a that can't be represented: ~a~%" n (quadruples n)))

 

 

{{out}}

{{works with|Rakudo|2018.09}}

 

my @sq = (0 .. N)»²;

my @not = False xx N;

}

 

{{out}}

<pre>(1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048)</pre>

This version is a brute force algorithm, with some optimization (to save compute time)

<br>which pre-computes some of the squares of the positive integers used in the search.

parse arg hi . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi=2200; high= 3 * hi /*Not specified? Then use the default.*/

do p=1 for hi; if d.p==. then $=$ p /*Not possible? Then add it to the list*/

end /*p*/ /* [↓] display list of not-possibles. */

{{out|output|text=&nbsp; when using the default input:}}

<pre>

Programming note: &nbsp; testing for &nbsp; '''a''' &nbsp; and &nbsp; '''b''' &nbsp; both being &nbsp; <big>odd</big> &nbsp; (lines '''15''' and '''16''' &nbsp; that each contain a &nbsp; '''do''' &nbsp; loop) &nbsp; as

<br>being a case that won't produce any solutions actually slows up the calculations and makes the program execute slower.

parse arg hi . /*obtain optional argument from the CL.*/

if hi=='' | hi=="," then hi=2200 /*Not specified? Then use the default.*/

do p=1 for hi; if d.p==. then $= $ p /*Not possible? Then add it to the list*/

end /*p*/ /* [↓] display list of not-possibles. */

{{out|output|text=&nbsp; is the same as the 1^st REXX version.}} <br><br>

 

=={{header|Ring}}==

 

limit = 2200

next

see pqstr + nl

{{Out}}

1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

=={{header|Ruby}}==

{{trans|VBA}}

l_add, l = {}, {}

1.step(n) do |x|

 

puts (1..n).reject{|x| l[x]}.join(" ")

{{Out}}

<pre>1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

</pre>

Considering the observations in the Rust and Sidef sections and toying with Enumerators :

squares5 = Enumerator.new{|y| (0..).each{|n| y << 2**n*5} }

 

end

# this takes less than a millisecond

{{Out}}

<pre>

which simply contains positive integers of the form 2^n or 5*2^n. Multiple implementations are provided.

 

use std::collections::BinaryHeap;

 

}

}

 

=={{header|Scala}}==

{{Out}}Best seen running in your browser either by [https://scalafiddle.io/sf/drfij1d/0 ScalaFiddle (ES aka JavaScript, non JVM)] or [https://scastie.scala-lang.org/6AHn7YXSRbKHzmOY5rWAwg Scastie (remote JVM)].

val MAX = 2200

val MAX2: Int = MAX * MAX * 2

println(notRepresented.mkString(" "))

 

 

=={{header|Sidef}}==

func sum_of_two_squares(n) is cached {

 

sum_of_three_squares(n) || take(n)

}

{{out}}

<pre>

 

Numbers d that cannot be expressed as a^2 + b^2 + c^2 = d^2, are numbers of the form 2^n or 5*2^n:

for n in (1..2200) {

if ((n & (n-1) == 0) || (n%%5 && ((n/5) & (n/5 - 1) == 0))) {

}

}

{{out}}

<pre>

=={{header|Swift}}==

{{trans|C}}

var a2 = 0, s = 3, s1 = 0, s2 = 0

var res = [Int](repeating: 0, count: n + 1)

}

 

 

{{out}}

=={{header|VBA}}==

{{trans|FreeBasic}}

Public Sub pq()

Dim s As Long, s1 As Long, s2 As Long, x As Long, x2 As Long, y As Long: s = 3

Next

Debug.Print

<pre> 1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048 </pre>

 

=={{header|Wren}}==

{{trans|FreeBASIC}}

var N2 = N * N * 2

var s = 3

if (!r[d]) System.write("%(d) ")

}

 

{{out}}

1 2 4 5 8 10 16 20 32 40 64 80 128 160 256 320 512 640 1024 1280 2048

</pre>

 

=={{header|zkl}}==

{{trans|ALGOL 68}}

# where d in [1..2200], a, b, c =/= 0 #

# max number to check #

if(not solution[ d ]) print(d, " ");

}

{{out}}

<pre>