Update - solution
It seems, a valid pattern is been indicated by the following picture, where your values $q$ are ordered in a binary (or ternary?) tree:
(remark, your sequence $q$ occurs when reading the yellow marked numbers from the first row from left to right and row by row beginning at index $1$)
I've sometimes seen sequences which have such a "binary tree" pattern. If it is really appropriate for your problem, this knowledge might be helpful to detect a generating formula. If this pattern is indeed correct, then I have a simple function to determine the value of $q$ at any index:
\\ program in Pari/GP
{getQ(idx)=local(b,a);
b=binary(idx); \\ b becomes vector with bits of value idx
a=1;for(k=2,length(b), if(b[k]==1, a=3*a+2^(k-1)));
return(a); }
checking:
getQ(3) \\ gives value 5
getQ(5) \\ gives value 7
getQ(25) \\ gives value 31
getQ(211) \\ 527
getQ(255) \\ 6305
first 12 values:
vector(12,r,getQ(r))
\\ output: [1, 1, 5, 1, 7, 5, 19, 1, 11, 7, 29, 5]
old text of answer
Unfortunately I didn't see how to implement computation of the squence of q's so I couldn't make it more likely that this binary pattern actually exists.
The numbers $1,5,19,65,211,...$ are likely best interpreted as differences of the type $3^n-2^n$ And many other numbers can be described as other difference of powers of 3 and 2, like
9 11 49 7 37 29
27-8 27-16 81-32 9-2 64-27 32-3
Also, $1,7,29,103,341,...$ can be described as $1$, $7=3\cdot 1+4$, $29= 3\cdot 7+8$, $103 = 3 \cdot 29+16$, $341 = 3\cdot 103 + 32$, $...$ but I think it is too much for me at the moment to proceed here.
If we follow the right-down arrows (black and grey) then there is a so simple pattern that I'm sure this is the best way to define the tree (and from this the sequence)
I've just copied the first 256 numbers
$q$ from the linked list in the OP. See:
0, 1, 1, 5, 1, 7, 5, 19, 1, 11, 7, 29, 5, 23, 19, 65, 1, 19, 11, 49, 7, 37,
29, 103, 5, 31, 23, 85, 19, 73, 65, 211, 1, 35, 19, 89, 11, 65, 49, 179, 7, 53,
37, 143, 29, 119, 103, 341, 5, 47, 31, 125, 23, 101, 85, 287, 19, 89, 73, 251, 65,
227, 211, 665, 1, 67, 35, 169, 19, 121, 89, 331, 11, 97, 65, 259, 49, 211, 179,
601, 7, 85, 53, 223, 37, 175, 143, 493, 29, 151, 119, 421, 103, 373, 341, 1087, 5,
79, 47, 205, 31, 157, 125, 439, 23, 133, 101, 367, 85, 319, 287, 925, 19, 121, 89,
331, 73, 283, 251, 817, 65, 259, 227, 745, 211, 697, 665, 2059, 1, 131, 67, 329,
35, 233, 169, 635, 19, 185, 121, 491, 89, 395, 331, 1121, 11, 161, 97, 419, 65,
323, 259, 905, 49, 275, 211, 761, 179, 665, 601, 1931, 7, 149, 85, 383, 53, 287,
223, 797, 37, 239, 175, 653, 143, 557, 493, 1607, 29, 215, 151, 581, 119, 485,
421, 1391, 103, 437, 373, 1247, 341, 1151, 1087, 3389, 5, 143, 79, 365, 47, 269,
205, 743, 31, 221, 157, 599, 125, 503, 439, 1445, 23, 197, 133, 527, 101, 431,
367, 1229, 85, 383, 319, 1085, 287, 989, 925, 2903, 19, 185, 121, 491, 89, 395,
331, 1121, 73, 347, 283, 977, 251, 881, 817, 2579, 65, 323, 259, 905, 227, 809,
745, 2363, 211, 761, 697, 2219, 665, 2123, 2059, 6305, ...
It seems a representation as numbers $6k \pm 1$ or $6k+1$,$6k+5$ could be helpful.
Best Answer
These numbers come from explicitly writing out the iterates of the Collatz function and seeing, from that, which numbers have which stopping times. If you want to condense the property being discussed, it's as follows: we can compute that $$c^q(x\cdot 2^q+p)=\alpha x + \beta$$ for some integer constants $\alpha$ and $\beta$. If $\alpha < 2^q$, then, for all great enough $n$ equivalent to $p$ mod $2^q$, we will have $c^q(n) < n$ - and we can use this to create the sort of statements in your question.
It's best to illustrate this with an example. To see that the stopping time of $32x + 11$ is $5$ (for the $c$ in the question*), one could calculate: $$c(32x+11) = 48x + 17$$ $$c^2(32x+11) = 72x + 26$$ $$c^3(32x+11) = 36x + 13$$ $$c^4(32x+11) = 54x + 20$$ $$c^5(32x+11) = 27x + 10$$ Where, for $x\geq 0$, it's clear that the first four iterates are greater than the input, and the fifth is less than the input - hence the stopping time is $5$. Note that we cannot compute the sixth iterate, since $27x+10$ could be either even or odd.
You can run a similar sort of calculation to explicitly get the first $q$ iterates of $c$ applied to $2^q\cdot x + p$ for any $p$ as a linear function of $x$ - and doing such a calculation might reveal the stopping time of numbers of that form (as it did in the example I gave).
If you wanted to generate the list they made in the paper, what you can do is calculate this for every possible mod $2$ residue, and note which residues have fixed stopping times. Then, of those residues which did not have fixed stopping times, you can split them into two residue classes mod $4$, and see if any of those have fixed stopping times (now being able to calculate one more iteration in the future). Then, you can split into residues mod $8$ and so on, until you are satisfied. Note that the number of residues remaining mod $2^q$ will grow exponentially (although the proportion of residues lacking a stopping time will decrease towards $0$).
You can be a bit more sophisticated with this, although it's not clear it would be useful for your application. If you fix the parities of the sequence $x, c(x), c^2(x),\ldots, c^{n-1}(x)$, there is a unique equivalence class mod $2^n$ such that $x$ in that class will have a trajectory with the specified parities - for instance, there is some mod $8$ equivalence class such that $x$ is even, $c(x)$ is odd, and $c^2(x)$ is even. You can note that, for $x$ in that class, we must have $c^n(x)=\alpha x + \beta$ for some rational $\alpha$ and $\beta$ - and can explicitly compute $$\alpha = (3/2)^{\text{# of odd steps in trajectory}}\cdot (1/2)^{\text{# of even steps in trajectory}}.$$ This can give the asymptotic results noted in the paper, but is probably not the most efficient way to generate a list of all classes that don't stop after some number of steps.
(*The paper you quote appears to use the version of the Collatz function that takes two steps to go from odd $x$ to $\frac{1}2(3x+1)$, so gets $8$ instead - but it's the same idea with that method, although it works somewhat less elegantly with that slower function)