Law of cosines - triples: Difference between revisions

{{trans|Python}}

 

 

F method1(n)

V t60 = method1(10'000)[1]

V notsame = sum(t60.filter((a, b, c) -> a != b | b != c).map((a, b, c) -> 1))

 

{{out}}

[(3, 5, 7), (7, 8, 13)]

Extra credit: 18394

</pre>

 

=={{header|Ada}}==

with Ada.Containers.Ordered_Maps;

 

Count_Triangles;

Extra_Credit (Limit => 10_000);

 

{{out}}

 

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

# find all integer sided 90, 60 and 120 degree triangles by finding integer solutions for #

# a^2 + b^2 = c^2, a^2 + b^2 - ab = c^2, a^2 + b^2 + ab = c^2 where a, b, c in 1 .. 13 #

print triangles( 90 );

print triangles( 120 )

{{out}}

<pre>

 

=={{header|AWK}}==

# syntax: GAWK -f LAW_OF_COSINES_-_TRIPLES.AWK

# converted from C

}

}

{{out}}

<pre>

=={{header|C}}==

=== A brute force algorithm, O(N^3) ===

* RossetaCode: Law of cosines - triples

*

return 0;

}

{{out}}

<pre>

 

=== An algorithm with O(N^2) cost ===

* RossetaCode: Law of cosines - triples

*

return 0;

}

{{output}}

<pre>

 

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

#include <iostream>

#include <tuple>

<< min << " to " << max2 << " where the sides are not all of the same length.\n";

return 0;

 

{{out}}

 

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

using System.Collections.Generic;

using static System.Linq.Enumerable;

 

private static bool NotAllTheSameLength((int a, int b, int c) triple) => triple.a != triple.b || triple.a != triple.c;

{{out}}

<pre>

60 degree triangles in range 1..10000 where not all sides are the same

18394 solutions</pre>

 

=={{header|Factor}}==

sequences sets sorting ;

IN: rosetta-code.law-of-cosines

[ * + ] 120

[ 2drop 0 - ] 90

{{out}}

<pre>

{ 13 13 13 }

}

</pre>

 

=={{header|FreeBASIC}}==

' compile with: fbc -s console

 

Print : Print "hit any key to end program"

Sleep

{{out}}

<pre> 15: 60 degree triangles

 

=={{header|Go}}==

 

import "fmt"

fmt.Print(" For an angle of 60 degrees")

fmt.Println(" there are", len(solutions), "solutions.")

 

{{out}}

 

=={{header|Haskell}}==

import qualified Data.Set as Set

import Data.Monoid ((<>))

[120, 90, 60])

putStrLn "60 degrees - uneven triangles of maximum side 10000. Total:"

{{Out}}

<pre>Triangles of maximum side 13

=={{header|J}}==

'''Solution:'''

RHS=: *: NB. right-hand-side of Cosine Law

LHS=: +/@:*:@] - cos@rfd@[ * 2 * */@] NB. Left-hand-side of Cosine Law

idx=. (RHS oppside) i. x LHS"1 adjsides

adjsides ((#~ idx ~: #) ,. ({~ idx -. #)@]) oppside

'''Example:'''

+--------+-------+------+

| 1 1 1|3 4 5|3 5 7|

+--------+-------+------+

60 #@(solve -. _3 ]\ 3 # >:@i.@]) 10000 NB. optional extra credit

 

=={{header|Java}}==

public class LawOfCosines {

 

 

}

{{out}}

<pre>

 

=={{header|JavaScript}}==

'use strict';

 

// MAIN ---

return main();

{{Out}}

<pre>Triangles of maximum side 13:

18394

[Finished in 3.444s]</pre>

 

=={{header|Julia}}==

{{trans|zkl}}

numnotsame(arrarr) = sum(map(x -> !all(y -> y == x[1], x), arrarr))

 

println("Angle 120:"); for t in tri120 println(t) end

println("\nFor sizes N through 10000, there are $(numnotsame(filtertriangles(10000)[1])) 60 degree triples with nonequal sides.")

 

Integer triples for 1 <= side length <= 13:

=={{header|Kotlin}}==

{{trans|Go}}

 

val squares13 = mutableMapOf<Int, Int>()

print(" For an angle of 60 degrees")

println(" there are ${solutions.size} solutions.")

 

{{output}}

 

=={{header|Lua}}==

local squares, roots, solutions = {}, {}, {}

local cos2 = ({[60]=-1,[90]=0,[120]=1})[angle]

solve(60, 10000, fexcr) -- extra credit

solve(90, 10000, fexcr) -- more extra credit

{{out}}

<pre>90° on 1..13 has 3 solutions

90° on 1..10000 has 12471 solutions

120° on 1..10000 has 10374 solutions</pre>

 

=={{header|Nim}}==

import tables

 

echo "\nFor sides in the range [1, 10000] where they cannot ALL be of the same length:\n"

var solutions = solve(60, 10000, false)

 

{{out}}

=={{header|Perl}}==

{{trans|Raku}}

binmode STDOUT, "utf8:";

use Sort::Naturally;

}

 

{{out}}

<pre>Integer triangular triples for sides 1..13:

 

=={{header|Phix}}==

{{out}}

<pre style="font-size: 11px">

Non-equilateral angle 60 triangles for sides 1..10000: 18394

</pre>

 

=={{header|Prolog}}==

{{works with|SWI Prolog}}

find_solutions(Limit, Solutions, Limit, []).

 

write_triples(60, Solutions),

write_triples(90, Solutions),

 

{{out}}

=={{header|Python}}==

===Sets===

 

def method1(N=N):

_, t60, _ = method1(10_000)

notsame = sum(1 for a, b, c in t60 if a != b or b != c)

 

{{out}}

A variant Python draft based on dictionaries.

(Test functions are passed as parameters to the main function.)

 

 

 

if __name__ == '__main__':

{{Out}}

<pre>Triangles of maximum side 13

60 degrees - uneven triangles of maximum side 10000. Total:

18394</pre>

 

=={{header|Raku}}==

(formerly Perl 6)

In each routine, <tt>race</tt> is used to allow concurrent operations, requiring the use of the atomic increment operator, <tt>⚛++</tt>, to safely update <tt>@triples</tt>, which must be declared fixed-sized, as an auto-resizing array is not thread-safe. At exit, default values in <tt>@triples</tt> are filtered out with the test <code>!eqv Any</code>.

my %sq = (1..$n).map: { .² => $_ };

my atomicint $i = 0;

my ($angle, $count) = 60, 10_000;

say "\nExtra credit:";

{{out}}

<pre>Integer triangular triples for sides 1..13:

displayed &nbsp; (using the

<br>absolute value of the negative number).

parse arg os1 os2 os3 os4 . /*obtain optional arguments from the CL*/

if os1=='' | os1=="," then os1= 13; s1=abs(os1) /*Not specified? Then use the default.*/

end /*b*/

end /*a*/

{{out|output|text=&nbsp; when using the default number of sides for the input: &nbsp; &nbsp; <tt> 13 </tt>}}

<pre>

══════════════════════════ 60º unique ══════════════════════════

18,394 solutions found for 60º unique (sides up to 10,000)

</pre>

 

=={{header|Ruby}}==

sumaabb, ab = a*a + b*b, a*b

case c*c

puts v.inspect, "\n"

end

{{out}}

<pre>For an angle of 60 there are 15 solutions:

</pre>

Extra credit:

ar = (1..n).to_a

squares = {}

 

puts "There are #{count} 60° triangles with unequal sides of max size #{n}."

{{out}}

<pre>There are 18394 60° triangles with unequal sides of max size 10000.

=={{header|Wren}}==

{{trans|Go}}

var squares10000 = {}

 

solutions = solve.call(60, 10000, false)

System.write(" For an angle of 60 degrees")

 

{{out}}

 

For an angle of 60 degrees there are 18394 solutions.

</pre>

 

=={{header|zkl}}==

sqrset:=[0..N].pump(Dictionary().add.fp1(True),fcn(n){ n*n });

tri90, tri60, tri120 := List(),List(),List();

tri.sort(fcn(t1,t2){ t1[0]<t2[0] })

.apply("concat",",").apply("(%s)".fmt).concat(",")

println("Integer triangular triples for sides 1..%d:".fmt(N));

foreach angle, triples in (T(60,90,120).zip(tritri(N))){

println(" %3d\U00B0; has %d solutions:\n %s"

.fmt(angle,triples.len(),triToStr(triples)));

{{out}}

<pre>

</pre>

Extra credit:

sqrset:=[1..N].pump(Dictionary().add.fp1(True),fcn(n){ n*n });

n60:=0;

}

n60

println(("60\U00b0; triangle where side lengths are unique,\n"

{{out}}

<pre>