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


Tema destacado: Estamos en la red social de Mastodon


  Mostrar Mensajes
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 436
1  Foros Generales / Foro Libre / Re: Conflicto Ucrania-Rusia,EEUU, OTAN, Europa. (Todas las noticias relacionadas irán aquí) en: 2 Marzo 2025, 02:46 am
...

Nada más llegar a la casa blanca le hizo como una broma a Zelensky respecto a su vestimenta vamos lo que viene ser reirse de su forma de vestir.
...

La mofa de Trump sobre la vestimenta de Zelenski: "Hoy se ha arreglado". Al llegar a la Casa Blanca el presidente de EEUU le recibió con comentarios sobre su vestuario. Una vez en rueda de prensa, uno de los periodistas vuelve a referirse al atuendo, preguntándole al presidente ucraniano si no piensa ponerse traje y si tiene en su armario dicha vestimenta.
...
Supo darle buena respuesta (si no leí mal).
"Cuando termine la guerra me compraré uno (traje) como el tuyo"...
2  Programación / .NET (C#, VB.NET, ASP) / Re: Ejercicio básico de combinaciones en: 2 Marzo 2025, 02:32 am
Preguntando a un amigo que suele jugar a la Bonoloto, me señala que el valor de cada apuesta es de 0'50e. y que el máximo de apuestas (por boleto, jugando múltiples apuestas) son 462, jugando 11 números.

Si quisieras conocer las combinaciones, que se apuestan con 11 números, ya deberías  tener claro como generar dicha lista con: "ADBCDE" y "FGHIJK" y obtendríamos las 426 combinaciones... donde cada letra representa exclusivamente uno de los 11 numeros jugados (11 letras = 11 números).
------------------------------------------------------------------------------------------------------------------------
ABCDEF
ABCDEG
ABCDEH
ABCDEI
ABCDEJ
ABCDEK
ABCDFG
ABCDFH
ABCDFI
ABCDFJ
ABCDFK
...
DFGHIJ
DFGHIK
DFGHJK
DFGIJK
DFHIJK
DGHIJK
EFGHIJ
EFGHIK
EFGHJK
EFGIJK
EFHIJK
EGHIJK
FGHIJK
Números en apuesta: 11
Total de Combinaciones/apuestas: 462


La teoría de las probabilidades establece igualdad de apariciones para cada combinación y número, sin embargo hay cierto concepto que puede darnos cierta perspectiva... y que paso a señalarte...

Si sumamos los valores de todas las combinaciones y la dividimos entre el número de combinaciones totales tendremos la media de la suma de los valores de las combinaciones.
La tendencia será siempre hacia ese valor. Dicho de otro modo, es el valor que más veces aparecerá.

Como hay casi 14 millones de combinaciones y al final en ellas cada número aparece el mismo número de veces, puede ser resumido y calculado prácticamente a mano de la siguiente manera (luego lo resuminos para hacer el cálculo mentalemnte):
1+2+3+4+5+6 = 21
2+3+4+5+6+7 = 27
3+4+5+6+7+8 = 33
(se calcula como la suma de ambos extremos por 3, ya que la suma 1+6 = 2+5 = 3+4 ... pero también podemos hacerlo más sencillo, pués vemos que cada combinación así formada crece exactamente en 6 respecto de la anterior, que es el resultado de añadir 1 cada valor en la combinación previa (cada vez)...)
la sumas finales son:
42+43+44+45+46+47 = 267
43+44+45+46+47+48 = 273
44+45+46+47+48+49 = 279

Dicho de otro modo... se puede finalmente simplicar con un simple bucle tal que así:
Código:
bucle para k desde 21 hasta 279 en pasos de 6
   j +=k
   i +=1
siguiente

TendenciaMediaDeLaSuma = (j/i)
Resultado:  (6600  /  44) = 150
Y por tanto el valor medio no es otro que el valor equidistante de los extremos, es decir entre 1 y 49 el punto medio es el 25. Si 25 es el punto medio y hay que jugar 6 valores, la suma media pues será: 6*25 = 150.
También puede calcularse como ((suma minima + suma maxima)/2) = ((279+21)/2) = 150.
Ese valor de 150 se puede calcular de varias formas como se puede ver, y desde la remota cuenta que exigía sumar los valores para los 14millones de combinaciones hasta el bucle y finalmente el cálculo mental, se ha progresado, pero es importanto entenderlo.

Si tuvieras almacenado suficientes resultados con la combinación ganadora y se hicera una estadíscia se dibujaría la famosa campana de Gauss, que es el alma de la aleatoriedad y la que refleja, los límites fuera d elos cuales no conviene apostar...

Te señalo como dibujarlo:
En los horizontales reflejaríamos los valores de suma, comenzando por 21 y acabando por 279, una columna por cada. Entre consecutivos ya ves que el que esté a su derecha, el valor es +6 del previo), y en los verticales se debe dibujar el número de apariciones que ha salido esa suma... es decir pondremos un punto en cada columna x (que representa la suma), a la altura y (que resulta de contar las veces que se ha dado esa suma), finalmente al unir con una línea esos puntos entre sí, tendríamos que el dibujo corresponde a la campana de Gauss. El valor pico, correponderá al 150.
Si no es así, puede afirmarse fuera de toda duda que el sistema no es del todo aleatorio, y por tanto habría que procurar que la suma de los valores en tus apuestas (como referencia), sea justamente el que se señalare como el pico en vez del valor 150...

Bien, pues si haces tus apuestas mira que la suma de los valores que apuestas, no se alejen mucho de esa cifra (150). Sigas el sistema que sigas, ten siempre esto en cuenta... de hecho si lllegas a trazar la campana, podrías señalar los dos puntos límites (uno a cada lado del pico), tras los cuales desciende drásticamente y por tanto te señalarían los límites adecuados para los que no conviene que tu apuesta sobrepasen.

Las regla formal del foro (y que estrictamente no tiene sentido siendo un foro de lectura y búsqueda pública), es no responder mensajes de más de 90 días de antigüedad... pero, pensaba que eras un usuario que aparecía con una duda puntual y ya, que luego desaparecía... pero veo que tu última entrada es de '30 noviembre 2024 (alrededor de hace 90 días), que tienes bastantes cientos de mensajes (no meramente 10-20 mensajes de haber interaccionado en 4-5 hilos) y veo también que tu interés se centra mucho en la combinatoria para usar en las apuestas...

El caso es que este mensaje que me autocito, era y es y siempre será muy interesante y pasó 'sin pena ni gloria'. Habría esperado por tu parte (@luis456) cierto interés, porque surge la interesante idea de generar la combinatoria de todas las combinaciones que surjan de cumplir la tendencia (del valor 150) o una desviada de ese valor, a uno u otro lado, conforme a la campana de Gauss...

De hecho es más interesante (generar las secuencias que comento en el párrafo anterior) que generar combinaciones con cierto criterio pero sin relevancia estadística (como la presente que da origen al hilo), "en fin Serafín..."
3  Foros Generales / Noticias / Re: Hackers vinculados a Corea del Norte roban el mayor botín de la historia de las criptomonedas: 1.500 millones de dól en: 2 Marzo 2025, 01:00 am
No deja de ser curioso, que para ser Corea del Norte un país atrasado en todo, sin embargo tengan 'informáticos' tan al punto que sean no solo buenos hackers, si no aparentemente maestros (al menos para el robo de datos)... o quizás la seguridad de ciertos sitios es tan lamentable que simplemente no sospechamos que lo sea?
4  Foros Generales / Foro Libre / Re: Trump abronca a Zelenski, que deja la Casa Blanca sin acuerdo: "Estás jugando con la III Guerra Mundial, vuelve cuan en: 2 Marzo 2025, 00:47 am



Ese tío es un sinvergüenza el que está en la casa blanca esto que ha pasado hoy no se ha visto nunca o yo no recuerdo algo así, intentando intimidar a zelensky echando en cara toda la ayuda militar que se le ha dado, que por cierto se lo dio biden y con mucho justo a cambio de nada, pero Trump se lo quiere cobrar a cambio de las famosas tierras raras que hay en Ucrania que sirven para ellos seguir compitiendo con china en tecnología eso si a costa de otros países aprovechándose de que Ucrania está en guerra y necesita mas ayuda militar y encima el cara dura de Trump intimidando para que firme ese acuerdo a cambio de no darle ninguna garantía de seguridad a Ucrania como es entrar en la Otan o por ejemplo darle mas ayudar militar, espero que no caigan en la trampa de estos locos como es Trump y Putin espero que sea listo y no firme ese acuerdo jamás por lo menos con Trump.

Además Estados Unidos debería estar fuera de las negociaciones pienso yo aquí los que tienen que negociar la supuesta paz es entre Rusia y Ucrania y en esa mesa de negociaciones tiene que estar Europa para eso esta el conflicto en nuestro territorio y no el otro charco como decía Zelensky.

Europa debería romper relaciones de alianzas totalmente con Estados Unidos mientras Donald Trump este de mandato luego ya se verá espero que se lo planteen muy enserio.

Vomitivo el comportamiento chulesco de Trump y su perrito faldero...

Su idea de someterlo a la TV. intuyo que tenía por objetivo forzarlo a aceptar para no verse afectado por miedo al ridículo etc... vaya táctica miserable... Pero Zelensky ha aguantado bien el tipo, quizás gracias a que como actor, está acostumbrado a las cámaras y al público y no le imponen, que parece sería el objetivo de Trump, explotar las debilidades humanas en su favor... trucos sucios de empresario barato.

Creo que podemos tachar a EE.UU. de la lista de aliados mientras este fantoche siga de presidente... 
5  Programación / Programación General / Re: ¿Qué método es recomendado para ordenar al azar un array? en: 2 Marzo 2025, 00:31 am
...

Intenté imitarlo pero como no sé exacto cómo funciona y esos nombres j e i me entreveran, decidí buscar en Wikipedia.
https://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
...
Cuidado, es fácil que al tratar de implementar el algoritmo se haga con ligeras diferencias, y que ya podría no cumplir todo su cometido, especialmente si caes en la versión Sattolo... (que genera secuencias cíclicas).


¿Es así? ¿hay otro mejor?
Y no, no hay otro mejor es el algoritmo más simple para hacer esta tarea...
Código:
Cantidad = Tamaño(Array)  
 Recorrer con k desde Cantidad-1 hasta 1 Regresivamente
    az = Random(entre 0 y k)
        
    tmp = Array(az)
    Array(az) = Array(k)
    Array(k) = tmp
 Siguiente
6  Programación / Programación General / Re: ¿Cual es el método más eficiente para ver si hay una línea de S signos? en: 2 Marzo 2025, 00:15 am
Antes que nada, los temas se responden en su hilo, no por privado...

...
Ya imprimí tu código hace días y lo estoy entendiendo un poco más.

Estas son mis dudas por ahora:

Pones:
buleano funcion Buscar(puntos, jugador, Fila, Columna, dF, dC)
¿qué es dF y dC?
dF y dC, son los nombres de dos parámetros cuyo significado es: 'diferencia de Filas y diferencia de Columnas.
Nota como en las líneas que llaman a dicha función, el valor que se entrega y recibiría ese parámetro puede ser un valor positivo, negativo o cero, en algún caso es el resultado de una suma o una resta, del valor allí actual ±1

Pones:
mientras tablero(Fila, Columna) = jugador
¿Has definido una función tablero? No la veo.
¿El tablero lo has definido como un array? Por ejemplo tablero = [3, 3, 3, 3, 3, 0, 0, 0, 0, 0...]
En efecto, Tablero es un array... no lo he definido en el pseudocódigo, por que ¿es evidente, no?.

Tu idea de poner casilleros que no se usan parece facilitar las cosas, pero no eficiente, por eso no me agrada del todo.
Cómo que no es eficiente?.

En un array de 3x3 (que es pequeño), ciertamente se traslada a un array de 5x5, que entre 9 y 25 hay diferencia... pero  ¿cuantos arrays de éstos vas a usar a la vez, 500?. Pues incluso con 500 arrays es más eficiente, el consumo de memoria es despreciable (salvo que estuvieres operando con un equipo con una memoria de pocos Mb. Apenas tengas 1Gb. ... es insignificante.
El caso es todavía más absurdo, si solo vas a usar 1-5 arrays (que muy probablemente se limite a solo 1 o 2) a la vez.

Más aún, cuanto mayor sea el tablero, más insignificante es ese añadido, pues siempre añade filas*2 + columnas*2 + 4. Así si tu Tablero es de (por ejemplo) 100x100 (10.000 elementos), el tamaño de la solución sería de 102x102 (100*4 + 4 = añade 404, en total 10.404), que como se ve, ya no es casi el triple del tamaño como sucedía en el tablero de 3x3 (278%), ahora es solo de un 104'04%...

Calcula cuanto es para un tablero de 1000x1000... verás que cuanto más grande es el tablero, menos porcentaje supone cercarlo perimetralmente con una casilla más.

En cuanto a la eficiencia en uso durante la progrtamación es extremadamente sencillo controlarlo y por tanto es muy eficiente, pues solo se busca la comprobación TRUE/FALSE en validaciones simples, de otro modo tienes que hacer más complejo cada caso, además de múltiples lineas de código y código más farragosos de leer y modificar... En cualquier caso, puedes recrear ambos modelos, y probarlos en bucle miles o decenas de miles de veces (en igualdad absoluta de condiciones), y verificar tiempos de ejecución entre ambos.

Cuando hagas una afirmación asegúrate que sea fundada, si no e spreferible callarse hasta comprobarlo, y si es una opinión, no es adecuado opinar públicamente sin haberse asegurado de lo que se dice, piensalo para ti, pero si no lo pones a prueba estarás dejando la posibilidad de aprender.

Por mi parte logré esto:
- Posibilidad de agrandar/achicar el tablero (hacerlo reinicia la partida).
- Posibilidad de elegir qué tan larga debe ser la línea (idem).
- Se detecta la victoria cuando se requiere 1 y se pone 1.
- La máquina pone en posiciones al azar donde no haya signo, funciona bien al menos con tablero 3x3.
- Se detecta la victoria/derrota cuando se requiere 2 y se ponen 2 contiguos en cualquier sentido. Funciona bien en tablero de 3x3.
Falta poner casos de empate y otras cosas...
Está bien que logres completar objetivos...

Código
  1. function HacerTablero () {
  2. // Esto se irá especificando en el while:
  3. Situacion = [];
  4. PosiblesAcciones = [];
  5. // Los casilleros se cuentan desde 0:
  6. MaxCasillero = CasillerosPorFila*CasillerosPorFila-1;
  7. LargoDeCasilleros = 384/CasillerosPorFila;
  8. NroDeCasilleroaColocar = -1;
  9. // Sus columnas y filas se cuentan desde 0,
  10. // sirven para posicionarlos más fácil:
  11. Columna = 0;
  12. Fila = 0;
  13. do {
  14. NroDeCasilleroaColocar++;
  15. // v es vacío:
  16. Situacion.push("v");
  17. PosiblesAcciones.push(NroDeCasilleroaColocar);
  18. CasilleroaColocar = "Casillero"+NroDeCasilleroaColocar;
  19. // set ("SignoEn"+CasilleroaColocar, "v");
  20. // sCasillero tiene código.
  21. attachMovie("sCasillero", CasilleroaColocar, NroDeCasilleroaColocar);
  22. setProperty (CasilleroaColocar, _x, LargoDeCasilleros*Columna);
  23. setProperty (CasilleroaColocar, _y, LargoDeCasilleros*Fila);
  24. setProperty (CasilleroaColocar, _width, LargoDeCasilleros);
  25. setProperty (CasilleroaColocar, _height, LargoDeCasilleros);
  26. Columna = Columna+1;
  27. if (Columna == CasillerosPorFila) {
  28. Columna = 0;
  29. Fila = Fila+1;
  30. }
  31. // Para que al presionar el botón se sepa qué modificar:
  32. set (CasilleroaColocar+".CasilleroAsociado", NroDeCasilleroaColocar);
  33. // trace("Colocado el "+NroDeCasilleroaColocar);
  34. } while (NroDeCasilleroaColocar<MaxCasillero);
  35. // Para que no muestre el mensaje de victoria:
  36. Win = "No";
  37. }
  38. function HumanoHaMarcado () {
  39. // Inutilizar botón del casillero marcado:
  40. setProperty (eval("Casillero"+CasilleroMarcado+".Boton"), _visible, false);
  41. // Agregar cruz:
  42. // SignosColocados++;
  43. eval("Casillero"+CasilleroMarcado).attachMovie("sCruz", "Cruz", 1);
  44. Situacion[CasilleroMarcado] = "X"
  45. // set ("SignoEnCasillero"+CasilleroMarcado, "X");
  46. // ¿Gana?
  47. if (JuntosRequeridos == 2) {
  48. ObtenerColumnayFilaDelMarcado();
  49. // Para saber si el cuadradito marcado no tiene...
  50. // contiguos hacia algún lado:
  51. ObtenerExcepciones();
  52. trace("Aplicando ChequeoDe2Excepto"+FuncNamePart1+FuncNamePart2);
  53. eval("ChequeoDe2Excepto"+FuncNamePart1+FuncNamePart2)();
  54. } else if (JuntosRequeridos == 1) {
  55. Win = "Sí";
  56. }
  57. if (Win == "Sí") {
  58. // Sí, inutilizar botones del tablero
  59. // (debería ser sólo los activos):
  60. InutilizarBotones();
  61. // Mostrar mensaje de victoria:
  62. attachMovie("sGanoX", "Mensaje", NroDeCasilleroaColocar+1);
  63. setProperty (Mensaje, _x, 192.4);
  64. setProperty (Mensaje, _y, 192);
  65. gotoAndStop (3);
  66. } else {
  67. // Quitar su acción de las posibles acciones:
  68. // Se busca en qué posición del array está:
  69. AccionRevisandose = -1;
  70. // Esto es para evitar restas:
  71. LastNroDeAcccion = PosiblesAcciones.length-1;
  72. // Probablemente sea ok poner true en la condición:
  73. do {
  74. AccionRevisandose++;
  75. if (PosiblesAcciones[AccionRevisandose] == CasilleroMarcado) {
  76. // Se sustituye por la que está última:
  77. PosiblesAcciones[AccionRevisandose] = PosiblesAcciones[LastNroDeAcccion];
  78. // Se elimina la última:
  79. PosiblesAcciones.pop();
  80. break;
  81. }
  82. } while (AccionRevisandose < LastNroDeAcccion);
  83. LastNroDeAcccion--;
  84. // Elegir una acción al azar:
  85. NroDeAccionElegida = random(PosiblesAcciones.length);
  86. AccionElegida = PosiblesAcciones[NroDeAccionElegida];
  87. // Eliminar la que está en el nro elegido:
  88. // Se sustituye por la que está última:
  89. PosiblesAcciones[NroDeAccionElegida] = PosiblesAcciones[LastNroDeAcccion];
  90. // Se elimina la última:
  91. PosiblesAcciones.pop();
  92. eval("Casillero"+AccionElegida).attachMovie("sCero", "Cero", 0);
  93. Situacion[AccionElegida] = 0;
  94. // Inutilizar el botón de ahí:
  95. setProperty (eval("Casillero"+AccionElegida+".Boton"), _visible, false);
  96. // Ver si 0 ganó:
  97. CasilleroMarcado = AccionElegida;
  98. if (JuntosRequeridos == 2) {
  99. ObtenerColumnayFilaDelMarcado();
  100. // Para saber si el cuadradito marcado no tiene...
  101. // contiguos hacia algún lado:
  102. ObtenerExcepciones();
  103. trace("Aplicando ChequeoDe2Excepto"+FuncNamePart1+FuncNamePart2);
  104. eval("ChequeoDe2Excepto"+FuncNamePart1+FuncNamePart2)();
  105. if (Win == "Sí") {
  106. // Sí, inutilizar botones del tablero
  107. // (debería ser sólo los activos):
  108. InutilizarBotones();
  109. // Mostrar mensaje de victoria:
  110. attachMovie("sGano0", "Mensaje", NroDeCasilleroaColocar+1);
  111. setProperty (Mensaje, _x, 192.4);
  112. setProperty (Mensaje, _y, 192);
  113. gotoAndStop (3);
  114. }
  115. }
  116. }
  117. // _level0.ObtenerSituacion();
  118. }
  119. function ObtenerColumnayFilaDelMarcado () {
  120. FilaDelMarcado = Math.floor(CasilleroMarcado/CasillerosPorFila);
  121. trace ("Su Fila según el cálculo es: "+FilaDelMarcado);
  122. ColumnaDelMarcado = CasilleroMarcado%CasillerosPorFila;
  123. trace ("Su Columna: "+ColumnaDelMarcado);
  124. }
  125. function ObtenerExcepciones () {
  126. if (FilaDelMarcado != 0) {
  127. if (FilaDelMarcado != CasillerosPorFila0) {
  128. FuncNamePart1 = "";
  129. } else {
  130. FuncNamePart1 = "Abajo";
  131. }
  132. } else {
  133. FuncNamePart1 = "Arriba";
  134. }
  135. if (ColumnaDelMarcado != 0) {
  136. if (ColumnaDelMarcado != CasillerosPorFila0) {
  137. FuncNamePart2 = "";
  138. } else {
  139. FuncNamePart2 = "Derecha";
  140. }
  141. } else {
  142. FuncNamePart2 = "Izquierda";
  143. }
  144. }
  145. // Chequear todo, no hay excepción especificada:
  146. function ChequeoDe2Excepto () {
  147. // 012
  148. // 3x5
  149. // 678
  150. Desde = -1;
  151. Hasta = 3;
  152. Incremento = 1;
  153. ChequeoDe2();
  154. if (Win == "No") {
  155. Desde = 4;
  156. Hasta = 8;
  157. Incremento = 1;
  158. ChequeoDe2();
  159. }
  160. }
  161. function ChequeoDe2ExceptoArriba () {
  162. // 0x2
  163. // 345
  164. // 678
  165. Desde = 1;
  166. Hasta = 5;
  167. Incremento = 1;
  168. ChequeoDe2();
  169. if (Win == "No") {
  170. if (Situacion[CasilleroMarcado] == Situacion[0]) {
  171. Win = "Sí";
  172. }
  173. }
  174. }
  175. function ChequeoDe2ExceptoAbajo () {
  176. // 012
  177. // 345
  178. // 6x8
  179. Desde = 2;
  180. Hasta = 6;
  181. Incremento = 1;
  182. ChequeoDe2();
  183. if (Win == "No") {
  184. if (Situacion[CasilleroMarcado] == Situacion[8]) {
  185. Win = "Sí";
  186. }
  187. }
  188. }
  189. function ChequeoDe2ExceptoIzquierda () {
  190. // 012
  191. // x45
  192. // 678
  193. Desde = -2;
  194. Hasta = 7;
  195. Incremento = 3;
  196. ChequeoDe2();
  197. if (Win == "No") {
  198. Desde = -6;
  199. Hasta = 6;
  200. Incremento = 6;
  201. ChequeoDe2();
  202. }
  203. }
  204. function ChequeoDe2ExceptoDerecha () {
  205. // 012
  206. // 34x
  207. // 678
  208. Desde = -2;
  209. Hasta = 7;
  210. Incremento = 3;
  211. ChequeoDe2();
  212. if (Win == "No") {
  213. Desde = -4;
  214. Hasta = 8;
  215. Incremento = 6;
  216. ChequeoDe2();
  217. }
  218. }
  219. function ChequeoDe2ExceptoArribaIzquierda () {
  220. // x12
  221. // 345
  222. // 678
  223. Desde = 2;
  224. Hasta = 4;
  225. Incremento = 1;
  226. ChequeoDe2();
  227. if (Win == "No") {
  228. if (Situacion[CasilleroMarcado] == Situacion[1]) {
  229. Win = "Sí";
  230. }
  231. }
  232. }
  233. function ChequeoDe2ExceptoArribaDerecha () {
  234. // 01x
  235. // 345
  236. // 678
  237. Desde = 2;
  238. Hasta = 5;
  239. Incremento = 1;
  240. ChequeoDe2();
  241. if (Win == "No") {
  242. if (Situacion[CasilleroMarcado] == Situacion[1]) {
  243. Win = "Sí";
  244. }
  245. }
  246. }
  247. function ChequeoDe2ExceptoAbajoIzquierda () {
  248. // 012
  249. // 345
  250. // x78
  251. Desde = 2;
  252. Hasta = 4;
  253. Incremento = 1;
  254. ChequeoDe2();
  255. if (Win == "No") {
  256. if (Situacion[CasilleroMarcado] == Situacion[7]) {
  257. Win = "Sí";
  258. }
  259. }
  260. }
  261. function ChequeoDe2ExceptoAbajoDerecha () {
  262. // 012
  263. // 345
  264. // 67x
  265. Desde = 3;
  266. Hasta = 5;
  267. Incremento = 1;
  268. ChequeoDe2();
  269. if (Win == "No") {
  270. if (Situacion[CasilleroMarcado] == Situacion[7]) {
  271. Win = "Sí";
  272. }
  273. }
  274. }
  275. //
  276. function ChequeoDe2 () {
  277. Win = "No";
  278. do {
  279. Desde = Desde+Incremento;
  280. trace("Chequeando "+Desde);
  281. if (Situacion[CasilleroMarcado] == Situacion[Desde]) {
  282. Win = "Sí";
  283. break;
  284. }
  285. } while (Desde < Hasta);
  286. }
  287. function InutilizarBotones () {
  288. BotonesInutilizados = -1;
  289. do {
  290. BotonesInutilizados++;
  291. setProperty ("Casillero"+BotonesInutilizados+".Boton", _visible, false);
  292. } while (BotonesInutilizados<MaxCasillero);
  293. }
  294. CasillerosPorFila = 3;
  295. // Contando desde 0:
  296. CasillerosPorFila0 = CasillerosPorFila-1;
  297. JuntosRequeridos = 2;
  298. HacerTablero();

Muestra:


También estoy haciendo una IA que aprende experimentando. Por ahora sólo capta 2 horizontales, no hay rival, y me falta la etapa 2:
En general la IA tiene sentido cuando algo es tan complejo y vasto que es inasumible para un humano poder abarcarlo... no vivimos tanto como para dedicarlo 8.000 años a determinados problemas... el juego del 3 en raya, es muy simple... si un niño de unos 12 años juega lo sufiiiiiiieciente no tardará en darse cuenta que hay una estrategia para no perder nunca, así como se dará cuenta que el jugador que sale tiene mayor ventaja.

Código
  1. // 2 en línea horizontal, en tablero de 2x2, sólo X:
  2. //
  3. // Uso arrays porque es más fácil así modificar los nombres...
  4. // de variables:
  5. //
  6. // Los casilleros están numerados así:
  7. // 0 1
  8. // 2 3
  9. // Situación inicial (v es casillero vacío):
  10. SituacionBase = ["v", "v", "v", "v"];
  11. // Ponerla en la lista de situaciones a experimentar:
  12. SaE1 = SituacionBase.slice();
  13. // Situaciones a experimentar (cuántas son):
  14. SaE = 1;
  15. NroDeSExperimentandose = 1;
  16. NombreDeSE = "S"+(SaE1.join(""));
  17. // Acción a realizarse (casillero a marcar):
  18. Action = 0;
  19. // Este programa tiene básicamente 2 etapas:
  20. // 1: Buscar situaciones en que se puede ganar mediante 1 acción.
  21. // 2: FALTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
  22. function BuscarBuenasSituaciones () {
  23. // Plantear situación porque puede modificarse pero...
  24. // podría requerirse su estado original luego:
  25. Situacion = SituacionBase.slice();
  26. trace("La situación experimentándose es "+Situacion);
  27. EvaluarAplicabilidadEt1();
  28. }
  29. // ¿La acción es realizable?
  30. // Etapa 1 (buscar buenas situaciones)
  31. function EvaluarAplicabilidadEt1 () {
  32. trace("Ejecutando EvaluarAplicabilidadEt1");
  33. if (Situacion[Action] == "v") {
  34. // Sí, realizarla:
  35. AplicarAccionEt1();
  36. } else if (Action < 3) {
  37. trace("La acción "+Action+" no es realizable.");
  38. // Sino si queda alguna acción sin probar...
  39. // en la situación, probarla:
  40. Action++;
  41. EvaluarAplicabilidadEt1();
  42. } else {
  43. trace("No hay más acciones realizables.");
  44. BuscarOtraSituacionEt1();
  45. }
  46. }
  47. function AplicarAccionEt1 () {
  48. trace("Ejecutando AplicarAccionEt1");
  49. Situacion[Action] = "X";
  50. trace("Se realizó la acción "+Action+"; ahora la situación es "+Situacion);
  51. // ¿Ganó?
  52. // Para averiguarlo, calcular fila (contando desde 0):
  53. ObtenerColumnayFilaDelMarcado();
  54. CuadraditoMinimoDeLaFila = FilaDelMarcado*2;
  55. if (Situacion[CuadraditoMinimoDeLaFila] == Situacion[CuadraditoMinimoDeLaFila+1]) {
  56. // trace("Situacion[CuadraditoMinimoDeLaFila] == Situacion[CuadraditoMinimoDeLaFila+1]: "+Situacion[CuadraditoMinimoDeLaFila]+" == "+Situacion[CuadraditoMinimoDeLaFila+1]);
  57. // Sí, crear datos sobre eso:
  58. // En la situación base conviene la acción realizada:
  59. set (NombreDeSE+"BestAction", Action);
  60. // En esa situación se requiere 1 acción para ganar:
  61. set (NombreDeSE+"DistanciaaGanar", 1);
  62. trace("Ganó, ahora se sabe que en la situación "+SituacionBase+" se gana usando la acción "+Action);
  63. BuscarOtraSituacionEt1();
  64. } else {
  65. EvaluarConocimientoSobreSEt1();
  66. // ¿Queda alguna acción sin probar...
  67. // en la situación?
  68. if (Action < 3) {
  69. // Sí, probarla:
  70. Action++;
  71. // Se ejecutará BuscarBuenasSituaciones.
  72. } else {
  73. BuscarOtraSituacionEt1();
  74. }
  75. }
  76. }
  77. function ObtenerColumnayFilaDelMarcado () {
  78. FilaDelMarcado = Math.floor(Action/2);
  79. ColumnaDelMarcado = Action%2;
  80. }
  81. // ¿Aún hay situaciones a experimentar?
  82. function BuscarOtraSituacionEt1 () {
  83. trace("Ejecutando BuscarOtraSituacionEt1");
  84. if (SaE > NroDeSExperimentandose) {
  85. IniciarExperimentosEnOtraSEt1();
  86. } else {
  87. trace( "No hay más situaciones a experimentar; inicia la etapa 2.");
  88. IniciarEtapa2();
  89. }
  90. }
  91. // ¿La situación está anotada en las que deben investigarse?
  92. function EvaluarConocimientoSobreSEt1 () {
  93. trace("Ejecutando EvaluarConocimientoSobreSEt1");
  94. SituacionHechaTexto = Situacion.join("");
  95. NombreDeSituacion = "S"+SituacionHechaTexto;
  96. Resumen = NombreDeSituacion+"BestAction";
  97. if (eval(Resumen) == undefined) {
  98. // No, anotar que debe investigarse:
  99. SaE++;
  100. set ("SaE"+SaE, Situacion.slice());
  101. trace("Esa situación no está anotada; se anota como nro "+SaE);
  102. // Esto para saber que está anotada:
  103. set (Resumen, "Desconocida");
  104. }
  105. }
  106. function IniciarExperimentosEnOtraSEt1 () {
  107. trace("Ejecutando IniciarExperimentosEnOtraSEt1");
  108. NroDeSExperimentandose++;
  109. SituacionBase = eval("SaE"+NroDeSExperimentandose);
  110. // trace("SituacionBase: "+SituacionBase);
  111. // Reset de la acción a probar:
  112. Action = 0;
  113. trace("Se inician experimentos en otra situación, la anotada nro "+NroDeSExperimentandose);
  114. }
  115. function IniciarEtapa2 () {
  116. DistanciaaGanarAceptada = 1;
  117. trace("Se experimentaron todas las situaciones; se reexperimentarán buscando resultados menos óptimos");
  118. trace("Son "+SaE+" situaciones; se acepta que la distancia a la victoria sea "+DistanciaaGanarAceptada);
  119. gotoAndStop (3);
  120. }

Citar

Este diagrama no lo terminé pero puede ayudar a entender cómo funciona:
Es suficiente con que lo entiendas tú...
7  Programación / Programación Visual Basic / Re: Comparación múltiple en: 1 Marzo 2025, 23:21 pm
Claro que hay forma sencilla de hacerlo en vb6...

Dado que son cadenas de texto a comparar, lo siguiente es perfectamente válido en tu caso:
Código
  1. if (.listcount =0) and ((instr("uno, dos, tres, cuatro", carpetaactual) >0) then
  2.  
Haz uso del parámetro 'compare' de la función interna 'instr', si fuera preciso...
8  Programación / Programación General / Re: ¿Cual es el método más eficiente para ver si hay una línea de S signos? en: 30 Enero 2025, 18:05 pm
El modo más sencillo no es investigar todo el 'tablero', si no a partir el último movimiento de un jugador, antes de pasarle el turno a otro jugador revisar si ese último movimiento, tiene 2 contiguas más en alguna de las 4 direcciones (vertical, horizontal, diagonal izquierda y diagonal derecha).
Para no incurrir en complicaciones de errores por estar fuera del tablero, es adecuado dimensionar el tablero a una casilla más perimetralmente... (solo en código, obviamente). Partamos pues de un esquema mental inicial con sus oportunas explicaciones...

Tablero 0:
 | 3 | 3 | 3 | 3 | 3 |
 | 3 | 0 | 0 | 0 | 3 |
 | 3 | 0 | 0 | 0 | 3 |
 | 3 | 0 | 0 | 0 | 3 |
 | 3 | 3 | 3 | 3 | 3 |


El tablero que se dibuja es el central (de 3x3), donde figuran las casillas vacías (valor 0). Perimetralmente se observa un valor 3 en todas las casilla.
El jugador 1 marca las casillas suyas con un 1, el jugador 2 con un 2.
Nota que son valores elegidos arbitrariamente, se puede elegir el conjunto que se desee siempre que se sea consecuente.

Veamos ahora una partida empezada, olvidemos los pasos previos, en ellos se hará lo mismo que ahora se comenta, pero como solo habria inicialmente 1 casilla, marcada y luego 2, no ofrece el interés (explicativo y aclaratorio) que cuando ya el tablero está más avanzado...

Tablero 1:
 | 3 | 3 | 3 | 3 | 3 |
 | 3 | 1 | 2 | 1 | 3 |
 | 3 | 0 | 1 | 0 | 3 |
 | 3 | - | 0 | 2 | 3 |
 | 3 | 3 | 3 | 3 | 3 |

Empezaba el jugador 1, luego el 2... ahora es el turno del 2, y va a poner su ficha en la casilla marcada con '-' (solo para verla fácilmente), procede pues analizar el si jugador 2 ha conseguido las 3 en raya, sabiendo que su último movimiento es la casilla 3-A, o también 3-1 (Tercerá fila columna 1).

Una función recibe: qué jugador tiene el turno y qué casilla marcó, queda pues mirar si a su alrededor las casillas contiguas son también son suyas hasta sumar 3:

Código:
buleano = funcion Validar(jugador, fila, columna)
    puntos tipo byte

    puntos =1
    Si (Buscar(jugador, fila-1, columna, -1, 0) = FALSE) luego        // 1 buscar hacia arriba:        // Buscar en vertical
        Si (Buscar(jugador, fila+1, columna, 1, 0) = FALSE) luego         // 2 buscar hacia abajo:    // Buscar en vertical
            puntos =1  //reset puntos a 1.
            Si (Buscar(jugador, fila, columna-1, 0, -1) = FALSE) luego         // 3 buscar hacia izquierda:     // Buscar en horizontal
                Si (Buscar(jugador, fila, columna+1, 0, 1) = FALSE) luego         // 4 buscar hacia derecha:    // Buscar en horizontal

                    // Ahora las diagonales...
                    puntos =1  //reset puntos a 1.
                    Si (Buscar(jugador, fila-1, columna-1, -1, -1) = FALSE) luego         // 5 buscar hacia diagonal izquierda y arriba:     // Buscar en diagonal '\'
                        Si (Buscar(jugador, fila+1, columna+1, 1, 1) = FALSE) luego         // 6 buscar hacia diagonal derecha y abajo:    // Buscar en diagonal '\'
                            puntos =1  //reset puntos a 1.
                            Si (Buscar(jugador, fila-1, columna+1, -1, 1) = FALSE) luego         // 7 buscar hacia diagonal derecha y arriba:      // Buscar en diagonal '/'
                                Si (Buscar(jugador, fila+1, columna-1, 1, -1) = FALSE) luego         // 8 buscar hacia diagonal izquierda y abajo:    // Buscar en diagonal '/'
                                    devolver FALSE
                                fin si
                            fin si
                        fin si
                    fin si
                fin si
            fin si
        fin si
    fin si
    
    devolver TRUE
fin funcion

Todas las verificaciones se derivan a esta única función para no repetir código,  donde solo cambia el avance de fila o columna para revisar...
El parámetro puntos se recibe por referencia, es decir conserva su valor tras salir de la función.
El tablero tiene perimetralmente una casilla adicional luego es del tamaño 0 a 4 de ancho y lo mismo de alto, siendo útiles a los jugadores solo las casillas 1,2,3.
 en ese perímetro hay un valor que no corresponde al tablero (valor 0), ni a los jugadores (1 ni 2).
Un jugador solo podría ocupar así una casilla del tablero con valor 0... etc... las normas son bien conocidas (en jerga se dice 'well known') por todos los interesados.  
Código:
buleano funcion Buscar(puntos, jugador, Fila, Columna, dF, dC)
    mientras tablero(Fila, Columna) = jugador
        puntos +=1
        Si (puntos = 3) devolver TRUE

        Fila += dF        // df puede ser -1, 0, 1
        Columna += dC   // dC puede ser -1, 0, 1
    repetir

    devolver FALSE
fin funcion

Si se examina el código con el estado actual en el 'tablero 2', se verá que devuelve  false, el jugador 2, no tiene 3 en raya.
Ahora supongamos que el jugador 2, (ver tablero 3) en vez de marcar la casilla 3,A hubiera marcado la casilla 3,B con intención luego de marcar la 3,A para hacer 3 en raya en la fila C.
Entonces el jugador 1, sí marca la casilla 3,A que si se comprueba con la función, devolverá TRUE tras la búsqeuda 7 (se han enumerado en los comentarios las 8 búsquedas), que es la diagonal '/' y que empieza a buscar desde la casilla marcada 3A  (3,1)

Tablero 3:
 | 3 | 3 | 3 | 3 | 3 |
 | 3 | 1 | 2 | 1 | 3 |
 | 3 | 0 | 1 | 0 | 3 |
 | 3 | - | 2 | 2 | 3 |
 | 3 | 3 | 3 | 3 | 3 |

La lógica es bastante simple, pero como se ve, no se precisa recorrer todas las líneas, ni todas las columnas, ni todas las diagonales, sino solo alrededor de la casilla recién marcada por el jugador.
9  Seguridad Informática / Seguridad / Re: me enviaron mensaje a mi correo de que me han hackeado y quiere que le de dinero pero sale que yo mismo lo envie en: 3 Julio 2024, 17:15 pm
Citar
I am a professional hacker...

Tan solo con esas primeras palabras ya delatan a un estafador de pocas capacidades técnicas (como hacker). Más del tipo probamos con 20.000 y alguno pagará...

Un 'hacker' experto, no te va a venir con cuentos ni tanta verbosidad, tampoco necesitará 'hacerte demostraciones' será patente lo que haya hecho en tu equipo-cuenta, y el mensaje que te dejare será muy escueto e irá al grano.

Si observas bien el texto, trata de convencer, lo que será logrado más o menos fácil para según que tipo de personas. Al inicio, tu estabas en el medio, has dudado y por ello precavido y preguntado, tras lo cual (ahora ya) no podrá convencerte.

Un típico estafador siempre tratará de convencer, siempre pondrá por delante superficialidades que llamen la atención (a los más bobos), al final cada ave tiene su tipo preferido de presa... y los bobos, tienen pocas defensas, son como pingüinos...
10  Comunicaciones / Redes / Re: DUDA SOBRE VELOCIDADES QUE NO ENCUENTRO SENTIDO en: 3 Julio 2024, 16:59 pm
En una red local, es más factible que se logre alcanzar el límite teórico, ya que excluye muchos problemas y mecanismos externos que lo ralentizarían.
Páginas: [1] 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 ... 436
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines