Mensajes

Hola mort. La mayoría de los libros usa la estrcutura for, tratándose de una cantidad general de "n" números. Pero si sólo son tres, puede calcularse de forma más "primitiva" con if.

Por supuesto, eso no sería práctico para más de tres números, pero al fin y al cabo el propósito de este ejercicio es netamente pedagógico, la idea es que practiques para ganar destreza.

¡¡ Interesante !! Eso sí que no lo sabía. Que considerar el float como long produce el logaritmo natural, y lo puesto supongo que produce el exp. Y lo demás ya es sencillo, como sabemos

x^(-1/2) = exp( -1/2 * log(x) )


Tengo que pensar en alguna palicación que se me ocurra utlizando este algoritmo.

Yo particularmente lo que conocía es la fórmula iterativa "de Newton", para calcular la raíz cuadrada de un número "a":

x_(n+1) = (1/2) * ( x_n  + a/x_n )

donde, en la medida que "n" se hace más grande, el valor x_n tiende a sqrt(a).

Sí, publica el código completo porque la verdad todo está bien, no tendría por qué arrojar un error 

Mmmmm,

Estuve revisando el link y cuenta la historia del asunto, es la verdad muy interesante.

Pero luego te muestra un código fuente que implementa el algoritmo de raíz cuadrada rápida, pero no entiendo que ¡¡Wtf!! es lo que hace .... 

Bueno, tengo una idea más o menos parecida.

Comparas las dos primeras. Si son distintas entonces una de ellas es "igual" a todas las demás, y la otra es la "distinta". Para dilucidar, debes revisar el tercer valor.

Si las dos primeras son iguales, pues buscas de la 3ra en adelante la primera que sea distinta y ya.

Ojo, sólo funcionará si el array tiene los valores correctamente: todos iguales y uno desigual.

Código (cpp) [Seleccionar] Expandir


int distinto( int *x, int N) {

int i;

if ( N < 3 ) return -1;

if ( x[0] == x[1] ) { /* los dos primeros iguales */
/* repetir desde el tercero en adelante, mientras
* sea igual al primero */
for ( i = 2; i < N && x[i] == x[0]; i++ )
;
if ( i < N )
return x[i] > x[0] ? i: -i;
else
return -1;
}
else /* los dos primeros distintos, revisar el tercero */
if ( x[0] == x[2] )
return x[1] > x[0] ? 1 : -1;
else
return 0;
}

Esta función la acabo de probar y me funcionó bien en todas las combinaciones.

OBSERVACIONES: (1) Si el distinto es el primero, devuelve el índice cero (no tiene signo). De otro modo, devuelve + o - según el caso.
(2) Si todos los elementos son iguales, o tiene menos de tres elementos, devuelve -1 (condición de error, jeje).

  Por nada amigo.

Por cierto, esa sintaxis que definiste "test -pass xyz" con el guión antes de la opción se parece a la típica de los comandos de UNIX y derivados. En Windows creo que es más usual el "/" (o sea "/pass" )

Visto que es así, y por lo visto tienes un alma inquieta y ávida de programación, ¿no has pensado en explorar Linux?

[incorrecto]

maikelowen ...

Eso de "una función que devuelva un array" (un array de cualquier cosa) es delicado en C. Recuerda que las variables que se declaren dentro del cuerpo de una función son locales, es decir, se destruyen al terminar la ejecución de la función, y por lo tando sus valores quedan indefinidos. Esto es, dichos valores pueden conservarse o no, es algo impredecible.

Si vas a construir una función cuyo propósito sea actualizar los valores de los elementos de un array, dicho array ha de ser declarado FUERA de la función. Por ejemplo, sea un código que actualice por teclado los valores de un array de tres elementos. Tal  vez pienses en algo como

Código (cpp) [Seleccionar] Expandir


int * f ( void );

int main() {

/* tomar tres valores desde el teclado */
int *x = f();

/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;

return 0;
}

/* Lee tres valores enteros del teclado, y los almacena  en vector */
int * f ( void ) {

int x[3];

cout << "1er numero: ";
cin >> x[0];

cout << "2do numero: ";
cin >> x[1];

cout << "3er numero: ";
cin >> x[2];

cin.ignore();

return x;
}

Pues, dicho código es incorrecto y de hecho el compilador podría informarte al respecto con un mensaje como "'warning: address of local variable 'x' returned", indicándote que estás devolviendo una variable local como retorno de la función.

Puede que este código funcione bien, o puede que no.  Es lo que llamamos una técnica de programación potencialmente peligrosa. Algo más apropiado sería:

Código (cpp) [Seleccionar] Expandir


void f( int * );

int main() {

/* tomar tres valores desde el teclado */
int x[3];

f(x);

/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;

return 0;
}

/* Lee tres valores enteros del teclado, y almacena  en vector */
void f ( int *x ) {

cout << "1er numero: ";
cin >> x[0];

cout << "2do numero: ";
cin >> x[1];

cout << "3er numero: ";
cin >> x[2];

cin.ignore();
}

donde declarar el array x FUERA de la función f, y entonces invocas a f(x) con el nombre del array como argumento de entrada, y no como valor de retorno.

Parece extraño que si la función devuelve el array actualizado, entonces dicho array deba pasarse como argumento de ENTRADA, en lugar de devolverse como SALIDA ¡¡¡Pero así es C   !!!, y la razón es que los arrays son técnicamente apuntadores a una zona de memoria que contiene ciertos datos, en lugar de ser objetos abstractos como en la P.O.O.

En lenguajes de programación orientados a objeto, como MATLAB, sí es permitido tener entidades de objeto como valores de retorno de una función. Tal vez este comportamiento se puede emular en C++ mediante referencias a objeto, pero ese sería otro tema.

============================================================================
Es posible poner a la función a devolver un array "a juro", indicando que devuelva una copia de su propio argumento como valor de retorno (ojo que es una copia de su argumento, no el mismo argumento como tal). Pero eso sería algo redundante, por ejemplo:

Código (cpp) [Seleccionar] Expandir


int * f( int * );

int main() {

/* tomar tres valores desde el teclado */
int x[3];
int * y;

y = f(x);

/* imprimir */
cout << "Los numeros son: " << x[0] << ", " << x[1] << ", " << x[2] << endl << endl;

return 0;
}

/* Lee tres valores enteros del teclado, y almacena  en vector */
int * f ( int *x ) {

cout << "1er numero: ";
cin >> x[0];

cout << "2do numero: ";
cin >> x[1];

cout << "3er numero: ";
cin >> x[2];

cin.ignore();

return x;
}

Funciona igual que antes, sólo que ahora devuelve una copia de x como retorno. Ahora, ¿qué sentido tiene tener en main() dos array's, uno x, y otro y, para tener el segundo como copia del primero?
Es lo que te hizo Blaster cuando definió en el main() los arreglos datos e info, ambos serán la misma cosa luego de llamar la función invocarPersonas(), entonces bastaba dejar sólo el primero.

Excelente por tu trabajo te felicito.

Sólo un detalle. ¿Te has preguntado por qué requieres dos getchar() para hacer la pausa al final del programa?
Con uno sólo no funciona 

La razón es que

Código (cpp) [Seleccionar] Expandir


a = getchar();
descarta la tecla ENTER, y sólo almacena en la variable a el carácter introducido antes del mismo. Entonces dicho ENTER debe ser "limpiado", a eso llamamos limpiar el búfer de entrada. Usamos:

Código (cpp) [Seleccionar] Expandir


while ( getchar() != '\n' ) ; /* limpiar el bufer de entrada */
y listo ya puedes poner un único getchar() al final del programa para producir la pausa.

Es recomendable siempre "limpiar el búfer" tras un getchar(), un gets() o un scanf() pues estas funciones descartan el carácter de nueva línea.

Hola maikelowen

Eso que planteas no presenta ningún problema ya que en C/C++ el nombre de un arreglo no es más que un apuntador al tipo de dato almacenado en el arreglo. Así dicho tipo de dato sea una estructura. Lo comprenderás más plenamente al leer el tema "Apuntadores en C" en un buen libro de texto o alguna buena página web.

Te pongo un ejemplo. El programa siguiente pide al usuario los datos de 2 personas y los almacena en un arreglo de registros de personas. A continuación, y para verificar que los datos han sido guardados correctamente, los muestra en pantalla.

La primera función, pide los datos al usuario registrarPersonas() pide los datos por consola, y los almacena en un arreglo de struct's. La segunda función mostrarPersonas() recibe dicho arreglo como argumento (que como ya dije no es más que un apuntador al primer struct guardado en el vector), e imprime los datos de los primeros 2 elementos (personas) guardados.

Está codificado para C++, ya que vi que en tu código original incluiste la clase string. Si lo quieres estrictamente para C, házmelo saber.

Código (cpp) [Seleccionar] Expandir


#include <iostream>
#include <string>

using namespace std;

struct persona {
int edad;
string nombre;
};

void registrarPersonas( struct persona *, int );
void mostrarPersonas( struct persona *, int );

int main () {

struct persona p[10];

/* registra 2 personas */
registrarPersonas( p, 2 );

/* muestra los datos de las 2 personas */
mostrarPersonas( p, 2);

return 0;
}

/* Registra datos de N personas en el arreglo */
void registrarPersonas( struct persona *p, int N ) {

int i;

for ( i = 0; i < N; i++ ) {
cout << "Persona " << i+1 << ":" << endl;
cout << "   " << "nombre: ";
getline(cin, p[i].nombre );

cout << "   " << "edad: ";
cin >> p[i].edad;
cout << endl;

while ( cin.get() != '\n' ) ; /* limpiar buffer de entrada */
}
}

/* Imprime los datos de las primeras N personas en el arreglo */
void mostrarPersonas( struct persona *p, int N ) {

int i;

cout << "Imprimiendo datos:" << endl << endl;
for ( i = 0; i < N; i++ ) {
cout << "Persona " << i+1 << ":" << endl;
cout << "   " << "nombre: " << p[i].nombre << endl;

cout << "   " << "edad: " << p[i].edad << endl << endl;
}
}

Observa el resultado en la consola:


=========================================================
Persona 1:
   nombre: maria a
   edad: 14

Persona 2:
   nombre: jose e. p.
   edad: 31

Imprimiendo datos:

Persona 1:
   nombre: maria a
   edad: 14

Persona 2:
   nombre: jose e. p.
   edad: 31
=========================================================

Excelente !!!