I notice some striking similarities between this question and the following two:

 - [Calculating a sequence of functions using iteration][1]
 - [Multiple generators for iterative construction of fractals][2]

Presumably, the user is the same, which conceals information about your mathematical and programming background - information that's useful to potential answers. Nonetheless, the question is interesting, so here's a go.

As I understand it, you're simultaneously generating two functions $y(x)$ and $z(x)$ on $[0,1]$. The $n^{\text{th}}$ approximations $y_n(x)$ and $z_n(x)$ are piecewise linear functions starting with $y_0(x)=z_0(x)=x$. You have two partitions of $[0,1]$, namely
$$0<a_1<a_2<\cdots<a_8<1$$
and
$$0<c_1<c_2<\cdots<c_8<1.$$
Each of $y_n(x)$ and $z_n(x)$ will be constructed by first randomly choosing one of those partitions (one for $y$ and one for $z$) and then placing scaled copies of either $y_{n-1}$ or $z_{n-1}$ (also chosen randomly and independently for each sub-interval) over each of the nine sub-intervals in the partition.

The main problem with your code, is that you're repeating tremendous amounts of code, rather than encapsulating repetitive stuff into functions. For example, you define `y0`, `y1`, `y2`, `y3`, and `y4` using the exact same code with suitable replacements. Why not define a *function* and then recursively define `y[n]`? 

Here's one approach:

 (* Your as and cs *)
 (* One partition will be randomly chosen for each step *)
 partitions = {
 Partition[{0.0, 0.25, 0.28, 0.3, 0.32, 0.7, 0.73, 0.78, 0.8, 1.0}, 2, 1],
 Partition[{0.0, 0.2, 0.25, 0.28, 0.32, 0.6, 0.7, 0.8, 0.83, 1.0}, 2, 1]
 };
 (* Your bs and ds *)
 compressions = {
 Partition[{0, 0.4, 0.22, 0.26, 0.1, 0.8, 0.6, 0.8, 0.6, 1}, 2, 1],
 Partition[{0, 0.45, 0.3, 0.45, 0.2, 0.75, 0.65, 0.7, 0.6, 1}, 2, 1]
 };
 transform[f_, x_, {a1_, a2_}, {b1_, b2_}] := 
 (b2 - b1)*(f /. x -> (x - a1)/(a2 - a1)) + b1;
 next[{y_, z_}, x_] := With[{
 part = RandomChoice[partitions],
 bs = RandomChoice[compressions]},
 Piecewise[Table[
 {transform[RandomChoice[{y, z}], x, part[[k]], bs[[k]]], 
 part[[k, 1]] <= x <= part[[k, 2]]},
 {k, 1, Length[partitions[[1]]]}]]];

Note that `next` accepts two *expressions* of `x`, rather than functions. It then returns a single `Piecewise` defined expression. The recursion can be implemented as follows:

 Clear[y, z];
 y[0] = z[0] = x;
 y[n_] := y[n] = next[{y[n - 1], z[n - 1]}, x];
 z[n_] := z[n] = next[{y[n - 1], z[n - 1]}, x];

We now graph it.

 GraphicsGrid[Table[Plot[#, {x, 0, 1}] & /@ {y[n], z[n]}, {n, 1, 4}]]

An alternative approach is to use functional iteration.

 step[{y_, z_}, x_] := {next[{y, z}, x], next[{y, z}, x]};
 iterated = NestList[step[#, x] &, {x, x}, 4];
 GraphicsGrid[Map[Plot[#, {x, 0, 1}] &, Rest[iterated], {2}]]

In either case, the graphs look like so:

![enter image description here][3]


 [1]: https://mathematica.stackexchange.com/questions/38555/calculating-a-sequence-of-functions-using-iteration
 [2]: https://mathematica.stackexchange.com/questions/55269/multiple-generators-for-iterative-construction-of-fractal
 [3]: https://i.sstatic.net/zfiTI.png