![]() |
|
||||
Código-Fonte Software de Gestão Financeira com código fonte em PHP, MySQL, Bootstrap, jQuery - Inclui cadastro de clientes, fornecedores e ticket de atendimentoDiga 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 |
|||||
Você está aqui: Cards de |
||
|
||
|
|
||
Python ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas |
Como calcular o arco cosseno de um número em Python usando o método acos() do módulo mathQuantidade de visualizações: 3756 vezes |
|
O arco cosseno, (também chamado de cosseno inverso) pode ser representado por cos-1 x, arccos x ou acos x. Esta função é a inversa do cosseno, ou seja, se o cosseno é a relação entre o cateto adjacente ao ângulo e a hipotenusa, o arco cosseno parte desta relação para encontrar o valor do ângulo. Em Python, o arco cosseno de um número pode ser obtido por meio do método acos() da classe Math. Este método recebe um valor double e retorna também um double, na faixa 0 <= x <= PI, onde PI vale 3.1416. Veja um código Python completo no qual informamos um número e em seguida calculamos o seu arco-cosseno:
# vamos importar o módulo Math
import math as math
def main():
numero = 0.5
print("O arco cosseno de %f é %f" % (numero, math.acos(numero)))
if __name__== "__main__":
main()
Ao executar este código nós teremos o seguinte resultado: O arco cosseno de 0.500000 é 1.047198 Não se esqueça de que as funções trigonométricas são usadas para modelar o movimento das ondas e fenômenos periódicos, como padrões sazonais. Elas formam a base para análises avançadas em engenharia elétrica, processamento digital de imagem, radiografia, termodinâmica, telecomunicações e muitos outros campos da ciência e da tecnologia. |
HTML5 ::: HTML5 + JavaScript ::: Canvas |
Programação gráfica para iniciantes - Como desenhar círculos com ou sem preenchimento usando o método arc() do objeto Canvas do HTML5Quantidade de visualizações: 7189 vezes |
Podemos usar o método arc() do objeto Canvas do HTML5 para desenhar círculos com ou sem prenchimento. Veja nos exemplos abaixo como isso pode ser feito. Primeiro um círculo sem preenchimento:
<!doctype html>
<html>
<head>
<title>O objeto Canvas do HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
// vamos desenhar um círculo sem preenchimento com raio de 80
contexto.beginPath(); // início um novo caminho
// o círculo começa no x = 100, y = 100, começa no ângulo 0
// e vai até o ângulo 360 (as medidas são em radianos, não em graus)
contexto.arc(100, 100, 80, 0, 2 * Math.PI, false);
contexto.lineWidth = 2; // largura da linha
contexto.strokeStyle = '#990000'; // cor da linha
contexto.stroke(); // realiza o desenho
</script>
</body>
</html>
Ao abrir esta página HTML nós teremos o seguinte resultado: ![]() E agora um círculo preenchido:
<!doctype html>
<html>
<head>
<title>O objeto Canvas do HTML5</title>
</head>
<body>
<Canvas id="canvas1" width="500" height="350"></Canvas>
<script type="text/javascript">
// obtemos uma referência ao elemento Canvas
var canvas = document.getElementById("canvas1");
// obtemos o contexto de desenho
var contexto = canvas.getContext("2d");
// vamos desenhar um círculo sem preenchimento com raio de 80
contexto.beginPath(); // início um novo caminho
// o círculo começa no x = 100, y = 100, começa no ângulo 0
// e vai até o ângulo 360 (as medidas são em radianos, não em graus)
contexto.arc(100, 100, 80, 0, 2 * Math.PI, false);
// vamos preencher o círculo
contexto.fillStyle = "#CCCCCC"; // cor do preenchimento
contexto.fill(); // preenche de fato
contexto.lineWidth = 2; // largura da linha
contexto.strokeStyle = '#990000'; // cor da linha
contexto.stroke(); // realiza o desenho
</script>
</body>
</html>
Ao abrir esta página HTML nós teremos o seguinte resultado: ![]() |
C++ ::: Desafios e Lista de Exercícios Resolvidos ::: STL Vector C++ |
Exercício Resolvido de C++ - Escreva um programa C++ com uma função chamada possui_numeros() que recebe um Vector de strings como argumentoQuantidade de visualizações: 494 vezes |
|
Pergunta/Tarefa: Escreva um programa C++ com uma função chamada possui_numeros() que recebe um Vector de strings como argumento e retorna outro Vector contendo apenas as strings que possuem um ou mais números. Se nenhuma das strings recebidas passar no teste, retorne um Vector vazio. Sua saída deverá ser parecida com: Elementos do Vector original: livro mesa7 cami45sa porta Palavras que possuem um ou mais números: mesa7 cami45sa Veja a resolução comentada deste exercício em C++:
#include <iostream>
#include <vector>
using namespace std;
// função que recebe um vetor de strings e retorna
// outro vector contendo apenas as strings que possuem
// um ou mais números
vector<string> possui_numeros(vector<string> palavras) {
// para guardar o resultado
vector<string> resultado;
// vamos percorrer os itens do vector recebido
for(string palavra : palavras) {
// agora percorremos os caracteres de cada string
for(char carac : palavra) {
// é um caractere?
if(isdigit(carac)) {
// adicionamos no segundo vector
resultado.push_back(palavra);
break;
}
}
}
// retorna o vector obtido
return resultado;
}
// função principal do programa
int main(int argc, char *argv[]){
// vamos criar um vector de palavras
vector<string> palavras = {"livro", "mesa7", "cami45sa", "porta"};
// vamos mostrar o conteúdo do vector original
cout << "Elementos do Vector original:\n";
for (string palavra : palavras) {
cout << palavra << " ";
}
// agora obtemos um vector com as palavras que contenham um ou mais
// números
vector<string> resultado = possui_numeros(palavras);
// e mostramos o resultado
cout << "\n\nPalavras que possuem um ou mais números:\n";
for (string palavra : resultado) {
cout << palavra << " ";
}
cout << "\n\n";
system("PAUSE"); // pausa o programa
return EXIT_SUCCESS;
}
|
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Dados - Árvores Binárias e Árvores Binárias de Busca |
Exercícios Resolvidos de Java - Como pesquisar um valor em uma árvore binária de busca usando uma função recursivaQuantidade de visualizações: 4557 vezes |
|
Pergunta/Tarefa: Escreva uma função recursiva em Java que permite pesquisar um valor em uma árvore binária de busca (BST). Se o valor for encontrado, uma referência ao nó da árvore (um objeto da classe NoArvore, por exemplo) deverá ser retornado. Caso contrário, o valor null deverá ser retornado para indicar que não há nós na árvore contendo tal valor. Sua saída deverá ser parecida com: Informe um valor inteiro: 7 Informe um valor inteiro: 1 Informe um valor inteiro: 8 Informe um valor inteiro: 10 Informe um valor inteiro: 4 Informe o valor a ser pesquisado: 3 O valor não foi encontrado na árvore Informe um valor inteiro: 8 Informe um valor inteiro: 2 Informe um valor inteiro: 35 Informe um valor inteiro: 4 Informe um valor inteiro: 7 Informe o valor a ser pesquisado: 4 O valor foi encontrado na árvore Veja a resolução comentada deste exercício usando Java: Código para NoArvore.java:
package estudos;
public class NoArvore {
int valor; // valor armazenado no nó
NoArvore esquerdo; // filho esquerdo
NoArvore direito; // filho direito
// construtor do nó
public NoArvore(int valor){
this.valor = valor;
}
}
Código para ArvoreBinariaBusca.java:
package estudos;
public class ArvoreBinariaBusca {
private NoArvore raiz; // referência para a raiz da árvore
// método usado para inserir um novo nó na árvore
// retorna true se o nó for inserido com sucesso e false
// se o elemento
// não puder ser inserido (no caso de já existir um
// elemento igual)
public boolean inserir(int valor){
// a árvore ainda está vazia?
if(raiz == null){
// vamos criar o primeiro nó e definí-lo como a raiz da árvore
raiz = new NoArvore(valor); // cria um novo nó
}
else{
// localiza o nó pai
NoArvore pai = null;
NoArvore noAtual = raiz; // começa a busca pela raiz
// enquanto o nó atual for diferente de null
while(noAtual != null){
if(valor < noAtual.valor) {
pai = noAtual;
noAtual = noAtual.esquerdo;
}
else if(valor > noAtual.valor){
pai = noAtual;
noAtual = noAtual.direito;
}
else{
return false; // um nó com este valor foi encontrado
}
}
// cria o novo nó e o adiciona ao nó pai
if(valor < pai.valor){
pai.esquerdo = new NoArvore(valor);
}
else{
pai.direito = new NoArvore(valor);
}
}
return true; // retorna true para indicar que o novo nó
// foi inserido
}
// método que permite pesquisar na árvore binária de busca
public NoArvore pesquisar(int valor){
return pesquisar(raiz, valor); // chama a versão recursiva
// do método
}
// sobrecarga do método pesquisar que recebe dois
// parâmetros (esta é a versão recursiva do método)
private NoArvore pesquisar(NoArvore noAtual, int valor){
// o valor pesquisado não foi encontrado....vamos retornar null
if(noAtual == null){
return null;
}
// o valor pesquisado foi encontrado?
if(valor == noAtual.valor){
return noAtual; // retorna o nó atual
}
// ainda não encontramos...vamos disparar uma nova
// chamada para a sub-árvore da esquerda
else if(valor < noAtual.valor){
return pesquisar(noAtual.esquerdo, valor);
}
// ainda não encontramos...vamos disparar uma nova
// chamada para a sub-árvore da direita
else{
return pesquisar(noAtual.direito, valor);
}
}
}
E aqui está o código para a classe que permite testar a árvore:
package estudos;
import java.util.Scanner;
public class Estudos {
public static void main(String[] args) {
Scanner entrada = new Scanner(System.in);
// vamos criar um novo objeto da classe ArvoreBinariaBusca
ArvoreBinariaBusca arvore = new ArvoreBinariaBusca();
// vamos inserir 5 valores na árvore
for(int i = 0; i < 5; i++){
System.out.print("Informe um valor inteiro: ");
int valor = Integer.parseInt(entrada.nextLine());
// vamos inserir o nó e verificar o sucesso da operação
if(!arvore.inserir(valor)){
System.out.println("Erro. Um elemento já contém este valor.");
}
}
// vamos pesquisar um valor na árvore
System.out.print("\nInforme o valor a ser pesquisado: ");
int valorPesquisa = Integer.parseInt(entrada.nextLine());
// obtém um objeto da classe NoArvore a partir do
// método pesquisar() da classe ArvoreBinariaBusca
NoArvore res = arvore.pesquisar(valorPesquisa);
// o valor foi encontrado?
if(res != null){
System.out.println("O valor foi encontrado na árvore");
}
else{
System.out.println("O valor não foi encontrado na árvore");
}
System.out.println("\n");
}
}
|
Java ::: Desafios e Lista de Exercícios Resolvidos ::: Ordenação e Pesquisa (Busca) |
Exercícios Resolvidos de Java - Como usar a Ordenação da Bolha em Java para ordenar os valores de um vetor em ordem crescente ou decrescenteQuantidade de visualizações: 3995 vezes |
|
Pergunta/Tarefa: A Ordenação da Bolha, ou ordenação por flutuação (literalmente "por bolha"), também chamada de Bubble Sort, é um algoritmo de ordenação dos mais simples. A ideia é percorrer o array diversas vezes, a cada passagem fazendo flutuar para o topo o maior elemento da sequência. Essa movimentação lembra a forma como as bolhas em um tanque de água procuram seu próprio nível, e disso vem o nome do algoritmo. No melhor caso, o algoritmo executa n operações relevantes, onde n representa o número de elementos do vetor. No pior caso, são feitas n2 operações. A complexidade desse algoritmo é de ordem quadrática. Por isso, ele não é recomendado para programas que precisem de velocidade e operem com quantidade elevada de dados. Escreva um programa Java que declara, constrói um vetor de 10 inteiros e peça para o usuário informar os valores de seus elementos. Em seguida use a ordenação da bolha para ordenar os elementos em ordem crescente. Sua saída deverá ser parecida com: Informe o valor para o índice 0: 84 Informe o valor para o índice 1: 23 Informe o valor para o índice 2: 9 Informe o valor para o índice 3: 5 Informe o valor para o índice 4: 11 Informe o valor para o índice 5: 3 Informe o valor para o índice 6: 50 Informe o valor para o índice 7: 7 Informe o valor para o índice 8: 2 Informe o valor para o índice 9: 73 O array informado foi: 84 23 9 5 11 3 50 7 2 73 O array ordenado é: 2 3 5 7 9 11 23 50 73 84 Veja a resolução comentada deste exercício usando Java:
package estudos;
import java.util.Scanner;
public class Estudos {
public static void main(String[] args) {
// vamos declarar e construir um vetor de 10 elementos
int valores[] = new int[10];
// para ler a entrada do usuário
Scanner entrada = new Scanner(System.in);
// vamos pedir que o usuário informe os valores
for(int i = 0; i < valores.length; i++){
System.out.print("Informe o valor para o índice " + i + ": ");
valores[i] = Integer.parseInt(entrada.nextLine());
}
// vamos mostrar o vetor informado
System.out.println("\nO array informado foi:\n");
for(int i = 0; i < valores.length; i++){
System.out.print(valores[i] + " ");
}
// vamos ordenar os elementos do vetor usando a ordenação da bolha
// laço externo de trás para frente
for(int i = valores.length - 1; i > 1; i--){
for(int j = 0; j < i; j++){ // laço interno vai no fluxo normal
if(valores[j] > valores[j + 1]){ // temos que trocá-los de lugar
int temp = valores[j];
valores[j] = valores[j + 1];
valores[j + 1] = temp;
}
}
}
// vamos exibir o vetor já ordenado
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");
}
}
|
Mais Desafios de Programação e Exercícios e Algoritmos Resolvidos de Java |
Veja mais Dicas e truques de Java |
Dicas e truques de outras linguagens |
E-Books em PDF |
||||
|
||||
|
||||
Linguagens Mais Populares |
||||
|
1º lugar: Java |








