Heronian triangles: Difference between revisions

{{trans|Python}}

 

L v != 0

(u, v) = (v, u % v)

print(h[0.<10].map3((x, y, z) -> ‘ #14 perim: #3 area: #.’.format(String((x, y, z)), x + y + z, hero(x, y, z))).join("\n"))

print("\nAll with area 210 subject to the previous ordering:")

 

{{out}}

 

=={{header|Ada}}==

with Ada.Finalization;

with Ada.Text_IO; use Ada.Text_IO;

end loop;

end;

{{out}}

<pre> 517 heronian triangles found :

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

{{Trans|Lua}}

MODE HERONIAN = STRUCT( INT a, b, c, area, perimeter );

# returns the details of the Heronian Triangle with sides a, b, c or nil if it isn't one #

OD

END

{{out}}

<pre>

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

{{Trans|Lua}}

% record to hold details of a Heronian triangle %

record Heronian ( integer a, b, c, area, perimeter );

end

end

{{out}}

<pre>

 

{{Trans|JavaScript}}

 

-- HERONIAN TRIANGLES --------------------------------------------------------

((ca's NSString's stringWithString:(str))'s ¬

capitalizedStringWithLocale:(ca's NSLocale's currentLocale())) as text

{{Out}}

<pre>Number of triangles found (with sides <= 200): 517

(7, 65, 68) 140 210

(3, 148, 149) 300 210</pre>

 

=={{header|AutoHotkey}}==

obj :=[]

loop, % MaxSide {

x := StrSplit(x, "`t"), y := StrSplit(y, "`t")

return x.1 > y.1 ? 1 : x.1 < y.1 ? -1 : x.2 > y.2 ? 1 : x.2 < y.2 ? -1 : 0

loop, parse, res, `n, `r

{

. "`nResults for Area = 210:"

. "`n" "Area`tPerimeter`tSides`n" res3

Outputs:<pre>517 results found

 

----

'''IMPORTANT''': This is a C99 compatible implementation. May result in errors on earlier compilers.

#include<stdlib.h>

#include<stdio.h>

return 0;

}

Invocation and output :

<pre>

 

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

using System.Collections.Generic;

 

}

}

{{out}}

<pre>Number of primitive Heronian triangles with sides up to 200: 517

 

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

#include <iostream>

 

}

};

 

 

std::vector<Triangle> result;

for(int a = 1; a <= side_limit; ++a)

for(int b = 1; b <= a; ++b)

{

result.push_back(t);

}

}

 

}

 

};

 

auto tri = generate_triangles();

std::cout << "There are " << tri.size() << " primitive Heronian triangles with sides up to 200\n\n";

std::cout << "area\tperimeter\tsides\n";

for(int i = 0; i < 10; ++i)

tri[i].a << 'x' << tri[i].b << 'x' << tri[i].c << '\n';

 

std::cout << "area\tperimeter\tsides\n";

for(auto it = range.first; it != range.second; ++it)

it->a << 'x' << it->b << 'x' << it->c << '\n';

{{out}}

<pre>There are 517 primitive Heronian triangles with sides up to 200

=={{header|CoffeeScript}}==

{{trans|JavaScript}}

s = (a + b + c) / 2

Math.sqrt s * (s - a) * (s - b) * (s - c)

for i in list

if i[4] == 210

{{out}}

<pre>primitive Heronian triangles with sides up to 200: 517

=={{header|D}}==

{{trans|Python}}

 

double hero(in uint a, in uint b, in uint c) pure nothrow @safe @nogc {

"\nAll with area 210 subject to the previous ordering:".writeln;

showTriangles(h.filter!(t => t[].hero == 210));

{{out}}

<pre>Primitive Heronian triangles with sides up to 200: 517

210 140 7x65x68

210 300 3x148x149</pre>

 

=={{header|EchoLisp}}==

;; returns quintuple (A s a b c)

;; or #f if not hero

(define (print-laurels H)

(writeln '🌿🌿 (length H) 'heroes '🌿🌿))

{{out}}

<pre>(define H (heroes))

 

=={{header|Elixir}}==

def triangle?(a,b,c) when a+b <= c, do: false

def triangle?(a,b,c) do

|> Enum.each(fn {a, b, c} ->

IO.puts "#{a}\t#{b}\t#{c}\t#{a+b+c}\t#{area_size}"

 

{{out}}

 

=={{header|ERRE}}==

PROGRAM HERON

 

END FOR

END PROGRAM

<pre>Number of triangles: 517

3 4 5 12 6

 

=={{header|Factor}}==

combinators.short-circuit formatting io kernel locals math

math.functions math.order math.parser math.ranges mirrors qw

[ first10 nl ] [ area210= ] bi ;

{{out}}

<pre>

=={{header|Fortran}}==

Earlier Fortran doesn't offer special functions such as SUM, PRODUCT and MAXVAL of arrays, nor the ability to create compound data aggregates such as STASH to store a triangle's details. Simple code would have to be used in the absence of such conveniences, and multiple ordinary arrays rather than an array of a compound data entity. Rather than attempt to create the candidate triangles in the desired order, the simple approach is to sort a list of triangles, and using an XNDX array evades tossing compound items about. Rather than create a procedure to do the sorting, a comb sort is not too much trouble to place in-line once. Further, since the ordering is based on a compound key, having only one comparison to code is a boon. The three-way-if statement is central to the expedient evaluation of a compound sort key, but this facility is deprecated by the modernists, with no alternative offered that avoids re-comparison of parts.

MODULE GREEK MATHEMATICIANS !Two millenia back and more.

CONTAINS

END DO !Just thump through the lot.

END

 

{{out}}

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre>There are 517 Heronian triangles with sides <= 200

 

=={{header|FutureBasic}}==

 

local fn gcd( a as long, b as long )

end fn = result

 

 

local fn CalculateHeronianTriangles( numberToCheck as long ) as long

for a = 1 to b

next

end fn = count

 

print "---------------------------------------------"

print "Side A", "Side B", "Side C", "Perimeter", "Area"

 

dim as Boolean flips : flips = _true

while ( flips = _true )

flips = _true

wend

// Find first 10 heronian triangles

for i = 1 to 10

next

print

// Search for triangle with area of 210

for i = 1 to count

next

 

Output:

 

=={{header|Go}}==

 

import (

}

}

{{out}}

<pre>Number of primitive Heronian triangles with sides up to 200: 517

 

=={{header|Haskell}}==

import Data.Maybe

import Data.Ord

mapM_ printTri $ take 10 tris

putStrLn ""

{{out}}

<pre>Heronian triangles found: 517

'''Hero's formula Implementation'''

 

b=: 1&{"1

c=: 2&{"1

area=: 2 %: s*(s-a)*(s-b)*(s-c) NB. Hero's formula

perim=: +/"1

 

We exclude triangles with zero area, triangles with complex area, non-integer area, and triangles whose sides share a common integer multiple.

The implementation above uses the symbols as given in the formula at the top of the page, making it easier to follow along as well as spot any errors. That formula distinguishes between the individual sides of the triangles but J could easily treat these sides as a single entity or array. The implementation below uses this "typical J" approach:

 

s=: -:@:perim

area=: [: %: s * [: */"1 s - ] NB. Hero's formula

isNonZeroInt=: 0&~: *. (= <.@:+)

 

'''Required examples'''

 

HeroTri=: (#~ isPrimHero) Tri NB. all primitive Heronian triangles with sides <= 200

 

17 28 39 _ 84 210

7 65 68 _ 140 210

 

=={{header|Java}}==

 

public class Heron {

}

}

{{out}}

<pre>Number of primitive Heronian triangles with sides up to 200: 517

===Imperative===

 

window.onload = function(){

var list = [];

}

}

{{out}}

<pre>Primitive Heronian triangles with sides up to 200: 517

ES6 JavaScript introduces syntactic sugar for list comprehensions, but the list monad pattern can already be used in ES5 – indeed in any language which supports the use of higher-order functions.

 

var chain = function (xs, f) { // Monadic bind/chain

) + '\n\n';

 

{{out}}

=={{header|jq}}==

{{works with|jq|1.4}}

def hero:

(add/2) as $s

( .[] | select( hero == 210 ) | "\(rjust(11)) \(add|rjust(3)) \(hero|rjust(4))" ) ;

 

{{out}}

The number of primitive Heronian triangles with sides up to 200: 517

The first ten when ordered by increasing area, then perimeter, then maximum sides:

[17,28,39] 84 210

[7,65,68] 140 210

 

=={{header|Julia}}==

 

'''Types and Functions'''

type IntegerTriangle{T<:Integer}

a::T

σ^2 == t

end

 

'''Main'''

slim = 200

 

println(@sprintf "%6d %3d %3d %4d %4d" t.a t.b t.c t.σ t.p)

end

 

{{out}}

=={{header|Kotlin}}==

{{trans|Scala}}

 

object Heron {

}

 

{{out}}

<pre>Number of primitive Heronian triangles with sides up to 200: 517

7 x 65 x 68 140 210

3 x 148 x 149 300 210</pre>

 

=={{header|Lua}}==

local function tryHt( a, b, c )

local result

local t = ht[ htPos ];

if t.area == 210 then htPrint( t ) end

{{out}}

<pre>

3 148 149 210 300

</pre>

 

=={{header|Nim}}==

 

type HeronianTriangle = tuple[a, b, c: int; p: int; area: int]

 

fmt"{t.a:3d}, {t.b:3d}, {t.c:3d} {t.p:7d} {t.area:8d}"

 

func hero(a, b, c: int): float =

let s = (a + b + c) / 2

result = sqrt(s * (s - a) * (s - b) * (s - c))

 

func isHeronianTriangle(x: float): bool = x > 0 and ceil(x) == x

 

const Header = " Sides Perimeter Area\n------------- --------- ----"

for a in 1..b:

let area = hero(a, b, c)

let t: HeronianTriangle = (a, b, c, a + b + c, area.toInt)

 

echo "Number of Heronian triangles: ", list.len

 

echo "\nOrdered list of first ten Heronian triangles:"

echo Header

for t in list.filterIt(it.area == 210): echo t

{{out}}

<pre>Number of Heronian triangles: 517

=={{header|ooRexx}}==

Derived from REXX with some changes

Call time 'R'

Numeric Digits 12

::requires rxmath library

::routine sqrt

{{out}}

<pre>517 primitive Heronian triangles found with side length up to 200 (inclusive).

=={{header|PARI/GP}}==

 

is(a,b,c)=(a+b+c)%2==0 && gcd(a,gcd(b,c))==1 && issquare(Heron([a,b,c]))

v=List(); for(a=1,200,for(b=a+1,200,for(c=b+1,200, if(is(a,b,c),listput(v, [a,b,c])))));

vecsort(u, (a,b)->Heron(a)-Heron(b))

vecsort(u, (a,b)->vecsum(a)-vecsum(b))

{{out}}

<pre>%1 = [[1, 2, 3], [1, 3, 4], [1, 4, 5], [1, 5, 6], [1, 6, 7], [1, 7, 8], [1, 8, 9], [1, 9, 10], [1, 10, 11], [1, 11, 12]]

=={{header|Pascal}}==

{{Trans|Lua}}

type

(* record to hold details of a Heronian triangle *)

if t^.area = 210 then htPrint( t )

end

{{out}}

<pre>

=={{header|Perl}}==

{{trans|Raku}}

use warnings;

use List::Util qw(max);

}

 

{{out}}

<pre>Primitive Heronian triangles with sides up to 200: 517

 

=={{header|Phix}}==

{{out}}

<pre>

 

=={{header|PowerShell}}==

function Get-Gcd($a, $b){

if($a -ge $b){

}

}

{{out}}

Primitive Heronian triangles with sides up to 200: 517

 

7 65 68 140 210

3 148 149 300 210

 

=={{header|Python}}==

 

from math import gcd, sqrt

 

% (sides, sum(sides), hero(*sides)) for sides in h

if hero(*sides) == 210))

{{out}}

<pre>Primitive Heronian triangles with sides up to 200: 517

Mostly adopted from Python implementation:

 

area <- function(a, b, c) {

s = (a + b + c) / 2

cat("Showing the first ten ordered first by perimeter, then by area:\n")

print(head(r[order(x=r[,"perimeter"],y=r[,"area"]),],n=10))

 

{{out}}

 

Showing the first ten ordered first by perimeter, then by area:

a b c perimeter area

[8,] 8 15 17 40 60

[9,] 7 15 20 42 42

 

=={{header|Racket}}==

 

(require data/order scribble/html)

 

@; Show a similar ordered table for those triangles with area = 210

@(triangles->table (tri-sort (filter (λ(t) (eq? 210 (car t))) ts)))

 

This program generates HTML, so the output is inline with the page, not in a <code>&lt;pre></code> block.

(formerly Perl 6)

{{works with|Rakudo|2018.09}}

my $s = ($a + $b + $c) / 2;

($s * ($s - $a) * ($s - $b) * ($s - $c)).sqrt;

say "\nArea $witharea:";

show @h.grep: *[0] == $witharea;

{{out}}

<pre>Primitive Heronian triangles with sides up to 200: 517

This REXX version doesn't need to explicitly sort the triangles as they are listed in the proper order.

parse arg N first area . /*obtain optional arguments from the CL*/

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

end /*k*/

end /*j*/ /* [↑] use the known perimeters. */

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

<pre>

 

It is about eight times faster than the 1^st REXX version.

parse arg N first area . /*obtain optional arguments from the CL*/

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

end /*k*/

end /*j*/ /* [↑] use the known perimeters. */

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

 

=={{header|Ring}}==

# Project : Heronian triangles

 

end

return gcd

Output:

<pre>

{17, 28, 39} 84 210

{20, 21, 29} 70 210

</pre>

 

=={{header|Ruby}}==

def self.valid?(a,b,c) # class method

short, middle, long = [a, b, c].sort

puts sorted.first(10).map(&:to_s)

puts "\nTriangles with an area of: #{area}"

{{out}}

<pre>

7x65x68 140 210.0

3x148x149 300 210.0

</pre>

 

=={{header|Scala}}==

private final val n = 200

for (c <- 1 to n; b <- 1 to c; a <- 1 to b if gcd(gcd(a, b), c) == 1) {

private final val header = "\nSides Perimeter Area"

private def format: Seq[Int] => String = "\n%3d x %3d x %3d %5d %10d".format

 

=={{header|Sidef}}==

{{trans|Ruby}}

 

has (sides, perimeter, area)

say sorted.first(10).join("\n")

say "\nTriangles with an area of: #{area}"

{{out}}

<pre>

=={{header|Smalltalk}}==

Works with Squeak 5.x

 

squaredArea := [:triangle |

area210 do: tabulate.

 

{{out}}

<pre>

 

=={{header|SPL}}==

#.sort(h,4,5,1,2,3)

#.output("There are ",t," Heronian triangles")

s = (a+b+c)/2

<= (s*(s-a)*(s-b)*(s-c))^0.5, s*2

{{out}}

<pre>

=={{header|Swift}}==

Works with Swift 1.2

 

typealias PrimitiveHeronianTriangle = (s1:Int, s2:Int, s3:Int, p:Int, a:Int)

for t in triangles[0...9] {

println("\(t.s1)\t\(t.s2)\t\(t.s3)\t\t\(t.p)\t\t\(t.a)")

 

{{out}}

 

=={{header|Tcl}}==

if {[info commands let] eq ""} {

 

sqlite3 db :memory:

main db

{{out}}

<pre>

 

=={{header|VBA}}==

s = (a + b + c) / 2

On Error GoTo Err

End If

Next i

<pre>Primitive Heronian triangles with sides up to 200: 517 (of 1353400 tested)

 

{{libheader|Wren-sort}}

{{libheader|Wren-fmt}}

 

var isInteger = Fn.new { |n| n is Num && n.isInteger }

var sides = Fmt.swrite("$2d x $3d x $3d", t[0][0], t[0][1], t[0][2])

Fmt.print("$-14s $3d $3d $3d", sides, t[1], t[2], t[3])

 

{{out}}

7 x 65 x 68 210 140 68

3 x 148 x 149 210 300 149

</pre>

 

=={{header|zkl}}==

{{trans|Python}}

s,a2:=(a + b + c).toFloat()/2, s*(s - a)*(s - b)*(s - c);

(a2 > 0) and a2.sqrt() or 0.0

A:=hero(a,b,c);

(A>0) and A.modf()[1].closeTo(0.0,1.0e-6) and A //--> area or False

heros:=Sink(List);

foreach a,b,c in ([1..MAX_SIDE],[a..MAX_SIDE],[b..MAX_SIDE]){

println("Area Perimeter Sides");

heros.filter(fcn([(h,_)]){ h==210 })

{{out}}

<pre>