Você está aqui: C ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes)

Como encontrar o par de elementos em um vetor que, somados, resulte no número informado - Solução usando força-bruta - Exercícios Resolvidos de C

Quantidade de visualizações: 453 vezes
Pergunta/Tarefa:

Dado o vetor:

// vamos declarar um vetor não ordenado de 8 ints
int numeros[] = {7, 12, 4, 5, 3, 1, 8, 6};
Peça para o usuário informar um número inteiro e encontre no vetor o par de elementos que, somados, resulte no número informado pelo usuário.

Há várias formas de se resolver esse problema. Nesse exercício nós colocamos a solução usando força-bruta.

Sua saída deverá ser parecida com:

O vetor criado é: [7, 12, 4, 5, 3, 1, 8, 6]
Informe um número: 10
Par encontrado: (7, 3)
Resposta/Solução:

Veja a resolução comentada deste exercício usando C:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

// protótipo da função que recebe um vetor de inteiros e um número
// representando a soma que devemos encontrar em dois pares
// de elementos do vetor
void encontrar_par(int numeros[], int tam_vetor, int numero);

// função principal do programa
int main(int argc, char *argv[]){
  // variáveis usadas na resolução do problema
  // vamos declarar um vetor não ordenado de 8 ints
  int numeros[] = {7, 12, 4, 5, 3, 1, 8, 6};
  int tam_vetor = 8;
  int numero, i;
  
  setlocale(LC_ALL,""); // para acentos do português 

  // vamos mostrar o vetor
  printf("O vetor criado é: ");
  for(i = 0; i < tam_vetor; i++){
    printf("%d, ", numeros[i]);
  }
    
  // vamos pedir para o usuário informar um valor
  printf("\nInforme um número: ");
  scanf("%d", &numero);
    
  // vamos encontrar o par de elementos que resulte em
  // uma soma igual ao número informado pelo usuário
  encontrar_par(numeros, tam_vetor, numero);
  
  printf("\n\n");
  system("PAUSE");	
  return 0;
}

// função que recebe um vetor de inteiros e um número
// representando a soma que devemos encontrar em dois pares
// de elementos do vetor
void encontrar_par(int numeros[], int tam_vetor, int numero){
  int encontrado = 0; // para registrar se encontramos
  int i, j;  
    
  // vamos percorrer todos os elementos do vetor, exceto
  // o último
  for (i = 0; i < tam_vetor - 1; i++){
    // no laço interno nós varremos desde o elemento
    // no índice i até o último elemento      
    for (j = i + 1; j < tam_vetor; j++){
      // encontramos o par de elementos que retorna a soma
      // que estamos procurando?
      if (numeros[i] + numeros[j] == numero){
        printf("Par encontrado: (%d, %d)", numeros[i], numeros[j]);
        encontrado = 1;
        break; // sai do laço interno
      }
    }
      
    // vamos sair do laço externo também caso o par
    // já tiver sido encontrado no laço interno
    if(encontrado){
      break;
    }
  }
 
  // o par não foi encontrado?
  if(!encontrado){    
    printf("O par de elementos não foi encontrado.");
  }
}


Link para compartilhar na Internet ou com seus amigos:

C ::: Dicas & Truques ::: Arquivos e Diretórios

Como ler o conteúdo de um arquivo uma linha de cada vez usando a função fgets() da linguagem C

Quantidade de visualizações: 28783 vezes
A função fgets(), disponível no header cstdio ou stdio.h, é usada para ler caracteres de um arquivo e armazená-los em um vetor de caracteres. Esta função recebe três argumentos. Veja:

char *fgets(char *buffer, int num, FILE *file);
buffer é um ponteiro para o vetor que receberá o conteúdo lido. num é o número de caracteres que será lido (veja que o conteúdo será lido até alcançar este número, ou um caractere de quebra de linha for encontrado, ou o marcador de fim de arquivo EOF for encontrado, o que vier primeiro). file é um ponteiro para o arquivo que foi aberto.

No exemplo abaixo usamos um laço while() para ler o conteúdo até que o final de arquivo EOF seja encontrado. Desta forma, como sabemos que cada linha no arquivo termina com um marcador de fim de linha, fica fácil ler cada linha. É claro que se a linha sendo lida for maior que o tamanho do buffer, o efeito não será conseguido. Observe ainda que cada linha lida contém o caractere de fim de linha anexado a ela:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
 
const int TAM_BUFFER = 255; // quantidade de caracteres 
  // a serem lidos no buffer de cada vez
 
int main(int argc, char *argv[])
{
  FILE *arquivo = fopen("c:\\testes.txt", "r");
  char buffer[TAM_BUFFER];
 
  // testa se o arquivo foi aberto com sucesso
  if(arquivo != NULL){
    // vamos usar um laço para ler o conteúdo do arquivo
    // e armazenar no buffer
    while(fgets(buffer, TAM_BUFFER, arquivo)){
      printf("%s\n", buffer);
    }
 
    fclose(arquivo); // libera o ponteiro para o arquivo
  }
  else{
    printf("Nao foi possivel abrir o arquivo.");
  } 

  printf("\n\n");
  system("PAUSE");
  return 0;
}



C ::: Dicas & Truques ::: Ordenação e Pesquisa (Busca)

Ordenação e pesquisa em C - Como ordenar um vetor de inteiros usando a ordenação Insertion Sort (Ordenação por Inserção)

Quantidade de visualizações: 2623 vezes
A ordenação Insertion Sort, ou Ordenação por Inserção, possui uma complexidade de tempo de execução igual à ordenação Bubble Sort (Ordenação da Bolha), ou seja, O(n2). Embora mais rápido que o Bubble Sort, e ser um algorítmo de ordenação quadrática, a ordenação Insertion Sort é bastante eficiente para problemas com pequenas entradas, sendo o mais eficiente entre os algoritmos desta ordem de classificação, porém, nunca recomendada para um grande conjunto de dados.

A forma mais comum para o entendimento da ordenação Insertion Sort é compará-la com forma pela qual algumas pessoas organizam um baralho num jogo de cartas. Imagine que você está jogando as cartas. Você está com as cartas na mão e elas estão ordenadas. Você recebe uma nova carta e deve colocá-la na posição correta da sua mão de cartas, de forma que as cartas obedeçam à ordenação.

A cada nova carta adicionada à sua mão de cartas, a nova carta pode ser menor que algumas das cartas que você já tem na mão ou maior, e assim, você começa a comparar a nova carta com todas as cartas na sua mão até encontrar sua posição correta. Você insere a nova carta na posição correta, e, novamente, a sua mão é composta de cartas totalmente ordenadas. Então, você recebe outra carta e repete o mesmo procedimento. Então outra carta, e outra, e assim em diante, até não receber mais cartas.

Esta é a ideia por trás da ordenação por inserção. Percorra as posições do vetor (array), começando com o índice 1 (um). Cada nova posição é como a nova carta que você recebeu, e você precisa inseri-la no lugar correto no sub-vetor ordenado à esquerda daquela posição.

Vamos ver a implementação na linguagem C agora? Observe o seguinte código, no qual temos um vetor de inteiros com os elementos {4, 6, 2, 8, 1, 9, 3, 0, 11}:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

#include <stdio.h>
#include <stdlib.h>
 
// função que permite ordenar um vetor de inteiros
// usando a ordenação Insertion Sort
void insertionSort(int vetor[], int tam){
  int i, temp, j;
  
  // este laço varre os elementos a partir do segundo
  // elemento, ou seja, o índice 1
  for(i = 1; i < tam; i++){
    // guardamos o elemento atual em temp
    temp = vetor[i];
		
    for(j = i; ((j > 0) && (vetor[j - 1] > temp)); j--){ 
      vetor[j] = vetor[j - 1]; // houve uma troca
    }
    
    vetor[j] = temp; // colocamos temp em seu devido lugar
  }
}  
 
int main(int argc, char *argv[]){
  int valores[] = {4, 6, 2, 8, 1, 9, 3, 0, 11};
  int i, tamanho = 9;
 
  // imprime a matriz sem a ordenação
  puts("Sem ordenação:\n");
  for(i = 0; i < 9; i++){
    printf("%d ", valores[i]);
  }
 
  // vamos ordenar a matriz
  insertionSort(valores, tamanho);
 
  // imprime a matriz ordenada
  puts("\n\nOrdenada usando Insertion Sort:\n");
  for(i = 0; i < 9; i++){
    printf("%d ", valores[i]);
  }   
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

Ao executar este código C nós teremos o seguinte resultado:

Sem ordenação:

4 6 2 8 1 9 3 0 11

Ordenada usando Insertion Sort:

0 1 2 3 4 6 8 9 11


C ::: Dicas & Truques ::: Strings e Caracteres

Como criar sua própria função substring() para obter uma substring a partir de uma string em C

Quantidade de visualizações: 16858 vezes
Em algumas situações precisamos obter uma substring a partir de uma string. A linguagem C já fornece algumas funções que tornam isso possível. No entanto, nenhuma destas funções permite especificar o índice inicial da substring. Sendo assim, o trecho de código abaixo mostra como escrever uma função substring() que permite informar a string de origem, o índice inicial e a quantidade de caracteres que serão obtidos. O retorno da função será um ponteiro para a substring obtida:

----------------------------------------------------------------------
Se precisar de ajuda com o código abaixo, pode me chamar
no WhatsApp +55 (62) 98553-6711 (Osmar)
----------------------------------------------------------------------

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

char *substring(char *origem, int inicio, int quant){
  char *res = origem;
  int i = 0;

  // posição inicial menor que 0 ou
  // posição inicial muito exagerada?
  if((inicio < 0) || (inicio > strlen(origem)))
    inicio = 0;

  // quantidade de caracteres muito exagerada?
  if(quant > inicio + strlen(origem))
    quant = strlen(origem) - inicio;

  // obtem os caracteres desejados
  for(i = 0; i <= quant - 1; i++){
    res[i] = origem[inicio + i];
  }

  // marca o fim da string
  res[i] = '\0';

  return res;
}

int main(int argc, char *argv[])
{
  char texto[] = "Gosto muito de C e C++";
  
  // não podemos bagunçar a string original
  char sub_temp[128];
  strcpy(sub_temp, texto);
  // 10 caracteres começando
  // no índice 6
  char *res = substring(sub_temp, 6, 10);

  // exibe o resultado
  puts(res);

  // exibe a string original
  puts(texto);

  system("pause");
  return 0;
}

Ao executar este código nós teremos o seguinte resultado:

muito de C
Gosto muito de C e C++


Desafios, Exercícios e Algoritmos Resolvidos de C

Veja mais Dicas e truques de C

Dicas e truques de outras linguagens

Códigos Fonte

Programa de Gestão Financeira Controle de Contas a Pagar e a Receber com Cadastro de Clientes e FornecedoresSoftware de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimento
Diga adeus às planilhas do Excel e tenha 100% de controle sobre suas contas a pagar e a receber, gestão de receitas e despesas, cadastro de clientes e fornecedores com fotos e histórico de atendimentos. Código fonte completo e funcional, com instruções para instalação e configuração do banco de dados MySQL. Fácil de modificar e adicionar novas funcionalidades. Clique aqui e saiba mais
Controle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidadesControle de Estoque completo com código fonte em PHP, MySQL, Bootstrap, jQuery - 100% funcional e fácil de modificar e implementar novas funcionalidades
Tenha o seu próprio sistema de controle de estoque web. com cadastro de produtos, categorias, fornecedores, entradas e saídas de produtos, com relatórios por data, margem de lucro e muito mais. Código simples e fácil de modificar. Acompanha instruções para instalação e criação do banco de dados MySQL. Clique aqui e saiba mais

Linguagens Mais Populares

1º lugar: Java
2º lugar: Python
3º lugar: C#
4º lugar: PHP
5º lugar: C
6º lugar: Delphi
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



© 2025 Arquivo de Códigos - Todos os direitos reservados
Neste momento há 64 usuários muito felizes estudando em nosso site.