Problema Uri,1259.

Pedro Henrique Faria Teixe · 11 de janeiro de 2017

O meu código esta dando Runtime Error, alguem ja o fez para ver aonde ta o erro no meu código, ou alguem consegue ler meu código e me dizer, onde esta causando o problema?

#include <stdio.h>
#include <stdlib.h>
int prariba(int *a, int *b);
int prabarro(int *a,int *b);

int prariba(int *a, int *b){

        return (*a-*b);
}

int prabarro(int *a, int *b){

        return (*b-*a);
}

int main(){
int n,aux;
int i,j,x=0,num,par[100],impar[100];
int k=0;
                scanf("%d",&n);

                for(i=0;i<n;i++){
                    scanf("%d",&num);
                    if(num%2 == 0) par[k++] = num;
                    else impar[x++] = num;
                }
             qsort(par,k,sizeof(int),prariba);
             qsort(impar,x,sizeof(int),prabarro);

                   for(i=0;i<k;i++){
                      printf("%d\n",par[i]);
                }
                for(i=0;i<x;i++){
                      printf("%d\n",impar[i]);
                }
return 0;
}

11 de janeiro de 2017

Tentei fazer esse mas o meu tb deu time limit apesar da resposta correta kkkk Já edito se conseguir

#include <iostream>
using namespace std;
void BubbleSort(int vetor[], int tamanho);

int main() {
	int entradas;
	cin >> entradas;

	int* vetor = new int[entradas];
	int par = 0, impar = 0;

	for (int i = 0; i < entradas; i++) {
		cin >> vetor[i];	
		if (vetor[i] % 2 == 0) {
			par++;
		}
		else{
			impar++;
		}
	}

	// Agora que temos todos valores, temos que separar em pares e impares para depois ordená-los.
	int* par_vect = new int[par];
	int* impar_vect = new int[impar];
	int counter1 = 0, counter2 = 0;

	for (int i = 0; i < entradas; i++) {
		if (vetor[i] % 2 == 0) {
			par_vect[counter1] = vetor[i];
			counter1++;
		}
		else {
			impar_vect[counter2] = vetor[i];
			counter2++;
		}
	}

	// Agora basta ordenar os numeros
	BubbleSort(impar_vect, counter2);
	BubbleSort(par_vect, counter1);

	for (int i = 0; i < counter1; i++) {
		cout << par_vect[i] << endl;
	}

	for (int i = counter2-1; i >= 0; i--) {
		cout << impar_vect[i] << endl;
	}

	delete[] vetor;
	delete[] par_vect;
	delete[] impar_vect;
	
	return 0;
}



void BubbleSort(int vetor[], int tamanho)
{
        int memoria, troca, i, j;
	
	troca=1; /*A variável "troca" será a verificação da troca em cada passada*/
	
	for(j=tamanho-1; (j>=1) && (troca==1); j--) 
        {
	        troca=0; /*Se o valor continuar 0 na próxima passada quer dizer que não houve troca e a função é encerrada.*/
		
		for(i=0; i<j; i++)
                {
			if(vetor[i]>vetor[i+1])
                        {
				memoria=vetor[i];
                                vetor[i]=vetor[i+1];
                                vetor[i+1]=memoria;
                                troca=1; /*Se houve troca, "troca" recebe 1 para continuar rodando.*/
                        }
                }
         }
}

Pedro Henrique Faria Teixe · 11 de janeiro de 2017

2 horas atrás, Marco Tulio Oliveira Abreu disse:

Tentei fazer esse mas o meu tb deu time limit apesar da resposta correta kkkk Já edito se conseguir


#include <iostream>
using namespace std;
void BubbleSort(int vetor[], int tamanho);

int main() {
	int entradas;
	cin >> entradas;

	int* vetor = new int[entradas];
	int par = 0, impar = 0;

	for (int i = 0; i < entradas; i++) {
		cin >> vetor[i];	
		if (vetor[i] % 2 == 0) {
			par++;
		}
		else{
			impar++;
		}
	}

	// Agora que temos todos valores, temos que separar em pares e impares para depois ordená-los.
	int* par_vect = new int[par];
	int* impar_vect = new int[impar];
	int counter1 = 0, counter2 = 0;

	for (int i = 0; i < entradas; i++) {
		if (vetor[i] % 2 == 0) {
			par_vect[counter1] = vetor[i];
			counter1++;
		}
		else {
			impar_vect[counter2] = vetor[i];
			counter2++;
		}
	}

	// Agora basta ordenar os numeros
	BubbleSort(impar_vect, counter2);
	BubbleSort(par_vect, counter1);

	for (int i = 0; i < counter1; i++) {
		cout << par_vect[i] << endl;
	}

	for (int i = counter2-1; i >= 0; i--) {
		cout << impar_vect[i] << endl;
	}

	delete[] vetor;
	delete[] par_vect;
	delete[] impar_vect;
	
	return 0;
}



void BubbleSort(int vetor[], int tamanho)
{
        int memoria, troca, i, j;
	
	troca=1; /*A variável "troca" será a verificação da troca em cada passada*/
	
	for(j=tamanho-1; (j>=1) && (troca==1); j--) 
        {
	        troca=0; /*Se o valor continuar 0 na próxima passada quer dizer que não houve troca e a função é encerrada.*/
		
		for(i=0; i<j; i++)
                {
			if(vetor[i]>vetor[i+1])
                        {
				memoria=vetor[i];
                                vetor[i]=vetor[i+1];
                                vetor[i+1]=memoria;
                                troca=1; /*Se houve troca, "troca" recebe 1 para continuar rodando.*/
                        }
                }
         }
}

demoro brother, conseguindo ai mostra pra nois

Carlos Adir · 12 de janeiro de 2017

Tente organizar os dados assim que já recebe os valores. Desta maneira, não é necessário usar o qsort para organiza-los e então diminui o tempo de execução.

Pedro Henrique Faria Teixe · 12 de janeiro de 2017

agora, Carlos Adir disse:

Tente organizar os dados assim que já recebe os valores. Desta maneira, não é necessário usar o qsort para organiza-los e então diminui o tempo de execução.

ok.

adicionado 15 minutos depois

16 minutos atrás, Carlos Adir disse:

Tente organizar os dados assim que já recebe os valores. Desta maneira, não é necessário usar o qsort para organiza-los e então diminui o tempo de execução.

#include <stdio.h>
#include <stdlib.h>
int main(){
int n,aux;
int i,j,x=0,v[100],par[100],impar[100];
int k=0;
                scanf("%d",&n);

                for(i=0;i<n;i++){
                    scanf("%d",&v[i]);
                    if(v[i]%2 == 0) par[k++] = v[i];
                    else impar[x++] = v[i];
                }
               //printf("\n");
                        for(i=0;i<k-1;i++){
                            for(j=i+1;j<k;j++){
                                if(par[j]<par[i]){
                                    aux = par[j];
                                    par[j] = par[i];
                                    par[i] = aux;
                                }
                            }
                        }
                        for(i=0;i<x-1;i++){
                            for(j=i+1;j<x;j++){
                                if(impar[j]>impar[i]){
                                    aux = impar[j];
                                    impar[j] = impar[i];
                                    impar[i] = aux;
                                }
                            }
                        }
                   for(i=0;i<k;i++){
                      printf("%d\n",par[i]);
                }
                for(i=0;i<x;i++){
                      printf("%d\n",impar[i]);
                }
return 0;
}

Tentei dessa forma, mas tb deu runtime error

MassakiMsk · 12 de janeiro de 2017

Use o quick sort. Nesse meu código eu copiei o quicksort da wikipedia.

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

void quick(int vet[], int esq, int dir);

int main()
{
    int par[100000], impar[100000];
    int n, i, j, k, l;

    j = 0;
    k = 0;
    scanf("%d", &n);
    for(i = 0; i < n; i++) {
        scanf("%d", &l);
        if(l % 2 == 0) {
            par[j] = l;
            j++;
        }
        else {
            impar[k] = l;
            k++;
        }
    }

    quick(par, 0, j - 1);
    quick(impar, 0, k - 1);

    for(i = 0; i < j; i++)
        printf("%d\n", par[i]);
    for(i = k - 1; i >= 0; i--)
        printf("%d\n", impar[i]);

}

void quick(int vet[], int esq, int dir){
    int pivo = esq, i,ch,j;         //Declaração das variavés e inicialização do pivo com o primeiro algarismo da sequencia
    for(i=esq+1;i<=dir;i++){        //Percorre todos os espaços do vetor
        j = i;                      //atribuição de valor
        if(vet[j] < vet[pivo]){     //verifica se o vetor da posição pivo é maior que de outra posição
         ch = vet[j];               //ch recebe o valor que é menor
         while(j > pivo){           //repete enquanto o j que é a posição do algarismo menor que o pivo ficar na posição 0
            vet[j] = vet[j-1];      //reorganiza a posição de vetores
            j--;                    //decremento para a organização
         }
         vet[j] = ch;               // atribuição da variavel menor que o pivo na posição inicial
         pivo++;                    // aumenta a posição do pivo em uma unidade
        }
    }
    if(pivo-1 >= esq){              // verifica se o valor do pivo é maior que o final do vetor.
        quick(vet,esq,pivo-1);      //final da execursão da função
    }
    if(pivo+1 <= dir){              //verifica se o valor do pivo é menor, indicando que ainda estar dentro das limitações do vetor
        quick(vet,pivo+1,dir);      //chama a função para eecutar novamente
    }
 }