Temas

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 (c) [Seleccionar] Expandir


if (sscanf(q,"R%dC%d", &r,&c)==2)


por que compara la instruccion sscanf con un 2?

Y en esta otra:

Código (c) [Seleccionar] Expandir


scanf("%d\n", &n);


Por que pone un salto de linea despues del especificador de conversion?

Hola que tal. Lo que pasa es que en este codigo:

Código (c) [Seleccionar] Expandir


/*Asignacion de valores en arreglos bidimensionales*/
#include <stdio.h>

/*Prototipos de funciones*/
void imprimir_arreglo( const int a[2][3] );

/*Inicia la ejecucion del programa*/
int main()
{
  int arreglo1[2][3] = { { 1, 2, 3 },
                         { 4, 5, 6 } };                         
  int arreglo2[2][3] = { 1, 2, 3, 4, 5 };
  int arreglo3[2][3] = { { 1, 2 }, { 4 } };
 
  printf( "Los valores en el arreglo 1 de 2 filas y 3 columnas son:\n" );
  imprimir_arreglo( arreglo1 );
 
  printf( "Los valores en el arreglo 2 de 2 filas y 3 columnas son:\n" );
  imprimir_arreglo( arreglo2 );
 
  printf( "Los valores en el arreglo 3 de 2 filas y 3 columnas son:\n" );
  imprimir_arreglo( arreglo3 );
 
  return 0;
}  /*Fin de main*/

/*Definiciones de funciones*/
void imprimir_arreglo( const int a[2][3] )
{
  int i;  /*Contador filas*/
  int j;  /*Contador columnas*/
 
  for (i = 0; i <=1; i++)
  {
    for (j = 0; j <= 2; j++)
    {
      printf( "%d ", a[i][j] );
    }
   
    printf( "\n" );
  }
} /*Fin de funcion imprime_arreglo*/


Cuando compilo de esa manera me da estos errores mi compilador:

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 (c) [Seleccionar] Expandir


/*Prototipos de funciones*/
void imprimir_arreglo( int a[2][3] );

.......

/*Definiciones de funciones*/
void imprimir_arreglo( int a[2][3] )
{

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.

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 (c) [Seleccionar] Expandir


#include <stdio.h>

int main()
{
int a;

scanf( "%d", &a );

while ( a > 5 )
{
printf( "El numero debe ser menor a 5, ingresa otro: " );
scanf( "%d", &a );
}

printf( "Correcto!" );

return 0;
}


O este:

Código (c) [Seleccionar] Expandir


#include <stdio.h>

int main()
{
int a;

do
{
scanf( "%d", &a );

if ( a > 5 )
printf( "El numero debe ser menor a 5, ingresa otro: " );
} while ( a > 5 );

printf( "Correcto!" );

return 0;
}


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 (c) [Seleccionar] Expandir

/* Este programa sirve para practicar sumas, restas, multiplicaciones y divisiones */
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

/* Prototipos de funciones */
float generarNumero( int nivelDificultad );
float operacion( float numero1, float numero2, int operacionElegida );
void respuestaCorrecta( void );
void respuestaIncorrecta( void );
void impresionTipoDeOperacion( int tipoDeOperacion );

/* Inicia la ejecucion del programa */
int main()
{
int i, correcta, nivel, operando, operando2;
float num1, num2, resultado, intento;
correcta = 0;

srand( time( NULL ) ); /* Modificacion de la semilla de los numeros pseudoaleatorios */

printf( "Bienvenido al sistema de aprendizaje asistido por computadora, se te preguntaran\n" );
printf( "10 operaciones y luego se te mencionara si necesitas ayuda tutorial.\n" );

printf( "Por favor ingresa el nivel que quieres practicar ( 1 al 3 )..." );

do {
scanf( "%d", &nivel );

if ( nivel < 1 || nivel > 3 ) {
printf( "Nivel no valido, intenta otravez..." );
}
} while ( nivel < 1 || nivel > 3 );

printf( "Que tipo de operaciones quiere resolver:\n" );
printf( "1. Sumas\n2. Restas\n3. Multiplicaciones\n4. Divisiones\n" );
printf( "5. Operaciones Aleatorias\n" );
printf( "Recuerda que no es obligatorio hacer las operaciones mentalmente, puedes\n" );
printf( "apoyarte de lapiz y papel para realizarlas. ATENCION! No se permite el\n" );
printf( "uso de calculadora.\n..." );

do {
scanf( "%d", &operando );

if ( operando < 1 || operando > 5 ) {
printf( "Opcion no valida, intenta de nuevo..." );
}
} while ( operando < 1 || operando > 5 );

operando2 = operando; /* Esta variable guarda el valor de operando, esto es para tener intacta nuestra variable y modificar la copia */

for ( i = 1; i <= 10; i++ ) {
/* Llamamos a las funciones generadoras de numeros aleatorios */
num1 = generarNumero( nivel );
num2 = generarNumero( nivel );

if ( operando == 5 ) { /* Y por este motivo es por el que debemos mantener intacta nuestra variable operando */
operando2 = 1 + rand() % 4; /* Genera una operacion aleatoria */
}

resultado = operacion( num1, num2, operando2 ); /* Llamamos a la funcion que resuelve la operacion elegida ( o generada ) */

printf( "Cuanto es %.0f ", num1 );
impresionTipoDeOperacion( operando2 );
printf( " %.0f?...", num2 );

do {
scanf( "%f", &intento );

if ( intento != resultado ) {
respuestaIncorrecta(); /* Llamada a la funcion que genera los mensajes aleatorios cuando se responde incorrectamente */
correcta--; /* Se decrementa en uno cada vez que se ingresa una respuesta correcta */
}
} while ( intento != resultado );

/* Cuando se ingresa la respuesta correcta, se llama a a funcion que genera el mensaje aleatorio y se incrementa correcta */
respuestaCorrecta();
correcta++;

} /* Fin de for */

if ( correcta < 7 ) { /* Si hubo mas de 3 respuestas incorrectas, se imprime este mensaje */
printf( "Cometiste varios errores, por favor pide ayuda adicional a tu profesor. Hasta la proxima!\n" );
}

return 0;
} /* Fin de main */

/* Definicion de funciones */
float generarNumero( int nivelDificultad )
{
switch ( nivelDificultad ) { /* Para generar numeros de 1, 2 y 3 digitos en los niveles 1, 2 y 3 respectivamente */
case 1:
return 1 + rand() % 9;
break;

case 2:
return 10 + rand() % 90;
break;

case 3:
return 100 + rand() % 900;
break;
} /* Fin de switch */
} /* Fin de funcion generaNumero */

float operacion( float numero1, float numero2, int operacionElegida )
{
switch ( operacionElegida ) { /* Para la resolucion de nuestra operacion, esto es para compararlo posteriormente con la respuesta del
user*/
case 1:
return numero1 + numero2;
break;

case 2:
return numero1 - numero2;
break;

case 3:
return numero1 * numero2;
break;

case 4:
return numero1 / numero2;
break;
}
} /* Fin de funcion operacion */

void respuestaCorrecta( void )
{
switch ( 1 + rand() % 4 ) {
case 1:
printf( "Muy bien!!\n" );
break;

case 2:
printf( "Excelente!!\n" );
break;

case 3:
printf( "Manten ese buen rendimiento!!\n" );
break;

case 4:
printf( "Buen trabajo!!\n" );
break;
} /* Fin de switch */
} /* Fin de funcion respuestaCorrecta */

void respuestaIncorrecta( void )
{
switch ( 1 + rand() % 4 ) {
case 1:
printf( "No. Por favor intenta de nuevo...\n" );
break;

case 2:
printf( "Incorrecto. Trata una vez mas\n" );
break;

case 3:
printf( "No te rindas!!\n" );
break;

case 4:
printf( "No. Sigue intentando\n" );
break;
} /* Fin de switch */
} /* Fin de funcion respuestaIncorrecta */

void impresionTipoDeOperacion( int tipoDeOperacion )
{
switch ( tipoDeOperacion ) {
case 1:
printf( "mas" );
break;

case 2:
printf( "menos" );
break;

case 3:
printf( "por" );
break;

case 4:
printf( "entre" );
break;
}
} /* Fin de funcion impresionTipoDeOperacion */

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 (c) [Seleccionar] Expandir


/* Se despliegan los factoriales de los numeros del 0 al 10, se utiliza la recursividad para calcularlos */
#include <stdio.h>

/* Prototipo de funcion */
long calculaFactorial( long numero );
void muestraLlamadasRecursivas( long numero );

/* Inicia la ejecucion del programa */
int main()
{

int i; /* Contador */

printf( "\n\n***Este programa imprime los factoriales de los numeros del 0 al 10\n" );
printf( "y sus llamadas recursivas a la funcion que calcula los mismos.\n" );
printf( "Este programa se crea con la finalidad de hacer que sea mas facil\n" );
printf( "entender el tema de recursividad***\n\n" );

/* Repite 11 veces; durante cada iteracion calcula el factorial de i y lo despliega en pantalla */
for ( i = 0; i <= 10; i++ )
{
printf( "%d! = %ld\n", i, calculaFactorial( i ) ); /* Imprimimos el valor del factorial */
muestraLlamadasRecursivas( i ); /* Llamamos a la funcion que imprime las llamadas a funcion */
}

return 0; /* Terminacion exitosa */

} /* Fin de main */

/* Definicion recursiva de la funcion factorial */
long calculaFactorial( long numero )
{
/* Caso base */
if ( numero <= 1 ) {
return 1;
} /* Fin de if */
else { /* Paso recursivo o llamada recursiva */
return ( numero * calculaFactorial( numero - 1 ) );
} /* Fin de else */
} /* Fin de la funcion factorial */

void muestraLlamadasRecursivas( long numero )
{
static int contadorEspacios = 1; /* es static para que el valor no se destruya entre las llamadas recursivas a funcion */
int contador = contadorEspacios; /* Variable que determinara el numero de espacios a imprimir */

for ( contador; contador >= 1; contador-- ) { /* Imprimimos los espacios correspondientes */
printf( " " );
} /* Fin de for */

if ( numero <= 1 ) {
printf( "1\n" );
printf( "-------------------\n" );
}
else {
printf( "%ld * factorial( %ld - 1 )\n", numero, numero ); /* Imprimimos la llamada recursiva */
contadorEspacios++; /* Agregamos 1 a la variable de espacios */
muestraLlamadasRecursivas( numero - 1 ); /* Llamamos recursivamente a la funcion */
}

contadorEspacios = 1; /* Reestablecemos la variable a 1 para que no se vallan a imprimir los espacios ya calculados en el factorial anterior*/
} /* Fin de funcion muestraLlamadasRecursivas */


Enserio agradeceria muchisimo su ayuda.