Buscar el ultimo espacio en blanco podria fallar si la frase tiene solo 1 palabra, sin espacio alguno.

Tal vez resulte mejor poner un puntero al final y devolverse hasta llegar o al inicio de la palabra o bien a un espacio en blanco.

Si ese metodo void produce un cambio de estado de un objeto, puedes preguntar el estado del objeto justo despues de efectuar la llamada al metodo que pruebas y compruebas que el cambio esperado se ha producido.

Hay que tener cuidado con exponente 0 o negativo.

Se puede iterar menos veces si en vez de multiplicar siempre por la base, se eleva al cuadrado y se divide el exponente por la mitad, multiplicando ese valor por el resultado final cuando el valor del exponente es impar.

Tu clase Entrada dice ser un tipo de Cine (extran~o para mi, pero bueno, aceptando esto...)
Tu clase Entrada ademas TIENE un cine dentro (s1).
Cuando estableciste el costo, lo hiciste con la Entrada, pero cuando calculas el pago, le pides al cine s1 que te de' el costo. El cine s1 no tiene la informacion de costo explicita.

Una alternativa a lo dicho: puesto que la restriccion solamente es que los datos esten en un vector, propongo que en vez de insertar los datos en posiciones sucesivas, y en vez de ordenar antes de comenzar a sacar elementos del inicio, podria irse creando un heapmin. Con esto, siempre se obtiene el elemento minimo en O(1), por lo que se parece a lo ya propuesto. Sucesivas remociones de este arreglo toman a lo mas O(log(n)) donde n es el tamano del arreglo de donde se obtiene ese minimo.

Puesto que se esta removiendo elementos, el tiempo deberia ser:
O(log(tamanoA)^2) + O(log(tamanoB)^2).

La creacion del arreglo final puede seguir la misma idea que se ha propuesto aqui.

El enunciado no indica que los vectores que se ingresan estan ordenados, que parece ser asumido por las soluciones presentadas.

y si esta condicion

if( (v[j].sexo == 'f') && v[j].handicap > v[j+1].handicap ){
 

la cambias por

if(( (v[j].sexo == 'f') && v[j+1].sexo == 'm')) || 
      ((v[j].sexo == v[j+1].sexo) && v[j].handicap > v[j+1].handicap) ){

Cambia algo?

Haz un ciclo de 3 vueltas y calcula i y j como lo estas haciendo y luego asigna la posicion indicada por i y j. El ciclo dentro del ciclo que tienes, eliminalo.

Lo malo que tiene esto es que es posible que se repita i y j de una iteracion a otra.
Una posible solucion es iterar hasta que el lugar indicado por i y j este vacio, por 3 veces.

Sugiero incluir los #include (relevantes) que estas usando.

Tal vez si construyes un programa minimo que muestre el error en vez de recortar pensando que lo que recortaste no tiene relevancia?

2 ciclos anidados de 1 a 6,
suma los indices, y cada vez que calce con el numero ingresado, incrementas un contador, el que convenientemente partio en 0.

La probabilidad final es lo que tenga ese contador dividido por 36, el numero total de posibilidades multiplicado por 100.

Al dividir, en vez de usar 36, conviene usar 36.0 para forzar el uso de punto flotante.