////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////

Posibilidades de las propiedades

de las bsquedas mediante fuerza bruta,
cuando slo se aumentando la complejidad de una.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Nota: En muchos casos menciono un requerimiento posible, es decir, puede haber ms o

puede haber otros alternativos.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Vars Cant
No tiene sentido poner Vars si no se usan. Requiere Aplics Cant.

Variedad de Vars Cant

Requiere Vars Cant.

Vars Complex
Requiere Vars Cant.

Variedad de Tipo de Var

Requiere Vars Cant.

Cands Cant
No tiene sentido poner Cands si no se usan. Requiere Max Cant de Conds Nec.

Variedad de Cand Cant

Necesidad dudosa. Requiere Cands Cant.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
Cands Complex

Base (Ent Pos) 2: Ent Neg 3: Ent or 1 Dec, 3: Ent, Pos or 4: Ent or 1 Dec,
Pos Neg Neg
C=1 C = -1 C = 0.1 C = -1 C = -0.1
Si 10 < C Si C < -10 Si 1 < C Si 10 < C Si C < -1
// Sol // Sol // Sol // Sol // Sol
C++ C-- C = (C*10+1)/10 C++ C = (C*10-1)/10
Goto Si Goto Si Goto Si Goto Si Goto Si
Nota: Para ms Dec agregar ms
0s en la parte donde se multiplica
y divide.
Debido a que las Conds son tan fciles de cumplir, crear Cands que las cumplan es ms
fcil que usar estos mtodos de bsqueda, pero esto es un poco de preparacin para
cuando hallar una solucin y plantear un mtodo para buscarla sea ms difcil, y cuando
lo 2ndo parezca ms til o sencillo que lo 1ero.

5: Nums (1 Dec max) 6: Lets

C = -0.1 Cs = " ABCDEFGHIJKLMNOPQRSTUVWXYZ"
Si 1 < C C=1
// Sol Si Cs.charAt(C) == Z
C = (C*10+1)/10 // Sol
Goto Si C++
Goto Si
Nota: Para ms Dec agregar ms 0s en la
parte donde se multiplica y divide. Requiere Conds Complex.
Mismo comentario.
7: Cada Cand es una List de Nums o Lets 8: Cada Cand es una List de Nums o Lets y
con la misma cantidad de elementos. pueden tener una distinta cantidad de
elementos.
L1_1 = 1 L1_1 = 1
L1_2 = 2 L1_2 = 2
L2_1 = 3 L1_3 = 3
L2_2 = 5 L2_1 = 1
C=1 L2_2 = 2
Si eval (L+C+_1) == 3 C=1
Si eval (L+C+_2) == 5 Si eval (L+C+_1) == 1
// Sol Si eval (L+C+_2) == 2
C++ Si eval (L+C+_3) == Inexistente
Goto Si // Sol
C++
Nota: Ya que en este caso el largo de todo Goto Si
elemento es igual, se puede usar el
mtodo de Lets, con las correspondientes Nota: En vez de inexist se podra usar vars
diferencias: que indiquen la can de elms de las lists, de
Cs = 1235 hecho no s si es posible usar inexist.
Los Solcheck toman 2 elementos. Sino, se podra crear elms en las lists,
C aumentara de a 2. definidos como Inex o algo as, segn se
requieran en la Cond. En el ejemplo, se
Requiere Max Cant de Conds Nec/Alt y requerira que toda lista tenga un mnimo
Conds Complex. de 2 elms, o sea que habra que crear elms
en las listas que tuvieran menos de 2 elms,
que en el ejemplo no hay.
De hecho, un mtodo quiz ms eficiente
sera eliminar toda lista con mayor o
menor elms de los que se pide. Luego el
problema pasara a ser de listas de igual
cantidad de elms, que es ms simple.

Requiere Max Cant de Conds Nec/Alt y

Conds Complex.
Mismo comentario pero adems la utilidad o sentido de estos problemas es dudosa, ya
que parece ms fcil usar Cands to Say, de modo que ellos conformaran la lista que se
busca.
9: Cada Cand es un Arch que contiene 1 Parte 2/2
variable Num, parte 1/2
C = 1; // 6
M.Resp = ""; if (10<M.C) {
fscommand ("fullscreen", "true"); // Sol
function BadCand () { M.Resp = "Un candidato que cumple la
M.Resp = "El candidato "+C+" no cumple condicin es el "+C+".\n"+M.Resp;
la condicin.\n"+M.Resp; stop ();
C = C+1; }
gotoAndPlay (2); // 7
} BadCand();
// 2
M.C = 0; Requiere Conds Complex.
// Proceso para cargar archivo y
determinar si se carg.
M.Cargas = 0;
// 3
M.Comp = 0;
M.Cargas = M.Cargas+1;
loadVariables (C+".txt", "M");
// 5
// Verificacin.
M.Comp = M.Comp+1;
M.C = Number(M.C);
if (M.C == 0) {
if (M.Comp == 10) {
if (M.Cargas == 3) { // Proceso para crear archivos; es otro
fscommand ("save", "30 fallas en programa, que sirve para ayudar a
cargar "+C+".txt"); comprobar la utilidad del anterior.
BadCand(); C = 1;
} else { // 2
// reload. fscommand ("save", C+".txt");
gotoAndPlay (3); // 3
} if (C<11) {
} else { C = C+1;
// retry. gotoAndPlay (2);
gotoAndPlay (4); }
} // 4
} fscommand ("quit");
Mismo comentario pero adems la utilidad o sentido de estos problemas es dudosa, ya
que parece ms fcil usar un mtodo normal y luego grabar la variable que se quiera en
el archivo que se quiera.

Lets en vez de Nums es ms fcil, ya que es lo mismo pero quitando la conversin a

Num.
10: Cada Cand es un Arch que contiene la 11: Cada Cand es un Arch que contiene una
misma cantidad de variables Num cantidad de variables Num que puede ser
diferente en cada uno
El proceso sera el mismo que con 1 El proceso sera el mismo que con 1
variable pero con estos cambios: variable pero con estos cambios:
// 2 // Los archivos incluiran una variable
Se crea M.C1, M.C2, etc. indicadora de cuntas variables Cs tienen.
// 5 // 2
La comprobacin se hara con cada M.C. Se Se crea M.Cs, M.C1, M.C2, etc. Se requiere
usara M.Verif. conocer el mximo nro de variables que
El Solcheck implicara toda var cargada. puede haber en un arch (*).
// 5
Requiere Conds Complex y Max Cant de La comprobacin se hara con M.Cs y cada
Conds Nec. M.C segn M.Cs. Se usara M.Verif.
El Solcheck implicara toda var cargada.

Requiere Conds Complex y Max Cant de

Conds Nec.

(*): Para que no sea necesario se podra

cargar Cs y luego adjudicar un valor imp a
los Cs correspondientes, recargar, y
comprobarlos.
Otra alternativa es cargarlos en otro lado
(no M).
Otra es que existan 2 archivos por cada
arch, uno contenedor de Cs y el otro de los
Cs.
Comentario prcticamente igual al anterior. Una de las diferencias es que seran
variables en vez de variable.

Lets en vez de Nums es ms fcil, ya que es lo mismo pero quitando la conversin a

Num.

12 o ms o menos:
Nota: A sera con la misma cantidad de elementos/variables y B que puede ser distinta.
Cada Cand es una List A de Lists A de Nums o Lets.
L1_1 = 1 L1_2 = 2 L2_1 = 2 L2_2 = 4
La lista 1 contiene una referencia a la sub lista 1 y 2. La 2 a la 2 y 4.
LL1_1 = 1 LL1_2 = 2 LL2_1 = 2 LL2_2 = 4 LL4_1 = 4 LL4_2 = 8
La sublista 1 contiene los nums 1 y 2. La 2 el 2 y 4. La 4 el 4 y 8.
Cada Cand es una List A de Lists B de Nums o Lets.
Cada Cand es una List B de Lists A de Nums o Lets.
Cada Cand es una List B de Lists B de Nums o Lets.
Cada Cand es una List A de Archs de 1 Num o Lets.
L1_1 = 1 L1_2 = 2 L2_1 = 2 L2_2 = 4
La lista 1 contiene una referencia al archivo 1 y 2. La 2 al 2 y 4.
 1.txt contiene 2. 2.txt contiene 4. 4.txt contiene 8.
Cada Cand es una List B de Archs de 1 Num o Lets.
Cada Cand es una List A de Archs A de Nums o Lets.
Cada Cand es una List B de Archs A de Nums o Lets.
Cada Cand es una List A de Archs B de Nums o Lets.
Cada Cand es una List B de Archs B de Nums o Lets.
Cada Cand es un Arch que contiene una referencia a una List A de nums/lets.
Las lists de este modo, estaran en el prog
Cada Cand es un Arch que contiene una referencia a una List B de nums/lets.
Cada Cand es un Arch que contiene una referencia a un Arch de nums/lets.
Cada Cand es un Arch que contiene una referencia a un Arch A de nums/lets.
Cada Cand es un Arch que contiene una referencia a un Arch B de nums/lets.
Cada Cand es un Arch A que contiene referencias a Lists A de nums/lets.
Cada Cand es un Arch A que contiene referencias a Lists B de nums/lets.
Cada Cand es un Arch A que contiene referencias a un Arch de nums/lets.
Cada Cand es un Arch A que contiene referencias a un Arch A de nums/lets.
Cada Cand es un Arch A que contiene referencias a un Arch B de nums/lets.
Cada Cand es un Arch B que contiene referencias a Lists A de nums/lets.
Cada Cand es un Arch B que contiene referencias a Lists B de nums/lets.
Cada Cand es un Arch B que contiene referencias a un Arch de nums/lets.
Cada Cand es un Arch B que contiene referencias a un Arch A de nums/lets.
Cada Cand es un Arch B que contiene referencias a un Arch B de nums/lets.
Todo esto parece complicable hasta el infinito, as como no tener sentido o necesidad.

Mximo-1, o 12 alternativo: Cands parcialmente desconocidos:

Esto es por ejemplo cuando se sabe que son nums o movs pero no cuales son vlidos.
Todo depende de la sit y quiz habr que probar cosas muy variadas (implica List
complex), como 1, 0.1, 10, -1, etc.

Mximo, o 13 alternativo: Cands desconocidos:

Similar a los parcialmente desconocidos, habra que usar nums, lets, etc.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Variedad de Tipo de Cand

Necesidad dudosa. Requiere Cands Complex

Aplics Conds
Requiere Aplics Cant

Aplics Conds Complex

Requiere Aplics Conds

Aplics Cant
 Requiere Vars Cant

Aplics Complex
Requiere Aplics Cant

Efs Conds
Requiere Efs Cant

Efs Conds Complex

Requiere Efs Conds

Efs Cant
Requiere Efs Complex

Efs Complex
Requiere Efs Cant

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Max Cant de Conds Nec

Base (1) 2 Ms de 2 requiere Cands

C=1 C=1 Cant o algo as, salvo que se
Si 10 < C Si 10 < C < 20 usen excepciones. Ej:
// Sol // Sol Si 10 < C < 20 && C != 12
C++ C++
Goto Si Goto Si Excepciones requiere 1
cond normal.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Max Cant de Conds Alt

Requiere Cands Cant o algo as, salvo que se use exactitud. Ej: or C == 11.

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////
Conds Complex

Base +1 mod +C
10 < C 10 < C+1 C1 < C2
10 < C-1
10 < C*2
10 < C/2
10 < C^2
10 < Cv2
Floor(C)
Round(C)
Ceil(C)
Abs(C)
Length(C)

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Cands to say

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

List Complex

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Cands Limits

////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////

Acts to Sol