clist := ["#00007F", "Blue", "#007FFF", "Aqua", "#7FFF7F", "Yellow", "coral", "Red"];

Concerning the Second Part of the Question: how to do the above more straightforwardly:

Instead of trying to fix up that listdensityplot's ranges, we can use the simpler functionality to specify the ranges that the plots:-surfdata provides.

ans_surf:=plots:-surfdata(res1, dimension=2, 152 .. 160, 0 .. 500, view = [t1 .. t2, 5 .. 60],
                          style = patchnogrid, colorscheme = clist,
                          labels = ["Time (ms)", "Frequency (kHz)"],
                          labeldirections = [Horizontal, Vertical], axes = box,
                          axesfont = ["Arial", 14], labelfont = ["Times New Roman", "Bold", 16],
                          title = "Spectrogram", titlefont = ["Calibri", "Bold", 16], size=[500,500]):

ans_surf;

Concerning the First Part, how to shade a listcontplot by a list of more than two colors: this solution implements multiple regions with solid colorings. (Obtaining multiple distinct shaded gradients would be another interesting goal, possibly done by constructing multiple surfdata results using piecewise undefined data?!)

Make a listcontplot with coloring from Black to pure Red. Thus the COLOUR substructures will have RGB values with the red component between 0.0 and 1.0.

PP := plots:-listcontplot(res1, coloring = ["Black", "Red"], filledregions = true, thickness=0,
                          levels = nops(clist)-1):

#clistlist := map(c->[ColorTools:-Color(c)[]], ListTools:-Reverse(clist)):
Clist := map(c->[ColorTools:-Color(c)[]], clist):

Replace the COLOUR substructures with colors from out list, taking the position based on the relative position of the existing red component between 0.0 and 1.0.

recoloredPP := subsindets(PP, specfunc(POLYGONS),
                          p->subsindets(p, specfunc(COLOUR),
                                        c->COLOUR(RGB,Clist[1+round((nops(Clist)-1)*(op(2,c)))][]))):

Instead of fiddling with forced tickmarks, transform the listcontplot from being 1..14,1..513 to 152..160,0..500 .
 
adj := plottools:-transform((x,y)->[152+(x-1)/(14-1)*(160-152),0+(y-1)/(513-1)*(500-0)]):

newPP:=plots:-display( adj(recoloredPP),
                       view = ["default", 5 .. 60],
                       labels = ["Time (ms)", "Frequency (kHz)"], labeldirections = [Horizontal, Vertical],
                       labelfont = ["Times New Roman", "Bold", 16],
                       axes = box, axesfont = ["Arial", 14],
                       title = "Spectrogram#2", titlefont = ["Calibri", "Bold", 16], size = [500, 500]):
newPP;

#plots:-display(Array([ans_surf, newPP]));

We can also test the transformer adj, by overlaying an unfilled listcontplot with the sufdata plot. If the transformer is correctly done then the contours would lie on the locations where the smoothed/interpolated colors's underlying values change. This is just a sanity check.

unfilledPP:= plots:-listcontplot(res1, coloring = ["Black", "Red"], thickness=0, levels = nops(clist)-1):

plots:-display( ans_surf, adj(unfilledPP) );

What if we don't like the black lines in the listcontplot result? We can remove them:

newPPnocurves:=subsindets(newPP,specfunc(CURVES),()->NULL):
newPPnocurves:

The edges of the filled regions appear ragged when the CURVES substructures have been removed. We can add shaded versions of those CURVES, so that the edges of the filled regions once again appear smooth (but not all the same colour).

Note that we have a choice between overlaying any ragged POLYGONS edge with either the lower or the upper adjacent color.

We can construct those CURVES (contours) using the same technique as before, but this time leaving out the filledregions option.


PPcurves := plots:-listcontplot(res1, coloring = ["Black", "Red"], levels = nops(clist)-1, thickness=0):
recoloredPPcurves := subsindets(PPcurves, specfunc(CURVES),
                          p->subsindets(p, specfunc(COLOUR),
                                        c->COLOUR(RGB,Clist[`if`(op(2,c)=0.0,1,1+round((nops(Clist))*(op(2,c))))][]))):
newPPcurves:=plots:-display( adj(recoloredPPcurves),
                             view = ["default", 5 .. 60] ):

newPPcurves;

Now we'll combine the multicoloured filled contour plot with the multicoloured unfilled contour plot.

newPPboth := plots:-display(newPPnocurves, newPPcurves):

newPPboth;

We could compare the multicoloured listcontplots, both with and without the added multicolored contour CURVES.

plots:-display(Array([newPP, newPPnocurves, newPPboth]));

We could compare with the original plots:-surfdata plot (keeping in mind that there were only 14 x-data points for each y-data point, which is coarse data).

plots:-display(Array([ans_surf, newPPboth]));

restart;

P:=proc(p) add((1/k^(1/10))*sin(1/k), k=1..10^p); end proc:

seq( evalhf(P(i)), i = 1 .. 5 ); # note that convergence is slow

restart;

S:=Sum((1/k^(1/10))*sin(1/k), k=1..infinity);

st:=time[real]():

evalf(S); # Maple has its own tools to figure this out quickly

time[real]()-st;

# Your instructor wants you to understand a trick,
# that this slowly converging sum can be split into two
# parts: one with quicker convergence and one which can be
# quickly handled symbolically (exactly).
#
# So then you only need to take a moderate number of terms
# for the first part, and do a fast float approximation of the
# second part.

Q:=Sum(1/k^(1/10)*(sin(1/k)-1/k),k=1..n)+Sum(1/k^(11/10),k=1..n);

combine(Q); # note that this is the original goal

# This computes the first part of Q, to a finite number of terms.

G:=proc(p) add(1/k^(1/10)*(sin(1/k)-1/k),k=1..10^p); end proc:

seq( evalhf(G(i)), i = 1 .. 6 ); # note the convergence

evalhf(G(6)) + value(Sum(1/k^(11/10),k=1..infinity));

evalf(%);
 

restart;

ee:=exp(I*n*Pi)+exp(-I*n*Pi)=2*cos(Pi*n);

new:=(rhs-lhs)(ee)=0;

is(new); # hrrmm

simplify(new);

evalc(new);

convert(new,exp);

convert(new,trig);

alt:=subs(Pi=foo, ee);

is( alt );

kernelopts(version);

restart;

kernelopts(version);

45*K*Unit(m*kg/s^2)+3*Unit(cm*kg/sec^2);

Unit(m*kg/s^2);

# Scheme 1, using the open brackets of previous releases.
`print/Unit` := proc()
    local Unit;
    if IsWorksheetInterface('Standard')
     or _EnvInRecursiveUnitsModulePrint = true then
       if member(convert(kernelopts(':-version'),string)[1..10],
                 ["Maple 2015","Maple 2016","Maple 2017"]) then
          Typesetting:-mfenced(Typesetting:-mrow(Typesetting:-mo("⟦"),
                               Typesetting:-Typeset(Typesetting:-EV(args)),
                               Typesetting:-mo("⟧"),
                               Typesetting:-msemantics = "Unit"),
                               ':-open' = "⟦", ':-close' = "⟧",
                               Typesetting:-msemantics = "Unit");
       else
          Unit(args);
       end if;
    else
       Unit([args]);
    end if;
end proc:

Unit(m*kg/s^2);

simplify(%);

45*K*Unit(m*kg/s^2)+3*Unit(cm*kg/sec^2);

simplify(%);

# scheme 2, using a color.
`print/Unit` := proc()
    local Unit, res;
    if IsWorksheetInterface('Standard')
     or _EnvInRecursiveUnitsModulePrint = true then
       if member(convert(kernelopts(':-version'),string)[1..10],
                 ["Maple 2015","Maple 2016","Maple 2017"]) then
          subsindets(Typesetting:-Typeset(Typesetting:-EV(:-Unit(args))),
                     specfunc(anything,{Typesetting:-mfrac,
                                        Typesetting:-mi,
                                        Typesetting:-mo}),
                     u->op(0,u)(op(u),mathcolor = "Green"));
       else
          Unit(args);
       end if;
    else
       Unit([args]);
    end if;
end proc:

45*K*Unit(m*kg/s^2)+3*Unit(cm*kg/sec^2);

simplify(%);

Unit(m*kg/s^2);

simplify(%);