Here is a brief way to do that.

   L := [seq(cos(x), x=0.1 .. 10.0, 0.1)];
   S := sort(L);
   S[35];

which produces -0.5885011173 as its last result.

Here's a slightly longer way, that shows a bit more. (figured that you're trying to learn some Maple. You could try and work out for yourself what these commands do...)

Download sort_cos_list.mw

You may have noticed that lists L and S each contain both the x-values as well as the cos(x) values. I only did it that way because I thought that it'd be fun/interesting to be able to immediately get the corresponding x-value which produced the 35th greatest cos-value, without doing any additional computation.

You've already assigned ics itself as a set., ie.
   ics := {V(0) = -65, h(0) = 0.6, m(0) = 0.05, n(0) = 0.32}

Having done that, you could pass either,
    {eq1, eq2, eq3, eq4} union ics
or,
    {eq1, eq2, eq3, eq4, op(ics)}
to dsolve.

That merges the differential equations and initial conditions together into a single (flat) set. 

Or you could assign only the expression sequence of conditions to ics (and not itself a set), ie,
   ics := V(0) = -65, h(0) = 0.6, m(0) = 0.05, n(0) = 0.32;
and then pass your original formulation to dsolve, ie.,
   {eq1, eq2, eq3, eq4, ics}

Adjust the rest, as desired. I didn't look to see if your system and the results made sense.

Download Question1_ac.mw

Here's one way, collecting wrt the global :-diff.

The colon-minus prefix makes it refer to the global name diff rather than the Physics export going by the similar name.

Download CollectDiff_ac.mw

The following replaces all names of the form `x` followed by a positive integer.

It handles your set of names assigned to t, and it doesn't matter how many such names there are.

It also allows you to make such replacements within expressions more generally.

Download subsind_ex.mw

If you know that there are just that particular 100 such names then you could do it more tersely like, say,

   subs('x||i=y||i'$i=1..100,t);
or,
   subs('x||i=y||i'$i=1..100,expr);

Or, using it more than once,

   S:='x||i=y||i'$i=1..100:
   subs(S,t);
   subs(S,expr);

Don't make the assignment to C if you want it to remain as an unassigned name.

It looks as if you wanted to use only an equation involving C, not an assignment.

Download isol.mw

You wrote of expressing them in terms of each other.

I'd be interested to know whether your wider investigations might have any use for expressing them all ("compactly") in terms of additional temporary variables.

For example,

Download rearrangingterms_q2.mw

I made those additional temporary substitutions as assignments. But they could also be formulated as a sequence of equations (for substitution into each other, up the chain).

You could optionally (telescopically) collapse a portion of that sequence of subsitutions, from the top down.  Eg, you could retain only the knowledge in a5 & a6, or what have you.

Also, such a scheme can also support a wider set of operations (expression forms) than just mere polynomials. For polynomials there are various techniques (basis, triangularization, etc) to produce such a substituion chain. But there are also mechanisms for doing it for a wider (non-polynomial) class.

The five you cited can be found pretty quickly, and exactly, as follows.

restart;

nsd := 16*a*b*c*(9 + a^2 + b^2 + c^2)*(b*c + a*(b + c) + 3*(a + b + c))
       - (3 + a + b + c)^2*(a*b + 3*c)*(3*b + a*c)*(3*a + b*c):

nsdac := eval(nsd,{c=a}):
rawac := solve({nsdac,a>0,b>0},[a,b]):
solac := map(s->{s[],c=eval(a,s)},rawac);

    solac := [{a = 1, b = 1, c = 1}, {a = 3, b = 3, c = 3}, 
              {a = 3, b = 9, c = 3}]

eval~(nsd, solac);

                 [0, 0, 0]

The remaining pair can be had immediately by noticing/proving the symmetry, or by re-running with each of the corresponding substitutions c=b and b=a.

Proving that there are no other solutions seems difficult or time-consuming. Let's see...

You mistakenly placed the call to polygonplot inside the call to draw.

Download jamet_ex.mw

Are you trying to get an effect something like one of these?

Download somecoll.mw

If you actually wanted to "collect" that term within a modification of the original expression assigned to aa, then you could follow that up with either of,

  subs(reveq,collect(algsubs(eq,expand(aa)),PP,simplify));

or,

  subs(reveq,collect(algsubs(eq,temp1),PP,simplify))
   + simplify(aa-temp1);

This can be done in your Maple 18 simply by,

   convert([sol],rational)[]

You have an expression sequence assigned to sol, not a list or a set. By wrapping it in square backets you get [sol] as a list. This allows you to pass them all together, without any being misinterpreted as options to the command.

By prepending [] to the call you can turn the result from a list back into a mere expression sequence (if you so want...).

problem1_ac.mw

This issue is covered quite clearly on the Help page for topic if, in the section Nested Selection Statements. See also the Help page for topic printlevel.

I'll mention that the inner conditional code does indeed get executed. The effects you're seeing only relate to the display of the inner results.

These effects also cover such nesting involving do-loops.

A good place to start looking for details, when you have an issue with a particular command, would be the Help page for that command.

Download LambW_simpl1.mw

You misspelled Distance as distance.

Download distance_ex.mw

Is this the kind of effect you're after?

Download plot_1_ac.mw

There are several variants on this methodology. I just gave one. (You don't necessarily need to construct revr. Instead you could refer to the reversed entries in the rhs of the tickmarks equation by indexing with a formula. And so on...)

I used Reverse after loading ListTools. Again, there are several other ways. Too many to mention. But the basic idea is to force the tickmarks.

ps. I gave one of the variants that is "simpler" because it relies on the special kind of r values you have. In fact for this special kind of r-values it could be done even more simply.

It's also possible to do it for more general r values (irregularly spaced, say), with a more exotic mapping. Let us know if you need that,

The idea behind that particular calling sequence is that you can efficiently re-use the created rtable (Array, Vector, etc). The relevant calls to Sample will populate the passed rtable, in-place.

This is more efficient than having Sample create new rtable containers each time, especially if you are going to do this many times.

Download Sample_and_rtables.mw