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

Usando um laço for para percorrer os elementos de uma matriz e exibir a soma dos valores positivos e a quantidade de valores negativos - Desafio de Programação Resolvido em C

Quantidade de visualizações: 11471 vezes
Exercícios Resolvidos de C - Usando um laço for para percorrer os elementos de uma matriz e exibir a soma dos valores positivos e a quantidade de valores negativos

Pergunta/Tarefa:

Considere a seguinte matriz de inteiros:

// uma matriz de inteiros contendo sete elementos
int valores[] = {-3, 9, 12, -34, -2, 20, 10};


Escreva um programa C que usa um laço for para percorrer todos os elementos desta matriz e exibir a soma dos valores positivos e a quantidade de valores negativos. Seu programa deverá exibir uma saída com a mensagem:

A soma dos valores positivos é: 51
A quantidade de valores negativos é: 3


Resposta/Solução:

Veja abaixo a resolução completa para esta tarefa:

----------------------------------------------------------------------
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>

int main(int argc, char *argv[])
{
  // uma matriz de inteiros contendo sete elementos
  int valores[] = {-3, 9, 12, -34, -2, 20, 10};
    
  // o primeiro passo é criar uma variável que vai receber a soma
  // dos valores positivos
  int soma_positivos = 0;

  // agora uma variável para receber a quantidade de valores negativos
  int quant_negativos = 0;
  
  int i;

  // agora vamos usar uma laço for para percorrer todos os elementos
  // da matriz
  for(i = 0; i < 7; i++){
    // vamos verificar se o valor do elemento atual é negativo
    if(valores[i] < 0){
      quant_negativos++;  
    }
    else{ // o valor é positivo
      soma_positivos = soma_positivos + valores[i]; 
    }
  }

  // vamos exibir a soma dos valores positivos
  printf("A soma dos valores positivos é: %d\n", soma_positivos);

  // vamos exibir a quantidade de valores negativos
  printf("A quantidade de valores negativos é: %d\n", quant_negativos);

  system("PAUSE");	
  return 0;
}


Link para compartilhar na Internet ou com seus amigos:

Delphi ::: Dicas & Truques ::: Bilbiotecas Estáticas (obj) e Dinâmicas (DLLs)

Como criar DLLs usando Delphi? É possível criar DLLs para o Windows usando Delphi?

Quantidade de visualizações: 12316 vezes
As DLLs (Dynamic Link Libraries - Bibliotecas de Vínculo Dinâmico) são arquivos compilados bem similares aos arquivos .exe que estamos acostumados a criar em Delphi. Uma DLL contém rotinas, recursos ou ambos. Mas, não pode ser executada por si só, ou seja, se dermos duplo-clique em uma DLL nada acontecerá.

Isso acontece porque uma DLL é desenvolvida para ser usada juntamente como outros aplicativos e/ou outras DLLs. No ambiente Windows encontramos muitas DLLs. Na verdade, o Windows e sua Win32 API é uma coleção de DLLs. Se olharmos nos diretórios System ou System32 encontraremos várias delas, incluindo kernel32.dll, gdi32.dll, user32.dll, shell32.dll, comctl32.dll, entre outras.

Mas, para que servem as DLLs? É possível desenvolver aplicações Windows sem usá-las? Vamos às respostas.

As DLLs existem com o propósito de compartilhar código entre aplicações. Isso quer dizer que uma mesma DLL pode estar sendo usada por vários programas ao mesmo tempo. E isso é verdade no ambiente Windows. Todos os programas de interface gráfica escritos em Delphi, C, C++, etc e que usam os componentes gráficos do Windows estão de alguma forma fazendo uso de códigos disponíveis em DLLs do sistema. Sem o aproveitamente de tais códigos os executáveis ficariam enormes, visto que cada um teria que implementar as rotinas de desenho e diretivas de criação de janelas. Ao aproveitar as funcionalidades disponíveis nas DLLs do sistema esta tarefa se torna muito mais fácil.

Mas, além de usar DLLs de terceiros com códigos já prontos e devidamente testados, você também pode criar suas próprias DLLs. O motivo disso é que você pode querer compartilhar algumas de suas rotinas entre os vários aplicativos que você desenvolve. A maior vantagem disso é que, ao atualizar ou corrigir o código em uma DLL você estará certo de que todas as aplicações que fazem uso desta DLL automaticamente perceberão e tirarão proveito da atualização.

Entre as vantagens do uso de DLLs podemos citar:

a) Podemos compartilhar rotinas e códigos entre várias aplicativos;

b) Ao mantermos boa parte de nossos códigos em DLLs nós conseguimos economizar memória e espaço em disco;

c) Outros desenvolvedores poderão usar nossas rotinas e lógica mesmo sem ter acesso aos nossos códigos-fontes;

d) Podemos usar códigos escritos em outras linguagens em nossos programas Delphi. Isso quer dizer que uma DLL escrita em C/C++ poderá ser usada em um programa Delphi sem qualquer problema. A prova disso é que as DLLs do Windows são escritas em C/C++.

Hora de criar sua primeira DLL em Delphi. Consulte outras dicas nesta seção para aprender a fazê-lo.

Para fins de compatibilidade, esta dica foi escrita usando Delphi 2009.


Python ::: Fundamentos da Linguagem ::: Estruturas de Controle

Como usar o laço for do Python - Apostila Python para iniciantes - O laço for

Quantidade de visualizações: 12500 vezes
O laço for (laço para) em Python é um pouco diferente daquele encontrado em Java, C ou C++. Na verdade, o laço for da Python está mais para o laço foreach do C# e o novo laço for do Java 1.5.

Em Python, o laço for funciona com sequencias (range), ou seja, a cada iteração do laço, um elemento da sequencia é retornado. Vamos ver isso mais de perto. Veja o exemplo a seguir:

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

def main():
  for i in range(1, 11):
    print(i)   
 
if __name__== "__main__":
  main()

Este trecho de código exibirá os números de 1 até 10. Veja que o último limite não é incluído na contagem. Este exemplo pode também ser escrito assim:

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

def main():
  for i in [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]:
    print(i)   
 
if __name__== "__main__":
  main()



PHP ::: Desafios e Lista de Exercícios Resolvidos ::: Arrays e Matrix (Vetores e Matrizes)

Exercícios Resolvidos de PHP - Escreva um programa PHP para mover todos os zeros para o final do vetor, sem alterar a ordem dos elementos já presentes no array

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

Dado o seguinte vetor de inteiros:

// vamos declarar e construir um vetor de 8 inteiros
$valores = array(0, 3, 0, 5, 7, 4, 0, 9);
Escreva um programa PHP para mover todos os zeros para o final do vetor, ou seja, para a direita, sem alterar a ordem dos elementos diferentes de zero já presentes no array e sem criar um vetor adicional ou temporário.

Sua saída deverá ser parecida com:

Vetor na ordem original:

0   3   0   5   7   4   0   9   

Vetor com os zeros deslocados para o final:

3   5   7   4   9   0   0   0
Resposta/Solução:

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

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

<?php
  // Este código PHP pode ser executado tanto na linha
  // de comando quanto pelo servidor web
  
  // vamos declarar e construir um vetor de 8 inteiros
  $valores = array(0, 3, 0, 5, 7, 4, 0, 9);
  	
  // vamos mostrar o vetor na ordem original
  echo("Vetor na ordem original:\n");
  for($i = 0; $i < count($valores); $i++){
    echo $valores[$i] . "  ";
  }
    
  // vamos inicializar j como 0 para que ele aponte para
  // o primeiro elemento do vetor
  $j = 0;
    
  // agora o laço for percorre todos os elementos do vetor,
  // incrementanto a variável i e deixando o j em 0
  for($i = 0; $i < count($valores); $i++){
    // encontramos um valor que não é 0
    if($valores[$i] != 0){
      // fazemos a troca entre os elementos nos índices
      // i e j
      $temp = $valores[$i];
      $valores[$i] = $valores[$j];
      $valores[$j] = $temp;
      // e avançamos o j para o elemento seguinte
      $j++;
    }
  }
    
  // agora mostramos o resultado
  echo "\n\nVetor com os zeros deslocados para o final:\n";
  for($i = 0; $i < count($valores); $i++){
    echo $valores[$i] . "  ";
  }
?>

Não se esqueça: A resolução do exercício deve ser feita sem a criação de um vetor, array ou lista adicional, e os elementos diferentes de zero devem permanecer na mesma ordem que eles estavam antes.


JavaScript ::: Dicas & Truques ::: Data e Hora

Como retornar o ano com quatro dígitos em JavaScript usando a função getFullYear() do objeto Date - Datas e horas em JavaScript

Quantidade de visualizações: 8926 vezes
Em algumas situações nós precisamos obter o ano de uma determinada data como um inteiro de quatro dígitos. Para isso nós podemos usar a função getFullYear() do objeto Date da linguagem JavaScript.

Veja o código a seguir:

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

<html>
<head>
<title>Estudando JavaScript</title>
</head>
<body>

<script type="text/javascript">
  var data = new Date();
  var ano = data.getFullYear();
  document.write("Estamos no ano: " + ano);
</script>
 
</body>
</html>

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

Estamos no ano: 2021


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

Como implementar a ordenação Quicksort em Java - Apostila de Java para iniciantes

Quantidade de visualizações: 187 vezes
A ordenação Quicksort é um dos algorítmos de ordenação mais encontrados em aplicações reais de programação. No Delphi esta ordenação é encontrada no objeto TList. No Java podemos encontrá-lo no método Arrays.sort(). Na linguagem C a ordenação Quicksort é implementada na função qsort() da biblioteca padrão.

O algoritmo de ordenação Quicksort é do tipo dividir para conquistar (divide-and-conquer principle). Neste tipo de algoritmo o problema é dividido em sub-problemas e a solução é concatenada quando as chamadas recursivas atingirem o caso base.

O vetor (ou array) a ser ordenado é dividido em duas sub-listas por um elemento chamado pivô, resultando em uma lista com elementos menores que o pivô e outra lista com os elementos maiores que o pivô. Esse processo é repetido para cada chamada recursiva. Sim, a ordenação Quicksort faz uso extensivo de recursividade, razão pela qual devemos ter muito cuidado para não estourar a pilha do sistema.

Existem muitos estudos sobre o pivô ideal para a ordenação Quicksort. Nessa dica adotarei o último elemento do array ou sub-array como pivô. Em vetores não ordenados essa estratégia, em geral, resulta em uma boa escolha.

Vamos ao código Java então? Veja um programa Java completo demonstrando o uso da ordenação Quicksort para um array de 10 elementos inteiros:

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

package estudos;

import java.util.Scanner;

public class Estudos {
  public static void main(String[] args) {
    // vamos declarar um array de 10 elementos
    int valores[] = new int[10];
    
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos pedir ao usuário para informar os valores para o vetor
    for(int i = 0; i < valores.length; i++){
      System.out.print("Informe o valor do elemento " + i + ": ");
      valores[i] = Integer.parseInt(entrada.nextLine()); 
    }

    // vamos mostrar o array informado
    System.out.println("\nO array informado foi:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");
    }
    
    // vamos ordenar o vetor usando a ordenação Quicksort
    quickSort(valores, 0, valores.length - 1);
    
    System.out.println("\n\nO array ordenado é:\n");
    for(int i = 0; i < valores.length; i++){
      System.out.print(valores[i] + "  ");
    }
    
    System.out.println("\n\n");
  }

  // função de implementação da ordenação Quicksort
  public static void quickSort(int vetor[], int inicio, int fim) {
    // o início é menor que o fim?
    if (inicio < fim) {
      // vamos obter o novo índice da partição
      int indiceParticao = particionar(vetor, inicio, fim);

      // efetuamos novas chamadas recursivas
      quickSort(vetor, inicio, indiceParticao - 1);
      quickSort(vetor, indiceParticao + 1, fim);
    }
  }
  
  // função que retorna o índice de partição
  private static int particionar(int vetor[], int inicio, int fim) {
    // para guardar o pivô
    int pivot = vetor[fim];
    int i = (inicio - 1);
 
    for (int j = inicio; j < fim; j++) {
      if (vetor[j] <= pivot) {
        i++;

        // fazemos a troca
        int temp = vetor[i];
        vetor[i] = vetor[j];
        vetor[j] = temp;
      }
    }

    // efetua a troca
    int temp = vetor[i + 1];
    vetor[i + 1] = vetor[fim];
    vetor[fim] = temp;

    return i + 1;
  }
}

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

Informe o valor do elemento 0: 7
Informe o valor do elemento 1: 2
Informe o valor do elemento 2: 43
Informe o valor do elemento 3: 1
Informe o valor do elemento 4: 9
Informe o valor do elemento 5: 6
Informe o valor do elemento 6: 22
Informe o valor do elemento 7: 3
Informe o valor do elemento 8: 37
Informe o valor do elemento 9: 5

O array informado foi:

7 2 43 1 9 6 22 3 37 5

O array ordenado é:

1 2 3 5 6 7 9 22 37 43


Desafios, Exercícios e Algoritmos Resolvidos de Java

Veja mais Dicas e truques de Java

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: Delphi
6º lugar: C
7º lugar: JavaScript
8º lugar: C++
9º lugar: VB.NET
10º lugar: Ruby



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