Hola a todos y que tengan un muy buen día,

#include <stdio.h>
 
int main(int argc, char **argv){
	int c;
 
	printf("\n Para finalizar ==> Ctrl + d (linux) == Ctrl + c (Windows)");
	printf("\n\n Por favor introduzca una numero entero...: ");
 
	while(EOF != (c = getchar())){
		if( c >= 48 && c <= 57 )
			putchar(c);
	}
 
	printf("\n EOF == %d\n", EOF);
 
	return 0;
}

Creo que no es necesario que comente demasiado sobre lo que quiero lograr que es finalizar el bucle de una forma autómatica sin tener que apretar Ctrl + d, tengo muchas horas leyendo y practicando sobre el tema pero no logro solucionarlo,-

Saludos.
Daniel

Hola a todos y que tengan un muy buen día.


Estudiando apuntadores en c me encontré con estas 2 declaraciones pero no las entiendo, alguien seria tan amable de poner algunas líneas de código para comenzar a entender algo del tema?.-
Es todo, intenté hacer un poco de práctica pero no logro hacer que el programa corra y no tengo nada para mostrar.-

Saludos.
Daniel

Hola a todos.
Como lo dice el enunciado, no logro ingresar más de 8 dígitos para pasar de binario a decimal, si ingreso 8 o menos dígitos el resultado es correcto, pero si por Ej. ingreso 110011001 me aparece un número mayor a 1 en el noveno dígito y de la manera que está validado regresa a la función principal,-
Cómo he buscado y buscado en la web y no ayo la manera de solucionarlo recurro una vez más a Uds.
El error está en la función decimal que se encuentra en la línea 99, dejo todo el programa por si a alguien se le ocurre alguna sugerencia para mejorarlo, me parece que error de lógica no tiene, me parece. -

#include <stdio.h>
#include <limits.h>  
#include <float.h> 
#include <stdlib.h>
#include <string.h>
 
void sumar(float, float);
void restar(float, float);
void dividir(float, float);
void multiplicar(float, float);
void porcentaje(float, float);
void binario(float, float);
void decimal(float, float);
void hexadecimal(float, float);
 
int main(void){
	void ( * calc[] ) (float, float) = { sumar, restar, dividir, multiplicar, porcentaje, binario, decimal, hexadecimal };
	float opUno, opDos;
	int  operador, ch, ok, opc;
 
	while( opc != 1 ){
		system( "clear" );
		opUno = 0.00;
		do{ 
			printf( "\n Introduzca un numero..........:" ); 
			ok = scanf("%f",&opUno) == 1 && opUno > 0.00 && opUno <= FLT_MAX;  
			while ((ch = getchar()) != EOF && ch != '\n'); 
		}while(!ok); 
 
		do{ 
			printf( "\n 1 - Sumar\n 2 - Restar\n 3 - Dividir\n 4 - Multiplicar\n 5 - Porcentaje" );
			printf( "\n 6 - Binario\n 7 - Decimal\n 8 - Hexadecimal\n\n Introduzca opcion..............:" ); 
			ok = scanf("%d",&operador) == 1 && operador >= 1 && operador <= 7;  
			while ((ch = getchar()) != EOF && ch != '\n'); 
		}while(!ok);
 
		if( operador >= 6 ){
			(* calc[ operador-1 ]) (opUno, opDos);
		}
		else{
			if( operador == 5){
				printf( "\n Introduzca el porcentual.......:" ); 
			}
			else{	
				printf( "\n Introduzca segundo operando....:" );
			}
			do{ 
				ok = scanf("%f",&opDos) == 1 && opDos > 0.00 && opDos <= FLT_MAX;  
				while ((ch = getchar()) != EOF && ch != '\n'); 
			}while(!ok); 
 
			(* calc[ operador-1 ]) (opUno, opDos);
		}
 
		do{ 
			printf( "\n\n 1 - para finalizar \n 2 - Otra operacion\n\n Introduzca opcion....:" ); 
			ok = scanf("%d",&opc) == 1 && opc >= 1 && opc <= 2;  
			while ((ch = getchar()) != EOF && ch != '\n'); 
		}while(!ok); 
	}
 
	return 0;
}
 
void sumar( float opUno, float opDos ){
	printf( "\n resultado ==> %5.3f\n", opUno + opDos );
}
 
void restar( float opUno, float opDos ){
	printf( "\n resultado ==> %5.3f\n", opUno - opDos );
}
 
void dividir( float opUno, float opDos ){
	printf( "\n resultado ==> %5.3f\n", opUno / opDos );
}
 
void multiplicar( float opUno, float opDos ){
	printf( "\n resultado ==> %5.3f\n", opUno * opDos );
}
 
void porcentaje(float opUno, float opDos){
	float porc, restado, sumado;
	porc = (opUno * opDos)/100;
	restado = opUno - porc;
	sumado  = opUno + porc;
 
	printf( "\n Porcentual = %5.3f  Restado = %5.3f  Sumado = %5.3f", porc, restado, sumado );	
}
 
void binario( float opUno, float opDos ){
	int entero, i, bits=sizeof(int)*8;
	entero=(int)opUno;
 
	printf("\n El numero %d en binario es: ", entero);
	for(i=0;i<bits;++i)
		if (((entero>>(bits-i-1))&1)==1) printf("1"); else printf("0");
}
 
void decimal( float opUno, float opDos ){
	char cadena[33];
	int elementos, decimal = 0, operando = 1, i; 
 
 	elementos = sprintf(cadena,"%1.0f",opUno);
 
	for( i = 0; i < elementos; i++){
		printf("\n %c", cadena[i]);
		if( cadena[i] > '1' ){
			printf( "\n El numero ingresado es incorrecto para esta operacion" );
			printf( "\n Pulse [Enter] para continuar... " ); getchar();
			return;
		}
	}
 
	for( --elementos; elementos >= 0; elementos-- ){
		if( cadena[elementos] == '1' ){
			decimal += operando; 
		}
		operando *= 2;
	}
 
	printf( "\n Decimal %d", decimal );
}
 
void hexadecimal( float opUno, float opDos ){
	int entero;
	entero=(int)opUno;
	printf("\n El numero %d en hexadecimal es: %X\n", entero, entero);
}

Saludos y muchas gracias desde ya.-
Daniel

Hola, gente, que tengan un muy buen día.-
Les dejo este código para que me digan de que otra manera se puede lograr lo mismo, los consulto porque siempre los expertos como Uds. tienen una manera distinta de lo que yo me pude imaginar, no realice muchas pruebas pero las que realice me dan el resultado correcto, la lógica me parece que es coherente.-
En cuanto al float es porque forma parte de una calculadora que además de sumar, restar, etc., transforma un decimal en binario, en hexadecimal y viceversa.-

#include <stdio.h>
#include <string.h>
 
int main(void){
	char cadena[33];
	float binario = 1100110;
	int elementos, decimal = 0, operando = 1; 
 
 	sprintf(cadena,"%1.0f",binario);
	elementos = strlen(cadena) ; 
 
	for(--elementos; elementos >= 0; elementos-- ){
		if( cadena[elementos] == '1' ){
			decimal += operando; 
		}
		operando *= 2;
	}
 
	printf( "En binario %s  ==> en decimal %d", cadena, decimal );
 
	return 0;
}

Bueno es todo.-
Saludos.
Daniel

Hola gente, que tengan un muy buen día.
Paso a explicarles lo que me pasa, soy nuevo en Linux y si no encuentro la solución en un tiempo prudencial tengo miedo de acobardarme (espero que eso no ocurra) el caso es que instalé Ubuntu 15.04, si lo uso desde el DVD todo funciona normalmente, pero si lo utilizo desde el rígido pasan pocos minutos y queda todo congelado, principalmente si abro el navegador,
tengo 2 GB de RAM y comparto Ubuntu con W7.-       

Espero que puedan darme alguna idea del porque me pasa esto.-
Un fuerte abrazo para todos.-
Daniel.

Hola y que tengan un muy buen día.
Como verán me estoy poniendo un poco pesado pero prometo que después de esto y por un tiempo voy a exponer mis dudas en otro foro, prometido.-
Al grano, esta operación no es factible en c:

unsigned a = 2147483648, b = 2, c = a * b;

 
Tengo conocimiento de las variable con más capacidad pero no importa en este caso, lo que quiero hacer es multiplicaciones realmente grandes y para ello quiero hacerlo con 2 variables char, también sé que esto si se puede hacer:

char a[] = "2147483647", b[] = "2";
unsigned int c = atoi(a) * atoi(b);

pero me limita al valor máximo que puede contener una variable unsigned int.-
Alguien sabe de alguna curiosidad matemática, algo a nivel de bist, algo que me dé el inicio para multiplicar 2 números alojados en variables char y poner el resultado  en otra del mismo tipo?, Cualquier ayuda será bien venida.-

Saludos.
Daniel   

Hola a todos.

#include <stdio.h>
 
#define MAX 10000
void numerosPerfectos();
 
int main(void){
 
	numerosPerfectos();
 
	return 0;
}
 
void numerosPerfectos(){
	int acumulador=0, i, j=1;
 
	printf("\n\n N%cmeros perfectos...: ", 163);
 
	for(i=1; i<MAX; i++){
		acumulador = 0;
		for(j=1; j<i; j++){
			if(i % j == 0){
				acumulador += j;
			}
		}
		if(i == acumulador){
			printf(" %d ", i);
		}
	}
}

El inconveniente es que si pongo #define MAX 10000 el resultado lo muestra en un periodo de tiempo aceptable, pero si deseo saber del 1 al 100000 muestra ==> 6- 28 – 496 – 8128 y de aquí en más tarda en términos de computación una eternidad (para terminar el programa).-
La consulta es, ¿sabe alguien otra manera de hacerlo?, mi computadora si bien es un poco vieja (2gb de ram) me parecería que tendría que mostrarlo al instante, pero no es así.-

Desde ya muchas gracias.-
   
Saludos.
Daniel   

Hola a todos.
El asunto es simple por lo menos para explicarlo, sólo que no se si se puede hacer, lo que quisiera saber es si en cada iteración además de generar los número ir ordenándolos, me parece que no quedaría del todo ordenado pero por lo menos ir intercambiando los posibles.-
El juego es de Argentina y se llama Quini6, los números a asertar son 6 y van del 0 al 45.-
En este caso no tiene mucho sentido porque el bucle se realiza sólo 6 veces, pero en el caso de generar por ejemplo 500.000 números tal vez acelere el tiempo que tardaría una manera y la otra.-

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
void generar();
 
int main(void){
	generar();
 
	return 0;
}
 
void generar(){
	int guardar[6], numero=0, i=0, hora = time(NULL);
	srand(hora);
 
	for(; i<6; i++){
		numero = rand()%46;
		guardar[i] = numero; 
	}
}

   


Desde ya muchas gracias y muchos saludos.-
Daniel

Hola a todos y que tengan un muy buen día.-


Bueno con el enunciado tan bien explicado no me queda mucho para agregar, sólo decirles que estoy trabado con la última parte la de intercambio de dígitos, lo he intentado de varias manera pero no me funciono.-

#include <stdio.h>
 
int main(void){
	int numero=5724, digito=0, div=1000, auxiliar=0, cifrado=0;
	while(numero>0){
		digito = numero/div;
		numero = numero-(div*digito);
		auxiliar = (digito+7)%10*div;
		cifrado += auxiliar;
		div /= 10;
	}
 
 
	printf("\n El n%cmero cifrado es...: %d\n", 163, cifrado);
 
	return 0;
}

Una cosita más, no tengan reparos en postear código que sea totalmente distinto al mío, el código es de mi propia idea y seguramente Uds. lo sabrán hacer de una manera más eficiente.-       

Saludos.
Daniel

Hola Amigos.
El enunciado del manual es el siguiente.-

//http://dacap.com.ar/blog/cpp/medir-el-tiempo-de-una-rutina/
#include <stdio.h>
#include <windows.h>
 
/* retorna "a - b" en segundos */
double performancecounter_diff(LARGE_INTEGER *a, LARGE_INTEGER *b){
	LARGE_INTEGER freq;
	QueryPerformanceFrequency(&freq);
	return (double)(a->QuadPart - b->QuadPart) / (double)freq.QuadPart;
}
 
int main(int argc, char *argv[]){
	int contador=0;
	LARGE_INTEGER t_ini, t_fin;
	double secs;
 
	QueryPerformanceCounter(&t_ini);
	while(contador <= 300000000){
		contador++;
		if(contador % 100000000 == 0){
			QueryPerformanceCounter(&t_fin);
			secs = performancecounter_diff(&t_fin, &t_ini);
			printf("%.16g milliseconds\n", secs * 1000.0);
			QueryPerformanceCounter(&t_ini);
		}
	}
 
	getchar();
	return 0;
}

El programa que logré a partir de los ejemplos de la página me funciona correctamente (por lo menos es lo que a mí me parece) lo que pasa es que no entiendo casi ninguna línea (creo que tiene que ver con las API’s de windows), la pregunta es ¿alguien me puede decir si se puede lograr lo mismo con con un programa en C puro?, de ser así ¿podrian poner algún ejemplo?.-

Saludos.
Daniel