We consider networks of processes which interact with beeps. In the basic model defined by Cornejo and Kuhn, which we refer to as the BL variant, processes can choose in each round either to beep or to listen. Those who beep are unable to detect simultaneous beeps. Those who listen can only distinguish between silence and the presence of at least one beep. Stronger variants exist where the nodes can also detect collision while they are beeping (B_{cd}L) or listening (BL_{cd}), or both (B_{cd}L_{cd}). Beeping models are weak in essence and even simple tasks are difficult or unfeasible with them. This paper starts with a discussion on generic building blocks (design patterns) which seem to occur frequently in the design of beeping algorithms. They include multi-slot phases: the fact of dividing the main loop into a number of specialised slots; exclusive beeps: having a single node beep at a time in a neighbourhood (within one or two hops); adaptive probability: increasing or decreasing the probability of beeping to produce more exclusive beeps; internal (resp. peripheral) collision detection: for detecting collision while beeping (resp. listening); and emulation of collision detection: for enabling this feature when it is not available as a primitive. We then provide algorithms for a number of basic problems, including colouring, 2-hop colouring, degree computation, 2-hop MIS, and collision detection (in BL). Using the patterns, we formulate these algorithms in a rather concise and elegant way. Their analyses (in the full version) are more technical, e.g. one of them relies on a Martingale technique with non-independent variables; another improves that of the MIS algorithm (P. Jeavons et al.) by getting rid of a gigantic constant (the asymptotic order was already optimal). Finally, we study the relative power of several variants of beeping models. In particular, we explain how every Las Vegas algorithm with collision detection can be converted, through emulation, into a Monte Carlo algorithm without, at the cost of a logarithmic slowdown. We prove that this slowdown is optimal up to a constant factor by giving a matching lower bound.

The following simulations by machines equipped with a one-way input tape and additional queue storage are shown: Every nondeterministic single-tape Turing machine (no separate input-tape) with time bound $t(n)$ can be simulated by one queue in $O(t(n))$ time. Every deterministic machine with a one-turn pushdown store can be simulated deterministically by one queue in $O(n\sqrt{n})$ time. Every Turing machine with several multidimensional tapes accepting with time bound $t(n)$ can be simulated by two queues in $O(t(n) \log^2 t(n))$ time. Every deterministic Turing machine with several linear tapes accepting with time bound $t(n)$ can be simulated deterministically in time $O(t(n) \log t(n))$ by a queue and a pushdown store. The first two results appear to be the first subquadratic simulations of other storage devices by one queue.

We consider the computer generation of random binary search trees with n nodes for the standard random permutation model. The algorithms discussed here output the number of external nodes at each level, but not the shape of the tree. This is important, for example, when one wishes to simulate the height of the binary search tree. Various paradigms are proposed, including depth-first search with pruning, incremental methods in which the tree grows with random-sized jumps, and a tree growing procedure gleaned from birth-and-death processes. The last method takes $O(\log^{4} n)$ expected time.

The game of Checkers can easily be generalized to be played on an N by N board and the complexity of deciding questions about positions regarded as a function of N. This paper considers mainly the question of whether a particular player can force a win from a given position and also the question of what is the best move in a given position. Each of these problems is shown to be complete in exponential time. This means that any algorithm to solve them must take time which rises exponentially with respect to some power of N and moreover that they are amongst the hardest problems with such a time bound.For instance if there are any problems solvable in exponential time but not in polynomial space, then these two problems are amongst them.

The worst possible storage fragmentation is analysed for two commonly used allocation strategies. In the case of the first fit system, fragmentation is not much worse than is inevitable but for the best fit system, it is almost as bad as it could be for any system.

The amount of store necessary to operate a dynamic storage allocation system, subject to certain constraints, with no risk of breakdown due to storage fragmentation, is considered. Upper and lower bounds are given for this amount of store, both of them stronger than those established earlier. The lower bound is the exact solution of a related problem concerning allocation of blocks whose size is always a power of 2.

Dynamic storage allocation using fixed blocks is usually inefficient in its use of store.The amount of store needed depends on the allocation strategy used.It is proved that for any strategy the amount of store needed is bounded below by a function which rises logarithmically with the size of blocks used.A certain strategy is shown to exceed this bound by a factor of at most 13/4.The exact amount of store needed is found for the case when blocks have sizes 1 and 2 only.