Q:

distribute values of list 1 unequal lenth over list 2 in linear/evenly fashion

I have 2 List<float> of unequal length. 
Scores and Grades. 
Depending on the configuration one or the other list is greater than the other. 
There are 2 scenarios:
Use case 1: 60 scores and 50 grades - 1 to 6 with tenth grades -
I have to distribute 60 scores over 50 grades in an even way. 
Thus many grades will have multiple related consecutive scores (1:N relation concerning data structure)
Use case 2: 40 scores and 50 grades - 1 to 6 with tenth grades - 
I have to distribute 40 scores over 50 grades in an even way. 
Thus 10 grades must be removed (50 - 40) evenly to get a 1:1 relation data structure between scores and grades. 
What algorithm`s are available to me that I can solve the problem with C#? 
I have written down here the result data I would expect to look like when the implemented algorythm is run. 
Use case 1 sample result data:
Scores  Grade
0   6
1   5,9
2 - 3   5,8
4   5,7
5   5,6
6   5,5
7   5,4
8 - 9   5,3
10  5,2
11  5,1
12  5
13  4,9
14 - 15 4,8
16  4,7
17  4,6
18  4,5
19  4,4
20 - 21 4,3
22  4,2
23  4,1
24  4
25  3,9
26 - 27 3,8
28  3,7
29  3,6
30  3,5
31  3,4
32 - 33 3,3
34  3,2
35  3,1
36  3
37  2,9
38 - 39 2,8
40  2,7
41  2,6
42  2,5
43  2,4
44 - 45 2,3
46  2,2
47  2,1
48  2
49  1,9
50 - 51 1,8
52  1,7
53  1,6
54  1,5
55  1,4
56 - 57 1,3
58  1,2
59  1,1
60  1

Use case 2 sample result data:
Score   Grade
0   6
1   5,9
2   5,8
3   5,6
4   5,5
5   5,4
6   5,3
7   5,1
8   5
9   4,9
10  4,8
11  4,6
12  4,5
13  4,4
14  4,3
15  4,1
16  4
17  3,9
18  3,8
19  3,6
20  3,5
21  3,4
22  3,3
23  3,1
24  3
25  2,9
26  2,8
27  2,6
28  2,5
29  2,4
30  2,3
31  2,1
32  2
33  1,9
34  1,8
35  1,6
36  1,5
37  1,4
38  1,3
39  1,1
40  1

C# converted code for y = f(x) ;-)
  int x, y, accum;
            int scores = 33;
            int grades = 51;
            float[] gradesArray = new float[grades];
            float[] scoresArray = new float[scores];

            for (y = 0; y < grades; y++)
                gradesArray[y] =   6.0f - y / 10.0f;

            accum = scores / 2;
            y = 0;
            for (x = 0; x < scores; x++)
            {
                scoresArray[x] = gradesArray[y];
                accum += grades;
                while (accum >= scores)
                {
                    y++;
                    accum -= scores;
                }
            }

A:

Assume gradesArray is an input array indexed by y, and scoresArray is the output array indexed by x. To generate the output array, for each index in the output array, you need to select the corresponding value from the input array.  In pseudo-code:
scoresArray[x] = gradesArray[y]   where y = f(x)

In words, each output value scoresArray[x] is taken from location y in the input array gradesArray[y], where y is some function of x. And what is that function?  Well it's a line. 
Here's some sample code that uses a line drawing algorithm to solve use case 1:
int x, y, accum;
int scores = 61;
int grades = 51;
float[] gradesArray = new float[grades];
float[] scoresArray = new float[scores];

for (y = 0; y < grades; y++)
    gradesArray[y] = 6.0f - y / 10.0f;

accum = (scores-1) / 2;
y = 0;
for (x = 0; x < scores; x++)
{
    scoresArray[x] = gradesArray[y];
    accum += (grades-1);
    y += accum / (scores-1);
    accum %= (scores-1);
}

To adapt the code for use case 2, just change int scores = 61 to int scores = 41.