Your answer to 1 is almost correct: It does not accept strings with zero $a$s such as $bc$. And it does not accept for example $acba$.
Try something like $$ [bc]^*(a[bc]^*a[bc]^*)^*$$
Based on this, you should have littel problems to find a regex for $4k$ number of $b$s and then $4k+1$ number of $b$s
For the third task, first solve "length equals $3$", then star
Let's look at your regular expression:
$$ (111)^* 011 \enspace. $$
It generates the strings $011$, $111011$, $111111011$, and so on. None of these words is such that every nonempty block of $1$s has odd length. Moreover, the total number of $1$s alternates between even and odd, contrary to your claim. Even if we had guaranteed blocks of $1$s of odd lengths, as in
$$ 1(11)^*01(11)^* \enspace, $$
our goal is not to describe some of the words in $L$, but all of them. This is not entirely trivial in this case; therefore let's take another, more systematic approach.
The strings in our language may start with any number of $0$s. So, we are going to use $0^*$ as a building block. A nonempty string of $1$s of odd length is given by $1(11)^*$. That's another building block for our regular expression. From $1(11)^*$ we get $1$, $111$, $11111$, and so on.
Finally, in between blocks of $1$s we can have any positive number of $0$s. That is, $00^*$. Let's now put these building blocks together:
$$ 0^* (1(11)^* 00^*)^* (1(11)^* + \epsilon) \enspace. $$
It's not the simplest regular expression out there, but we should be able to recognize the building blocks. We start with an optional block of $0$s. Then we have zero or more blocks of $1$s of odd lengths, each followed by one or more zeros. Finally, we have an optional block of $1$s (of odd length) not followed by $0$s to account for the fact that a word in $L$ may not have trailing $0$s.
This is not the only regular expression for $L$, as is often the case. If you have already seen Kleene's Theorem, you should know of the systematic procedure alluded to by John Hughes in his comment. For this $L$ it produces a regular expression of complexity comparable to the one above.
Best Answer
I think you are quite close. Although it is hard to accurately guess your intent from just a single expression, it looks like you are trying to capture the idea that once the string contains any $00$, it’s forced to contain only zeros from that point on. A simpler way to express that is just to end your expression with $0^*$ rather than $(000^* \cup \epsilon)$: adding any number of zeroes to the end of a valid string will not make it invalid.
This has the side effect of addressing your issue that the expression doesn’t represent $0$. But is that enough? The left half is responsible for encoding all strings that contain at most one consecutive zero, and do not end in zero. And that is indeed what it does: it allows for an empty string, but if it starts with a $0$ that must be immediately followed by a $1$, while if it starts with a $1$ then any valid string can follow. So with that small adjustment, your expression works.
It’s natural to find it harder to express arbitrarily regular languages as regular expressions rather than an automaton. For instance, even though regular languages are closed under complements, it is usually quite painful to negate the logic of a regexp, while negating a DFA is super easy.
One thing worth keeping in mind is that you could always express a language as a DFA and then apply the standard method for converting DFAs to a regular expression.