There is a recursive formula to count partitions which is fairly simple computationally but fairly weird mathematically (as recursive formulas go). Here it is coded in Maple:

restart:
nPart:= proc(n::integer)
option remember;
local k;
    if n<=0 then `if`(n=0,1,0)
    else
        -add(
            (-1)^k*(thisproc(n-k*(3*k-1)/2) + thisproc(n-k*(3*k+1)/2)),
            k= 1..floor((sqrt(24*n+1)+1)/6)
        )
    fi
end proc:

For large n, there are some more-complicated formulas that are faster. But the above isn't horribly slow for moderately large n.

I post this not because it's any better than combinat:-numbpart but because it's simple enough to have significant educational value.

You have 6 algebraic equations to fit 6 parameters. So it's very likely that the solution space is a 6 - 6 = 0-topological-dimension subset of C^6 (C = complex numbers), so the probability that there's an integer 6-tuple in that subset is infinitesimal. 

Note that you mistakenly used m in the solve command.

Here are four non-hackish ways to do it. The first, unapply, requires that the recurrence have a closed-form solution. The others have no such requirement.

The second, makeproc, requires that the recurrence be expressible as a single algebraic formula. The remaining two do not have that requirement, and they allow formulas and procedures of arbitrary complexity.

The third, module, is a very general technique that's important to learn. They're like classes in C++. Both the local and export variables retain their values between invocations, thus avoiding the need for globals. Nearly all large pieces of Maple code are written as modules.

The fourth, procname/thisproc, is also important to learn. It uses a technique called memoization: building a table matching all input with its output. Memoization can also be made automatic by giving a procedure option remember. In this technique, the procedure's own name takes the place of the global.

restart:
Last:= unapply(rsolve({f(n)=4*f(n-1)+n, f(0)=1}, f(n)), n):
seq(Last(k), k= 1..10);

restart:
Last:= rsolve({f(n)=4*f(n-1)+n, f(0)=1}, f(n), makeproc):
seq(Last(k), k= 1..10);

restart:
Last:= module()
local _Last, ModuleApply:= (k::posint)-> (_Last:= 4*_Last+k);
export Init:= N-> (_Last:= N);
end module:
Last:-Init(1):
seq(Last(k), k= 1..10);

restart:
Last:= (k::posint)-> (procname(k):= 4*thisproc(k-1) + k):
Last(0):= 1:
seq(Last(k), k= 1..10);

It can be done like this:

Ab:= Matrix(M$2):
Ab[[1,-1], ..]:= A[[1,-1], ..]:
Ad:= A - Ab;
 

You have more unknowns than equations, so a purely numeric solution is not possible. I assume that you want to solve for x[0], x[1], y[0], y[1]? A solution in terms of t can be easily obtained with solve:

Sol:= solve({eq||(1..4)}, {x[0], x[1], y[0],  y[1]});

Then you can get numeric solutions for a given t by (for example),

evalf([allvalues(eval(Sol, t= 1.2))]);

The environment variable printlevel controls the nesting level to which the results of statements within do-, if-, and proc-blocks are displayed. See ?printlevel.

Yes, it has occasionally happened for me that the kernel crashes (with the boxed message) but the Save is grayed out on the File menu. In those cases, clicking the X to the right of the worksheet's name on the tabs bar will bring up a Save File dialog. (If there's only one worksheet shown on the tabs bar, that X is all the way to right edge of the window.) Either way that you save the worksheet, you'll get that kernel crash message again, but you can ignore it.

The kernel crash message says you should close Maple entirely. In my experience, this is totally false, and it's only necessary to close the worksheet(s) attached to the crashed kernel. Not closing the GUI will save you a lot of time, especially if you have a lot of open worksheets. I've done this hundreds of times without any problem.

Ordinarily, when you use evalb(...=...) to test equality, it only checks whether the objects are absolutely identical, that is, that they are in fact the exact same object with only one memory address. Many common objects in Maple, such as regular sets, are called immutable, and there's an ongoing process (happening in the background such that the user is generally unaware of it) called automatic simplification that ensures that only one copy of each such object is stored. On the other hand, for objects considered mutable, multiple copies of them that are mathematically equal may exist. And, as I said, ordinarily evalb(...=...) will not say that such objects are equal. But, the object/module MultiSet overloads the = operator to bypass what ordinarily happens. You can see the overload procedure via

showstat(MultiSet:-`=`);

But, that overloading is not sophisticated enough (nor is there any existing mechanism in Maple by which it could be) to detect when you've constructed more-complicated structures which contain the MultiSets.

I'd guess that the issue with the file saving is just a case of read/write permissions. It seems unlikely to me that it has anything to do with the content of the file. To test that theory, try 

X:= 7;
save X, "file.m";
restart:
read "file.m":
X;

After 3 years, here is a solution using LPSolve for 10 deliveries with more than 1 truckload. (VV's combinatorial solution is for 8 deliveries. Brian's ILP solution is only of the 1-load TSP (i.e., travelling salesman problem = 1 load) subproblem.) The truck is required to return to the warehouse when it's finished each round of deliveries. The worksheet below specifically shows the solution for 2 loads (truck capacity K = 100). To increase the number of loads, set the value of K lower. 
 

Download VehicleRoutingILP.mw

Do you mean something like this?

unapply([for k to 3 do x^k od], x);

This uses syntax new to Maple 2019. The example above would be better done with seq, but there are more-elaborate examples where a do-loop (or for-loop) works and seq doesn't. There are also cases where seq is the less-efficient option.

I would've given the same answer as Joe and Acer if I'd gotten to it in time. I'll add that the same level of type checking can also be applied to the return value of a procedure:

P:= proc()::posint; 0 end proc:  

P(); #error when assertlevel is set to 2

But mostly I want to draw your attention to the distinction between types and properties because I think that you may be referring to the latter. Types are inherent to data structures (i.e., anything that you can assign to a variable): Given any structure x and any type t, type(x,t) should return true or false; nebulous or ambiguous cases should be avoided when coding t.

Properties, on the other hand, can be given to symbolic variables (i.e., names) with assume and related commands. Some "property-aware" commands will respect the properties, but most commands will ignore them.

Maple's type system is highly developed, but the property system is nascent and has been so AFAIK since created by Gaston Gonnet, et al, many years ago. My guess is that making significant improvements to the system would require redesign of Maple from the ground up. I believe that the strongly typed "free" CAS named Axiom has something like this implemented. Maybe it'd be possible to get Maple and Axiom to interact?

Use:

cat("", V, ".xls")

The plot3d command needs more quotes. This works:

plot3d(['f(x,y,'g(x, y)')'], x=0..1,y=0..1)

Use

f~([$0..5])

If you put % immediately before an operator, it makes it inert. So, you can do a %/ b * c, and it'll display like you want. The inertness will remain until you use the value command.

Unfortunately, you do need to use some special syntax to get things to display as you want.

If an ! appears in the first column of input, it's a shell escape, equivalent to a system command. See ?system.