Itera la cadena solo una vez.

Itera la cadena y con un condicional revisa si el caracter actual es 'G' o 'g', si se cumple, no imprimas ese caracter.

Si usas Python o Java puedes usar el método .replace() y sustituir las 'G' y 'g' con el caracter vacío ''

#include<stdio.h>
#include<string.h>

#define or ||

void solve(){
    int n; scanf("%d",&n);
    char str[n+1];
    scanf("%s",str);

    for(int i=0; i<n; i++){
	if(str[i] == 'G' or str[i] == 'g'){
	    continue;
	}

	printf("%c",str[i]);
    }
    printf("\n");
}

int main(){
    solve();
    return 0;
}

n = int(input())
s = input()

print(s.replace('G','').replace('g',''))

$$$r = \sqrt{(x-u)^2+(y-v)^2}$$$

Donde $$$x$$$ e $$$y$$$ son el centro de cualquier círculo y $$$u$$$ y $$$v$$$ son cualquier punto al que Zum tira un dardo.

Sea $$$r_{act}$$$ el radio del punto actual al centro de cualquier círculo y $$$r$$$ el radio de un círculo. Si $$$r_{act} \lt = r$$$, entonces el punto actual está dentro del círculo de radio $$$r$$$.

Para cada dardo que tira Zum, debemos calcular su distancia con respecto al centro de ambos círculos mediante la fórmula de la distancia euclidiana, nos evitaremos sacar la raíz cuadrada manejando el cuadrado de todos los términos. La distancia al centro del círculo grande es: $$$D_i^2 = (u_i - x_1)^2 + (v_i - y_1)^2$$$. Y la distancia al centro del círculo pequeño es $$$d_i^2 = (u_i - x_2)^2 + (v_i - y_2)^2$$$. Si $$$d_i^2$$$ es menor o igual que el radio del circulo pequeño al cuadrado, llamémosle $$$r_1^2$$$ ($$$d_i^2 \leq r_1^2$$$), se imprime "YAAAAY!". Si esta condición no se cumple, revisamos la distancia al centro del círculo grande ($$$D_i^2 \leq r_1^2$$$), si se cumple, imprimimos "MEH", en caso contrario, terminamos imprimiendo "BUUUUU!".

Calcula la distancia de cada número a su primo más cercano simulando las dos operaciones.

Ordena esas distancias.

Primero debemos generar un arreglo del mismo tamaño que el arreglo original, es decir, tamaño $$$N$$$, llamemos a este arreglo dist[N]. Para cada elemento del arreglo original $$$a_i$$$, guardaremos en $$$dist_i$$$ la distancia a su primo más cercano. Vamos a dividir el número entre dos hasta llegar a cero, por cada división, vamos a revisar qué tan lejos está el número actual de un primo tanto hacia arriba como hacia abajo, mientras llevamos conteo del valor mínimo actual, es decir, si la división actual + su distancia al primo más cercano es menor que el valor que tenemos actualmente, lo actualizamos.

Una vez que tengamos todas las distancias calculadas vamos a ordenarlas con cualquier algoritmo de ordenamiento (que no sea Bogo Sort ;D) y nuestra respuesta será ir iterando en orden este nuevo arreglo, restándole la distancia actual a nuestra $$$K$$$, que es las operaciones que tenemos disponibles.

#include<stdio.h>
#include<stdbool.h>

#define and &&
#define MAX_VAL 1050 
#define ll long long
#define INF 200000000

int min(int a, int b){
    return a < b ? a : b;
}

void bubbleSort(int n, int *arr){
    for(int i=0; i<n-1; i++){
        for(int j=0; j<n-i-1; j++){
            if(arr[j] > arr[j+1]){
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j+1] = tmp;
            }
        }
    }
}

bool isPrime(ll n){
    if(n==1) return false;
    if(n==2) return true;
    if(n%2 == 0) return false;

    for(int i=3; i<n; i+=2){
	if(n%i == 0) return false;
    }

    return true;
}

int distToPrime(int n){
    if (isPrime(n)) return 0;
    
    int dist = 1;
    while(true){
        if (n - dist >= 2 && isPrime(n - dist)) return dist;
        if (isPrime(n + dist)) return dist;
        dist++;
    }
}

int distance(int n){
    int min_cost = INF;
    int divisions = 0;
    while (n > 0) {
        int cost = divisions + distToPrime(n);
        min_cost = min(min_cost, cost);
        
        n /= 2;
        divisions++;
    }
    
    int zero = divisions + 2; 
    min_cost = min(min_cost, zero);

    return min_cost;
}

void solve(){
    int n, k; 
    scanf("%d %d", &n, &k);
    
    int board[n], costs[n];
    for(int i=0; i<n; i++){
        scanf("%d", &board[i]);
	costs[i] = distance(board[i]);
    }


    bubbleSort(n, costs);


    
    int numPrimes = 0;
    for(int i=0; i<n; i++){
        if(costs[i] <= k){
            numPrimes++;
            k -= costs[i];
        }else{
	    break;
	}
    }

    printf("%d\n", numPrimes);
}

int main(){
    solve();
    return 0;
}

En programación competitiva no es usual que una solución así funcione, debido a que estamos probando por fuerza bruta muchas posibles distancias, así como checar uno por uno los números primos y como cereza en el pastel, estamos usando un ordenamiento burbuja, que no es un algoritmo eficiente para ordenar. Hay muchos temas involucrados para lograr una solución eficiente para este problema. Sin embargo, describiremos la solución que nosotros esperábamos para este problema y dejamos como ejercicio para el lector la lectura sobre estos temas.

En el caso de que los límites del problema fueran $$$1 \leq N,M,a_i, \leq 10^5$$$, la solución necesaria sería en cuanto a idea la misma, pero usaremos métodos distintos para lograrlo.

Primero, necesitamos precomputar todos los primos hasta el elemento más grande del arreglo. Para esto se utiliza un algoritmo llamado Criba de Eratóstenes, que nos devolverá una tabla que nos dirá si el i-ésimo número de la tabla es primo. Con el fin de consultar de forma rápida si cualquier número es primo mediante consultar la tabla.

Con esto podremos probar las distancias a los primos de forma rápida. Para ordenar, hay múltiples algoritmos eficientes que nos permiten ordenar. En la solución del ejemplo se usa el ordenamiento por conteo (Counting Sort).