Mensajes

Declaras empleados e[3], sin haber hecho un typedef de la struct y luego usas la struct... etc etc.

Se consecuente con tus declaraciones y con los parámetros que tus funciones reciben y los argumentos que pasas al llamarlas.

Además ten cuidado con cosas como esta:

Código (c) [Seleccionar] Expandir

void ingresar(empleado d);

Debes pasar la referencia de d para poder modificarla.

Código (c) [Seleccionar] Expandir

#include <stdio.h>

typedef struct {
    char nom[40];
    int asiento[3];
} empleado;
void ingresar(empleado * d);
void asignarAsiento(empleado q[]);
void imprimir(empleado a);

int main()
{
   int i;
     empleado e[3];
     asignarAsiento(e);
     for (i=0; i<3; ++i)
       imprimir(e[i]);
     return 0;
}
void ingresar(empleado * d){
    printf("Nombre: ");
     scanf("%s", d->nom);
    printf("Asiento: ");
     scanf("%d", d->asiento);
   }
void asignarAsiento(empleado e[]){
   int i, j;
   for(i=0; i<3; i++){
       ingresar(&e[i]);
       for(j=0; j<i; j++) {

           if( *e[i].asiento == *e[j].asiento ){
               printf ("Asiento ocupado. Vuelva a intentarlo.\n");
               i--;
               break;
           }
       }
   }
}
void imprimir(empleado a){
    printf("Nombre: %s\tAsiento: %d\n", a.nom, *a.asiento);
}


Puede que te funcione.

@barnix456, bueno tú has insertado todo el código en un mismo archivo y funciona. Pero claro, si tienes programas de 10-20 mil líneas, la cosa se complica.

La idea sería:

funciones.h

Código (c) [Seleccionar] Expandir



/* Tipos de datos */

/* Encabezados de funciones públicas */

void restar(void);
void multiplicar(void);
void dividir(void);
void potencia(void);
void raiz_cuadrada(void);
void seno(void);
void coseno(void);
void tangente(void);

funciones.c

Código (c) [Seleccionar] Expandir



/* includes */

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

void sumar(void)
{
   float num1, num2;
printf("\nIntroduzca los dos numeros a sumar: \n");
scanf("%f %f", &num1, &num2);
   printf("\n%.2f", num1 + num2);
return;
}
void restar(void)
{
   float num1, num2;
printf("\nIntroduzca los dos numeros a restar: \n");
scanf("%f %f", &num1, &num2);
printf("\n%.2f", num1 - num2);
return;
}
void multiplicar(void)
{
   float num1, num2;
printf("\nIntroduzca los dos numeros a multiplicar: \n");
scanf("%f %f", &num1, &num2);
printf("\n%.2f", num1 * num2);
return;
}
void dividir(void)
{
   float num1, num2;
printf("\nIntroduzca los dos numeros a dividir: \n");
scanf("%f %f", &num1, &num2);
printf("\n%.2f", num1 / num2);
return;
}
void potencia(void)
{
   float num1, num2;
printf("\nIntroduzca la base: \n");
scanf("%f", &num1);
printf("Introduzca el exponente: \n");
scanf("%f", &num2);
printf("\n%.2f", pow(num1, num2));
return;
}
void raiz_cuadrada(void)
{
   float num1;
printf("\nIntroduzca el numero: \n");
scanf("%f", &num1);
printf("La raiz cuadrada es: %.2f \n", sqrt(num1));
return;
}
void seno(void)
{
   float num1;
printf("\nIntroduzca el numero: \n");
scanf("%f", &num1);
printf("El seno es: %.2f \n", sin(num1));
return;
}
void coseno(void)
{
   float num1;
printf("\nIntroduzca el numero: \n");
scanf("%f", &num1);
printf("El coseno es: %.2f \n", cos(num1));
return;
}
void tangente(void)
{
   float num1;
printf("\nIntroduzca el numero: \n");
scanf("%f", &num1);
printf("La tangente es: %.2f \n", tan(num1));
return;
}


main.c

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include "funciones.h" // <- debe estar en el mismo dir o especificar ruta completa

void main()
{
   int op;

   printf("\t\tElija una opcion:\n\n");
printf("\t*********************************\n");
printf("\t*\t [1] Sumar\t\t*\n");
printf("\t*\t [2] Restar\t\t*\n");
printf("\t*\t [3] Multiplicar\t*\n");
printf("\t*\t [4] Dividir\t\t*\n");
printf("\t*\t [5] Potencia\t\t*\n");
printf("\t*\t [6] Raiz cuadrada\t*\n");
printf("\t*\t [7] Seno\t\t*\n");
printf("\t*\t [8] Coseno\t\t*\n");
printf("\t*\t [9] Tangente\t\t*\n");
printf("\t*\t [10] Salir\t\t*\n");
printf("\t*********************************\n\n");
scanf("%d", &op);

switch (op) {

case 1:
sumar();
getchar();
break;

case 2:
restar();
getchar();
break;

case 3:
multiplicar();
getchar();
break;

case 4:
dividir();
getchar();
break;

case 5:
potencia();
getchar();
break;

case 6:
raiz_cuadrada();
getchar();
break;

case 7:
seno();
getchar();
break;

case 8:
coseno();
getchar();
break;

case 9:
tangente();
getchar();
break;

case 10:
break;

default:
           printf("Ha elejido una opcion incorrecta\n");
           break;
}
}


La idea ahora sería compilar funciones.c como objeto. Es decir generar un fichero compilado, aunque no ejecutable.
Usando gcc sería:

Código [Seleccionar] Expandir

gcc -c funciones.c -o funciones.o

Lo siguiente, compilar main.c junto con funciones.h como objeto:
Usando gcc sería:

Código [Seleccionar] Expandir

gcc -c main.c funciones.h -o main.o

Finalmente deberíamos generar el ejecutable final compilando los dos archivos objeto (funciones.o y main.o):
Usando gcc sería:

Código [Seleccionar] Expandir

gcc main.o funciones.o -o ejecutable (En Windows .exe)

Para agilizar la compilación en módulos se diseñan archivos makefile de tal manera que solo con ejecutar make, compilamos todo nuestro programa.

Hay diversos motivos por los que se usan los headers de C o los módulos en general.

Una de las ideas es facilitar la lectura del código, optimizar la depuración del código y hacer más portable el código.

Imaginad que tenéis todas las librerías que uséis escritas en un mismo archivo o_O. Lo que hacéis es incluirlas y así quedan representadas por la directiva #include en vuestro código (el preprocesador luego incluirá el código de esas librerías en el archivo donde se incluyan).

Otra idea es la de encapsulación de código. Una parte interfaz (o pública) y otra parte implementación (o privada). De tal manera que el programador puede elegir qué información es visible para otros usuarios y cuál no.

Los archivos con extensión .h (headers o encabezados) contienen la información pública. Tipos de datos y encabezados de funciones para su posterior acceso. Y los archivos con extensión .c ( c files o archivos c ) contienen la parte privada o de implementación relacionanda con su encabezado.

Por ejemplo, imaginemos que implementamos un árbol binario y cada nodo guarda un entero. Posteriormente nosotros queremos un árbol binario que represente cadenas de caracteres. Pues tan solo yendo al header del árbol binario, podemos modificar ese tipo y todo el código nos servirá para represenar árboles binarios cuyos nodos representan cadenas de caracteres... De esa manera se incentiva la abstracción del código...

¡Saludos!

Aquí tienes un tutorial bueno, bonito y barato de mi facultad:

http://www.dc.fi.udc.es/~so-grado/CursoC.pdf

Es muy interesante tratar a los vectores n-dimensionales como punteros.

Pues aquí un código para generar un vector de números aleatorios en un rango:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#include <math.h>
#include <sys/time.h>
#define TAM 10

void inicializar_semilla() {
srand(time(NULL));
}

/* genera un vector de tamaño n con números de -10 a 10 */
void aleatorio_mod10(int v[], int n) {
int i;
inicializar_semilla();
for (i=0; i < n; i++)
v[i] = (rand() % 21) - 10;
}

int main () {
    int vector[TAM], i;
    aleatorio_mod10(vector, TAM);
    for (i=0; i<TAM; i++)
printf("%d ", vector[i]);
    printf("\n");
}


rand() % x: genera un número aleatorio entre 0 y x-1

En mi caso: rand() % 21: genera números entre 0 y 20.

Si a ese resultado le resto 10, pues genero números en el rango [-10,10] en Z

@Jaes también depende de la codificación que esté usando tu Shell. Estoy en Linux así que de momento no te puedo ayudar.

[x]

Lo mejor para entender como funciona sería una explicación gráfica. Así que te recomiendo algún pdf o algún vídeo incluso mejor.

Pongo el código para que lo puedas leer mejor:

Ordenación por inserción:

Código (c) [Seleccionar] Expandir

void ord_ins(int v[], int n) {
   int i,j,x;
   for (i=1;i<n;i++) {
       x = v[i];
       j = i-1;
       while ( (j>-1) && (v[j]>x) )
           v[j+1] = v[j--];
       v[j+1] = x;
   }
}

índices del vector: 0..N-1 y ordenación ascendente

Bueno supongamos que tenemos el array { 7, 2, 6, 4, 8, -3 }

1º. Suponemos que el primer elemento está ordenado.

2º. Recorremos el array desde 1 hasta N-1, porque el primer elemento suponemos que está ordenado.

3º. Entonces teniendo en cuenta el for de 1 a N-1, en cada iteración del for escogeremos el elemento

Código [Seleccionar] Expandir

array[i]. Es decir, en la primera iteración el 2, en la siguiente al 6, en la siguiente al 4... Es decir x =

Código [Seleccionar] Expandir

array[i]

4º Insertamos ordenadamente x en el subvector generado por los índices 0 e i-1. En este caso insertar x en el subvector { 7 }, porque va desde 0 a i-1, y como i vale 1, pues es el subvector array(0..0). Como 2 es menor que siete, lo insertamos delante.

array { 2, 7, 6, 4, 8, -3 } Hay que mover el 7 a la derecha y el 2 situarlo en la primera posición

5º Volvemos al paso 3 hasta terminar el ciclo for

-> { 2, 7, 6, 4, 8, -3 } seleccionamos el 6 e insertamos en { 2, 7 } => { 2, 6, 7, 4, 8, -3 }

-> { 2, 6, 7, 4, 8, -3 } seleccionamos el 4 e insertamos en { 2, 6, 7 } => { 2, 4, 6, 7, 8, -3 }

-> { 2, 4, 6, 7, 8, -3 } seleccionamos el 8 e insertamos en { 2, 4, 6, 7 } => { 2, 4, 6, 7, 8, -3 } <= El elemento está ya ordenado

-> { 2, 4, 6, 7, 8, -3 } seleccionamos el -3 e insertamos en { 2, 4, 6, 7, 8 } => { -3, 2, 4, 6, 7, 8,} <= Vualá, vector ordenado

Recuerda que para cada inserción tenemos que mover todos los elelementos desde la posición donde vamos a insertar hasta i-1 una posición hacia adelante.

Saludos y espero que lo entiendas.

Me sigue sin funcar, no me reconoce el pasaje de valor de longitud o tamaño del vector, a vector atravez de una variable.

Es que le tienes que pasar la dirección de memoria donde está alojada la variable largo en el montículo. O sea, el puntero:

Código (c) [Seleccionar] Expandir

ordenar1(&largo,vector1)

No, no haría falta, porque le pasas una copia y listo ._., Y a mí al compilar con C::B y ejecutar me va todo perfecto.

No tiene sentido ordenar y luego extraer, quicksort en el mejor caso es n*log(n), unido a extraer quedaría O(n*log(n) + n).En el caso peor, sería O(n²).La complejidad de mi algoritmo es simplemente O(n). ( ya sé que no estamos discutiendo eficiencia)

Extraer es constante, no lineal: O(2) = O(1). Pero que sí, que se puede hacer lineal llevando el max y el cuasi_max a la par.

... A mí sí me da.

Edito:

Me faltaba sumar la h del final. Edito el código arriba.

Cuando usas dos decimales no termina de funcionar bien.