Você está aqui: GoLang ::: Desafios e Lista de Exercícios Resolvidos ::: Estruturas de Controle |
Exercícios Resolvidos de Go - Um programa que lê duas notas, calcula a média aritmética e exibe uma mensagem de reprovado, exame ou aprovado - Lista de Exercícios Resolvidos de GoLangQuantidade de visualizações: 245 vezes |
Pergunta/Tarefa: Escreva um programa Golang que leia duas notas (como float64), calcule e mostre a média aritmética e uma mensagem de acordo com as seguintes regras: 1) Se a média for inferior a 4,0 escreva "Reprovado"; 2) Se a média for igual ou superior a 4,0 e inferior a 7,0 escreva "Exame"; 3) Se a média for igual ou superior a 7,0 escreva "Aprovado". Sua saída deverá ser parecida com: Informe a primeira nota: 8 Informe a segunda nota: 7.4 A média obtida foi: 7.7 Aprovado Veja a resolução comentada deste exercício usando Go: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // Algoritmo Golang para calcular a média de um aluno // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { // variáveis que vamos usar na resolução do problema var n1, n2, media float64 // vamos solicitar as duas notas do aluno fmt.Printf("Informe a primeira nota: ") fmt.Scanln(&n1) fmt.Printf("Informe a segunda nota: ") fmt.Scanln(&n2) // vamos calcular a média aritmética media = (n1 + n2) / 2 fmt.Printf("A média obtida foi: %f", media) // vamos verificar se o aluno foi reprovado, está de exame ou aprovado if (media < 4.0) { // reprovado fmt.Printf("\nReprovado") }else if ((media >= 4.0) && (media < 7.0)) { // exame fmt.Printf("\nExame") }else { fmt.Printf("\nAprovado") } } |
![]() |
GoLang ::: Desafios e Lista de Exercícios Resolvidos ::: Geometria, Trigonometria e Figuras Geométricas |
Exercícios Resolvidos de Golang - Como calcular a área de um losango em GoQuantidade de visualizações: 821 vezes |
Pergunta/Tarefa: Um losango é um quadrilátero equilátero, ou seja, é um polígono formado por quatro lados de igual comprimento. Um losango é também um paralelogramo. Alguns autores exigem ainda que nenhum dos ângulos do quadrilátero seja reto para que ele seja considerado um losango. A área (em metros quadrados) de um losango pode ser calculada usando-se a seguinte fórmula: ![]() Onde D1 é a diagonal maior e D2 é a diagonal menor. Escreva um programa Golang que leia a diagonal maior e a diagonal menor e calcule a área do losango. Sua saída deverá ser parecida com: Informe a medida da diagonal maior: 5 Informe a medida da diagonal menor: 10 A área (em metros quadrados) do losango é: 25 Veja a resolução comentada deste exercício usando Go: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { // variáveis que vamos usar na resolução do problema var diagonal_maior, diagonal_menor int var area float32 // vamos ler os valores das diagonais maior e menor fmt.Print("Informe a medida da diagonal maior: ") fmt.Scanln(&diagonal_maior) fmt.Print("Informe a medida da diagonal menor: ") fmt.Scanln(&diagonal_menor) // calcula a area do losango area = float32((diagonal_maior * diagonal_menor)) / 2 // mostra o resultado fmt.Printf("A área (em metros quadrados) é: %.2f", area) } |
GoLang ::: Fundamentos da Linguagem ::: Laços |
Como usar o laço for em GoLang - O laço for da linguagem GoQuantidade de visualizações: 813 vezes |
Como todas (ou praticamente todas) as linguagens de programação, a GoLang também possui o seu laço for, ou loop for. Este laço é usado para repetir uma ou mais instruções quando sabemos exatamente quantas vezes essa repetição ocorrerá. Em Go, o laço for é composto de três partes: inicialização, teste de continuidade e incremento ou decremento da variável de controle. Na parte da inicialização nós declaramos e inicializamos as variáveis que serão usadas dentro da estrutura. O teste de continuidade é a parte na qual verificamos se o laço deverá continuar repetindo ou encerrar. Finalmente, a parte de incremento ou decremento é usada para ajustarmos a variável de controle do laço. Veja, por exemplo, como escrever um laço for em GoLang que contará de 1 até 10, escrevendo os números na tela: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { for i := 1; i <= 10; i++ { fmt.Printf("%d ", i) } } Ao executar este código Go nós teremos o seguinte resultado: 1 2 3 4 5 6 7 8 9 10 O laço for da linguagem GoLang nos permite omitir as partes da inicialização e de incremento ou decremento, embora esse tipo de código não seja muito usual. Veja um trecho de código no qual usamos o laço for da linguagem Go para contar de 10 até 0 (omitindo a parte da inicialização da variável de controle): ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { i := 10 // definimos o valor inicial aqui for ; i >= 0; i-- { fmt.Printf("%d ", i) } } Ao executarmos este código Go nós teremos o seguinte resultado: 10 9 8 7 6 5 4 3 2 1 0 Veja, agora, uma modificação do código acima. Desta vez eu omiti a parte de incremento ou decremento da variável de controle: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { for i := 10; i >= 0; { fmt.Printf("%d ", i) i-- } } |
GoLang ::: Fundamentos da Linguagem ::: Variáveis e Constantes |
Como declarar variáveis em Go usando var e sem definir o tipo da variávelQuantidade de visualizações: 309 vezes |
Em algumas situações nós queremos declarar variáveis na linguagem Go mas não queremos definir de antemão o tipo, ou seja, se ela será do tipo int, float, boolean, string, etc. Essa situação é muito comum quando a variável receberá o retorno de uma função. Quando não definimos o tipo da variável, a própria linguagem se encarrega de fazer isso para nós, por meio da inferência de tipos. Assim, dependendo do valor que a variável recebe, o seu tipo será definido automaticamente. Veja um exemplo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar os módulos necessários import ( "fmt" ) // esta é a função principal do programa func main() { // vamos declarar uma variável do tipo real // Como não definimos o tipo, ele será // automaticamente float64 var salario = 1250.94 // vamos mostrar o tipo da variável fmt.Printf("O tipo da variável é: %T", salario) } Ao executarmos este código Golang nós teremos o seguinte resultado: O tipo da variável é: float64 |
GoLang ::: Dicas & Truques ::: Geometria, Trigonometria e Figuras Geométricas |
Como calcular a equação reduzida da reta em GoLang dados dois pontos pertencentes à retaQuantidade de visualizações: 749 vezes |
Nesta dica de Go veremos como calcular a equação reduzida da reta quando temos dois pontos pertencentes à esta reta. Não, nessa dica não vamos calcular a equação geral da reta, apenas a equação reduzida. Em outras dicas do site você encontra como como isso pode ser feito. Para relembrar: a equação reduzida da reta é y = mx + n, em que x e y são, respectivamente, a variável independente e a variável dependente; m é o coeficiente angular, e n é o coeficiente linear. Além disso, m e n são números reais. Com a equação reduzida da reta, é possível calcular quais são os pontos que pertencem a essa reta e quais não pertencem. Vamos começar então analisando a seguinte figura, na qual temos dois pontos que pertencem à uma reta: ![]() Note que a reta da figura passa pelos pontos A(5, 5) e B(9, 2). Então, uma vez que já temos os dois pontos, já podemos calcular a equação reduzida da reta. Veja o código GoLang completo para esta tarefa: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar o módulo de formatação de // entrada e saída import "fmt" // esta é a função principal do programa func main() { // variáveis que vamos usar na resolução do problema var x1, y1, x2, y2, m, n float32 var sinal string // vamos ler as coordenadas do primeiro ponto fmt.Print("Coordenada x do primeiro ponto: ") fmt.Scanln(&x1) fmt.Print("Coordenada y do primeiro ponto: ") fmt.Scanln(&y1) // vamos ler as coordenadas do segundo ponto fmt.Print("Coordenada x do segundo ponto: ") fmt.Scanln(&x2) fmt.Print("Coordenada y do segundo ponto: ") fmt.Scanln(&y2) sinal = "+" // vamos calcular o coeficiente angular da reta m = (y2 - y1) / (x2 - x1) // vamos calcular o coeficiente linear n = y1 - (m * x1) // coeficiente linear menor que zero? O sinal será negativo if n < 0 { sinal = "-" n = n * -1 } // mostra a equação reduzida da reta fmt.Printf("Equação reduzida: y = %.2fx %s %.2f", m, sinal, n); } Ao executar este código GoLang nós teremos o seguinte resultado: Coordenada x do primeiro ponto: 5 Coordenada y do primeiro ponto: 5 Coordenada x do segundo ponto: 9 Coordenada y do segundo ponto: 2 Equação reduzida: y = -0,75x + 8,75 Para testarmos se nossa equação reduzida da reta está realmente correta, considere o valor 3 para o eixo x da imagem acima. Ao efetuarmos o cálculo: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- >> y = (-0.75 * 3) + 8.75 y = 6.5000 temos o valor 6.5 para o eixo y, o que faz com que o novo ponto caia exatamente em cima da reta considerada na imagem. |
GoLang ::: Dicas & Truques ::: Strings e Caracteres |
Como retornar o tamanho de uma string em Golang usando os métodos len() e RuneCountInString()Quantidade de visualizações: 714 vezes |
Em algumas situações nós precisamos obter e retornar o tamanho de uma string, ou seja, a quantidade de caracteres em uma palavra, frase ou texto. Para isso nós podemos duas funções na linguagem Go: len() e RuneCountInString(). O método len() retorna a quantidade de bytes contidos em uma string. Note, porém, que esta função não é recomendada quando estamos lidando com caracteres do conjunto utf8, que requerem dois bytes. Dessa forma, se estivermos certos de que a string não possui acentos ou caracteres especiais, então o método len() é o mais adequado. Veja um trecho de código Golang no qual pedimos para o usuário informar uma palavra ou frase e em seguida nós informamos a quantidade de caracteres contidos nela: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar os módulos necessários import ( "bufio" "fmt" "os" "strings" ) // esta é a função principal do programa func main() { // variáveis que vamos usar na resolução do problema var frase string var tamanho int // vamos pedir para o usuário informar uma // palavra ou frase fmt.Print("Informe uma palavra ou frase: ") var entrada = bufio.NewReader(os.Stdin) frase, _ = entrada.ReadString('\n') frase = strings.TrimSpace(frase) // vamos obter o tamanho da string tamanho = len(frase) // e mostramos o resultado fmt.Printf("A palavra ou frase contém %d caracteres", tamanho) } Ao executarmos este código Go nós teremos o seguinte resultado: Informe uma palavra ou frase: Gosto de Python A palavra ou frase contém 15 caracteres Se contarmos a quantidade de caracteres na string informada, realmente veremos que o código retornou o resultado esperado. O problema acontece quando informamos uma palavra ou frase com acentos ou caracteres especiais. Experimente e veja que a função len() começa a retornar uma contagem estranha. Quando nossas strings possuem caracteres especiais ou com acentos, a função a ser usada é RuneCountInString(). Veja: ---------------------------------------------------------------------- Se precisar de ajuda com o código abaixo, pode me chamar no WhatsApp +55 (62) 98553-6711 (Osmar) ---------------------------------------------------------------------- // pacote principal package main // vamos importar os módulos necessários import ( "bufio" "fmt" "os" "unicode/utf8" "strings" ) // esta é a função principal do programa func main() { // variáveis que vamos usar na resolução do problema var frase string var tamanho int // vamos pedir para o usuário informar uma // palavra ou frase fmt.Print("Informe uma palavra ou frase: ") var entrada = bufio.NewReader(os.Stdin) frase, _ = entrada.ReadString('\n') frase = strings.TrimSpace(frase) // vamos obter o tamanho da string tamanho = utf8.RuneCountInString(frase) // e mostramos o resultado fmt.Printf("A palavra ou frase contém %d caracteres", tamanho) } Ao executarmos este novo código nós teremos o resultado: Informe uma palavra ou frase: Código A palavra ou frase contém 6 caracteres |
Veja mais Dicas e truques de GoLang |
Dicas e truques de outras linguagens |
Quem Somos |
![]() Entre em contato comigo para, juntos, vermos em que posso contribuir para resolver ou agilizar o desenvolvimento de seus códigos.
|
![]() Não basta ter um site. É necessário ter um site que é localizado e converte usuários em clientes. Se sua página não faz isso, Fale comigo e vamos fazer uma analise e conseguir resultados mais satisfatórios..
|
Linguagens Mais Populares |
1º lugar: Java |
Códigos Fonte |
![]() 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 |
![]() 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 |