I want to build a wall, 100.0 m. max, by laying blocks end to end. The blocks are 4.5-53.7 m long. Their total length is longer than the wall but I cannot shorten them. Is there an algorithm to select the blocks that will give me the longest wall?

I'm going to describe a general mathematical technique to solve these kinds of problems called Mixed Integer Programming (MIP). You can solve these problems using Excel's Solver, but there are specialized solvers that are more efficient (GLPK's free, CBC requires programming, SCIP is excellent but only free for academic use, and CPLEX/MOSEK/Gurobi are commercial). Suppose each block [math]i[/math] has a length [math]l_i[/math], and that there are [math]n[/math] blocks. The total length [math]L[/math] is given as: [math]L = \sum_{i=1}^{n} l_i \cdot \delta_{i}[/math] where [math]\delta_i \in \{0,1\}[/math] are binary decision variables to be decided by the optimizer. In Excel, these would be cells with integer restrictions and range [0,1]. We can write an optimization problem as follows: [math]\max L[/math] subject to [math]L = \sum_{i=1}^{n} l_i \cdot \delta_{i}[/math] [math]L_{L} \leq L \leq 100[/math] where [math]L_{L}[/math] is some lower-bound for [math]L[/math]. Usually we can set this lower bound to some length obtained through a naive configuration of blocks -- this just tells the optimizer to quickly discard solutions that aren't at least as good as a naive configuration, and only consider solutions that are as good or better. This narrows the solution space and speeds up the solution process. This can be trivially set to the longest block (53.7m) because any solution must AT LEAST be equal to or longer than that. If you can piece together a few blocks (either randomly or using some heuristic), and say, get 93.2m or something, you should use that as the lower bound. The tighter the lower bound, the faster the solution process (generally). The algorithm complexity depends on various factors, and while it is NP-hard (with full enumeration being the worst case), many solvers can generally do far, far better on average. The optimizer will then return a set of [math]\delta_i[/math] denoting the blocks that need to be put together to build the wall (the admissible blocks are those with values of [math]\delta_i=1[/math]). The solution obtained is mathematically rigorous, and the global optimum is guaranteed. Of course, this method is not amenable to computation by hand, but I thought I'd just throw it out there.

Maybe not the most computationally efficient or elegant solution but why not try using a Monte-Carlo style random walk? For n trials, you can pick any number of blocks and keep adding their lengths until your total length ls close to or equal to 100m.  After you iterate through your n trials, you can return the solution that best approaches 100m. You can start off with a high value for n and then observe the results. An accessible tutorial on random walk algorithms can be found on 's site where he illustrates methods of burning a large number of folders to the smallest number of DVDs http://www.matpalm.com/burn.it/

This looks a bit like a classic bubble sort but using a different criterion for whether you swap item xi with xj.  I think the following covers all the cases and will enable you to write code in the language of your choice You don't even have to do an initial sort.  Initialize the wall length, L, to 0.  Initialize the Used property of each block to 0.  Proceed down the list of blocks, changing the Used property of each from 0 to 1 and adding the block's length to L, until L is greater than the target Length, T.  Now loop over all the blocks and for each block, If  If the block is Used, test whether (L - the Used block's length) is closer to T than the current value of L.  If so, change the block's Used property to 0 and change L. Else. If (L + the unUsed block's length) is closer to T,  change the block's Used to 1 and change L Else loop over all the blocks with Used=1.  If (L - the Used block's length + the unUsed block's length) is closer to T, swap the Used properties of the two blocks and change L. Unfortunately, once through the list won't necessarily give the best.  To test for convergence, at the end of each loop through all the blocks, store the value for L, say as L_last.  Quit at the end of a loop when L = L_last. Edit:  This fails for the case that the first block is 91 feet long and the next 10 blocks are all 10 feet long.  This is pathological & could be solved by inspection without needing a program.  But it illustrates a general case where the next improvement requires replacing 1 block by N blocks.  As with many optimization problems, the next step is to repeat the whole program, starting with a different randomized order for the blocks.  Do this many times, keeping track of the best solution so far.  This could be called the Monte Carlo piece.  If you find a piece where L=T, you've found a solution.  There may be other solutions.  If you try 1000 times and never get a solution with L=T, there's no guarantee that there are not better solutions.