​Mi tabla tiene 2 partes.

La 1era se ve así:


La 2nda:


Explico: Hay ciertas características o condiciones, a la izquierda, y se cuenta cuántas escaleras cumplen cada una. Por ejemplo Fi es cuando el 1er contacto (first) que tuvo el personaje con esa escalera, fue por la izquierda. Si eso es true, se pone 1, y sino 0. A la derecha se suma la cantidad de escaleras que cumplieron esa condición. Los datos para eso están en otra sección que no viene al caso. No le presten atención al No, porque no viene al caso tampoco, lo copié sin darme cuenta.

La diferencia entre ambas partes es que la 2nda se basa en la 1era, es true si alguna de las 2 condiciones en la izquierda se cumple. Por ejemplo SioSd significa que la escalera fue contactadas sólo por la izquierda o sólo por la derecha. Si alguna de esas condiciones se cumple, será 1, y sino 0. El total en la derecha funciona igual, no hay problema con eso.

¿Cómo se hace la 2nda parte? Por ejemplo TsoDxA en la escalera 1 es:
=SI($B$11+B49>0; 1; 0)
en la escalera 2 es: =SI($C$11+C49>0; 1; 0)
en la 3 es: =SI($D$11+D49>0; 1; 0)
etc
En B11 está el dato de Ts para la 1er escalera, en B49 está el correspondiente de DxA.
La variable Ts se mantiene hacia abajo, en tanto en la izquierda de la 1er columna diga Ts, por eso le puse el signo de $, para que al autorellenar o como se llame, la referencia no cambie.
El problema es que cuando aparece algo nuevo en la izquierda, como en el caso de Si, tengo que cambiar esas referencias, o sea, por ejemplo $B$11 lo tengo que cambiar por $B$12, $C$11 por $C$12, y así hasta la H. Sólo 7 cambios, el resto lo autocompleto, parece poca cosa, pero la tabla es grande, las variables en la izquierda cambian muchas veces, así que esos cambios los tengo que hacer muchas veces, a menos que me den una solución mejor...

¿Qué se les ocurre?

Por ejemplo: ¿Es posible poner una referencia basada en el contenido de una celda? No sé si serviría, es una intuición. Si en la derecha, donde no se vea, pongo un número, y a cada referencia se le suma ese número, tendría que modificar 1 número nada más, en vez de 7 cosas que implican tener que presionar F2 y moverse en el contenido de la celda. Bueno, tal vez necesite modificar la referencia 1 vez, el resto lo autorelleno.​

Me recomendaron poner esto:
=SI(BUSCARV(INDICE(DIVIDIRTEXTO($A51;"o";0);;1);$A$7:$H$49;COLUMNA();0)+BUSCARV(INDICE(DIVIDIRTEXTO($A51;"o";0);;2);$A$7:$H$49;COLUMNA();0)>0; 1; 0)
en B51
No lo entiendo y cuando lo pongo el resultado es #¿NOMBRE?

Creo que mi versión, 2013, no tiene esa fórmula, porque no me aparece como opción cuando la escribo.

Le pedí a GPT que me la explique, esto es lo que sigo sin entender:
BUSCARV(INDICE(...);$A$7:$H$49;COLUMNA();0):
BUSCARV busca el valor que se ha obtenido con INDICE dentro del rango $A$7:$H$49.
El tercer argumento COLUMNA() se utiliza para determinar de qué columna se debe devolver el valor. La función COLUMNA() devuelve el número de la columna de la celda donde está escrita la fórmula. Si la fórmula está en la columna C, por ejemplo, devolverá 3.
El cuarto argumento 0 indica que se debe hacer una coincidencia exacta.
Entonces, el primer BUSCARV busca el valor 123 (o lo que sea que haya en la primera parte del texto de $A51)

Busca Fi, por ejemplo, en el rango $A$7:$H$49. Como está en la columna A, podría ser $A$7:$A$49 ¿o no?
Lo hallará en A7. ¿Y luego? No entiendo lo de COLUMNA(). De hecho no entiendo qué devuelve BuscarV ¿la coordenada donde está el valor? A7. Luego, dependiendo de en qué columna esté la fórmula, debería tomar el valor de la fila 7 y esa columna, o sea, si está en 2, la tomaría de B7 ¿pero cómo hace eso? ¿escribir COLUMNA() sustituye la columna que fue el resultado de BuscarV? ¿sustituye A por B?

El 999999 en la derecha tiene botones encima y abajo, más o menos alineados con cada caracter. Los que están en su costado no vienen al caso. Quiero lograr que al presionar uno de esos botones, aumente o baje la cifra correspondiente. No entiendo mucho de cómo Flash "usa" los colores. Tengo:
ColorDelFondo = new Color("Fondo");
ColorDelFondo.setRGB(0x999999);
// Eso no se puede mostrar directo en texto,
// así que creo una variable:
ColorDelFondoB = "999999";

El objeto Fondo está puesto. Su color se establece bien, según lo que se ponga luego del set...

El cuadro de texto debería mostrar ColorDelFondo, pero si lo configuro así muestra la referencia al objeto, algo como "Objeto: Fondo". Tal vez funcione poner ColorDelFondo.setRGB, no probé ¿ideas? Igual esto es por rendimiento nomás.

Cuando se presione el botón encima del 1er 9, o lo que sea que haya en el momento, debe aumentar eso, si es posible. Lo mismo con el botón del 2ndo 9, etc, y los botones de abajo, para bajar las cantidades.

Sé que debo usar ifs para que el número no quede como -1 ni cosas extrañas, y quizá me conviene hacer algo así:
ColorDelFondo = 0x999999;
ColorDelObjetoFondo = new Color("Fondo");
ColorDelObjetoFondo.setRGB(ColorDelFondo);
...para simplificar, pero eso hace que en el texto se muestre un número más largo, no es hexadecimal.

Viendo la ayuda, dice algo así_

on(release) {
	ColorDelObjetoFondo = new Color("Objeto");
	ColorDelObjetoFondo.setRGB(parseInt(input, 16));
}

¿Debo haberlo definido así?
ColorDelFondo = "999999";

¿y luego poner

on(release) {
	ColorDelObjetoFondo = new Color("Objeto");
	ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
}

?

Pero eso no modifica los valores. Imagino que conviene modificar los que no son un string, y luego pasar el valor a ColorDelFondo, convertido en string, para que se muestre como número de 6 cifras.

No sé bien cómo hacer todo eso xP ¿ideas?

Tal vez estaba triste y fue todo en minúsculas, no se me había ocurrido eso. Ya no me acuerdo bien qué pensé sobre esto porque me puse a ordenar otros archivos, hasta ahora que sólo me queda este (del año en cuestión, tengo otros más xP ). Pero más o menos lo que había pensado es descartar combinaciones de letras. ¿Puedo hacer una lista de passwords y dársela a john? ¿cómo deben estar puestos? La lista la haría yo, el tema es que acepte el formato o lo pueda adaptar.

Antes de postear eso anduve buscando soluciones pero sobre el password remover no encontré info sobre "account", luego buscaré un tutorial, no sé.
Probé programas que parecen más bonitos que john pero en el momento en que empiezan dicen que hay que pagar, no entiendo por qué no avisan antes  

A estas alturas no tengo idea de cómo era el password, como dijiste no le pondría 666 pero de otras cosas no estoy seguro.
Me gustaría un programa que haga las pruebas, por ejemplo con largo 5, se pueda parar, se guarde dónde quedó, y al abrirlo siga ¿john hace eso? No recuerdo. ¿Es muy difícil hace un probador yo mismo? Igual con los passwords de john serviría, se los doy de a partes, pero bueno, me resulta un poco incómodo ese programa.

No sé si es la sección adecuada.

https://youtu.be/Ael4L-bzthA
Nota: El 1er texto, que se mueve, se grabó mal porque aunque el grabador empieza tarda en empezar a grabar, entonces no sé cuando empieza. Pero ese texto no es el problemático.

Time = 55;
_level0.Speed = _level0.Time/Caracteres;
Se refiere a la velocidad de la moto.

¿Por qué si la fórmula es la misma, en 1er texto largo da bastante tiempo para leerlo pero el 2ndo no? ¿es por la distancia entre los caracteres?

Quiero usar distintas fuentes.

Había probado que la duración fuese por línea pero como en unas fuentes hay muchos más caracteres por línea me pareció que mejor era por caracteres.

¿No hay una fórmula fácil si se cambian las fuentes?

El WinRAR Password Remover v.5.0.1 me pide un user y un password, puse y me dice que está mal, duh, pero voy a buscar a ver...

+1 a Doblekiller de Machacador. Había probado otras cosas y eran complicadas de usar, este incluso sin el manual parece mejor, al menos a la hora de poder seleccionar y borrar los duplicados de cierta carpeta.

Ya lo tendrían que haber cerrado, pero pedí que pasen los nombres por privado precisamente para que no haya spam aquí.

Vine a ampliar un tema que hice de videojuegos y me encontré con un privado diciéndome que me borraron un post de otro tema porque según la persona no tenía que ver con él.

Que borren cosas de política o incitaciones a la violencia lo entiendo, pero con eso y esto otro ya quitan las ganas de participar, no se puede hablar tranquilo, no se sabe cuando aparecerá alguno a borrar lo que escribas por a, por b, por c, etc ¿para qué escribir acá entonces? Te salís un poquito de la informática y te borran. Surgió un mini debate con Elektro sobre si está bien que pongan trabas a todos por culpa de algunos, algo que se hace en el foro, de hecho yo estaba defendiendo las reglas del foro y me borran el mensaje, bah.

En fin, pregunta del título. Pasen por privado. Si no les gusta el tema ciérrenlo, no lo borren please.

Un mod borró mi respuesta porque dijo que no tenía que ver con el tema. Quisiera que no me borren esto también, déjenme decir por qué no respondo (lo acabo de decir).

Cambié esto que estaba incompleto:

function VerSiColorFaltabaEtc () {
	// Esta función se usa en 2 lados distintos usando variables distintas,
	// por eso en algunos casos hay 2 traces casi iguales.
	// Esto puede cambiar:
	ColorFaltaba = "No";
	PunteroDeColores = 0;
	while (PunteroDeColores<Faltantes) {
		PunteroDeColores++;
		trace ("Comparando con el color guardado en el lugar "+PunteroDeColores+": "+eval("Faltante"+PunteroDeColores));
		if (ColorDeCuadradito.getRGB() == eval("Faltante"+PunteroDeColores)) {
			trace ("Iguales, el color del cuadradito recién agregado faltaba.");
			ColorFaltaba = "Sí";
			trace ("El cuadradito "+CuadraditosColocados+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
			trace ("El cuadradito "+CuadraditoaRepintar+" fue el 1ero de un color no anotado: "+ColorDeCuadradito.getRGB());
			// Quitarlo de la lista de faltantes,
			// para eso sustituirlo por...
			// el último y borrar el último
			// (si el que debe borrarse es el último,
			// la sustitución es en vano pero...
			// el resultado el mismo,
			// sin necesidad de reordenar la lista)
			set ("Faltante"+PunteroDeColores, eval("Faltante"+Faltantes));
			Faltantes--;
			trace ("La cantidad de colores faltantes es "+Faltantes);
			// Para que no siga mirando la lista:
			PunteroDeColores = Faltantes;
		}
	}
	// Si el color no faltaba:
	if (ColorFaltaba == "No") {
		trace ("No faltaba, se verá si es uno de los únicos.");
		// Esto puede cambiar:
		ColorUnico = "Sí";
		PunteroDeColores = 0;
		while (PunteroDeColores<MenosDe2) {
			PunteroDeColores++;
			trace ("Comparando con el color guardado en el lugar "+PunteroDeColores+": "+eval("MenosDe2"+PunteroDeColores));
			if (ColorDeCuadradito.getRGB() == eval("MenosDe2"+PunteroDeColores)) {
				trace ("Iguales, el color del cuadradito recién agregado ya existía.");
				ColorUnico = "No";
				// Quitarlo de la lista de únicos,
				// para eso sustituirlo por...
				// el último y borrar el último
				// (si el que debe borrarse es el último,
				// la sustitución es en vano pero...
				// el resultado el mismo,
				// sin necesidad de reordenar la lista)
				set ("MenosDe2"+PunteroDeColores, eval("MenosDe2"+MenosDe2));
				MenosDe2--;
				trace ("La cantidad de colores únicos es "+MenosDe2);
				// Para que no siga mirando la lista:
				PunteroDeColores = MenosDe2;
			}
		}
		if (ColorUnico == "No") {
			trace ("El cuadradito "+CuadraditosColocados+" tiene un color ya existente: "+ColorDeCuadradito.getRGB());
			trace ("El cuadradito "+CuadraditoaRepintar+" tiene un color ya existente: "+ColorDeCuadradito.getRGB());
		}
	}
}
// Agregar, distribuir cuadraditos y asignarles un color,
// pero la cantidad de diferentes colores debe ser...
// la indicada por _level0.ColoresRequeridos. Por eso...
// se hace una lista de los colores faltantes y de...
// los presentes menos de 2 veces,
// y se irán eliminando en el futuro:
Faltantes = _level0.ColoresRequeridos;
MenosDe2 = _level0.ColoresRequeridos;
Colores = 0;
do {
	Colores++;
	set ("Faltante"+Colores, _level0.PosiblesColores[Colores-1]);
	set ("MenosDe2"+Colores, _level0.PosiblesColores[Colores-1]);
} while (Colores<_level0.ColoresRequeridos);
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Si el dibujo no tenía los colores necesarios:
	if (Faltantes>0) {
		trace ("El dibujo probablemente aún no tiene los colores requeridos, faltaban: "+Faltantes);
		trace ("Se colocó el cuadradito: "+CuadraditosColocados);
		trace ("Su color es: "+ColorDeCuadradito.getRGB());
		trace ("Se verá si es uno de los faltantes.");
		VerSiColorFaltabaEtc();
	}
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// Si es necesario, reasignar colores hasta lograr lo requerido:
while (Faltantes>0) {
	trace ("Se asignó color a todos los cuadraditos pero faltaron colores: "+Faltantes);
	trace ("Se volverán a asignar colores.");
	CuadraditoaRepintar = 0;
	do {
		CuadraditoaRepintar++;
		ColorDeCuadradito = new Color("Cuadradito"+CuadraditoaRepintar);
		ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
		VerSiColorFaltabaEtc();
	} while (CuadraditoaRepintar<_level0.MaxCuadradito);
}

Por esto simplificado que funciona mal:

// Agregar, distribuir cuadraditos y asignarles un color:
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Incrementar el contador de cuadraditos de ese color:
	Resumen = "Color"+ColorDeCuadradito;
	set(Resumen, eval(Resumen)+1);
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// El dibujo debe tener la cantidad de colores...
// indicada por _level0.ColoresRequeridos. Por eso,
// y por practicidad, se asignará a cuadraditos al azar,
// cada uno de los colores, evitando reelegir cuadraditos.
Colores = 0;
do {
	// Elegir cuadradito al azar:
	CuadraditoElegido = random(_level0.MaxCuadradito)+1;
	trace("CuadraditoElegido: "+CuadraditoElegido);
	// Ver si ya fue elegido:
	PunteroDeElegidos = 0;
	while (Colores>PunteroDeElegidos) {
		PunteroDeElegidos++;
		trace("Comparando con el "+PunteroDeElegidos+", que es: "+eval("Elegido"+PunteroDeElegidos));
		if (eval("Elegido"+PunteroDeElegidos) == CuadraditoElegido) {
			trace("Son iguales");
			// Ya elegido, repetir el proceso para elegir otro:
			Colores--;
			// Terminar este loop:
			PunteroDeElegidos = Colores;
		}
	}
	Colores++;
	// Guardar en la lista al cuadradito elegido:
	set("Elegido"+Colores, CuadraditoElegido);
	trace("El recién elegido fue guardado en: Elegido"+Colores);
	// Asignarle el color:
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditoElegido);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[Colores-1]);
	trace("Se le asignó el color "+_level0.PosiblesColores[Colores-1]);
	trace("La cantidad de colores asignada es "+Colores);
} while (Colores<_level0.MaxCuadradito);

Y lo arreglé así:

// Agregar, distribuir cuadraditos y asignarles un color:
CuadraditosColocados = 0;
Columna = 0;
Fila = 0;
trace ("Asignando colores para un nuevo dibujo.");
do {
	CuadraditosColocados = CuadraditosColocados+1;
	attachMovie("mCuadradito", "Cuadradito"+CuadraditosColocados, CuadraditosColocados);
	setProperty ("Cuadradito"+CuadraditosColocados, _x, Columna*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _y, Fila*_level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _width, _level0.LargoDeCuadraditos);
	setProperty ("Cuadradito"+CuadraditosColocados, _height, _level0.LargoDeCuadraditos);
	ColorDeCuadradito = new Color("Cuadradito"+CuadraditosColocados);
	ColorDeCuadradito.setRGB(_level0.PosiblesColores[random(_level0.PosiblesColores.length)]);
	// Incrementar el contador de cuadraditos de ese color:
	Resumen = "Color"+ColorDeCuadradito;
	set(Resumen, eval(Resumen)+1);
	Columna = Columna+1;
	if (Columna == _level0.CuadraditosPorFila) {
		Columna = 0;
		Fila = Fila+1;
	}
} while (CuadraditosColocados<_level0.MaxCuadradito);
// El dibujo debe tener la cantidad de colores...
// indicada por _level0.ColoresRequeridos. Por eso,
// y por practicidad, se asignará a cuadraditos al azar,
// cada uno de los colores, evitando reelegir cuadraditos.
Colores = 0;
do {
	// Elegir cuadradito al azar:
	CuadraditoElegido = random(_level0.MaxCuadradito)+1;
	trace("CuadraditoElegido: "+CuadraditoElegido);
	// Esto puede cambiar:
	ElegidoValido = "Sí";
	// Ver si ya fue elegido:
	PunteroDeElegidos = 0;
	while (Colores>PunteroDeElegidos) {
		PunteroDeElegidos++;
		trace("Comparando con el "+PunteroDeElegidos+", que es: "+eval("Elegido"+PunteroDeElegidos));
		if (eval("Elegido"+PunteroDeElegidos) == CuadraditoElegido) {
			trace("Repetido");
			// Ya elegido, repetir el proceso para elegir otro:
			ElegidoValido = "No";
			// Terminar este loop:
			PunteroDeElegidos = Colores;
		}
	}
	if (ElegidoValido == "Sí") {
		Colores++;
		// Guardar en la lista al cuadradito elegido:
		set("Elegido"+Colores, CuadraditoElegido);
		trace("El recién elegido fue guardado en: Elegido"+Colores);
		// Asignarle el color:
		ColorDeCuadradito = new Color("Cuadradito"+CuadraditoElegido);
		ColorDeCuadradito.setRGB(_level0.PosiblesColores[Colores-1]);
		trace("Se le asignó el color "+_level0.PosiblesColores[Colores-1]);
		trace("La cantidad de colores asignada es "+Colores);
	}
} while (Colores<_level0.ColoresRequeridos);

Ahora bien ¿es necesario ese último if? ¿el código anterior no puede funcionar bien sin eso? Lo hice intentando evitar ese if y lo tuve que usar igual, bah, creí que era posible ¿no lo es? ¿cómo sería posible?

En cuanto a qué es más eficiente, no lo sé, de esta forma se están asignando colores que puede que ya estén asignados y entonces es innecesario, pero la cantidad de colores que usaré es más bien poca así que el loop es corto y de la otra manera hay que usar más loops así que... Dudo que esto sea mala idea.