elhacker.net cabecera Bienvenido(a), Visitante. Por favor Ingresar o Registrarse
¿Perdiste tu email de activación?.


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Temas
Páginas: 1 2 3 4 5 6 7 8 [9] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ... 51
81  Foros Generales / Foro Libre / Hacer lista de métodos que sólo quitan caracteres, sin liarse. en: 24 Noviembre 2024, 02:25 am
En cuanto a métodos conque se obtiene o genera un número a partir de otro, por ahora me sirvió clasificarlos en 4 tipos:
A: No cambian los caracteres, sólo cambian de lugar.
B: Se pierden algunos y se generan otros.
C: Se pierden algunos.
D: Se generan algunos.

Por ahora intento hacer la lista de los C, es decir de los métodos que modifican a un número mediante quitarle caracteres, sin cambiarlos de lugar ni transformarlos de otros modos.

Lo más reciente que tengo es esto:


Vease que en naranja parece haber 2 variables:
1: Qué caracter se quita: El 1ero, el central, el último.
2: De qué parte se quita: Del todo, de la parte entera, de la decimal, 1 de cada una.

La variable 1 varía hacia abajo, la 2 varía hacia la derecha.

En rojo hay 3 variables así que me lío, no puedo variarlas hacia 3 lados porque la tabla sólo tiene 2 dimensiones. Que una varíe hacia la izquierda y la otra a la derecha no sirve porque ya no habría cruces de 3 coordenadas.

Lo que se me ocurre es que una de las variables varíe en hojas, o sea, en otra hoja sólo estaría lo rojo y en vez de decir "su siguiente presencia" podría decir "su última presencia" (referirse a la central no es tan simple), pero para mí es lioso, y además ¿si llegan a ser 4 qué, hago distintos archivos?

Pienso que debe haber alguna buena manera de hacer la lista visiblemente ordenada, para facilitar que se pongan todas las posibilidades, pero distintas cosas que probé no me funcionaron por a o por b.

Es combinatoria, pero los posibles valores no se saben a priori. Tampoco se pueden concatenar todos igual.

Lo normal es hacer una lista de una columna, hacia abajo:
A0a
A0b
etc
donde cada caracter de eso sería cada valor de las variables, 3 en este caso.

Pero yo haciéndolo así me entrevero en este caso, no sé bien por qué, me parece que queda más comprensible si los que son similares se ponen al lado, formando una tabla.

Se me acaba de ocurrir hacer una tabla en que en cada celda, los valores varíen cada cierto tiempo, de ese modo podrían entrar en 2 dimensiones la variación de 3 variables, pero ya probé algo similar y el hecho de que parte del texto cambie mientras lo miro me genera cierta confusión en casos como este. Además si hay 4 variables no servirá.

Este tipo de problemas los tuve varias veces. ¿Sugerencias?
82  Programación / Programación General / ¿Por qué el cambio de color no se aplica? en: 23 Noviembre 2024, 08:41 am
Código
  1. on (release) {
  2. 	// Los separadores (fondo) tendrán el color de este botón,
  3. 	// y este botón el color que tenían los separadores:
  4. 	ExColorDelFondo = _level0.ColorDelFondo;
  5. 	_level0.ColorDelFondo = ColorDeCentro.getRGB().toString(16).toUpperCase();
  6.  
  7. 	_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));
  8.  
  9. 	ColorDeCentro.setRGB(parseInt(ExColorDelFondo, 16));
  10. }

Funciona todo menos:
_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));

No importa qué ponga luego de RGB, no se aplica.

Pero desde el lv0 funciona:
ColorDelFondo = Rojo+Verde+Azul;
// Actualizar el color del objeto:
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));

Le paso un texto hexadecimal (ColorDelFondo), lo convierte en decimal, y se lo asigna de color a un objeto.

La situación es la misma.

_level0.ColorDelFondo: FFFFFF
ColorDeCentro: 10066329


Explico desde el principio, no sé...

Esto es lo relevante en este momento:

Es largo explicar por qué se ve así, no viene al caso.

Lo que tiene color cyan es "las separaciones", también fondo. Se inició así:
Código
  1. ColorDelObjetoFondo = new Color("Fondo");
  2. ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));

Y se le puede cambiar el color con los botones con flechita de colores, así:
Código
  1. function ActualizarColorDelFondo () {
  2. 	// Formar el color:
  3. 	ColorDelFondo = Rojo+Verde+Azul;
  4. 	// Actualizar el color del objeto:
  5. 	ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
  6. }
  7.  
Los botones cambian el color correspondiente y luego aplican eso.

Estoy agregando botones que al presionarlos hagan intercambios, o sea, se ve uno blanco, al cliquearlo quedaría cyan (o como esté el fondo o separador en ese momento) y el fondo quedaría blanco.

Pero ese botón, para que aparezca de un color variable y haga un efecto, lo puse en una película. No debería haber problema con eso. Pero sucede lo que dije al inicio, no se aplica, no sé qué pasa.

Les dejo el archivo. Tienen que mirar el código del botón superior izquierdo, que en la imagen se ve blanco pero en el editor se ve gris como los demás. Vayan al 2ndo frame de eso y vean el cuadrado negro. Ahí está el código que falla.

Acabo de poner esto:
_level0.Rojo = "FF";
_level0.ActualizarColorDelFondo ();
...y funciona. Pero por qué esto no:
_level0.ColorDelObjetoFondo.setRGB(parseInt(_level0.ColorDelFondo, 16));
si es lo mismo que:
ColorDelObjetoFondo.setRGB(parseInt(ColorDelFondo, 16));
¿Hay algo mal escrito que no veo? La única diferencia es que el 1ero dice _level0. en 2 lados porque fue usado desde una película y lo que se quiere señalar está en el lv0.

Podría entonces usar la función mencionada luego de cambiar el valor del rojo, etc, pero no tiene mucho sentido modificar partes si ya tengo una variable que tiene el color a transferir.

Una posible explicación sería que ActualizarColorDelFondo se esté aplicando todo el tiempo pero la quité, puse
_level0.ColorDelObjetoFondo.setRGB(0);
y no funcionó.

https://docs.google.com/document/d/1HkhDR97uRp5Gv_ECbm7z0w301a5SFc-6/edit?usp=sharing&ouid=109273743447273895658&rtpof=true&sd=true


EDIT: Parece que es un bug.

Si esto:
on (release) {
   _level0.ColorDelObjetoFondo.setRGB(0);
}
está en un botón del level0, funciona. Pero si el botón está dentro de una película, no. Se puede hacer funcionar poniendo el código en una función y llamándola, pero no debería ser necesario.
83  Programación / Programación General / Busco eficiencia, tengo while con función y quiero evitar un if. en: 22 Noviembre 2024, 07:37 am
Tengo algo como:
Código
  1. Repetir
  2. 	Si se puede variar
  3. 		VariaciónConChequeoNormal
  4. 		Si se capta simetría
  5. 			repetir pero VariaciónConChequeoExtra
  6. 		sino
  7. 			repetir normalmente
  8. 	sino
  9. 		despintar
  10. mientras no se capte un dibujo ok

Básicamente, en un caso tengo que hacer unos chequeos extra que normalmente no, así que no quiero hacerlos si es innecesario, pero quiero evitar poner ese if en el código que siento que es innecesario (*), y por cómo es el código es complicado... ¿Basado en eso se les ocurre algo?

Me refiero a algo así:
Código
  1. Repetir
  2. 	Si se puede variar
  3. 		Si no se captó simetría
  4. 			VariaciónConChequeoNormal
  5. 		sino
  6. 			VariaciónConChequeoExtra
  7. 		fin del si
  8. 		Si se capta simetría
  9. 			Marcar que se detectó simetría y repetir
  10. 		sino
  11. 			Marcar que no se detectó simetría y repetir
  12. 	sino
  13. 		despintar
  14. mientras no se capte un dibujo ok

Esto:
Código:
Si no se captó simetría
	VariaciónConChequeoNormal
sino
	VariaciónConChequeoExtra
fin del si

Si en vez de VariaciónConChequeoExtra se pudiera poner un do parecido al original, tal vez... Lo pensaré.


Aquí una explicación más detallada:
Intento que un programa genere todos los dibujos de X*X cuadraditos en blanco y negro, que cumplan ciertas condiciones, X va aumentando. Las condiciones son:
// debe tener algún cuadradito pintado en cada columna y fila,
// no debe haber muchos pintados aislados,
// no debe ser simétrico (espejo vertical | ) a alguno ya mostrado,
// y no debe tener demasiados cuadraditos despintados (contando desde el MinPintado, que se cuenta desde arriba a la derecha, como un texto).

El conteo de aislados, cuando se pinta un cuadradito, no es completo porque no es necesario, porque como se pintan desde abajo a la izquierda, nunca habrá uno pintado a la derecha ni abajo, como se explica aquí (más abajo está el código completo):
// Debido a que al pintar un cuadradito...
// los de abajo y el de la derecha estarán despintados,
// sólo se miran el de la izquierda y los de arriba:
Eso es el chequeo normal.

Cuando se capta que un dibujo es simétrico a uno ya hecho, para evitar que se generen posibles otros simétricos se modifica el cuadradito más derecho de la fila donde se detectó la falla, en vez de modificar el cuadradito de más abajo o donde fuera normalmente. Esto es bueno, pero al hacerlo se requiere un chequeo extra de los aislados, porque en este caso puede que haya pintados abajo.

Son suposiciones sobre este programa, un error que me ha parecido detectar, no es que lo tenga del todo claro.

He pensado, como puse arriba, en crear 2 funciones para los 2 tipos de variaciones, pero no quiero usar un if, siento que no es necesario.

Código
  1. // En este programa hay cuadraditos nombrados así:
  2. // 123
  3. // 456
  4. // 789
  5. // Se irán pintando diferentes combinaciones y...
  6. // su tamaño se reducirá a medida que...
  7. // la cantidad por fila y columna aumente.
  8. // Para que un dibujo se muestre...
  9. // debe tener algún cuadradito pintado en cada columna y fila,
  10. // no debe haber muchos pintados aislados,
  11. // no debe ser simétrico (espejo vertical | ) a alguno ya mostrado,
  12. // y no debe tener demasiados cuadraditos despintados
  13. // (contando desde el MinPintado).
  14. // Ver frame 2 por más información.
  15. // 
  16. // CuadraditosPorFila es también porColumna.
  17. // Debido a que en cierto chequeo se asume que...
  18. // si el cuadradito no está en la parte inferior ni...
  19. // superior entonces está en una fila intermedia,
  20. // conviene que CuadraditosPorFila comience siendo >1;
  21. // aumenta 1 antes de aplicarse:
  22. CuadraditosPorFila = 2;
  23. // Usada en Variar:
  24. function ObtenerColumnayFila () {
  25. 	Fila = Math.ceil(Puntero/CuadraditosPorFila);
  26. 	// trace ("Su Fila según el cálculo es: "+Fila);
  27. 	Columna = (Puntero-1)%CuadraditosPorFila+1;
  28. 	// trace ("Su Columna: "+Columna);
  29. 	// Esto se usa para evitar repeticiones...
  30. 	// de concatenaciones y simplificarlas:
  31. 	ColumnaRelevante = "PintadosenC"+Columna;
  32. 	FilaRelevante = "PintadosenF"+Fila;
  33. }
  34. // Usada en ParteDeContarEtc:
  35. function PosibleIncrementoDeContiguosPintados () {
  36. 	// ¿El contiguo indicado está pintado?
  37. 	if (eval("Cuadradito"+Fila3+"_"+Columna3) == 0) {
  38. 		// Sí, aumentar contador:
  39. 		ContiguosPintados++;
  40. 		// trace ("De ese contiguo ("+Fila2+"_"+Columna2+"), su contiguo "+Fila3+"_"+Columna3+" está pintado; por ahora se vió que tiene "+ContiguosPintados+" contiguos pintados.");
  41. 	}
  42. }
  43. // Usada en ContarContiguosDeContiguoAlNewPintado y ContarContiguosDeContiguoAlNewDespintado:
  44. function ParteDeContarEtc () {
  45. 	ContiguosPintados = 0;
  46. 	// trace("Analizando su inferior derecho.");
  47. 	Fila3 = Fila2+1;
  48. 	Columna3 = Columna2+1;
  49. 	PosibleIncrementoDeContiguosPintados();
  50. 	// trace("Analizando su inferior.");
  51. 	Columna3--;
  52. 	PosibleIncrementoDeContiguosPintados();
  53. 	// trace("Analizando su inferior izquierdo.");
  54. 	Columna3--;
  55. 	PosibleIncrementoDeContiguosPintados();
  56. 	// trace("Analizando su derecho.");
  57. 	Columna3 = Columna3+2;
  58. 	Fila3--;
  59. 	PosibleIncrementoDeContiguosPintados();
  60. 	// trace("Analizando su izquierdo.");
  61. 	Columna3 = Columna3-2;
  62. 	PosibleIncrementoDeContiguosPintados();
  63. 	// trace("Analizando su superior derecho.");
  64. 	Columna3 = Columna3+2;
  65. 	Fila3--;
  66. 	PosibleIncrementoDeContiguosPintados();
  67. 	// trace("Analizando su superior.");
  68. 	Columna3--;
  69. 	PosibleIncrementoDeContiguosPintados();
  70. 	// trace("Analizando su superior izquierdo.");
  71. 	Columna3--;
  72. 	PosibleIncrementoDeContiguosPintados();
  73. }
  74. // Usada en Variar:
  75. function ContarContiguosDeContiguoAlNewPintado () {
  76. 	// ¿El contiguo indicado está pintado?
  77. 	// trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
  78. 	if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
  79. 		// Sí, el recién pintado no está aislado:
  80. 		ElRecienPintadoEstaAislado = "No";
  81. 		// trace ("Está pintado; el recién pintado no está aislado.");
  82. 		// Se contarán los contiguos de este (contiguo al recién...).
  83. 		ParteDeContarEtc();
  84. 		// trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién pintado tiene "+ContiguosPintados+" contiguos pintados.");
  85. 		// ¿Estaba aislado?
  86. 		if (ContiguosPintados == 1) {
  87. 			// Sí, reducir el contador:
  88. 			CuadraditosAislados--;
  89. 			// trace ("El contiguo al recién pintado sólo tiene 1 contiguo pintado, estaba aislado, ahora hay "+CuadraditosAislados+" aislados.");
  90. 		}
  91. 	} else {
  92. 		// trace ("No está pintado.");
  93. 	}
  94. }
  95. // Usada en Variar:
  96. function ContarContiguosDeContiguoAlNewDespintado () {
  97. 	// ¿El contiguo indicado está pintado?
  98. 	// trace ("Analizando Cuadradito"+Fila2+"_"+Columna2+": "+eval("Cuadradito"+Fila2+"_"+Columna2));
  99. 	if (eval("Cuadradito"+Fila2+"_"+Columna2) == 0) {
  100. 		// Sí, el recién despintado no estaba aislado:
  101. 		ElRecienDespintadoEstabaAislado = "No";
  102. 		// trace ("Está pintado; el recién despintado no estaba aislado.");
  103. 		// Se contarán los contiguos de este (contiguo al recién...).
  104. 		ParteDeContarEtc();
  105. 		// trace ("Ese contiguo ("+Fila2+"_"+Columna2+") al recién despintado tiene "+ContiguosPintados+" contiguos pintados.");
  106. 		// ¿Está aislado?
  107. 		if (ContiguosPintados == 0) {
  108. 			// Sí, aumentar el contador:
  109. 			CuadraditosAislados++;
  110. 			// trace ("El contiguo al recién despintado quedó aislado, ahora hay "+CuadraditosAislados+" aislados.");
  111. 		}
  112. 	} else {
  113. 		// trace ("No está pintado.");
  114. 	}
  115. }
  116. // En F3 se repite:
  117. function Variar () {
  118. 	// Repetir mientras no se produzca un dibujo ok:
  119. 	do {
  120. 		// Esto para modificar la variable que indica el color,
  121. 		// que es 0 o 1:
  122. 		ReferenciaAlColoraModificar = "ColordeCuadradito"+Puntero;
  123. 		ColoraModificar = eval(ReferenciaAlColoraModificar);
  124. 		// Esto para el color real:
  125. 		NuevoColor = new Color("Cuadradito"+Puntero);
  126. 		// ¿El cuadradito puede cambiar de color?
  127. 		if (ColoraModificar>0) {
  128. 			// Sí, hacer los cambios:
  129. 			// En la variable:
  130. 			set (ReferenciaAlColoraModificar, ColoraModificar-1);
  131. 			// Del color real:
  132. 			NuevoColor.setRGB(0);
  133. 			// trace ("   Se pintó el cuadradito "+Puntero);
  134. 			// Asignarle el color de la 2nda manera:
  135. 			ObtenerColumnayFila();
  136. 			set ("Cuadradito"+Fila+"_"+Columna, 0);
  137. 			// Incrementar contador de cuadraditos pintados en...:
  138. 			// la columna y fila donde se pintó:
  139. 			set (ColumnaRelevante, eval(ColumnaRelevante)+1);
  140. 			set (FilaRelevante, eval(FilaRelevante)+1);
  141. 			// Actualizar cantidad de cuadraditos pintados aislados:
  142. 			// De cada pintado al lado del recién pintado,
  143. 			// se verá si estaba aislado,
  144. 			// en cuyo caso disminuirá el contador.
  145. 			// Si no hay pintados al lado del nuevo, aumentará.
  146. 			// trace ("Se actualizará el contador de pintados aislados:");
  147. 			// Esta variable puede cambiar, se refiere al recién pintado:
  148. 			ElRecienPintadoEstaAislado = "Sí";
  149. 			// Para analizar a su izquierdo:
  150. 			Fila2 = Fila;
  151. 			Columna2 = Columna-1;
  152. 			// Si su izquierdo existe y está pintado,
  153. 			// entonces el actual no está aislado,
  154. 			// y se mira si el izquierdo de ese estaba aislado:
  155. 			// Cuántos de sus contiguos están pintados.
  156. 			// Si la cantidad es 1, estaba aislado,
  157. 			// el contador de Aislados baja.
  158. 			// Debido a que al pintar un cuadradito...
  159. 			// los de abajo y el de la derecha estarán despintados,
  160. 			// sólo se miran el de la izquierda y los de arriba:
  161. 			ContarContiguosDeContiguoAlNewPintado();
  162. 			// Para analizar a su izquierdo de arriba:
  163. 			Fila2--;
  164. 			ContarContiguosDeContiguoAlNewPintado();
  165. 			// Para analizar al de arriba:
  166. 			Columna2++;
  167. 			ContarContiguosDeContiguoAlNewPintado();
  168. 			// Para analizar a su derecho de arriba:
  169. 			Columna2++;
  170. 			ContarContiguosDeContiguoAlNewPintado();
  171. 			if (ElRecienPintadoEstaAislado == "Sí") {
  172. 				// trace("El recién pintado está aislado");
  173. 				CuadraditosAislados++;
  174. 			}
  175. 			// trace("        El dibujo tiene "+CuadraditosAislados+" cuadraditos aislados");
  176. 			// Actualizar contador de despintados
  177. 			// (contando desde MinPintado)
  178. 			CuadraditosDespintados--;
  179. 			// Para juzgar:
  180. 			// ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
  181. 			Puntero2 = 0;
  182. 			// Esto puede que cambie:
  183. 			CuadraditoenCadaFyC = "Sí";
  184. 			do {
  185. 				Puntero2 = Puntero2+1;
  186. 				// ¿La columna Puntero2 no tiene algún cuadradito pintado?
  187. 				if (eval("PintadosenC"+Puntero2)<1) {
  188. 					CuadraditoenCadaFyC = "No";
  189. 				} else if (eval("PintadosenF"+Puntero2)<1) {
  190. 					// La fila Puntero2 no tiene algún cuadradito pintado.
  191. 					CuadraditoenCadaFyC = "No";
  192. 				}
  193. 			} while (CuadraditoenCadaFyC == "Sí" && Puntero2<CuadraditosPorFila);
  194. 			// ¿El dibujo tiene cuadraditos pintados en toda columna y fila?
  195. 			if (CuadraditoenCadaFyC == "No") {
  196. 				// No, no mostrarlo y hacer otro:
  197. 				// trace ("    No ocupa cada F y C, salteándolo.");
  198. 				DibujosPequeños++;
  199. 				// Actualizar MinCuadraditoPintado si corresponde:
  200. 				if (Puntero<MinCuadraditoPintado) {
  201. 					MinCuadraditoPintado = Puntero;
  202. 					// trace(Puntero);
  203. 					// Como ahora se cuenta un cuadradito extra,
  204. 					// que estaba despintado, el contador aumenta:
  205. 					CuadraditosDespintados++;
  206. 					// Si se llegó al punto en que los dibujos...
  207. 					// pueden ser simétricos a unos ya hechos:
  208. 					if (Puntero<CuadraditoCentraloCD) {
  209. 						// En el próximo dibujo se pintará el superior derecho:
  210. 						Puntero = CuadraditosPorFila;
  211. 					} else {
  212. 						// Preparar Puntero para generar el próximo dibujo:
  213. 						Puntero = MaxPosiciondePuntero;
  214. 					}
  215. 				} else {
  216. 					// Preparar Puntero para generar el próximo dibujo:
  217. 					Puntero = MaxPosiciondePuntero;
  218. 				}
  219. 			} else if (CuadraditosAislados>MaxCuadraditosAislados) {
  220. 				// trace ("    Tiene demasiados cuadraditos pintados aislados: "+CuadraditosAislados+" salteándolo.");
  221. 				DibujosAislados++;
  222. 				// Preparar Puntero para generar el próximo dibujo:
  223. 				Puntero = MaxPosiciondePuntero;
  224. 			} else if (MinCuadraditoPintado<CuadraditoCentraloCD) {
  225. 				// El dibujo puede ser simétrico...
  226. 				// a otro ya mostrado. ¿Lo es?
  227. 				// Esto puede cambiar:
  228. 				DibujoEsSimetrico = "No";
  229. 				// Captar valor (colores) de cada fila;
  230. 				// si alguno es menor al inverso, sí:
  231. 				PunteroDeFilas = 0;
  232. 				do {
  233. 					PunteroDeFilas++;
  234. 					PunteroDeColumnas = 0;
  235. 					PunteroInverso = CuadraditosPorFila;
  236. 					do {
  237. 						PunteroDeColumnas++;
  238. 						Valor = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroDeColumnas);
  239. 						ValorInverso = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroInverso);
  240. 						// trace("Valor: "+Valor);
  241. 						// trace("ValorInverso: "+ValorInverso);
  242. 						if (Valor<ValorInverso) {
  243. 							DibujoEsSimetrico = "Sí";
  244. 							FilaFallada = PunteroDeFilas;
  245. 							PunteroDeFilas = CuadraditosPorFila;
  246. 							break;
  247. 						} else if (Valor>ValorInverso) {
  248. 							// Es ok:
  249. 							PunteroDeFilas = CuadraditosPorFila;
  250. 							break;
  251. 						}
  252. 						PunteroInverso--;
  253. 					} while (PunteroDeColumnas<CuadraditosPorFila);
  254. 				} while (PunteroDeFilas<CuadraditosPorFila);
  255. 				// Este if es probablemente innecesario,
  256. 				// porque se supone que el dibujo será simétrico u ok,
  257. 				// antes de que se terminen de comparar todas las filas.
  258. 				if (DibujoEsSimetrico == "Sí") {
  259. 					// trace ("  El dibujo es simétrico a otro ya mostrado.");
  260. 					DibujosSimetricos++;
  261. 					// Al Puntero ponerlo al final de la fila...
  262. 					// captada como simétrica, para posiblemente...
  263. 					// evitar algunos otros dibujos simétricos:
  264. 					Puntero = CuadraditosPorFila*FilaFallada;
  265. 				} else if (CuadraditosDespintados<MinCuadraditosDespintados) {
  266. 					trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
  267. 					DibujosDensos++;
  268. 					// Preparar Puntero para generar el próximo dibujo:
  269. 					Puntero = MaxPosiciondePuntero;
  270. 				} else {
  271. 					DibujosOk++;
  272. 					// trace ("  Mostrando dibujo nro: "+DibujosOk);
  273. 					// Preparar Puntero para generar el próximo dibujo:
  274. 					Puntero = MaxPosiciondePuntero;
  275. 					play ();
  276. 					break;
  277. 				}
  278. 			} else if (CuadraditosDespintados<MinCuadraditosDespintados) {
  279. 				trace ("  El dibujo tiene demasiados cuadraditos despintados: "+CuadraditosDespintados);
  280. 				DibujosDensos++;
  281. 				// Preparar Puntero para generar el próximo dibujo:
  282. 				Puntero = MaxPosiciondePuntero;
  283. 			} else {
  284. 				DibujosOk++;
  285. 				// trace ("  Mostrando dibujo nro: "+DibujosOk);
  286. 				// Preparar Puntero para generar el próximo dibujo:
  287. 				Puntero = MaxPosiciondePuntero;
  288. 				play ();
  289. 				break;
  290. 			}
  291. 		} else {
  292. 			// Despintar un cuadradito, no viene al caso.
  293. 		}
  294. 	} while (true);
  295. }
  296.  

Pero dudo que convenga poner por ahí una copia modificada de todo eso... Tendría que crear muchas funciones. No sé, joder ¿ideas?
84  Programación / Programación General / ¿Cómo generar passwords rápido? Flash es muy lento y mi PC creo que no resiste. en: 22 Noviembre 2024, 04:21 am
Si pongo un while probablemente se tranque porque tarda mucho, y si pongo que el código se ejecute en cada frame es muy lento, pero aunque se me acaba de ocurrir que se ejecute más de 1 vez por frame, el otro problema es que mi PC no creo que pueda seguir ejecutando ese programa, si el texto generado es mucho.

Conozco estas formas de generarlo:

A- En traces, que son como prints. Ya vi que entre más haya, más se enlentece.

B- En un cuadro de texto. Dudo que sea mejor.

C- En variables, un password por cada variable (P1 = "Aaaa", P2 = ... etc). Idem. Luego copiaría las variables, sustituiría = por tab, lo pegaría en Excel y quedarían los contenidos de las variables listos para copiar, separados de sus nombres y del =.

D- En 1 variable, poniendo salto de línea. Podría ser mejor que lo anterior, pero que los traces no sé.

Arrays, guardar en archivos, en fin, como sea, creo que Flash es muy lento para esto. Pensé eb Excel ¿será muy lento? ¿qué programa recomiendan, que permita copiar los passwords o genere un archivo de ellos?
Quiero que se generen por mi código, aclaro, ya lo tengo, tendría que conviertirlo al lenguaje que me recomienden ¿cual? ¿y cómo lo uso?

Otra aclaración, aunque en el fondo no sirve: Es para averiguar un password que olvidé, de un archivo mío, o de varios míos, con passwords que olvidé (no sé si tienen el mismo password o se diferencian en 1 caracter).
85  Foros Generales / Foro Libre / ¿Qué programa te gustaría que yo haga? Gratis y te doy el editable. en: 19 Noviembre 2024, 23:28 pm
No me pidan cosas complicadísimas, que no sé tanto.

Tampoco cosas que claramente son no éticas (aunque la mayoría está descartada por lo anterior).

Sería en Macromedia Flash 5.

Te doy el exe.

Un swf que lo puedes abrir con el reproductor que viene con el editor Flash. Los reproductores que se descargaban sueltos, para Youtube y similares, no sé si sirven.
Por lo que sé, los swf son menos peligrosos, los exes pueden crear/modificar archivos, los swf no he visto que puedan (aunque es probable).

Y te doy el fla, el archivo editable, que lo puedes abrir con el editor Flash.

Si por algún motivo cierran el tema, me pueden enviar un mensaje privado.


Simplemente para practicar y ver qué quiere la gente. Por ahora lo que me pidieron fue:
- Algo para ganar en juegos de azar. Complicado y no ético.
- Un programa que diga si otro termina o no. Dicen que es imposible en ciertos casos, que hay paradojas.

Cosas que he visto en este foro:
A- Ganar dinero, objetos, etc, sin esfuerzo.
B- Ubicar a supuesto acosador, estafador o hacker.
C- Robar cuenta del amigo porque no le dice cómo hacer trampa en juego, por ejemplo.
D- Aparente virus, de broma.
E- Recuperar cuenta que el servicio se niega a dar.

A: No sé, además esfuérzate y merécelo, o juegoa algún juego donde a nadie le importe si haces trampa.
B: Tampoco sé, además no se sabe si la historia es verídica, y no es el acosador quien pide ubicar a la persona.
C: Idem, y busca mejores amigos/juegos.
D: Prefiero algo útil, pero podría intentar. Igual ya hay, mejor que busquen por ahí.
E: No sé, y es similar a B.


En cuanto a que el problema es que sea en Flash, ni idea, es como que te ofrezcan una silla hecha a martillazo común y con una madera que la pueden comer las hormigas, por poner un ejemplo. ¿Qué importa si fue hecha con un martillo común o uno eléctrico y taladro y demás? Importa que funcione. En cuanto a los peligros por madera de mala calidad, no la lleves donde haya hormigas y listo. Son juegos offline, no sé online, no usan Internet, así que si te pueden hackear alguno no es problema del juego sino que el hacker ese tiene mucho nivel, es como que te pueda hackear el buscaminas...

Ah, sí, puede que pida ayuda a una IA o a gente, claro.
86  Foros Generales / Foro Libre / ¿Puede GPT programar más rápido que tú o incluso cosas que no sabes? en: 18 Noviembre 2024, 14:40 pm
En mi caso sí. Pareciera entonces que programar fuese una pavadita, que cualquiera puede hacer, porque a ver, no soy experto pero hace años que le doy al asunto. O es que en una escala del 1 al 5, yo estoy en LV2 y GPT en 4 o 3 y la diferencia se nota mucho. Pero hay otras cosas que no hace tan bien, al menos aún, no es Dios ¿pero cómo hace el tipo para programar tan bien siendo un "cacharro", una máquina? ¿deberé volverme GPTólico? ¿surgirá una nueva religión?
87  Programación / Programación General / ¿Se puede evitar estos ifs, cómo? en: 18 Noviembre 2024, 05:37 am
El código es largo como para ponerlo todo, cualquier cosa pregunten:
Código
  1. 		} else if (MinCuadraditoPintado < CuadraditoCentraloCD) {
  2. 			// El dibujo puede ser simétrico...
  3. 			// a otro ya mostrado. ¿Lo es?
  4. 			// Esto puede cambiar:
  5. 			DibujoEsSimetrico = "No";
  6. 			// Captar valor (colores) de cada fila;
  7. 			// si alguno es menor al inverso, sí:
  8. 			PunteroDeFilas = 0;
  9. 			do {
  10. 				PunteroDeFilas++;
  11. 				PunteroDeColumnas = 0;
  12. 				PunteroInverso = CuadraditosPorFila;
  13. 				do {
  14. 					PunteroDeColumnas++;
  15. 					Valor = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroDeColumnas);
  16. 					ValorInverso = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroInverso);
  17. 					// trace("Valor: "+Valor);
  18. 					// trace("ValorInverso: "+ValorInverso);
  19. 					if (Valor < ValorInverso) {
  20. 						DibujoEsSimetrico = "Sí";
  21. 						FilaFallada = PunteroDeFilas;
  22. 						PunteroDeFilas = CuadraditosPorFila;
  23. 						break;
  24. 					} else if (Valor > ValorInverso) {
  25. 						// Es ok:
  26. 						PunteroDeFilas = CuadraditosPorFila;
  27. 						break;
  28. 					}
  29. 					PunteroInverso--;
  30. 				} while (PunteroDeColumnas < CuadraditosPorFila);
  31. 			} while (PunteroDeFilas < CuadraditosPorFila);
  32. 			// Este if es probablemente innecesario,
  33. 			// porque se supone que el dibujo será simétrico u ok,
  34. 			// antes de que se terminen de comparar todas las filas.
  35. 			if (DibujoEsSimetrico == "Sí") {
  36. 				// trace ("  El dibujo es simétrico a otro ya mostrado.");
  37. 				DibujosSimetricos++;
  38. 				// Al Puntero ponerlo al final de la fila...
  39. 				// captada como simétrica, para posiblemente...
  40. 				// evitar algunos otros dibujos simétricos:
  41. 				Puntero = CuadraditosPorFila*FilaFallada;
  42. 				Variar();
  43. 			} else if (CuadraditosDespintados < MinCuadraditosDespintados) {
  44. 				trace ("  El dibujo tiene demasiados cuadraditos pintados: "+CuadraditosDespintados);
  45. 				DibujosDensos++;
  46. 				// Preparar Puntero para generar el próximo dibujo:
  47. 				Puntero = MaxPosiciondePuntero;
  48. 				Variar();
  49. 			} else {
  50. 				DibujosOk++;
  51. 				// trace ("  Mostrando dibujo nro: "+DibujosOk);
  52. 				// Preparar Puntero para generar el próximo dibujo:
  53. 				Puntero = MaxPosiciondePuntero;
  54. 				play ();
  55. 			}
  56. 		} else if (CuadraditosDespintados < MinCuadraditosDespintados) {
  57. 			trace ("  El dibujo tiene demasiados cuadraditos pintados: "+CuadraditosDespintados);
  58. 			DibujosDensos++;
  59. 			// Preparar Puntero para generar el próximo dibujo:
  60. 			Puntero = MaxPosiciondePuntero;
  61. 			Variar();
  62. 		} else {
  63. 			DibujosOk++;
  64. 			// trace ("  Mostrando dibujo nro: "+DibujosOk);
  65. 			// Preparar Puntero para generar el próximo dibujo:
  66. 			Puntero = MaxPosiciondePuntero;
  67. 			play ();
  68. 		}
  69.  

En resumen:
Código:
sino si el dibujo puede ser simétrico
   averiguar si lo es, iniciando un while
      iniciar otro while, también necesario
         si se capta simetría
            terminar los while
         sino si se capta que no hay simetría
            terminar los while
      fin del while
   fin del while
   Si se captó simetría
      hacer A
   sino si es denso
      hacer B
   sino
      hacer C
sino si es denso
   hacer B
sino
   hacer C

Veo 2 problemas:
- Ifs fuera del while, que se cumplen del mismo modo que los de dentro, sin que vaya a haber cambios en el proceso.
- Código repetido.

En cuanto al 1er punto:
El código es parte de la función Variar, que se autollama en los casos A y B, así que los while deberían terminar antes de que se autollame, por eso no puedo hacer A dentro del while como correspondería.

El código repetido se podría evitar si se analiza siempre la simetría (quitar el else if inicial), pero no parece buena idea sabiendo que será necesario sólo a partir de cierto punto (el código se repite así que tampoco es que haya un punto fijo, sólo hay condiciones fijas).

No sé. Lo de simetría, por las dudas, no se refiere a si el dibujo es capicúa, sino que, al ser invertido (espejo | ) es igual a un dibujo hecho antes.

Es un programa que genera dibujos en blanco y negro siguiendo cierto órden.


Me gustaría poner un ejemplo más simple sobre esta estructura de código... A ver:
Código:
Si hace calor
   usar gorro
sino si el cielo está nublado
   averiguar si está lloviendo, iniciando un while
      iniciar otro while, también necesario
         si se capta lluvia
            terminar los while
         sino si se capta que no llueve
            terminar los while
      fin del while
   fin del while
   Si se captó lluvia
      usar paraguas
   sino si hay terremoto
      no salir
   sino
      hacer lo normal
sino si hay terremoto
   no salir
sino
   hacer lo normal
No es muy parecido porque no hay autollamadas. ¿Ese es el problema, debería evitarlas? Puedo poner un while al principio supongo... Repetir mientras el dibujo generado no sea ok. Probaré. ¿Alguna otra idea o sugerencia?

¿Y el código repetido cómo lo hago más eficiente?
88  Programación / Programación General / Simulación de choques desde atrás. en: 17 Noviembre 2024, 07:53 am
Barriles aparecen desde la izquierda, moviéndose a la derecha. Quiero que en vez de poder ocupar el mismo espacio (es un mundo 2d, los barriles están acostados y se ve su parte circular, como si fuese una rueda) y que uno pase al otro como si nada, se choquen, y que el de atrás pierda velocidad ¿se detenga? y el otro gane ¿lo mismo que la otra perdió? Pregunto porque no sé cómo sería más realista.

El principal problema que tengo es quizá por no saber Física. Se me ocurre algo así:
Se mueve el barril que está más a la izquierda.
luego el siguiente, y así sucesivamente hasta el más derecho.
Luego se va mirando desde la izquierda, a ver si quedó tocando a uno de delante, en cuyo caso el de atrás pierde velocidad y el de delante gana.
El problema es que a altas velocidades puede ocurrir algo así:
O sea, son 2 momentos distintos. En el 1ero, arriba, no se chocaron.
Abajo, se movieron, como indiqué, pero el de más izquierda se movía mucho más rápido que el del medio, que era más rápido que la derecha, así que quedaron tocándose los 3. Si en el programa pongo que I se detenga por tocar a M, y M se detenga por tocar a D, entonces I y M van a quedarse tocando y quietos, lo cual no es físicamente posible, sería que estén ocupando el mismo espacio.

¿Cómo lo hago bien?
89  Media / Juegos y Consolas / Sugerencias para historia de hackers. en: 17 Noviembre 2024, 05:48 am
Sigo con mi sueño de hacer un videojuego en que distintos personajes vayan viajando al mundo de otros, que esté alterado por los villanos de los que viajan.

¿Pero quién podría ser el enemigo? ¿quién inició eso y con qué objetivo?

Acabo de ver un resumen de la historia de FF 13-2, probablemente eso me inspiró un poco.

El enemigo podría ser un bug, o un hacker, pero para no dejar al concepto o estereotipo malparado, se me ocurrió poner hackers buenos también. Que no haya malos es más complicado, tal vez imposible, o tal vez si a todos los involucrados les falta información importante o por mala suerte o descuido hubo un gran malentendido. No sé, leo ideas.

Lo que se me había ocurrido es que el hacker malvado, o el grupo de hackers malvados, a pesar de los esfuerzos de los buenos, lograron dar consciencia a un villano, el cual va viajando a otros videojuegos para dar consciencia a otros villanos y reunirse todos en un mundo específico, tal vez Internet, con lo cual sería el fin de los videojuegos tal como los conocemos. Luego de todo el entrenamiento volverían a sus juegos con la capacidad de obtener información y dinero de los jugadores, todo lo cual se lo darían a los hackers malvados, ese es su plan. ¿Se les ocurre algo mejor?
Habría que explicar por qué el villano debe recorrer los mundos uno por uno en vez de ir directo a Internet. Tal vez simplemente no hay varios caminos, sólo uno que atraviesa todos los mundos. O para poder ir deben adquirir cierta cantidad de poder ¿para no perder su consciencia, lo vi en Ghost in the Shell?
Los buenos por su parte hicieron lo mismo con el héroe antagonista del villano, y se dedican a proteger a los demás héroes, para que no mueran por el ataque de los villanos, que están adelantados. Algunos podría ser que estén engañados, hipnotizados, debilitados, etc, y haya que recuperarlos.

Otra idea era que el hacker malvado quería convertirse en el final boss de un videojuego, por lo que de algún modo se proyectó en uno, y empezó a hacer desmadres dejando a los héroes más o menos intactos para que lo persigan.

Slayers Try también tuvo algo que ver con estas ideas xP Y Ralph el demoledor pero lo vi hace mucho.

Es como "the ultimate goal" de los hackers malvados: Dar consciencia a un villano virtual, capaz de modificar software a una velocidad y profundidad y con una facilidad que la humanidad no podríad xD
90  Informática / Software / En Excel, especificar fórmulas más rápido. en: 16 Noviembre 2024, 06:26 am
​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?
Páginas: 1 2 3 4 5 6 7 8 [9] 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ... 51
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines