Lunes, 9 de Agosto de 2010
admin
A la hora de crear un hash para una contraseña, es conveniente no incluir sólo la contraseña, sino concatenar una cadena o un número más; lo mismo cuando generamos claves para que interaccionen aplicaciones en varios servidores; aunque hay veces en que, dados los pocos datos de que disponemos a la hora de generar la clave, no tenemos mucho donde elegir a la hora de crear el hash.
Por ese motivo se me ocurrió esta función en PHP, lo que hace es intercalar cadenas, es decir, tenemos dos cadenas, y queremos generar una cadena a partir de las dos anteriores, podemos coger un carácter de una, otro de otra, y así sucesivamente (como si estuviéramos barajando) hasta formar una cadena cuya longitud es la suma de las dos. Por ejemplo si tenemos las palabras “poesia” y “binaria“, resultaría la cadena: pboiensairaia .
Aunque, ya que vamos a hacer algo así, ¿ por qué limitarlo ? Hagamos una función que soporte una cantidad indeterminada de cadenas:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
| function intercalar ($cadenas)
{
$n_cadenas = count ($cadenas);
if ($n_cadenas==1) /* Si sólo hay una cadena, la devolvemos */
return $cadenas[0];
/* Contamos los caracteres de cada cadena y los almacenamos en un array */
$chars_cadena=array();
for ($i=0; $i<$n_cadenas; $i++)
$chars_cadena[$i]=strlen($cadenas[$i]);
$max_cadena = max ($chars_cadena); /* La cadena más larga determina cuándo paramos */
$res='';
/* Recorremos la longitud de cadena más larga */
for ($j=0; $j<$max_cadena; $j++)
{
/* Recorremos todas las cadenas */
for ($i=0; $i<$n_cadenas; $i++)
{
/* Si la cadena no está terminada añadiremos el carácter a la cadena */
if ($j<$chars_cadena[$i])
$res.=$cadenas[$i][$j];
}
}
return $res;
}
echo intercalar (array("Poesia", "Binaria", "Blog", "Gaspar", "Programacion", "Software", "Libre")); |
La cadena resultante de este ejemplo será: PBBGPSLoilaroienosofbsagpgtrirarweairaaamraecion.
Miércoles, 10 de Marzo de 2010
admin
A mi entender, es una de las funciones más útiles que se han inventado, como programador de PHP estoy harto de utilizarlo para filtrar información (caracteres a la derecha y a la izquierda, ya sean espacios, caracteres especiales o algún carácter que yo utilice para el control de la información).
Sabemos que el usuario final no nos va a dejar las cosas fáciles, puesto que a veces, nos llena un campo con “intros” al principio y al final; o la información, después de pasar por HTTP, lectura de un archivo XML o por otros tratamientos, tal vez tenga un retorno de carro al final; por eso, a veces es útil hacer:
Pero ahora estamos en C++, bien quería postear también el código en C++, así que decidí googlear un poco para ver esto:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| #include <string>
const std::string whiteSpaces( " \f\n\r\t\v" );
void trimRight( std::string& str,
const std::string& trimChars = whiteSpaces )
{
std::string::size_type pos = str.find_last_not_of( trimChars );
str.erase( pos + 1 );
}
void trimLeft( std::string& str,
const std::string& trimChars = whiteSpaces )
{
std::string::size_type pos = str.find_first_not_of( trimChars );
str.erase( 0, pos );
}
void trim( std::string& str, const std::string& trimChars = whiteSpaces )
{
trimRight( str, trimChars );
trimLeft( str, trimChars );
} |
Con esto podemos jugar con nuestros textos…
Ahora vamos al caso de C, muchos se siguen preguntando… pero si C es un lenguaje muy antiguo, ¿aún se sigue usando? Pues sí ! Aunque muchas cosas sean horribles de programar en C, a pelo, se sigue usando, y aún le queda mucha vida a este lenguaje. Por eso, veremos dos funciones trim() especiales para C:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| #include <stdio.h>
#include <string.h>
char *trim (char *s )
{
char *start = s ;
/* Nos comemos los espacios al inicio */
while(*start && isspace (*start ))
++start ;
char *i = start ;
char *end = start ;
/* Nos comemos los espacios al final */
while(*i )
{
if( !isspace (*(i ++)) )
end = i ;
}
/* Escribimos el terminados */
*end = 0;
return start ;
}
char *trim2 (char *s , const char *trimChars )
{
char *start = s ;
/* Nos comemos los caracteres al principio */
while(*start && strpbrk ((const char*)start , trimChars )==start )
++start ;
char *i = start ;
char *end = start ;
/* Nos comemos los caracteres al final */
while(*i )
{
if( strpbrk (i ++, trimChars )!=i -1 )
end = i ;
}
/* Coloramos el perminador */
*end = 0;
return start ;
}
int main ()
{
char mi_cadena [30]="\f\n Cadena; \tSucia \n\t ;";
printf("Mi cadena inicialmente: \"%s\"\n", mi_cadena );
printf("Mi cadena tras trim(): \"%s\"\n", trim (mi_cadena ));
printf("Mi cadena tras trim2(): \"%s\"\n", trim2 (mi_cadena ,";\f\n\t"));
} |
En C también podremos tener nuestro trimleft y nuestro trimright y creo que es fácil sacarlo desde esta función general, ya que *start se mueve indicando el principio de la cadena, y con end, y es ese movimiento (que aunque perdemos algo de memoria) el que hace que se recorte la cadena; además, como buena función de C, perdemos la cadena que inicialmente teníamos.
Hace tiempo tuve la necesidad de hacer una función de cambios de base, pero que no estuviera limitada, es decir, no tuviera definido qué base vamos a introducir y qué base debe devolver. Es decir, convertiremos un número en base b1 a base b2; la limitación, el número de caracteres con los que contemos, en el ejemplo hay hasta base 36, y es fácil extenderlo hasta base256… un número en hexadecimal no tiene desde el 0 al 9 y de la A a la F, pues un base36, del 0 al 9 y de la A a la Z. Con un poco de imaginación podremos sacar muchas ideas de este fragmento. Incluye programa de ejemplo:
Hace tiempo tuve la necesidad de hacer una función de cambios de base, pero que no estuviera limitada, es decir, no tuviera definido qué base vamos a introducir y qué base debe devolver. Es decir, convertiremos un número en base b1 a base b2; la limitación, el número de caracteres con los que contemos, en el ejemplo hay hasta base 36, y es fácil extenderlo hasta base64, base256, por ejemplo… con un poco de imaginación podremos sacar muchas ideas de este fragmento. Incluye programa de ejemplo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
| #include <stdio.h>
#include <string.h>
#include "strutils.h"
void cambiobase (char *n1 , int b1 , char *n2 , int b2 )
{
int lnum = strlen (n1 ); /* Longitud de nuestro número */
/* Caracteres que forman todos los posibles números hasta base 36 */
char numeros [37]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
int divide ;
int i ;
int posn =0;
int long2 ;
do
{
divide = 0;
long2 = 0; /* Será un puntero de n1, */
/* ya que iremos modificando su valor, long2 */
/* nos indicará por dónde vamos */
for (i =0; i <lnum ; i ++)
{
/* divide vale lo que valía antes multiplicado por la base + el número que acabamos de extraer */
/* que coincidirá con la posición del carácter dentro del array de numeros[] */
divide =divide *b1 +strchr (numeros , n1 [i ])-(char*)&numeros ;
if (divide >=b2 )
{
/* Si el número resultante es mayor o igual a la base */
n1 [long2 ] = numeros [(int) divide / b2 ]; /* Modificaremos el dígito long2 de n1, */
/* y este será el número divide/b2 en base b1 */
divide = divide % b2 ; /* divide será el resto de la división */
long2 ++;
}
else if (long2 >0)
{
n1 [long2 ] = '0'; /* divide<b2, pero en iteraciones anteriores ha sido >= */
long2 ++;
}
}
lnum =long2 ;
/* hemos hallado un dígito de n2. Su valor será divide */
n2 [posn ] = numeros [divide ];
posn ++; /* posn es el puntero del nuevo número */
} while (long2 !=0);
n2 [posn ] = '\0';
n2 =strrev (n2 , posn );
}
int main ()
{
char num1 [20], num2 [20];
int base1 , base2 ;
printf("Numero a convertir:");
scanf ("%s", num1 );
printf("¿En qué base está ese número? ");
scanf ("%d", &base1 );
printf("¿A qué base quieres convertirlo? ");
scanf ("%d", &base2 );
cambiobase (num1 , base1 , num2 , base2 );
printf("\n%s\n", num2 );
return 0;
} |
La idea principal la saqué hace tiempo de un código escrito en otro lenguaje.
Tenemos que tener en cuenta que esta función utiliza a strutils.h (ver anterior post), aunque también podéis copiar directamente la función strrev y a compilar!!
Todo esto es debido a que el algoritmo para cambiar la base genera el número (como una cadena, pero al fin y al cabo un número) al revés, es decir el dígito de menor peso primero.
En C, una de las pequeñas cosas que a veces nos hace más lentos a la hora de hacer un pequeño programa es la posibilidad de darle la vuelta a una cadena. Bien, aquí traigo un pequeño código (función y ejemplo) de strrev, que además de poder dar la vuelta a una cadena, puede manipular sólo ciertos caracteres:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
| #include <stdio.h>
#include <string.h>
char *strrev (char *str , int strl )
{
/* Creamos punteros al principio y al final de la cadena */
/* C A R A C T E R 5 \0 */
/* | | */
char *start = str , *end = str + strl - 1;
char temp ;
/* Iteramos hasta que el principio y el fin coincidan */
while(start < end )
{
/* Intercambiamos los caracteres */
/* 1º C A R A C T E R 5 */
/* 2º 5 A R A C T E R C */
/* 3º 5 R R A C T E A C */
/* 4º 5 R E A C T R A C */
/* 4º 5 R E T C A R A C */
temp = *start ;
*start ++ = *end ;
*end -- = temp ;
}
return str ;
}
/* Ejemplo */
int main ()
{
char cadena [50]="Una cadena de caracteres cualquiera";
char tmp [50]="Una cadena de caracteres cualquiera";
char *cad2 =cadena ;
printf("Cadena original: %s\n", cadena );
printf("Cadena al revés: %s\n", strrev (tmp , strlen (tmp )));
strrev (cadena +14, 10);
printf("Caracteres al revés: %s\n", cad2 );
return 0;
} |
Esta función la encontré hace mucho tiempo navegando y me pareció muy interesante, sobre todo por cómo está hecha, creo que es de las más rápidas.
Últimos comentarios