Up and Down Sequences

The quality of pseudo random-number generators used in some computations, especially simulation, is a significant issue. Proposed generation algorithms are subjected to many tests to establish their quality, or, more usually, their lack of it. One of the common tests is the run test.

In this test, sequences are tested for ``runs up" and ``runs down."

We will examine series of data values for the ``Up" and ``Down" sequences each series contains.

Within a series, an ``Up" sequence continues as long as each data-value received is not less than the previous data-value. An ``Up" sequence terminates when a data-value received is less than the previous data-value received.

A ``Down" sequence continues as long as each data-value received is not greater than the previous data-value. A ``Down" sequence terminates when a data-value received is greater than the previous data-value received.

An ``Up" sequence can be initiated by the termination of a ``Down" sequence and vice versa. (Sequences initiated in this manner have length one at this initiation point.)

All the initial data-values are part of an ``Up" sequence, and contribute to its length, if the first deviation of the data-values is upwards.

All the initial data-values are part of a ``Down" sequence, and contribute to its length, if the first deviation of the data-values is downwards.

If the data-values received don't allow classification as either an ``Up" or a ``Down" sequence, the data should be considered to have neither sequence.

Find the average length of both the ``Up" and the ``Down" sequences encountered for each input line in the data file. Report these average lengths as each input line is processed.

Input

Each of the separate series to be examined is contained on a single line of input.

Each series to be analyzed consists of at least one and no more than 30 unsigned, non-zero integers. Each integer in a series has at least one digit and no more than four digits. The integers are separated from each other by a single blank character. Each of the series will be terminated by a single zero (0) digit. This terminator should not be considered as being part of the series being analyzed.

The set of series to be analyzed is terminated by a single zero (0) digit as the input on a line. This terminator should not be considered to be a series, and no output should be produced in response to its encounter.

Output

A line with two real values is to be emitted for each input data set encountered. It must begin with the message ``Nr values = N: ", where N is the number of input data in the line; and then to continue with the average values for runs.

First, the average ``Up" run length, then the average ``Down" run length. Separate these values with a space.

Answers must be rounded to six digits after the decimal point.

Sample Input

1 2 3 0
3 2 1 0
1 2 3 2 1 0
2 2 2 2 3 0
4 4 4 4 3 0
4 4 4 3 3 3 3 0
4 4 4 3 3 3 4 0
5 5 5 5 0
1 2 3 2 3 4 5 0
0

Sample Output (Your output, using your chosen language, may be default-formatted differently).

Nr values = 3:  2.000000 0.000000
Nr values = 3:  0.000000 2.000000
Nr values = 5:  2.000000 2.000000
Nr values = 5:  4.000000 0.000000
Nr values = 5:  0.000000 4.000000
Nr values = 7:  0.000000 6.000000
Nr values = 7:  1.000000 5.000000
Nr values = 4:  0.000000 0.000000
Nr values = 7:  2.500000 1.000000

#include <stdio.h>

int main() {
    long long A[50], B[50];
    while(scanf("%lld", &A[0]) == 1) {
        if(A[0] == 0)   break;
        B[0] = 1;
        int n = 1, m = 1;
        while(scanf("%lld", &A[n]) == 1 && A[n]) {
            if(A[n] == A[n-1])
                B[n-1]++;
            else
                B[n] = 1, n++;
            m++;
        }
        int up_len = 0, down_len = 0, upt = 0, downt = 0;
        int i, j, len;
        for(i = 0; i < n; i++) {
            j = i, len = B[i];
            while(j+1 < n && A[j+1] > A[j])
                len += B[j+1], j++;
            if(i != j) {
                up_len += len-1;
                upt ++;
                B[j] = 1;
                i = j-1;
                continue;
            }
            j = i, len = B[i];
            while(j+1 < n && A[j+1] < A[j])
                len += B[j+1], j++;
            if(i != j) {
                down_len += len-1;
                downt ++;
                B[j] = 1;
                i = j-1;
            }
        }
        if(upt == 0)    upt = 1;
        if(downt == 0)  downt = 1;
        printf("Nr values = %d:  %.6lf %.6lf\n", m, (double)up_len/upt, (double)down_len/downt);
    }
    return 0;
}