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

 

=={{header|Action!}}==

BYTE count,a,b,c

 

Test(13,60,1)

Test(13,120,-1)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Law_of_cosines_-_triples.png Screenshot from Atari 8-bit computer]

 

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

 

=={{header|Factor}}==

sequences sets sorting ;

IN: rosetta-code.law-of-cosines

[ * + ] 120

[ 2drop 0 - ] 90

{{out}}

<pre>

 

=={{header|Fortran}}==

IMPLICIT NONE

 

END DO

 

<pre>

90. degree triangles:

 

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

 

To save space, we define `squares` as a hash rather than as a JSON array.

reduce range(1; 1+n) as $i ({}; .[$i*$i|tostring] = $i);

 

| " For an angle of \(degrees) degrees, there are \(.) solutions.") ;

 

{{out}}

<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

 

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

Length[%]

Solve[{a^2+b^2-a b==c^2,1<=a<=13,1<=b<=13,1<=c<=13,a<=b},{a,b,c},Integers]

Solve[{a^2+b^2+a b==c^2,1<=a<=13,1<=b<=13,1<=c<=13,a<=b},{a,b,c},Integers]

Length[%]

{{out}}

<pre>{{a->3,b->4,c->5},{a->5,b->12,c->13},{a->6,b->8,c->10}}

 

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

Using a simple flat sequence of 100 million elements (well within the desktop language limits, but beyond JavaScript) proved significantly faster than a dictionary (5x or so).

<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>

<span style="color: #000080;font-style:italic;">--constant lim = iff(platform()=JS?13:10000)</span>

<span style="color: #000000;">show</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"Non-equilateral angle 60 triangles for sides 1..10000: %d%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">solve</span><span style="color: #0000FF;">(</span><span style="color: #000000;">60</span><span style="color: #0000FF;">,</span><span style="color: #000000;">10000</span><span style="color: #0000FF;">,</span><span style="color: #004600;">false</span><span style="color: #0000FF;">),</span><span style="color: #004600;">false</span><span style="color: #0000FF;">)</span>

<span style="color: #000080;font-style:italic;">--end if</span>

{{out}}

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

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

=={{header|R}}==

This looks a bit messy, but it really pays off when you see how nicely the output prints.

inputs <- cbind(A = inputs[1, ], B = inputs[2, ])[sort.list(inputs[1, ]),]

Pythagoras <- inputs[, "A"]^2 + inputs[, "B"]^2

sum(!is.na(output[, 3])), "solutions in the 90º case,",

sum(!is.na(output[, 4])), "solutions in the 60º case, and",

{{out}}

<pre> A B C (90º) C (60º) C (120º)

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

 

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

 

=={{header|XPL0}}==

int Eqn;

int Cnt, A, B, C;

[for Case:= 1 to 3 do LawCos(Case);

ExtraCredit;

 

{{out}}

 

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