int main()
{
int vetor[] = {3,2,1};
imprimirVetor(vetor);
bogosort(vetor);
imprimirVetor(vetor);
return 0;
}
main()
{
//vars
int A[6], B[6];
printf("OPERACOES COM VETORES\n\n");
lerVetor(A, 6);
lerVetor(B, 6);
imprimirVetor(A, 6);
imprimirVetor(B, 6);
calcular(A, 6, B);
}
int main(int argc, char **argv) {
srand(time(NULL));
int* A;
int* B;
A = geraVetor();
if(A == NULL){
printf("Não foi possível alocar memória para o vetor\n");
return 1;
}
B = geraVetor();
if(B == NULL){
printf("Não foi possível alocar memória para o vetor\n");
free(A);
return 1;
}
int nThreads = calculaThreads();
pthread_t *thread = (pthread_t*) malloc(sizeof(pthread_t)*nThreads);
if(thread == NULL){
printf("Erro: Não foi possivel alocar memória para as threads\n");
free(A);
free(B);
return 1;
}
argumentosThread *argumentos = (argumentosThread*)malloc(sizeof(argumentosThread)*NTHREADS);
if(argumentos == NULL){
printf("Erro: Não foi possivel alocar memória para os argumentos\n");
free(A);
free(B);
free(thread);
return 1;
}
pthread_mutex_init(&mutex, NULL); // criação da mutex
imprimirVetor('A', A);
imprimirVetor('B', B);
prepararThreads(nThreads, A, B, thread, argumentos);
esperarThreads(nThreads, thread);
imprimeResultado();
free(argumentos);
free(thread);
free(A);
free(B);
pthread_mutex_destroy(&mutex); //destruição da mutex
pthread_exit(NULL);
}
main()
{
/* vars */
int A[T], B[T];
printf("SOMA DE DOIS VETORES\n\n");
/* Entrada */
lerVetor(A);
lerVetor(B);
/* Processamento e Saída */
printf("\nA:\n");
imprimirVetor(A);
printf("\nB:\n");
imprimirVetor(B);
somar(A, B);
}
int main(){
//Declaracao das variaveis
float vImpares[MAX];
// Armazenar quadrado de valores impares
quadradoImpar(vImpares);
//Imprimir os valores
imprimirVetor(vImpares);
return 0;
}
void somar(int v[], int u[])
{
int i, soma[T];
for (i = 0; i < T; ++i) {
soma[i] = v[i] + u[i];
}
printf("\nSOMA:\n");
imprimirVetor(soma);
}
void parImpar(int v[])
{
int j, A[T], B[T],
contPar = 0,
contImpar = 0;
for (j = 0; j < T; j++) {
if (v[j]%2 == 0) {
A[contPar] = v[j];
contPar++;
} else {
B[contImpar] = v[j];
contImpar++;
}
}
printf("\nA:\n");
imprimirVetor(A, contPar);
printf("\nB:\n");
imprimirVetor(B, contImpar);
}
main()
{
/* vars */
int X[T], qtdPares;
printf("QUANTIDADE DE PARES\n\n");
lerVetor(X);
imprimirVetor(X);
qtdPares = calcularPares(X);
printf("\npares: %i\n", qtdPares);
}
redirecionarFluxo(int valor){
switch(valor){
case 1:
popularVetor();
break;
case 2:
imprimirVetor();
break;
case 3:
insertionSort();
break;
case 4:
break;
}
}
main()
{
int i, X[T];
printf("VETOR DE PARES E IMPARES\n\n");
for (i = 0; i < T; i++) {
printf("X[%i]: ", i);
scanf("%i", &X[i]);
}
printf("\nX:\n");
imprimirVetor(X, T);
parImpar(X);
}
int main() {
int a[100], b[100], c[100], i, j, n;
printf("qual o numero de conjuntos? ");
scanf("%d", &n);
lerVetor(a);
for (i = 1; i < n; i++) {
lerVetor(b);
intersec(a, b, c);
memcpy(&a, &c, sizeof a);
}
printf("\na interseccao dos conjuntos é ");
imprimirVetor(c);
return 0;
}
int main (){
int matrizA[MAX_LIN][MAX_COL];
int vetA[MAX_COL];
int nL,nC;
printf ("Informe o numero linhas da matriz: ");
scanf ("%d",&nL);
printf ("Informe o numero colunas da matriz: ");
scanf ("%d",&nC);
alimentar(matrizA,nL,nC);
printf("****************************\n");
printf("******** MATRIZ A **********\n");
printf("****************************\n");
exibir(matrizA,nL,nC);
inicializarVetor(vetA,nL);
somaLinha(matrizA,nL,nC,vetA);
imprimirVetor(vetA,nL);
getch();
}
/* ---------------- */
int main(){
int numElementos = 0, //Armazena o tamanho do vetor.
opcao, //Armazena o a opção selecionada pelo usuário.
vetor[MAX],
numero; //Armazena o número digitado pelo usuário para contagem e busca.
// variaveis para a rotina de maximo e minimo
int maximo, minimo;
// variaveis para a rotina de soma
int somaPares, somaImpares, somaPositivos, somaNegativos;
// variaveis para a rotina de estatistica
float media, mediaHarmonica, mediana, desvioPadrao;
// variaveis para a rotina de contagem
int qtPares, qtImpares, qtPrimos, qtFibonacci;
// variaveis para a rotina de busca por valor
int totalOcorrencia, primeiraOcorrencia, ultimaOcorrencia;
numElementos = tamanhoVetor();
popularVetor(vetor, numElementos);
scanf("%d", &opcao); //Lê a opção selecionada pelo usuário.
//Executa as opções enquanto o usuário não digitar a opção 0 - Sair.
while(opcao != OPC_SAIR){
switch(opcao){
//----------------------------------------------------------
case OPC_IMPRIMIR:
imprimirVetor(vetor, numElementos);
break;
//----------------------------------------------------------
//----------------------------------------------------------
case OPC_MAXMIN:
calcularMaxMin(vetor, numElementos, &maximo, &minimo);
printf("%d %d\n", maximo, minimo);
break;
//----------------------------------------------------------
//----------------------------------------------------------
case OPC_SOMA:
calcularSomas(vetor, numElementos, &somaPares, &somaImpares, &somaPositivos, &somaNegativos);
printf("%d %d %d %d\n", somaPares, somaImpares, somaPositivos, somaNegativos);
break;
//----------------------------------------------------------
//----------------------------------------------------------
case OPC_ESTATISTICA:
// lembre-se de considerar apenas numeros maiores que zero na media harmonica
// para o desvio padrao, considere o vetor como amostra e nao a populacao toda
calcularEstatistica(vetor, numElementos, &media, &mediaHarmonica, &mediana, &desvioPadrao);
printf("%.2f %.2f %.2f %.2f\n", media, mediaHarmonica, mediana, desvioPadrao);
break;
//----------------------------------------------------------
//----------------------------------------------------------
case OPC_BUSCARVALOR:
scanf("%d",&numero); //le qual numero esta sendo buscado
buscarValor(vetor, numElementos, numero, &totalOcorrencia, &primeiraOcorrencia, &ultimaOcorrencia);
printf("%d %d %d\n", totalOcorrencia, primeiraOcorrencia, ultimaOcorrencia);
break;
//----------------------------------------------------------
//----------------------------------------------------------
case OPC_CONTAGEM:
contarEspecial(vetor, numElementos, &qtPares, &qtImpares, &qtPrimos, &qtFibonacci);
printf("%d %d %d %d\n", qtPares, qtImpares, qtPrimos, qtFibonacci);
break;
//----------------------------------------------------------
}
scanf("%d", &opcao);
}
return 0;
}
int main()
{
int n,tipoVetor,respostaMenuIncial;
int jaEstaOrdenado=0;
printf("***************CRIAR VETOR************\n");
printf("Digite o tamanho do Vetor: \n");
scanf("%d",&n);
int vetor[n];
do{
printf("TIPO do Vetor: \n");
printf("1-Numeros 0-100\n");
printf("2-CEPs de Belem\n");
scanf("%d",&tipoVetor);
if (tipoVetor==1){
preencherVetor(vetor,n);
printf("O VETOR CRIADO FOI PREENCHIDO COM VALORES ALEATORIOS !!!!!!!!!\n");
}
else
if (tipoVetor==2){
gerarCepBelem(vetor,n);
printf("O VETOR CRIADO FOI PREENCHIDO COM CEPs de Belem !!!!!!!!!\n");
}
}while(tipoVetor!=1 && tipoVetor!=2 );
do
{
printf("\n\n*****************MENU****************");
printf("\n\n1-IMPRIMIR VETOR ");
printf("\n2-ORDENAR VETOR ");
printf("\n3-BUSCA NO VETOR ");
printf("\n4-LIMPAR TELA ");
printf("\n5-INVERTER VETOR ");
printf("\n0-ENCERRAR\n\nRESPOSTA: ");
scanf("%d",&respostaMenuIncial);
if (respostaMenuIncial==1)
{
imprimirVetor(vetor,n);
}
else if (respostaMenuIncial==2)
{
menuOrdenacao(vetor, n, &jaEstaOrdenado);
prosseguir ();
}
else if (respostaMenuIncial==3)
{
menuBusca(vetor, n, &jaEstaOrdenado);
prosseguir ();
}
else if (respostaMenuIncial==4)
{
system("cls");
}
else if (respostaMenuIncial==5)
{
inverterVetor(vetor,n);
prosseguir ();
}
else if(respostaMenuIncial!=0)
{
printf("VALOR INCORRETO\n\n");
prosseguir ();
}
}while(respostaMenuIncial!=0);
}//////////////fim main
