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

 

 


Tema destacado: Recuerda que debes registrarte en el foro para poder participar (preguntar y responder)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación General
| | |-+  Busco eficiencia, tengo while con función y quiero evitar un if.		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Busco eficiencia, tengo while con función y quiero evitar un if.  (Leído 898 veces)
Tachikomaia


Desconectado Desconectado

Mensajes: 1.460


Hackentifiko!


Ver Perfil
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?
En línea
Danielㅤ


Desconectado Desconectado

Mensajes: 1.853


🔵🔵🔵🔵🔵🔵🔵


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #1 en: 22 Noviembre 2024, 14:12 pm »
Hola, desde mi punto de vista, lo más rápido es C y que trabaje en modo oculto, es decir que no utilice ventana gráfica (GUI) ni tampoco la consola, aunque no lo parezca, pero la consola lo hace un poco más lento y más si tiene que imprimir datos por la ventana.


Saludos


En línea
Tachikomaia


Desconectado Desconectado

Mensajes: 1.460


Hackentifiko!


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #2 en: 22 Noviembre 2024, 18:30 pm »
Creo que te confundiste de tema, tu respuesta sería para el tema de los passwords. Si es así, dime y lo hablamos allá, o sea acá:
https://foro.elhacker.net/programacion_general/iquestcomo_generar_passwords_rapido_flash_es_muy_lento_y_mi_pc_creo_que_no_resiste-t522729.0.html;topicseen
En línea
Danielㅤ


Desconectado Desconectado

Mensajes: 1.853


🔵🔵🔵🔵🔵🔵🔵


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #3 en: 22 Noviembre 2024, 18:48 pm »
Jajaja si me he confundido, la respuesta era para el otro tema de los passwords, el mismo que pusiste en el link, ya he respondido ahí.


Saludos y gracias por notar y comentar la confusión.
En línea
Tachikomaia


Desconectado Desconectado

Mensajes: 1.460


Hackentifiko!


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #4 en: 24 Noviembre 2024, 07:26 am »
Si en vez de while usara autollamadas o llamadas a la función similar, sería el fin del problema. Lo hice pero me di cuenta de 2 cosas:
> Luego de que se detecta simetría y hay variaciones, los análisis posiblemente deberían ser completos, es decir como VariarLuegoDeSimetria, así que las funciones serían más distintas de lo que pensé, VariarLuegoDeSimetria podría tener que autollamarse donde normalmente se llamaría a Variar.
> Luego de que se detecta simetría y se despinta un cuadradito, el chequeo de aislados posiblemente debe ser completo.
...Intento evitar que el programa haga análisis en vano, pero es muy complicado parece, así que parece que conviene que el análisis sea completo siempre.

O sea, puse que cuando se pinta/despinta un cuadradito, mire de todos los contiguos a ver si estaban aislados. Dudo que sea lo más eficiente pero me resulta muy complicado todo esto, ni siquiera estoy seguro de haber logrado resultados correctos, pero eso es otro tema.
En línea
Danielㅤ


Desconectado Desconectado

Mensajes: 1.853


🔵🔵🔵🔵🔵🔵🔵


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #5 en: 25 Noviembre 2024, 01:06 am »
Eso de los cuadritos lo podes hacer de la siguiente forma:

Cuando pintas un cuadrito, guardas en una variable o array las posiciones o items de los cuadritos contiguos, entonces cuando el programa vaya a pintar otro cuadrito, hará la comprobación por ejemplo si X's posiciones están en ese array y si lo están, entonces podrás saber si falta alguno por pintar y cuales son esos cuadritos (posición).
En línea
Tachikomaia


Desconectado Desconectado

Mensajes: 1.460


Hackentifiko!


Ver Perfil
Re: Busco eficiencia, tengo while con función y quiero evitar un if.
« Respuesta #6 en: 25 Noviembre 2024, 08:12 am »
No te entiendo y lo explicaré más pues quizá me faltó, no sé.

El programa luego de hacer dibujos de 3x3 hace de 4x4, empezando así:
BBBN
BBNB
BNBB
NBBB
Donde N es negro y B blanco. Traza una / no viene al caso por qué.

Luego pinta o despinta cuadraditos desde abajo hacia la izquierda, por lo que el siguiente dibujo será:
BBBN
BBNB
BNBB
NBBN

Están nombrados así:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
Y pinta/despinta desde el 16, haciendo todas las combinaciones posibles.

Debido a esa forma conque pinta/despinta, cuando se quiere saber si el recién pintado está aislado, no es necesario chequear el de la derecha ni los de abajo. Porque todos estarán despintados. Es como cuando reduces lo mínimo posible al binario 1000, te va a quedar 0111, no sé si realmente es así en binario pero el punto es que cuando disminuye algo de adelante, todo lo demás queda al máximo, que en este caso es despintado (pintado=0 porque en Flash el color negro es 0, así no me entrevero en eso, y 1 es despintado, blanco). Por lo tanto, había puesto que esos análisis innecesarios no se hagan.

Por otro lado, se quiere que los dibujos no sean simétricos (espejo | ) a otros ya hechos, porque son iguales pero al revés, es aburrido. No confundir conque el dibujo sea simétrico. Esto es simétrico:
NBBN
BBBB
NNNN
NBBN
o capicúa, como quieran. Pero lo que yo digo es simétrico a uno ya hecho, por ejemplo este:
NNBB
BBBB
BBBB
BBBB
es simétrico a:
BBNN
BBBB
BBBB
BBBB
que fue hecho antes. Para saber si fue hecho antes, se usan los números. Como di a entender, los dibujos con más valor son hechos antes. El cuadradito 1 empieza teniendo valor 1, el 2 también, etc, y el valor va bajando como dije en el ejemplo de los binarios. La fila superior del que se quiere analizar (NNBB) es 0011. Si eso es < que su inverso (1100) entonces su simétrico ya fue hecho y ese dibujo no debe mostrarse. No me acuerdo de memoria el resto, acá está:
Código
  1. 				// El dibujo puede ser simétrico...
  2. 				// a otro ya mostrado. ¿Lo es?
  3. 				// Esto puede cambiar:
  4. 				DibujoEsSimetrico = "No";
  5. 				// Captar valor (colores) de cada fila;
  6. 				// si alguno es menor al inverso, sí:
  7. 				PunteroDeFilas = 0;
  8. 				do {
  9. 					PunteroDeFilas++;
  10. 					PunteroDeColumnas = 0;
  11. 					PunteroInverso = CuadraditosPorFila;
  12. 					do {
  13. 						PunteroDeColumnas++;
  14. 						Valor = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroDeColumnas);
  15. 						ValorInverso = eval("Cuadradito"+PunteroDeFilas+"_"+PunteroInverso);
  16. 						// trace("Valor: "+Valor);
  17. 						// trace("ValorInverso: "+ValorInverso);
  18. 						if (Valor<ValorInverso) {
  19. 							DibujoEsSimetrico = "Sí";
  20. 							FilaFallada = PunteroDeFilas;
  21. 							PunteroDeFilas = CuadraditosPorFila;
  22. 							break;
  23. 						} else if (Valor>ValorInverso) {
  24. 							// Es ok:
  25. 							PunteroDeFilas = CuadraditosPorFila;
  26. 							break;
  27. 						}
  28. 						PunteroInverso--;
  29. 					} while (PunteroDeColumnas<CuadraditosPorFila);
  30. 				} while (PunteroDeFilas<CuadraditosPorFila);
Ya más o menos comprobé que eso puede ocurrir desde que un superior izquierdo está pintado:
IIDD

Bueno, cuando se capta un simétrico, intenté evitar que se produzcan dibujos que también lo serán. Para eso, en vez de mandar el Puntero hacia el inferior derecho, lo mando al final de la fila que se captó como "fallida". Porque si por ejemplo el error está en la fila superior, hacer todas las variaciones posibles en filas inferiores es inútil, el dibujo seguirá siendo simétrico. No es el método ideal de evitarlos, sólo lo mejor que se me ocurrió.
Pero al cambiar el lugar a donde va el Puntero en esos casos, ahora sí es necesario chequear otros cuadraditos. O eso creo... antes desde que se captaba una simetría el contador de cuadraditos aislados me daba -1 a partir de cierto punto, está mal, y dibujos que estaban bien los consideraba con muchos aislados. En fin, yo no puedo entender todo esto todo el tiempo, a veces me olvido de algunas cosas. Vamos a ver un caso concreto, este es el 1er simétrico que capta en 4x4:

Los que pinté de rojo es que están aislados. ¿Por qué ese es el 1er simétrico captado? Supongo que porque otros anteriores fueron descartados por otros motivos (es "pequeño" o tiene demasiados aislados).
1010 > 0101 así que no debería captarse como simétrico, m... Lo grabo en video a ver si lo entiendo mejor. Como se saltea dibujos, no sé bien qué pasa, y no tengo ganas de cambiar el code ahora y ver otra vez:
https://youtu.be/e-Qn3K8t_3A

Luego de esto:

Se pinta el inferior derecho y se capta como dibujo denso (demasiados pintados).
Luego quedará así:
BNBB
BBBB
BBBB
BBBB
Se considera "pequeño" (hay alguna columna o fila donde no hay un pintado), y en este caso especial (el mínimo pintado disminuyó, o sea, el 1er pintado era el 3, ahora el 2), para evitar simétricos supongo, se pone el Puntero en el superior derecho, por lo que el siguiente es:
BNBN
BBBB
BBBB
BBBB
Pequeño. Ahora el Puntero se pone en el inferior derecho. Y sigue, pero no entiendo por qué se considera simétrico el mencionado antes, tendré que pensarlo.

La cosa es que yo quería evitar hace los análisis innecesarios, pero ahora a veces lo son así que podría poner un if para ver si debe hacer el análisis completo o no, pero no quiero poner ese if, no sé, eso es lo que recuerdo de todo esto xP Por ahora puse que se haga el análisis completo siempre.


EDIT: El error estaba en una parte del código que no mostré porque no pensé que pudiera tener un error. Cuando el dibujo se agranda, a cada cuadradito se le asigna color de 3 maneras, o mejor dicho hay 3 variables que guardan el mismo color, aunque puede que con distinto valor:
- La normal, la que tiene efecto directo, cambia el color del cuadradito.
- ColordeCuadradito1, ColordeCuadradito2, etc, los valores son 0 para negro y 1 para blanco.
- Cuadradito1_1, Cuadradito1_2, etc, es igual que el anterior pero se indica con filas y columnas.
Bueno, en ese momento se hacía:
set ("Cuadradito"+(Fila+1)+"_"+(Columna+1), "FFFFFF");
Luego al hacer el análisis de simetría, en unos traces decía:
Analizando fila 1, columna 1
Valor: FFFFFF
ValorInverso: 0
Analizando fila 1, columna 2
Valor: 0
ValorInverso: 1
0 < 1
...No se interpretaba que "FFFFFF" fuese > 0. causando el error. Lo corregí poniendo 1 en vez de "FFFFFF" cuando se define, nunca se usa el "FFFFFF" excepto para asignar el color real, pero no necesita estar definido ahí.
« Última modificación: 27 Noviembre 2024, 06:19 am por Tachikomaia » En línea
Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Busco un juego.. sólo quiero saber el nombre
Juegos y Consolas 		xayurix 0 1,724 Último mensaje 12 Diciembre 2005, 00:00 am
por xayurix
tengo dos dvd y quiero juntarlos
Multimedia 		pointter 1 3,153 Último mensaje 5 Diciembre 2010, 21:08 pm
por Songoku
tengo las pass, busco user
Seguridad 		ruben_linux 2 2,836 Último mensaje 6 Diciembre 2011, 19:33 pm
por ruben_linux
Busco portátil y no encuentro el que yo quiero
Hardware 		javirita 7 3,886 Último mensaje 11 Febrero 2016, 03:00 am
por RMDGodoy96
Tengo 19 años y quiero comenzar
Foro Libre 		Refleck 8 4,501 Último mensaje 13 Junio 2021, 18:26 pm
por VictorVe
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines