Por ejemplo ¿puede un hacker hacer que en otra pantalla se muestre lo que el víctimo está viendo en la suya?

¿Puede un hacker escribir cosas en la computadora del víctimo mientras éste lee atónito? Por ejemplo que el víctimo esté escribiendo y de repente en el cuadro de texto en vez de que aparezca lo que escribe aparezca lo que escriba el hacker, que podría ser algo como "No pude comunicarme de otra manera, soy un espíritu, necesito que vayas a...".

¿Que cosas que se suele creer que son imposibles para un hacker, son posibles?

¿Y qué cosas que algunos creen posibles para un hacker, en realidad no lo son (por ahora al menos)?

Sería una versión mejorada de este:
https://www.youtube.com/watch?v=i_aPn9W2WF8
mezclada con Magic The Gathering y Yu-gi-oh.

N = Nro de jugadores.
??? = Cantidades a decidir.

- Cada jugador debe hacer un mazo de cartas.
- Hay 3 tipos de cartas:
--- Números.
--- Operadores.
--- Personas o personajes que han sido relevantes en las Matemáticas.
- Cada jugador baraja su mazo. Luego pone cartas boca arriba, formando cada uno un cuadro de ???x??? cartas.
- Debe haber al menos 1 carta de tipo número en cada cuadro. Cada jugador puede devolver sus cartas a su mazo y volver a poner otras, pero cada vez que lo haga tendrá que poner 1 carta menos. Si llega un punto en que sólo puede poner 1 carta y la que pone no es un número, pierde.
- El órden de los turnos podría ser decidido según la cantidad de números que hayan puesto, o su suma, o cual sea el mayor, o no sé, qué sería mejor. En caso de empate se vería quien tiene la 2nda cantidad mayor, o la suma mayor, o lo que se haya decidido, y así sucesivamente. En caso de que no sea posible desempatar así se comienza a ver quién tiene el número mayor al final de su mazo.
- Podría ser que, quien inicia, no toma una carta de su mazo en esa ocasión. En los demás casos sí, al inicio de su turno, el jugador toma una carta de su mazo.
- En cada turno se puede lanzar sólo 1 operación (1 número, 1 operador y otro número) y sólo a 1 personaje.
- El contexto podría ser:
A: Los números en el cuadro de cada jugador son candados, gana quien abre todos los del adversario.
B: Los cuadros son murallas, gana quien hace un camino vertical en la muralla rival. En este caso al inicio debería haber al menos 1 número en cada columna de cada cuadro.
C: Alguna de esas 2 con el agregado de que luego debe quitarle puntos de vida.

Los personajes causarían efectos especiales en el juego, como obtener 2 cartas del mazo, ver la mano del rival, etc.

Sería bueno que durante el juego los jugadores pudieran poner números en sus cuadros y/o intercambiar sus otras cartas de ahí por números pero no sé si así nomás o de algún modo especial. Se requieren 2 y 1 operador para destruir 1 rival... Si se pudiera poner un número en el cuadro cada vez que se tenga en la mano entonces ¿para qué usar 3 cartas en destruir 1 si se podrían poner 3? Por eso no puede ser. ¿Para poner 1 hay que descartar 2 cartas? Podría ser. También, que si en el cuadro se tiene una carta no número y en la mano un número, se puedan intercambiar.

Podría haber cartas tipo trampa también, estarían en el cuadro y se podrían activar cuando se destruye un número al lado. En este caso las cartas que no sean número estarían boca abajo y se pondrían boca arriba cuando un número sea destruido ¿está bien? O en caso de jugarse en el modo "hacer camino", se activarían cuando deja de haber un número delante y el rival decide pasar.

Tal vez sería bueno que en vez de tomar 1 carta por turno se tomen 2, el problema es que entre más cartas más se tarda en jugarlas porque debe pensarse más, por tener más opciones.

Otra posibilidad es que en vez de jugar con 1 mazo en que están todos los tipos de cartas mezclados, se juegue con varios mazos a la vez. Está bien mientras no se mezclen todas en la mano y en la pila de descarte, sino habría que reacomodarlas al final de cada partida (por supuesto si es un videojuego no sería problema).

Una idea que me gustó es que un efecto especial sea "obtén el menor resultado posible". Ambos jugadores podrían usar todos los números y operadores que quieran intentando eso y el ganador obtendría algún beneficio especial (tomar del mazo el doble de cartas que haya usado, por ejemplo), pero si en general no se tendrá muchas cartas en la mano no tiene mucha gracia.

Ahora que me doy cuenta, debería permitirse lanzar operaciones más grandes, es decir, con más números y más operadores.

En fin ¿qué más se les ocurre?

No entiendo por qué se pone tan lento a veces. Tomé estas fotos al administrador de tareas, indicando que muestre los procesos de todos los usuarios porque por defecto no lo hace:




Veo por ejemplo que está Firefox, pero yo no lo uso ¿cómo quito que se actualice sólo? Debería hacerlo sólo cuando lo abro, cosa que no hago en años. Lo tengo por las dudas, además se supone que es una versión antigua porque en un tiempo los certificados no me funcionaban o algo así. Si se actualiza no tiene sentido.

Nero tampoco tendría que estarse actualizando, que lo haga cuando lo use...

Hay muchas cosas que no sé qué son.

Hace tiempo pregunté algo por ahí (nada que ver con poner cosas vivas en circuitos) y me dieron esto:
https://diarioti.com/neuronas-de-sanguijuela-en-computadoras/5189

Si hacen eso, que la máquina empiece a actuar de modo muy raro o peligroso ya no me parece tan imposible. ¿Realmente pueden predecir o controlar lo que harán esas neuronas? ¿realmente son más rápidas que lo que usan las PC y demás? ¿alguien sabría por qué? Pues de algún moido las neuronas también harán cálculos ¿no? Dudo que hagan las cosas por simple atracción como si fuesen imanes y metales ¿o sí? No sé, todo muy raro.

Y eso es de 1999, vaya a saber en qué quedó.

Algo más:
https://www.levante-emv.com/tendencias21/2023/03/03/ordenadores-construidos-neuronas-humanas-vuelta-84044439.html

Más o menos en 2008 me hice una pregunta similar pero no he cambiado tanto

Ejemplos de dudas sencillas:
¿Qué número es mayor que 10?
¿Qué número entero del 1 al 9 elegí?

Son sencillas porque:
- Simplemente hay que decir un número entero.
- Las condiciones que debe cumplir la solución son fáciles de expresar y chequear.

Con fuerza bruta se pueden resolver:
Decir un número acorde, muy bajo/alto. Si cumple la condición mostrarlo y sino disminuirlo/aumentarlo.

Lo complicado empieza al intentar complicar la duda. ¿Cómo se pueden complicar las dudas?

Pensé en cuales son las variables de las dudas, aumentar su cantidad y complejidad... A continuación dejo una lista sobre eso:
Pero está incompleta, de hecho no sé cómo saber si está completa, y parece inútil, es como que en vez de ir por distintos caminos subo una montaña a ver qué caminos hay, pero cuesta subir y no avanzo por los caminos.

¿Qué me conviene hacer?

Recientemente pensé en cómo sería agregar "variables de la situación", cosa que ya había pensado un poco:
¿Qué número es mayor que X y menor que Y? 2 variables: X e Y.
¿Cual es uno de 2 números que elegí? Idem.

Esto parece que inevitablemente aumenta la cantidad de condiciones que deben chequearse, salvo que la acción o candidato use una de las variables de situación, ejemplo:
Lo cual es bastante random e inútil creo. Si fuesen palabras de un tipo, entonces tendría sentido, por ejemplo "adivina qué deporte pensé". Por esto, parecería que conviene probar aumentar las condiciones.

A ver, es que a 1era vista hay 2 opciones:
1: Ver cuales son las variables (la lista incompleta que puse) e ir agregando esas variaciones en las dudas. Agregar un efecto (algo que influye en nuestras acciones y no podemos controlar), o complicar el tipo de variable, etc. Se hacen distintas mezclas cada vez más complejas o con más ingredientes.
2: Pensar cual es la variable que conviene complicar, complicarla, pensar otra, complicarla, hacer mezclas, y repetir.

Yo intentaba lo 1ero, pero ya dije el problema.

Lo 2ndo es que no me convence mucho. Es posible agregar una condición que el número deba cumplir, y otra, y otra, y así hasta el infinito ¿pero qué utilidad tiene hacer eso?

Las condiciones serán cada vez más complejas, creo, es inevitable, no podemos estar diciendo N<X, N>Y, N<J, etc, basta con ver si X<J o qué (además esas no son variables de situación, o al menos no necesitan definirse como tales, o sería una duda más compleja de la que pienso), en cierto punto habrá que poner condiciones como "debe ser par", "debe ser capicúa", etc.

Bueno ¿condiciones cada vez más complejas entonces? Para números. Algo había hecho para eso, pero sigo prefiriendo el método 1 (completar la lista e ir mezclando todo más o menos a la vez), no sé...

GPT (no le vi utilidad en este caso):

Si un while dura demasiado, aparece un mensaje diciendo eso, así que no quiero usar whiles largos como:
pero cortos puede ser.

Con los for supongo que ocurre lo mismo, igual no me gustan los for.

Cuando una repetición es larga, se puede hacer:
Es más lento que un while pero tiene otro defecto peor: Sólo se producen números en el frame 2.

Para mejorar eso se puede hacer:
Si muestra el 101 y no se quiere, se cambia la condición por N<99 o N<=100.

Para evitar repetición de código, se puede hacer algo así:

   actions for fotograma 1
      N = -1;
      function Variar () {
         N = N+1;
         trace (N);
         if (N == 100) {
            stop();
         } else if (Fram == 3) {
            gotoAndPlay (2);
         }
      }
   actions for fotograma 2
      Fram = 2;
      Variar();
   actions for fotograma 3
      Fram = 3;
      Variar();

Pero mi código quiero que guarde los Ns que cumplan ciertas condiciones y que se detenga sólo cuando cada una haya sido cumplida por algún N, hago esto:

   actions for fotograma 1
      Soluciones = 0;
      N = -1;
      function Variar () {
         N = N+1;
         C = String(N).charat(N);
         trace (N+": "+C);
         if (C == 0) {
            if (Solfor0 == undefined) {
               Solfor0 = N;
               trace ("para que C sea 0 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == -9) {
            if (Solfor9 == undefined) {
               Solfor9 = N;
               trace ("para que C sea -9 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == 4.5) {
            if (Solfor4 == undefined) {
               Solfor4 = N;
               trace ("para que C sea 4.5 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == -7.2) {
            if (Solfor7 == undefined) {
               Solfor7 = N;
               trace ("para que C sea -7.2 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         }
         if (Soluciones<4) {
            if (Fram == 3) {
               gotoAndPlay (2);
            }
         } else {
            trace ("para que C sea 0 usar N: "+Solfor0);
            trace ("para que C sea -9 usar N: "+Solfor9);
            trace ("para que C sea 4.5 usar N: "+Solfor4);
            trace ("para que C sea -7.2 usar N: "+Solfor7);
            stop ();
         }
      }
   actions for fotograma 2
      Fram = 2;
      Variar();
   actions for fotograma 3
      Fram = 3;
      Variar();

Por otro lado, tengo otro programa que intento que haga lo mismo pero en vez de probar los números 0, 1, 2, 3... quiero que sean 0, 1, 10, 2, 11, 100... y quiero que funcione más rápido si es posible, es decir, ya tengo un código que hace eso pero tiene el defecto de tener frames "al ped*" como mostré en el código 2, quiero aplicarle la "técnica" que mostré en el 4, o acelerarlo así de algún modo ¿cómo?

Este es el código:

   actions for fotograma 1
      Soluciones = 0;
      MinLongitud = 1;
      MaxLongitud = 1;
      N1 = -1;
   actions for fotograma 2
      Longitud = MinLongitud;
   actions for fotograma 3
      Nombre = "N"+Longitud;
      N = eval(Nombre)+1;
      if (String(N).length>Longitud) {
         // El valor ya fue producido.
         MinLongitud = MinLongitud+1;
         gotoAndPlay (2);
      } else {
         // Guardar el valor en la lista correspondiente.
         set (Nombre, N);
         C = String(N).charat(N);
         trace (N+" resulta "+C);
         if (C == 0) {
            if (Solfor0 == undefined) {
               Solfor0 = N;
               trace ("para que C sea 0 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == -9) {
            if (Solfor9 == undefined) {
               Solfor9 = N;
               trace ("para que C sea -9 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == 4.5) {
            if (Solfor4 == undefined) {
               Solfor4 = N;
               trace ("para que C sea 4.5 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         } else if (C == -7.2) {
            if (Solfor7 == undefined) {
               Solfor7 = N;
               trace ("para que C sea -7.2 usar N: "+N);
               Soluciones = Soluciones+1;
            }
         }
      }
   actions for fotograma 4
      // ¿El último valor producido es de la lista de los más largos?
      if (Longitud<MaxLongitud) {
         // No, producir uno de una lista de más largos:
         Longitud = Longitud+1;
         gotoAndPlay (3);
      } else {
         // Sí, se creará un valor para una nueva lista, de valores más largos.
         // La siguiente ecuación no funciona cuando MaxLongitud es 1, por eso hay un if y else.
         if (MaxLongitud>1) {
            set ("N"+(MaxLongitud+1), eval("N"+MaxLongitud)*10-1);
         } else {
            set ("N"+(MaxLongitud+1), 9);
         }
         MaxLongitud = MaxLongitud+1;
         gotoAndPlay (2);
      }

Estoy usando un método que me ha gustado bastante pero tiene un defecto que quisiera me ayuden a evitar, o que me digan un método mejor.

Lo que estoy listando son posibles variables en juegos sencillos y el método es que estoy usando es:
Paso 1: Se escriben las posibilidades más básicas en la columna 1.
Paso 2: En la cabeza de la columna 2 se escribe un cambio aplicable a alguna de las posibilidades.
Paso 3: En las coordenadas correspondientes se aplica el cambio si es posible.

Paso 4: Se crea otra hoja (Excel).
Paso 5: De la hoja anterior, la columna 1 se copia a la nueva.
Paso 6: De la hoja anterior, las posibilidades surgidas se copian a la nueva, ordenadas según cuántas cosas fueron modificadas desde las originales.
Repetir desde el paso 2.


Entiendo que parezca una pavada pero cada vez me entrevero más en el paso 6.

Las imágenes mostradas son de la hoja 1 y 2, esta es de la 7 y al lado la 8:

Es decir, tengo una tabla como la de la izquierda y debo hacer que quede como la que está en la derecha. ¿Cómo hacerlo sin entreverarse?

Porque, al principio hacía esto:
En cuanto al paso 5 y 6, copiaba la hoja entera. Las filas en que surgió una posibilidad, las copiaba e insertaba en un nivel posterior. Luego regresaba a lo que copié y borraba el contenido de la columna 2 (tras modificar la cabeza, el contenido cambiará también).
Pero me entreveraba un poco, por estar moviendo la pantalla hacia arriba y abajo, me entrevero en cuanto a qué copié y a dónde debo copiarlo.

Ahora intenté esto:
1: Copio el 1er nivel de la columna 1.
2: Copio el siguiente nivel no copiado.
3: Copio las posibilidades surgidas en la columna 2 del nivel anterior.
Pero igual me entrevero.

Antes de empezar el tema pensé en poner otra columna que diga los niveles, y entonces ordenar la tabla por eso, pero por ejemplo las de nivel 2 que quiero poner debajo de las otras de ese nivel, estarán arriba, así que no sirve, o en definitiva no veo que tenga mucho control de todo esto, dudo que sirva. Ahora se me ocurre que puedo escribir cosas como 2a, 2b, etc, para que se ordenen así, pero igual no me fío mucho.

Finalmente, mientras hacía el tema se me ocurrió que en vez de copiar podría copiar y luego cortar, de ese modo no podría entreverarme en cuanto a qué ordené y qué me falta pero bueno, publico el tema igual a ver si me dicen métodos mejores y si a alguien le sirve esto fenómeno.

Estaría bueno poder programar generaciones de listas de posibilidades, sean de lo que sea. No sé si es tan complicado, habría expresiones con distintas cantidades de variables y según sus valores se mostrarían unas palabras u otras ¿no? ¿alguien da un pseudocódigo sobre eso?

¿Les recuerda a algo?



Ni idea qué fue 1ero, pero si quieren ver una buena peli donde aparece el roboto, aprovechen aquí:
https://www.youtube.com/watch?v=CLFVnjk8yro

Sé que cliqueando en la cabeza o cabecera de la columna Modificado, en la vista detallada, se ordenan como quiero. Eso hago. Pero cuando muevo la carpeta hacia otra (debo hacerlo) las configuraciones de sus subcarpetas se pierden, y yo me olvido (porque se supone que están ordenadas como quiero, así suele ser, no me ando fijando a ver si están ordenadas o no) y me acaba de ocurrir que entré a un archivo de ahí pensando que era el más reciente pero no.

Lo que quisiera es que con algunos clics o algo se ordenen por fecha los archivos de todas las subcarpetas que tenga una carpeta. He probado hacerle clic derecho, recuerdo que había una opción de personalizar esta carpeta pero no la veo, veo propiedades. Ah, ya vi por casualidad, aparece si hago clic derecho estando en la carpeta, no al hacer clic en una carpeta. Bue. ¡Pero es lo mismo que propiedades! Y ahí no veo modo de hacerlo.

¿No queda más remedio que entrar en todas las subcarpetas y hacer clics en las cabeceras otra vez? No es que deba hacer este proceso seguido, pero parece absurdo y evitable.

La siguiente función se aplica en distintos sitios del programa, pero no creo que el problema esté fuera de ella, creo que el problema es la altura asignada a la flecha y cómo Flash la aplica:

function InsertarNodo () {
	Imagenes = Imagenes+1;
	Nodos = Nodos+1;
	Grafo.attachMovie("mNodo", "Nodo"+Nodos, Imagenes);
	// Especificar la situación que representa:
	set ("Grafo.Nodo"+Nodos+".EnHP", EnHP);
	// Insertar flecha:
	Imagenes = Imagenes+1;
	Grafo.attachMovie("mFlecha", "Flecha"+Nodos, Imagenes);
	// Especificar el sitio donde se insertan:
	PosicionY = PadrePosicionY+33;
	setProperty ("Grafo.Nodo"+Nodos, _y, PosicionY);
	setProperty ("Grafo.Flecha"+Nodos, _x, PadrePosicionX);
	setProperty ("Grafo.Flecha"+Nodos, _y, PadrePosicionY+6.5);
	Hijos = Hijos+1;
	if ( Hijos == 1 ) {
		PosicionX = PadrePosicionX;
		setProperty ("Grafo.Nodo"+Nodos, _x, PosicionX);
	} else {
		Hijo = 0;
		MinPosicionX = PadrePosicionX-16.5*(Hijos-1);
		SAquedebeActualizarse = SAs-Hijos;
		do {
			Hijo = Hijo+1;
			PosicionX = (Hijo-1)*33+MinPosicionX;
			setProperty ("Grafo.Nodo"+(Nodos-Hijos+Hijo), _x, PosicionX);
			// Actualizar datos de las posiciones guardadas:
			SAquedebeActualizarse = SAquedebeActualizarse+1;
			set ("SA"+SAquedebeActualizarse+"PosicionX", PosicionX);
			// Rotación y tamaño de flecha.
	 		DistanciaXPadreHijo = Math.abs(PosicionX);
			setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _height, Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
			trace ("Altura: "+Math.sqrt(DistanciaXPadreHijo*DistanciaXPadreHijo+20*20));
			Rotacion = 180/Math.PI*Math.atan (DistanciaXPadreHijo/20*-1);
			if ( PosicionX<0 ) {
				Rotacion = Rotacion*-1;
			}
			setProperty ("Grafo.Flecha"+(Nodos-Hijos+Hijo), _rotation, Rotacion);
		} while ( Hijo < Hijos );
	}
}

La 1era vez que se aplica esa función inserta una flecha y no la modifica porque no es necesario; queda como quiero:


La 2nda vez inserta otra (ahora hay 2) y modifica el tamaño y rotación de ambas; quedan como quiero:


La 3era vez lo mismo:


La 4ta vez no queda bien:

Algunas están más anchas que otras, ni idea por qué, y probablemente más largas de lo que deben. Pero las alturas supuestamente son iguales en las que deben serlo:
Altura: 53.3877326733399
Altura: 25.9277843249283
Altura: 25.9277843249283
Altura: 53.3877326733399

¿Alguna idea de cual es el problema, error, y cómo corregirlo?