@Preben Alsholm & @Carl Love Thanks again. 
Maybe the real time just depends upon the chronological order of codes. When I run the zip version first, `~` is slower instead: (But it seems to me that the first call almost always uses more memories.) 
 

Download `_`_and_zip.mw

@Preben Alsholm Thanks for your reply. Surely their respective domains of operation are different, but I am intrigued to know when `~` and map do the same thing, why the latter is less efficient here. (Is this just determined by the computer's performance?)

@Christian Wolinski Many thanks. I think that this doesn't work on the trivial case x = [].

@Carl Love Thanks very much. I shall think it over later.

And what about other two commands? Contrary to my expectations, they do not do the same thing (at least here). 

@Oliveira I find an instance such that _Z1 ≠ _Z1: 

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

restart;
op([-1, -1], Invfunc[cos](0)):
ToInert(%);

The return value is always _Inert_LOCALNAME("_Z1~", ```different number```), which is surely distinct from the ToInert(_Z1).

@nm Thanks. As regards the series solutions, if an "exact" general solution is available, we can utilize the asympt function later, but if the symbolic solver is stuck… 
An instance that both Maple and Mathematica cannot solve: 

dsolve({t^2*diff(diff(z(t),t),t)+log(t)^2*z(t)=0},z(t),type='series',t=infinity):
AsymptoticDSolveValue[t^2*Derivative[2][z][t]+Log[t]^2*z[t]==0,z[t],t->Infinity];

@nm It's a undocumented internal function, so use of Holonomic`DifferentialAsymptoticSeries is somewhat discouraged. 

In addition, unfortunately, 

dsolve({t^6*diff(diff(z(t),t),t)+2*t^5*diff(z(t),t)-4*z(t)=0},z(t),'series');

returns nothing (in other words, Maple is unable to find symbolic solution), but Mma's AsymptoticDSolveValue is still capable of solving it. (I don't why.)

@nm Actually, one can obtain (almost) the same results in Mma: 

Series solutions from MatLab's ode::series (just for comparison): 

@Carl Love & @mmcdara Thanks. 

In my opinion, Mathematica's Apply is technically not identical with Maple's apply. Compare:

(* Mma *)
Construct[f, a, b, c];
(* Maple *)
apply(f, a, b, c):

 and 

(* Mma *)
Apply[f, {a, b, c}];
(* Maple *)
`?()`(f, [a, b, c]):

@Carl Love Well, maybe the better term is "ordered pair" rather than "rule" (let alone "function"). (A bijection is dispensable.)
Here is the result from Mathematica: 

@Christian Wolinski, @mmcdara, and @Carl Love 
Thanks. But if we add a new rule f＝g (which gives an additional cycle), the results will go wrong.

@lcz 

eval(reduce(uneval(SubstituteAll), [s, seq(uneval(L1[k], L2[k]), k = 1 .. length['shortname'](L1))]));
 = 
  "{ {0, 1}, {1, 2}, {1, 10}, {2, 3}, {3, 4}, {4, 5},

    {4, 9}, {5, 6}, {6, 7}, {7, 8},{8, 9}, {10, 11}, {11, 12},

    {11, 16}, {12, 13}, {13, 14}, {14, 15}, {15, 16}}"

@Carl Love Actually, as I mentioned before, sometimes such a list does perform a permutation, but in my opinion, we do not need to regard it as a permutation. 
Here we convert one cycles into (another) rules: 

cycles := [[g, d, c], [e, a], [f, d, c], [b]]:
use ListTools in rules := (combinat['randperm']@MakeUnique@curry(`?()`,`=`)~@FlattenOnce)([seq(Transpose([k,Rotate(k,1)]),k  in  cycles),[[a,b](*,[f,g]*)]]) end use: # a = b obfuscates the rules here.

Yet I have no idea how to reconvert rules back into cycles. 
Comparison: 
 

Download trivial.mw

@Carl Love Sorry, I don't know if such algorithms exist. This instance is adapted from the last example of MMA's Apply (which is more or less similar to Maple's `?()`). Unfortunately, the original function that occured in the help page only has limited functionalities. (So it is incorrect in general.)