given a text choose letters from it in a way that ...

Two common interpretations exist.

1) Letters can be picked in any order

Then the answer is just the bottleneck count:

$$\text{max\_svo} = \min(\#s,\#v,\#o)$$

Because every "svo" needs exactly one s, one v, and one o.

Complexity

• Time: O(n)
• Space: O(1)

Python

python
def max_svo_any_order(text: str) -> int:
    s = v = o = 0
    for ch in text:
        ch = ch.lower()
        if ch == 's':
            s += 1
        elif ch == 'v':
            v += 1
        elif ch == 'o':
            o += 1
    return min(s, v, o)

---

2) Letters must keep their order in the original text

Then you want the maximum number of disjoint subsequences equal to "svo".

The optimal greedy strategy is:

• count unfinished "s" groups
• count unfinished "sv" groups
• when you see:
  • s: start a new group
  • v: attach it to an existing s if possible
  • o: attach it to an existing sv if possible and complete one "svo"

Why this is optimal

Using a v as soon as possible on an available s, and using an o as soon as possible on an available sv, never reduces future options. Delaying only risks wasting characters.

Complexity

• Time: O(n)
• Space: O(1)

Python

python
def max_svo_in_order(text: str) -> int:
    s_waiting = 0   # number of partial groups: "s"
    sv_waiting = 0  # number of partial groups: "sv"
    completed = 0

    for ch in text:
        ch = ch.lower()

        if ch == 's':
            s_waiting += 1

        elif ch == 'v':
            if s_waiting > 0:
                s_waiting -= 1
                sv_waiting += 1

        elif ch == 'o':
            if sv_waiting > 0:
                sv_waiting -= 1
                completed += 1

    return completed

Example

python
text = "ssvovosvo"
print(max_svo_in_order(text))   # 2

---

Most likely intended answer

For a text string, “choose letters from it” usually implies preserving order, so the best efficient solution is:

python
def solve(text: str) -> int:
    s_waiting = 0
    sv_waiting = 0
    completed = 0

    for ch in text:
        if ch == 's':
            s_waiting += 1
        elif ch == 'v' and s_waiting:
            s_waiting -= 1
            sv_waiting += 1
        elif ch == 'o' and sv_waiting:
            sv_waiting -= 1
            completed += 1

    return completed

That is optimal and runs in O(n) time with O(1) memory.

If you want, I can also give the same solution in C++, Java, or explain the proof more formally.