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

 

 


Tema destacado:


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / Problema con codigo para codificar/decodificar caracteres (SENCILLO) en: 30 Octubre 2012, 18:35 pm
Vi que hay gente que pide mucho codigos para codificar y decodificar textos por lo que decidi hacer uno para compartirlo (SENCILLO, ya que estoy aprendiendo), pero se me presento un problema...

Primero que nada aclaro que soy nuevo en esto de C++ por lo que cualquier critica constructiva es bienvenida!
Llevo trabajando 1 mes en este codigo, no es que sea complicado, es que e hecho muchas modificaciones, le falta mucho, pasara por mas capas de encriptacion
y mas detalles claro, pero hasta ahorita va asi.

Segundo:
la letra 'ñ' se pone diferente asi que...



del codigo hay una linea que se pone asi:
case 222111121: {fputs("ñ", Answer); break;}
buscala por el numero 222111121 para que no batalles
Remplazenla por:
case 222111121: {fputs("ñ", Answer); break;}

Y una linea que se pone asi:
case 'ñ': {fputs("222111121", textyEncrypted); break;}
Remplazenla por:
case 'ñ': {fputs("222111121", textyEncrypted); break;}

No se porque se pone asi y solo es aqui en esta pagina (probablemente tengo que hacer algo para poner esa letra pero nose como, pido perdon por eso)

Planteo el problema:
Tengo entendido que hay un caracter que se llama (end of text) y cuando uso 'fread' me lee eso tambien y creo que el error en este programa esta relacionado con eso.
En el ejemplo 3: no lo cifra completamente ya que hay un error y nose como corregirlo.

Ahora comparto el codigo y despues del codigo doy ejemplos del problema y como usar el codigo y ver le problema.

Código
  1. //1. Cuando te pida los nombres acabalos con (.txt)
  2. //	 ejemplo: Si quires poner de nombre "codificado" entonces pondrias: Codificado.txt
  3.  
  4. //2. El error de alguna manera esta (segun yo) en que hay caracteres que lee
  5. //	 como el "end of text" o algo asi se llama. El que esta despues de cada enter.
  6. //	 y lo intente solucionar con lo que le llame "//Metodo Eliminar End Of File (SEGUN YO)"
  7. //	 buscalo con control+f esta hasta abajo.
  8.  
  9. #include "stdafx.h"
  10. #include <iostream>
  11. #include <iomanip>
  12.  
  13. long op();						//Menu opciones.
  14. void encodeNotePad();			//Codificar lo que este en un notepad.
  15. void decodeToNotePad();			//Decodifica y lo pone en un notepad diferente.
  16.  
  17. int main()
  18. {
  19. 		long resultado = 0;
  20. 		resultado = op();
  21. 		switch(resultado)
  22. 		{
  23. 			case 1: encodeNotePad();
  24. 				break;
  25. 			case 2: decodeToNotePad();
  26. 				break;	
  27. 			default: std::cout << "Sorry, not an option.";
  28. 				break;
  29. 		}
  30. 	system ("pause");
  31. 	return 0;
  32. }
  33.  
  34. void decodeToNotePad()
  35. {
  36. 	char NombreNotePad[20] = ".";
  37. 	char NombreNotePadFinal[20] = ".";
  38. 	char textoLeer[500000] = "Failed.";
  39. 	char textoTraductor[500000] = "Failed.";
  40. 	long counter1 = 0;
  41. 	long counter9 = 0;
  42. 	long numero = 0;
  43. 	long CharInt = 0;
  44. 	long counterLast = 0;
  45. 	long Snumber = 0;
  46. 	char espacio[] = "13";
  47. 	FILE * filePad;
  48. 	FILE * Answer;
  49.  
  50. 	//Pide el nombre del archivo que quieres codificar
  51. 	std::cout << "Name of the file to be decode\t";	std::cin >> NombreNotePad;
  52. 	//Que nombre le quieres poner al archivo que va a resultar codificado?
  53. 	std::cout << "New name for the file: \t";	std::cin >> NombreNotePadFinal;
  54.  
  55. 	//Abrimos los 2 (uno en forma de lecutra y el otro listo para escribir)
  56. 	filePad = fopen(NombreNotePad, "r");
  57. 	Answer = fopen(NombreNotePadFinal, "a+");
  58.  
  59. 	fopen (NombreNotePad, "r");
  60. 	fopen (NombreNotePadFinal, "a+");
  61.  
  62. 	rewind(filePad);
  63.  
  64. 	//Aqui leemos el texto
  65. 	fread(textoLeer, sizeof(char)|| sizeof(long), 500000-1, filePad);
  66.  
  67. 	//Se divide entre 9 porque cada 'forma de encriptacion' tiene 9 digitos
  68. 	//ejemplo: a = 211111111
  69. 	Snumber = (strlen(textoLeer))/9;
  70. 	rewind(filePad);
  71.  
  72.  
  73. 	while(counter1 < (Snumber))
  74. 	{
  75. 		//Va checando de 9 en 9
  76. 		fseek(filePad, counter9, SEEK_CUR);
  77. 		fread(textoTraductor, sizeof(char) || sizeof(long), 9, filePad);
  78. 		CharInt = atoi(textoTraductor);
  79.  
  80. 		switch(CharInt)
  81. 		{
  82. 			case 211111111: {fputs(" ", Answer); break;}
  83. 			case 222221221: {fputs("a", Answer); break;}
  84. 			case 221111111: {fputs("b", Answer); break;}
  85. 			case 111112121: {fputs("c", Answer); break;}
  86. 			case 222211111: {fputs("d", Answer); break;}
  87. 			case 222222221: {fputs("e", Answer); break;}
  88. 			case 222221111: {fputs("f", Answer); break;}
  89. 			case 222212212: {fputs("g", Answer); break;}
  90. 			case 111111222: {fputs("h", Answer); break;}
  91. 			case 222122122: {fputs("i", Answer); break;}
  92. 			case 221122111: {fputs("j", Answer); break;}
  93. 			case 111122222: {fputs("k", Answer); break;}
  94. 			case 222212122: {fputs("l", Answer); break;}
  95. 			case 122221111: {fputs("m", Answer); break;}
  96. 			case 121111111: {fputs("n", Answer); break;}
  97. 			case 221221222: {fputs("o", Answer); break;}
  98. 			case 112211221: {fputs("p", Answer); break;}
  99. 			case 111121211: {fputs("q", Answer); break;}
  100. 			case 221122222: {fputs("r", Answer); break;}
  101. 			case 222221212: {fputs("s", Answer); break;}
  102. 			case 122221222: {fputs("t", Answer); break;}
  103. 			case 222111111: {fputs("u", Answer); break;}
  104. 			case 112212111: {fputs("v", Answer); break;}
  105. 			case 111111212: {fputs("w", Answer); break;}
  106. 			case 222222121: {fputs("x", Answer); break;}
  107. 			case 111112112: {fputs("y", Answer); break;}
  108. 			case 221111121: {fputs("z", Answer); break;}
  109. 			case 112111111: {fputs("A", Answer); break;}
  110. 			case 111222221: {fputs("B", Answer); break;}
  111. 			case 122212222: {fputs("C", Answer); break;}
  112. 			case 112222111: {fputs("D", Answer); break;}
  113. 			case 212222222: {fputs("E", Answer); break;}
  114. 			case 122222221: {fputs("F", Answer); break;}
  115. 			case 111111221: {fputs("G", Answer); break;}
  116. 			case 122122221: {fputs("H", Answer); break;}
  117. 			case 121211111: {fputs("I", Answer); break;}
  118. 			case 111111122: {fputs("J", Answer); break;}
  119. 			case 121111112: {fputs("K", Answer); break;}
  120. 			case 111211111: {fputs("L", Answer); break;}
  121. 			case 211212212: {fputs("M", Answer); break;}
  122. 			case 212212222: {fputs("N", Answer); break;}
  123. 			case 122222211: {fputs("O", Answer); break;}
  124. 			case 222111221: {fputs("P", Answer); break;}
  125. 			case 122211111: {fputs("Q", Answer); break;}
  126. 			case 221212222: {fputs("R", Answer); break;}
  127. 			case 211112111: {fputs("S", Answer); break;}
  128. 			case 112211111: {fputs("T", Answer); break;}
  129. 			case 112111211: {fputs("U", Answer); break;}
  130. 			case 211111112: {fputs("V", Answer); break;}
  131. 			case 111222211: {fputs("W", Answer); break;}
  132. 			case 122222122: {fputs("X", Answer); break;}
  133. 			case 211211111: {fputs("Y", Answer); break;}
  134. 			case 111221111: {fputs("Z", Answer); break;}
  135. 			case 122111111: {fputs("0", Answer); break;}
  136. 			case 222222222: {fputs("1", Answer); break;}
  137. 			case 122122222: {fputs("2", Answer); break;}
  138. 			case 111112222: {fputs("3", Answer); break;}
  139. 			case 212122222: {fputs("4", Answer); break;}
  140. 			case 111122211: {fputs("5", Answer); break;}
  141. 			case 222221222: {fputs("6", Answer); break;}
  142. 			case 121222222: {fputs("7", Answer); break;}
  143. 			case 222122222: {fputs("8", Answer); break;}
  144. 			case 111121111: {fputs("9", Answer); break;}
  145. 			case 212221111: {fputs("{", Answer); break;}
  146. 			case 111222112: {fputs("}", Answer); break;}
  147. 			case 111212111: {fputs("(", Answer); break;}
  148. 			case 211121111: {fputs(")", Answer); break;}
  149. 			case 222121222: {fputs("<", Answer); break;}
  150. 			case 112121111: {fputs(">", Answer); break;}
  151. 			case 221122122: {fputs("|", Answer); break;}
  152. 			case 112121212: {fputs(",", Answer); break;}
  153. 			case 122222111: {fputs("/", Answer); break;}
  154. 			case 111121112: {fputs(";", Answer); break;}
  155. 			case 111222111: {fputs(":", Answer); break;}
  156. 			case 222212222: {fputs("+", Answer); break;}
  157. 			case 111122111: {fputs("-", Answer); break;}
  158. 			case 222222212: {fputs("*", Answer); break;}
  159. 			case 222222122: {fputs("@", Answer); break;}
  160. 			case 111211211: {fputs("?", Answer); break;}
  161. 			case 221222222: {fputs(".", Answer); break;}
  162. 			case 111111121: {fputs("&", Answer); break;}
  163. 			case 111112221: {fputs("$", Answer); break;}
  164. 			case 112222211: {fputs("%", Answer); break;}
  165. 			case 111112211: {fputs("!", Answer); break;}
  166. 			case 211211211: {fputs("^", Answer); break;}
  167. 			case 112221222: {fputs("\n", Answer); break;}
  168. 			case 112221211: {fputs("_", Answer); break;}
  169. 			case 112211212: {fputs("	", Answer); break;}
  170. 			case 111111211: {fputs("\"", Answer); break;}
  171. 			case 111111112: {fputs("\'", Answer); break;}
  172. 			case 222111121: {fputs("ñ", Answer); break;}
  173. 			case 212111111: {fputs("#", Answer); break;}
  174. 			case 111111111: {fputs("=", Answer); break;}
  175. 			case 121111121: {fputs("[", Answer); break;}
  176. 			case 222212121: {fputs("]", Answer); break;}
  177. 			case 222211122: {fputs("\\", Answer); break;}
  178.  
  179. 			//Si hay un caracter que no existe, pone 123456789
  180. 			default: {fputs("123456789", Answer); break;}
  181.  
  182. 		}
  183. 		counterLast++; numero++; counter1++; counter9+9;
  184. 	}
  185. 	fclose(Answer);
  186. 	fclose(filePad);	
  187. }
  188.  
  189. void encodeNotePad()
  190. {
  191. 	char NotePad[20] = ".";
  192. 	char NotePadResult[20] = ".";
  193. 	char texty[500000] = ".";
  194. 	long textyLength;
  195. 	FILE * filePad;
  196. 	FILE * textyEncrypted;
  197. 	long counter = 0;
  198. 	long counterEnter = 0;
  199. 	long counterEnter1 = 0;
  200.  
  201. 	std::cout << "Name of the file to encode: \t";	std::cin >> NotePad;
  202. 	std::cout << "Name of the new file: \t";	std::cin >> NotePadResult;
  203. 	system("cls");
  204.  
  205. 	filePad = fopen(NotePad, "r");
  206. 	std::cout << "File A:\tFile to be encoded.\n";
  207. 	std::cout << "File B:\tFile encoded.\n";
  208. 	std::cout << "\nLooking for file A...\t";	//Sign
  209. 	if(filePad)
  210. 	{	
  211. 		std::cout << "done\n";	//Sign
  212. 		rewind(filePad);
  213. 		std::cout << "Reading file A...\t";	//Sign
  214. 		fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);
  215.  
  216. 		std::cout << "done\n";	//Sign
  217.  
  218. 		textyLength = strlen(texty);
  219. 		std::cout << "\nTextLength\t" << textyLength << std::endl;
  220.  
  221. 		std::cout << "Closing file A...\t";	//Sign
  222. 		fclose(filePad);
  223. 		std::cout << "done\n";	//Sign
  224.  
  225. 		//Quita el 'text of file' despues de cada enter. (SEGUN YO AKI HAY UN ERROR)
  226. 		//Metodo Eliminar End Of File (SEGUN YO)
  227. 		while(textyLength>counterEnter)
  228. 		{
  229. 			switch(texty[counterEnter])
  230. 			{
  231. 				case '\n' : counterEnter1++;
  232. 			}
  233. 			counterEnter++;
  234. 		}
  235. 		std::cout << "\nNumeros de enter:\t" << counterEnter1 << std::endl;
  236.  
  237. 		std::cout << "\nLooking for file B...\t";
  238. 		textyEncrypted = fopen(NotePadResult, "a+");
  239. 		std::cout << "done";	//Sign
  240.  
  241. 		//Aqui restamos el numero de enter (que serian los text of end sobrantes)
  242. 		//para que solo queden los caracteres normales.
  243. 		textyLength = textyLength - counterEnter1;
  244. 		std::cout << "\nTextLength\t" << textyLength << std::endl;
  245. 		std::cout << "\nEncoding file B...\t";
  246. 		while(textyLength>counter)
  247. 		{
  248. 			switch(texty[counter])
  249. 			{
  250. 				case ' ': {fputs("211111111", textyEncrypted); break;}
  251. 				case 'a': {fputs("222221221", textyEncrypted); break;}
  252. 				case 'b': {fputs("221111111", textyEncrypted); break;}
  253. 				case 'c': {fputs("111112121", textyEncrypted); break;}
  254. 				case 'd': {fputs("222211111", textyEncrypted); break;}
  255. 				case 'e': {fputs("222222221", textyEncrypted); break;}
  256. 				case 'f': {fputs("222221111", textyEncrypted); break;}
  257. 				case 'g': {fputs("222212212", textyEncrypted); break;}
  258. 				case 'h': {fputs("111111222", textyEncrypted); break;}
  259. 				case 'i': {fputs("222122122", textyEncrypted); break;}
  260. 				case 'j': {fputs("221122111", textyEncrypted); break;}
  261. 				case 'k': {fputs("111122222", textyEncrypted); break;}
  262. 				case 'l': {fputs("222212122", textyEncrypted); break;}
  263. 				case 'm': {fputs("122221111", textyEncrypted); break;}
  264. 				case 'n': {fputs("121111111", textyEncrypted); break;}
  265. 				case 'o': {fputs("221221222", textyEncrypted); break;}
  266. 				case 'p': {fputs("112211221", textyEncrypted); break;}
  267. 				case 'q': {fputs("111121211", textyEncrypted); break;}
  268. 				case 'r': {fputs("221122222", textyEncrypted); break;}
  269. 				case 's': {fputs("222221212", textyEncrypted); break;}
  270. 				case 't': {fputs("122221222", textyEncrypted); break;}
  271. 				case 'u': {fputs("222111111", textyEncrypted); break;}
  272. 				case 'v': {fputs("112212111", textyEncrypted); break;}
  273. 				case 'w': {fputs("111111212", textyEncrypted); break;}
  274. 				case 'x': {fputs("222222121", textyEncrypted); break;}
  275. 				case 'y': {fputs("111112112", textyEncrypted); break;}
  276. 				case 'z': {fputs("221111121", textyEncrypted); break;}
  277. 				case 'A': {fputs("112111111", textyEncrypted); break;}
  278. 				case 'B': {fputs("111222221", textyEncrypted); break;}
  279. 				case 'C': {fputs("122212222", textyEncrypted); break;}
  280. 				case 'D': {fputs("112222111", textyEncrypted); break;}
  281. 				case 'E': {fputs("212222222", textyEncrypted); break;}
  282. 				case 'F': {fputs("122222221", textyEncrypted); break;}
  283. 				case 'G': {fputs("111111221", textyEncrypted); break;}
  284. 				case 'H': {fputs("122122221", textyEncrypted); break;}
  285. 				case 'I': {fputs("121211111", textyEncrypted); break;}
  286. 				case 'J': {fputs("111111122", textyEncrypted); break;}
  287. 				case 'K': {fputs("121111112", textyEncrypted); break;}
  288. 				case 'L': {fputs("111211111", textyEncrypted); break;}
  289. 				case 'M': {fputs("211212212", textyEncrypted); break;}
  290. 				case 'N': {fputs("212212222", textyEncrypted); break;}
  291. 				case 'O': {fputs("122222211", textyEncrypted); break;}
  292. 				case 'P': {fputs("222111221", textyEncrypted); break;}
  293. 				case 'Q': {fputs("122211111", textyEncrypted); break;}
  294. 				case 'R': {fputs("221212222", textyEncrypted); break;}
  295. 				case 'S': {fputs("211112111", textyEncrypted); break;}
  296. 				case 'T': {fputs("112211111", textyEncrypted); break;}
  297. 				case 'U': {fputs("112111211", textyEncrypted); break;}
  298. 				case 'V': {fputs("211111112", textyEncrypted); break;}
  299. 				case 'W': {fputs("111222211", textyEncrypted); break;}
  300. 				case 'X': {fputs("122222122", textyEncrypted); break;}
  301. 				case 'Y': {fputs("211211111", textyEncrypted); break;}
  302. 				case 'Z': {fputs("111221111", textyEncrypted); break;}
  303. 				case '#': {fputs("212111111", textyEncrypted); break;}
  304. 				case '0': {fputs("122111111", textyEncrypted); break;}
  305. 				case '1': {fputs("222222222", textyEncrypted); break;}
  306. 				case '2': {fputs("122122222", textyEncrypted); break;}
  307. 				case '3': {fputs("111112222", textyEncrypted); break;}
  308. 				case '4': {fputs("212122222", textyEncrypted); break;}
  309. 				case '5': {fputs("111122211", textyEncrypted); break;}
  310. 				case '6': {fputs("222221222", textyEncrypted); break;}
  311. 				case '7': {fputs("121222222", textyEncrypted); break;}
  312. 				case '8': {fputs("222122222", textyEncrypted); break;}
  313. 				case '9': {fputs("111121111", textyEncrypted); break;}
  314. 				case '{': {fputs("212221111", textyEncrypted); break;}
  315. 				case '}': {fputs("111222112", textyEncrypted); break;}
  316. 				case '"': {fputs("111111211", textyEncrypted); break;}
  317. 				case '=': {fputs("111111111", textyEncrypted); break;}
  318. 				case '(': {fputs("111212111", textyEncrypted); break;}
  319. 				case ')': {fputs("211121111", textyEncrypted); break;}
  320. 				case '<': {fputs("222121222", textyEncrypted); break;}
  321. 				case '>': {fputs("112121111", textyEncrypted); break;}
  322. 				case '|': {fputs("221122122", textyEncrypted); break;}
  323. 				case ',': {fputs("112121212", textyEncrypted); break;}
  324. 				case '/': {fputs("122222111", textyEncrypted); break;}
  325. 				case ';': {fputs("111121112", textyEncrypted); break;}
  326. 				case ':': {fputs("111222111", textyEncrypted); break;}
  327. 				case '+': {fputs("222212222", textyEncrypted); break;}
  328. 				case '-': {fputs("111122111", textyEncrypted); break;}
  329. 				case '*': {fputs("222222212", textyEncrypted); break;}
  330. 				case '@': {fputs("222222122", textyEncrypted); break;}
  331. 				case '?': {fputs("111211211", textyEncrypted); break;}
  332. 				case '.': {fputs("221222222", textyEncrypted); break;}
  333. 				case '&': {fputs("111111121", textyEncrypted); break;}
  334. 				case '$': {fputs("111112221", textyEncrypted); break;}
  335. 				case '%': {fputs("112222211", textyEncrypted); break;}
  336. 				case '!': {fputs("111112211", textyEncrypted); break;}
  337. 				case '^': {fputs("211211211", textyEncrypted); break;}
  338. 				case '_': {fputs("112221211", textyEncrypted); break;}
  339. 				case '\n': {fputs("112221222", textyEncrypted); break;}
  340. 				case '	': {fputs("112211212", textyEncrypted); break;}
  341. 				case '\'': {fputs("111111112", textyEncrypted); break;}
  342. 				case 'ñ': {fputs("222111121", textyEncrypted); break;}
  343. 				case '[': {fputs("121111121", textyEncrypted); break;}
  344. 				case ']': {fputs("222212121", textyEncrypted); break;}
  345. 				case '\\': {fputs("222211122", textyEncrypted); break;}
  346.  
  347. 				default: {fputs("123456789", textyEncrypted); break;}
  348. 			}
  349. 			counter++;
  350. 		}
  351. 		std::cout << "done\n";	//Sign
  352. 		std::cout << "Closing file B...\t";	//Sign
  353. 		fclose(textyEncrypted);
  354. 		std::cout << "done\n";	//Sign
  355.  
  356. 		std::cout << "\n\n\n\n*-----------------------*\n";
  357. 		std::cout << "*-----------------------*";
  358. 		std::cout << "\n\nEncryption completed\n\n";
  359. 		std::cout << "*-----------------------*\n";
  360. 		std::cout << "*-----------------------*\n\n\n\n";
  361. 	}
  362. 	else
  363. 	{
  364. 		std::cout << "Fail\n\n\n";
  365. 	}
  366. }
  367.  
  368. long op()
  369. {
  370. 	long opciones;
  371. 	std::cout << "Select an option:" << std::endl;
  372. //	std::cout << "_____________________________________\n" << std::endl;
  373. 	std::cout << "\n";
  374. 	std::cout << "1.Encode notepad\t" << std::endl;
  375. 	std::cout << "2.Decode notepad\t" << std::endl;
  376. //	std::cout << "\n_____________________________________" << std::endl;
  377. 	std::cin >> opciones;
  378. 	system("cls");
  379. 	return opciones;
  380. }

Ahora, para usarlo tenemos que crear un Bloc de notas y ponle el nombre que quieras. Vamos a empezar a probarlo.

Ejemplo 1 <Funciona bien>
Agrega este texto al bloc de notas.

Citar
ImageNet is an image dataset organized according to the WordNet hierarchy. Each meaningful concept in WordNet, possibly described by multiple words or word phrases, is called a "synonym set" or "synset". There are more than 100,000 synsets in WordNet, majority of them are nouns (80,000+). In ImageNet, we aim to provide on average 1000 images to illustrate each synset. Images of each concept are quality-controlled and human-annotated. In its completion, we hope ImageNet will offer tens of millions of cleanly sorted images for most of the concepts in...


------Para codificar------
1. Corre el programa
2. Pon la opcion '1' que es "1. Encode notepad"
3. Pon el nombre de tu archivo + .txt si mi archivo se llama "a", entonces pondre "a.txt".
4. Pon otro nombre (sera el documento cifrado). Recuerda agregarle .txt, si mi archivo se llamara "b", entonces pondre "b.txt".
5. Busca el archivo con el segundo nombre en tu carpeta donde estas corriendo este programa. (si lo abres veras que son puros numeros).

Ahora vamos a decodificarlo.
------Para decodificar------
1. Corre el programa
2. Pon la opcion '2' que es "2. Decode notepad"
3. Pon el nombre del archivo CIFRADO, en mi caso seria "b.txt".
4. Ahora ponemos el nombre de como va a quedar decodificado, yo pondre "c.txt"
5. Buscalo el archivo "c.txt" y veelo. (Es igual al enterior)


Ejemplo 2 <Funciona bien>

Ahora vamos a probar con algo mas complejo... Sigue los mismos pasos (aqui la diferencia es que si hay un caracter que no tengo registrado, nos pone 123456789) <si quieres pruebalo o saltate al siguiente, en el siguiente hay un error>

Esta vez vamos a codificar este texto:
Citar
Ahora el uso de la computadora es muy común, tanto en empresas, negocios y algunos hogares.

Pero cuando personas relacionadas con las antes mencionadas interactúan con la computadora la mayoría de las veces solo piensan que todas las computadoras son del mismo tipo.

Además que quieren tener mas información acerca de las computadoras y no saben ?los tipos de computadoras que existen? y esto es una limitante para que las personas, que interactúan con ellas, sepan acerca de la computación


Las computadoras se clasifican en súper computadoras, macro computadoras o mainframes, mini computadoras y micro computadoras o PC.

Las clasificaciones contienen un cierto tipo de computadoras con características especificas.


Supercomputadoras
Una supercomputadora es le tipo de computadora más potente y más rápido que existe en un momento dado. Estas maquinas están diseñadas para procesar enormes cantidades de información en poco tiempo y son dedicadas a una tarea especifica.

Un ejemplo de súper computadora es una computadora que se utiliza para el manejo de un grupo de maquinas ensambladoras de productos metálicos.


Ejemplo 3<Error!!>

Nota: Sigue los mismos pasos, pero ve que al final no se decodifico completamente.

Vamos a codificar el MISMO CODIGO QUE ESTAMOS USANDO, si, el codigo que estamos usando para codificar y decodificar, vas a copiarlo y pegarlo a tu bloc de notas. Osea:

copia este texto citado y pegalo en tu bloc de notas y pruebalo, al final veras que falta texto:
Citar
//1. Cuando te pida los nombres acabalos con (.txt)
//    ejemplo: Si quires poner de nombre "codificado" entonces pondrias: Codificado.txt

//2. El error de alguna manera esta (segun yo) en que hay caracteres que lee
//    como el "end of text" o algo asi se llama. El que esta despues de cada enter.
//    y lo intente solucionar con lo que le llame "//Metodo Eliminar End Of File (SEGUN YO)"
//    buscalo con control+f esta hasta abajo.

#include "stdafx.h"
#include <iostream>
#include <iomanip>

long op();                  //Menu opciones.
void encodeNotePad();         //Codificar lo que este en un notepad.
void decodeToNotePad();         //Decodifica y lo pone en un notepad diferente.

int main()
{
      long resultado = 0;
      resultado = op();
      switch(resultado)
      {
         case 1: encodeNotePad();
            break;
         case 2: decodeToNotePad();
            break;   
         default: std::cout << "Sorry, not an option.";
            break;
      }
   system ("pause");
   return 0;
}

void decodeToNotePad()
{
   char NombreNotePad[20] = ".";
   char NombreNotePadFinal[20] = ".";
   char textoLeer[500000] = "Failed.";
   char textoTraductor[500000] = "Failed.";
   long counter1 = 0;
   long counter9 = 0;
   long numero = 0;
   long CharInt = 0;
   long counterLast = 0;
   long Snumber = 0;
   char espacio[] = "13";
   FILE * filePad;
   FILE * Answer;

   //Pide el nombre del archivo que quieres codificar
   std::cout << "Name of the file to be decode\t";   std::cin >> NombreNotePad;
   //Que nombre le quieres poner al archivo que va a resultar codificado?
   std::cout << "New name for the file: \t";   std::cin >> NombreNotePadFinal;
   
   //Abrimos los 2 (uno en forma de lecutra y el otro listo para escribir)
   filePad = fopen(NombreNotePad, "r");
   Answer = fopen(NombreNotePadFinal, "a+");

   fopen (NombreNotePad, "r");
   fopen (NombreNotePadFinal, "a+");

   rewind(filePad);

   //Aqui leemos el texto
   fread(textoLeer, sizeof(char)|| sizeof(long), 500000-1, filePad);
   
   //Se divide entre 9 porque cada 'forma de encriptacion' tiene 9 digitos
   //ejemplo: a = 211111111
   Snumber = (strlen(textoLeer))/9;
   rewind(filePad);


   while(counter1 < (Snumber))
   {
      //Va checando de 9 en 9
      fseek(filePad, counter9, SEEK_CUR);
      fread(textoTraductor, sizeof(char) || sizeof(long), 9, filePad);
      CharInt = atoi(textoTraductor);

      switch(CharInt)
      {
         case 211111111: {fputs(" ", Answer); break;}
         case 222221221: {fputs("a", Answer); break;}
         case 221111111: {fputs("b", Answer); break;}
         case 111112121: {fputs("c", Answer); break;}
         case 222211111: {fputs("d", Answer); break;}
         case 222222221: {fputs("e", Answer); break;}
         case 222221111: {fputs("f", Answer); break;}
         case 222212212: {fputs("g", Answer); break;}
         case 111111222: {fputs("h", Answer); break;}
         case 222122122: {fputs("i", Answer); break;}
         case 221122111: {fputs("j", Answer); break;}
         case 111122222: {fputs("k", Answer); break;}
         case 222212122: {fputs("l", Answer); break;}
         case 122221111: {fputs("m", Answer); break;}
         case 121111111: {fputs("n", Answer); break;}
         case 221221222: {fputs("o", Answer); break;}
         case 112211221: {fputs("p", Answer); break;}
         case 111121211: {fputs("q", Answer); break;}
         case 221122222: {fputs("r", Answer); break;}
         case 222221212: {fputs("s", Answer); break;}
         case 122221222: {fputs("t", Answer); break;}
         case 222111111: {fputs("u", Answer); break;}
         case 112212111: {fputs("v", Answer); break;}
         case 111111212: {fputs("w", Answer); break;}
         case 222222121: {fputs("x", Answer); break;}
         case 111112112: {fputs("y", Answer); break;}
         case 221111121: {fputs("z", Answer); break;}
         case 112111111: {fputs("A", Answer); break;}
         case 111222221: {fputs("B", Answer); break;}
         case 122212222: {fputs("C", Answer); break;}
         case 112222111: {fputs("D", Answer); break;}
         case 212222222: {fputs("E", Answer); break;}
         case 122222221: {fputs("F", Answer); break;}
         case 111111221: {fputs("G", Answer); break;}
         case 122122221: {fputs("H", Answer); break;}
         case 121211111: {fputs("I", Answer); break;}
         case 111111122: {fputs("J", Answer); break;}
         case 121111112: {fputs("K", Answer); break;}
         case 111211111: {fputs("L", Answer); break;}
         case 211212212: {fputs("M", Answer); break;}
         case 212212222: {fputs("N", Answer); break;}
         case 122222211: {fputs("O", Answer); break;}
         case 222111221: {fputs("P", Answer); break;}
         case 122211111: {fputs("Q", Answer); break;}
         case 221212222: {fputs("R", Answer); break;}
         case 211112111: {fputs("S", Answer); break;}
         case 112211111: {fputs("T", Answer); break;}
         case 112111211: {fputs("U", Answer); break;}
         case 211111112: {fputs("V", Answer); break;}
         case 111222211: {fputs("W", Answer); break;}
         case 122222122: {fputs("X", Answer); break;}
         case 211211111: {fputs("Y", Answer); break;}
         case 111221111: {fputs("Z", Answer); break;}
         case 122111111: {fputs("0", Answer); break;}
         case 222222222: {fputs("1", Answer); break;}
         case 122122222: {fputs("2", Answer); break;}
         case 111112222: {fputs("3", Answer); break;}
         case 212122222: {fputs("4", Answer); break;}
         case 111122211: {fputs("5", Answer); break;}
         case 222221222: {fputs("6", Answer); break;}
         case 121222222: {fputs("7", Answer); break;}
         case 222122222: {fputs("8", Answer); break;}
         case 111121111: {fputs("9", Answer); break;}
         case 212221111: {fputs("{", Answer); break;}
         case 111222112: {fputs("}", Answer); break;}
         case 111212111: {fputs("(", Answer); break;}
         case 211121111: {fputs(")", Answer); break;}
         case 222121222: {fputs("<", Answer); break;}
         case 112121111: {fputs(">", Answer); break;}
         case 221122122: {fputs("|", Answer); break;}
         case 112121212: {fputs(",", Answer); break;}
         case 122222111: {fputs("/", Answer); break;}
         case 111121112: {fputs(";", Answer); break;}
         case 111222111: {fputs(":", Answer); break;}
         case 222212222: {fputs("+", Answer); break;}
         case 111122111: {fputs("-", Answer); break;}
         case 222222212: {fputs("*", Answer); break;}
         case 222222122: {fputs("@", Answer); break;}
         case 111211211: {fputs("?", Answer); break;}
         case 221222222: {fputs(".", Answer); break;}
         case 111111121: {fputs("&", Answer); break;}
         case 111112221: {fputs("$", Answer); break;}
         case 112222211: {fputs("%", Answer); break;}
         case 111112211: {fputs("!", Answer); break;}
         case 211211211: {fputs("^", Answer); break;}
         case 112221222: {fputs("\n", Answer); break;}
         case 112221211: {fputs("_", Answer); break;}
         case 112211212: {fputs("   ", Answer); break;}
         case 111111211: {fputs("\"", Answer); break;}
         case 111111112: {fputs("\'", Answer); break;}
         case 222111121: {fputs("ñ", Answer); break;}
         case 212111111: {fputs("#", Answer); break;}
         case 111111111: {fputs("=", Answer); break;}
         case 121111121: {fputs("[", Answer); break;}
         case 222212121: {fputs("]", Answer); break;}
         case 222211122: {fputs("\\", Answer); break;}

         //Si hay un caracter que no existe, pone 123456789
         default: {fputs("123456789", Answer); break;}

      }
      counterLast++; numero++; counter1++; counter9+9;
   }
   fclose(Answer);
   fclose(filePad);   
}

void encodeNotePad()
{
   char NotePad[20] = ".";
   char NotePadResult[20] = ".";
   char texty[500000] = ".";
   long textyLength;
   FILE * filePad;
   FILE * textyEncrypted;
   long counter = 0;
   long counterEnter = 0;
   long counterEnter1 = 0;

   std::cout << "Name of the file to encode: \t";   std::cin >> NotePad;
   std::cout << "Name of the new file: \t";   std::cin >> NotePadResult;
   system("cls");
      
   filePad = fopen(NotePad, "r");
   std::cout << "File A:\tFile to be encoded.\n";
   std::cout << "File B:\tFile encoded.\n";
   std::cout << "\nLooking for file A...\t";   //Sign
   if(filePad)
   {   
      std::cout << "done\n";   //Sign
      rewind(filePad);
      std::cout << "Reading file A...\t";   //Sign
      fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);
      
      std::cout << "done\n";   //Sign
      
      textyLength = strlen(texty);
      std::cout << "\nTextLength\t" << textyLength << std::endl;

      std::cout << "Closing file A...\t";   //Sign
      fclose(filePad);
      std::cout << "done\n";   //Sign

      //Quita el 'text of file' despues de cada enter. (SEGUN YO AKI HAY UN ERROR)
      //Metodo Eliminar End Of File (SEGUN YO)
      while(textyLength>counterEnter)
      {
         switch(texty[counterEnter])
         {
            case '\n' : counterEnter1++;
         }
         counterEnter++;
      }
      std::cout << "\nNumeros de enter:\t" << counterEnter1 << std::endl;
      
      std::cout << "\nLooking for file B...\t";
      textyEncrypted = fopen(NotePadResult, "a+");
      std::cout << "done";   //Sign

      //Aqui restamos el numero de enter (que serian los text of end sobrantes)
      //para que solo queden los caracteres normales.
      textyLength = textyLength - counterEnter1;
      std::cout << "\nTextLength\t" << textyLength << std::endl;
      std::cout << "\nEncoding file B...\t";
      while(textyLength>counter)
      {
         switch(texty[counter])
         {
            case ' ': {fputs("211111111", textyEncrypted); break;}
            case 'a': {fputs("222221221", textyEncrypted); break;}
            case 'b': {fputs("221111111", textyEncrypted); break;}
            case 'c': {fputs("111112121", textyEncrypted); break;}
            case 'd': {fputs("222211111", textyEncrypted); break;}
            case 'e': {fputs("222222221", textyEncrypted); break;}
            case 'f': {fputs("222221111", textyEncrypted); break;}
            case 'g': {fputs("222212212", textyEncrypted); break;}
            case 'h': {fputs("111111222", textyEncrypted); break;}
            case 'i': {fputs("222122122", textyEncrypted); break;}
            case 'j': {fputs("221122111", textyEncrypted); break;}
            case 'k': {fputs("111122222", textyEncrypted); break;}
            case 'l': {fputs("222212122", textyEncrypted); break;}
            case 'm': {fputs("122221111", textyEncrypted); break;}
            case 'n': {fputs("121111111", textyEncrypted); break;}
            case 'o': {fputs("221221222", textyEncrypted); break;}
            case 'p': {fputs("112211221", textyEncrypted); break;}
            case 'q': {fputs("111121211", textyEncrypted); break;}
            case 'r': {fputs("221122222", textyEncrypted); break;}
            case 's': {fputs("222221212", textyEncrypted); break;}
            case 't': {fputs("122221222", textyEncrypted); break;}
            case 'u': {fputs("222111111", textyEncrypted); break;}
            case 'v': {fputs("112212111", textyEncrypted); break;}
            case 'w': {fputs("111111212", textyEncrypted); break;}
            case 'x': {fputs("222222121", textyEncrypted); break;}
            case 'y': {fputs("111112112", textyEncrypted); break;}
            case 'z': {fputs("221111121", textyEncrypted); break;}
            case 'A': {fputs("112111111", textyEncrypted); break;}
            case 'B': {fputs("111222221", textyEncrypted); break;}
            case 'C': {fputs("122212222", textyEncrypted); break;}
            case 'D': {fputs("112222111", textyEncrypted); break;}
            case 'E': {fputs("212222222", textyEncrypted); break;}
            case 'F': {fputs("122222221", textyEncrypted); break;}
            case 'G': {fputs("111111221", textyEncrypted); break;}
            case 'H': {fputs("122122221", textyEncrypted); break;}
            case 'I': {fputs("121211111", textyEncrypted); break;}
            case 'J': {fputs("111111122", textyEncrypted); break;}
            case 'K': {fputs("121111112", textyEncrypted); break;}
            case 'L': {fputs("111211111", textyEncrypted); break;}
            case 'M': {fputs("211212212", textyEncrypted); break;}
            case 'N': {fputs("212212222", textyEncrypted); break;}
            case 'O': {fputs("122222211", textyEncrypted); break;}
            case 'P': {fputs("222111221", textyEncrypted); break;}
            case 'Q': {fputs("122211111", textyEncrypted); break;}
            case 'R': {fputs("221212222", textyEncrypted); break;}
            case 'S': {fputs("211112111", textyEncrypted); break;}
            case 'T': {fputs("112211111", textyEncrypted); break;}
            case 'U': {fputs("112111211", textyEncrypted); break;}
            case 'V': {fputs("211111112", textyEncrypted); break;}
            case 'W': {fputs("111222211", textyEncrypted); break;}
            case 'X': {fputs("122222122", textyEncrypted); break;}
            case 'Y': {fputs("211211111", textyEncrypted); break;}
            case 'Z': {fputs("111221111", textyEncrypted); break;}
            case '#': {fputs("212111111", textyEncrypted); break;}
            case '0': {fputs("122111111", textyEncrypted); break;}
            case '1': {fputs("222222222", textyEncrypted); break;}
            case '2': {fputs("122122222", textyEncrypted); break;}
            case '3': {fputs("111112222", textyEncrypted); break;}
            case '4': {fputs("212122222", textyEncrypted); break;}
            case '5': {fputs("111122211", textyEncrypted); break;}
            case '6': {fputs("222221222", textyEncrypted); break;}
            case '7': {fputs("121222222", textyEncrypted); break;}
            case '8': {fputs("222122222", textyEncrypted); break;}
            case '9': {fputs("111121111", textyEncrypted); break;}
            case '{': {fputs("212221111", textyEncrypted); break;}
            case '}': {fputs("111222112", textyEncrypted); break;}
            case '"': {fputs("111111211", textyEncrypted); break;}
            case '=': {fputs("111111111", textyEncrypted); break;}
            case '(': {fputs("111212111", textyEncrypted); break;}
            case ')': {fputs("211121111", textyEncrypted); break;}
            case '<': {fputs("222121222", textyEncrypted); break;}
            case '>': {fputs("112121111", textyEncrypted); break;}
            case '|': {fputs("221122122", textyEncrypted); break;}
            case ',': {fputs("112121212", textyEncrypted); break;}
            case '/': {fputs("122222111", textyEncrypted); break;}
            case ';': {fputs("111121112", textyEncrypted); break;}
            case ':': {fputs("111222111", textyEncrypted); break;}
            case '+': {fputs("222212222", textyEncrypted); break;}
            case '-': {fputs("111122111", textyEncrypted); break;}
            case '*': {fputs("222222212", textyEncrypted); break;}
            case '@': {fputs("222222122", textyEncrypted); break;}
            case '?': {fputs("111211211", textyEncrypted); break;}
            case '.': {fputs("221222222", textyEncrypted); break;}
            case '&': {fputs("111111121", textyEncrypted); break;}
            case '$': {fputs("111112221", textyEncrypted); break;}
            case '%': {fputs("112222211", textyEncrypted); break;}
            case '!': {fputs("111112211", textyEncrypted); break;}
            case '^': {fputs("211211211", textyEncrypted); break;}
            case '_': {fputs("112221211", textyEncrypted); break;}
            case '\n': {fputs("112221222", textyEncrypted); break;}
            case '   ': {fputs("112211212", textyEncrypted); break;}
            case '\'': {fputs("111111112", textyEncrypted); break;}
            case 'ñ': {fputs("222111121", textyEncrypted); break;}
            case '[': {fputs("121111121", textyEncrypted); break;}
            case ']': {fputs("222212121", textyEncrypted); break;}
            case '\\': {fputs("222211122", textyEncrypted); break;}
                               
            default: {fputs("123456789", textyEncrypted); break;}
         }
         counter++;
      }
      std::cout << "done\n";   //Sign
      std::cout << "Closing file B...\t";   //Sign
      fclose(textyEncrypted);
      std::cout << "done\n";   //Sign
      
      std::cout << "\n\n\n\n*-----------------------*\n";
      std::cout << "*-----------------------*";
      std::cout << "\n\nEncryption completed\n\n";
      std::cout << "*-----------------------*\n";
      std::cout << "*-----------------------*\n\n\n\n";
   }
   else
   {
      std::cout << "Fail\n\n\n";
   }
}

long op()
{
   long opciones;
   std::cout << "Select an option:" << std::endl;
//   std::cout << "_____________________________________\n" << std::endl;
   std::cout << "\n";
   std::cout << "1.Encode notepad\t" << std::endl;
   std::cout << "2.Decode notepad\t" << std::endl;
//   std::cout << "\n_____________________________________" << std::endl;
   std::cin >> opciones;
   system("cls");
   return opciones;
}


y como podemos ver, se decodifica incompletamente.
Alguien sabe porque?, Gracias!
2  Programación / Programación C/C++ / Auto-eliminarse un ejecutable o bloquearlo, es posible? en: 27 Octubre 2012, 03:14 am
Si por ejemplo, un ejecutable te pide una contraseña y fallas 3 veces,
que el programa automaticamente se elimine o no se pueda volver a
ejecutar.

Esto es posible?
Como?

Gracias! (:
3  Programación / Programación C/C++ / Error con funciones (Solucionado, gracias!) en: 12 Octubre 2012, 06:12 am
Hola, hay un error en funciones y no logro encontrarlo, primero que nada quiero que sepan que soy nuevo en esto de usar funciones, siempre eh hecho completamente mi programa en main y ahora estoy empezando a usar funciones.

Este codigo si corre bien, pero a la hora de poner la opcion 1, entra a la funcion "encode" y en la funcion encode, se supone que debe de preguntar el texto que se va a codificar, pero en vez de preguntarlo se lo brinca completamente.

Cabe aclarar que si lo pongo todo en main y no uso las funciones, si hace lo que tiene que hacer, pero en algun lado me equivoque con las funciones y simplemente se salta todo.

agradezco mucho la ayuda! (:

Código:
#include "stdafx.h"
#include <iostream>
#include <iomanip>

void encode();
int op(int);

int main()
{
	int opciones, resultado;

	opciones = 0;
	resultado = op(opciones);

	switch(resultado)
	{
		case 1: encode();
		break;
		default: std::cout << "nada!";
	}

	system ("pause");
	return 0;
}

int op(int opciones)
{
	std::cout << "Select an option:\n1.Encode\n";
	std::cin >> opciones;
	system("cls");
	return opciones;
}

void encode()
{
	int counter = 0;
	FILE * filePad;
	int lengthText = 0;
	char text[50000];

	filePad = fopen("TextEncrypted.txt", "a+");
	std::cout << "Text:\n";
	std::cin.getline(text, 50000);
}
4  Programación / Programación C/C++ / como imprimir valores que tengan zeros al principio en: 8 Octubre 2012, 05:40 am
Voy a poner un ejemplo antes de explicar:

Código:
#include "stdafx.h"
#include <iostream>
using namespace std;

int main()
{
	int numero = 0000001;
	cout << "numero: " << numero << endl;
	system("pause");
	return 0;
}

En este caso estoy usando la variable int, ocupo que me imprima el numero "0000001", pero me imprime el numero "1" nadamas. Que tengo que hacer/cambiar para que me imprima los zeros que tengo antes. Gracias!
5  Programación / Programación C/C++ / fread o alguna funcion para leer un bloc de notas en: 5 Octubre 2012, 14:26 pm
Hola tengo una duda de como funciona fread.

size_t fread ( void * ptr, size_t size, size_t count, FILE * stream );

lo que quiero hacer es leer un bloc de notas, pero nose que poner en las 2 del medio.
ejemplo:


char texto[100];
FILE * pFile;

fread(texto, *, *, pFile);


donde puse los "*" (asteriscos), ahi ¿que numeros van?, o ¿de que depende el numero que voy a poner ahi?, o ¿que significa "size_t size, size_t count"?;

o alguna otra manera de leer un bloc de notas?

gracias!
6  Seguridad Informática / Análisis y Diseño de Malware / Troyano (dudas) en: 2 Octubre 2012, 05:50 am
Hola, tengo una duda acerca de un 'troyano' que quiero hacer para aprender y poder compartirlo para que las demas personas que quieren hacer algo similar, puedan tenerlo y aprender de el.

Quiero hacer un programa para poder ver la pantalla de alguna otra computadora.

1 ¿Que programas me recomiendan usar? Porque?
2 ¿Que tan complejo es hacer esto?
3 ¿Conocen algun tutorial que me enseñe hacer esto?

Gracias!
7  Programación / Programación C/C++ / Es posible hacer esto? en: 27 Septiembre 2012, 06:55 am
Hola, agradezco a todos los que pasen por aquí.

Actualmente acabo de empezar a estudiar Desarrollo de Aplicaciones Computacionales y quiero saber que tanto “alcance” tiene C++.

Por alcance me refiero a si puede hacer ciertas cosas de las que tengo duda. Es posible hacer un programa en C++ que haga lo siguiente:

 :huh:Primer programa: :huh:
1.1 Tome foto a la pantalla si haces un clic 1.2 Pegue la foto en paint o en algún programa 1.3 Guarde la foto 1.4 Le ponga un “x” nombre y la foto siguiente tendría “x+1” etc. Esto se puede hacer en C++?

 :huh:Segundo programa: :huh:
2.1 Que abra por ejemplo una página de internet y recolecte información de esa página y la acomode en algún lado? Por ejemplo:

Entren a http://www.tibia.com/community/?subtopic=characters y escriban “Wobz”. El programa lo que aria es copiar esa información, ordenarla  y pasarlo a un Excel de forma ordenada (por ordenada me refiero por ejemplo una columna que diga “Character” y este el nombre de los monos, otra columna que diga “Level” y estén los niveles). Es esto posible en C++?

Gracias por responder acerca de si esto es posible o no. Aclaro que todo lo que quiero saber es si esto se puede hacer usando C++ o no se puede hacer. Gracias!
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines