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


Tema destacado: Guía rápida para descarga de herramientas gratuitas de seguridad y desinfección


  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 ... 51
51  Programación / Programación General / En muchos lenguajes, tempArray = array ¿es una referencia y les parece bien? en: 12 Enero 2025, 21:51 pm
A esto:
https://foro.elhacker.net/programacion_general/iquestque_metodo_es_recomendado_para_ordenar_al_azar_un_array-t522940.0.html
...quería agregarle eficientemente que el nuevo array pudiera tener menos elementos que el original. Como no se me ocurrió bien cómo, consulté a GPT:

En Macromedia Flash 5 tengo un array de 3 elementos y quiero que se genere otro array con 2 de esos elementos al azar, y ordenados al azar ¿cómo?

Citar
En **Macromedia Flash 5**, puedes usar `ActionScript` para lograr lo que necesitas: generar un nuevo array con dos elementos seleccionados al azar del array original, y luego ordenarlos aleatoriamente. Aquí tienes un ejemplo de código que hace exactamente eso:

```actionscript
// Array original con 3 elementos
var originalArray = ["Elemento1", "Elemento2", "Elemento3"];

// Función para seleccionar 2 elementos al azar del array original
function getRandomElements(array) {
    // Copiar el array original para no modificarlo
    var tempArray = array.slice(0);
    var randomArray = [];
    
    // Seleccionar 2 elementos al azar
    for (var i = 0; i < 2; i++) {
        var randomIndex = Math.floor(Math.random() * tempArray.length);
        randomArray.push(tempArray[randomIndex]);
        // Remover el elemento seleccionado para evitar duplicados
        tempArray.splice(randomIndex, 1);
    }
    
    // Mezclar los elementos seleccionados
    randomArray.sort(function() {
        return Math.random() - 0.5;
    });
    
    return randomArray;
}

// Generar el nuevo array con 2 elementos al azar y ordenados al azar
var newArray = getRandomElements(originalArray);

// Mostrar el resultado
trace("Array original: " + originalArray);
trace("Nuevo array: " + newArray);
```

### Explicación del código:

1. **Copia del array original**:
   - Usamos `slice(0)` para crear una copia del array original, de modo que no lo modifiquemos al eliminar elementos.

2. **Selección aleatoria**:
   - En el loop, se seleccionan dos elementos al azar usando `Math.random()` y se eliminan del array temporal (`tempArray`) con `splice()`, para evitar duplicados.

3. **Orden aleatorio**:
   - Usamos `sort()` con una función de comparación que devuelve un valor aleatorio para mezclar los elementos seleccionados.

4. **Resultado**:
   - El nuevo array (`newArray`) contiene dos elementos seleccionados al azar del array original, y están ordenados de manera aleatoria.

### Ejemplo de salida:

Si el array original es `["Elemento1", "Elemento2", "Elemento3"]`, la salida podría ser algo como:

```
Array original: Elemento1,Elemento2,Elemento3
Nuevo array: Elemento2,Elemento1
```

Cada vez que ejecutes el código, la selección y el orden serán diferentes.

¿por qué pones
var tempArray = array.slice(0);
en vez de
tempArray = array;
?

Citar
La razón por la que usé:

```actionscript
var tempArray = array.slice(0);
```

en lugar de:

```actionscript
tempArray = array;
```

es para **crear una copia del array original**, en lugar de simplemente referenciarlo.

### Diferencia entre copiar y referenciar un array:

- **`tempArray = array;`**  
  Esto no crea un nuevo array. En lugar de ello, `tempArray` apunta al mismo espacio de memoria que el array original (`array`). Si modificas `tempArray` (como eliminar elementos con `splice()`), también estarás modificando el array original, porque ambos comparten el mismo contenido.

- **`tempArray = array.slice(0);`**  
  Esto crea una **copia del array original**. Cualquier cambio que hagas en `tempArray` no afectará al array original, ya que ahora son dos arrays independientes.

### ¿Por qué es importante en este caso?

En el código, usamos `splice()` para eliminar elementos del array temporal (`tempArray`) mientras seleccionamos elementos aleatorios. Si no hacemos una copia (usando `slice()`), también estaríamos eliminando elementos del array original, lo cual probablemente no sea lo que queremos.

### Ejemplo práctico:

Supongamos que tienes este código:

```actionscript
var originalArray = ["Elemento1", "Elemento2", "Elemento3"];
var tempArray = originalArray;

// Modificar tempArray
tempArray.splice(0, 1);

// Imprimir ambos arrays
trace("originalArray: " + originalArray);
trace("tempArray: " + tempArray);
```

**Salida:**

```
originalArray: Elemento2,Elemento3
tempArray: Elemento2,Elemento3
```

Como ves, al modificar `tempArray`, también se modifica `originalArray`, porque ambos apuntan al mismo array.

Ahora, usando `slice(0)`:

```actionscript
var originalArray = ["Elemento1", "Elemento2", "Elemento3"];
var tempArray = originalArray.slice(0);

// Modificar tempArray
tempArray.splice(0, 1);

// Imprimir ambos arrays
trace("originalArray: " + originalArray);
trace("tempArray: " + tempArray);
```

**Salida:**

```
originalArray: Elemento1,Elemento2,Elemento3
tempArray: Elemento2,Elemento3
```

Aquí, `originalArray` permanece intacto, porque `tempArray` es una copia independiente.

### Conclusión:

Usar `slice(0)` asegura que puedas trabajar con un array temporal sin modificar el array original. Esto es crucial cuando necesitas preservar el estado del array original para otros usos o simplemente para evitar efectos secundarios no deseados.

Poner un nombre, luego = y luego un valor, es crear una variable cuyo nombre es el indicado en nombre y su valor es indicado luego del signo =, no es una referencia ¿o estoy equivocado?

Citar
Estás en lo correcto en términos generales: cuando haces algo como:

```actionscript
var nombre = valor;
```

estás creando una variable llamada `nombre` y asignándole el valor de `valor`. Sin embargo, **el comportamiento de la variable depende del tipo de dato que estés asignando**. En ActionScript (y en muchos lenguajes de programación), los tipos de datos se dividen principalmente en dos categorías:

1. **Tipos primitivos** (números, cadenas, booleanos, etc.).
2. **Tipos complejos o de referencia** (objetos, arrays, etc.).

La diferencia clave radica en cómo se asignan y manejan los valores en memoria.

---

### Tipos primitivos: Copia del valor

Cuando asignas un tipo primitivo a una variable, se copia su valor directamente en la nueva variable. Por ejemplo:

```actionscript
var a = 5;
var b = a;
b = 10;

trace(a); // 5
trace(b); // 10
```

Aquí, `a` y `b` son independientes, porque el número `5` (un tipo primitivo) se copió en `b`. Cambiar `b` no afecta a `a`.

---

### Tipos complejos (como arrays): Referencia en memoria

Cuando trabajas con tipos complejos, como arrays u objetos, lo que realmente estás asignando no es el "valor" en sí, sino una **referencia en memoria** al lugar donde se almacenan esos datos. Esto significa que si usas el operador `=` para asignar un array a otra variable, ambas variables apuntarán al mismo array en memoria. Por ejemplo:

```actionscript
var originalArray = [1, 2, 3];
var otherArray = originalArray;

otherArray.push(4);

trace(originalArray); // [1, 2, 3, 4]
trace(otherArray);    // [1, 2, 3, 4]
```

Aquí, tanto `originalArray` como `otherArray` apuntan al mismo array en memoria. Al modificar `otherArray`, también estás modificando `originalArray`.

Si quieres evitar este comportamiento y trabajar con una copia independiente del array, necesitas crear una copia explícita, como con el método `slice()`:

```actionscript
var originalArray = [1, 2, 3];
var otherArray = originalArray.slice(0);

otherArray.push(4);

trace(originalArray); // [1, 2, 3]
trace(otherArray);    // [1, 2, 3, 4]
```

Ahora, `originalArray` y `otherArray` son arrays completamente separados, y los cambios en uno no afectan al otro.

---

### Conclusión

Cuando haces:

```actionscript
tempArray = array;
```

no estás creando un nuevo array. Estás haciendo que `tempArray` apunte al mismo array en memoria que `array`. Por eso, cualquier cambio que hagas en `tempArray` también se verá reflejado en `array`.

Si quisieras que `tempArray` sea una copia independiente del contenido de `array` (sin afectar al original), necesitas usar algo como:

```actionscript
tempArray = array.slice(0);
```

Esto crea un nuevo array con el mismo contenido, pero almacenado en un espacio de memoria diferente.

En resumen: la diferencia entre **valor** y **referencia** es lo que causa este comportamiento.

¿Por qué lo hicieron así?

Citar
Implementar arrays y objetos como **tipos por referencia** en lenguajes como ActionScript (y otros lenguajes como javascript, Python, etc.) no es algo arbitrario, tiene razones prácticas y de diseño. Aquí te explico por qué **los arrays y objetos funcionan por referencia** y no como copias directas:

---

## 1. **Eficiencia en memoria y rendimiento**
Cuando trabajas con tipos complejos como arrays u objetos, estos pueden contener grandes cantidades de información. Si cada vez que los asignaras a una nueva variable se hiciera una copia completa de los datos, esto consumiría mucha memoria y sería muy lento.

Por ejemplo, considera este caso:

```actionscript
var arrayGrande = [1, 2, 3, ..., 100000]; // Un array con 100,000 elementos
var copia = arrayGrande; // ¿Qué pasaría si fuera una copia completa?
```

Si el lenguaje copiara todo el array al asignarlo, el programa tendría que:

1. Reservar **el doble** de espacio en memoria para almacenar los mismos datos.
2. Copiar cada uno de los 100,000 elementos al nuevo array.

Esto haría que las operaciones de asignación fueran lentas y que el uso de memoria se disparara rápidamente en aplicaciones que manejan muchos datos.

**Por referencia**, en cambio, el lenguaje simplemente crea un "puntero" o "referencia" al espacio de memoria donde ya está almacenado el array. Esto es mucho más rápido y eficiente porque no duplica los datos, sino que solo comparte la referencia.

---

## 2. **Facilita la mutabilidad**
Cuando trabajas con objetos y arrays, muchas veces necesitas que todos los cambios se reflejen en el mismo lugar. Si los arrays fueran siempre copiados al asignarlos, sería complicado coordinar los cambios entre diferentes partes de tu código.

Por ejemplo:

```actionscript
var config = { ancho: 800, alto: 600 };
var referencia = config;

referencia.ancho = 1024;

trace(config.ancho); // 1024
```

Aquí, tanto `config` como `referencia` apuntan al mismo objeto. Si cambias un valor en `referencia`, también se refleja en `config`, porque ambos son referencias al mismo objeto. Esto facilita que múltiples variables o funciones trabajen con los mismos datos sin necesidad de copiar y sincronizar los cambios manualmente.

Si los objetos fueran copiados automáticamente, el cambio en `referencia` no afectaría a `config`, y tendrías que buscar formas más complicadas de mantenerlos sincronizados.

---

## 3. **Es coherente con el diseño de programación orientada a objetos**
Los lenguajes como ActionScript están diseñados para manejar objetos de manera flexible. En este paradigma, los objetos y arrays suelen comportarse como entidades compartidas, **en lugar de duplicarse automáticamente**. Esto es clave para trabajar con estructuras de datos dinámicas, como listas enlazadas, árboles, o gráficos, donde las relaciones entre los elementos son importantes.

Por ejemplo:

```actionscript
var nodo1 = { valor: 1, siguiente: null };
var nodo2 = { valor: 2, siguiente: nodo1 };

trace(nodo2.siguiente.valor); // 1
```

Este tipo de estructuras serían mucho más difíciles de implementar si cada asignación hiciera copias completas de los datos.

---

## 4. **Consistencia con otros lenguajes**
ActionScript heredó muchas de sus características de javascript (que, a su vez, está inspirado en otros lenguajes como Java). En todos estos lenguajes, los objetos y arrays funcionan por referencia. Esto hace que el comportamiento sea predecible y **consistente con el estándar de la industria**, lo que facilita a los programadores aprender y trabajar con lenguajes similares.

---

## ¿Por qué no hacerlo todo por valor?
Si trabajar por referencia es tan eficiente, podrías preguntarte por qué no todos los tipos de datos funcionan así. La razón es que **los tipos primitivos (como números, cadenas y booleanos)** son mucho más simples y pequeños en términos de tamaño en memoria. Duplicarlos no es costoso y, en la mayoría de los casos, es más útil que sean independientes.

Por ejemplo:

```actionscript
var a = 5;
var b = a;
b = 10;

trace(a); // Todavía es 5
trace(b); // Es 10
```

En este caso, trabajar **por valor** tiene sentido porque los números son pequeñas cantidades de datos y se espera que sean independientes.

---

## Conclusión
Los arrays y objetos funcionan por referencia porque:

1. **Es más eficiente** en términos de memoria y rendimiento.
2. **Facilita la mutabilidad**, permitiendo que los cambios se reflejen automáticamente en todas las referencias.
3. **Es coherente** con el diseño de programación orientada a objetos.
4. **Sigue un estándar** que es consistente con otros lenguajes.

Aunque este comportamiento puede parecer confuso al principio, con el tiempo te darás cuenta de que es una decisión lógica y práctica para manejar datos complejos. Si necesitas una copia independiente, siempre puedes usar métodos como `slice()` o técnicas específicas para clonar objetos y arrays.

No le veo sentido, si quiero crear una copia debería poder hacerlo normalmente no con "slice", si consume mucho entonces el programador debería saberlo y no usarlo salvo que sea útil ¿por qué limitarnos?

Claro que no entendí todos los motivos que dice ahí, que una variable tenga 2 nombres puede ser útil pero... Si fuese así, debería poder hacerse con variables simples, y sobretodo debería poder hacerse de otro modo. Que una misma expresión, tan básica, haga cosas distintas según el tipo de variable parece absurdo.

¿Qué opinan?

Edit: Sabía que había excepciones a eso, tenemos por ejemplo que Número+Número es una suma pero si alguno de esos números es cadena entonces el + es concatenar. Pero vamos, no es lo mismo el + que el =. El = es sagrado xP

Edit2: Es como si al copiar un archivo en Windows, este en vez de eso copiara un acceso directo. Joder, si quiero una copia porque voy a modificar una, dejame copiar tranquilo  >:(
52  Programación / Programación General / ¿Cual es el método más eficiente para ver si hay una línea de S signos? en: 7 Enero 2025, 18:05 pm
Conocen el juego 3 en línea, tic tac toe, tateti, etc.

Yo estoy haciendo un S en línea, es decir, que el juego permita elegir cuántos signos debe haber en la línea (y qué tan grande es el tablero).

Anduve pensando cual es el método más eficiente de ver si alguien ganó.

Se me ocurrieron 2 métodos.

El 1ero es bastante bruto, más o menos así:
Código:
Se apunta al superior izquierdo.
Repetir:
Si no está vacío:
   Se miran sus contiguos de diagonal derecha-arriba:
   Si no hay o no marcan victoria:
      Se miran sus contiguos de la derecha:
      Si no hay o no marcan victoria:
         Se miran sus contiguos de diagonal derecha-abajo:
         Si no hay o no marcan victoria:
            Se miran sus contiguos de abajo:
            Si no hay o no marcan victoria:
                  Si hay un casillero hacia abajo:
                     Se empieza a mirar ese.
                  sino si hay casilleros en la derecha:
                     Se empieza a mirar el superior de esa columna.
No es necesario que los ifs se repitan, sólo que al escribirlo así nomás quedaba más claro.

El otro método intentaba usar menos repeticiones o variaciones de variables, pero a medida que lo analicé llegó un punto en que me parecía igual. En la misma repetición, se apunta a 2 casilleros (al principio son el mismo), y en cada repetición se varía a cual se apunta (y analiza como puse arriba), el 1ero es cada vez más hacia la derecha y el 2ndo hacia abajo. Cuando no quedan, se apunta al diagonal derecho-abajo y se repite el proceso hasta que el apuntado sea el inferior derecho.

Empecé a aplicar el método 1:
Código
  1. // Por practicidad al calcular, las filas se cuentan desde 0:
  2. Fila = -1;
  3. // Las columnas no, desde 1:
  4. Columna = 0;
  5. do {
  6. Fila++;
  7. SemiReferenciaAlCas = "Casillero"+Fila+"_";
  8. do {
  9. Columna++;
  10. // Si el casillero no está vacío:
  11. if (eval(SemiReferenciaAlCas+Columna != 2)) {
  12. // Esto va variando qué siguientes...
  13. // casilleros se analizan:
  14. Extra = 0;
  15. do {
  16. Extra++;
  17. //

Ahí iría lo de analizar hacia la diagonal arriba-derecha, y el resto de las cosas. Pero siento que es tan poco eficiente que prefiero que me digan algo mejor, que probablemente haya. Sino, más adelante le pregunto a GPT.

Por cierto, tengo pensado que la máquina aprenda a jugar experimentando, por eso los valores de los casilleros están grabados de 2 formas, por ejemplo el superior izquierdo:
// 2 es vacío, 1 es cruz, 0 es 0.
Casillero1 = 2;
Casillero1_1 = 2;
Porque al hacer referencia a una situación es más fácil variar sólo una variable (no fila y columna).
Lo necesito para hacer árboles, no sé cómo lo hacen uds, hablaremos en otra ocasión de eso.

Mientras hacía el tema me di cuenta que alcanza con analizar solamente las líneas que impliquen al casillero recién modificado  :xD así que intentaré eso y podría borrar todo esto, pero igual puede ser interesante, luego pongo lo que logre.
53  Programación / Programación General / ¿Qué método es recomendado para ordenar al azar un array? en: 7 Enero 2025, 07:16 am
Probablemente los lenguajes modernos tienen una función que lo hace, no busco eso.

Yo había pensado algo así:
Código
  1. Colores = ["Azul", "Rojo", "Verde", "Blanco", "Negro"];
  2. // Esto habría que hacerlo con loop pero no es lo relevante:
  3. PesoDeElementos = [Math.random(), Math.random(), Math.random(), Math.random(), Math.random()];
  4. Elemento1aReubicarse = -1;
  5. ReordenarHasta = 4;
  6. do {
  7. Elemento1aReubicarse++;
  8. Elemento2aReubicarse = Elemento1aReubicarse+1;
  9. if (PesoDeElementos[Elemento1aReubicarse] > PesoDeElementos[Elemento2aReubicarse]) {
  10. // Intercambiar esos 2 elementos:
  11. SaveDeElemento1 = Colores[Elemento1aReubicarse];
  12. Colores[Elemento1aReubicarse] = Colores[Elemento2aReubicarse];
  13. Colores[Elemento1aReubicarse] = SaveDeElemento1;
  14. }
  15. if (Elemento2aReubicarse == ReordenarHasta) {
  16. // Hacia la derecha ya está reordenado, volver a la izquierda:
  17. Elemento1aReubicarse = -1;
  18. ReordenarHasta--;
  19. }
  20. } while (ReordenarHasta > 0);

Pero suponiendo que podía haber algo más sencillo (esa cosa la acabo de hacer, no sé si funciona), le pregunté a GPT. Me dijo un método de Fisher o algo así que no entendí. En Wikipedia tampoco. Pero se me ocurrió (o puede ser igual a lo que no entendí) un método que recorra los elementos, hasta el central, intercambiando los de un lado con los de otro, y luego el central con cualquiera, pero tenía dudas de cómo sería exactamente y ahora noto que no sería justo, es decir, el 1er elemento nunca quedaría 2ndo (salvo que fuesen menos de 4), y además:
- Si siempre hay intercambio, nunca podrían quedar en el lugar original, lo cual debería poder suceder.
- Si puede no haber intercambio, la probabilidad de que queden igual varios de ellos es muy alta.
Así que eso no sirve ¿pero cual es entonces un buen método?

Copio la conversación que tuve con GPT:
Citar
En **Macromedia Flash 5**, que utiliza **ActionScript 1.0**, puedes implementar un algoritmo para reordenar un array al azar utilizando un enfoque conocido como el algoritmo de **Fisher-Yates Shuffle**. Aquí tienes el código que puedes usar para reordenar al azar el array `PosiblesColores`:

```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos

// Función para reordenar el array al azar
function shuffleArray(array) {
    var i, j, temp;
    for (i = array.length - 1; i > 0; i--) {
        j = Math.floor(Math.random() * (i + 1)); // Genera un índice aleatorio válido
        // Intercambia los elementos array y array[j]
        temp = array;
        array = array[j];
        array[j] = temp;
    }
}

// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);

// Imprime el array reordenado para verificar
for (var i = 0; i < PosiblesColores.length; i++) {
    trace(PosiblesColores);
}
```

### Explicación del código:
1. **Algoritmo Fisher-Yates**:
   - Este algoritmo recorre el array desde el último elemento hasta el primero.
   - En cada iteración, selecciona un índice aleatorio entre `0` y el índice actual, e intercambia los dos elementos.
   - Esto garantiza que cada permutación del array sea igualmente probable.

2. **`Math.random()`**:
   - Genera un número decimal aleatorio entre `0` y `1`.
   - Multiplicamos este número por el rango necesario (`i + 1`) para obtener un índice aleatorio válido.

3. **Intercambio de elementos**:
   - Usamos una variable temporal (`temp`) para almacenar el valor de uno de los elementos mientras realizamos el intercambio.

4. **`trace()`**:
   - Esta función imprime los valores en el panel de salida para que puedas verificar el resultado del reordenamiento.

### Ejemplo de salida:
Si el array original es:

```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```

Después de ejecutar el código, el array podría quedar como:

```actionscript
[0, 0xFFFFFF, 0xFF0000]
```

O cualquier otra permutación aleatoria de los elementos.

Puedes modificar el array `PosiblesColores` para agregar más elementos, y el algoritmo seguirá funcionando correctamente.

quisiera que el índice vaya subiendo en vez de bajando y que uses while en vez de for

Citar
¡Claro! Aquí está el código modificado para que el índice vaya **subiendo** y se use un bucle `while` en lugar de `for`. El algoritmo sigue siendo equivalente al **Fisher-Yates Shuffle**, pero adaptado a tus especificaciones:

```actionscript
// Array original
PosiblesColores = [0xFFFFFF, 0xFF0000, 0]; // Puedes agregar hasta 10 elementos

// Función para reordenar el array al azar
function shuffleArray(array) {
    var i = 0;  // Empieza desde el primer índice
    var len = array.length;

    while (i < len - 1) {
        // Genera un índice aleatorio entre i y el último índice
        var j = Math.floor(Math.random() * (len - i)) + i;

        // Intercambia los elementos array y array[j]
        var temp = array;
        array = array[j];
        array[j] = temp;

        // Incrementa el índice
        i++;
    }
}

// Llama a la función para mezclar el array
shuffleArray(PosiblesColores);

// Imprime el array reordenado para verificar
var index = 0;
while (index < PosiblesColores.length) {
    trace(PosiblesColores[index]);
    index++;
}
```

### Cambios realizados:
1. **Uso de `while`**:
   - El índice `i` comienza en `0` y se incrementa en cada iteración hasta el penúltimo elemento (`len - 1`).
   - El bucle `while` se detiene cuando el índice `i` alcanza el penúltimo elemento.

2. **Generación de índice aleatorio (`j`)**:
   - En lugar de seleccionar un índice aleatorio para cualquier posición del array, `j` se selecciona entre `i` (el índice actual) y el final del array.
   - Esto asegura que cada elemento solo sea intercambiado con los elementos que aún no han sido procesados.

3. **Intercambio de elementos**:
   - Igual que antes, usamos una variable temporal `temp` para realizar el intercambio entre `array` y `array[j]`.

4. **Impresión con `while`**:
   - Se utiliza un bucle `while` para imprimir cada elemento del array después de ser mezclado.

### Ejemplo de salida:
Dado el array original:

```actionscript
PosiblesColores = [0xFFFFFF, 0xFF0000, 0];
```

Después de ejecutar el código, podrías obtener una permutación como:

```actionscript
[0xFF0000, 0, 0xFFFFFF]
```

O cualquier otra ordenación aleatoria.

Este código es completamente funcional y cumple con las especificaciones que pediste.

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

Creo que ahora entiendo, va desde derecha a izquierda y "rolled" significa que eligió intercambiar con ese, el elemento posible de intercambiarse era el 4 y "rolled" un 1, yo interpretaba que había elegido por azar el 1 y no sabía de dónde había sacado el 4.

¿Es así? ¿hay otro mejor?
54  Foros Generales / Sugerencias y dudas sobre el Foro / Physhing en el foro ¡¿?! en: 6 Enero 2025, 10:54 am


Aunque sale ese tema y usuario, pudo haber sido acá:
https://foro.elhacker.net/desarrollo_web/cual_es_el_mejor_hostingservidor_dedicado_para_proyectos-t522776.0.html;msg2282159#msg2282159

La otra página es Youtube. Estaba viendo mis temas para responder, incluido el otro por curiosidad, y me saltó ese cartel.

Al otro tema, ese del link, creo que es la 1era vez que entro. Otra cosa que no suelo hacer es entrar a 2 temas a la vez digamos, pero no debería ser un problema.

EDIT:
No sé si en el otro, pero acá:
https://foro.elhacker.net/programacion_general/generar_funciones-t522899.0.html;msg2282600;topicseen#msg2282600
me acaba de salir de nuevo el cartel.
55  Programación / Programación General / ¿Qué tanto sentido tiene programar? en: 4 Enero 2025, 07:16 am
Para ver todos los dibujos posibles uno a uno, hice un programa que los genera así, aunque por ahora sólo son en blanco y negro, de esos 2 colores nada más.

Luego indiqué que no mostrara dibujos que no cumplieran ciertas características.

A:
Luego empecé a indicar cómo pasar de uno aceptable al siguiente aceptable, para evitar generar los que no van a mostrarse. Por si no se entiende:
Supongamos que quieres ver todos los números divisibles entre 3. Puedes generar todos los enteros y mostrar sólo los divisibles entre 3 (se genera el 1 pero no se muestra, luego el 2 pero tampoco, el 3 sí, luego el 4 pero no...), o puedes simplemente indicar que se generen sólo los necesarios (3, 6...). Pero no en todo contexto es simple.
Noté una falla en eso que hice. Tengo una idea sobre cómo corregirlo pero, si lo que hice antes estuvo mal ¿por qué creer que ahora estará bien? Tampoco es que deba creer que estará mal, no se debe creer que se puede prever el futuro tanto, es cuestión de probar, pero me tiene un poco cansado, no sé, me pregunto hasta qué punto tiene sentido fallar, fallar, fallar y cuando no se notan errores no estar seguro de si no hay o uno está fallando en detectarlos. Es como "Mejor que lo haga otro, alguien que no falle tanto".

Había concluido que lo mejor era dejar de intentar hacer A, pero eso en última instancia es como creer que no tiene sentido intentar programar, es dejar de programar. Por eso estoy un poco confuso, el programa en sí tampoco tiene mucho sentido, los dibujos que muestra es como que son nada, grandes cuadrados cerca, así o asá. Una IA o como se llame, hoy en día hace dibujos bastante bien de lo que se le pida, así que pa qué. En parte era porque quería demostrar que los dibujos no son una creación, que deba tener dueño, es algo que puede ser generado pintando ciertos puntos de ciertos colores, duh, y se puede lograr probando combinaciones. Y por ver dibujos interesantes, no sé. Ah, y era una práctica para otras cosas, no puedo generar películas o representaciones de cerebros, si no puedo generar dibujos... Mejor empezar por lo más fácil. No sé si es un error dejar esto o no. Y la cuestión es más profunda que eso, quizá debería dejar la programación misma, pero para hacer qué, no sé, si igual la cuestión de que puedo fallar sigue.

Probablemente no es un tema de programación entonces, pero aquí lo dejo, como "testimonio" de lo que es programar sin saber hacerlo bien, o el problema que sea.


Recientemente vi este video:
https://www.youtube.com/watch?v=4zk6uodm7tY
Yo no entendí Matrix y no recordaba tanto, aparentemente el programador comete fallas que no sabe corregir.
56  Programación / Python / Buscador de combinaciones inexistentes no funciona. en: 3 Enero 2025, 05:20 am
Relacionado con:
https://foro.elhacker.net/hacking/descartar_combinaciones_de_caracteres_al_buscar_password-t522886.0.html

Código dado por GPT:
Código
  1. import itertools
  2.  
  3. def cargar_diccionario(ruta):
  4.    """Carga el diccionario desde un archivo .txt y devuelve un conjunto de palabras en minúsculas."""
  5.    with open(ruta, 'r', encoding='utf-8') as archivo:
  6.        return set(palabra.strip().lower() for palabra in archivo)
  7.  
  8. def generar_combinaciones(alfabeto):
  9.    """Genera todas las combinaciones posibles de dos letras del alfabeto."""
  10.    return {a + b for a, b in itertools.product(alfabeto, repeat=2)}
  11.  
  12. def buscar_combinaciones(diccionario, combinaciones):
  13.    """Busca combinaciones dentro de las palabras del diccionario."""
  14.    presentes = set()
  15.  
  16.    # Buscar combinaciones dentro de palabras individuales
  17.    for palabra in diccionario:
  18.        for i in range(len(palabra) - 1):
  19.            presentes.add(palabra[i:i+2])
  20.  
  21.    # Buscar combinaciones entre palabras consecutivas
  22.    lista_palabras = sorted(diccionario)  # Ordenar las palabras
  23.    for i in range(len(lista_palabras) - 1):
  24.        ultima_letra = lista_palabras[-1]
  25.        primera_letra = lista_palabras[i + 1][0]
  26.        presentes.add(ultima_letra + primera_letra)
  27.  
  28.    return combinaciones - presentes
  29.  
  30. # Paso 1: Cargar diccionarios
  31. diccionario_es = cargar_diccionario('diccionario_es.txt')
  32. diccionario_en = cargar_diccionario('diccionario_en.txt')
  33.  
  34. # Paso 2: Generar combinaciones posibles
  35. alfabeto_es = 'abcdefghijklmnñopqrstuvwxyz'
  36. alfabeto_en = 'abcdefghijklmnopqrstuvwxyz'
  37. combinaciones_es = generar_combinaciones(alfabeto_es)
  38. combinaciones_en = generar_combinaciones(alfabeto_en)
  39.  
  40. # Paso 3: Buscar combinaciones inexistentes en cada diccionario
  41. inexistentes_es = buscar_combinaciones(diccionario_es, combinaciones_es)
  42. inexistentes_en = buscar_combinaciones(diccionario_en, combinaciones_en)
  43.  
  44. # Paso 4: Combinar resultados y mostrar combinaciones inexistentes en ambos idiomas
  45. inexistentes_totales = inexistentes_es.intersection(inexistentes_en)
  46.  
  47. print(f"Combinaciones inexistentes en ambos idiomas ({len(inexistentes_totales)}):")
  48. print(sorted(inexistentes_totales))

Tengo los diccionarios y les puse los nombres que dice ahí:
diccionario_es.txt
diccionario_en.txt

El programa se cierra enseguida sin que yo pueda ver qué pasa. ¿Cual es la falla, cómo lo arreglo?
57  Foros Generales / Dudas Generales / Convertir espacios seguidos en saltos de línea. en: 2 Enero 2025, 23:23 pm
Intento conseguir una lista prolija de las cartas de una versión modificada de Magic The Gathering Shandalar que no sé cual es. 2010 o 2012 probablemente. Revisé archivos Readme y otros pero no lo vi claro. El instalador no lo tengo a mano. El archivo más nuevo es de 2009-07.

Busqué en Internet listas de cartas de esas versiones y tampoco hallé. Lo mejor que encontré es una lista en un archivo Cards.dat pero está entreverada, así:
Citar
Air Elemental Air Elemental Creature - Elemental Flying Pray that it doesn't seek the safety of your lungs.      Ancestral Recall Ancestral Recall Instant Target player draws three cards.       Animate Artifact Animate Artifact Enchant Artifact Enchanted non-creature artifact is a creature with power and toughness each equal to its converted mana cost. It's still an artifact.       Animate Dead Animate Dead Enchantment When Animate Dead comes into play, if it's in play, it becomes an enchant creature. Put target creature card from a graveyard into play under your control enchanted by Animate Dead.
Enchanted creature gets -1/-0.
When Animate Dead leaves play, destroy enchanted creature. It can't be regenerated.       Animate Wall Animate Wall Enchant Wall Enchanted creature may attack as though it weren't a Wall.       Ankh of Mishra Ankh of Mishra Artifact Whenever a land comes into play, Ankh of Mishra deals 2 damage to that land's controller.       Armageddon Armageddon Sorcery Destroy all lands.       Aspect of Wolf Aspect of Wolf Enchant Creature Enchanted creature gets +X/+Y, where X is equal to half the number of |H1Forests you control, rounded down, and Y is equal to half the number of |H1Forests you control, rounded up.       Bad Moon Bad Moon Enchantment |SBlack creatures get +1/+1.       Badlands Badlands Land - Mountain Swamp Badlands can be tapped to produce |B or |R.
etc, tampoco están ordenadas alfabéticamente. En general, una nueva carta se menciona luego de muchos espacios. Al parecer a veces son 6, a veces 7, quizá a veces otra cantidad.

Quisiera un método para convertir esos varios espacios en un salto de línea.

Converir 7 espacios seguidos en un salto de línea.

Luego converir 6.

Y si hay otras cantidades, lo mismo.

¿Cómo?

Esto:
https://onlinetexttools.com/convert-spaces-to-newlines
Al principio nada hacía, había muchas opciones, no sabía cual elegir, luego de repente mostró un resultado pero convirtiendo cada espacio, yo no quiero eso, sólo si son 7 espacios seguidos, luego 6, etc.

Edit:
Sirvió esto:
https://www.youtube.com/watch?v=6s2WWC7NQ0E

Antes había probado ver caracteres ocultos y copiar el de salto pero no sirvió, bah.
58  Foros Generales / Foro Libre / ¿Cómo estuvo tu 2024? en: 2 Enero 2025, 00:14 am
No se hable de cosas que puedan hacer cerrar el tema, lo pongo en foro libre porque no va a ser sólo de programación, pero tampoco es para tirar bombas.

Proyecto 1:
Escribir libro que enseñe cosas a gente como yo era o similar.

Porque siento que no me enseñaron suficiente, así que de hecho no puedo enseñar mucho, pero en fin, algo es mejor que sólo nada.
La idea es que lo pueda entender cualquiera, más o menos como esto:
https://www.pictocuentos.com/el-patito-feo/4
Como eso es una historia, y lo más fácil es, supuestamente, contar la de uno, para empezar hago eso.
Es que ¿cómo hacer un libro que enseñe a usarlo a quien no sepa? Imagina que lo recibe un indígena que nunca vió uno, quiero que le sirva a alguien así incluso, por eso no sé bien cómo empezar y hago algo simple por ahora.
Pero es más complicado de lo que pensé, resumir cada año en 1 palabra y 1 imagen, por ahora haría eso, una versión para gente que no quiera mucho texto, luego haría otra con más. ¿Qué palabra es la más correcta? ¿qué imagen? Y hallarla no siempre es sencillo. Por suerte esta página:
https://poe.com/
tiene chats que pueden generar imágenes, por ejemplo Imagen3-Fast.
Cuando copio una tabla en Word y la pego en otro lado aparece sólo un trozo, así que tuve que ponerla en partes:
https://i.ibb.co/ZTF5M2s/Resumen-libro-parte-1.png
https://i.ibb.co/ggr36Yr/Resumen-libro-parte-2.png
https://i.ibb.co/N3X7PSZ/Resumen-libro-parte-3.png
https://i.ibb.co/ctdFN0H/Resumen-libro-parte-4.png
https://i.ibb.co/r0J6n4f/Resumen-libro-parte-5.png
Creo que va bien, aunque a velocidad de tortuga con una pata rota. Por lo explicado en una de esas imágenes, se supone que ahora avanzaré más rápido.
En cuanto a de dónde son algunas imágenes:
- Seiken Denketsu 3 y Breath of Fire 2.
- Super Dodge Ball Neo Geo y un juego de Kunio en que las protagonistas son mujeres, no recuerdo el nombre.
- Evangelion (Shinji fue sustituído) y Love Hina.
- Final Fantasy 4.
- Rescue Rangers, también conocido como Los rescatadores o algo así, capítulo "El caso del culto Cola", lo tenía en video cuando no había mucho que ver y lo vi muuuchas veces...
- El bardo que aparece en diálogos es de Ásterix.
- En el globo de pensamiento de Yugioh, Final Fantasy 6 y una carta de Magic.
- Love Hina.
- Transformers, capítulo "Dark awakening".

Proyecto 2:
Ordenar el PC.
Aún no pude averiguar mis olvidados passwords, y tampoco avanzo muy rápido, pero bue...

Proyecto 3:
Aprender a hacer programas que resuelvan dudas.
No sé bien qué pasó con esto, intenté varias cosas pero es como que no avanzo. Hace muy poco decidí, en vez de intentar imaginar dudas simples, partir de conocidas, simplificarlas y luego irlas complicando. Aún no empecé con eso.

Proyecto 4:
Hacer programa que genere todos los posibles dibujos, uno a uno, evitando los que no cumplen ciertas condiciones.
Al principio del año, el programa mostraba todos los dibujos, o al menos no vi que evitara algunos, no recuerdo. Ahora ya evita, e intento que evite más eficientemente. Tuve varios entreveros y cambié varias cosas. Hace poco me di cuenta de que el dibujo mayor (si se considera representado por un número) válido no es una / (nota: 1 es blanco, 0 es negro):
110
101
011
que es 110101011
sino este estilo
110
110
001
que es 110110001
Esta es la versión más estable que tengo, creo:
https://drive.google.com/file/d/1SAzKGQ5u2LdCQshSr1jacnrSIms9C5aw/view?usp=sharing
Incluye el editable, su swf y exe. Luego de un que se genere una imagen deben presionar espacio, pueden dejarlo presionado para que avance más rápido. La idea era ver cosas interesantes ¿conocen los test de Rorscharch? Pero resultó aburrido. Aún así, creo que me servirá esto, en mi siguiente proyecto:

Proyecto 5:
Hacer programa que genere varios dibujos, principalmente con el objetivo de servir de sprites.
Hay mucho que debo agregarle, y no todo está funcionando bien, ni evita errores. Además de poder cambiar algunas cosas con botones, pueden cliquear los dibujos, eso hará que muten un poco; la idea es ir seleccionando el que más guste, pero al final es como que conviene más editarlo en Paint xP
https://drive.google.com/file/d/1Boo6Ca33MMalrVe6uT0F8vCLJhnk0uyj/view?usp=sharing

Proyecto 6:
Hacer juegos.
Similarmente a con las dudas, es como que he dado muchas vueltas, sin avanzar. Hace muy poco decidí, en vez de intentar hacer juegos simples (que es complicado idear una justificación para lo que son o sucede en ellos), imitar a los de acá:
https://www.mobygames.com/game/sort:date/page:1/
simplificando. Empecé por el 3 en línea. Aún no lo tengo hecho porque empecé hace poco, además nunca había hecho ese juego ni alguno tan similar. Por ahora sólo se puede cambiar ek tamaño del tablero y poner cruces:

Si llego a tener algo que más o menos valga la pena dar, se los paso.

Proyecto 7:
Participar en competencias de juegos.
Me refiero a elegir un modo de jugar, una especie de reto (aunque debe ser medible qué tan bien se logra), y jugar.
Hice:
- En un juego de acción, Donkey Kong, obtener el máximo Score posible en el 1er loop.
- En un juego de puzzle, Lode Runner, pasar las stages intentando no hacer agujeros.
Eso ha sido difícil, con estos dedos que aún los tengo medio mal y presionaba teclas sin querer, hacer un agujero en un sitio indebido requería volver a empezar, en general no ha sido divertido. También había que ver cómo se comportaban los enemigos, dependía mucho de hallar "errores" en su comportamiento.
Ahora estoy con:
- En un juego de carreras, Excitebike, pasar los tracks... es difícil explicar cómo, hice un video sobre eso, pero aún no lo subí, estoy esperando a pasar el 4, pero básicamente es intentar pasar el juego evitando presionar botones distintos al A. Tampoco es divertido, es horrible, el juego es como muy azaroso, a veces choca y a veces no, a veces rebota un poquito aunque se caiga derecho; lo que hago entonces es buscar un modo seguro de clasificar, aunque no sea el que menos botones use, por lo que mi partida podría ser superada si se tiene suerte.
He logrado pasar el 4 usando 20 botones sin contar el A. Este mapa muestra cómo, en el video lo pondré completo:

Lo que más me gusta es hacer experimentos en juegos de estrategia, esto de evitar presionar botones también pero no en un juego tan azaroso o que depende tanto del momento justito en que hagas una cosa u otra, además como dije es jodido porque si presionas uno sin querer o por costumbre porque normalmente conviene, perdiste. Pero ya llegará el momento, ojalá.
La mayoría de competencias que hace la gente son sobre pasar el juego rápido, es algo que no limita tu habilidad, pero no soy bueno en eso, en entender qué es mejor cuando se tienen muchas opciones, así que suelo preferir limitar las opciones, aprender así, y si luego me interesa entonces limitar menos y así sucesivamente. Además aburre un poco ver siempre lo mismo, siempre todo rápido, es como si no disfrutaran los juegos, algunos hasta usan bugs que le quitan la gracia.
Por otro lado, avancé bastante en comprender cuales son las posibles competencias. Pero es difícil explicar sobre eso, pueden ver esto si quieren pero no es tan claro:
https://drive.google.com/file/d/1UrpdCxgao0r4OlUnRg9agxSu8TZThANs/view?usp=sharing
Comiencen por el exe o swf y usen las flechas de derecha o izquierda, no usen las de arriba o abajo porque nada aparecerá. Luego el archivo de Excel muestra cosas que pueden obtenerse o contarse de una partida de Dragon Warrior especialmente, pero tiene cierta validez para otros juegos.

Intenté otras cosas ese año pero avancé poco en ellas y preferí enfocarme en menos cosas para avanzar más rápido, que aún así no ha servido de mucho.

En vez de querer darme trabajo quieren darme pastillas, no tengo idea de qué hacer, mi problema además de la torpeza es que me resulta muy complicado cumplir horarios, no duermo a una hora especifica, puede cambiar. Fui a una organización donde supuestamente ayudan a la gente pero la señora de ahí no quiso leer algo que escribí, ni decirme en cuántas palabras quería que se lo diga, se puso a leer la parte final, no entendió, y me fui porque pa qué hablar con gente así.

Tal vez debería escribir menos y hacer más, escribo diarios de lo que hago, pero creo que me ayuda a pensar mejor, concentrarme mejor, además me olvido muchas cosas y tener anotadas las cosas claro que ayuda, por ejemplo errores que debo corregir o cosas que se me ocurrieron agregar.
59  Programación / Programación General / Generar funciones. en: 30 Diciembre 2024, 06:30 am
Al parecer todas las dudas relacionadas con quitar caracteres requieren 3 variables mínimo, yo quería sólo 2, así que voy a por operaciones comúnes donde parece que sí pueden ser 2.

El programa intentaría resolver una duda variable, algo así:
Definir Constante.
Seleccionar al azar cómo se aplicará el Candidato.
Definirlo.
Aplicarlo.
Variarlo hasa que Constante < Resultado.

Quiero ayuda con lo de seleccionar. El paso de aplicar el candidato sería llamar a una función especificada por el paso de seleccionar. Seleccionarla es fácil. Llamar a una función variable no es el problema. Es que son muchas posibles aplicaciones, o funciones, por ejemplo:
Aplicacion0 () {
   Resultado = Candidato;
}
Aplicacion1 () {
   Resultado = Candidato+Constante;
}
Aplicacion2 () {
   Resultado = Candidato+Candidato;
}
Aplicacion3 () {
   Resultado = Candidato-Constante;
}
etc

O sea, el programa intentaría resolver una duda al azar, dependiendo de qué función elija al principio, por ejemplo si elige la 2 es:
¿Qué valor conviene darle a Candidato para que Constante < Candidato+Candidato?
Pero la condición en el código sería Constante < Resultado, en eso se guardaría el resultado de las operaciones que hagan falta.

Así pues, necesito generar una lista de funciones o aplicaciones. En la definición de Resultado pueden usarse sólo las 2 variables mencionadas. Y operaciones matemáticas comúnes. Y paréntesis. 3 operaciones máximo.

Bueno, supongo que es algo como:
Aplicacion = 0
Repetir:
   Mostrar en pantalla "Aplicacion"+Aplicacion+" () {"+salto de línea+"   Resultado = "
...es decir, falta una parte, que no sé, pero la idea es que un programa genere esas funciones, las muestre, yo las copio y las pego en el programa que quiero hacer, o sea, el generador es como un subprograma, un medio.

Hay que variar lo que viene luego de "= ".

¿Ideas?

No tengo puntos para GPTear, cuando pueda lo hago.
60  Informática / Software / ¿Qué son los archivos ~$algo.xlsx o docx? en: 30 Diciembre 2024, 05:11 am
Entiendo que son como trozos de recuperación de otros archivos, modificaciones que no fueron guardadas ¿alguien me confirma o me da más info?

Intento eliminar archivos repetidos y no sé bien qué hacer con estos, al no saber bien qué son.
Páginas: 1 2 3 4 5 [6] 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 ... 51
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines