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


Tema destacado: Entrar al Canal Oficial Telegram de elhacker.net


Páginas: [1] 2 3 4 5 6 7 8 9 10
 1 
 en: Hoy a las 05:41 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Decidí empezar con cuadros 100% de un color.

Estoy programando la velocidad con la que cambian y pensando otras opciones que no impliquen cambiar tanto los dibujos. Supongo que no hay.
Pero cliquear un cuadro hace que todos los demás queden igual y luego se les muta algo.

Más o menos lo tengo hecho, luego haré una consulta sobre optimizar el código.

Lo de las "líneas perfectas" ya está resuelto hace décadas: es el algoritmo de Bresenham. Reparte los cuadraditos de forma pareja entre filas y columnas usando solo sumas de enteros, y te ahorra todas esas reglas de 1/3 y 2/3.
Lo que leí sobre ese algoritmo no lo entendí, y en vez de buscar explicaciones que entienda intenté resolver el problema por mi cuenta. Igual fijate esto la línea amarilla bajando un poco:
https://en.wikipedia.org/wiki/Bresenham%27s_line_algorithm#Algorithm_for_integer_arithmetic
No sé si eso es una solución que da, pero no es como la mía.
Si quieres haz una versión en Python o algo y vemos si es igual.

Me anoto tus sugerencias, pero como comenté puede que tarde en llegar a intentar aplicarlas.

 2 
 en: Hoy a las 03:15 
Iniciado por @XSStringManolo - Último mensaje por @XSStringManolo
Kyanite
Segura. Ligera. Cómoda.


Hola a todos,

Os presento Kyanite, una distribución Linux mínima que he creado desde cero y que ya podéis llevar en el móvil con su app para Android. Es un Linux completo con terminal propia, listo para usar en un par de minutos.



¿Qué es Kyanite?

Una distro minimalista construida sobre componentes escritos en Rust en lugar del userland clásico en C (BusyBox). La idea es sencilla: reducir la superficie de ataque eliminando de la base los fallos de seguridad de memoria, y mantener la compatibilidad con el ecosistema de Debian.

  • Init propio (kyanite-init), escrito en Rust.
  • Shell: Brush, compatible con Bash, en Rust.
  • Utilidades básicas: uutils coreutils (ls, cat, cp, mv, rm...), en Rust.
  • Gestor de paquetes propio: kpkg, con interfaz estilo apk y modo compatible con apt (apt, apt-get y apt-cache funcionan).

¿Por qué otra distro?

  • Pequeña: unos 30 MB descomprimida y unos 8 MB comprimida. Una imagen de Debian ronda los 100 MB.
  • Con el catálogo de Debian: los paquetes que instalas con kpkg vienen de los repositorios oficiales de Debian y usan glibc. Así funcionan muchas cosas que dan problemas en distros con musl.
  • Segura por diseño: los índices de los repositorios se verifican con OpenPGP, las descargas se comprueban por tamaño y SHA256, la extracción no puede salirse del directorio raíz y nunca se instalan bits setuid/setgid.
  • Sin scripts de mantenedor: kpkg no ejecuta preinst/postinst/prerm/postrm. Cuando un paquete necesita configuración, Kyanite incluye un hook declarativo con un conjunto cerrado de acciones. Menos magia y menos riesgo.
  • Actualizaciones firmadas: las versiones de la base se publican con firma Ed25519 y checksum SHA256.

La app para Android

La APK te da Kyanite funcionando en el móvil, con terminal integrada y herramientas para gestionar el entorno, sin tocar nada del sistema.

Descarga directa: Kyanite.apk
Código y documentación de la app: github.com/StringManolo/KyaniteAndroid

Para instalarla tendrás que permitir la instalación desde orígenes desconocidos, como con cualquier APK que no venga de una tienda.

Primeros pasos

Una vez dentro, instalar software es así de simple:

Código:
kpkg update            # actualiza los índices
kpkg search <término>  # busca paquetes
kpkg add git curl      # instala paquetes con sus dependencias
kpkg del <paquete>     # elimina paquetes
kpkg upgrade           # actualiza la base de Kyanite y tus paquetes

Si vienes de Debian o Ubuntu, también te vale esto:

Código:
apt update && apt install curl

Estado del proyecto

Kyanite es estable para experimentar a diario, pero aún no está completa. Hoy es una base mínima; el objetivo es que crezca hasta ser una distribución completa, kernel incluido. Hay limitaciones conocidas (por ejemplo, algunos paquetes pueden necesitar configuración manual si todavía no tienen hook), y todas están documentadas en el README.

Qué os pido

  • Probadla y contadme qué falla y qué echáis de menos.
  • Si encontráis un bug, abrid un issue o escribid aquí mismo, en el hilo.
  • Si os gusta, una estrella en GitHub ayuda mucho a que más gente lo encuentre.

Proyecto (la distro): github.com/StringManolo/Kyanite
App para Android: github.com/StringManolo/KyaniteAndroid

Gracias por leer y por probarlo.

Un saludo,
StringManolo

 3 
 en: Ayer a las 08:51 
Iniciado por cotin - Último mensaje por Mr.Byte
me referia a un promt que me haga una descripcion de la imagen o me digan que podria usar
Puedes usar CharGpt, Gemini, etc
Pero si buscas algo GRATUITO, SIN REGISTRO Y SIN CENSURA (solo por cuestiones legales),  puedes usar
https://perchance.org/nexora-similar

Autorecreate: Crea imagenes similares
Analyze Image: Crea un prompt
Generate Twin:Crea imagenes similares, despues de Analize image (y modficar el prompt si lo deseas.

 4 
 en: 20 Noviembre 2026, 17:07 pm 
Iniciado por Tachikomaia - Último mensaje por Danielㅤ
Hola, yo creo que la mejor forma de detener un bucle o ciclos recursivos, es usar una condición If, que si se cumple entonces continua nuevamente, también se puede usar break o return, pero no son recomendables porque es detener a la fuerza un proceso o salir a la fuerza de un ciclo.

 5 
 en: 20 Noviembre 2026, 15:46 pm 
Iniciado por Tachikomaia - Último mensaje por pingperdido
Para evitar forzar los contadores de los bucles externos, lo más limpio es meter toda la búsqueda dentro de una función y hacer un return en cuanto encuentres la solución. Si prefieres no usar funciones, una variable booleana tipo encontrado = true con un break en cada nivel te dejará el flujo mucho más claro.

 6 
 en: 20 Noviembre 2026, 12:03 pm 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Estoy ampliándolo, ya acaba cuando halla una solución, pero la forma en que acaba es algo confusa, a ver si la pueden mejorar.

Código
  1. Datos = 3;
  2. Dato1 = 1;
  3. BuenResultado1 = 2;
  4. Dato2 = 2;
  5. BuenResultado2 = 3;
  6. Dato3 = 3;
  7. BuenResultado3 = 4;
  8. TiposDePaso = 2;
  9. Pasos = 0;
  10. while (Pasos < 2) {
  11. // Se prueba un método con un paso más, para probar métodos que sólo tienen 1 paso, luego métodos que tienen 2, etc:
  12. Pasos++;
  13. trace("Aumentó la cantidad de pasos, es "+Pasos);
  14. // Crea nuevo paso:
  15. this["PasoaProbar"+Pasos] = 0;
  16. trace("Creado PasoaProbar"+Pasos+", su tipo es "+this["PasoaProbar"+Pasos]);
  17. NroDePasoaVariar = Pasos+1;
  18. trace("Se definió NroDePasoaVariar");
  19. // Se indica que el paso a variar sea otro, para que varíe el último hasta que no se pueda, se reseteé, luego el penúltimo, y así, para lograr todas las variaciones posibles:
  20. while (NroDePasoaVariar > 1) {
  21. NroDePasoaVariar--;
  22. trace("Se redujo NroDePasoaVariar, ahora es "+NroDePasoaVariar);
  23. // Prepara el valor que usará el paso:
  24. this["ValoraProbar"+NroDePasoaVariar] = -2;
  25. trace("Se definió ValoraProbar"+NroDePasoaVariar);
  26. // Se modifica ese valor, para que por ejemplo se pruebe +1, +2, etc:
  27. while (this["ValoraProbar"+NroDePasoaVariar] < 1) {
  28. this["ValoraProbar"+NroDePasoaVariar] = this["ValoraProbar"+NroDePasoaVariar]+1;
  29. trace("Se varió ValoraProbar, ahora es "+this["ValoraProbar"+NroDePasoaVariar]);
  30. // Resumen:
  31. PasoaProbar_ = "PasoaProbar"+NroDePasoaVariar;
  32. // trace("El paso que se variará es "+PasoaProbar_);
  33. this[PasoaProbar_] = 0;
  34. trace("Se definió "+PasoaProbar_);
  35. // trace("Su valor es "+this[PasoaProbar_]);
  36. // Se modifica el paso indicado, para que por ejemplo haga Dato+Valor, Dato*Valor, etc:
  37. while (this[PasoaProbar_] < TiposDePaso) {
  38. this[PasoaProbar_] = this[PasoaProbar_]+1;
  39. trace("Se varió "+PasoaProbar_+", ahora su tipo es "+this[PasoaProbar_]);
  40. // trace(PasoaProbar1+" y "+PasoaProbar2);
  41. // Se verá si el método logra los resultados para cada dato:
  42. BuenResultadoHallado = true;
  43. NroDeDatoaProbar = 0;
  44. trace("Se definió NroDeDatoaProbar");
  45. // Se modifica qué dato o "Input" se chequea:
  46. while (NroDeDatoaProbar < Datos && BuenResultadoHallado == true) {
  47. NroDeDatoaProbar++;
  48. trace("Se varió NroDeDatoaProbar, ahora es "+NroDeDatoaProbar);
  49. trace("Su correspondiente buen resultado es "+eval("BuenResultado"+NroDeDatoaProbar));
  50. NroDePasoaEjecutar = 0;
  51. // Se modifica el paso a ejecutar, para ver si el método (fórmula) sirve para lograr el resultado deseado con ese dato de input:
  52. while (NroDePasoaEjecutar < Pasos) {
  53. NroDePasoaEjecutar++;
  54. trace("Se ejecutó el paso "+NroDePasoaEjecutar);
  55. this["TipoDePaso"+this["PasoaProbar"+NroDePasoaEjecutar]]();
  56. // Resultado = this["Resultado"+NroDePasoaEjecutar];
  57. trace("El resultado es "+this["Resultado"+NroDePasoaEjecutar]);
  58. }
  59. if (this["Resultado"+Pasos] != this["BuenResultado"+NroDeDatoaProbar]) {
  60. BuenResultadoHallado = false;
  61. trace("El resultado no es el deseado");
  62. } else {
  63. trace("El resultado es el deseado");
  64. if (NroDeDatoaProbar == 3) {
  65. trace("Solución hallada");
  66. trace("Paso1: "+this["PasoaProbar"+Pasos]);
  67. trace("Valor1: "+this["ValoraProbar"+Pasos]);
  68. // Para detener los loops:
  69. Pasos = 9;
  70. NroDePasoaVariar = 0;
  71. ValoraProbar0 = 9;
  72. TiposDePaso = 0;
  73. }
  74. }
  75. }
  76. }
  77. }
  78. if (BuenResultadoHallado == false) {
  79. this[PasoaProbar_] = 1;
  80. trace("El paso "+this[PasoaProbar_]+" ya no puede variar, se reseteó ");
  81. }
  82. }
  83. }
  84. function TipoDePaso1 () {
  85. trace("El paso ejecutado fue Dato+Valor");
  86. _root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]+_root["ValoraProbar"+NroDePasoaVariar];
  87. }
  88. function TipoDePaso2 () {
  89. trace("El paso ejecutado fue Dato*Valor");
  90. _root["Resultado"+Pasos] = _root["Dato"+NroDeDatoaProbar]*_root["ValoraProbar"+NroDePasoaVariar];
  91. }

 7 
 en: 19 Noviembre 2026, 13:41 pm 
Iniciado por El_Andaluz - Último mensaje por crazykenny
no se como todavia os meteis en redes sociales
y mucho menos creerse lo que los perdedores dementes que viven alli alucinan.

Bueno, D1k0v2, yo realmente no llegue a meterme del todo ni llegue a prestarles demasiada atención desde el principio (o desde que salieron), y, francamente actualmente tampoco hay ganas por mi parte viendo todo el odio/hate y polarización que hay .

Aunque, claro,, supongo que siempre hay excepciones y mi caso es un caso evidente.

Muchas gracias por vuestra atención, y, bueno, saludos.

 8 
 en: 19 Noviembre 2026, 12:59 pm 
Iniciado por Boxenknacker - Último mensaje por Boxenknacker
Nuevo: Acabamos de subir una nueva .ISO con los archivos de idioma para español e inglés.

Podéis cambiar fácilmente entre Español, Inglés y Alemán directamente desde la barra del escritorio.

¡Un saludo!

 9 
 en: 19 Noviembre 2026, 11:12 am 
Iniciado por Tachikomaia - Último mensaje por Tachikomaia
Últimamente tuve problemas en el barrio, eso me influyó en tardar en responderte, vi tu respuesta porque iba a consultar liado intentando entender las condiciones que deben cumplirse para el else if, ya que el else requiere más condiciones, decidí hacer el else if 1ero.

En la parte del else veo un par de cosas: dentro del while restas NroDeLineaMirandose pero nunca vuelves a hacer LineaMirandose = eval("LV1Code"+CodeBase)[NroDeLineaMirandose], así que siempre analizas la misma línea
Desde el último post hice algunas modificaciones, pero dejame ver... Sí, parece mal eso, y parece que ya lo tengo corregido pero me cuesta confirmarlo, o sea, poner traces adecuadamente, a ver si tú puedes, te muestro el código que tengo ahora:
Código
  1. // Para códigos de 2 cosas:
  2. CodesLV2 = 0;
  3. CodeBase = 0;
  4. // Repetir mientras haya alguna base sin usar:
  5. // Se van a generar códigos con 2 cosas:
  6. while (CodeBase < CodesLV1) {
  7. CodeBase++;
  8. TextoLineaPorLinea = eval("LV1Code"+CodeBase).join("\n");
  9. trace ("CodeBase: \n"+TextoLineaPorLinea+"\n");
  10. LineaDondeAgregar = -1;
  11. // Repetir mientras haya alguna línea posterior en Codebase:
  12. // Se cambiará la línea donde se agrega código en Codebase:
  13. while (LineaDondeAgregar < eval("LV1Code"+CodeBase).length) {
  14. LineaDondeAgregar++;
  15. trace("LineaDondeAgregar: "+LineaDondeAgregar+"\n");
  16. //
  17. // Para averiguar espacios iniciales requeridos:
  18. // Si hay alguna línea anterior entonces puede...
  19. // que se requieran espacios, sino esto no...
  20. // funcionaría bien y no tiene sentido porque...
  21. // el resultado siempre debería ser 0:
  22. EspaciosRequeridos = "";
  23. if (LineaDondeAgregar > 0) {
  24. // 1ero se averigua la cantidad de espacios...
  25. // iniciales de la línea anterior:
  26. // AÚN NO PUEDE SABERSE SI ESTO FUNCIONA
  27. LineaAnterior = eval("LV1Code"+CodeBase)[LineaDondeAgregar-1];
  28. CaracterEvaluandose = 0;
  29. do {
  30. if (LineaAnterior.charAt(CaracterEvaluandose) == " ") {
  31. EspaciosRequeridos = EspaciosRequeridos+" ";
  32. } else {
  33. break;
  34. }
  35. CaracterEvaluandose++;
  36. } while (CaracterEvaluandose < eval("LV1Code"+CodeBase)[LineaDondeAgregar].length);
  37. //
  38. // Luego se averigua si la línea es un if o...
  39. // algo así que requiera espacios,
  40. // en cuyo caso se le agregan:
  41. // Extrae el texto desde la posición...
  42. // EspaciosRequeridos hasta el final:
  43. LineaSinEspacios = LineaAnterior.substr(EspaciosRequeridos);
  44. trace("LineaSinEspacios: "+LineaSinEspacios+"\n");
  45. if (LineaSinEspacios == "if {" or LineaSinEspacios == "do {" or LineaSinEspacios == "while {") {
  46. EspaciosRequeridos = EspaciosRequeridos+"   ";
  47. }
  48. }
  49. Action = 0;
  50. // Repetir mientras haya alguna acción agregable
  51. // (se refiere a 1, 2, etc, no ifs, etc):
  52. // Se cambiará la acción que se agrega:
  53. while (Action <= eval("LV1Code"+CodeBase+"MaxAction")) {
  54. Action++;
  55. CodesLV2++;
  56. NombredeNewCode = "LV2Code"+CodesLV2;
  57. //
  58. // Para agregar código 1ero se copia el base:
  59. set (NombredeNewCode, eval("LV1Code"+CodeBase).slice());
  60. //
  61. // Insertar en la posición LineaDondeAgregar:
  62. // Parámetros: (índice, elementos_a_eliminar, nuevo_elemento)
  63. eval(NombredeNewCode).splice(LineaDondeAgregar, 0, EspaciosRequeridos+Action);
  64. trace (NombredeNewCode+":");
  65. TextoLineaPorLinea = eval(NombredeNewCode).join("\n");
  66. trace (TextoLineaPorLinea+"\n");
  67. }
  68. //
  69. // Para agregar if, do, while...
  70. AgregablesLinea1 = ["if {", "do {", "while {"];
  71. AgregablesLinea2 = ["}", "} while", "}"];
  72. NroDeCosaaAgregar = 0;
  73. // Repetir mientras no se haya agregado algo de eso:
  74. // Se cambiará qué se agrega:
  75. while (NroDeCosaaAgregar < 3) {
  76. CodesLV2++;
  77. NombredeNewCode = "LV2Code"+CodesLV2;
  78. // Se copia la base:
  79. set (NombredeNewCode, eval("LV1Code"+CodeBase).slice());
  80. // Insertar en la posición LineaDondeAgregar
  81. // Parámetros: (índice, elementos_a_eliminar, nuevo_elemento)
  82. eval(NombredeNewCode).splice(LineaDondeAgregar, 0, EspaciosRequeridos+AgregablesLinea1[NroDeCosaaAgregar]);
  83. eval(NombredeNewCode).splice(LineaDondeAgregar+1, 0, EspaciosRequeridos+AgregablesLinea2[NroDeCosaaAgregar]);
  84. trace (NombredeNewCode+":");
  85. TextoLineaPorLinea = eval(NombredeNewCode).join("\n");
  86. trace (TextoLineaPorLinea+"\n");
  87. NroDeCosaaAgregar++;
  88. }
  89. //
  90. // Para agregar else if sólo cuando desde la línea...
  91. // donde se quiere agregar, mirando hacia arriba:
  92. // No se detecta un do (o while) sin cerrar y...
  93. // además se detecta un if abierto en el cual no...
  94. // se detectó un else:
  95. // Desde la línea actual ir mirando hacia arriba:
  96. NroDeLineaMirandose = LineaDondeAgregar;
  97. PuedeHaberElseIf = undefined;
  98. DosCerrados = 0;
  99. OtrosCerrados = 0;
  100. ElseEnIfMirandose = undefined;
  101. // Mientras haya alguna línea arriba:
  102. trace("Se verá si es posible agregar else if");
  103. while (NroDeLineaMirandose > 0) {
  104. NroDeLineaMirandose--;
  105. LineaMirandose = eval("LV1Code"+CodeBase)[NroDeLineaMirandose];
  106. trace("Se quitarán espacios de la línea: "+LineaMirandose);
  107. // Para averiguar espacios iniciales que...
  108. // deben borrarse para saber qué tiene...
  109. // la línea sin ellos:
  110. EspaciosaQuitar = "";
  111. CaracterEvaluandose = 0;
  112. do {
  113. if (LineaMirandose.charAt(CaracterEvaluandose) == " ") {
  114. EspaciosaQuitar = EspaciosaQuitar+" ";
  115. } else {
  116. break;
  117. }
  118. CaracterEvaluandose++;
  119. } while (CaracterEvaluandose < eval("LV1Code"+CodeBase)[LineaMirandose].length);
  120. LineaSinEspacios = LineaMirandose.substr(EspaciosaQuitar);
  121. trace("Se eliminaron los espacios, la línea es: "+LineaSinEspacios+"\n");
  122. if (LineaSinEspacios == "} while") {
  123. DosCerrados++;
  124. } else if (LineaSinEspacios == "}") {
  125. OtrosCerrados++;
  126. } else if (LineaSinEspacios == "do {") {
  127. DosCerrados--;
  128. if (DosCerrados == -1) {
  129. PuedeHaberElseIf = false;
  130. break;
  131. }
  132. } else if (LineaSinEspacios == "while {") {
  133. OtrosCerrados--;
  134. if (OtrosCerrados == -1) {
  135. PuedeHaberElseIf = false;
  136. break;
  137. }
  138. } else if (LineaSinEspacios == "} else {") {
  139. ElseEnIfMirandose = true;
  140. } else if (LineaSinEspacios == "if {") {
  141. OtrosCerrados--;
  142. if (OtrosCerrados == -1) {
  143. // trace("OtrosCerrados es -1");
  144. if (ElseEnIfMirandose == true) {
  145. ElseEnIfMirandose = undefined;
  146. } else {
  147. PuedeHaberElseIf = true;
  148. break;
  149. }
  150. }
  151. } else if (LineaSinEspacios == "} else if {") {
  152. if (ElseEnIfMirandose != true) {
  153. PuedeHaberElseIf = true;
  154. break;
  155. }
  156. }
  157. }
  158. if (PuedeHaberElseIf == true) {
  159. CodesLV2++;
  160. NombredeNewCode = "LV2Code"+CodesLV2;
  161. // Se copia la base:
  162. set (NombredeNewCode, eval("LV1Code"+CodeBase).slice());
  163. // Insertar en la posición LineaDondeAgregar
  164. // Parámetros: (índice, elementos_a_eliminar, nuevo_elemento)
  165. eval(NombredeNewCode).splice(LineaDondeAgregar, 0, EspaciosaQuitar+"} else if {");
  166. trace (NombredeNewCode+":");
  167. TextoLineaPorLinea = eval(NombredeNewCode).join("\n");
  168. trace (TextoLineaPorLinea+"\n");
  169. }
  170. }
  171. }
  172. stop ();

Lo que dices ya lo tengo en el loop:
Código
  1. while (NroDeLineaMirandose > 0) {
  2. NroDeLineaMirandose--;
  3. LineaMirandose = eval("LV1Code"+CodeBase)[NroDeLineaMirandose];
  4.  

Pasa que los traces como los tengo no me alcanzan para entender qué pasa, te muestro una parte:
CodeBase:
if {
}

LineaDondeAgregar: 0

LV2Code11:
1
if {
}

LV2Code12:
if {
}
if {
}

LV2Code13:
do {
} while
if {
}

LV2Code14:
while {
}
if {
}

Se verá si es posible agregar else if
LineaDondeAgregar: 1


Ahí antes de pasar a la línea 1 debería haber un mensaje de por qué no se puede agregar en la 0.
-> if {
}
...porque no se detectó un if o else if antes, si se agregara ahí quedaría
} else if {
if {
}

Ni siquiera se mira qué hay antes porque es la línea 0, ya se sabe que antes nada hay. Esto
while (NroDeLineaMirandose > 0) {
no empieza.

Sigo con la salida, se dijo que ahora se agregaría en la línea 1, o sea:
if {
-> }

LineaSinEspacios: if {

Ese trace debería quitarlo porque es sobre cuántos espacios iniciales debe tener la línea a agregar, ni siquiera coincide con la línea donde agregar.

LV2Code15:
if {
   1
}

LV2Code16:
if {
   if {
   }
}

LV2Code17:
if {
   do {
   } while
}

LV2Code18:
if {
   while {
   }
}

Se verá si es posible agregar else if
Se quitarán espacios de la línea: if {
Se eliminaron los espacios, la línea es: if {

LV2Code19:
if {
} else if {
}


Ahí se ve cómo se agregaron distintas cosas al código base, incluyendo else if.
Los traces
"Se quitarán espacios de la línea: if {
Se eliminaron los espacios, la línea es: if {"
...tampoco sirven de mucho.
Debe informarse qué línea está mirando, qué encontró...

Al menos pude entender algo: Cuando intenta agregar en la línea 2, no puede porque el else if quedaría afuera:
if {
}
} else if {
...era algo que no entendía de la salida.

LineaDondeAgregar: 2

LV2Code20:
if {
}
1

LV2Code21:
if {
}
if {
}

LV2Code22:
if {
}
do {
} while

LV2Code23:
if {
}
while {
}

Se verá si es posible agregar else if
Se quitarán espacios de la línea: }
Se eliminaron los espacios, la línea es: }

Se quitarán espacios de la línea: if {
Se eliminaron los espacios, la línea es: if {


Ahí agregó cosas en la línea 2, luego intentó agregar else if pero no pudo, pero no explica por qué ¿cómo lo podría explicar?

...

Otra duda que tengo es de las condiciones de else if ¿están bien?

Citar
DosAbiertos y OtrosAbiertos los pones a 0 dentro del bucle, por lo que se reinician en cada vuelta y nunca acumulan.
Bien, creo que corregí eso también, fijate.

Citar
Además substr(EspaciosaQuitar) recibe el texto con los espacios y no un número, tendría que ser substr(EspaciosaQuitar.length), y lo mismo con EspaciosRequeridos más arriba.
Eso no lo cambié, si funcionara mal ¿los códigos tendrían mal los espacios? No veo que suceda.

Bueno, además de lo que dije, mi duda es cómo pongo las condiciones para que agregue else sólo cuando puede agregarlo. Según lo que pensé las condiciones son las mismas que else if pero además:
- En el if donde se quiere incluir el else, no debe haber otro else encima ni abajo, ejemplo:
if {
} else {
} else {
2 else seguidos está mal.

- En el if donde se quiere incluir el else, no debe haber un else if abajo, ejemplo:
if {
} else {
} else if {
else y luego else if está mal.

Por mi cuenta seguiré intentando avanzar.

 10 
 en: 19 Noviembre 2026, 10:47 am 
Iniciado por Javi Metal - Último mensaje por pingperdido
Prueba a conectarlo a una pantalla externa por HDMI. Si en el monitor se ve bien, el fallo casi seguro es del cable flex de la pantalla o del propio panel, no de la gráfica.

Páginas: [1] 2 3 4 5 6 7 8 9 10
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines