|
141
|
Foros Generales / Sugerencias y dudas sobre el Foro / ¿Sería buena idea crear un blog aquí sobre avances de nuestros proyectos?
|
en: 15 Junio 2024, 02:01 am
|
Lo bueno: - Es una opción a ver a quien le interese. - Implicaría más actividad en el foro, si hay participación ahí. - Puede atraer a más usuarios, tal vez.
Posibles problemas: - Spammers. No me refiero a que muchos vengan, publiquen sus cosas una vez y adiós, eso no sé si sería un problema, sino que me refiero al caso de que la gente publique casi lo mismo a cada rato: "Agregué una opción al menú", "agregué otra", etc. Yo mismo podría ser que haga algo así, aunque no por gusto. - Desorden. Si se postean muchas cosas será un tema de cosas un poco random, no sé si lo consideran un problema. Ya hay un tema donde la gente pùblica canales de YT, o sus blogs, esto sería parecido pero podría ser más activo. - Más trabajo para los mods, posibles links a malware de usuarios que luego nunca más participen...
¿Hay posibles soluciones, o prevenciones? Por ejemplo para el 1 se podría limitar el número de post por semana, o mes, o si trabajan en más de 1 proyecto podría limitarse la cantidad de post por semana/mes sobre cada proyecto (es decir se pueden hacer 2 mensajes por semana, por ejemplo, si es sobre 2 proyectos distintos). Pero eso no evita que se puedan postear pequeñeces o incluso "Esta semana se me complicó". Para el 3, en caso de ser usuarios nuevos se podría exigir que pongan una imagen, código o video a YT, no sólo el link a quien sabe dónde y qué.
|
|
|
142
|
Programación / Programación General / ¿Programar esto es buena idea o antes debo saber más?
|
en: 12 Junio 2024, 11:25 am
|
Quiero hacer más rápido esto que me resulta difícil. Nota: X puede ser monedas, estrellas, cualquier cosa de un videojuego, en esta tarea no es necesario especificarla. La hoja 1 está completa:  La hoja 2 está completa (vean que lo obtenido en la hoja 1 es usado aquí como base):  La hoja 3 no, y no sé cuántas hojas quiero hacer:  El problema de que un programa lo haga (sólo una lista, no como las imágenes) es que hay casos especiales, no es tan fácil saberlos a priori o que el programa los produzca bien cuando debe ¿qué me recomiendan?
|
|
|
143
|
Programación / Programación General / Distribuir cosas en una tabla ¿división básica?
|
en: 11 Junio 2024, 01:02 am
|
Si tengo una tablero de XxX casilleros y quiero distribuir Y colores ¿cómo defino de qué color es cada casillero? Por ejemplo si X es 3 e Y es 6 quiero esto: 112 233 456 Es decir, se reparte 9 entre 6 y lo que sobre se da a los 1eros colores. El casillero 1 debe ser de color 1. El 2 de color 1. El 3, 2. 4, 2. 5, 3. 6, 3. 7, 4. 8, 5. 9, 6. ¿Cómo logro eso? X e Y pueden variar, claro. Me dieron una supuesta solución en otro lado pero no pude hacerlo funcionar: Para un tablero L×L y c colores llama:
N=L^2 a=floor(N/c) (parte entera de N/c) r=mod(N,c) (resto de dividir N entre c)
Entonces el número de color que tienes que poner en la fija i, columna j, es:
- Si p<=r*(a+1), floor((p-1)/(a+1)+1 - Si p>r*(a+1), r+1+floor((p-r(a+1)-1)/a)
donde p=(i-1)*L+j Mi código (no es sobre asignar colores sino "ModificacionesRequeridas", pero la idea es la misma): DibujosPorFila = 5; MaxCuadro = DibujosPorFila*DibujosPorFila; CuadraditosPorFila = 4; MaxCuadradito = CuadraditosPorFila*CuadraditosPorFila; DistintasMutaciones = Math.floor(MaxCuadro/CuadraditosPorFila); Resto = MaxCuadro%CuadraditosPorFila; on (release) { // Los dibujos serán como el de encima de este botón // y mutarán: Dibujo = 0; // Repetir para el dibujo 1, 2, etc: do { Dibujo++; // El dibujo a copiar no necesita ser modificado: if (Dibujo != _parent.ID) { Cuadradito = 0; // Repetir hasta que todo cuadradito se haya copiado, // por ahora no hay mutación: do { Cuadradito++; ColoraCopiar = new Color("_parent.Cuadradito"+Cuadradito); ColoraSustituirse = new Color("_level0.Dibujo"+Dibujo+".Cuadradito"+Cuadradito); ColoraSustituirse.setRGB(ColoraCopiar.getRGB()); } while (Cuadradito<_level0.MaxCuadradito); // De cada dibujo copia, variar cuadraditos al azar, // de 1 hasta CuadraditosPorFila, // aumentando por dibujo hacia derecha y abajo: // Repetir hasta que se haya variado esa cantidad... // de cuadraditos: CuadraditosModificados = 0; if (Dibujo <= _level0.Resto*(_level0.DistintasMutaciones+1)) { ModificacionesRequeridas = Math.floor((Dibujo-1)/(_level0.DistintasMutaciones+1))+1; } else { ModificacionesRequeridas = _level0.Resto+1+Math.floor((Dibujo-_level0.Resto(_level0.DistintasMutaciones+1)-1)/_level0.DistintasMutaciones); } trace(Dibujo+": "+ModificacionesRequeridas); // Cosas que no vienen al caso. } } while (Dibujo<_level0.MaxCuadro); }
Resultado: (Nro de casillero, número asignado (que puede entenderse como color)): 2: 1 3: 1 4: 1 5: 1 6: 1 7: 1 8: 3 9: 3 10: 3 11: 3 12: 3 13: 4 14: 4 15: 4 16: 4 17: 4 18: 4 19: 5 20: 5 21: 5 22: 5 23: 5 24: 5 25: 6 Necesito que sea: Del 1 al 7: Son de 1. De 8 a 13: De 2. De 14 a 19: De 3. De 20 a 25: De 4. 11111 11222 22233 33334 44444
|
|
|
144
|
Programación / Programación General / Explicación de estas líneas (Flash) y simplificar el código.
|
en: 9 Junio 2024, 04:02 am
|
Quiero llamar a una función variable de la raíz (level0) desde una película. Si fuese una función fija sería: _level0.NombreDeLaFuncion(); Llamar a una función variable de la raíz, desde la raíz, creo que sería: FuncionALlamar = "Funcion1"; eval(FuncionALlamar)(); Si fuese FuncionALlamar = "_level0.Funcion1"; quizá funcionaría desde una película, se me acaba de ocurrir, pero he estado probando cosas y nada funciona. ¿Cómo sería? "_level0."+eval(_level0.FuncionALlamar)(); o eval("_level0."+_level0.FuncionALlamar)(); No recuerdo qué cosas probé, la solución que puse funcionó (no me gustaba porque me parecía inconveniente extender innecesariamente el valor de la variable), pero estoy liado en cuanto a qué hacen esas líneas. eval usa texto y variables para indicar el nombre de una variable y si existe devuelve su valor, pero si luego hay un () entonces ese nombre es de una función a la cual llama. Hasta ahí entiendo ¿está bien, no? Pero con lo del _level0. me lié. --------------------------------------------------------------------------------------------------------- Otra pregunta. Tengo por ahí: PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"]; Y uso esta función luego: function ModificarP2() { if (P2Valor<6) { P2Valor++; P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; } else { Continuar = "No"; } }
La idea es que P2 cambie a "!=", luego a "<=", y así sucesivamente pero no funciona. Es que esto: P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; lo hice basado en algo que me dijeron pero no entiendo qué hace. Obtiene la parte [a definir] del array llamado PosiblesSignos ¿no? Ahora creo que alcanza con decir: P2 = PosiblesSignos[P2Valor]; Sí, ahora me funcionó. ¿Pero qué es esto: P2 = PosiblesSignos[P2Valor(PosiblesSignos.length)]; ? Debo haber copiado mal  --------------------------------------------------------------------------------------------------------- Finalmente: ¿Es posible simplificar este código, cómo? // Este programa genera una comparación simple y su evaluación, pero: // Debe haber alguna parte cuyo contenido no está definido. // Ejemplo: 1 < ... : true // Luego intenta asignar el contenido faltante, // pero por ahora sólo si falta sólo 1. // Las siguientes funciones se usan en Resolvedor1, etc: function Comparacion() { if (P2 == "==") { Resultado = P1 == P3; } else if (P2 == "!=") { Resultado = P1 != P3; } else if (P2 == "<=") { Resultado = P1 <= P3; } else if (P2 == ">=") { Resultado = P1 >= P3; } else if (P2 == "<") { Resultado = P1 < P3; } else { Resultado = P1 > P3; } return Resultado+"" == P4; } function ModificarP1() { if (P1<10) { P1++; } else { Continuar = "No"; } } function ModificarP2() { if (P2Valor<6) { P2Valor++; P2 = PosiblesSignos[P2Valor]; } else { Continuar = "No"; } } function ModificarP3() { if (P3<10) { P3++; } else { Continuar = "No"; } } function ModificarP4() { if (P4 == "true") { P4 = "false"; } else { Continuar = "No"; } } // Se repite en F2, cuando hay 1 contenido indefinido y es el 1: function Resolvedor1 () { trace("Se probará el Candidato "+eval("P"+Indefinido)); if (Comparacion()) { trace ("Solución hallada, ver respuesta."); Mensaje = Mensaje+"\n"+P1+" "+P2+" "+P3+": "+P4; gotoAndStop (3); } else if (Continuar == "Sí") { // Se modificará el candidato: eval(ModificadoraUsar)(); } else { trace ("No se pudo hallar una solución."); gotoAndStop (3); } } PosiblesTiposDeContenido = ["Normal", "Indefinido"]; PosiblesSignos = ["==", "!=", "<=", ">=", "<", ">"]; // Generar las 4 partes hasta que se cumpla la condición: do { Indefinidos = 0; // Parte 1 (cosa 1 a comparar): TipoDelParte1 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte1 == "Normal") { Parte1 = random(10); } else { Parte1 = "..."; Indefinidos++; Indefinido = 1; // set("Indefinido"+Indefinidos, 1); } // Parte 2 (símbolo comparador): TipoDelParte2 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte2 == "Normal") { Parte2 = PosiblesSignos[random(6)]; } else { Parte2 = "..."; Indefinidos++; Indefinido = 2; // set("Indefinido"+Indefinidos, 2); } // Parte 3 (cosa 2 a comparar): TipoDelParte3 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte3 == "Normal") { Parte3 = random(10); } else { Parte3 = "..."; Indefinidos++; Indefinido = 3; // set("Indefinido"+Indefinidos, 3); } // Parte 4 (evaluación): TipoDelParte4 = PosiblesTiposDeContenido[random(PosiblesTiposDeContenido.length)]; if (TipoDelParte4 == "Normal") { // Definir esta parte según las anteriores: // ¿Fueron definidas? if (Parte1 != "..." && Parte2 != "..." && Parte3 != "...") { // Sí, ver qué definición corresponde: if (Parte2 == "==") { Parte4 = Parte1 == Parte3; } else if (Parte2 == "!=") { Parte4 = Parte1 != Parte3; } else if (Parte2 == "<=") { Parte4 = Parte1 <= Parte3; } else if (Parte2 == ">=") { Parte4 = Parte1 >= Parte3; } else if (Parte2 == "<") { Parte4 = Parte1 < Parte3; } else { Parte4 = Parte1 > Parte3; } } else { // No toda parte fue definida, // definir esta al azar: Parte4 = random(2); if (Parte4 == 0) { Parte4 = "true"; } else { Parte4 = "false"; } } } else { Parte4 = "..."; Indefinidos++; Indefinido = 4; // set("Indefinido"+Indefinidos, 4); } } while (Indefinidos == 0); Mensaje = Parte1+" "+Parte2+" "+Parte3+": "+Parte4; // Marca si algún canditato puede modificarse: Continuar = "Sí"; // Decidir qué resolvedor usar y preparar variables: if (Indefinidos == 1) { P1 = Parte1; P2 = Parte2; P3 = Parte3; P4 = Parte4; // Asignar un valor al contenido indefinido: if (Indefinido == 1) { P1 = 0; } else if (Indefinido == 2) { P2Valor = 0; P2 = "=="; } else if (Indefinido == 3) { P3 = 0; } else { P4 = "true"; } ResolvedoraUsar = "_level0.Resolvedor"+Indefinidos; ModificadoraUsar = "ModificarP"+Indefinido; } else { Mensaje = Mensaje+"\nAún no hay resolvedor para esta duda."; stop(); }
La idea es solucionar problemas así cada vez más complejos. Esto es sólo el comienzo...
|
|
|
145
|
Programación / Programación General / Contar cuántos cuadraditos pintados aislados hay en un dibujo.
|
en: 2 Junio 2024, 20:05 pm
|
Por ejemplo aquí se considera que no hay:  En este contexto lo blanco no se considera pintado, es fondo. Todos los cuadraditos pintados tienen al menos 1 pintado al lado (diagonal también cuenta). Estoy haciendo un generador de dibujos así y quiero que no muestre (o que no genere, sería lo ideal) los que tengan cierta cantidad de cuadraditos pintados aislados. La cantidad depende del tamaño del dibujo, no importa aquí cual es. El dibujo se va modificando de a 1 cuadradito, se pinta uno, o se despinta uno (o más) y se pinta otro. Así, debo hacer algo como: - Cuando se pinte uno nuevo, mirar si al lado hay otro. Si no hay, incrementar el contador de aislados. Si hay, ver si ese o esos estaban aislados, en cuyo caso disminuir el contador cuanto corresponda (según cuantos eran los aislados). - Cuando se despinte uno, mirar si hay cuadraditos pintados al lado. Si no hay, disminuir el contador de aislados. Si hay, mirar al lado de cada uno y aumentar el contador de aislados por cada uno que haya quedado aislado. Mi pregunta es: ¿Hay un modo más fácil? ¿es posible que lo haga GPT o algo así? Es que es mucho código... Por ahora hice esto y luego vi que no sirven else ifs, sólo ifs: // Para juzgar: // ¿El dibujo tiene menos de Largo/2 cuadraditos aislados? // Se actualizará el contador de pintados aislados: // De cada pintado al lado del recién pintado, // se verá si estaba aislado, // en cuyo caso disminuirá el contador. // Si no hay pintados al lado del nuevo, aumentará. CuadraditoAislado = "Sí"; // ¿El modificado es el inferior derecho? if (Puntero == MaxPosiciondePuntero) { // Sí, ver el -1 (izquierdo), -L (up) y -L-1 (iu): // xSS // xS* if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > MinCuadraditoInferior) { // Inferior no en una esquina, // contar el +1 (derecho), -1, -L+1 (du), -L y -L-1: // SSS // S*S if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero == MinCuadraditoInferior) { // Inferior izquierdo, // contar el +1, -L+1 y -L: // SSx // *Sx if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > CuadraditosPorFila) { // No es superior. if (Puntero%CuadraditosPorFila == 0) { // Central derecho, // contar el +L, +L-1, -1, -L y -L-1: // xSS // xS* // xSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero%CuadraditosPorFila != 1) { // Central, contar todos los contiguos: // SSS // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } } else { // Central izquierdo, // contar el +L+1, +L, +1, -L+1 y -L: // SSx // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } } } else if (Puntero == CuadraditosPorFila) { // Superior derecho, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } } else if (Puntero > 1) { // Superior cemtral, // contar el +L+1, +L, +L-1, +1 y -1: // S*S // SSS if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila-1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } else { // Superior izquierdo, // contar el +L+1, +L y +1: // *Sx // SSx if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila+1)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero+CuadraditosPorFila)) == 1) { CuadraditoAislado = "No"; } else if (eval("ColordeCuadradito"+(Puntero-1)) == 1) { CuadraditoAislado = "No"; } } if (CuadraditoAislado == "Sí") { CuadraditosAislados++; }
Es decir, ahí sólo estoy viendo si el cuadradito nuevo está aislado ¡me falta ver si sus contiguos lo estaban! (o si lo están sin contar al nuevo) y me falta el caso en que se despinta un cuadradito. ¿Tal vez se podrían usar functions para evitar repetir código? No sé bien cómo. Además, siendo tanto, puede que haya cometido algún error :/
|
|
|
146
|
Foros Generales / Foro Libre / ¿Qué pasó hoy 2024-05-28 a las 6:45 en el cielo de Uruguay, Montevideo?
|
en: 28 Mayo 2024, 12:07 pm
|
Algo cerca del cerro, hubo una fila de varias luces similares a las de estrellas, a considerable distancia entre sí. Entre todas ocuparían el largo del cielo que alguien puede ver, más o menos. Hubo también unas pequeñas luces instantáneas y a veces vi algunas que iban a otra dirección. En eso vi un avión hacer un movimiento distinto al que suelo ver hacer, pero a esta hora no suelo verlos. Hizo una especie de curva. Las luces iban a su misma velocidad más o menos.
Si alguien puede averiguar algo, agradezco.
Ah, cierto, no tenía con qué filmarlos ni tomarles fotos, sorry.
|
|
|
147
|
Programación / Programación General / El OR y AND a nivel de bits ¿sólo conviene usarlo para agilizar procesos?
|
en: 20 Mayo 2024, 12:22 pm
|
explícame cómo funciona el desplazamiento | en programación GPT: En programación, el operador de desplazamiento `|` se conoce como "OR a nivel de bits" o "OR bit a bit". Este operador se utiliza principalmente en lenguajes de programación que admiten manipulación de bits, como C, C++, Java, entre otros.
El operador `|` realiza una operación lógica OR (o inclusiva) entre los bits de dos operandos. A nivel de bits, el OR devuelve un 1 si al menos uno de los bits correspondientes en los operandos es 1. Si ambos bits son 0, el resultado será 0.
Aquí hay un ejemplo para ilustrar cómo funciona el operador de desplazamiento `|`:
Supongamos que tenemos dos números en representación binaria:
``` A: 11001010 B: 10110111 ```
Si aplicamos el operador `|` entre A y B, el resultado sería:
``` A | B: 11111111 ```
Cada bit en la posición correspondiente se compara entre A y B. Si al menos uno de los bits es 1, el resultado tendrá un 1 en esa posición. En este caso, todos los bits son 1 porque hay al menos un 1 en cada posición.
Es importante destacar que el operador `|` se aplica a nivel de bits, lo que significa que opera individualmente en cada bit de los operandos. Esto puede ser útil cuando se trabaja con máscaras de bits, banderas o manipulación de bits específica.
Espero que esta explicación te haya ayudado a comprender cómo funciona el operador de desplazamiento `|` en programación. Si tienes alguna otra pregunta, ¡no dudes en preguntar! y el and? ¡Claro! El operador de desplazamiento `&` se conoce como "AND a nivel de bits" o "AND bit a bit" en programación. Este operador se utiliza para realizar una operación lógica AND entre los bits correspondientes de dos operandos.
El operador `&` compara los bits en cada posición de los operandos y devuelve un 1 si y solo si ambos bits correspondientes son 1. Si alguno de los bits es 0, el resultado será 0.
Aquí hay un ejemplo para ilustrar cómo funciona el operador de desplazamiento `&`:
Supongamos que tenemos dos números en representación binaria:
``` A: 11001010 B: 10110111 ```
Si aplicamos el operador `&` entre A y B, el resultado sería:
``` A & B: 10000010 ```
Cada bit en la posición correspondiente se compara entre A y B. Solo si ambos bits son 1, el resultado tendrá un 1 en esa posición. En este caso, solo el séptimo y el segundo bit son 1 en ambos operandos, por lo que el resultado tiene un 1 solo en esas posiciones.
Al igual que con el operador `|`, el operador `&` se aplica a nivel de bits y es útil para realizar operaciones de máscaras de bits, filtrado de bits o verificación de ciertas propiedades de los bits.
Espero que esta explicación te haya ayudado a comprender cómo funciona el operador de desplazamiento `&` en programación. Si tienes más preguntas, ¡no dudes en hacerlas! para qué sirven esos desplazamientos, por qué se le llama desplazamientos? Los operadores de desplazamiento, como `<<` (desplazamiento a la izquierda) y `>>` (desplazamiento a la derecha), son diferentes de los operadores `|` y `&` que mencionamos anteriormente. Permíteme explicarte cómo funcionan y por qué se les llama "desplazamientos".
Estos operadores de desplazamiento se utilizan para mover los bits de un número hacia la izquierda o hacia la derecha. El desplazamiento se realiza en función de la cantidad de posiciones especificadas.
1. Desplazamiento a la izquierda (`<<`): Este operador desplaza los bits de un número hacia la izquierda en la cantidad de posiciones especificadas. Cada desplazamiento hacia la izquierda duplica el valor del número. Por ejemplo:
``` 5 << 2 // Resultado: 20 ``` En este caso, el número 5 en binario es `101`. Al desplazarlo dos posiciones hacia la izquierda, obtenemos `10100`, que es el número 20 en binario.
2. Desplazamiento a la derecha (`>>`): Este operador desplaza los bits de un número hacia la derecha en la cantidad de posiciones especificadas. Cada desplazamiento hacia la derecha divide el valor del número. Hay dos tipos de desplazamiento a la derecha: desplazamiento a la derecha lógico y desplazamiento a la derecha aritmético.
- Desplazamiento a la derecha lógico (`>>>`): En este tipo de desplazamiento, los bits se desplazan hacia la derecha y se rellenan con ceros en la posición más significativa. Por ejemplo:
``` 20 >>> 2 // Resultado: 5 ``` En este caso, el número 20 en binario es `10100`. Al desplazarlo dos posiciones hacia la derecha, obtenemos `101`, que es el número 5 en binario.
- Desplazamiento a la derecha aritmético (`>>`): En este tipo de desplazamiento, los bits se desplazan hacia la derecha y se rellenan con el bit más significativo (el bit de signo) en la posición más significativa. Esto significa que si el número es positivo, se rellena con ceros, y si el número es negativo, se rellena con unos. Por ejemplo:
``` -20 >> 2 // Resultado: -5 ``` En este caso, el número -20 en binario es `11111111111111111111101100`. Al desplazarlo dos posiciones hacia la derecha, obtenemos `11111111111111111111111011`, que es el número -5 en binario.
Los operadores de desplazamiento son útiles en situaciones donde se necesita manipular bits individuales de un número, realizar cálculos rápidos de potencias de dos, implementar algoritmos de codificación o decodificación, y en otros casos específicos relacionados con la manipulación de bits.
Espero que esta explicación aclare el concepto de desplazamientos y cómo se utilizan en programación. Si tienes más preguntas, no dudes en hacerlas. dame un ejemplo de un operador or usado en un programa Aquí tienes un ejemplo sencillo de cómo se puede utilizar el operador OR (`|`) en un programa:
Supongamos que tienes un programa en C que maneja permisos de usuario representados como combinaciones de banderas o "flags". Cada flag indica un permiso específico, y puedes combinar múltiples flags utilizando el operador OR para obtener un conjunto de permisos completo.
```c #include <stdio.h>
// Definición de flags de permisos #define PERM_READ 1 // Permiso de lectura: 0001 en binario #define PERM_WRITE 2 // Permiso de escritura: 0010 en binario #define PERM_EXEC 4 // Permiso de ejecución: 0100 en binario
int main() { int permisosUsuario = PERM_READ | PERM_WRITE; // Combinación de permisos de lectura y escritura
// Verificación de permisos if (permisosUsuario & PERM_READ) { printf("El usuario tiene permiso de lectura.\n"); } if (permisosUsuario & PERM_WRITE) { printf("El usuario tiene permiso de escritura.\n"); } if (permisosUsuario & PERM_EXEC) { printf("El usuario tiene permiso de ejecución.\n"); } else { printf("El usuario no tiene permiso de ejecución.\n"); }
return 0; } ```
En este ejemplo, definimos tres flags de permisos (`PERM_READ`, `PERM_WRITE` y `PERM_EXEC`) que se representan mediante valores binarios distintos. Luego, utilizamos el operador OR (`|`) para combinar los flags de permisos de lectura y escritura en la variable `permisosUsuario`.
Después, utilizamos el operador AND (`&`) en una serie de condiciones para verificar los permisos del usuario. Si el resultado de la operación AND entre los permisos del usuario y un flag específico es distinto de cero, significa que el usuario tiene ese permiso y se muestra un mensaje correspondiente.
En este caso, el programa imprimirá los mensajes "El usuario tiene permiso de lectura." y "El usuario tiene permiso de escritura.", ya que esos flags están presentes en la combinación de permisos del usuario. Sin embargo, no imprimirá el mensaje "El usuario tiene permiso de ejecución." porque ese flag no está presente en los permisos del usuario.
Este es solo un ejemplo básico para ilustrar el uso del operador OR en un programa. En aplicaciones reales, la combinación de flags y el uso de operadores OR pueden ser mucho más complejos y variados, dependiendo de los requisitos específicos del programa. dame otro ejemplo, pero relacionado con videojuegos Claro, aquí tienes un ejemplo relacionado con videojuegos. Supongamos que estás desarrollando un videojuego de plataformas y tienes un personaje que puede tener diferentes habilidades. Puedes utilizar el operador OR (`|`) para combinar las habilidades del personaje y determinar qué acciones puede realizar.
```python # Definición de habilidades del personaje HABILIDAD_SALTO = 1 # Salto: 0001 en binario HABILIDAD_CORRER = 2 # Correr: 0010 en binario HABILIDAD_ATACAR = 4 # Atacar: 0100 en binario HABILIDAD_PLANEAR = 8 # Planear: 1000 en binario
# Habilidades del personaje habilidades_personaje = HABILIDAD_SALTO | HABILIDAD_CORRER | HABILIDAD_ATACAR
# Verificación de habilidades if habilidades_personaje & HABILIDAD_SALTO: print("El personaje puede saltar.")
if habilidades_personaje & HABILIDAD_CORRER: print("El personaje puede correr.")
if habilidades_personaje & HABILIDAD_ATACAR: print("El personaje puede atacar.")
if habilidades_personaje & HABILIDAD_PLANEAR: print("El personaje puede planear.") else: print("El personaje no puede planear.") ```
En este ejemplo, el personaje tiene cuatro habilidades diferentes: salto, correr, atacar y planear. Cada habilidad se representa mediante un valor binario diferente. Utilizamos el operador OR (`|`) para combinar las habilidades del personaje en la variable `habilidades_personaje`.
Luego, utilizamos el operador AND (`&`) en una serie de condiciones para verificar las habilidades del personaje. Si el resultado de la operación AND entre las habilidades del personaje y una habilidad específica es distinto de cero, significa que el personaje tiene esa habilidad y se muestra un mensaje correspondiente.
En este caso, el programa imprimirá los mensajes "El personaje puede saltar.", "El personaje puede correr." y "El personaje puede atacar.", ya que esas habilidades están presentes en las habilidades del personaje. Sin embargo, no imprimirá el mensaje "El personaje puede planear." porque esa habilidad no está presente en las habilidades del personaje.
Este es solo un ejemplo básico para ilustrar el uso del operador OR en un contexto de videojuegos. En un juego real, las habilidades y su combinación podrían ser mucho más complejas y permitir una amplia variedad de acciones para el personaje. No entiendo ¿no es más fácil algo como: HABILIDAD_SALTO = true HABILIDAD_CORRER = true HABILIDAD_ATACAR = true HABILIDAD_PLANEAR = false Si HABILIDAD_SALTO == true puede saltar etc? O en vez de true/false, "Sí"/"No", 1/0, etc. Yo quiero aprender eso del or y and si es algo que no se puede hacer de otro modo o resulta mucho más fácil hacerlo así. Si es por agilizar procesos, entiendo que es importante pero por ahora paso. A un número le puedo sumar otro, eso es útil y difícilmente insustituible. El or viene a decir que a 2 binarios los puedo transformar en 1, uno tiene más probabilidad de tener 1s ¿pero eso para qué sirve? Capaz que los ejemplos que me dió son incorrectos, imagino que si se tienen 2 cosas a comparar, con muchas variables, en vez de hacer: SumaDe1 = Objeto1TieneCuello+Objeto1TieneManos+Objeto1TienePiernas SumaDe2 = Objeto2TieneCuello+Objeto2TieneManos+Objeto2TienePiernas Si SumaDe1 == SumaDe2 los objetos son iguales ... usando or se podría hacer la comparación sin sumar ni usar 3 ifs ¿puede ser?
|
|
|
148
|
Programación / Programación General / Generador de dibujos usando programación genética.
|
en: 20 Mayo 2024, 11:27 am
|
https://drive.google.com/file/d/1BSfitRU9lBvKPfmlnQ9Vw0W5aNcHVQyE/view?usp=sharingLo intenté pero no le veo mucho uso práctico por ahora ¿tal vez no es programación genética lo que hice? No le puse interfase así que para usarlo mejor (modificarlo a voluntad) se requiere Flash (el editor de archivos fla). Actualmente genera 5*5 dibujos (hojitas) en la pantalla, cada uno de 10*10 cuadraditos, pero eso se puede cambiar, el código está en el frame 1: DibujosPorFila = 5; CuadraditosPorFila = 10; Si cambian eso y ponen Probar película, ya está. Los colores actuales son blanco, negro, azul y la separación entre los dibujos es verde, todo fácimente modificable también, pero ese código está en la película Cuadros: PosiblesColores = [0xFFFFFF, 0x0000FF, 0x000000]; Se pueden modificar o agregar. Si quisieran muchísimos colores o todos entonces tendrían que hacer varios cambios, pero es que no lo hice con la intención de que pudiera haber tantos porque es más bien para generar sprites y suelen tener pocos. Cuando hacen clic a un dibujo, los demás dibujos quedan como él excepto por un cuadradito, que es el mutado. Puede haber algún error en el proceso (el código está en el botón que hay en la película Botón) pero el resultado según veo es correcto (en algún caso me pareció que en algún dibujo la imagen no mutó), sólo que, como di a entender, no me parece tan útil como esperaba, es decir, la idea es que uno elija el dibujo que más le guste, se generan parecidos, reelige, y así, pero como los iniciales son tan sin sentido y sólo se va modificando de 1 cuadradito, el resultado es... dibujos sin sentido, demasiado similares como para ver rápido las diferencias, y parece que da igual cual se elija entonces, o uno quiere que se pinte cierto punto pero en tal caso conviene dibujar a mano. ¿Es posible mejorarlo? ¿cómo? Algunas ideas que no he aplicado, y difícil que lo haga porque no creo que cambie mucho: - Que en vez de variar sólo 1 cuadradito, varíe por ejemplo (CuadraditosPorFila) cuadraditos, es decir, si CuadraditosPorFila es 10 entonces los dibujos tienen 100 cuadraditos, de los cuales variarán 10. Es que no le veo mucho sentido, si el dibujo elegido es el que más gusta ¿entonces por qué variarlo tanto? Ahora se me ocurre que en un dibujo se varíe 1, en otro 2, etc, eso podría ser... - Que los dibujos tengan todos los colores especificados. Que si dices que los posibles sean 9, en los dibujos siempre haya 9. Cuando se dice los colores posibles en realidad se está diciendo los que ha de tener el sprite, ni más ni menos, así que tiene sentido para mí. - Evitar que lo producido en uno se produzca en otro. También, aunque si tienen muchos cuadraditos y colores es poco probable que se produzcan iguales. - Evitar que se produzcan dibujos antes producidos. Sí pero bastante difícil de aplicar, al menos para mí, no le veo sentido a intentarlo por ahora. - Posibilidad de que los dibujos no sean de X*X cuadraditos, sino de X*Y. Es decir que puedan ser rectangulares en vez de siempre cuadrados. Puede ser útil si se quiere dibujos rectangulares porque sino es probable que lo que sería fondo tuviese cuadraditos que lo harían parecer otra cosa, ruido, pero no me convence del todo... Los dibujos rectangulares se pueden hacer en hojas cuadradas si son más grandes... - Hacer que una imagen tomada de otro lado aparezca en cada dibujo. En realidad esto sería otra cosa, un modificador random de imágenes, luego programación genética. Para esto, en vez de pintarse X*X cuadraditos (lo cual taparía la imagen), se insertaría 1 en el dibujo 1, 2 en el 2, etc, de colores al azar según los especificados, y cuando se cliqueé un dibujo eso se transmitiría a los demás, y mutarían. Un modo más fácil es que todos los cuadraditos estén en modo invisible, excepto los que fueron "insertados". No sé si en algo hecho en Flash se puede pegar una imagen o especificar que se cargue una, un archivo, pero se puede poner en el editor y listo. En fin, puede que intente algo de eso pero lo que haré es que los dibujos pue, ah, no, es un sin sentido >__< había pensado esto: Tal vez debería intentar un generador así: Dibujo1 Dibujo2 Dibujo3 Dibujo4 Dibujo5 Dibujo6 Dibujo7 Dibujo8 Dibujo9 Donde al cliquear uno se llevaría hacia el centro y en los demás se pintaría un cuadradito hacia esa dirección, por ejemplo en el Dibujo4 se pintaría el cuadradito izquierdo. Si no se gusta el color del que se quiere, se podría presionar el del medio y sería como repetir el proceso. Eso sólo tiene sentido si los dibujos tienen 3*3 cuadraditos, o si fuesen de 5*5 y hubiera 25 dibujos, en el dibujo 1 se modificaría el cuadradito 1, en el 2 el 2, etc, m... en definitiva sirve sólo si la cantidad de dibujos es igual o mayor a la de cuadraditos por fila^2, ah, entonces sí puede servir. m... Nah, ya no le veo utilidad a la idea tampoco, sólo sirve para saber fácil qué cuadradito se modificó, pero eso es poco útil a menos que se busque que se modifique en cierto lugar pero en tal caso conviene modificarlo manualmente. En fin ¿ideas? Por ahora intentaré el modificador de imágenes.
|
|
|
149
|
Foros Generales / Foro Libre / ¿Existe un servicio que envíe paquetes sin preguntar a quién ni a donde exacto?
|
en: 19 Mayo 2024, 09:13 am
|
Supongamos que un anónimo de Internet (en teoría) quiere enviar algo a otro anónimo, de otro país, sin que se pierda el anonimato. No sé cómo funciona el correo físico pero supongo que probablemente te piden tu nombre, y sobretodo la dirección a donde enviar el paquete. Pero lo que digo podría ser algo así: - A la persona a quien se lo vas a enviar, le dices un password. - Vas a la oficina de correos y dices que se lleve a la oficina de X ciudad donde está la persona, y se lo den a la que diga el password. - La persona va, dice el password, y le dan el paquete. ¿Eso existe o no? GPT: No conozco ningún servicio de mensajería o paquetería que funcione exactamente como describes, donde no se solicite información sobre el remitente ni el destinatario. Los servicios de envío de paquetes generalmente requieren datos como los nombres, direcciones y, en ocasiones, números de teléfono o correos electrónicos para garantizar una entrega exitosa.
Si deseas enviar un paquete de forma anónima, es posible que tengas opciones alternativas. Una opción podría ser utilizar un servicio de reenvío de paquetes o una empresa de casilleros postales. Estas empresas proporcionan direcciones de envío alternativas, lo que te permite utilizar una dirección diferente a la tuya propia. Sin embargo, aún así, en algún momento deberás proporcionar una dirección válida para recibir el paquete en el servicio de reenvío o casillero postal.
Es importante tener en cuenta que, independientemente de cómo se envíe el paquete, es posible que las aduanas y las autoridades de los países involucrados requieran información sobre el contenido del paquete y puedan llevar a cabo inspecciones de seguridad. Además, las políticas y regulaciones de envío pueden variar según los países y los servicios utilizados, por lo que es recomendable investigar y comprender las normas y restricciones aplicables antes de realizar cualquier envío.
En cualquier caso, siempre es aconsejable actuar dentro de los límites legales y respetar las políticas de envío de los servicios utilizados para evitar problemas o consecuencias indeseadas. No entendí bien si es posible que no se den nombres. El paquete podría ser revisado por los del correo, en eso no hay drama, supongo que lo podrían querer robar pero eso incluso si en teoría no deben chequearlo, no sé cómo es el sistema, supongo que de algún modo lo chequean, por si es una bomba o algo así. ¿Le ven algún problema? ¿gente que le pueda dar un mal uso, cómo? ¿podría ser un buen negocio? Yo no creo tener la habilidad ni el capital como para iniciarlo, el que quiera y pueda aquí lo tiene. - Puede haber gente que vaya y diga passwords random a ver si acierta. Lo veo difícil, ambos casos, pero se podría cobrar por cada password mal que se diga. - Gente que envíe cosas al cohete, para molestar. También difícil, más si se cobra por enviarlo, nadie lo haría así. Además la oficina podría advertir que, pasado 1 mes sin que haya sido reclamado, el paquete quedará a su disposición. - Diferente gente que envíe cosas distintas al mismo lugar con el mismo password. Uf, aunque es poco probable, esto sería una complicación, no se le puede decir "ese password ya existe, use otro", porque entonces podría decirle a su amigo que vaya a la oficina a decirlo y recibir un paquete que él no envió. Una posible solución es exigir que los passwords cumplan ciertas condiciones según los que hayan sido asignados. Por ejemplo si ya existe el password 0123456789, cuando se vaya a entregar algo se diría "¿De cuantos caracteres quiere que sea su password?", bah, nah, el password lo podría asignar la misma oficina, simplemente cambia el orden del proceso: - Vas a la oficina, pides hacer el envío, te dan un password. - Se lo dices a quien quieres que reciba el paquete. - Va, dice el password y lo recibe. ¿Qué más?
|
|
|
150
|
Media / Diseño Gráfico / Busco técnicas para dibujar muro: ¿Achicar una parte?
|
en: 18 Mayo 2024, 07:40 am
|
De este muro:  me falta la parte de arriba y el costado. El costado es un trabajo chino, tengo que borrar algunas líneas y otras no, y cada vez las distancias son más cortas, cada vez se ve menos:  Flash da la posibilidad de, digamos, mover una parte para un lado y otra para otro, como si fuese convertir un rectángulo en un paralelogramo; usando eso me quedó así:  Pero a eso le falta digamos el efecto de irse achicando hacia el horizonte (el mío está exagerado, pero me gustó así). ¿Qué puedo hacer? Quisiera que se achique de un lado pero no de otro, o sea seleccionar una imagen, digamos un rectángulo, y que se achique sólo la parte de arriba, convirtiéndose entonces en un triángulo rectángulo. ¿Existe un editor online o poco pesado que haga eso? Lo explico con una imagen por las dudas:  Eso se puede hacer en Flash con "shapes", o sea líneas y rellenos, pero si la imagen tiene muchas cosas de esas es mucho más complicado, pero se me acaba de ocurrir usar mi muro como relleno (color) de una shape, voy a probar eso en unos días, pero el relleno no se achica como muestra la animación, lo acomodé manualmente (y la 2nda no quedó bien); en el caso del muro quizá no se pueda...
|
|
|
|
|
|
|