First, your function name could use a more clear name. arrayOfInt2string contains a lot of information but none of it makes it clear what the user of function actually is. decode_str is more clear. Likewise, array is a bad parameter. The data you're passing is a tuple, not an array. But regardless the type is not a good indicator of what it is. encoded_str would be clearer. As much as possible, come up with relevant names to make your script easier to read.

You can initialise b just using b = []. But even better would be to use a list comprehension. A list comprehension collapses a for loop into a single line expression to generate a list. In your case, you can create your whole b list in just one line like this:

        b = [chr(int(a[i:i+2], 16)) for i in range(0, len(a), 2)]

It basically flips the syntax of your for loop around. You have your expression for each element of b followed by the syntax of your for loop. If you really wanted to, both for loops could be collapsed this way, but that would probably read as too complicated to follow.

For your s assignment, you can use the += operator. It basically says to add whatever is on the right of the operator to the current value of s. It's shorthand to essentially do what your code already does.

        s += ''.join(b.reverse())

Using ''.join(b.reverse()) is not strictly necessary. You can use the slicing operator to reverse it in a shorter line. You've used the slicing operator elsewhere, but you may or may not be aware of the third parameter it takes called the step parameter. It basically tells Python what amount to increment each step by, similar to the third parameter you pass to range. You can pass a negative value to start at the end and go backwards, so you can flip b like this: b[::-1].

Marc's answer is an excellent option if you don't care about validation.

If you need to be somewhat sure that the given string represents one of the known formats, then you can pre-bind a match method in a list of pre-compiled regular expressions:

import re
from typing import Iterable

lottery_searches = [
    re.compile(pat).match
    for pat in (
        r'^(\d+)-(\d+)-(\d+)-(\d+)-(\d+), Mega Ball.*$',
        r'^(\d+)-(\d+) \+ (\d+)-(\d+)$',
        r'^(\d+)-(\d+)-(\d+)-(\d+)-(\d+)$',
    )
]


def lottery_string_to_ints(lottery: str) -> Iterable[int]:
    for search in lottery_searches:
        match = search(lottery)
        if match:
            return (int(g) for g in match.groups())

    raise ValueError(f'"{lottery}" is not a valid lottery string')

with output

In[2]: tuple(lottery_string_to_ints('03-23-27-34-37, Mega Ball: 13'))
Out[2]: (3, 23, 27, 34, 37)

In[3]: tuple(lottery_string_to_ints('01-12 + 08-20'))
Out[3]: (1, 12, 8, 20)

In[4]: tuple(lottery_string_to_ints('04-15-17-25-41'))
Out[4]: (4, 15, 17, 25, 41)

In[5]: tuple(lottery_string_to_ints('04-15'))
Traceback (most recent call last):
  File "262933.py", line 20, in lottery_string_to_ints
    raise ValueError(f'"{lottery}" is not a valid lottery string')
ValueError: "04-15" is not a valid lottery string