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

 

 


Tema destacado: Introducción a la Factorización De Semiprimos (RSA)


  Mostrar Temas
Páginas: [1]
1  Programación / Programación C/C++ / Instruccion sscanf [C] en: 26 Febrero 2013, 18:57 pm
Que tal, tengo una duda, estaba viendo un programa y tiene una comparacion muy rara (bueno para mi que soy nuevo en esto) miren

Código
  1. if (sscanf(q,"R%dC%d", &r,&c)==2)
  2.  

por que compara la instruccion sscanf con un 2?

Y en esta otra:

Código
  1. scanf("%d\n", &n);
  2.  

Por que pone un salto de linea despues del especificador de conversion?
2  Programación / Programación C/C++ / [C] Paso de arreglos bidimensionales a funciones. (?) en: 19 Febrero 2013, 17:29 pm
Hola que tal. Lo que pasa es que en este codigo:
Código
  1. /*Asignacion de valores en arreglos bidimensionales*/
  2. #include <stdio.h>
  3.  
  4. /*Prototipos de funciones*/
  5. void imprimir_arreglo( const int a[2][3] );
  6.  
  7. /*Inicia la ejecucion del programa*/
  8. int main()
  9. {
  10.  int arreglo1[2][3] = { { 1, 2, 3 },
  11.                         { 4, 5, 6 } };                        
  12.  int arreglo2[2][3] = { 1, 2, 3, 4, 5 };
  13.  int arreglo3[2][3] = { { 1, 2 }, { 4 } };
  14.  
  15.  printf( "Los valores en el arreglo 1 de 2 filas y 3 columnas son:\n" );
  16.  imprimir_arreglo( arreglo1 );
  17.  
  18.  printf( "Los valores en el arreglo 2 de 2 filas y 3 columnas son:\n" );
  19.  imprimir_arreglo( arreglo2 );
  20.  
  21.  printf( "Los valores en el arreglo 3 de 2 filas y 3 columnas son:\n" );
  22.  imprimir_arreglo( arreglo3 );
  23.  
  24.  return 0;
  25. }  /*Fin de main*/
  26.  
  27. /*Definiciones de funciones*/
  28. void imprimir_arreglo( const int a[2][3] )
  29. {
  30.  int i;  /*Contador filas*/
  31.  int j;  /*Contador columnas*/
  32.  
  33.  for (i = 0; i <=1; i++)
  34.  {
  35.    for (j = 0; j <= 2; j++)
  36.    {
  37.      printf( "%d ", a[i][j] );
  38.    }
  39.  
  40.    printf( "\n" );
  41.  }
  42. } /*Fin de funcion imprime_arreglo*/
  43.  

Cuando compilo de esa manera me da estos errores mi compilador:
Citar
ArreglosBidimensionales.c: In function ‘main’:
ArreglosBidimensionales.c:16:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’
ArreglosBidimensionales.c:19:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’
ArreglosBidimensionales.c:22:3: warning: passing argument 1 of ‘imprimir_arreglo’ from incompatible pointer type [enabled by default]
ArreglosBidimensionales.c:5:6: note: expected ‘const int (*)[3]’ but argument is of type ‘int (*)[3]’

Pero cuando compilo quitandole el calificador de tipo const al prototipo y definicion de funciones es decir asi:
Código
  1. /*Prototipos de funciones*/
  2. void imprimir_arreglo( int a[2][3] );
  3.  
  4. .......
  5.  
  6. /*Definiciones de funciones*/
  7. void imprimir_arreglo( int a[2][3] )
  8. {
  9.  
Si puedo compilar correctamente.

Por que pasa eso? Por que en arreglos unidimensionales si puedo compilar con el calificador const y en los bidimensionales no? Alguien me puede ayudar con esta duda?
Por cierto uso el compilador GNU GCC.
Agradecimientos por adelantado.
3  Programación / Programación C/C++ / Cual es la mejor manera para validar una entrada? en: 14 Febrero 2013, 18:05 pm
Hola que tal! Vengo con otra pequeña duda. Solamente quisiera saber cual de los siguientes bloques de código es el mas apropiado u optimizado para leer dígitos y validarlos:

Este:
Código
  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5. int a;
  6.  
  7. scanf( "%d", &a );
  8.  
  9. while ( a > 5 )
  10. {
  11. printf( "El numero debe ser menor a 5, ingresa otro: " );
  12. scanf( "%d", &a );
  13. }
  14.  
  15. printf( "Correcto!" );
  16.  
  17. return 0;
  18. }
  19.  

O este:
Código
  1. #include <stdio.h>
  2.  
  3. int main()
  4. {
  5. int a;
  6.  
  7. do
  8. {
  9. scanf( "%d", &a );
  10.  
  11. if ( a > 5 )
  12. printf( "El numero debe ser menor a 5, ingresa otro: " );
  13. } while ( a > 5 );
  14.  
  15. printf( "Correcto!" );
  16.  
  17. return 0;
  18. }
  19.  
4  Programación / Programación C/C++ / Programa de Educacion Asistida por Computadora en C. en: 11 Febrero 2013, 03:50 am
Hola de nuevo, pues ahora hice un programa para practicar las operaciones aritméticas básicas (suma, resta, multiplicación y división). Solamente me gustaría su opinión sobre el mismo, es decir, que les parece la estructura del código. Hice un programa anteriormente (distinto a este) y me hicieron la recomendación de no comentar tanto el código por que se veia muy adornado y pues puse en practica ese consejo, esta comentado pero solo lo necesario. Me gustaría saber en que aspectos podría mejorar mi programa, me refiero a la estructura del código, hago este tipo de preguntas por que quiero aprender a programar limpiamente y hacer que mi código sea fácil de comprender. Agradecimientos por adelantado.

Código
  1. /* Este programa sirve para practicar sumas, restas, multiplicaciones y divisiones */
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <time.h>
  5.  
  6. /* Prototipos de funciones */
  7. float generarNumero( int nivelDificultad );
  8. float operacion( float numero1, float numero2, int operacionElegida );
  9. void respuestaCorrecta( void );
  10. void respuestaIncorrecta( void );
  11. void impresionTipoDeOperacion( int tipoDeOperacion );
  12.  
  13. /* Inicia la ejecucion del programa */
  14. int main()
  15. {
  16. int i, correcta, nivel, operando, operando2;
  17. float num1, num2, resultado, intento;
  18. correcta = 0;
  19.  
  20. srand( time( NULL ) ); /* Modificacion de la semilla de los numeros pseudoaleatorios */
  21.  
  22. printf( "Bienvenido al sistema de aprendizaje asistido por computadora, se te preguntaran\n" );
  23. printf( "10 operaciones y luego se te mencionara si necesitas ayuda tutorial.\n" );
  24.  
  25. printf( "Por favor ingresa el nivel que quieres practicar ( 1 al 3 )..." );
  26.  
  27. do {
  28. scanf( "%d", &nivel );
  29.  
  30. if ( nivel < 1 || nivel > 3 ) {
  31. printf( "Nivel no valido, intenta otravez..." );
  32. }
  33. } while ( nivel < 1 || nivel > 3 );
  34.  
  35. printf( "Que tipo de operaciones quiere resolver:\n" );
  36. printf( "1. Sumas\n2. Restas\n3. Multiplicaciones\n4. Divisiones\n" );
  37. printf( "5. Operaciones Aleatorias\n" );
  38. printf( "Recuerda que no es obligatorio hacer las operaciones mentalmente, puedes\n" );
  39. printf( "apoyarte de lapiz y papel para realizarlas. ATENCION! No se permite el\n" );
  40. printf( "uso de calculadora.\n..." );
  41.  
  42. do {
  43. scanf( "%d", &operando );
  44.  
  45. if ( operando < 1 || operando > 5 ) {
  46. printf( "Opcion no valida, intenta de nuevo..." );
  47. }
  48. } while ( operando < 1 || operando > 5 );
  49.  
  50. operando2 = operando; /* Esta variable guarda el valor de operando, esto es para tener intacta nuestra variable y modificar la copia */
  51.  
  52. for ( i = 1; i <= 10; i++ ) {
  53. /* Llamamos a las funciones generadoras de numeros aleatorios */
  54. num1 = generarNumero( nivel );
  55. num2 = generarNumero( nivel );
  56.  
  57. if ( operando == 5 ) { /* Y por este motivo es por el que debemos mantener intacta nuestra variable operando */
  58. operando2 = 1 + rand() % 4; /* Genera una operacion aleatoria */
  59. }
  60.  
  61. resultado = operacion( num1, num2, operando2 ); /* Llamamos a la funcion que resuelve la operacion elegida ( o generada ) */
  62.  
  63. printf( "Cuanto es %.0f ", num1 );
  64. impresionTipoDeOperacion( operando2 );
  65. printf( " %.0f?...", num2 );
  66.  
  67. do {
  68. scanf( "%f", &intento );
  69.  
  70. if ( intento != resultado ) {
  71. respuestaIncorrecta(); /* Llamada a la funcion que genera los mensajes aleatorios cuando se responde incorrectamente */
  72. correcta--; /* Se decrementa en uno cada vez que se ingresa una respuesta correcta */
  73. }
  74. } while ( intento != resultado );
  75.  
  76. /* Cuando se ingresa la respuesta correcta, se llama a a funcion que genera el mensaje aleatorio y se incrementa correcta */
  77. respuestaCorrecta();
  78. correcta++;
  79.  
  80. } /* Fin de for */
  81.  
  82. if ( correcta < 7 ) { /* Si hubo mas de 3 respuestas incorrectas, se imprime este mensaje */
  83. printf( "Cometiste varios errores, por favor pide ayuda adicional a tu profesor. Hasta la proxima!\n" );
  84. }
  85.  
  86. return 0;
  87. } /* Fin de main */
  88.  
  89. /* Definicion de funciones */
  90. float generarNumero( int nivelDificultad )
  91. {
  92. switch ( nivelDificultad ) { /* Para generar numeros de 1, 2 y 3 digitos en los niveles 1, 2 y 3 respectivamente */
  93. case 1:
  94. return 1 + rand() % 9;
  95. break;
  96.  
  97. case 2:
  98. return 10 + rand() % 90;
  99. break;
  100.  
  101. case 3:
  102. return 100 + rand() % 900;
  103. break;
  104. } /* Fin de switch */
  105. } /* Fin de funcion generaNumero */
  106.  
  107. float operacion( float numero1, float numero2, int operacionElegida )
  108. {
  109. switch ( operacionElegida ) { /* Para la resolucion de nuestra operacion, esto es para compararlo posteriormente con la respuesta del
  110. user*/
  111. case 1:
  112. return numero1 + numero2;
  113. break;
  114.  
  115. case 2:
  116. return numero1 - numero2;
  117. break;
  118.  
  119. case 3:
  120. return numero1 * numero2;
  121. break;
  122.  
  123. case 4:
  124. return numero1 / numero2;
  125. break;
  126. }
  127. } /* Fin de funcion operacion */
  128.  
  129. void respuestaCorrecta( void )
  130. {
  131. switch ( 1 + rand() % 4 ) {
  132. case 1:
  133. printf( "Muy bien!!\n" );
  134. break;
  135.  
  136. case 2:
  137. printf( "Excelente!!\n" );
  138. break;
  139.  
  140. case 3:
  141. printf( "Manten ese buen rendimiento!!\n" );
  142. break;
  143.  
  144. case 4:
  145. printf( "Buen trabajo!!\n" );
  146. break;
  147. } /* Fin de switch */
  148. } /* Fin de funcion respuestaCorrecta */
  149.  
  150. void respuestaIncorrecta( void )
  151. {
  152. switch ( 1 + rand() % 4 ) {
  153. case 1:
  154. printf( "No. Por favor intenta de nuevo...\n" );
  155. break;
  156.  
  157. case 2:
  158. printf( "Incorrecto. Trata una vez mas\n" );
  159. break;
  160.  
  161. case 3:
  162. printf( "No te rindas!!\n" );
  163. break;
  164.  
  165. case 4:
  166. printf( "No. Sigue intentando\n" );
  167. break;
  168. } /* Fin de switch */
  169. } /* Fin de funcion respuestaIncorrecta */
  170.  
  171. void impresionTipoDeOperacion( int tipoDeOperacion )
  172. {
  173. switch ( tipoDeOperacion ) {
  174. case 1:
  175. printf( "mas" );
  176. break;
  177.  
  178. case 2:
  179. printf( "menos" );
  180. break;
  181.  
  182. case 3:
  183. printf( "por" );
  184. break;
  185.  
  186. case 4:
  187. printf( "entre" );
  188. break;
  189. }
  190. } /* Fin de funcion impresionTipoDeOperacion */
5  Programación / Programación C/C++ / Optimizacion de codigo en C. en: 10 Febrero 2013, 01:58 am
Hola que tal. Es mi primer tema aqui en la pagina de elhacker.net, y pues solo me gustaria una pequeña ayuda en un programa que elabore. Este programa imprime los factoriales de los numeros del 0 hasta el 10 con sus respectivas llamadas recursivas, es decir imprime las llamadas recursivas que se hacen en cada factorial agregandoles un salto de linea y un nivel de sangrado. El punto es que tengo dudas respecto a la estructura de mi codigo, es decir, quisiera saber si lo elabore con la optimizacion de codigo correcta o si aun se puede optimizar mas. Con optimizacion de codigo me refiero a que si esta correctamente estructurado y en cualquier respuesta, si se puede estructurar mas.

Código
  1. /* Se despliegan los factoriales de los numeros del 0 al 10, se utiliza la recursividad para calcularlos */
  2. #include <stdio.h>
  3.  
  4. /* Prototipo de funcion */
  5. long calculaFactorial( long numero );
  6. void muestraLlamadasRecursivas( long numero );
  7.  
  8. /* Inicia la ejecucion del programa */
  9. int main()
  10. {
  11.  
  12. int i; /* Contador */
  13.  
  14. printf( "\n\n***Este programa imprime los factoriales de los numeros del 0 al 10\n" );
  15. printf( "y sus llamadas recursivas a la funcion que calcula los mismos.\n" );
  16. printf( "Este programa se crea con la finalidad de hacer que sea mas facil\n" );
  17. printf( "entender el tema de recursividad***\n\n" );
  18.  
  19. /* Repite 11 veces; durante cada iteracion calcula el factorial de i y lo despliega en pantalla */
  20. for ( i = 0; i <= 10; i++ )
  21. {
  22. printf( "%d! = %ld\n", i, calculaFactorial( i ) ); /* Imprimimos el valor del factorial */
  23. muestraLlamadasRecursivas( i ); /* Llamamos a la funcion que imprime las llamadas a funcion */
  24. }
  25.  
  26. return 0; /* Terminacion exitosa */
  27.  
  28. } /* Fin de main */
  29.  
  30. /* Definicion recursiva de la funcion factorial */
  31. long calculaFactorial( long numero )
  32. {
  33. /* Caso base */
  34. if ( numero <= 1 ) {
  35. return 1;
  36. } /* Fin de if */
  37. else { /* Paso recursivo o llamada recursiva */
  38. return ( numero * calculaFactorial( numero - 1 ) );
  39. } /* Fin de else */
  40. } /* Fin de la funcion factorial */
  41.  
  42. void muestraLlamadasRecursivas( long numero )
  43. {
  44. static int contadorEspacios = 1; /* es static para que el valor no se destruya entre las llamadas recursivas a funcion */
  45. int contador = contadorEspacios; /* Variable que determinara el numero de espacios a imprimir */
  46.  
  47. for ( contador; contador >= 1; contador-- ) { /* Imprimimos los espacios correspondientes */
  48. printf( " " );
  49. } /* Fin de for */
  50.  
  51. if ( numero <= 1 ) {
  52. printf( "1\n" );
  53. printf( "-------------------\n" );
  54. }
  55. else {
  56. printf( "%ld * factorial( %ld - 1 )\n", numero, numero ); /* Imprimimos la llamada recursiva */
  57. contadorEspacios++; /* Agregamos 1 a la variable de espacios */
  58. muestraLlamadasRecursivas( numero - 1 ); /* Llamamos recursivamente a la funcion */
  59. }
  60.  
  61. contadorEspacios = 1; /* Reestablecemos la variable a 1 para que no se vallan a imprimir los espacios ya calculados en el factorial anterior*/
  62. } /* Fin de funcion muestraLlamadasRecursivas */
  63.  

Enserio agradeceria muchisimo su ayuda.
Páginas: [1]
WAP2 - Aviso Legal - Powered by SMF 1.1.21 | SMF © 2006-2008, Simple Machines