Mostrar Mensajes
Código:
N = 0
Repetir:
N++
Si N cumple la condición
mostrar N en pantalla
N = "Listo"
mientras N != "Listo"
¿Pero qué pasa si se quiere también que se chequeen números negativos? Podría ser:
Código:
N = 0
Repetir:
N++
Si N cumple la condición
mostrar N en pantalla
N = "Listo"
sino
N*-1
Si N cumple la condición
mostrar N en pantalla
N = "Listo"
sino
N*-1
mientras N != "Listo"
¿Y si se quiere que también se chequee decimales cada vez más largos? Esto ya no sé, me refiero a algo como:
0
1
-1
2
-2
0.1
-0.1
3
-3
0.2
-0.2
0.01
-0.01
etc
¿Con qué código se podría generar una serie así?
En cuanto a que la serie produzca números que en general cumplan cualquier condición más rápido que otras, quizá no sea posible, porque si se necesita un número mayor que 10000 por ejemplo entonces que se produzcan negativos enlentecerá el proceso, acelerar el hallazgo de ciertos Ns enlentece la de otros.
Pero entonces al menos me gustaría que la serie produzca siempre partes muy distintas a las anteriores, creo que sería parecido. ¿Qué es "distintas"? Puede decirse que 123 es lo más distinto a -123, pero sus subnúmeros (1, 2 y 3) son iguales, su orden es el mismo, su diferencia es la misma (1-2=-1, 2-3=-1), la distancia entre los números en sí es sólo 246, etc, mientras que por ejemplo -9077 sería distinto en muchos más aspectos. Si sólo fuesen números positivos, me gustaría que fuese algo como:
1
9 (número de 1 subnúmero, lo más alejado posible del anterior).
53 (número de 2 subnúmeros, primero el más alejado o promedio de los anteriores, y el 2ndo es el más alejado entre medio del central y el mínimo (5 y 1)).
7 (1 subnúmero, el más alejado del que era central y del máximo (5 y 9)).
26 (2sns, no sé si sería el correcto pero quedando "02468", 2 y 6 son los más alejados y además están ordenados de menor a mayor, no como el anterior 53).
804 (3sns, quedaba "048", quizá 408 serviría, lo esencial es que no esté totalmente ordenado).
A partir de aquí ya no quedan números sin usar así que se repetirían, además cuando se formen números con varios subnúmeros también deben repetirse algunas veces (ejemplo 55).
¿Cómo se puede programar que suceda algo así?
Me gustaría mezclar eso con negativos y decimales también, cuidando que los mismos tipos de número (por ejemplo los negativos) sean siempre distintos (porque al producir distintos tipos cuidando que sean distintos entre sí quizá se da el caso de que los del mismo tipo sean muy parecidos, hay que evitar eso también).
¿Cómo?
Veamos qué dice GPT.
¿Con actionscript cómo se podría generar una serie así?
0
1
-1
2
-2
0.1
-0.1
3
-3
0.2
-0.2
0.01
-0.01
etc
Citar
Aquí tienes un ejemplo de cómo generar la serie que mencionaste utilizando ActionScript:
```actionscript
var series:Array = [];
var n:Number = 0;
var sign:Number = 1;
var increment:Number = 1;
while (series.length < 100) {
series.push(n);
if (sign > 0) {
n += increment;
} else {
n -= increment;
increment /= 10;
}
sign *= -1;
}
// Imprimir la serie
for each (var num:Number in series) {
trace(num);
}
```
En este ejemplo, utilizamos un bucle `while` para generar los números de la serie. La variable `n` almacena el número actual, `sign` determina si el número debe ser positivo o negativo, y `increment` controla el tamaño del siguiente incremento.
En cada iteración del bucle, agregamos el número actual a la serie y luego actualizamos `n`, `sign` y `increment` según las reglas de la serie. Cuando el signo cambia de positivo a negativo, dividimos `increment` por 10 para generar los números decimales más pequeños.
Después de generar la serie, imprimimos cada número utilizando el comando `trace()`.
Ten en cuenta que este ejemplo es solo una forma de generar la serie solicitada en ActionScript. Puedes ajustar los parámetros y la lógica según tus necesidades específicas.
Muy complicado, hay mucho de ahí que no entiendo (no uso AS así), intento que simplifique:```actionscript
var series:Array = [];
var n:Number = 0;
var sign:Number = 1;
var increment:Number = 1;
while (series.length < 100) {
series.push(n);
if (sign > 0) {
n += increment;
} else {
n -= increment;
increment /= 10;
}
sign *= -1;
}
// Imprimir la serie
for each (var num:Number in series) {
trace(num);
}
```
En este ejemplo, utilizamos un bucle `while` para generar los números de la serie. La variable `n` almacena el número actual, `sign` determina si el número debe ser positivo o negativo, y `increment` controla el tamaño del siguiente incremento.
En cada iteración del bucle, agregamos el número actual a la serie y luego actualizamos `n`, `sign` y `increment` según las reglas de la serie. Cuando el signo cambia de positivo a negativo, dividimos `increment` por 10 para generar los números decimales más pequeños.
Después de generar la serie, imprimimos cada número utilizando el comando `trace()`.
Ten en cuenta que este ejemplo es solo una forma de generar la serie solicitada en ActionScript. Puedes ajustar los parámetros y la lógica según tus necesidades específicas.
Citar
puede ser una lista de números sueltos en vez de una serie?
Citar
¡Por supuesto! Si deseas generar una lista de números sueltos en lugar de una serie continua, puedes modificar el código de la siguiente manera:
```actionscript
var numbers:Array = [0, 1, -1, 2, -2, 0.1, -0.1, 3, -3, 0.2, -0.2, 0.01, -0.01];
// Imprimir la lista de números
for each (var num:Number in numbers) {
trace(num);
}
```
En este ejemplo, hemos creado un arreglo llamado `numbers` que contiene los números sueltos de la lista. Luego, utilizamos un bucle `for each` para recorrer el arreglo y mostrar cada número utilizando el comando `trace()`.
Puedes agregar, eliminar o modificar los números en el arreglo según tus necesidades. Simplemente asegúrate de seguir la sintaxis correcta de ActionScript para definir los números (usando el punto decimal para los números decimales, por ejemplo).
Recuerda que este código solo imprimirá los números en la consola de salida. Si deseas hacer algo más con los números, como almacenarlos en variables o realizar cálculos, puedes adaptar el código en consecuencia.
```actionscript
var numbers:Array = [0, 1, -1, 2, -2, 0.1, -0.1, 3, -3, 0.2, -0.2, 0.01, -0.01];
// Imprimir la lista de números
for each (var num:Number in numbers) {
trace(num);
}
```
En este ejemplo, hemos creado un arreglo llamado `numbers` que contiene los números sueltos de la lista. Luego, utilizamos un bucle `for each` para recorrer el arreglo y mostrar cada número utilizando el comando `trace()`.
Puedes agregar, eliminar o modificar los números en el arreglo según tus necesidades. Simplemente asegúrate de seguir la sintaxis correcta de ActionScript para definir los números (usando el punto decimal para los números decimales, por ejemplo).
Recuerda que este código solo imprimirá los números en la consola de salida. Si deseas hacer algo más con los números, como almacenarlos en variables o realizar cálculos, puedes adaptar el código en consecuencia.
no, sí programando, pero sin agregarlos en una variable array
Citar
Si deseas generar y mostrar una lista de números sin almacenarlos en un arreglo, puedes hacerlo utilizando un bucle y el comando `trace()` para imprimir cada número individualmente. Aquí tienes un ejemplo:
```actionscript
var count:int = 0;
var number:Number = 0;
var increment:Number = 1;
while (count < 13) {
if (count % 2 == 0) {
number += increment;
} else {
number -= increment;
increment /= 10;
}
trace(number);
count++;
}
```
En este ejemplo, utilizamos un bucle `while` para generar y mostrar una lista de 13 números. La variable `count` se utiliza para llevar la cuenta del número de elementos generados, y la variable `number` almacena el número actual de la lista. También tenemos la variable `increment`, que controla el tamaño del siguiente incremento.
Dentro del bucle, verificamos si `count` es par o impar utilizando el operador de módulo `%`. Si es par, incrementamos `number` según la regla de incremento. Si es impar, decrementamos `number` y dividimos `increment` por 10 para generar los números decimales más pequeños.
Finalmente, utilizamos `trace(number)` para imprimir cada número en la consola de salida.
Ten en cuenta que este código genera y muestra los números directamente sin almacenarlos en una variable de matriz. Puedes ajustar el número de elementos y las reglas de incremento según tus necesidades.
```actionscript
var count:int = 0;
var number:Number = 0;
var increment:Number = 1;
while (count < 13) {
if (count % 2 == 0) {
number += increment;
} else {
number -= increment;
increment /= 10;
}
trace(number);
count++;
}
```
En este ejemplo, utilizamos un bucle `while` para generar y mostrar una lista de 13 números. La variable `count` se utiliza para llevar la cuenta del número de elementos generados, y la variable `number` almacena el número actual de la lista. También tenemos la variable `increment`, que controla el tamaño del siguiente incremento.
Dentro del bucle, verificamos si `count` es par o impar utilizando el operador de módulo `%`. Si es par, incrementamos `number` según la regla de incremento. Si es impar, decrementamos `number` y dividimos `increment` por 10 para generar los números decimales más pequeños.
Finalmente, utilizamos `trace(number)` para imprimir cada número en la consola de salida.
Ten en cuenta que este código genera y muestra los números directamente sin almacenarlos en una variable de matriz. Puedes ajustar el número de elementos y las reglas de incremento según tus necesidades.
quiero que hagas eso pero para generar la lista que te dije al inicio
Citar
Mis disculpas por la confusión anterior. Aquí tienes el código para generar y mostrar la lista de números que mencionaste al inicio:
```actionscript
var count:int = 0;
var number:Number = 0;
var increment:Number = 1;
while (count < 100) {
if (count % 2 == 0) {
number += increment;
} else {
number -= increment;
increment /= 10;
}
trace(number);
count++;
}
```
En este caso, hemos ajustado el código para generar una lista de 100 números siguiendo el patrón que mencionaste inicialmente. El bucle `while` genera los números utilizando las mismas reglas de incremento que mencionaste.
Cada número se imprime utilizando el comando `trace()`. El código seguirá generando y mostrando los números hasta que se hayan generado los 100 elementos de la lista.
Recuerda que puedes ajustar el número de elementos y las reglas de incremento según tus necesidades.
```actionscript
var count:int = 0;
var number:Number = 0;
var increment:Number = 1;
while (count < 100) {
if (count % 2 == 0) {
number += increment;
} else {
number -= increment;
increment /= 10;
}
trace(number);
count++;
}
```
En este caso, hemos ajustado el código para generar una lista de 100 números siguiendo el patrón que mencionaste inicialmente. El bucle `while` genera los números utilizando las mismas reglas de incremento que mencionaste.
Cada número se imprime utilizando el comando `trace()`. El código seguirá generando y mostrando los números hasta que se hayan generado los 100 elementos de la lista.
Recuerda que puedes ajustar el número de elementos y las reglas de incremento según tus necesidades.
muestra la lista que genera eso
Citar
Aquí tienes la lista generada por el código:
```
0
1
-1
2
-2
0.1
-0.1
3
-3
0.2
-0.2
0.01
-0.01
0.3
-0.3
Le di stop porque está mal.```
0
1
-1
2
-2
0.1
-0.1
3
-3
0.2
-0.2
0.01
-0.01
0.3
-0.3
no has entendido o me expliqué mal.
En la 1er repetición debe producirse un número entero positivo y su negativo, son el 1 y -1, eso lo entendiste.
En la 2nda repetición debe producirse eso mismo pero sumándole 1 al positivo (su negativo también debe cambiar, debe ser el negativo del numero número), y además debe producirse un número positivo de un decimal (0.1) y su negativo. Eso también lo entendiste.
En definitiva, es como si estuvieses haciendo una serie de enteros, mostrando también cada negativo, y en cada nueva repetición empiezas a hacer otra serie pero cada vez con más decimales, y sus negativos. Haz eso.
Citar
Mis disculpas nuevamente por la confusión. Ahora entiendo lo que estás buscando. Aquí tienes el código actualizado para generar la lista siguiendo el patrón que describiste:
```actionscript
var count:int = 1;
var increment:int = 1;
while (count <= 10) {
var number:int = increment;
var negativeNumber:int = -increment;
trace(number);
trace(negativeNumber);
var decimalIncrement:Number = 0.1;
var decimalCount:int = count;
while (decimalCount > 0) {
var decimalNumber:Number = number + decimalCount * decimalIncrement;
var negativeDecimalNumber:Number = -decimalNumber;
trace(decimalNumber.toFixed(1));
trace(negativeDecimalNumber.toFixed(1));
decimalCount--;
decimalIncrement /= 10;
}
increment++;
count++;
}
```
Este código generará la lista siguiendo el patrón que describiste. Comenzará con una serie de enteros positivos y sus respectivos negativos, y en cada repetición se agregarán números positivos con decimales y sus negativos correspondientes. El número de decimales aumentará en cada repetición.
Los números se mostrarán utilizando el comando `trace()`. Los números enteros se mostrarán sin decimales, mientras que los números con decimales se mostrarán con un solo decimal utilizando `toFixed(1)`.
Ten en cuenta que en este código he utilizado un límite de 10 repeticiones, pero puedes ajustarlo según tus necesidades.
```actionscript
var count:int = 1;
var increment:int = 1;
while (count <= 10) {
var number:int = increment;
var negativeNumber:int = -increment;
trace(number);
trace(negativeNumber);
var decimalIncrement:Number = 0.1;
var decimalCount:int = count;
while (decimalCount > 0) {
var decimalNumber:Number = number + decimalCount * decimalIncrement;
var negativeDecimalNumber:Number = -decimalNumber;
trace(decimalNumber.toFixed(1));
trace(negativeDecimalNumber.toFixed(1));
decimalCount--;
decimalIncrement /= 10;
}
increment++;
count++;
}
```
Este código generará la lista siguiendo el patrón que describiste. Comenzará con una serie de enteros positivos y sus respectivos negativos, y en cada repetición se agregarán números positivos con decimales y sus negativos correspondientes. El número de decimales aumentará en cada repetición.
Los números se mostrarán utilizando el comando `trace()`. Los números enteros se mostrarán sin decimales, mientras que los números con decimales se mostrarán con un solo decimal utilizando `toFixed(1)`.
Ten en cuenta que en este código he utilizado un límite de 10 repeticiones, pero puedes ajustarlo según tus necesidades.
muestrame los 1eros 20 números de eso
Citar
Aquí tienes la lista de los primeros 20 números generados por el código:
```
1
-1
1.1
-1.1
1.01
-1.01
1.001
-1.001
1.0001
-1.0001
1.00001
-1.00001
1.000001
-1.000001
1.0000001
-1.0000001
1.00000001
-1.00000001
1.000000001
-1.000000001
1.0000000001
-1.0000000001
2
-2
2.1
-2.1
2.01
-2.01
```
Estos son los primeros 20 números generados siguiendo el patrón descrito anteriormente. El patrón comienza con "1" y su negativo "-1", luego se agregan números con un decimal creciente y sus negativos correspondientes. Después de completar la serie con un decimal, se pasa al siguiente número entero y se repite el proceso.
```
1
-1
1.1
-1.1
1.01
-1.01
1.001
-1.001
1.0001
-1.0001
1.00001
-1.00001
1.000001
-1.000001
1.0000001
-1.0000001
1.00000001
-1.00000001
1.000000001
-1.000000001
1.0000000001
-1.0000000001
2
-2
2.1
-2.1
2.01
-2.01
```
Estos son los primeros 20 números generados siguiendo el patrón descrito anteriormente. El patrón comienza con "1" y su negativo "-1", luego se agregan números con un decimal creciente y sus negativos correspondientes. Después de completar la serie con un decimal, se pasa al siguiente número entero y se repite el proceso.
Equivocado de nuevo y ya me cansé, al menos tengo más idea de cómo hacerlo. ¿Qué me dicen uds?