Go: package main

import (
	"fmt"
	"sort"
)

// TriangleKind kind of triangle
type TriangleKind int

const (
	// Nothing not triangle
	Nothing TriangleKind = iota
	// RightTriangle the right triangle
	RightTriangle
	// SharpTriangle the sharp triangle
	SharpTriangle
	// ObtuseTriangle the obtuse triangle
	ObtuseTriangle
) // const for Triangle kind

type result struct {
	rTriangle int
	sTriangle int
	oTriangle int
}

func (res *result) String() string {
	return fmt.Sprintf("%d %d %d %d", res.rTriangle+res.sTriangle+res.oTriangle, res.rTriangle, res.sTriangle, res.oTriangle)
}

func checkTriangleType(a int, b int, c int) TriangleKind {
	p := []int{a, b, c}
	sort.Sort(sort.IntSlice(p))
	if !(p[0]+p[1] > p[2] && p[1]+p[2] > p[0] && p[2]+p[0] > p[1]) {
		return Nothing
	}

	c = (p[0] * p[0]) + (p[1] * p[1]) - (p[2] * p[2])
	if c == 0 {
		return RightTriangle
	}
	if c > 0 {
		return SharpTriangle
	}
	return ObtuseTriangle
}

func main() {
	var res = new(result)
	var a, b, c int
	var hasNext = true
	for hasNext {
		fmt.Scanf("%d %d %d", &a, &b, &c)
		switch checkTriangleType(a, b, c) {
		case Nothing:
			hasNext = false
		case RightTriangle:
			res.rTriangle++
		case SharpTriangle:
			res.sTriangle++
		case ObtuseTriangle:
			res.oTriangle++
		}
	}
	fmt.Println(res.String())
}

Python: f = True
cnt = 0
l = [0,0,0]
while f:
    t = [int(s) for s in input().split()]
    t.sort()
    if t[0]+t[1] <= t[2]:
        f = False
        continue
    if t[0]**2+t[1]**2 > t[2]**2:
        l[0]+=1
    elif t[0]**2+t[1]**2 == t[2]**2:
        l[1]+=1
    else:
        l[2]+=1
print(sum(l),l[0],l[1],l[2])

Python: t = 0
n = 0
s = 0
w = 0

while True:
    a = list(map(int, input().split()))
    a.sort()
    if a[0]+a[1] <= a[2]:
        print('{} {} {} {}'.format(t, n, s, w))
        break
    else:
        t += 1
        left = a[0]**2 + a[1]**2 
        right = a[2]**2
        if left == right:
            n += 1
        elif left > right:
            s += 1
        else:
            w += 1

Python: ans = [0 for i in range(4)]
while True:
  sides = sorted([int(inp) for inp in input().split()])
  if sides[2] >= sides[1] + sides[0]:
    print(ans[0], ans[1], ans[2], ans[3])
    break
  if sides[2]**2 > sides[1]**2 + sides[0]**2:
    ans[3]+=1
  elif sides[2]**2 == sides[1]**2 + sides[0]**2:
    ans[1]+=1
  else:
    ans[2]+=1
  ans[0]+=1

Python: import sys
import fileinput
import math
from collections import Counter
from decimal import Decimal

RADIAN180 = math.pi
ANGLE90 = 90

counter = Counter()


def is_triangle(edges):
    return edge[0] + edge[1] > edge[2] and \
           edge[1] + edge[2] > edge[0] and \
           edge[2] + edge[0] > edge[1]


def calculate_radian(edges):
    edge.sort()
    radian = []

    s = sum(edge) / 2
    s = math.sqrt(s * (s - edge[0]) * (s - edge[1]) * (s - edge[2]))
    h = 2 * s / edge[2]

    radian.append(math.asin(h / edge[0]))
    radian.append(math.asin(h / edge[1]))

    radian.append(RADIAN180 - sum(radian))

    return radian


for input_list in fileinput.input():

    edge = [int(item) for item in input_list.split(" ")]

    if is_triangle(edge):

        counter["ALL"] = counter["ALL"] + 1

        radian = calculate_radian(edge)

        max_radian = max(radian)
        max_angle = math.degrees(max_radian)

        if max_angle < ANGLE90:
            counter["ACUTE"] += 1
        elif max_angle == ANGLE90:
            counter["RIGHT"] += 1
        else:
            counter["OBTUSE"] += 1
    else:
        for garbage in sys.stdin:
            pass
        break

print(counter['ALL'], counter["RIGHT"], counter["ACUTE"], counter["OBTUSE"])

Python: def checkTriangle(a, b, c):
    if a + b > c and a + c > b and b + c > a:
        return True
    return False


def checkOct(a, b, c):
    a, b, c = [i * i for i in [a, b, c]]
    if a + b == c or a + c == b or b + c == a:
        return 0
    elif c < a + b or b < a + c or a < b + c:
        return 1
    else:
        return 2

for i in range(5):
    a, b, c = map(int, input())
    result = [0] * 3
    if checkTriangle(a, b, c):
        result[checkOct(a, b, c)] += 1
print(sum(result),*result)

Python: chokkaku,eikaku,donkaku = 0,0,0
while 1:
    abc = sorted((map(int,input().split())))
    a,b,c = abc[0],abc[1],abc[2]
    if a+b <= c:
        print(chokkaku+eikaku+donkaku,chokkaku,eikaku,donkaku)
        break
    elif a**2+b**2 > c**2:
        eikaku += 1
    elif a**2+b**2 < c**2:
        donkaku += 1
    else:
        chokkaku += 1

Python: r=a=o=0
while 1:
 l,m,n=sorted(list(map(int,input().split())))
 if l+m<=n:break
 c=l*l+m*m-n*n
 if c>0:a+=1
 elif c<0:o+=1
 else:r+=1
print(r+a+o,r,a,o)

Python: A =[] 
while True:
    try:
        A.append(sorted(list(map(int,input().split())),reverse=True))

    except:
        break
        #または、quit(),os.exit()をして止める。


def triangle_types(X):
    print(X)
    num_of_acute = 0
    num_of_right = 0
    num_of_obtuse = 0
    num_of_normal = 0
    for i in range(len(X)):
        a,b,c = [j for j in X[i]]
        ans = b**2 + c**2 - a**2
        if (a < b + c):
            num_of_normal+=1
            if (ans > 0):
                num_of_acute+=1
            elif (ans == 0):
                num_of_right+=1
            elif (ans < 0):
                num_of_obtuse+=1
            else:
                print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
                return
        else:
            print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
            return
    
if __name__ == '__main__':
    triangle_types(A)

Python: A =[] 
while True:
    try:
        A.append(sorted(list(map(int,input().split())),reverse=True))

    except:
        break
        #または、quit(),os.exit()をして止める。


def triangle_types(X):
    print(X)
    num_of_acute = 0
    num_of_right = 0
    num_of_obtuse = 0
    num_of_normal = 0
    for i in range(len(X)):
        a,b,c = [j for j in X[i]]
        ans = b**2 + c**2 - a**2
        print("a:{},b+c:{}".format(a,b+c))
        if (a <= b + c and b <= a + c and c <= a + b):
            num_of_normal+=1
            if (ans > 0):
                num_of_acute+=1
            elif (ans == 0):
                num_of_right+=1
            elif (ans < 0):
                num_of_obtuse+=1
            else:
                print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
                return
        else:
            print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
            return
    print("{} {} {} {}".format(num_of_normal,num_of_right,num_of_acute,num_of_obtuse))
    return

if __name__ == '__main__':
    triangle_types(A)

Python: #input_f = "3 4 5\n2 1 2\n6 3 4\n1 1 1\n1 2 3"
input_f = input()

counter = [0, 0, 0]

def t_check(a,b,c):
    if a + b > c:
        if b + c > a:
            if a + c > b: return True
    return False



def f_check(a_, b_, c_):
    tmp = []
    tmp.append(a_)
    tmp.append(b_)
    tmp.append(c_)
    sqrts = []
    for i in range(3):
        sqrts.append(tmp[i]**2)
    m = max(sqrts)
    s = sum(sqrts)

    print(m,s)
    
    if m == (s - m): return(0)
    if m > (s - m): return(2)
    if m < (s - m): return(1)
 
    
for i in range(int(len(input_f))):
    t = input_f.split("\n")[i].split()
    fn, sn, tn = int(t[0]),int(t[1]),int(t[2])
    if t_check(fn,sn,tn):
        counter[f_check(fn,sn,tn)] += 1
    else: 
        print(sum(counter),counter[0], counter[1], counter[2])
        break

Python: count = 0
cho,ei,don = 0,0,0
while(True):
    tmp = list(map(int, input().split()))
    tmp.sort()
    a,b,c = tmp[0],tmp[1],tmp[2]
    if a + b <= c:
        break
    else:
        a2 , b2 , c2 = a ** 2, b ** 2, c ** 2
        if a2 + b2 == c2:
            cho += 1
        elif a2 + b2 < c2:
            don += 1
        else:
            ei += 1
ans = str(cho+ei+don) + " " + str(cho) + " " + str(ei) + " " + str(don)+ "\n"
print(ans)