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

 

 


Tema destacado: ¿Eres nuevo? ¿Tienes dudas acerca del funcionamiento de la comunidad? Lee las Reglas Generales


  Mostrar Mensajes
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11
61  Programación / Scripting / Re: encotrar numero en pagina mechanize regular expresion en: 20 Junio 2015, 23:32 pm
Sí que se pueden usar exp. reg. para buscar lo que quieres. Te pongo un ejemplo escrito en Perl, ya que en Python no sé cómo se pueden usar las exp. reg. extendidas:
Código
  1. #!/usr/bin/perl
  2. $html = <<'HTML';
  3. <html>
  4. <head>
  5. </head>
  6. <body>
  7. <p>Un párrafo con número: 42</p>
  8. </body>
  9. </html>
  10. HTML
  11.  
  12. $html =~ /(\d+)(?(?{ $^N >= 25 and $^N <= 50 })(?{print "sí\n"})|(?{print "no\n"}))/;
Como ves, el truco consiste en capturar una cifra, y compararla con los límites que queremos, y el resultado imprimirlo inmediatamente.

Escrito de forma más clara:
Código
  1. #!/usr/bin/perl  
  2. $html = <<'HTML';
  3. <html> 
  4. <head> 
  5. </head>
  6. <body>
  7. <p>Un párrafo con número: 42</p>
  8. </body>
  9. </html>
  10. HTML
  11.  
  12. $html =~ 
  13.         /
  14.         (\d+)                                           # capturar números
  15.         (?(?{
  16.                         $^N >= 25 and $^N <= 50         # ¿está dentro de los límites?
  17.                 }) 
  18.                 (?{
  19.                         print "sí\n"                    # sí
  20.                 }) 
  21.                 |  
  22.                 (?{
  23.                         print "no\n"                    # no
  24.                 })
  25.         )  
  26.         /x;
62  Programación / Scripting / Re: ayuda con python urgente!! en: 20 Junio 2015, 23:05 pm
No necesitas un doble bucle. Con uno te vale, ya que el índice que recorre las filas es el mismo que las columnas (con eso, accedemos a la diagonal).

Código
  1. if mat[i][i] == 0:
63  Programación / Scripting / Re: Alguien con experiencia que me pueda guiar o dar tips en: 13 Junio 2015, 15:21 pm
Es mejor que no uses extensiones conocidas, aunque el formato sea el mismo. Solo con esa ya hay mucha gente que ni se molesta en averiguar qué es lo que hay dentro.

Un ejemplo que he visto en una aplicación así: los archivos extra (como tus MOD) subían con extensión .zipx , y realmente era un zip comprimido con una contraseña, pero, además, estaba invertido (el primer byte del archivo era el último, el segundo, el penúltimo, etc.).

Hay más trucos, como hacerle un XOR a todos los bytes, sumar un valor fijo a cada grupo de bytes, etc., etc. Hay muchos métodos para esconder la información.

Lo malo es... si hacen ingeniería inversa de tu programa y averiguan el procedimiento que usas.

En cuanto a la forma de hacerlo, pues puedes usar el mismo lenguaje en que desarrollas los MOD, pero depende de si puedes integrar el procedimiento de comprensión.

Ejemplo: tuvimos un caso en que era necesario enviar informes a los clientes. Ese informe iba comprimido, ya que era texto y tenía que ser muy rápido. Pero en el lado del cliente no podíamos instalar la biblioteca de descomprensión. La solución fue comprimir los archivos con un sencillo método RLE personalizado para comprimir palabras, no bytes. Y el procedimiento para descomprimir en el lado del cliente fue igual de simple.
64  Programación / Programación General / Este año, la YAPC::EU 2015, en Granada (la de España) en: 4 Junio 2015, 15:41 pm
Buenas.

Solo unas líneas para contaros que este año se celebrará la próxima YAPC::EU en Granada. Será la primera vez que este evento europeo se celebre en España.

Ya está abierta la inscripción.

En estos momentos ya son más de 200 los registrados, de 33 países y 59 grupos de usuarios, de los cuales más de 100 son los confirmados.

De momento, más de 50 charlas aprobadas.

Mod: Links corregidos.
65  Programación / Scripting / Perl v5.22 en: 1 Junio 2015, 22:54 pm
Perl 5.22.0 representa, aproximadamente, 12 meses de desarrollo desde Perl 5.20.0 y contiene aproximadamente 590 000 líneas de cambios a lo largo de 2400 archivos por parte de 94 autores.

Nuevas características
  • Perl sabe qué métodos se han definido en una clase, y puede llamarlos más rápido
  • Crea alias a partir de referencias en ambos lados de una asignación o en una variable de control
  • Existen nuevos operadores de bit, para diferenciar los casos de números y cadenas de caracteres
  • El operador de entrada de líneas, el diamante doble, <<>>, reduce los casos mágicos cuando gestionamos ARGV (archivos abiertos de forma implícita desde la línea de comandos)
  • La forma de open() entubado ahora funciona en Windows
  • Valores de punto flotante en hexadecimal. (Pero, ¿qué demonios es esto?)
  • close() ahora pone sus errores en $! y saca una advertencia cuando falla de forma implícita
Mejoras en la expresiones regulares
  • Márgenes \b especiales en exp. reg., incluyendo agrupaciones de grafemas, márgenes de palabras en Unicode, y márgenes en sentencias
  • La nueva opción /n (no captura) en exp. reg. convierte a todos los grupos de paréntesis como de no captura
  • El módulo re ahora tiene un modo estricto
  • Solo puede usar un /x, porque /xx significará otra cosa, en el futuro

Y soporte de Unicode 7.0.

El módulo CGI se ha quitado. Si se desea, se puede instalar desde CPAN, pero lo recomendado hoy en día es usar otras tecnologías.

Plataformas que vuelven a funcionar: IRIX y Tru64. z/OS ejecutando el código de página 1047 de EBCDIC.

Plataformas obsoletas: NeXTSTEP/OPENSTEP
66  Programación / Scripting / Re: como procesar archivos en linux en: 23 Abril 2015, 04:50 am
¿Puedes publicar un ejemplo, unas pocas líneas, de cómo son los archivos de entrada?

Falsea los datos sensibles, como los de las MAC. Solo nos interesa el formato del archivo.
67  Programación / Scripting / Re: como procesar archivos en linux en: 21 Abril 2015, 18:36 pm
Si pones un ejemplo pequeño de lo que quieres hacer, te damos la solución  ;)
68  Programación / Scripting / Re: duda ejercicio combinatoria en: 19 Abril 2015, 21:45 pm
¡Ah!, entiendo: hay una limitación en el número de escalones que se pueden subir, de hasta 3.

Claro... muy poca gente podría dar un salto de muchos escalones para subir  :laugh:

Entonces, mis soluciones no sirven.

Pero... con dos pequeños cambios, ya vuelve a funcionar   ;D
Código
  1. #!/usr/bin/perl
  2. my $escalones = 0 + shift;                                      # leemos el número de escalones
  3.  
  4. if ($escalones > 0) {                                           # si es un número positivo
  5.     my @combinaciones = descompon($escalones);                  # sacamos todas las @combinaciones
  6.     print "Hay ", scalar(@combinaciones), " combinaciones:\n";  # informamos del número de @combinaciones
  7.     print join('; ' => @combinaciones), "\n";                   # y las propias combinaciones
  8. }
  9.  
  10. sub descompon {                                                 # devuelve una lista de combinaciones
  11.     my $escalones = shift;                                      # para un determinado número de $escalones
  12.  
  13.     my @combinaciones;                                          # aquí guardaremos las @combinaciones encontradas
  14.  
  15.     for my $salto ( 1 .. 3 ) {                                  # damos un $salto cada vez mayor
  16.         next if $salto > $escalones;
  17.         my $resto = $escalones - $salto;                        # después del $salto, nos queda un $resto de $escalones
  18.  
  19.         if ( not $resto ) {                                     # si hemos llegado arriba
  20.             push @combinaciones, $salto;                        # guardamos ese $salto como nueva combinación
  21.         }
  22.         else {                                                  # si aún no hemos llegado
  23.             my @resto_combinaciones = descompon($resto);        # vemos todas las combinaciones que quedan para subir
  24.  
  25.             for my $combina_resto ( @resto_combinaciones ) {    
  26.                                                                 # y las guardamos
  27.                 push @combinaciones, join "," => $salto, $combina_resto;
  28.             }
  29.         }
  30.     }
  31.  
  32.     return @combinaciones;                                      # devolvemos las @combinaciones encontradas
  33. }
69  Programación / Scripting / Re: duda ejercicio combinatoria en: 18 Abril 2015, 19:52 pm
Ya se me ha quejado alguno diciendo que mi solución es muy complicada  :xD

Aquí pongo la solución usando recursión.
Código
  1. #!/usr/bin/env perl
  2. my $escalones = 0 + shift;					# leemos el número de escalones
  3.  
  4. if ($escalones > 0) {						# si es un número positivo
  5.     my @combinaciones = descompon($escalones);			# sacamos todas las @combinaciones
  6.     print "Hay ", scalar(@combinaciones), " combinaciones:\n";	# informamos del número de @combinaciones
  7.     print join('; ' => @combinaciones), "\n";			# y las propias combinaciones
  8. }
  9.  
  10. sub descompon() {						# devuelve una lista de combinaciones
  11.     my $escalones = shift;					# para un determinado número de $escalones
  12.  
  13.     my @combinaciones;						# aquí guardaremos las @combinaciones encontradas
  14.  
  15.     for my $salto (1 .. $escalones) {				# damos un $salto cada vez mayor
  16. 	my $resto = $escalones - $salto;			# después del $salto, nos queda un $resto de $escalones
  17.  
  18. 	if (not $resto) {					# si hemos llegado arriba
  19. 	    push @combinaciones, $salto;			# guardamos ese $salto como nueva combinación
  20. 	}
  21. 	else {							# si aún no hemos llegado
  22. 	    for my $combina_resto (descompon($resto)) {		# vemos todas las combinaciones que quedan para subir
  23. 								# y las guardamos
  24. 		push @combinaciones, join "," => $salto, $combina_resto;
  25. 	    }
  26. 	}
  27.     }
  28.  
  29.     return @combinaciones;					# devolvemos las @combinaciones encontradas
  30. }
Ejemplo:
Código:
$ ./descompon2.pl 6
Hay 32 combinaciones:
1,1,1,1,1,1; 1,1,1,1,2; 1,1,1,2,1; 1,1,1,3; 1,1,2,1,1; 1,1,2,2; 1,1,3,1; 1,1,4; 1,2,1,1,1; 1,2,1,2; 1,2,2,1; 1,2,3;
 1,3,1,1; 1,3,2; 1,4,1; 1,5; 2,1,1,1,1; 2,1,1,2; 2,1,2,1; 2,1,3; 2,2,1,1; 2,2,2; 2,3,1; 2,4; 3,1,1,1; 3,1,2; 3,2,1;
 3,3; 4,1,1; 4,2; 5,1; 6

Naturalmente, existen más soluciones... :silbar:
70  Programación / Scripting / Re: duda ejercicio combinatoria en: 18 Abril 2015, 17:53 pm
Perdón, pero para subir 4 escalones a mi me salen 8 combinaciones:

Código:
4
3,1
2,2
2,1,1
1,3
1,2,1
1,1,2
1,1,1,1

Muestro aquí mi solución, usando el motor de expresiones regulares de Perl, realizando una búsqueda exhaustiva por todas las combinaciones, al provocar un fallo premeditado que obliga a que el motor haga "backtracking" y busque una nueva solución.

Como no sé mucho de Python, lo dejo en Perl, pero es fácil pasarlo a Python (creo). Primero, la versión que se puede ejecutar desde la línea de comandos:
Código
  1. $ perl -E '$n = shift; $rx = ("(1*?)" x ($n-1)) . "(1+)"; $rx = qr/^$rx$/; $x = "1" x $n; $x =~ m/$rx(?{$visto{ join "," => grep { $_ > 0 } map { $+[$_] - $-[$_] } 1..$n }++ })(*FAIL)/; say join "; " => sort keys %visto' 4
  2. 1,1,1,1; 1,1,2; 1,2,1; 1,3; 2,1,1; 2,2; 3,1; 4
Y ahora la versión más normal:
Código
  1. #!/usr/bin/env perl
  2. use feature 'say';
  3.  
  4. my %visto;						# memoria de combinaciones ya vistas (evitar repeticiones)
  5.  
  6. my $escalones = shift;					# leemos los escalones
  7.  
  8. my $rx = ("(1*?)" x ($escalones-1)) . "(1+)";		# creamos el patrón de búsqueda. Es de la forma (1*?)(1*?)...(1+)
  9. $rx = qr/^$rx$/;
  10.  
  11. my $x = "1" x $escalones;				# esta var. contiene tantos '1' como indiquen los $escalones
  12.  
  13. $x =~ m/
  14. 	$rx						# buscamos una combinación
  15. 	(?{
  16. 	    $visto{					# la decodificamos
  17. 		join "," => grep { $_ > 0 } map { $+[$_] - $-[$_] } 1..$escalones
  18. 	    }++
  19. 	})
  20. 	(*FAIL)						# provocamos un fallo de 'backtraking'
  21.       /x;
  22.  
  23. say join "; " => sort keys %visto;			# resultado, formateado

Ejemplo:
Código:
$ descompon.pl 5
1,1,1,1,1; 1,1,1,2; 1,1,2,1; 1,1,3; 1,2,1,1; 1,2,2; 1,3,1; 1,4; 2,1,1,1; 2,1,2; 2,2,1; 2,3; 3,1,1; 3,2; 4,1; 5
Páginas: 1 2 3 4 5 6 [7] 8 9 10 11
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines