Hola, gente.
Esta vez los molesto por poco, me podrían decir que tengo que agregar a mi código para medir el tiempo que tarda en ejecutarse, busqué en foros y lo que intené no funcionó. -
Es probable que me quieran dar un tirón de orejas por tratar de reinventar la rueda, pero créanme que es tan solo para practicar con punteros y de paso cotejarlo con el método de la burbuja y saber que es más rápido si un doble for o un bucle while. -
#include <stdio.h>
void ordenar(size_t *ptrV, size_t elementos);
void mostrar(size_t *ptrV, size_t elementos);
int main( void ){
size_t vector[] = {99, 8, 13, 6, 104, 40, 7, 2, 1}, *ptrV = vector;
static size_t elementos = sizeof (vector) / sizeof (size_t);
ordenar(ptrV, elementos);
mostrar(ptrV, elementos);
return 0;
}
void ordenar(size_t *ptrV, size_t elementos){
size_t i, tmp = 0;
while(1){
if( *(ptrV+i) > *(ptrV+(i+1)) ){
tmp = *(ptrV+i);
*(ptrV+i) = *(ptrV+(i+1));
*(ptrV+(i+1)) = tmp;
}
if( i+1 == elementos ){
if( tmp == 0) break;
else{tmp = 0; i = -1;}
}
i++;
}
}
void mostrar(size_t *ptrV, size_t elementos){
size_t i;
for( i = 0; i < elementos; i++ )
printf( " %u", *(ptrV+i) );
}
Desde ya muchas gracias. -
Saludo.
Daniel
(http://i67.tinypic.com/21m9n3t.png)
Si usas Unix o derivado usa el comando time. Suponiendo que tu programa se llame 'mi_programa'
escribe en el shell
time ./mi_programa
#include <time.h>
#include <stdio.h>
int main(){
clock_t cl = clock();
// Programa
cl = clock()-cl;
printf("%i", (cl*1000)/CLOCKS_PER_SEC);
}
Ivancea96, cuando corro lo que me sugeriste agregar me pasa esto:
(http://i63.tinypic.com/fnuws9.png)
compila a la perfección solo que cambie el %i por %li (me daba error).-
Daniel.
MAFUS.
Lo tuyo funciona solo que no se cierra el programa hasta apretar Enter por lo tanto en segundos el tiempo tomado no es tan preciso. -
En cuanto a Windows el que dejo a continuación, funciona (no lo verifique, pero debe ser muy parecido al de ivancea96 ) como lo posteo, pero si lo aplico al programa me hace exactamente lo mismo que al principio. -
desconozco que efecto extraño produce el programa que ordena que si le agrego esas pocas líneas revienta, seguiremos investigando, igual espero que alguien se ilumine y pueda hallar la solución. -
#include <stdio.h>
#include <time.h>
int main( void )
{
long int i=0;
clock_t comienzo;
comienzo=clock();
for( i=0; i<10000; i++ ){
printf("*");
}
printf( "\n Sgundos transcurridos.....: %f s\n", (clock()-comienzo)/(double)CLOCKS_PER_SEC );
return 0;
}
Daniel.
Me funciona correctamente. ¿Cuál es el código que te falla, y qué código de error lanza?
Hola.
Citar¿Cuál es el código que te falla?
Cuando le agrego las líneas que me sugeriste.
Citar¿qué código de error lanza?
Al compilar ninguno, al ejecutar no muestra nada y aparece el mensaje que postee anteriormente. -
Cuando decís que te funciona correctamente, te referís a que ¿lo estás corriendo dentro del programa mío o con algún código diferente?. -
Saludos.
El problema está en la función "ordenar". No has inicializado la variable "i", por lo que al principio del while esta variable tiene un valor basura, que por casualidad, no te da error cuando pones solo tu código pero si que da error cuando fusionamos tu código con el de contar el tiempo. Repito, es casualidad que al principio no diera error
Hola, class_OpenGL.
Efectivamente, esa variable era la causante del error, cuando cambie el bucle for por el while no lo tube en cuenta. -
En la función printf efectué 2 cambios y quedo así (de lo contrario me daba errores):
printf("\n\n Milesegundos transcurridos.....:%f", (cl*1000)/(double)CLOCKS_PER_SEC);
%f y (double)
Por último ¿es coherente que me de el resultado con el signo menos?
-98.000000
-95.000000
Saludos.
Daniel
No, no lo es. Si vas a trabajar con milisegundos, te recomiendo tratarlo como entero. En Windows, no tendrás microsegundos.
Luego, asegúrate de haber hecho clock()-cl y no al revés.
He probado el programa y me salen 0 milisegundos (recuerda que solo mides milisegundos, y estos se truncan), ninguna cifra negativa.
Hola a todos.
Voy a exponer el código y como lo implemente para que me digan si es correcto porque me quedan dudas con el resultado, por Ej. 4294967199, ¿estos son milisegundos y 4.30.... segundos?.-
En cuanto a Linux, se puede poner esta línea para que la salida vaya a un archivo de texto. -
>> (time ls) 2> salida.txt
int main( void ){
size_t vector[] = {99, 8, 13, 6, 10, 40, 7, 2, 1,74}, *ptrV = vector;
static size_t elementos = sizeof (vector) / sizeof (size_t);
clock_t cl = clock();
ordenar(ptrV, elementos);
mostrar(ptrV, elementos);
cl = clock() - cl;
printf("\n\n %lu", (cl*1000)/CLOCKS_PER_SEC);
return 0;
}
Saludos.
Daniel
No, el resultado está en milisegundos. Deduzco que por alguna razón te está saliendo un número negativo en la operación "cl = clock() - cl;", pero al interpretar ese número negativo como un entero sin signo, te sale ese número. Si en vez de mostrarlo como un entero sin signo lo mostraras con signo, te saldría -97 ms...
No sé por qué razón te sale un tiempo negativo... Prueba a compilar con otro compilador. Yo he compilado el código tal y como tu lo tienes y me salen resultados coherentes...
Hola.
Bueno a pesar de no lograr el cometido porque realmente todas las pruebas que hice no me dieron resultdo, encontré una aplicación utilizando la librería windows.h que funciona muy bien, me gustaría colgarla aquí, pero como no conozco si es legal esto de sacar programas de una página y copiarlo en otra mejor lo dejamos ahí. -
Lo que quiero consultarles concretamente es ¿es posible generar números aleatorios sin que se repitan? o la única manera es por cada número generado verificar si ya se encuentra en el arreglo. -
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
void llenar( size_t *ptrNumeros );
void ordenar( size_t *ptrNumeros );
void mostrar( size_t *ptrNumeros );
#define TAM 102
int main( int argc, char *argv[] ){
size_t numeros[TAM], *ptrNumeros = numeros;
llenar( ptrNumeros );
ordenar( ptrNumeros );
mostrar( ptrNumeros );
return 0;
}
void llenar( size_t *ptrNumeros ){
size_t hora = time(NULL), i;
srand(hora);
for(i = 0; i < TAM; i++){
*(ptrNumeros + i) = rand()% 100 + 200;
}
}
void ordenar( size_t *ptrNumeros ){
size_t i = 0, tmp = 0;
while(1){
if( *( ptrNumeros+i) > *(ptrNumeros+(i+1)) ){
tmp = *(ptrNumeros+i);
*(ptrNumeros+i) = *(ptrNumeros+(i+1));
*(ptrNumeros+(i+1)) = tmp;
}
if( i+1 == TAM ){
if( tmp == 0) break;
else{tmp = 0; i = -1;}
}
i++;
}
}
void mostrar(size_t *ptrNumeros){
size_t i;
for( i = 0; i < TAM; i++ ){
if( i%10 == 0 ) printf( "\n" );
printf( " %u", *(ptrNumeros+i) );
}
}
Saludos.
Daniel
Podrías generar un número aleatorio guardado en el primer elemento, y cuando calcules un número aleatorio en el segundo, si este es igual al primero, generas otro número aleatorio, y así para todas las posiciones del arreglo. Es una solución relativamente sencilla, pero no sé si será la mejor porque dependes de que te salga un número aleatorio diferente (saldrá, pero no sé después de cuántas ejecuciones)
Hola, amigo.
Te dejo la manera que lo hice, no tarda tanto en aparecer los 100 números, Parece ser lo que me propones.
void llenar( size_t *ptrNumeros ){
size_t hora = time(NULL), i, tmp, ok = 0;
srand(hora);
for(i = 0; i < TAM; i++){
do{
tmp = rand()% 999 + 1 ;
ok = verifica( ptrNumeros, tmp );
}while(ok);
*( ptrNumeros + i ) = tmp;
}
}
int verifica( size_t *ptrNumeros, size_t tmp ){
size_t i, stop = 0;
for( i = 0; i < TAM; i++ ){
if( *( ptrNumeros + i) == tmp )
stop = 1;
}
return stop;
}
Saludos.
Con el problema de contar los tiempos: yo he terminado de hacer este programa y me cuenta hasta los microsegundos.
#include <stdio.h>
#include <time.h>
int main() {
time_t c=clock();
long unsigned j = 1;
for(long unsigned i = 0; i < 1000000000; ++i) {
if(i == j) {
printf("t(%lu) = %f\n", j, (clock() - c)*1.0/CLOCKS_PER_SEC);
j *= 10;
}
}
printf("t(%lu) = %f\n", j, (clock() - c)*1.0/CLOCKS_PER_SEC);
return 0;
}
Hola : NOB2014
Tu código parase que ya funciona solo mencionaria unos detalles
Ejemplo esta linea:
size_t numeros[TAM], *ptrNumeros = numeros;
No es necesario crear un arreglo y luego asignárselo a un puntero. Si por ejemplo lo vas a pasar por parametro a una funcion, el cual esta declarado de esta forma:
void llenar( size_t *ptrNumeros )
basta con ponerlo directamente al final de cuentas un arreglo es una estructura que apunta a una dirección en resumen es un puntero
Ejemplo:
size_t numeros[TAM]
llenar( numeros );
Otro detalle, este ya es en gustos, te aconsejaría remplazar esta forma de asignar el arreglo:
*(ptrNumeros + i) = rand()% 100 + 200;
Y recomendaría mejor esta:
ptrNumeros[i]= rand()% 100 + 200;
Las dos formas funcionan igual pero, la segunda forma hace tu código mas legible, y se hace mas a relucir cuando se aumenta el tamaño y complejidad del proyecto
Espero mis comentarios no se tomen a mal
Salutos....
Hola.
MAFUS, te dejo una captura para que me digas que es lo que estoy leyendo, segundos, milesegundos. -
(http://i68.tinypic.com/wuid1x.png)
crack81, muchas pero muchas gracias por esas sugerencias no tenes una idea como se agradece de este lado, no obstante (como lo aclare al principio) lo hice con punteros porque estoy estudiando justamente punteros y estaba practicando. -
Un abrazo y muchas gracias por el tiempo que le dedicaron al tema. -
Daniel
Solo es cuestión de observación. ¿Estás usando cl/CLOCKS_PER_SEC o (cl*1000)/CLOCKS_PER_SEC? Si estás usando la primera opción, son segundos (te lo dice CLOCKS_PER_SEC), pero si estás usando la segunda opción estás viendo milisegundos, porque estás multiplicando los segundos por 1000.
La unidad es el segundo: 1.000000 es 1 segundo.
No puedo decir que este "bien" ahora pero parece ser que al menos por un factor de 100 estaba errado antes.
#include <stdio.h>
#include <time.h>
int main( void )
{
long int i=0;
clock_t comienzo;
comienzo=clock();
// programa
for( i=0; i<5000000; i++ ){
printf("*");
}
printf( "\n Segundos transcurridos.....: %f s\n", 100*(clock()-comienzo)/(double)CLOCKS_PER_SEC );
return 0;
}
Segun leo en StackOverflow: "CLOCKS_PER_SEC might be defined as 1000000, depending on what options you use to compile, and thus it does not seem like a good solution."
http://stackoverflow.com/questions/5248915/execution-time-of-c-program
---
PD: realmente veo que ni siquiera es un factor multiplo de 10
Eso son centisegundos, no segundos.
Me tomé el trabajo de medir el tiempo de ejecucion del programa que posteé (o sea le subi el tiempo hasta que sea posible medirlo facilmente) y como digo...... el valor esta "en el orden" de los SEGUNDOS (correcto ahora para mi SO) pero tampoco es creo exacto (me difiere en algunos segundos)
Veo el problema como algo "grave" ya que nadie parece tener la seguridad de como es y menos cross-plataform o cross-compiler
En Windows, suele ser CLOCKS_PER_SEC = 1000, y en Unix = 1000000. clock también retorna un valor acorde a estas cantidades y correcto.
1. ¿Qué valor tiene CLOCKS_PER_SEC en tu SO?
2. ¿Qué SO es?
3. ¿El valor retornado por tu clock() va en el rango de los milisegundos o de los microsegundos? ¿Otro quizás?
Uso Windows 6.3 y si vale 1000 como dices
En fin.... me toco multiplicar por 100 como decia respecto del programa aportado aqui para que tenga algun sentido....
¿Qué valor da clock()-comienzo en una diferencia aproximada de 1 segundo? En entero, sin coma flotante.
Hola.
Perdón por interponerme pero el código de boctulus me da resultados correctisimos, medido con un reloj de una página de internet, correctisimos. -
Solo que lo hago como dijo MAFUS, en segundos. -
printf( "\n Segundos transcurridos.....: %f s\n", 1.0*(clock()- comienzo)/(double)CLOCKS_PER_SEC );
Saludos.
Daniel
El codigo no es mio, es la forma estandar de usar la libreria
Pero como digo en Windows el factor es de 100 (aprox) asi que creo este tipo de calculos deberian hacerse con ayuda del precompilador (#ifndef _Windows ...) al menos que se quiera solo valores relativos (mismo computador, mismo SO)
#include <stdio.h>
#include <time.h>
#ifdef __linux__
#define TIMEFACTOR 1
#elif _WIN32
#define TIMEFACTOR 100
#else
// definir
#endif
int main( void )
{
long int i=0;
clock_t comienzo;
comienzo=clock();
// programa
for( i=0; i<1000000; i++ ){
printf("*");
}
printf( "\n Segundos transcurridos.....: %f s\n", TIMEFACTOR*(clock()-comienzo)/(double)CLOCKS_PER_SEC );
return 0;
}
Insisto, el único "factor" es CLOCKS_PER_SEC, que para eso existe.
Multiplicar por 1000, da milisegundos. multiplicar por 100, centisegundos.
Si en tu compilador o sistema no funciona así, habrá que analizar por qué. Poner un coeficientes que cuadre no es una opción lógica.
Prueba si quieres en otro PC, en otro SO o en una máquina virtual para ver el resultado que debiera dar.
Ivan: me parece perfecto que insistas, estoy tratando de ver porque no me concuerdan los resultados.
Siguiendo con la liberia time.h, te pido mires este codigo....... no le encuentro el fallo:
#include <stdio.h>
#include <time.h>
int main( void )
{
// solo como control adicional
time_t tiempo1 = time(0);
time_t tiempo2 = time(0);
struct tm *tini = localtime(&tiempo1);
struct tm *tfin = localtime(&tiempo2);
char output[128];
strftime(output,128,"%d/%m/%y %H:%M:%S",tini);
printf("%s\n",output);
// programa
for(int i=0; i<40000000; i++ ){
}
strftime(output,128,"%d/%m/%y %H:%M:%S",tfin);
printf("%s\n",output);
return 0;
}
No logro muestre dos fechas-horas distintas!
PD: quiero utilizar esto para rematar con el tema..... probando si es necesario o no un TIMEFACTOR adicional (pues en realidad quiero estar de acuerdo contigo)
En todo caso:
#include <stdio.h>
#include <time.h>
int main( void )
{
// solo como control adicional
time_t tiempo1 = time(0);
struct tm *tini = localtime(&tiempo1);
char output[128];
strftime(output,128,"%d/%m/%y %H:%M:%S",tini);
printf("%s\n",output);
// programa
for(int i=0; i<1000000000; i++ ){
}
time_t tiempo2 = time(0);
struct tm *tfin = localtime(&tiempo2);
strftime(output,128,"%d/%m/%y %H:%M:%S",tfin);
printf("%s\n",output);
return 0;
}
Si llamas a time() al principio 2 veces, serán iguales.
Me sirvió ;D
Gracias y.... por todo!