Let $$$s$$$ be the maximum length of a job interval.

The algorithm has an approximation factor of about $$$(1 + \frac{x + 2 \cdot s}{y})$$$ (so it’s only helpful when we have $$$\max(x, s) \lll y$$$), and it works in the following manner:

Let’s first find an optimal assignment for $$$x=0$$$ (this is the standard machine assignment problem and can be solved in sub-quadratic time using a simple greedy algorithm).

You then run the following procedure:

m = number of machines required by optimal assignment for x = 0
v[m] = vector of assigned jobs for x = 0 (v[i] stores all intervals assigned to machine i)

i = 1   #index of the old machine we’re currently processing
p = 0   #pointer that we will use as the start of the break on the next machine
g = m   #number of machines used till now

while i <= m:
    if p == 0:
        g = g + 1
        we rent a new machine indexed g, initially assigned no jobs

    if some there exists some job [l, r] in v[i] such that l <= p < r, set p = r

    let J be the set of jobs in v[i] which intersect with [p, p + x]
    let Q be max(p + x, maximum rightbound in J (0 if J is empty))
    
    if y - Q < x:
        we assign a break interval [p, p + x] on machine g 
        p = 0
    else
        on machine i, reserve interval [p, p + x] for a break
        move all intervals in J from machine i to machine g
        p = Q
        i = i + 1

finally, if we havent assigned a break interval on the last machine, its alright as its guaranteed that [y - x, y] will be free on this machine

the required number of machines is g

That would be kind of awkward to explain in plain english (and there might be a few off-by-oneish bugs in the pseudo code, ignore them), so I hope the idea is self-evident. We're creating new machines so that we can freely assign breaks to the old ones in a cyclical manner, and are then able to transfer the displaced jobs to the new ones (while of course ensuring that the new machines also get break intervals).

What is the approximation factor? Notice that $$$p$$$ is only set back to $$$0$$$ after at least $$$\lfloor \frac{y}{x + 2 \cdot s} \rfloor - 1$$$ increments to $$$i$$$. In other words, we create a new machine for every $$$\lfloor \frac{y}{x + 2 \cdot s} \rfloor - 1$$$ old ones. So we use at most $$$\approx m \cdot (1 + \frac{1}{\lfloor \frac{y}{x + 2 \cdot s} \rfloor - 1}) \approx m \cdot (1 + \frac{x + 2 \cdot s}{y})$$$ machines (forgive my egregious use of $$$\approx$$$).

Since $$$m$$$ (required number of machines with $$$x = 0$$$) cannot be larger than the number of machines in the optimal assignment with whatever value of $$$x$$$ we're given, the approximation factor is at least as good as $$$(1 + \frac{x + 2 \cdot s}{y})$$$.

We can improve the constant factor(s) in the $$$(O(x) + O(s))/O(y)$$$ term through some cheap tryhard methods, but the general $$$(x + s)/y$$$ nature will still remain.