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)
| | |-+  Problema con codigo para codificar/decodificar caracteres (SENCILLO)
0 Usuarios y 1 Visitante están viendo este tema.
Páginas: [1] Ir Abajo Respuesta Imprimir
Autor Tema: Problema con codigo para codificar/decodificar caracteres (SENCILLO)  (Leído 3,593 veces)
Erres

Desconectado Desconectado

Mensajes: 30



Ver Perfil
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!


« Última modificación: 30 Octubre 2012, 18:59 pm por Erres » En línea

En lo que sea, pero el mejor.
Stakewinner00


Desconectado Desconectado

Mensajes: 1.426



Ver Perfil WWW
Re: Problema con codigo para codificar/decodificar caracteres (SENCILLO)
« Respuesta #1 en: 30 Octubre 2012, 21:28 pm »

ahora no tengo mucho tiempo (después lo miro ya que esta interesante)
pero si se decodifica a medias puede que sea que la variable que usas llego a su tope? y no puede descodificar más?.

Si te interesa tambien cree un codificador muy simple y la teoría criptográfica no tiene mucha base pero me diverti, el sistema par cifrar es aleatorio dejo el link

http://foro.elhacker.net/programacion_cc/aporte_c-t370237.0.html


« Última modificación: 30 Octubre 2012, 21:31 pm por Stakewinner00 » En línea

Erres

Desconectado Desconectado

Mensajes: 30



Ver Perfil
Re: Problema con codigo para codificar/decodificar caracteres (SENCILLO)
« Respuesta #2 en: 30 Octubre 2012, 22:36 pm »

checare tu codigo (: se ve muy bueno y probablemente pueda aprender de tu codigo y si me das permiso "combinarlo" con el mio para poder hacer una codificacion todavia mas fuerte y cuando lo acabe compartirlo con todos (: .

si se decodifica a medias puede que sea que la variable que usas llego a su tope? y no puede descodificar más?

acabo de checar lo que comentaste ^^, gracias por la respuesta, le agrege mas texto, y si lo agarro todo y lo codifico, pero como de costumbre, le quito parte del final. (quita como 10 caracteres o 9), nose de que dependa
En línea

En lo que sea, pero el mejor.
Erres

Desconectado Desconectado

Mensajes: 30



Ver Perfil
Re: Problema con codigo para codificar/decodificar caracteres (SENCILLO)
« Respuesta #3 en: 30 Octubre 2012, 22:44 pm »

de hecho esta muy interesante el error,

prueben esto:

vallan a la funcion "void encodeNotePad()"

y vallan a donde leemos 'filePad' que es aqui:

Código
  1. fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);

si despues de eso, le agregamos que nos imprima texty... quedaria asi...

Código
  1. fread(texty, sizeof(char)||sizeof(long)||sizeof(int), 500000-1, filePad);
  2. std::cout << "texty:\n" << texty;
  3. std::cout << "done\n"; //Sign

(esto usando el ejemplo 3)
vean lo que imprime texty...
esta inesperado...

imprime todo lo que leeyo + vuelve a imprimir parte del final (increible y no entiendo porque :p)

intente arreglar eso usando este codigo:

Código
  1. while(textyLength>counterEnter)
  2. {
  3. switch(texty[counterEnter])
  4. {
  5. case '\n' : counterEnter1++;
  6. }
  7. counterEnter++;
  8. }

porque segun yo se copiaba de mas porque abian caracteres 'end of text' entonces intente por cada enter, borrar el 'end of text'

y tuvo exito, hasta que vi que quitaba parte del codigo

lo interesante es que si quitamos esto:

Código
  1. while(textyLength>counterEnter)
  2. {
  3. switch(texty[counterEnter])
  4. {
  5. case '\n' : counterEnter1++;
  6. }
  7. counterEnter++;
  8. }

en vez de quitar codigo
imprime de mas 0.o
En línea

En lo que sea, pero el mejor.
Stakewinner00


Desconectado Desconectado

Mensajes: 1.426



Ver Perfil WWW
Re: Problema con codigo para codificar/decodificar caracteres (SENCILLO)
« Respuesta #4 en: 31 Octubre 2012, 16:51 pm »

para que lea todo el contenido puedes probar el siguiente ejemplo http://www.cplusplus.com/reference/iostream/ostream/put/, puedes buscar por esa misma web que creo que hay ejemplos que te podrían servir para augmentar el numero de caracteres que lee tu programa.
En línea

Páginas: [1] Ir Arriba Respuesta Imprimir 

Ir a:  

Mensajes similares
Asunto Iniciado por Respuestas Vistas Último mensaje
[java] codigo fuente sencillo para reloj analogico
Java
strike-maXter 4 27,884 Último mensaje 25 Enero 2005, 21:30 pm
por strike-maXter
COMO DECODIFICAR CÓDIGO Hexadecimal « 1 2 3 4 »
Hacking
hkr_1900 32 50,560 Último mensaje 31 Enero 2014, 02:24 am
por jstylee89
codificar codigo interno
Programación Visual Basic
zerofive 3 890 Último mensaje 8 Noviembre 2006, 06:16 am
por zerofive
busco Un codigo muy sencillo « 1 2 »
PHP
bels_mike 18 6,067 Último mensaje 14 Octubre 2007, 11:19 am
por Alex_bro
Berta CMS, un sencillo gestor de contenido de código libre para tus páginas web
Noticias
wolfbcn 0 904 Último mensaje 25 Marzo 2012, 03:20 am
por wolfbcn
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines