Problem:
Problem D: Digits on the Floor Taro attempts to tell digits to Hanako by putting straight bars on the floor. Taro wants to
express each digit by making one of the forms shown in Figure 1. Since Taro may not have bars of desired lengths, Taro cannot always make forms exactly as
shown in Figure 1. Fortunately, Hanako can recognize a form as a digit if the connection
relation between bars in the form is kept. Neither the lengths of bars nor the directions of forms
affect Hanako’s perception as long as the connection relation remains the same. For example,
Hanako can recognize all the awkward forms in Figure 2 as digits. On the other hand, Hanako
cannot recognize the forms in Figure 3 as digits. For clarity, touching bars are slightly separated
in Figures 1, 2 and 3. Actually, touching bars overlap exactly at one single point.    Figure 1: Representation of digits      Figure 2: Examples of forms recognized as digits    In the forms, when a bar touches another, the touching point is an end of at least one of them.
That is, bars never cross. In addition, the angle of such two bars is always a right angle. To enable Taro to represent forms with his limited set of bars, positions and lengths of bars can
be changed as far as the connection relations are kept. Also, forms can be rotated. Keeping the connection relations means the following.    Figure 3: Forms not recognized as digits (these kinds of forms are not contained in the dataset)     Separated bars are not made to touch.  Touching bars are not made separate.  When one end of a bar touches another bar, that end still touches the same bar. When it
touches a midpoint of the other bar, it remains to touch a midpoint of the same bar on
the same side.  The angle of touching two bars is kept to be the same right angle (90 degrees and -90
degrees are considered different, and forms for 2 and 5 are kept distinguished).  Your task is to find how many times each digit appears on the floor. The forms of some digits always contain the forms of other digits. For example, a form for
9 always contains four forms for 1, one form for 4, and two overlapping forms for 7. In this
problem, ignore the forms contained in another form and count only the digit of the “largest”
form composed of all mutually connecting bars. If there is one form for 9, it should be interpreted
as one appearance of 9 and no appearance of 1, 4, or 7. Input The input consists of a number of datasets. Each dataset is formatted as follows.  n  x 1a y 1a x 1b y 1b  x 2a y 2a x 2b y 2b . . .  x na y na x nb y nb  In the first line, n represents the number of bars in the dataset. For the rest of the lines, one
line represents one bar. Four integers x a , y a , x b , y b , delimited by single spaces, are given in
each line. x a and y a are the x- and y- coordinates of one end of the bar, respectively. x b and y b are those of the other end. The coordinate system is as shown in Figure 4. You can assume
1 ≤ n ≤ 1000 and 0 ≤ x a , y a , x b , y b ≤ 1000. The end of the input is indicated by a line containing one zero.    Figure 4: The coordinate system   You can also assume the following conditions.  More than two bars do not overlap at one point.  Every bar is used as a part of a digit. Non-digit forms do not exist on the floor.  A bar that makes up one digit does not touch nor cross any bar that makes up another
digit.  There is no bar whose length is zero.  Output For each dataset, output a single line containing ten integers delimited by single spaces. These
integers represent how many times 0, 1, 2, . . . , and 9 appear on the floor in this order. Output
lines must not contain other characters. Sample Input 9
60 140 200 300
300 105 330 135
330 135 250 215
240 205 250 215
298 167 285 154
30 40 30 90
30 90 150 90
150 90 150 20
30 40 150 40
8
320 20 300 60
320 20 380 50
380 50 240 330
10 50 40 20
10 50 110 150
110 150 180 80
40 20 37 17
37 17 27 27
20
72 222 132 182
204 154 204 54
510 410 520 370
404 54 204 54
530 450 410 450
204 68 404 68
80 110 120 30
130 160 180 60
520 370 320 320
310 360 320 320
120 30 180 60
60 100 80 110
404 154 204 154
80 60 60 100
430 550 590 550
510 410 310 360
430 450 430 550
404 54 404 154
232 202 142 262
142 262 102 202
0 Output for the Sample Input 0 1 0 1 0 0 0 0 0 1
0 0 0 0 0 1 0 1 0 0
1 0 1 0 2 0 0 0 1 0

Solution (Python):
import sys
readline = sys.stdin.readline
write = sys.stdout.write

def dot3(O, A, B):
    ox, oy = O; ax, ay = A; bx, by = B
    return (ax - ox) * (bx - ox) + (ay - oy) * (by - oy)
def cross3(O, A, B):
    ox, oy = O; ax, ay = A; bx, by = B
    return (ax - ox) * (by - oy) - (bx - ox) * (ay - oy)
def dist2(A, B):
    ax, ay = A; bx, by = B
    return (ax - bx) ** 2 + (ay - by) ** 2
def is_intersection(P0, P1, Q0, Q1):
    C0 = cross3(P0, P1, Q0)
    C1 = cross3(P0, P1, Q1)
    D0 = cross3(Q0, Q1, P0)
    D1 = cross3(Q0, Q1, P1)
    if C0 == C1 == 0:
        E0 = dot3(P0, P1, Q0)
        E1 = dot3(P0, P1, Q1)
        if not E0 < E1:
            E0, E1 = E1, E0
        return E0 <= dist2(P0, P1) and 0 <= E1
    return C0 * C1 <= 0 and D0 * D1 <= 0

def solve():
    N = int(readline())
    if N == 0:
        return False
    LS = []
    for i in range(N):
        xa, ya, xb, yb = map(int, readline().split())
        LS.append(((xa, ya), (xb, yb)))
    *p, = range(N)
    def root(x):
        if x == p[x]:
            return x
        p[x] = y = root(p[x])
        return y
    def unite(x, y):
        px = root(x); py = root(y)
        if px < py:
            p[py] = px
        else:
            p[px] = py
    for i in range(N):
        p0, p1 = LS[i]
        for j in range(i):
            q0, q1 = LS[j]
            if is_intersection(p0, p1, q0, q1):
                unite(i, j)
    M = 0
    G = []
    lb = [0]*N
    for i in range(N):
        if root(i) == i:
            G.append([LS[i]])
            lb[i] = M
            M += 1
            continue
        e = lb[root(i)]
        G[e].append(LS[i])
    ans = [0]*10
    for g in G:
        if len(g) == 1:
            ans[1] += 1
            continue
        s = {}
        for p0, p1 in g:
            s[p0] = s.get(p0, 0) + 1
            s[p1] = s.get(p1, 0) + 1

        if len(g) == 5:
            d = {}
            for p0, p1 in g:
                v0 = s[p0]; v1 = s[p1]
                key = ((v0, v1) if v0 < v1 else (v1, v0))
                d[key] = d.get(key, 0) + 1
            if (1, 1) in d:
                ans[8] += 1
            else:
                ls = []
                for p0, p1 in g:
                    if s[p0] == 1:
                        ls.append((p0, p1))
                    if s[p1] == 1:
                        ls.append((p1, p0))
                (p0, p1), (q0, q1) = ls
                for e in g:
                    r0, r1 = e
                    if s[r0] != 2 or s[r1] != 2:
                        continue
                    if (is_intersection(p0, p1, r0, r1) and p1 not in e) or (is_intersection(q0, q1, r0, r1) and q1 not in e):
                        ans[6] += 1
                        break
                else:
                    if cross3(p0, p1, q1) < 0:
                        ans[2] += 1
                    else:
                        ans[5] += 1
            continue

        if len(g) == 3:
            if len(s) == 4:
                ans[7] += 1
            else:
                ans[4] += 1
        elif len(g) == 4:
            if len(s) == 4:
                ans[0] += 1
            elif len(s) == 5:
                ans[9] += 1
            else:
                ans[3] += 1
    write(" ".join(map(str, ans)))
    write("\n")
    return True
while solve():
    ...