Buenas gente bueno recordando hace meses me gustaria hacer un reto y espero que participemos todos :)
bien calentemos primeros :D
RETO: Funcion Extraer Valores Numericos de Cadenas
Ejemplo:
Input: ewiuc3dskhd8nkd62ndsnk9
Ouput: 38629
Teneis hasta 08/01/2012 ese dia se hara el Testing de nuestras funciones , gana la funcion mas optimizada, la mas veloz de todas!
como testear la velocidad de nuestras funciones?
Con la Cabecera: Time.h: http://es.wikipedia.org/wiki/Time.h
Vamos Participemos todos! ;D
edit: edito más reglas un poco tarde viendo las espectativas de algunos codigos :P
* NO VALE ASM INLINE ( sera para el proximo reto, pronto :D )
* la funcion debe de devolver el valor en una variable o como retorno de funcion
Cadena para la prueba de velocidad:
"sdh!w2 28 :-) 9ndk#1@b______dy0--hveybd@ # qism083 s'kl...: su2b7h ++bjsnbvxj77ygv1hiiiioms90nms sjbah b#!1! --R-E-D--0+-w++ONE***WWW."
RETURN:
"228910083277719010"
#include <stdio.h>
#include <stdlib.h>
unsigned int getNumbers(char* szIn, char* szBuffer, size_t sizeBuffer);
int main()
{
char szCadena[] = {"ewiuc3dskhd8nkd62ndsnk9"};
char* szBuffer = NULL;
size_t size = getNumbers(szCadena, NULL, 0); // Cuantos numeros hay?...
if (size > 0)
{
szBuffer = (char*)malloc(size + 1);
printf("%d\n", getNumbers(szCadena, szBuffer, size));
printf("%s\n", szBuffer);
free(szBuffer);
}
getchar();
return EXIT_SUCCESS;
}
unsigned int getNumbers(char* szIn, char* szOut, size_t sizeBuffer)
{
unsigned int iRet = 0;
while(*szIn)
{
if (sizeBuffer == 0 && szOut)
break;
if ((*szIn) >= '0' && '9' >= (*szIn) )
{
if (szOut)
{
(*szOut++) = (*szIn);
--sizeBuffer;
}
iRet++;
}
szIn++;
}
if (szOut)
*szOut = (char)0x0;
return iRet;
}
#include <stdio.h>
#include <stdlib.h>
unsigned int getNumbers(char* szIn, char* szBuffer, size_t sizeBuffer);
int main()
{
char szCadena[] = {"ewiuc3dskhd8nkd62ndsnk9"};
char* szBuffer = NULL;
size_t size = getNumbers(szCadena, NULL, 0); // Cuantos numeros hay?...
if (size > 0)
{
szBuffer = (char*)malloc(size + 1 - 3);
printf("Se extrayeron: %d de %d\n", getNumbers(szCadena, szBuffer, size - 3), size);
printf("%s\n", szBuffer);
free(szBuffer);
}
getchar();
return EXIT_SUCCESS;
}
Dulces Lunas!¡.
Bueno ahí va mi versión, la de BlackZeroX la veo poco superable así que se me ocurrió ir guardando los números en un unsigned long ya que puede ser más práctico.
#include <stdio.h>
#include <stdlib.h>
unsigned int parseNumbers(char * szStr, unsigned long * uintOut)
{
unsigned int result = 0;
if (!(szStr && uintOut))
return result;
for (*uintOut = 0; *szStr != 0; szStr++)
if ((*szStr) >= '0' && (*szStr) <= '9')
{
*uintOut = (*uintOut * 10) + (*szStr) - 48;
result++;
}
return result;
}
int main()
{
char * szCadena = "ewiuc3dskhd8nkd62ndsnk9";
unsigned long numbers = 0;
printf("Cantidad de numeros: %d\n", parseNumbers(szCadena, &numbers));
printf("Numbers: %d\n", numbers);
getchar();
return 0;
}
El algoritmo no tiene mucha ciencia, en cada instancia del bucle que encuentra un número voy multiplicando por 10 y sumándole el nuevo número. El nuevo número lo calculo restándole 48 a su número ASCII.
Se me ocurrió una forma de superar el algoritmo de BlackZeroX, igual mañana la pongo en práctica. Sería recorrer el bucle hasta la mitad e ir comprobando los números por delante y por detrás de la cadena, el problema sería juntar los números de las dos mitades pero en cadenas muy muy largas sería más eficiente.
Saludos.
Cita de: Khronos14 en 5 Enero 2012, 00:17 AM
Se me ocurrió una forma de superar el algoritmo de BlackZeroX, igual mañana la pongo en práctica. Sería recorrer el bucle hasta la mitad e ir comprobando los números por delante y por detrás de la cadena, el problema sería juntar los números de las dos mitades pero en cadenas muy muy largas sería más eficiente.
Saludos.
Al leerte se me ocurrieron 2 formas mas... al rato las pongo en practica xP, igual son lentas en cadenas cortas, pero en cadenas largas uff.
Nota: Modifique mi codigo...
Dulces Lunas!¡.
C++, solo para ver que tal le va a la STL del compilador que usen para probar :laugh:
#include <string>
#include <algorithm>
#include <iostream>
using namespace std;
bool no_es_numero(char c)
{
return !isdigit(c);
}
string &extraer(string &str)
{
str.resize(remove_if(str.begin(), str.end(), no_es_numero) - str.begin());
return str;
}
void main()
{
string s = "ewiuc3dskhd8nkd62ndsnk9";
cout << extraer(s);
}
Bueno estoy suponiendo que no hay más de 9 digitos en la cadena (por que sino no caverán en un int)
#include <stdio.h>
#include <ctype.h>
int extraernum(const char *s);
int main()
{
printf("%d\n",extraernum("ewiuc3dskhd8nkd62ndsnk9"));
return 0;
}
int extraernum(const char *s)
{
const char *p=s;
int n=0;
while(*p)
{
if(isdigit(*p)) n=10*n+((*p)-'0');
p++;
}
return n;
}
EDIT: No habia leído los códigos de más arriba antes de hacer este post :-[. En este uso básicamente es el MISMO ALGORITMO que utilizó Kronos14.
Una forma ligeramente distinta en C estándar, utilizando la función strpbrk (prototipo en <string.h>) es:
#include <stdio.h>
#include <string.h>
int get_num(char const *s)
{
int num = 0;
while (s = strpbrk(s, "01234567890"))
num = num * 10 + *s++ - '0';
return num;
}
int main(void)
{
printf("%d\n", get_num("ewiuc3dskhd8nkd62ndsnk9"));
return 0;
}
Editado: el proceso ahora esta en una funcion.
Un saludo
Bueno codes gente! ;D
Cita de: GarbageCollector en 5 Enero 2012, 01:20 AM
Bueno estoy suponiendo que no hay más de 9 digitos en la cadena (por que sino no caverán en un int)
#include <stdio.h>
#include <ctype.h>
int extraernum(const char *s);
int main()
{
printf("%d\n",extraernum("ewiuc3dskhd8nkd62ndsnk9"));
return 0;
}
int extraernum(const char *s)
{
const char *p=s;
int n=0;
while(*p)
{
if(isdigit(*p)) n=10*n+((*p)-'0');
p++;
}
return n;
}
Lo siento la función debe de aceptar cualquier longitud de cadena, no debe ser fija ( no lo puse en la reglas, perdon)
la mia:
#include "stdio.h"
void getnumbers(char* Str, int &v)
{
int c=0;
do{
if((Str[c] >= 0x30) && (Str[c] <= 0x39)){
Str[v]=Str[c];
v++;
}
Str[c]=NULL;
c++;
}while(!(Str[c] == NULL));
}
int main()
{
char rSTR[] = {"ewiuc3dskhd8nkd62ndsnk9"};
int nVals = 0x0;
getnumbers(rSTR,nVals);
printf("%s\n",rSTR);
printf("%i\n",nVals);
return 0;
}
No hay cuidado ;D Ahora el code sí cumple con las especificaciones del problema:
#include <stdio.h>
#include <ctype.h>
#define MAX_DIGITOS 1000
int extraernum(const char *s, char *n);
int main()
{
char n[MAX_DIGITOS];
int cdig;
cdig=extraernum("ewiuc3dskhd8nkd62ndsnk9",n);
printf("%s\n%d\n",n,cdig);
return 0;
}
int extraernum(const char *s, char *n)
{
const char *p=s;
int cdig=0;
while(*p)
{
if(isdigit(*p)) n[cdig++]=*p;
p++;
}
n[cdig]='\0';
return cdig;
}
@GarbageCollecter
Tu codigo tiene una declaración que es absurda... mas en espesifico const char *p...
Dulces Lunas!¡.
EI: juntando mensajes.
mmm se me ocurre hacer esto (es demasiado CODIGO)...
* Tiene un Bug respecto a la ordenación de los elementos...
* Tiene la ventaja de que deberia de ser el doble de rapido que mi algoritmo normal (Solo si se cuenta con minimos 2 nucleos esto es plena teoria)...
linkear a: libpthread o como se llame en su PC...
Esta funcion el 1er hilo recorre el 0 y numeros PARES, el segundo hilo solo Numeros IMPARES...
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
typedef struct _config
{
char* szIn;
char* szOut;
size_t size;
size_t start;
unsigned int* lpPosOut;
pthread_mutex_t* lpMutex;
}
CONFIG, *LPCONFIG;
void* divideYVenceras(void* arg);
unsigned int getNumbers(char* szIn, char* szOut, size_t size);
int main()
{
char szCadena[] = {"ewiuc3dskhd8nkd62ndsnk9"};
char* szBuffer = NULL;
size_t size = getNumbers(szCadena, NULL, 0); // Cuantos numeros hay?...
if (size > 0)
{
szBuffer = (char*)malloc(size + 1);
printf("Se extrayeron: %d de %d\n", getNumbers(szCadena, szBuffer, size ), size);
printf("%s\n", szBuffer);
free(szBuffer);
}
getchar();
return EXIT_SUCCESS;
}
void*
divideYVenceras(void* arg)
{
LPCONFIG lpConfig = (LPCONFIG)arg;
unsigned int iRet = 0;
unsigned int i = lpConfig->start;
while(lpConfig->szIn[i])
{
if (i > 0 && !lpConfig->szIn[i - 1])
break;
if (lpConfig->size < (*lpConfig->lpPosOut) && lpConfig->szOut)
break;
if (lpConfig->szIn[i] >= '0' && '9' >= lpConfig->szIn[i] )
{
if (lpConfig->szOut)
{
pthread_mutex_lock(lpConfig->lpMutex);
lpConfig->szOut[(*lpConfig->lpPosOut)++] = lpConfig->szIn[i];
pthread_mutex_unlock(lpConfig->lpMutex);
}
iRet++;
}
i += 2;
}
pthread_exit((void*)iRet);
//return iRet; // No tendria caso...
}
unsigned int
getNumbers(char* szIn, char* szOut, size_t size)
{
pthread_t pthHilos[2];
CONFIG udtConfig[2];
unsigned int i = 0;
unsigned int lpiRet = 0;
unsigned int iRet = 0;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
udtConfig[0].szIn = udtConfig[1].szIn = szIn;
udtConfig[0].size = udtConfig[1].size = size;
udtConfig[0].szOut = udtConfig[1].szOut = szOut;
udtConfig[0].start = 0;
udtConfig[1].start = 1;
udtConfig[0].lpPosOut = udtConfig[1].lpPosOut = &i;
udtConfig[0].lpMutex = udtConfig[1].lpMutex = &mutex;
pthread_create(&pthHilos[0], NULL, divideYVenceras, &udtConfig[0]);
pthread_create(&pthHilos[1], NULL, divideYVenceras, &udtConfig[1]);
pthread_join(pthHilos[0], (void**)&lpiRet);
iRet = (int)lpiRet;
pthread_join(pthHilos[1], (void**)&lpiRet);
iRet += (int)lpiRet;
pthread_mutex_destroy(&mutex);
if (szOut)
szOut[iRet + 1] = (char)0x0;
return iRet;
}
Codigo Actualizado...
El primer Hilo recorre el 1er trozo de la cadena y el segundo hilo el trozo faltante... se pueden agrenar N hilos si asi se requieren... es RAPIDO con Cadenas LARGAS...
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
typedef struct _config
{
char* szIn;
size_t sizeIn;
char* szOut;
size_t sizeOut;
unsigned int* lpPosOut;
pthread_mutex_t* lpMutex;
}
CONFIG, *LPCONFIG;
void* divideYVenceras(void* arg);
unsigned int getNumbers(char* szIn, size_t sizeIn, char* szOut, size_t sizeOut);
int main()
{
char szCadena[] = {"ewiuc3dskhd8nkd62ndsnk9"};
char* szBuffer = NULL;
size_t size = getNumbers(szCadena, strlen(szCadena), NULL, 0); // Cuantos numeros hay?...
if (size > 0)
{
szBuffer = (char*)malloc(size + 1);
printf("Se extrayeron: %d de %d\n", getNumbers(szCadena, strlen(szCadena), szBuffer, size ), size);
printf("%s\n", szBuffer);
free(szBuffer);
}
getchar();
return EXIT_SUCCESS;
}
void*
divideYVenceras(void* arg)
{
LPCONFIG lpConfig = (LPCONFIG)arg;
unsigned int iRet = 0;
if (lpConfig->szIn)
{
while(lpConfig->sizeIn-- && *lpConfig->szIn)
{
if (lpConfig->sizeOut < (*lpConfig->lpPosOut) && lpConfig->szOut)
break;
if ((*lpConfig->szIn) >= '0' && '9' >= (*lpConfig->szIn) )
{
if (lpConfig->szOut)
{
pthread_mutex_lock(lpConfig->lpMutex);
lpConfig->szOut[(*lpConfig->lpPosOut)++] = *lpConfig->szIn;
pthread_mutex_unlock(lpConfig->lpMutex);
}
iRet++;
}
lpConfig->szIn++;
}
}
pthread_exit((void*)iRet);
//return iRet; // No tendria caso...
}
unsigned int
getNumbers(char* szIn, size_t sizeIn, char* szOut, size_t sizeOut)
{
pthread_t pthHilos[2];
CONFIG udtConfig[2];
unsigned int i = 0;
unsigned int iRet = 0;
unsigned int iAdd = 0;
pthread_mutex_t mutex;
pthread_mutex_init(&mutex, NULL);
udtConfig[0].szIn = szIn;
udtConfig[0].sizeIn = (sizeIn >> 1);
udtConfig[0].szOut = udtConfig[1].szOut = szOut;
udtConfig[0].sizeOut = udtConfig[1].sizeOut = sizeOut;
udtConfig[0].lpPosOut = udtConfig[1].lpPosOut = &i;
udtConfig[0].lpMutex = udtConfig[1].lpMutex = &mutex;
udtConfig[1].sizeIn = ((udtConfig[0].sizeIn) + (sizeIn & 0x1));
udtConfig[1].szIn = &szIn[(udtConfig[0].sizeIn)];
pthread_create(&pthHilos[0], NULL, divideYVenceras, &udtConfig[0]);
pthread_create(&pthHilos[1], NULL, divideYVenceras, &udtConfig[1]);
pthread_join(pthHilos[0], (void**)&iAdd);
iRet = (int)iAdd;
pthread_join(pthHilos[1], (void**)&iAdd);
iRet += (int)iAdd;
pthread_mutex_destroy(&mutex);
if (szOut)
szOut[iRet + 1] = (char)0x0;
return iRet;
}
Dulces Lunas!¡.
Aquí os dejo mi versión, tiene complejidad O(str.size()):
EDITO: Pongo el algoritmo como forma de función, thanks EI
#include <iostream>
#include <cctype>
using namespace std;
string extraer(const string &str){
string aux;
for(int a=0; a<(int)str.size(); a++) if(isdigit(str[a])) aux.push_back(str[a]);
return aux;
}
int main(){
string str;
str = "ewiuc3dskhd8nkd62ndsnk9";
//cin >> str;
str = extraer(str);
cout << str << endl;
return 0;
}
La verdad es que los requisitos no estan bien definidos pero me parece que se pidio una FUNCION. ¿Con un codigo solo ya es suficiente, no?
El mio soy nuevo en esto de c++, asi que espero respuestas q me ayuden a mejorar :rolleyes:
#include <iostream>
#include <string.h>
#include <stdio.h>
using namespace std;
int extraer(char cad[50])
{
for(int i=0;i<=strlen(cad);i++)
{
if(cad[i]>='0'&&cad[i]<='9')
{
cout<<cad[i];
}
}
return 0;
}
int main()
{
char cadena[50];
cout << "coloque la cadena" << endl;
gets(cadena);
cout<<extraer(cadena);
return 0;
}
El algoritmo (procesar cada carácter de forma secuencial) esta bien. Lo que si hay que cambiar son algunos detalles como los nombres de los encabezados (deberían ser <cstdio> y <cstring>) y evitar el uso de la función "gets". Tampoco utilizas el valor de retorno de la función (en lugar de imprimir cada dígito debes calcular el numero y retornarlo).
Para el caso te conviene leer el tema |Lo que no hay que hacer en C/C++. Nivel basico| (http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html).
Un saludo
alexis33de: empujar el resultado de extraer en cout no tiene ningun sentido, lo unico que logras es escribir un 0 que no es parte del input en pantalla (en mi codigo sirve para imprimir la cadena que retorna mi funcion).
Hay va mi codigo:
#include <stdio.h>
#include <string.h>
#include <ctype.h>
int llistar_numeros(char frase[])
{
int numcars = strlen(frase);
int cont=0;
while(cont<numcars){
if (isdigit(frase[cont]))
{
printf("%c",frase[cont]);
}
cont++;
}
}
int main()
{
char paraula[] = "as3k34nk3k3n4nkl2n4n3n2n888888nn8n8nn8nn8n8nkn87k6n78";
llistar_numeros(paraula[]);
}
PD: Como puedo hacer para identar con colores el codigo?
m0rf: Tenes que poner el lenguaje del codigo en cuestion: code=c (pone editar en tu mensaje ahora y vas a ver el cambio tal y como lo hice).
Vale gracias.
Por cierto para utilizar la libreria time.h para saber el tiempo que gasta en encontrar los numeros, que hago pongo un printf con el tiempo al principio de la aplicación y al final o solo al final?
Tenes que obtener el valor al comienzo y al final (del programa o de la funcion, no se, el autor del reto hara las pruebas) para poder hacer el calculo de cuanto tardo.
Cita de: BlackZeroX (Astaroth) en 5 Enero 2012, 07:14 AM
@GarbageCollecter
Tu codigo tiene una declaración que es absurda... mas en espesifico const char *p...
¡Absurda! ¿Porqué?! :xD
const char *p;indica que los caracteres apuntados por
p no serán modificados como es el caso de la función. La función
printf también hace uso de
const char *.
#include <stdio.h>
#include <string.h>
void getnumbs (char *cadena)
{ int cont;
for (cont=0; cont<strlen (cadena); cont++)
if (cadena [cont] >= '0' && cadena [cont] <= '9') printf ("%c", cadena [cont]);
}
int main ()
{ getnumbs ("ewiuc3dskhd8nkd62ndsnk9"); return 0; }
sagrini@pc10-1:~/Escritorio$ nano code.c
sagrini@pc10-1:~/Escritorio$ gcc -o code code.c
sagrini@pc10-1:~/Escritorio$ ./code
38629juanra@pc10-1:~/Escritorio$
38629
Process returned 0 (0x0) execution time : 0.018 s
Press ENTER to continue.
Al que dude que mi código no sea válido, que lea las normas jajaja
Un saludo! Sagrini
Citar38629
Process returned 0 (0x0) execution time : 0.018 s
Press ENTER to continue.
Hola Sagrini, podrias poner con que codigo haces las pruebas de tiempo de ejecución? Es para hacerme una idea.
Por cierto es más rápido un while o un for? Segun lo que tengo entendido es más rápido un for me parece. Que opinión tienen?
Saludos.
Cita de: Sagrini en 5 Enero 2012, 18:29 PM
Al que dude que mi código no sea válido, que lea las normas jajaja
Si somos flexibles con la descripción del reto (RETO: Funcion Extraer Valores Numericos de Cadenas) podemos entender que se imprima y ya está, pero en su sentido más extricto dice que extraigas, pero no te dice nada de mostrarlo en la salida por consola (porque podria ser en un archivo perfectamente), por lo que lo más correcto es devolver un dato del mismo tipo que procesas (char *, string, etc) pero solo con valores númericos.
@m0rf: en los demás IDE no sé, pero en Codeblocks cuando terminas de ejecutar la aplicación te sale ese mensaje.
PD: tu código va a ser de los/el más eficiente, está en C y no usas estructuras stl como el string, enhorabuena. campeón. Si quieres más eficiencia, guarda strlen(cadena) en una variable, así no tienes que calcularlo 2000 veces
@Eternal Idol:
Si, fue error mio no escribir todos los detalles :/
porque si modificara tendrian que funcionar hasta con cadenas de tipo: "ndwhe28bdm9n82g1b@n9 #.:Lnhq"
aunque la mayoria si funcionasen perfectamente ( si no es todas )
@m0rf:
yo lo voy a hacer de esta forma:
clock_t ini, end;
double sec;
ini = clock();
// call function
end = clock();
sec = (double)(end - ini) / CLOCKS_PER_SEC;
claro que en un bucle de 1000 ciclos...
si alguien tiene una mejor forma de hacerlo que diga por fa :)
@m0rf:
segun lo que sé un for...
@Sagrini:
en la funcion tendria que hacer la tarea de obtener los caracteres devolviendolos en una variable como parametro o como retorno no debe
debe imprimirlos porque al fin y al cabo no se imprimiran , lo hacemos para demostracion lo que nos interesa es la velocidad de la funcion...
@El_Java:
Y las Librerías de tu code?
EDIT:
Gente e agregado la cadena que sera la que determinara la velocidad de nuestras funciones, por favor tomenla en cuenta ( Pido disculpas por no escribirla desde principio aunque creo visto que todas nuestras funciones cumplen con las espectativas de tal cadena :) )
@RHL
Pon en rojo lo que tienes en color amarillo, estoy ciego, pero no tanto como para no ver lo que escribes, seria mejor que hicieras citas por medio de su nick (en este estilo) que citar su publicación, ya que si estoy ciego para ver el amarillo pero da un poco de flojera leerte así!¡.
Otras cosas respecto al Reto...
Segun entiendo lo que se pretende es utilizar un algoritmo de dificultad O(X) [lineal] ¿no?... si es asi usa mi primer codigo, y si esta abierto a criterio e ingenio pues toma en consideración el segundo solo como prueba de test (Tiene un errores de retornos, retorna TODOs los numeros pero de manera desordenada... ademas es una de las mas lentas)!¡...
Dulces Lunas!¡.
El caso que yo uso una plantilla para programar con miles de macros y librerias, y se me ha olvidado añadir las que necesita, ahora mismo lo hago.
Saludos!
Cita de: GarbageCollector en 5 Enero 2012, 18:18 PM
¡Absurda! ¿Porqué?! :xD
const char *p;
indica que los caracteres apuntados por p no serán modificados como es el caso de la función. La función printf también hace uso de const char *.
BlackZeroX (Astaroth) se refiere (supongo) a que no es necesario declarar la variable ya que en su lugar puedes utilizar el parámetro "s". De hacerlo así la función se reduce a:
int extraernum(const char *s)
{
int n = 0;
while (*s){
if (isdigit(*s))
n = 10 * n + *s - '0';
s++;
}
return n;
}Un saludo
Cita de: rir3760 en 6 Enero 2012, 00:23 AM
BlackZeroX (Astaroth) se refiere (supongo) a que no es necesario declarar la variable ya que en su lugar puedes utilizar el parámetro "s". De hacerlo así la función se reduce a:
int extraernum(const char *s)
{
int n = 0;
while (*s){
if (isdigit(*s))
n = 10 * n + *s - '0';
s++;
}
return n;
}
Un saludo
Gracias
Aqui va otra forma diferente, sin duda no es practica, ni rapida, ni versatil, pero hey! funciona. xD
//typedef int (* mprintf) ( const char * format, ... );
//mprintf myprintf = (mprintf)0x77c4186a;
//myprintf("%c", cad[x]);
unsigned short mstrlen(char *cad)
{
char *pcad = cad;
while(*pcad++);
return pcad - cad;
}
void extraer(char *cad)
{
unsigned short x = 0;
while(x++ <= mstrlen(cad))
if(cad[x] <= 57 && cad[x] >= 48 )
((int (*)( const char * format, ... ) )0x77c4186a)("%c", cad[x]);
}
int main()
{
char cad[] = "sdh!w2 28 :-) 9ndk#1@b______dy0--hveybd@ # qism083 s'kl...: su2b7h ++bjsnbvxj77ygv1hiiiioms90nms sjbah b#!1! --R-E-D--0+-w++ONE***WWW.";
extraer(cad);
return 0;
}
@MORF:
Lo he hecho con Codeblocks, que me muestra la salida de tiempo. No sé exactamente cómo calcula los tiempos (supongo que de una forma parecida a RHL, pero ni idea xD), pero ahí está. Luego, la mecánica del while () no es muy diferente de la del for (), pero depende del uso que se le vaya a dar. Generalmente, while () es más simple, pero en este caso for () es más adecuado.
Por cierto, tu código es MUY parecido al mío, y tu mensaje ha sido modificado varias veces. A ver, no seamos... ¬¬
@EL_JAVA:
Cita de: El_Java en 5 Enero 2012, 20:45 PM
Si somos flexibles con la descripción del reto (RETO: Funcion Extraer Valores Numericos de Cadenas) podemos entender que se imprima y ya está, pero en su sentido más extricto dice que extraigas, pero no te dice nada de mostrarlo en la salida por consola (porque podria ser en un archivo perfectamente), por lo que lo más correcto es devolver un dato del mismo tipo que procesas (char *, string, etc) pero solo con valores númericos.
Mi código (a mi parecer) es completamente válido. Yo me atengo a las reglas, si las reglas son tan flexibles...
Cita de: Sagrini en 6 Enero 2012, 23:23 PM
Por cierto, tu código es MUY parecido al mío, y tu mensaje ha sido modificado varias veces. A ver, no seamos... ¬¬
Bueno mi codigo se parece al tuyo por que hace lo mismo más que nada. Si te he de ser sincero si que lo he modificado basandome en tu codigo, simplemente para pasarle la cadena directamente a la función ya que no se porque habia declarado una variable dentro del main del programa para pasarla a la función.
A parte de esto tenia la intención de cambiar el while por un for para ver si iba más rapido, pero lo comprobe con la manera de RHL y la verdad que a parte de que no siempre da el mismo valor era igual de rapido el while hasta diria que daba más 0.003 ms xD.
Por cierto si mi función se parece a la tuya es por que tu me la hayas copiado porque la he posteado antes y solo he cambiado lo que te comento.
@RHL: Tal vez no he hecho bien la comprobación porque me sale 0.001, 0.002 dependiendo de la vez que lo ejecute.
Gente! hay un problema en las funciones que la cadena es pasada por referencia o el puntero no se puede testear porque
en un bucle desde la segunda llamada se estaria buscano en la cadena ya modificada y obtenida los valores :P
se me escapo... :P ahora que estoy haciendo pruebas...
EDIT:
@M0rf:
en una sola ejecucion no vas a poder medir el tiempo tenes que hacerlo en un bucle de por ejemplo 1000 ciclos
Cita de: RHL en 7 Enero 2012, 09:54 AMen una sola ejecucion no vas a poder medir el tiempo tenes que hacerlo en un bucle de por ejemplo 1000 ciclos
quien dice? fijate este (http://foro.elhacker.net/programacion_cc/minmayus-t258220.0.html;msg1254111#msg1254111) post...
S2
Cita de: Karman en 7 Enero 2012, 10:15 AM
quien dice? fijate este (http://foro.elhacker.net/programacion_cc/minmayus-t258220.0.html;msg1254111#msg1254111) post...
S2
Bien! pero muy poco todavia los valores que devuelve son enteros (5,7,4,...)... a menos que se modifique para doubles pero por lo que
veo el print esta para ellos :P
Cita de: RHL en 7 Enero 2012, 10:38 AMBien! pero muy poco todavia los valores que devuelve son enteros (5,7,4,...)... a menos que se modifique para doubles pero por lo que
veo el print esta para ellos :P
el que sea variable el resultado es porque el SO no puede parar todos sus drivers y procesos fundamentales para ejecutar tu código, pero dentro de todo zafás de las interferencias de otros procesos...
S2
Windows no es un S.O. de tiempo real, no podes garantizar la ejecucion realmente, solo sugerirla.
Y no se cual es el problema con el bucle, simplemente hace que la entrada sea una variable cuyo ambito termine en el mismo bucle y listo:
for (int x = 0; x < 500000; x++)
{
string s = "sdh!\"w2 28 :-) 9ndk#1@b______dy0--hveybd@ # qism083 s'kl...: su2b7h ++bjsnbvxj77ygv1hiiiioms90nms sjbah b#!1! --R-E-D--0+-w++ONE***WWW.";
extraer(s);
}
Cita de: Sagrini en 6 Enero 2012, 23:23 PM
Mi código (a mi parecer) es completamente válido. Yo me atengo a las reglas, si las reglas son tan flexibles...
No conlleva mucho merito esa idea, debido a que los primeros codigos retornan el resultado (por parametro o por funcion)... además la función indica claramente extraer, nunca se lee imprimir... obviamente alguien la a cagado al no poner las reglas, prototipos (en dado caso), o criterios explicitos... pero aun asi es lo de menos puesto a que el reto es de velocidad (en cuention al algoritmo), quien imprima algo dentro de la función que entrega, esta claró que son los que van a perder en primera linea...
Nota: Alguien que proponga un reto con mas dificultad y que no sea un reto de complejidad lineal...
Dulces Lunas!¡.
si, ya tengo las resultados pero mi como dice blackzerox mi error fue que no declare el prototipo de
las funciones y algunas funciones son mas rapidas por eso mismo y seria injusto para algunos
por eso me e decidido el reto fallido! por mi culpa U_U
Podriamos convertir el reto en hacer la funcion más precisa para calcular el tiempo de ejecución de otra funcion, que podrian ser las que tenemos sobre extracción de numeros. Se tendrian que adaptar las normas para que no ubiera problemas y mandar los codigos por mp.
Que opinan?
Saludos.
Los retos son una perdida de tiempo, mejor ayuden a resolver problemas reales de los usuarios.