Example #1
0
void main()
{
	int i, j, vector1[7], vector2[5], vector3[12], k, numi, numi2;


	printf(" ##### EJERCICIO 4 ##### \n");
	printf("Introduce los datos del primer vector. \n");
	intro(vector1, 7);
	printf("Introduce los datos del segundo vector. \n");
	intro(vector2, 5);
	

	ordena(vector1, 7);
	ordena(vector2, 5);
	
	for(k=0, numi=0, numi2=0; k<12; k++)
	{
		if(numi2>=5 || (numi<7 && vector1[numi]<vector2[numi2]))
		{
			vector3[k]=vector1[numi];
			numi++;
		}
		else
		{
			vector3[k]=vector2[numi2];
			numi2++;
		}
	}
	muestra(vector1, 7);
	muestra(vector2, 5);
	muestra(vector3, 12);

	fflush(stdin);
	getchar();
}
main()
{
    register int i,j;
    int pivote,primero,ultimo;
    i=primero;
    j=ultimo;
    pivote=cartelera.movie.nombre[(primero+ultimo)/2];
    do
    {
        while(cartelera[i].movie.nombre<pivote)
        {
            i++;
        }
        while(cartelera[i].movie.nombre>pivote)
        {
            j--;
        }
        if(i<=j)
        {
            intercambia(&cartelera[i].movie.nombre,&cartelera[j].movie.nombre);
            i++;
            j--;
        }
    }while(i<=j);
    if(primero<j)
    {
        ordena(cartelera,primero,j);
    }
    if(ultimo>i)
    {
        ordena(cartelera,i,ultimo);
    }
}
void ordena(int comb[], int lin[],int p, int u){
	int m;
	if(p<u){
		m=particao(comb,lin,p,u);
		ordena(comb,lin,p,m-1);
		ordena(comb,lin,m+1,u);
	}
}
Example #4
0
/*Paassa por todos os elementos da árvore para calcular a moda*/
void ordena(Words* a)
{
    if(a!=NULL)
    {
        a->vizinhos = ordena_lista(a->vizinhos);
        ordena(a->esq);
        ordena(a->dir);
    }
}
Example #5
0
int lru(Tipo_Lista * memoria, struct tipo_elemento pagina) {
    int ret = -1;
    struct tipo_elemento * p;
    p = pesquisa(memoria, pagina.valor);
    if (p == NULL) {
        insere(memoria, pagina.valor);
        ordena(memoria->inicio, memoria->qtd);
    } else {
        ret = (memoria->qtd - p->acessos);
        elimina(memoria, p);
        insere(memoria, pagina.valor);
        ordena(memoria->inicio, memoria->qtd);
    }
    return ret;
}
Example #6
0
int main(void) {
	unsigned int i = 0, j, tam = 10, n, *v = (unsigned int*) malloc(
			tam * sizeof(unsigned int));
	freopen("e8.txt", "r", stdin);
	freopen("s8.txt", "w", stdout);
	if (v != NULL) {
		scanf("%u", &n);
		while (n) {
			v[i] = n;
			i++;
			if (i >= tam) {
				tam = tam * 2;
				v = (unsigned int*) realloc(v, tam * sizeof(unsigned int));
			}

			scanf("%u", &n);
		}
		ordena(v, i);
		for (j = 0; j < i; j++) {
			printf("%u ", v[j]);
		}
		printf("\n");
		printf("%.1lf\n", media(v, i));
		printf("%u\n", maior(v, i));
		printf("%u\n", menor(v, i));

	}

	free(v);
	fclose(stdin);
	fclose(stdout);
	return 0;
}
Example #7
0
int main(int argc, const char * argv[]) {
   
    int * valores = (int *) malloc(N * sizeof(int));
    
    int * p = valores;
    
    srand((int) time(NULL));
    
    for (; p < (valores + N); ++p) {
        *p = rand() % 100;
        printf("%4d", *p);
    }
    
    ordena(valores, desc);
    
    
    printf("\n\n--- Ordenados ---\n\n");
    
    for (p = valores; p < (valores + N); ++p) {
        printf("%4d", *p);
    }
    
    free(valores);
    
    return 0;
}
Example #8
0
void filtroMediana(int m[MAXLINHA][MAXCOLUNA], int linhas, int colunas, int larguraJanela) {
    int  n;
    int vizinhanca[JANELA_MAX*JANELA_MAX];
    for (int i = 0; i < linhas; i++) {
        for (int j = 0; j < colunas; j++) {
            copia[i][j] = m[i][j];
        }
    }

    for (int i = 0; i < linhas; i++) {
        for (int j = 0; j < colunas; j++) {
            n = 0;
            for (int k = i - larguraJanela/2; k <= i + larguraJanela/2; k++) {
                for (int l = j - larguraJanela/2; l <= j + larguraJanela/2; l++) {
                    if (k >= 0 && l >= 0 && k < linhas && l < colunas) {
                        vizinhanca[n] = copia[k][l];
                        n++;
                    }
                }
            }
            ordena(vizinhanca, n);
            m[i][j] = n % 2 == 0 ? vizinhanca[(n - 1)/2 + 1] : vizinhanca[(n - 1)/2];
        }
    }
}
Example #9
0
void main(void){
  int i;

  ordena(vect, 8);
  for ( i= 0; i<8; i++ )
    printf("%d\n", vect[i]);
}
Example #10
0
int main(int argc, char* argv[]){
    
    Lista l1=vacia(), l2=vacia();
    FILE *in1=fopen(*(argv+1),"r"), *in2=fopen(*(argv+2),"r"), *out=fopen(*(argv+3),"w");
    char pal1[40], *pal2; 
    
    while(fscanf(in1,"%s",pal1)>0){
        pal2=(char*)malloc(40);
        strcpy(pal2,pal1); 
        l1=cons(pal2,l1);
    }

    while(fscanf(in2,"%s",pal1)>0){
        pal2=(char*)malloc(40);
        strcpy(pal2,pal1); 
        l2=cons(pal2,l2);
    }


    implista(ordena(pega(l1,l2)),out);     
    printf("%d palabras en %s.\n",numelem(pega(l1,l2)),*(argv+2));
    
    fclose(in1);
    fclose(in2);
    fclose(out); 
  
    
     return 0;   
}
Example #11
0
int main()
{
	pessoa p[100],
	m[100],f[100];//variaveis para seperar mulheres de homens, formando grupos a parte.
	int num,//numero de pessoas
	i,j,//contadores para os loops
	casais,contM=0,contF=0;//contadores para o numero de casais , de homens e de mulheres.
	scanf("%d",&num);//entrada do usuario
	/*loop que chama a função de leitura e ja passa os valores para o vetor M se for homem ou F se for mulher*/
	for (i = 0 ; i < num ; i++)
	{
		le_dados (&p[i]);
		/*if para separar sexo Masculino de feminino*/
		if (p[i].sexo == 'M'|| p[i].sexo == 'm')
		{
			m[contM]=p[i];
			contM++;//contador aumenta se for homem.
		}
		else 
		{
			f[contF] = p[i];
			contF++;//contador aumenta de for mulher
		}
	}
	/*numero de casais é dado pelo menor numero de pessoas de um mesmo sexo*/
	if(contF > contM)
	{
		casais = contM;
	}
	else
	{
		 casais = contF;
	}
	/*chamada das funçoes ordena, que ordena ambos os vetores na ordem decrescente*/
	ordena(&m,contM);//ordena vetor dos homens
	ordena(&f,contF);//ordena vetor das mulheres
	/*imprime os casais com preferencia aos mais velhos*/
	for(i = 0; i < casais ; i++)
	{
		printf("%s (%c,%d) e ", m[i].nome , m[i].sexo , m[i].idade);
		printf("%s (%c,%d)\n", f[i].nome , f[i].sexo , f[i].idade);
	}
		
	system("pause");
	return 0;
}
Example #12
0
int main(int argc, const char **argv){

    int buffer = 0;
    void (*ordena) (int datos[MAX], int ini, int ulti, int (*criterio)(int, int));//Puntero a la función.
    /*La función se llama selecion pero hacemos el puntero ordena.*/
    ordena = selection;
    while (scanf(" %i", &buffer) != EOF)
        datos[cima++] = buffer;

    imprime(datos);
    crono();//Enciendo el cronometro.
    ordena(datos, 0, cima-1, mayor_a_menor);
    imprime(datos);
    ordena(datos, 0, cima-1, menor_a_mayor);
    imprime(datos);

    return EXIT_SUCCESS;
}
Example #13
0
int main() {
    int a, b, c;

    printf("Insira os valores a ordenar:\n");
    scanf("%d %d %d", &a, &b, &c);
    printf("Valores a, b, c ordenados por ordem crescente: ");
    ordena(&a, &b, &c);
    return 0;
}
Example #14
0
main(){
	int n1, n2, n3;
	printf("\nFuncao Ordena");
	printf("\nDigite os 3 numeros: ");
	scanf("%d %d %d", &n1, &n2, &n3);

	ordena(n1,n2,n3);

}
Example #15
0
int main(){
	int N=7;
	int v[7]={1,9,8,5,4,3,2};
	int i;
	printVetor(v,N);
	ordena(v,N);
	printVetor(v,N);
	return 1;
}
pont ordena(pont c, int ind)
{
	/*                Algoritmo identico ao merge                 */
	/*   pont c: recebe a celula na qual vai ordenar              */
	/*   int ind: indice, para diferenciar, se compara por ordem  */
	/*  alfabetica ou pelo numero de ocorrencias                  */                
	
    pont a, b;
    if(!c->next) return c;
    a = c;
    b = c->next;
    while(b && b->next){
        c = c->next; b=b->next->next;
    }
    b = c-> next;
    c->next = NULL;
    return mergeOrdena(ordena(a, ind), ordena(b, ind), ind);
}
Example #17
0
int main (){

int vetor[] = {3,5,2,1,4,8,1};

int k = 1;
ordena(vetor, 7, k);
printv(vetor,7);
std::cout << k << " menor elemento é " << vetor[k-1] << std::endl;

}
Example #18
0
int gera_entrada(FILE *arquivo)
{
	int nro_entradas,tam_alfabeto,nro_subconj,tam_subconj,cont,flag,elem,i,indice,chuchu;
	int *alfabeto,*conj;	
	arquivo = fopen("entrada.txt","a");
	nro_entradas = rand()%10;	
	

	for(i=0;i<nro_entradas;i++)
	{
		fprintf(arquivo,"%s","inicio");	
		cont = 0;
		tam_alfabeto = rand()%8;
		alfabeto = malloc((tam_alfabeto+1)*sizeof(int)); //+1 pq a primeira posicao eh o tamanho dele
		alfabeto[0] = tam_alfabeto;
		
		while(cont != tam_alfabeto)
		{
			//flag = 0;
			elem = rand()%20;			//elemento do alfabeto
			
			if(pertence(elem,alfabeto,tam_alfabeto))
			{
				insere(elem,alfabeto,tam_alfabeto);
				cont++;
			}		
		}
		ordena(alfabeto,tam_alfabeto); //alfabeto vai estar em ordem crescente
		fprintf(arquivo,"\n");
		for(indice=0; indice < tam_alfabeto+1;indice++)
			fprintf(arquivo,"%d ",alfabeto[indice]);				
				
		nro_subconj = rand()%20;
		fprintf(arquivo,"\nnro de subconj=%d \n",nro_subconj);

		for(indice=0;indice<nro_subconj;indice++)
		{
			tam_subconj = rand()%tam_alfabeto;
			conj = gera_conjunto(alfabeto,tam_subconj,tam_alfabeto);
			
			for(chuchu=0;chuchu<tam_subconj+1;chuchu++)
			{
				fprintf(arquivo,"%d ",conj[chuchu]);
			}
			fprintf(arquivo,"\n");

		}

	}
	free(alfabeto);
	free(conj);
	fprintf(arquivo,"\nfim");
	fclose(arquivo);
}
void ordenar::muestra(void)
{  int opc;
	opc=ordena();
	switch(opc)
	    {
	    case '1':  burbuja_asc(); break;
	    case '2':  burbuja_des(); break;
	    case '3':  bur_sen_asc(); break;
	    case '4':  bur_sen_des(); break;
	    }
}
Example #20
0
int main(int argc, const char **argv){

    int buffer = 0;
    void (*ordena)(int *, int, int, int (*criterio)(int, int));
    double tiempo;

    ordena = selection;

    while (scanf(" %i", &buffer) != EOF)
        datos[cima++] = buffer;

    imprime(datos);
    crono();
    ordena(datos, 0, cima-1, mayor_a_menor);
    tiempo = crono();
    fprintf(stderr, "tiempo = %.2lf\n", tiempo);
    imprime(datos);
    ordena(datos, 0, cima-1, menor_a_mayor);
    imprime(datos);

    return EXIT_SUCCESS;
}
Example #21
0
int main() {
	int vetor[] = {1, 7, 5, 4, 2, 3, 6};
	int i;
	
	ordena (vetor, MAX, 0);
	
	for(i = 0; i < MAX; i++) {
		printf("%d ", vetor[i]);
	}
	
	printf("\n");
	return (0);
}  
/* Insere um elemento na lista de maneira ordenada.
   Caso a lista nao esteja ordenada, ordena antes da insercao */
void insereOrdenado(Lista *p_l, elem_t e){
	No_lista *novo;
	novo = malloc (sizeof(No_lista));
	novo->info = e;

	if (!ordenada(p_l))
		ordena(p_l);
	while(p_l->prox != NULL && p_l->prox->info < e ){
		p_l = p_l->prox;
	}	
	novo->prox = p_l->prox;
	p_l->prox = novo;

}
Example #23
0
int main(int argc, char** argv) {
    Aluno **vetor;
    int n,i=0,indice;
    printf("Tamanho do vetor: ");
    scanf("%d",&n);
    vetor = (int **)malloc(n *sizeof(Aluno*));
   for (i=0; i<n; i++)
       vetor[i] = (Aluno*) malloc(sizeof(Aluno));
   for (i=0; i<n; i++) {
    printf("\nAluno %d:\n",i+1); 
    inserir_dados(vetor,i);
   }
    ordena(n,vetor);
    imprimir(vetor,n);
    return (EXIT_SUCCESS);
}
Example #24
0
int main(){
	char query[20];
	listaCurso *LC=NULL;
	Pessoa *p=NULL;
	Query *Q=NULL;
	int elements;
	LC=abreFicheiro(LC);
	printf("Introduza a query: ");
	scanf("%s",query);
	Q=splitQuery(query);
    p=procuraQuery(LC,Q);
	p=ordena(p);
	elements=totalElements(p);
	printf("%d\n",elements);
	show(p);
	return (0);
}
int main(){

    int v[12]={1,4,6,7,8,10,1,3,5,6,7,8};
    //int v[9]={1,4,6,1,3,5,6,7,8};
    int inicio=0;
    int meio = 6;
    int fim = 12;
    int i;
    ordena(v,inicio,meio,fim);
    //ordena(v,inicio,meio,fim);
    for (i = 0;i<fim;i++){
        printf("%i\n",v[i]);

    }
    system("pause");
    return 0;
}
Example #26
0
File: 1082.c Project: Gruutak/uri
int main(int argc, char** argv) {

  char x,y;
  int N, M, C, i, j, k, u, v;
  int graph[MAXN][MAXN];
  int cont = 0;

  scanf("%d", &C);

  for (k=0; k < C;k++){
    scanf("%d %d", &N, &M);

    for (i=0; i < N; i++)
      for (j=0; j < N; j++)
	graph[i][j] = 0;

    for (i=0; i < M; i++){
      scanf(" %c", &x);
      scanf(" %c", &y);
      u = x - 'a';
      v = y - 'a';
      graph[u][v] = graph[v][u] = 1;
    }

    for (i = 0; i < N; i++) {
		cor[i] = BRANCO;
	}

	cont = 0;
	printf("Case #%d:\n", k+1);
	for(i = 0; i < N; i++) {
		if(cor[i] == BRANCO) {
			cont++;
			BFS(graph, i, N);

			ordena(componente);
			for(j = 0; j < N && componente[j] != -1; j++)
				printf("%c,", componente[j] + 'a');

			printf("\n");
		}
	}
	printf("%d connected components\n\n", cont);
  }
}
//Programa Principal
int main(void)
{
	int n = 10;
	register int vet[n], i;
	for(i = 0; i < n; i++){
		printf("Digite um numero inteiro: ");
		fflush(stdin);
		scanf("%d", &vet[i]);
	}
	ordena(vet, n);
	printf("\n\nO vetor ordenado: ");
	for(i = 0; i < n; i++){
		printf("%d ", vet[i]);
	}
	getchar();
	getchar();
	return 0;
}
Example #28
0
int main(void)
{
    int i, j, k;
    clock_t tempo1, tempo2;

    double tempo[20];
    Matriz *m= malloc(sizeof(Matriz));
    pthread_t *tr = malloc(sizeof(pthread_t));
    pthread_t *tr2 = malloc(sizeof(pthread_t));
    pthread_t t[20];

    for(i = 0; i < 20; i++)
        m->thr[i]=0;

    srand(time(NULL));

    pthread_create(tr, NULL, inc1, (void*)m);
    pthread_create(tr2, NULL, inc2, (void*)m);

    m->indice=0;

    for(i = 1; i <= 19; i++)
    {
        tempo1 = time(NULL);
        ordena(i, m);
        for(j = 1; j <= i; j++)
            pthread_create(&t[j], NULL, mult, (void*)m);

        for(j = 1; j <= i; j++)
            pthread_join(t[j], NULL);

        m->indice=0;
        for(k = 0; k <= i; k++)
            m->thr[k] = 0;
        tempo2 = time(NULL);

        tempo[i] = tempo2 - tempo1;
    }

    for(k = 1; k <= 19; k++)
        printf("Threads: %d | Tempo: %f segundos\n", k, tempo[k]);
  
    return 0;
}
Example #29
0
void crear_soluciones(struct Generacion *generacion) {


int main(int argc, const char **argv){

    int entrada = 0;
    struct Stack clases;
    struct Stack plazas;
    struct Generacion generacion;

    srand(time(NULL));

    /* Entrada de datos */
    init(&clases);
    while( (entrada = cuantos("Alumnos")) > 0)
        push(entrada, &clases);

    init(&plazas);
    while( ( entrada = cuantos("Plazas")) > 0)
        push(entrada, &plazas);

    generacion.n_clases    = clases.cima;
    generacion.n_autobuses = plazas.cima;

    /* Algoritmo */
    crear_soluciones(&generacion);
    for (int g=0; g<GENERACIONES; g++)
        evalua(&generacion);
        ordena(&generacion);
        recombina(&generacion);
        muta(&generacion);


    /* House keeping */
    for (int i=0; i<INDIVIDUOS; i++)
        free(generacion.solucion[i].n_autobus);
    free(clases.data);
    free(plazas.data);

    return EXIT_SUCCESS;
}
Example #30
0
int main(){
    
     Lista l1=cons('7',cons('8',cons('9',cons('a',cons('b',cons('c',vacia()))))));
     Lista l2=cons('1',cons('2',cons('3',cons('4',cons('5',cons('6',vacia()))))));
          
     printf("La lista l1 tiene %d elementos.\n",numelem(l1));
     puts("Los elementos de la lista l1 son: \n");
     implista(l1);
     puts("------------------------");
     printf("La lista [l1|l2] tiene %d elementos.\n",numelem(pega(l1,l2)));
     puts("Los elementos de la lista [l1|l2] invertida son:\n");
     implista(invierte(pega(l1,l2)));

     printf("Esta el num 3 en la lista 2?: ");
     estaen('3',l2)?puts("Si."):puts("No."); 
     printf("Esta el num 9 en la lista 2?: "); 
     estaen('9',l2)?puts("Si."):puts("No.");
	 
	 puts("------------------------");
	 printf("Lista ordenada que resulta de pegar l1 y l2 ( [l1|l2] ) es: \n");
	 implista(ordena(pega(l1,l2)));    
     return 0;
}