Una fuerza bruta "de valores" prueba valores, así que si hay millones de situaciones posibles puede que necesites guardar millones de variables.
Ejemplo: Se le muestra el número 0 y debe decir el mismo número pero el programa no sabe eso.
Prueba el 0, sirve, crea la variable Situacion0=0, o sea, cuando el número es 0 decir 0.
Se le muestra el número 1. Prueba el 0, no sirve, prueba el 1, crea la variable Situacion1 = 1, etc, etc.

En cambio una "de métodos" prueba métodos, lo cual supongo reduce la cantidad de información que debe quedar guardada.
Ejemplo: Se le muestra el número 0 y debe decir eso*3 pero el programa no lo sabe.
Prueba hacerle *0, sirve (porque 0*3 también es 0).
Siguiente situación, se le muestra 1.
Le hace *0, no sirve.
Se vuelve a la 1er situación, pero ahora prueba *1. Sirve.
Siguiente situación: 1, le hace *1, no sirve.
Se vuelve a la 1er situación, pero ahora prueba *2. Sirve.
Siguiente situación: 1, le hace *2, no sirve.
Se vuelve a la 1er situación, pero ahora prueba *3. Sirve.
Siguiente situación: 1, le hace *3, sirve.
Y así va a seguir probando todas las situaciones que se requieran, siempre va a servir y entonces la fuerza

crea Solucion = Numero*3

Quiero aprender a programar fuerza bruta "de métodos" y por eso pregunto cuales serían los ejercicios más sencillos para empezar.

Lo había hablado con la IA pero necesito algo más sencillo. Lo 1ero que me dijo fue un robot en un laberinto pero supongo que hay cosas más sencillas.
https://share.google/aimode/ZojJzrjPaAkS3xcgK

La IA me dijo una "optimización" que usa 2 whiles pero sigue usando ifs así que la descarté.

Más allá de eso mejoré el código, ahora varía el operador:

// Se buscará fórmula para obtener un número N...
// a partir de él mismo usando un operador y PostOperador:
// ¿Cual debe ser el operador y PostOperador para que...
// N Operador PostOperador == N?
SolucionHallada = false;
Operadores = ["+", "-", "*", "/", "-N", "/N"];
PostOperador = -10;
while (SolucionHallada == false) {
	SolucionHallada = true;
	PostOperador++;
	NroDeOperador = -1;
	do {
		NroDeOperador++;
		Operador = Operadores[NroDeOperador];
		N = -1;
		do {
			N++;
			trace("Probando "+Operador+PostOperador+" para N "+N);
			// Vemos si Operador y PostOperador sirven al actual valor de N:
			if (Operador == "+") {
				Resultado = N+PostOperador;
			} else if (Operador == "-") {
				Resultado = N-PostOperador;
			} else if (Operador == "*") {
				Resultado = N*PostOperador;
			} else if (Operador == "/") {
				Resultado = N/PostOperador;
			} else if (Operador == "-N") {
				Resultado = PostOperador-N;
			// } else if (Operador == "/N") {
			} else {
				Resultado = PostOperador/N;
			}
			if (Resultado == N) {
				trace(Operador+PostOperador+" sirvió para N "+N);
				// Sirvió, N cambiará para ver si así también sirve:
			} else {
				trace(Operador+PostOperador+" FALLó para N "+N);
				// No sirvió, probaremos Ns desde N 0,
				// con otro Operador:
				SolucionHallada = false;
				break;
			}
		} while (N<10);
	} while (SolucionHallada == false && NroDeOperador < Operadores.length);
}
trace ("El Operador y PostOperador útiles parece ser "+Operador+PostOperador);

Cosas a hacer ahora:
- Optimizarlo porque usa SolucionHallada varias veces, está lioso.
- Agregar el operador ^, ^N y mejorar el nombre PostOperador porque ya no siempre es eso.
- Agregar más operadores, los de logaritmo que no sé bien cómo se usan, si se puede con ^.