There are many ways of implementing your application. Here is one idea for a design, let me know if this makes sense to you and if you want any help understanding and implementing it.
If you can adjust the physical distance of the weighing device so that it is the same distance from the first solenoid as the solenoids are from each other then that makes the design simpler. We can add in functionality later to cope with a different distance if necessary but my explanation will be easier if we assume that the weight sensor and the solenoids are all separated by 3072 counts.
Assume ten solenoids numbered from 1 to 10 with number 1 being the one for the lightest objects and 10 for the heaviest.
Lets refer to every 3072 counts as a cycle. For each cycle (3072 counts) we want to weigh an item that is over the weight sensor and activate a solenoid when an item weighed in an earlier cycle comes over the correct solenoid.
A cycle has a duration in counts, this duration starts at the time an object is near enough that a solenoid should be activated, and it finishes when the solenoid is deactivated. The actual timings will depend on how long the solenoid needs activating in order to ensure the object drops. You also want to make sure that you are taking your weight value a point in the cycle that the object is fully over the weight sensor.
If I was building this for commercial use I would be tempted to use a photo transistor to detect the physical presence of the objects (or whatever is holding the objects) to trigger the start and end of a cycle, but this may be more complex then you need. So to keep it simpler for now, say a new cycle starts every 3072 counts and lasts for enough counts for an object to drop.
At each cycle I would get the weight value. If the value was greater than a threshold I would use a lookup table or calculate the appropriate solenoid number for this weight. For example, no object would return a value of 0 (no solenoid), the lightest objects would return solenoid 1 etc. with the heaviest object returng 10.
I would then have a circular buffer, you can google circular buffers if you are not familiar with this, but for now think of it as a kind of shift register that holds integer values. We will put the solenoid number we just calculated at the first available position in this buffer. At each new cycle, the appropriate solenoid number (or 0 if no object) would put into the next position in the buffer.
here is an example where we assume that obj1 has weight value of 2, obj2 has value of 1, and obj3 has value of 3
At the start, the first cycle with an object above the weight threshold will look like this
obj3 obj2 obj1 ? ? ?
weight Sol1 Sol2 SoL3
and if obj1 has a weight value of 2 then immediately after weighing the buffer will look like this:
[2] [0] [0] ?.
Here is the second cycle:
Obj4 obj3 obj2 obj1 ? ?
weight Sol1 Sol2 SoL3
buffer after cycle 2: [1] [2] [0] [0] ?.
And the third cycle:
Obj5 Obj4 obj3 obj2 obj1 ?
weight Sol1 Sol2 SoL3
buffer after cycle 3: [3] [1] [2] [0] [0] ?.
Now the trick is to remember that at the start of every cycle the first element of this circular buffer is always over the weighing sensor, the second is always over solenoid 1. the third over two etc. So all that needs to be done is to check if the value in each buffer position from 1 to 10 (remember in C that the first position is 0) is the same as the solenoid number. In every case that the value equals the position then that solenoid should be activated.
Because we need a circular buffer (memory is finite on the arduino so we need to reuse elements of the buffer that represent objects that have been dropped, the current position wraps around when it gets to the end of the buffer. But I think all this is easier to implement then it is to explain.
That's a lot to take in. Does it make any sense to you?