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

 

=={{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++}}==

{{Works with|C++11}}

#include <cmath>

#include <iostream>

std::cout << area(*it) << '\t' << perimeter(*it) << "\t\t" <<

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

 

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

include "ConsoleWindow"

 

end if

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

 

=={{header|Lua}}==

local function tryHt( a, b, c )

local result

local t = ht[ htPos ];

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

{{out}}

<pre>

 

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

Heron[a_, b_, c_] := With[{s = (a + b + c)/2}, Sqrt[s (s - a) (s - b) (s - c)]]

PrintTemporary[Dynamic[{a, b, c}]];

results // Length

Take[results, 10] // Dataset

{{out}}

<pre>517

 

=={{header|Nim}}==

 

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

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}}==

<span style="color: #008080;">function</span> <span style="color: #000000;">heroArea</span><span style="color: #0000FF;">(</span><span style="color: #004080;">integer</span> <span style="color: #000000;">a</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">b</span><span style="color: #0000FF;">,</span> <span style="color: #000000;">c</span><span style="color: #0000FF;">)</span>

<span style="color: #004080;">atom</span> <span style="color: #000000;">s</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">(</span><span style="color: #000000;">a</span><span style="color: #0000FF;">+</span><span style="color: #000000;">b</span><span style="color: #0000FF;">+</span><span style="color: #000000;">c</span><span style="color: #0000FF;">)/</span><span style="color: #000000;">2</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">if</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>

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

 

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

 

=={{header|Rust}}==

use num_integer::Integer;

use std::{f64, usize};

}

 

{{out}}

<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}}

import "/sort" for Sort

import "/fmt" for Fmt

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}}

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