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

 

 


Tema destacado: Usando Git para manipular el directorio de trabajo, el índice y commits (segunda parte)


+  Foro de elhacker.net
|-+  Programación
| |-+  Programación C/C++ (Moderadores: Eternal Idol, Littlehorse, K-YreX)
| | |-+  Librería de Snippets en C/C++		0 Usuarios y 1 Visitante están viendo este tema.
Páginas: 1 2 [3] 4 Ir Abajo Respuesta Imprimir
Autor Tema: Librería de Snippets en C/C++  (Leído 25,811 veces)
X3R4CK3R

Desconectado Desconectado

Mensajes: 74


Divide y vencerás


Ver Perfil WWW
Re: Librería de Snippets en C++
« Respuesta #20 en: 28 Julio 2013, 05:03 am »
Cita de: OmarHack en 22 Julio 2013, 22:52 pm
    system ("title Longitud De Un Texto");
    system ("color 0f");

Un consejo: deberías acostumbrarte a prescindir de system si vas a programar en C++, para cambiar el title de la cmd tienes la función SetConsoleTitle , y para cambiar el color está SetConsoleTextAttribute, ambos pertenecen a la API de windows:

Código
  1. SetConsoleTitle("Longitud De Un Texto");
  2. SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), FOREGROUND_GREEN | BACKGROUND_RED); //Texto en verde, fondo en rojo



Saludos
En línea
Stakewinner00


Desconectado Desconectado

Mensajes: 1.426



Ver Perfil WWW
Re: Librería de Snippets en C/C++
« Respuesta #21 en: 28 Julio 2013, 11:40 am »
Otro snippet de cripto clásica este de el algoritmo Playfair. El código solo soporta mayúsculas pero ya iré editando con las mejoras que le ponga.

Código
  1. /*
  2. EXAMPLE
  3.  
  4. 	string a;
  5. 	cin >> a;
  6. 	string b;
  7. 	b= playfair_encrypt(a,"CRIPTOPUNK");
  8. 	cout << b << endl; //playfair_encrypt(mensaje,clave)
  9. 	cout << playfair_decrypt(b,"CRIPTOPUNK");
  10. */
  11.  
  12. #include <string>
  13.  
  14. using std::string;
  15.  
  16. inline void generar_matriz(string);
  17. string playfair_encrypt(string, string);
  18. string playfair_decrypt(string, string);
  19.  
  20. char matriz[5][5];
  21. void generar_matriz(string clave_inprocessada)
  22. {
  23. 	char ABC[25]={'A','B','C','D','E','F','G','H','I','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
  24. 	string clave;
  25. 	bool exist;
  26. 	for(int i=0;i<clave_inprocessada.size();i++)
  27. 	{
  28. 		for(int p=0;p<clave.size();p++)
  29. 		{
  30. 			if(clave_inprocessada[i] == clave[p])
  31. 				exist = true;
  32. 		}
  33. 		if(exist==false)
  34. 		{
  35. 			clave += clave_inprocessada[i];
  36. 		} else {
  37. 			exist = false;
  38. 		}
  39. 	}
  40.  
  41. 	short temp=0;
  42. 	bool cual=false;
  43. 	for(short j=0;j<5;j++)
  44. 	{	
  45. 		for(short i=0;i<5;i++)
  46. 		{
  47. 			for(int p=0;p<25;p++)
  48. 			{
  49. 				if(ABC[p] == clave[temp])
  50. 				ABC[p]='J';
  51. 			}
  52. 			if(temp==clave.size() && cual==false)
  53. 			{
  54. 				cual = true;
  55. 				temp=0;
  56. 			}
  57. 			if(cual==false)
  58. 			{	
  59. 				matriz[j][i] = clave[temp];
  60. 			} else {
  61. 				while(ABC[temp]=='J') 
  62. 				{
  63. 					temp++;
  64. 				}
  65. 				matriz[j][i] = ABC[temp];
  66. 			}
  67. 			temp++;
  68. 		}
  69. 	}
  70. 	/*for(short j=0;j<5;j++)
  71. 	{
  72. 		for(short p=0;p<5;p++)
  73. 		{
  74. 			std::cout << matriz[j][p];
  75. 		}
  76. 		std::cout << std::endl;
  77. 	}*/
  78. }
  79.  
  80. string playfair_encrypt(string s, string clave)
  81. {
  82. 	generar_matriz(clave);
  83. 	string ct;
  84. 	short p1;
  85. 	short p2;
  86. 	short e1;
  87. 	short e2;
  88. 	for(int i=0;i<s.size();i += 2)
  89. 	{
  90. 		if(s[i]==s[i+1])
  91. 		{
  92. 			ct += s[i];
  93. 			ct += 'X' + s[i+1];
  94. 		} else {
  95. 			ct += s[i];
  96. 			ct += s[i+1];
  97. 		}
  98. 	}
  99. 	s = ct;	
  100. 	ct="";
  101. 	for(int i=0;i<s.size();i++)
  102. 	{
  103. 		if(s[i]=='J')
  104. 		s[i]='I';
  105. 		for(int p=0;p<5;p++)
  106. 		{
  107. 			for(int j=0;j<5;j++)
  108. 			{
  109. 				if(s[i]==matriz[p][j])
  110. 				{
  111. 					p1=p;
  112. 					p2=j;
  113. 				}
  114. 			}
  115. 		}
  116. 		i++;
  117. 		if(i>clave.size())
  118. 		clave += 'X';
  119. 		for(int p=0;p<5;p++)
  120. 		{
  121. 			for(int j=0;j<5;j++)
  122. 			{
  123. 				if(s[i]==matriz[p][j])
  124. 				{
  125. 					e1=p;
  126. 					e2=j;
  127. 				}
  128. 			}
  129. 		}
  130. 		if(e1!=p1 && e2!=p2)
  131. 		{
  132. 			ct += matriz[p1][e2];
  133. 			ct += matriz[e1][p2];
  134. 		} else if(e1!=p1 && e2==p2) {
  135. 			if(p1==4)
  136. 			{
  137. 				p1 = -1;
  138. 			} else if(e1==4) {
  139. 				e1=-1;
  140. 			}
  141. 			ct += matriz[p1+1][p2];
  142. 			ct += matriz[e1+1][e2];
  143. 		} else if(e1==p1 && e2!=p2) {
  144. 			if(p2==4)
  145. 			{
  146. 				p2 = -1;
  147. 			} else if(e2==4) {
  148. 				e2=-1;
  149. 			}
  150. 			ct += matriz[p1][p2+1];
  151. 			ct += matriz[e1][e2+1];	
  152. 		}
  153. 	}
  154. 	return ct;
  155. }
  156.  
  157. string playfair_decrypt(string s, string clave)
  158. {
  159. 	generar_matriz(clave);
  160. 	string ct;
  161. 	short p1;
  162. 	short p2;
  163. 	short e1;
  164. 	short e2;
  165. 	for(int i=0;i<s.size();i++)
  166. 	{
  167. 		for(int p=0;p<5;p++)
  168. 		{
  169. 			for(int j=0;j<5;j++)
  170. 			{
  171. 				if(s[i]==matriz[p][j])
  172. 				{
  173. 					p1=p;
  174. 					p2=j;
  175. 				}
  176. 			}
  177. 		}
  178. 		i++;
  179. 		if(i>clave.size())
  180. 		clave += 'X';
  181. 		for(int p=0;p<5;p++)
  182. 		{
  183. 			for(int j=0;j<5;j++)
  184. 			{
  185. 				if(s[i]==matriz[p][j])
  186. 				{
  187. 					e1=p;
  188. 					e2=j;
  189. 				}
  190. 			}
  191. 		}
  192. 		if(e1!=p1 && e2!=p2)
  193. 		{
  194. 			ct += matriz[p1][e2];
  195. 			ct += matriz[e1][p2];
  196. 		} else if(e1!=p1 && e2==p2) {
  197. 			if(p1==0)
  198. 			{
  199. 				p1 = 1;
  200. 			} else if(e1==0) {
  201. 				e1=1;
  202. 			}
  203. 			ct += matriz[p1-1][p2];
  204. 			ct += matriz[e1-1][e2];
  205. 		} else if(e1==p1 && e2!=p2) {
  206. 			if(p2==0)
  207. 			{
  208. 				p2 = 5;
  209. 			} else if(e2==0) {
  210. 				e2= 5;
  211. 			}
  212. 			ct += matriz[p1][p2-1];
  213. 			ct += matriz[e1][e2-1];	
  214. 		}
  215. 	}
  216. 	return ct;
  217. }
« Última modificación: 29 Julio 2013, 10:25 am por Stakewinner00 » En línea
do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: Librería de Snippets en C/C++
« Respuesta #22 en: 29 Julio 2013, 17:36 pm »
¡Buenas!

Aquí os dejo unos códigos que acabo de hacer. Han salido a raíz de una pregunta posteada y por fin me he decidido ha hacerlos.

Son funciones para el manejo de la combinatoria (combinaciones, variaciones y permutaciones, tanto con repeticiones como sin repeticiones).

Trabajan con indices de enteros, así que los resultados de las funciones son aplicables a cualquier vector o contenedor lineal al que se pueda acceder por subindices.

Primero os dejo tanto combinatoria.h como combinatoria.c y al final un codigo de ejemplo.

¡Saludos!

Si os resulta mas cómodo aquí os dejo un enlace de descarga.

combinatoria.h
Código
  1. #ifndef COMBINATORIA_H
  2. #define COMBINATORIA_H
  3.  
  4. /*
  5.  * La esctructura t_combinatoria guarda una lista con todos los elementos
  6.  * que genera un tipo combinatorio... (lio)
  7.  *
  8.  * Por ejemplo. Si caltulamos las permutaciones de un conjunto, cada elemento
  9.  * de lista sera una de las permutaciones. (mas claro)
  10.  *
  11.  * n_elementos es el numero de listas. Si hemos calculado permutaciones de n
  12.  * elementos n_elementos sera n!...
  13.  *
  14.  * longitud_elemento es la longitud de cada elemento generado:
  15.  * en variaciones de n elementos tomados de k en k, longitud_elemento = k.
  16.  *
  17.  */
  18.  
  19. struct t_combinatoria
  20. {
  21.     unsigned char **lista;
  22.     unsigned long n_elementos;
  23.     unsigned char longitud_elemento;
  24. };
  25. typedef struct t_combinatoria t_combinatoria;
  26.  
  27. /*
  28.  * IMPORTATISIMO UTILIZAR LA FUNCION PARA INICIALIZAR ANTES DE CUALQUIER
  29.  * LLAMADA A ALGUNA DE LAS SIGUIENTES FUNCIONES, Y FINALIZAR LOS DATOS
  30.  * DESPUES DE TERMINAR DE UTILIZARLOS
  31.  *
  32.  */
  33. void inicializar_combinatoria(t_combinatoria *comb);
  34. void finalizar_combinatoria(t_combinatoria *comb);
  35.  
  36. /* CUALLQUIERA DE LAS SIGUIENTE FUNCIONES DEVUELVE 0 SI HAY ALGUN ERROR Y 1 SI TODO VA BIEN */
  37.  
  38. /* Combinaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n)*/
  39. int combinaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion);
  40.  
  41. /* Combinaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera)*/
  42. int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjutnto, unsigned char elementos_combinacion);
  43.  
  44. /* variaciones sin repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k <= n) */
  45. int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);
  46.  
  47. /* variaciones con repeticion de n (elementos_conjunto) tomados de k (elementos_combinacion) en k (k cualquiera) */
  48. int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion);
  49.  
  50. /* permutaciones sin repeticion de n (elementos_conjunto) elementos */
  51. int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto);
  52.  
  53. /*permutaciones con repeticion de un conjunto de elementos_conjunto elementos, y repeticiones es un vector
  54.  * en el que se nos indica cuantas veces se repite el elemento i de la lista
  55.  */
  56. int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones);
  57.  
  58. #endif // COMBINATORIA_H
  59.  

combinatoria.c
Código
  1. #include "combinatoria.h"
  2.  
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6.  
  7. void inicializar_combinatoria(t_combinatoria *c)
  8. {
  9.     c->lista = NULL;
  10.     c->n_elementos = 0;
  11.     c->longitud_elemento = 0;
  12. }
  13.  
  14. void finalizar_combinatoria(t_combinatoria *c)
  15. {
  16.     unsigned long i;
  17.  
  18.     for(i = 0 ; i < c->n_elementos ; i++)
  19.         free(c->lista[i]);
  20.  
  21.     free(c->lista);
  22.  
  23.     c->lista = NULL;
  24.     c->n_elementos = 0;
  25.     c->longitud_elemento = 0;
  26. }
  27.  
  28. unsigned long factorial(unsigned long n)
  29. {
  30.     unsigned long ret = 1;
  31.  
  32.     while(n)
  33.         ret *= (n--);
  34.  
  35.     return ret;
  36. }
  37.  
  38. unsigned long variaciones_n_k(unsigned long n, unsigned long k)
  39. {
  40.     unsigned long copia_n = n, ret = 1;
  41.  
  42.     while(n - (copia_n - k))
  43.         ret *= (n--);
  44.  
  45.     return ret;
  46. }
  47.  
  48. unsigned long exponencial(unsigned long base, unsigned long exponente)
  49. {
  50.     unsigned long ret = 1;
  51.  
  52.     if(exponente)
  53.         while(exponente--)
  54.             ret *= base;
  55.  
  56.     return ret;
  57. }
  58.  
  59. unsigned long binomial(unsigned long n, unsigned long k)
  60. {
  61.     return variaciones_n_k(n,k) / factorial(k);
  62. }
  63.  
  64. unsigned long binomial_generalizado(unsigned char *repeticiones, unsigned long dim)
  65. {
  66.     unsigned long ret = 0,i;
  67.  
  68.     for(i = 0 ; i < dim ; i++)
  69.         ret += repeticiones[i];
  70.  
  71.     ret = factorial(ret);
  72.  
  73.     for(i = 0 ; i < dim ; i++)
  74.         ret /= factorial(repeticiones[i]);
  75.  
  76.     return ret;
  77. }
  78.  
  79. int combinaciones(t_combinatoria *datos,unsigned char elementos_conjunto, unsigned char elementos_combinacion)
  80. {
  81.     static unsigned char indice = 0;
  82.     static unsigned long elementos_fijados = 0;
  83.     static unsigned char *aux = NULL;
  84.     unsigned long i;
  85.  
  86.     if(!elementos_combinacion || !elementos_conjunto)
  87.         return 0;
  88.  
  89.     if(indice == elementos_combinacion)
  90.     {
  91.         memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));
  92.  
  93.         elementos_fijados++;
  94.  
  95.         return 1;
  96.     }
  97.  
  98.     /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
  99.     if(!indice)
  100.     {
  101.         if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
  102.             return 0;
  103.  
  104.         datos->n_elementos = binomial(elementos_conjunto,elementos_combinacion);
  105.         datos->longitud_elemento = elementos_combinacion;
  106.  
  107.         if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
  108.         {
  109.             datos->n_elementos = 0;
  110.             datos->longitud_elemento = 0;
  111.  
  112.             return 0;
  113.         }
  114.  
  115.         for(i = 0 ; i < datos->n_elementos ; i++)
  116.         {
  117.             if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
  118.             {
  119.                 unsigned long j;
  120.  
  121.                 for(j = 0 ; j < i ; j++)
  122.                     free(datos->lista[i]);
  123.  
  124.                 free(datos->lista);
  125.                 datos->lista = NULL;
  126.  
  127.                 datos->n_elementos = 0;
  128.                 datos->longitud_elemento = 0;
  129.  
  130.                 return 0;
  131.             }
  132.         }
  133.  
  134.         for(i = 0 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
  135.         {
  136.             aux[indice] = i;
  137.  
  138.             indice++;
  139.  
  140.             combinaciones(datos, elementos_conjunto, elementos_combinacion);
  141.  
  142.             indice--;
  143.         }
  144.  
  145.         free(aux);
  146.         aux = NULL;
  147.         elementos_fijados = 0;
  148.         indice = 0;
  149.     }
  150.     else
  151.     {
  152.         for(i = aux[indice - 1] + 1 ; i < elementos_conjunto - elementos_combinacion + indice + 1; i++)
  153.         {
  154.             aux[indice] = i;
  155.  
  156.             indice++;
  157.  
  158.             combinaciones(datos, elementos_conjunto, elementos_combinacion);
  159.  
  160.             indice--;
  161.         }
  162.     }
  163.  
  164.     return 1;
  165. }
  166.  
  167. int combinaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_combinacion)
  168. {
  169.     static unsigned char indice = 0;
  170.     static unsigned long elementos_fijados = 0;
  171.     static unsigned char *aux = NULL;
  172.     unsigned long i;
  173.  
  174.     if(!elementos_combinacion || !elementos_conjunto)
  175.         return 0;
  176.  
  177.     if(indice == elementos_combinacion)
  178.     {
  179.         memcpy(*(datos->lista + elementos_fijados), aux, elementos_combinacion * sizeof(unsigned char));
  180.  
  181.         elementos_fijados++;
  182.  
  183.         return 1;
  184.     }
  185.  
  186.     /* si es la primera vez que llamamos a la funcion, reservamos memoria para la tabla de combinaciones */
  187.     if(!indice)
  188.     {
  189.         if(!(aux = (unsigned char *) malloc(elementos_combinacion * sizeof(unsigned char))))
  190.             return 0;
  191.  
  192.         datos->n_elementos = binomial(elementos_conjunto + elementos_combinacion - 1,elementos_combinacion);
  193.         datos->longitud_elemento = elementos_combinacion;
  194.  
  195.         if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
  196.         {
  197.             datos->n_elementos = 0;
  198.             datos->longitud_elemento = 0;
  199.  
  200.             return 0;
  201.         }
  202.  
  203.         for(i = 0 ; i < datos->n_elementos ; i++)
  204.         {
  205.             if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
  206.             {
  207.                 unsigned long j;
  208.  
  209.                 for(j = 0 ; j < i ; j++)
  210.                     free(datos->lista[i]);
  211.  
  212.                 free(datos->lista);
  213.                 datos->lista = NULL;
  214.  
  215.                 datos->n_elementos = 0;
  216.                 datos->longitud_elemento = 0;
  217.  
  218.                 return 0;
  219.             }
  220.         }
  221.  
  222.         for(i = 0 ; i < elementos_conjunto; i++)
  223.         {
  224.             aux[indice] = i;
  225.  
  226.             indice++;
  227.  
  228.             combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);
  229.  
  230.             indice--;
  231.         }
  232.  
  233.         free(aux);
  234.         aux = NULL;
  235.         elementos_fijados = 0;
  236.         indice = 0;
  237.     }
  238.     else
  239.     {
  240.         for(i = aux[indice - 1] ; i < elementos_conjunto ; i++)
  241.         {
  242.             aux[indice] = i;
  243.  
  244.             indice++;
  245.  
  246.             combinaciones_repeticion(datos, elementos_conjunto, elementos_combinacion);
  247.  
  248.             indice--;
  249.         }
  250.     }
  251.  
  252.     return 1;
  253. }
  254.  
  255. int variaciones(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
  256. {
  257.     static unsigned char indice = 0;
  258.     static unsigned long elementos_fijados = 0;
  259.     static unsigned char *aux = NULL;
  260.     static unsigned char *lista_indices = NULL;
  261.     unsigned long i;
  262.  
  263.     if(!elementos_variacion || !elementos_conjunto)
  264.         return 0;
  265.  
  266.     if(indice == elementos_variacion)
  267.     {
  268.         memcpy(*(datos->lista + elementos_fijados), aux, elementos_variacion * sizeof(unsigned char));
  269.  
  270.         elementos_fijados++;
  271.  
  272.         return 1;
  273.     }
  274.  
  275.     if(!indice)
  276.     {
  277.         if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
  278.             return 0;
  279.  
  280.         if(!(lista_indices = (unsigned char *) malloc(elementos_conjunto * sizeof(unsigned char))))
  281.         {
  282.             free(aux);
  283.             aux = NULL;
  284.  
  285.             return 0;
  286.         }
  287.  
  288.         for(i = 0 ; i < elementos_conjunto ; i++)
  289.             lista_indices[i] = i;
  290.  
  291.         datos->n_elementos = variaciones_n_k(elementos_conjunto , elementos_variacion);
  292.         datos->longitud_elemento = elementos_variacion;
  293.  
  294.         if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
  295.         {
  296.             free(aux);
  297.             aux = NULL;
  298.  
  299.             free(lista_indices);
  300.             lista_indices = NULL;
  301.  
  302.             datos->n_elementos = 0;
  303.             datos->longitud_elemento = 0;
  304.  
  305.             return 0;
  306.         }
  307.  
  308.         for(i = 0 ; i < datos->n_elementos ; i++)
  309.         {
  310.             if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
  311.             {
  312.                 unsigned long j;
  313.  
  314.                 for(j = 0 ; j < i ; j++)
  315.                     free(datos->lista[j]);
  316.  
  317.                 free(datos->lista);
  318.                 datos->lista = NULL;
  319.  
  320.                 free(aux);
  321.                 aux = NULL;
  322.  
  323.                 free(lista_indices);
  324.                 lista_indices = NULL;
  325.  
  326.                 datos->n_elementos = 0;
  327.                 datos->longitud_elemento = 0;
  328.  
  329.                 return 0;
  330.             }
  331.         }
  332.     }
  333.  
  334.     aux[indice] = lista_indices[indice];
  335.  
  336.     indice++;
  337.     variaciones(datos, elementos_conjunto, elementos_variacion);
  338.     indice--;
  339.  
  340.     for(i = indice + 1; i < elementos_conjunto ; i++)
  341.     {
  342.         aux[indice] = lista_indices[i];
  343.  
  344.         lista_indices[indice] ^= lista_indices[i];
  345.         lista_indices[i] ^= lista_indices[indice];
  346.         lista_indices[indice] ^= lista_indices[i];
  347.  
  348.         indice++;
  349.  
  350.         variaciones(datos , elementos_conjunto , elementos_variacion);
  351.  
  352.         indice--;
  353.  
  354.         lista_indices[indice] ^= lista_indices[i];
  355.         lista_indices[i] ^= lista_indices[indice];
  356.         lista_indices[indice] ^= lista_indices[i];
  357.     }
  358.  
  359.     if(!indice)
  360.     {
  361.         elementos_fijados = 0;
  362.         indice = 0;
  363.  
  364.         free(aux);
  365.         aux = NULL;
  366.  
  367.         free(lista_indices);
  368.         lista_indices = NULL;
  369.     }
  370.  
  371.     return 1;
  372. }
  373.  
  374. int variaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char elementos_variacion)
  375. {
  376.     static unsigned char indice = 0;
  377.     static unsigned long elementos_fijados = 0;
  378.     static unsigned char *aux = NULL;
  379.     unsigned long i;
  380.  
  381.     if(!elementos_variacion || !elementos_conjunto)
  382.         return 0;
  383.  
  384.     if(indice == elementos_variacion)
  385.     {
  386.         memcpy(*(datos->lista + elementos_fijados),aux,elementos_variacion * sizeof(unsigned char));
  387.  
  388.         elementos_fijados++;
  389.  
  390.         return 1;
  391.     }
  392.  
  393.     if(!indice)
  394.     {
  395.         if(!(aux = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
  396.             return 0;
  397.  
  398.         datos->n_elementos = exponencial(elementos_conjunto, elementos_variacion);
  399.         datos->longitud_elemento = elementos_variacion;
  400.  
  401.         if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
  402.         {
  403.             datos->n_elementos = 0;
  404.             datos->longitud_elemento = 0;
  405.  
  406.             return 0;
  407.         }
  408.  
  409.         for(i = 0 ; i < datos->n_elementos ; i++)
  410.         {
  411.             if(!(datos->lista[i] = (unsigned char *) malloc(elementos_variacion * sizeof(unsigned char))))
  412.             {
  413.                 unsigned long j;
  414.  
  415.                 for(j = 0 ; j < i ; j++)
  416.                     free(datos->lista[j]);
  417.  
  418.                 free(datos->lista);
  419.                 datos->lista = NULL;
  420.  
  421.                 datos->n_elementos = 0;
  422.                 datos->longitud_elemento = 0;
  423.  
  424.                 return 0;
  425.             }
  426.         }
  427.     }
  428.  
  429.     for(i = 0 ; i < elementos_conjunto ; i++)
  430.     {
  431.         aux[indice] = i;
  432.  
  433.         indice++;
  434.         variaciones_repeticion(datos, elementos_conjunto, elementos_variacion);
  435.         indice--;
  436.     }
  437.  
  438.     if(!indice)
  439.     {
  440.         free(aux);
  441.         aux = NULL;
  442.  
  443.         elementos_fijados = 0;
  444.     }
  445.  
  446.     return 1;
  447. }
  448.  
  449. int permutaciones(t_combinatoria *datos, unsigned char elementos_conjunto)
  450. {
  451.     return variaciones(datos , elementos_conjunto , elementos_conjunto);
  452. }
  453.  
  454. int permutaciones_repeticion(t_combinatoria *datos, unsigned char elementos_conjunto, unsigned char *repeticiones)
  455. {
  456.     static unsigned char indice = 0;
  457.     static unsigned long elementos_fijados = 0;
  458.     static unsigned char *aux = NULL;
  459.     unsigned long i;
  460.  
  461.     if(!elementos_conjunto)
  462.         return 0;
  463.  
  464.     if(!indice)
  465.     {
  466.         for(i = 0 ; i < elementos_conjunto ; i++)
  467.             datos->longitud_elemento += repeticiones[i];
  468.  
  469.         if(!datos->longitud_elemento)
  470.             return 0;
  471.  
  472.         if(!(aux = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
  473.         {
  474.             datos->longitud_elemento = 0;
  475.  
  476.             return 0;
  477.         }
  478.  
  479.         datos->n_elementos = binomial_generalizado(repeticiones, elementos_conjunto);
  480.  
  481.         if(!(datos->lista = (unsigned char **) malloc(datos->n_elementos * sizeof(unsigned char *))))
  482.         {
  483.             free(aux);
  484.             aux = NULL;
  485.  
  486.             datos->n_elementos = 0;
  487.             datos->longitud_elemento = 0;
  488.  
  489.             return 0;
  490.         }
  491.  
  492.         for(i = 0 ; i < datos->n_elementos ; i++)
  493.         {
  494.             if(!(datos->lista[i] = (unsigned char *) malloc(datos->longitud_elemento * sizeof(unsigned char))))
  495.             {
  496.                 unsigned long j;
  497.  
  498.                 for(j = 0 ; j < i ; j++)
  499.                     free(datos->lista[j]);
  500.  
  501.                 free(datos->lista);
  502.                 datos->lista = NULL;
  503.  
  504.                 free(aux);
  505.                 aux = NULL;
  506.  
  507.                 datos->n_elementos = 0;
  508.                 datos->longitud_elemento = 0;
  509.  
  510.                 return 0;
  511.             }
  512.         }
  513.     }
  514.  
  515.     if(indice == datos->longitud_elemento)
  516.     {
  517.         memcpy(*(datos->lista + elementos_fijados), aux, datos->longitud_elemento * sizeof(unsigned char));
  518.  
  519.         elementos_fijados++;
  520.  
  521.         return 1;
  522.     }
  523.  
  524.     for(i = 0; i < elementos_conjunto ; i++)
  525.     {
  526.         if(repeticiones[i])
  527.         {
  528.             aux[indice] = i;
  529.             repeticiones[i]--;
  530.  
  531.             indice++;
  532.             permutaciones_repeticion(datos,elementos_conjunto,repeticiones);
  533.             indice--;
  534.  
  535.             repeticiones[i]++;
  536.         }
  537.     }
  538.  
  539.     if(!indice)
  540.     {
  541.         free(aux);
  542.         aux = NULL;
  543.  
  544.         elementos_fijados = 0;
  545.     }
  546.  
  547.     return 1;
  548. }
  549.  

ejemplo
Código
  1. #include <stdio.h>
  2.  
  3. #include "combinatoria.h"
  4.  
  5. int main()
  6. {
  7.     t_combinatoria comb;
  8.     int i, j;
  9.     unsigned long repeticiones[] = {2,1,0,0,2};
  10.     char vector1[] = "aeiou";
  11.     char *vector2[] = {"que","dia","mas","tonto","llevo"};
  12.  
  13.     inicializar_combinatoria(&comb);
  14.  
  15.     /* combinaciones sin repeticion de 5 elementos, tomados de 3 en 3 */
  16.     combinaciones(&comb,5,3);
  17.  
  18.     for(i = 0 ; i < comb.n_elementos ; i++)
  19.     {
  20.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  21.             printf("%c",vector1[comb.lista[i][j]]);
  22.  
  23.         printf("\n");
  24.     }
  25.  
  26.     printf("\n");
  27.  
  28.     for(i = 0 ; i < comb.n_elementos ; i++)
  29.     {
  30.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  31.             printf("%s ",vector2[comb.lista[i][j]]);
  32.  
  33.         printf("\n");
  34.     }
  35.  
  36.     printf("\n");
  37.  
  38.     while(getchar() != '\n');
  39.  
  40.     finalizar_combinatoria(&comb);
  41.  
  42.     inicializar_combinatoria(&comb);
  43.  
  44.     permutaciones(&comb,3);
  45.  
  46.     for(i = 0 ; i < comb.n_elementos ; i++)
  47.     {
  48.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  49.             printf("%c",vector1[comb.lista[i][j]]);
  50.  
  51.         printf("\n");
  52.     }
  53.  
  54.     printf("\n");
  55.  
  56.     for(i = 0 ; i < comb.n_elementos ; i++)
  57.     {
  58.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  59.             printf("%s ",vector2[comb.lista[i][j]]);
  60.  
  61.         printf("\n");
  62.     }
  63.  
  64.     printf("\n");
  65.  
  66.     while(getchar() != '\n');
  67.  
  68.     finalizar_combinatoria(&comb);
  69.  
  70.     inicializar_combinatoria(&comb);
  71.  
  72.     /*
  73.      * permutaciones con repeticion de 5 elementos donde 
  74.      * el prinero se repite 2 veces, el segundo 1 vez y
  75.      * el quinto 2 veces (repeticiones = {2,1,0,0,2})
  76.      */
  77.     permutaciones_repeticion(&comb,5,repeticiones);
  78.  
  79.     for(i = 0 ; i < comb.n_elementos ; i++)
  80.     {
  81.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  82.             printf("%c",vector1[comb.lista[i][j]]);
  83.  
  84.         printf("\n");
  85.     }
  86.  
  87.     printf("\n");
  88.  
  89.     for(i = 0 ; i < comb.n_elementos ; i++)
  90.     {
  91.         for(j = 0 ; j < comb.longitud_elemento ; j++)
  92.             printf("%s ",vector2[comb.lista[i][j]]);
  93.  
  94.         printf("\n");
  95.     }
  96.  
  97.     printf("\n");
  98.  
  99.     while(getchar() != '\n');
  100.  
  101.     finalizar_combinatoria(&comb);
  102.  
  103.  
  104.     return 0;
  105. }
  106.  

¡Saludos!
« Última modificación: 31 Julio 2013, 00:44 am por do-while » En línea
- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
do-while


Desconectado Desconectado

Mensajes: 1.276


¿Habra que sacarla de paseo?


Ver Perfil
Re: Librería de Snippets en C/C++
« Respuesta #23 en: 29 Julio 2013, 20:34 pm »
¡Buenas!

Aun arriesgándome a un tirón de orejas por el doble post, os deho aqui el SHA1.

La última vez que me juntaron dos posts con códigos relativamente largos, se perdio parte del código por exceder el límite de caracteres del post... por favor, EI, Littlehorse, no me unáis los posts.

sha1.h
Código
  1. #ifndef SHA1_H
  2. #define SHA1_H
  3.  
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <stdio.h>
  7.  
  8. #ifndef ULL_MAX
  9.     #define ULL_MAX 0xFFFFFFFFFFFFFFFFULL
  10. #endif
  11.  
  12. typedef unsigned long (*_funciones)(unsigned long, unsigned long, unsigned long);
  13.  
  14. char* sha1(char *input, unsigned long long len);
  15.  
  16. unsigned long long sha1_ajustar_datos(char **datos, unsigned long  long len);
  17.  
  18. unsigned long sha1_extraer_submensaje(char *m , unsigned long sub , unsigned long bloque);
  19.  
  20. #endif /* SHA1_H */
  21.  

sha1.c
Código
  1. #include "sha1.h"
  2.  
  3. #define sha1F(X,Y,Z) (((X) & (Y)) | ((~(X)) & (Z)))
  4. #define sha1G(X,Y,Z) ((X) ^ (Y) ^ (Z))
  5. #define sha1H(X,Y,Z) (((X) & (Y)) | ((X) & (Z)) | ((Y) & (Z)))
  6.  
  7. char* sha1(char *input, unsigned long long len)
  8. {
  9.     char *aux = NULL;
  10.     unsigned long long longitud, i,j;
  11.     unsigned long reg[5], aux_reg[5], K[4], bloque = 0, sub[80];
  12.     unsigned long tmp;
  13.  
  14.  
  15.     if(!(aux = malloc(len * sizeof(char))))
  16.         return NULL;
  17.  
  18.     memcpy(aux,input,len * sizeof(char));
  19.  
  20.     if(!(longitud = sha1_ajustar_datos(&aux,len)))
  21.     {
  22.         free(aux);
  23.         return NULL;
  24.     }
  25.  
  26.     reg[0] = 0x67452301;
  27.     reg[1] = 0xEFCDAB89;
  28.     reg[2] = 0x98BADCFE;
  29.     reg[3] = 0x10325476;
  30.     reg[4] = 0xC3D2E1F0;
  31.  
  32.     K[0] = 0x5A827999;
  33.     K[1] = 0x6ED9EBA1;
  34.     K[2] = 0x8F1BBCDC;
  35.     K[3] = 0xCA62C1D6;
  36.  
  37.     while(longitud)
  38.     {
  39.         memcpy(aux_reg , reg , 5 * sizeof(unsigned long));
  40.  
  41.         for(j = 0 ; j < 16 ; j++)
  42.             for(i = 0 ; i < 4 ; i++)
  43.                 memset(((char*)&sub[j]) + i, *(aux + bloque * 64 + j * 4 + 3 - i) , sizeof(char));
  44.  
  45.         for(i = 16 ; i < 80 ; i++)
  46.         {
  47.             sub[i] = sub[i - 3] ^ sub[i - 8] ^ sub[i - 14] ^ sub[i - 16];
  48.             sub[i] = sub[i] << 1 | sub[i] >> 31;
  49.         }
  50.  
  51.         for(i = 0 ; i < 20 ; i++)
  52.         {
  53.             tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1F(aux_reg[1],aux_reg[2],aux_reg[3]) +
  54.                             aux_reg[4] + sub[i] + K[0];
  55.  
  56.             aux_reg[4] = aux_reg[3];
  57.             aux_reg[3] = aux_reg[2];
  58.             aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
  59.             aux_reg[1] = aux_reg[0];
  60.             aux_reg[0] = tmp;
  61.         }
  62.  
  63.         for(i = 20 ; i < 40 ; i++)
  64.         {
  65.             tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
  66.                             aux_reg[4] + sub[i] + K[1];
  67.  
  68.             aux_reg[4] = aux_reg[3];
  69.             aux_reg[3] = aux_reg[2];
  70.             aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
  71.             aux_reg[1] = aux_reg[0];
  72.             aux_reg[0] = tmp;
  73.         }
  74.  
  75.         for(i = 40 ; i < 60 ; i++)
  76.         {
  77.             tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1H(aux_reg[1],aux_reg[2],aux_reg[3]) +
  78.                             aux_reg[4] + sub[i] + K[2];
  79.  
  80.             aux_reg[4] = aux_reg[3];
  81.             aux_reg[3] = aux_reg[2];
  82.             aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
  83.             aux_reg[1] = aux_reg[0];
  84.             aux_reg[0] = tmp;
  85.         }
  86.  
  87.         for(i = 60 ; i < 80 ; i++)
  88.         {
  89.             tmp =  ((aux_reg[0] << 5) | (aux_reg[0] >> 27)) + sha1G(aux_reg[1],aux_reg[2],aux_reg[3]) +
  90.                             aux_reg[4] + sub[i] + K[3];
  91.  
  92.             aux_reg[4] = aux_reg[3];
  93.             aux_reg[3] = aux_reg[2];
  94.             aux_reg[2] = (aux_reg[1] << 30) | (aux_reg[1] >> 2);
  95.             aux_reg[1] = aux_reg[0];
  96.             aux_reg[0] = tmp;
  97.         }
  98.  
  99.         for(i = 0 ; i < 5 ; i++)
  100.             reg[i] += aux_reg[i];
  101.  
  102.         bloque++;
  103.         longitud -= 64;
  104.     }
  105.  
  106.     free(aux);
  107.  
  108.     if(!(aux = malloc(41 * sizeof(unsigned long))))
  109.         return NULL;
  110.  
  111.     aux[0] = '\0';
  112.  
  113.     for(i = 0 ; i < 5 ; i++)
  114.         sprintf(aux,"%s%08lX",aux,reg[i]);
  115.  
  116.     return aux;
  117. }
  118.  
  119. unsigned long long sha1_ajustar_datos(char **datos, unsigned long  long len)
  120. {
  121.     unsigned long long new_len;
  122.     char *aux;
  123.     int c = 0,i;
  124.  
  125.     /* si longitud en bits es mayor que ULL_MAX */
  126.     if(len > ULL_MAX / 8)
  127.         return 0; /* devolvemos falso */
  128.  
  129.     if(64 - (len % 64) > 8)
  130.     {
  131.         if(ULL_MAX - (64 - (len % 64)) >= len)
  132.             new_len = len + (64 - (len % 64));
  133.         else
  134.             return 0;
  135.     }
  136.     else
  137.     {
  138.         if(ULL_MAX - 64 - (64 - (len % 64)) >= len)
  139.             new_len = len + 64 + (64 - (len % 64));
  140.         else
  141.             return 0;
  142.     }
  143.  
  144.     if(!(aux = (char*) realloc(*datos , new_len * sizeof(char))))
  145.         return 0;
  146.  
  147.     (*datos) = aux;
  148.  
  149.     c = 1 << 7;
  150.  
  151.     memset((*datos) + len , c , sizeof(char));
  152.     memset((*datos) + len + 1 , 0 , (new_len - len - 1) * sizeof(char));
  153.  
  154.     /* pasamos la longitud de bytes a bits */
  155.     len *= 8;
  156.  
  157.     for(i = 0 ; i < 8 ; i++)
  158.         memset((*datos) + new_len - 8 + i , ((char*)&len)[7 - i] , sizeof(char));
  159.  
  160.     return new_len;
  161. }
  162.  

¡Saludos!

El enlace para la descarga
« Última modificación: 29 Julio 2013, 20:41 pm por do-while » En línea
- Doctor, confundo los números y los colores.
- Vaya marrón.
- ¿Marrón? ¡Por el culo te la hinco!
Eternal Idol
Kernel coder
Moderador
***
Desconectado Desconectado

Mensajes: 5.958


Israel nunca torturó niños, ni lo volverá a hacer.


Ver Perfil WWW
Re: Librería de Snippets en C/C++
« Respuesta #24 en: 29 Julio 2013, 20:45 pm »
¿Y para que necesitamos tanto codigo entonces? Hay lugares especificos donde subirlos, esta claro que el foro no es para eso, ni lo soporta ...
En línea
La economía nunca ha sido libre: o la controla el Estado en beneficio del Pueblo o lo hacen los grandes consorcios en perjuicio de éste.
Juan Domingo Perón
OmarHack


Desconectado Desconectado

Mensajes: 1.268


Ver Perfil
Re: Librería de Snippets en C/C++
« Respuesta #25 en: 30 Julio 2013, 07:25 am »
Cuando tenga tiempo os dejo "algunos" cifrados que tengo en C++.
Lo subiré a sourcecode para no tumbar la página y a los que abran el tema. xDDD
Increíble el curro de todos.

PD: uso system porque total tengo que recurrir al sistema si o si. La API de windows no sirve para nada que no sea windows, así que creo que da lo mismo. System es menos código.

PD2: Pensé que sha1 era bastante más largo.

PD3: ¿Cuántos gigas tiene el server y cuantos ocupados? Tiene que ser una locura.

Yo pienso que tiene sobre 15 teras.
En línea
I like to test things.
X3R4CK3R

Desconectado Desconectado

Mensajes: 74


Divide y vencerás


Ver Perfil WWW
Re: Librería de Snippets en C/C++
« Respuesta #26 en: 30 Julio 2013, 08:21 am »
Cita de: OmarHack en 30 Julio 2013, 07:25 am
uso system porque total tengo que recurrir al sistema si o si. La API de windows no sirve para nada que no sea windows, así que creo que da lo mismo. System es menos código.

En cuanto a portablidad, claro, da lo mismo, te lo decía porque es un mal hábito llamar al sistema cuando en C++ tienes funciones para la misma tarea, más que nada porque gastas recursos innecesarios (y la diferencia es bien grande). ;)

Saludos
En línea
eferion


Desconectado Desconectado

Mensajes: 1.248


Ver Perfil
Re: Librería de Snippets en C/C++
« Respuesta #27 en: 30 Julio 2013, 10:47 am »
Cita de: ivancea96 en 26 Julio 2013, 16:30 pm
Función que devuelve true si un numero es primo :p

Quizás se pueda optimizar más, pero weno jeje

Código
  1. bool primo(unsigned int u){
  2. unsigned int i=0;
  3. if(u<2) return FALSE;   //Comprobar si es 1
  4. for (i=2; u%i!=0; i+=2) {if(i>u/2){ i=u; break;}}  //Rompera cuando se encuentre un divisor, o el 'i' sea mayor que la mitad de el numero (para ahorrar tiempo)
  5. if (u == i) return TRUE; //Si el divisor encontrado es el mismo numero, es primo
  6. else return FALSE; //Sino, no lo es
  7. }

El caso es que mirando el código había algo que no me gustaba... me decidí a probarlo y este es el resultado:

Mi codigo:

Código
  1. void main( )
  2. {
  3.   for ( unsigned int i=2;i<20;++i )
  4.   {
  5.     if ( primo( i ) )
  6.       std::cout << i << " es primo" << std::endl;
  7.   }
  8. }

El resultado:

Código:
2  es primo
3  es primo
5  es primo
7  es primo
9  es primo
11  es primo
13  es primo
15  es primo
17  es primo
19  es primo

Me da a mí que tu código necesita un repaso.

EI: juntando mensajes.

Venga vale, no solo me voy a dedicar a criticar... mi versión para los números primos:

Código
  1. bool primo(unsigned int u)
  2. {
  3.   bool to_return = true;
  4.  
  5.   if( u<2 )
  6.     to_return = false; // Comprobar si es 1
  7.   else if ( u != 2 )
  8.   {
  9.     if ( u % 2 == 0 ) // Divisible entre 2
  10.       to_return = false;
  11.     else
  12.     {
  13.       unsigned int tope = u/3;
  14.       for ( unsigned int i=3; i <= tope && to_return; i+=2 )
  15.         to_return = ( u % i != 0 );
  16.     }
  17.   }
  18.  
  19.   return to_return;
  20. }
« Última modificación: 30 Julio 2013, 12:37 pm por Eternal Idol » En línea
OmarHack


Desconectado Desconectado

Mensajes: 1.268


Ver Perfil
Re: Librería de Snippets en C/C++
« Respuesta #28 en: 2 Agosto 2013, 06:38 am »
Cita de: X3R4CK3R en 30 Julio 2013, 08:21 am
En cuanto a portablidad, claro, da lo mismo, te lo decía porque es un mal hábito llamar al sistema cuando en C++ tienes funciones para la misma tarea, más que nada porque gastas recursos innecesarios (y la diferencia es bien grande). ;)

Saludos
No creo que haya tanta diferecia, si me lo puedes demostrar las usaré :P
Gracias, voy a informarme, un saludo.
En línea
I like to test things.
X3R4CK3R

Desconectado Desconectado

Mensajes: 74


Divide y vencerás


Ver Perfil WWW
Re: Librería de Snippets en C/C++
« Respuesta #29 en: 2 Agosto 2013, 07:29 am »
Cita de: OmarHack en  2 Agosto 2013, 06:38 am
No creo que haya tanta diferecia, si me lo puedes demostrar las usaré :P
Gracias, voy a informarme, un saludo.

prueba a hacer un bucle infinito donde printeas un mensaje con printf o cout, y otro con system("echo ..."), verás que éste último te consume casi un núcleo entero de CPU.

Saludos
En línea
Páginas: 1 2 [3] 4 Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
Nanoalgoritmos, Snippets, Instrucciones, Virutas y Más
Programación General 		~ 1 2,436 Último mensaje 19 Agosto 2012, 07:19 am
por sistemx
Librería de Snippets para VB.NET !! (Compartan aquí sus snippets) « 1 2 ... 59 60 »
.NET (C#, VB.NET, ASP) 		Eleкtro 592 526,950 Último mensaje 27 Abril 2024, 03:03 am
por Eleкtro
[Snippets] javascript / CSS / HTML5
Desarrollo Web 		#!drvy 2 3,483 Último mensaje 19 Marzo 2013, 21:48 pm
por #!drvy
Librería de Snippets para Delphi « 1 2 »
Programación General 		crack81 15 21,046 Último mensaje 25 Marzo 2016, 18:39 pm
por crack81
índice de la Librería de Snippets para VB.NET !!
.NET (C#, VB.NET, ASP) 		Eleкtro 7 6,507 Último mensaje 4 Julio 2018, 21:35 pm
por Eleкtro
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines