PHP ::: Dicas & Truques ::: Data e Hora

Como gerar um calendário mensal completo para um determinado mês e ano usando PHP

Quantidade de visualizações: 453 vezes
Nesta dica eu mostro como podemos usar as principais funções de data e hora da linguagem PHP para montar um calendário PHP completo (com comentários e fácil de modificar). Basta passar um mês e ano e a função se encarrega do restante.

Este código é muito útil em aplicações PHP para escolas, faculdades, sistemas financeiros, etc. Veja o resultado na imagem abaixo:



E agora o código completo:

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

<?php
  // função que permite montar o calendário
  function montar_calendario($mes, $ano){
    // um vetor para guardar os meses
    $meses = array(1 => 'Janeiro', 2 => 'Fevereiro', 
      3 => 'Março', 4 => 'Abril', 5 => 'Maio', 
      6 => 'Junho', 7 => 'Julho', 8 => 'Agosto', 
      9 => 'Setembro', 10 => 'Outubro', 11 => 'Novembro',
      12 => 'Dezembro');
  
    // um vetor com os dias da semana
    $dias_semana = array('Dom', 'Seg', 'Ter', 'Qua',
      'Qui', 'Sex', 'Sáb');
  
    // vamos obter o primeiro dia do calendário
    $primeiro_dia = mktime(0, 0, 0, $mes, 1, $ano);
    // obtém a quantidade de dias no mês  
    $dias_mes = date('t', $primeiro_dia);  
    // dia da semana que o calendário inicia (começa em 0)
    $dia_inicio = date('w', $primeiro_dia);
    
    // cria a tabela HTML para o calendário
    echo '<table border="1" cellspacing="0" cellpadding="4">
      <tr><th colspan="7">'. $meses[$mes] . ' - ' . 
       $ano . '</th>
      </tr>
      <tr><td align="center">';
       echo implode('</td><td align="center">', $dias_semana);
    echo '</td></tr>';
   
    // precisamos de células vazias até encontrarmos
    // o dia inicial da semana
    if($dia_inicio > 0){ 
      for($i = 0; $i < $dia_inicio; $i++){ 
        echo '<td>&nbsp;</td>'; 
      }
    }
   
    // agora já podemos começar a preencher o
    // calendário
    for($dia = 1; $dia <= $dias_mes; $dia++ ){
      if($dia_inicio == 0){
        // vamos colorir o domingo de vermelho
        $estilo = ' style="color: red"';
      } 
      else{
        $estilo = '';
      }     

      // vamos colocar a data de hoje sublinhada
      if(($dia == date("j")) && ($mes == date("n")) && 
       ($ano == date("Y"))){
         echo '<td ' . $estilo . ' align="center"><u>' 
           . $dia . '</u></td>';
      }
      else{
        echo '<td ' . $estilo . ' align="center">' . 
          $dia . '</td>';
      }
     
      // vamos incrementar o dia de referência 
      $dia_inicio++;
     
      // já precisamos adicionar uma nova linha na tabela?
      if($dia_inicio == 7){
        $dia_inicio = 0;
        echo "</tr>";

        if($dia < $dias_mes){
          echo '<tr>';
        }
      }
    } // fim do laço for
   
    // agora preenchemos as células restantes
    if($dia_inicio > 0){
      for($i = $dia_inicio; $i < 7; $i++){
        echo '<td>&nbsp;</td>';
      }
   
      echo '</tr>';
    }
 
    echo '</table>';
  }
 
  // vamos montar o mês de março de 2021
  montar_calendario(3, 2021);
?>
 
</body>
</html>



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

Como inverter uma string em C++ usando as funções begin(), end() e reverse()

Quantidade de visualizações: 13432 vezes
Em várias situações nós precisamos inverter a ordem dos caracteres de uma palavra, frase ou texto em C++. Para isso nós podemos usar uma combinação das funções begin(), end() e reverse() da biblioteca padrão do C++.

Veja o código completo para o exemplo:

#include <string>
#include <iostream>
#include <algorithm> 
 
using namespace std;
 
// função principal do programa C++ 
int main(int argc, char *argv[]){
  // vamos declarar um objeto da classe string
  string frase = "Gosto de programar em C++";
     
  // vamos mostrar a string original
  cout << "String original: " << frase << endl;   
     
  // agora vamos usar a função reverse() para inverter o 
  // conteúdo da string
  reverse(frase.begin(), frase.end());
      
  // e mostramos o resultado    
  cout << "String invertida: " << frase << endl;;
     
  cout << "\n" << endl;	    
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

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

String original: Gosto de programar em C++
String invertida: ++C me ramargorp ed otsoG


GNU Octave ::: GNU Octave para Engenharia ::: Cálculo Diferencial e Integral

Como calcular a derivada de uma função usando a função diff() do GNU Octave - Regra do Tombo (ou Regra da Potência)

Quantidade de visualizações: 3666 vezes
No cálculo, a derivada em um ponto de uma função y = f(x) representa a taxa de variação instantânea de y em relação a x neste ponto.

Um exemplo típico é a função velocidade que representa a taxa de variação (derivada) da função espaço. Do mesmo modo, a função aceleração é a derivada da função velocidade.

Geometricamente, a derivada no ponto x = a de y = f(x) representa a inclinação da reta tangente ao gráfico desta função no ponto (a,~f(a)). A função que a cada ponto x associa a derivada neste ponto de f(x) é chamada de função derivada de f(x). [Citação da Wikipédia]

Nesta dica mostrarei como podemos usar a função diff() do GNU Octave para calcular a derivada de uma função usando a Regra do Tombo ou, mais formalmente, a Regra da Potência.

Dada uma função:



A Regra do Tombo pede que o n desça e multiplique o x, que agora estará elevado a n - 1. Vamos ver um exemplo então? Observe como a derivada de f(x) = x5 é calculada na imagem a seguir:



Veja agora como podemos fazer este cálculo em GNU Octave. Para isso, abra a janela de comandos e dispare as linhas a seguir:

>> pkg load symbolic [ENTER]
>> syms x [ENTER]
>> f = x ** 5 [ENTER]
f = (sym)

   5
  x

>> diff(f, x) [ENTER]
ans = (sym)

     4
  5*x

>>

É possível que, após o comando "syms x" você veja algumas mensagens de aviso relacionadas à sua versão instalada do Python. Não se preocupe, pois esses avisos não interferem na funcionalidade da função diff().


Python ::: Python para Engenharia ::: Engenharia Civil - Cálculo Estrutural

Como calcular o Índice de Esbeltez de um pilar em Python - Python para Engenharia Civil e Cálculo Estrutural

Quantidade de visualizações: 317 vezes


O índice de esbeltez de um pilar, representado pela letra grega &#955; (lambda) é uma relação que mede a altura do pilar em relação à sua largura ou seção transversal. Esse índice é usado para avaliar a suscetibilidade de um pilar à flambagem, que é um tipo de falha estrutural que pode ocorrer em pilares esbeltos sob compressão.

Segundo a NBR 6118, 15.8.2, os pilares devem ter índice de esbeltez menor ou igual a 200 (&#955; &#8804; 200). Apenas no caso de postes com força normal menor que 0,10 fcd x Ac, o índice de esbeltez pode ser maior que 200.

O índice de esbeltez é a razão entre o comprimento de flambagem e o raio de giração, nas direções a serem consideradas. De acordo com o comprimento de flambagem, os pilares classificam-se como: curto, se &#955; < 35; medianamente esbelto, se 35 < &#955; < 90; esbelto, se 90 < &#955; < 140; e muito esbelto, se 140 < &#955; < 200.

A fórmula para o cálculo do índice de esbeltez pode ser definida como:

\[\lambda = 3,46 \cdot \frac{le}{h} \]

Onde:

&#955; = número adimensional representando o índice de esbeltez ao longo da direção escolhida (x ou y);

le = algura do pilar, ou seja, o comprimento do pilar em centímetros.

h = dimensão escolhida (x ou y) em centímetros.

De acordo com a norma NBR 6118 (ABNT, 2014), se o índice de esbeltez na direção escolhida for menor que 35, nós não precisamos considerar os efeitos locais de 2ª ordem.

Vamos agora ao código Python? Pediremos ao usuário para informar o comprimento (altura) do pilar em metros, as dimensões nas direções x e y e mostraremos os índices de esbeltez nas direções x e y do pilar com as respectivas anotações da necessidade ou não da consideração dos efeitos locais de 2ª ordem. Veja:

# método principal
def main():
  # vamos pedir o comprimento do pilar em metros (pé direito)
  le = float(input("Informe o comprimento do pilar (em metros): "))
  # vamos converter o comprimento em metros para centímetros
  le = le * 100.0

  # vamos pedir as dimensões do pilar
  hx = float(input("Informe a dimensão do pilar na direção x (em cm): "))
  hy = float(input("Informe a dimensão do pilar na direção y (em cm): "))

  # agora vamos calcular o índice de esbeltez na direção x
  lambda_x = 3.46 * (le / hx)

  # agora vamos calcular o índice de esbeltez na direção y
  lambda_y = 3.46 * (le / hy)

  # e mostramos os resultados
  print("\nO índice de esbeltez na direção x é: {0}".format(round(lambda_x, 2)))

  # precisamos considerar os efeitos locais de segunda ordem na direção x?
  if lambda_x < 35:
    print("Não considerar os efeitos locais de 2ª ordem na direção x")
  else:
    print("Considerar os efeitos locais de 2º ordem na direção x")

  print("\nO índice de esbeltez na direção y é: {0}".format(round(lambda_y, 2)))

  # precisamos considerar os efeitos locais de segunda ordem na direção y?
  if lambda_y < 35:
    print("Não  considerar os efeitos locais de 2ª ordem na direção y")
  else:
    print("Considerar os efeitos locais de 2ª ordem na direção y")

if __name__== "__main__":
  main()

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

Informe o comprimento do pilar (em metros): 2.88
Informe a dimensão do pilar na direção x (em cm): 40
Informe a dimensão do pilar na direção y (em cm): 19

O índice de esbeltez na direção x é: 24.91
Não considerar os efeitos locais de 2ª ordem na direção x

O índice de esbeltez na direção y é: 52.45
Considerar os efeitos locais de 2ª ordem na direção y


R ::: Dicas de Estudo e Anotações ::: Variáveis e Constantes

Como usar a função class() da linguagem R para verificar o tipo de dados de uma variável

Quantidade de visualizações: 1238 vezes
Na linguagem R nós não precisamos informar o tipo de dados de uma variável no momento de sua declaração e, consequentemente, atribuição de seu valor inicial. No entanto, a linguagem permite que as variáveis, no decorrer da execução do programa, assumam outros tipos de dados.

Dessa forma, em várias situações nós podemos precisar verificar qual o tipo de dados armazenado em um variável em um determinado momento, talvez, com o propósito de não assumir riscos durante um cálculo envolvendo inteiros e decimais.

A função class() da linguagem R recebe o nome de uma variável e nos informa o seu tipo de dados. Veja um exemplo de seu uso:

> x <- 10 [ENTER]
> class(x) [ENTER]
[1] "numeric"
> x <- "Java" [ENTER]
> class(x) [ENTER]
[1] "character"
> x <- TRUE [ENTER]
> class(x) [ENTER]
[1] "logical"
> x <- 5L [ENTER]
> class(x) [ENTER]
[1] "integer"
> 

Execute estas linhas na janela de comandos do R ou em um script e veja como a variável x assumiu, no decorrer da execução, os tipos numeric, character, logical e integer.


Java ::: Fundamentos da Linguagem ::: Estruturas de Controle

Java para iniciantes - Como criar laços for infinitos em Java

Quantidade de visualizações: 9535 vezes
Laços for infinitos em Java podem ser criado da seguinte forma:

for(;;){
  // bloco de instruções
}

Veja um exemplo:

import javax.swing.JOptionPane;

public class Estudos{
  public static void main(String[] args) {
    int valor;
    int soma = 0;

    // Lê continuamente até o usuário informar 0
    for(;;){
      // efetua a próxima leitura
      String str = JOptionPane.showInputDialog(null,
        "Informe um valor inteiro:\n(ou 0 para sair)",
         "Estudos", JOptionPane.QUESTION_MESSAGE);

      valor = Integer.parseInt(str);
  
      // testa se o laço pode ser finalizado
      if(valor == 0)
        break;
 
      soma += valor;
    }

    JOptionPane.showMessageDialog(null, "A soma é: " + soma,
       "Estudos", JOptionPane.INFORMATION_MESSAGE);
  }
}

Sempre que criar laços infinitos, tenha a certeza de fornecer um teste de parada dentro do corpo do laço. Do contrário seu programa só poderá ser interrompido matando-se o processo.


Ruby ::: Dicas & Truques ::: Programação Orientada a Objetos

Como acessar variáveis de instâncias para leitura em Ruby sem a necessidade de métodos acessores usando a função attr_reader

Quantidade de visualizações: 6944 vezes
Por padrão, variáveis de instância em Ruby só podem ser acessadas usando métodos acessores, ou seja, uma variável de instância @nome deve ser lida usando um método obter_nome.

É possível dispensar o uso de métodos acessores empregando o método attr_reader nos nomes das variáveis que poderão ser acessadas, para leitura, é claro. Veja um exemplo:

# Definição da classe Cliente
class Cliente
   attr_reader :nome, :idade
   
   def initialize(nome, idade)
      @nome = nome
      @idade = idade
   end
    
   def obter_nome
      @nome
   end
    
   def obter_idade
      @idade
   end
end

# Cria uma instância da classe Cliente e inicializa as
# variáveis de instância @nome e @idade
cliente = Cliente.new("Osmar J. Silva", 35)

# Acessa as variáveis de instância sem a necessidade de
# métodos acessórios
puts cliente.nome
puts cliente.idade

Sem o uso do método attr_reader, a linha:

puts cliente.nome


causaria o seguinte erro:

teste.rb:25: undefined method `nome' for 
#<Cliente:0x27f540c @nome="Osmar J. S
ilva", @idade=35> (NoMethodError)



Java ::: Coleções (Collections) ::: HashMap

Como retornar a quantidade de mapeamentos (chave-valor) em um HashMap do Java usando o método size()

Quantidade de visualizações: 7952 vezes
Em algumas situações precisamos saber a quantidade de mapeamentos (chave-valor) contidos em um HashMap. Para isso nós podemos usar o método size(). Veja o exemplo:

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    
    // vamos criar uma instância de HashMap
    HashMap<Integer, String> clientes = new HashMap<Integer, String>();

    // vamos adicionar três chaves e seus valores
    clientes.put(new Integer(1), "Osmar J. Silva");
    clientes.put(new Integer(2), "Salvador Miranda de Andrade");
    clientes.put(new Integer(3), "Marcos da Costa Santos");
      
    // vamos obter a quantidade de mapeamentos neste HashMap
    int quant = clientes.size();

    // vamos exibir o resultado
    System.out.println("Este HashMap contém " + quant +
      " mapeamentos.");    

    System.exit(0);
  }
}

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

Este HashMap contém 3 mapeamentos.


GNU Octave ::: Dicas & Truques ::: Trigonometria - Funções Trigonométricas

Como calcular o comprimento da hipotenusa em GNU Octave dadas as medidas do cateto oposto e do cateto adjascente

Quantidade de visualizações: 1079 vezes
Nesta dica mostrarei como é possível usar a linguagem GNU Octave para retornar o comprimento da hipotenusa dadas as medidas do cateto oposto e do cateto adjascente. Vamos começar analisando a imagem a seguir:



Veja que, nessa imagem, eu já coloquei os comprimentos da hipotenusa, do cateto oposto e do cateto adjascente. Para facilitar a conferência dos cálculos, eu coloquei também os ângulos theta (que alguns livros chamam de alfa) e beta já devidamente calculados.

Então, sabendo que o quadrado da hipotenusa é igual à soma dos quadrados dos catetos (Teorema de Pitógoras):

\[c^2 = a^2 + b^2\]

Tudo que temos a fazer a converter esta fórmula para código GNU Octave (um script do GNU Octave). Veja:

a <- 20 # medida do cateto oposto
b <- 30 # medida do cateto adjascente
  
# agora vamos calcular o comprimento da hipotenusa
c <- sqrt(power(a, 2) + power(b, 2))
 
# e mostramos o resultado
fprintf("O comprimento da hipotenusa é: %f\n\n", c)

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

O comprimento da hipotenusa é: 36.056000

Como podemos ver, o resultado retornado com o código GNU Octave confere com os valores da imagem apresentada.


JavaScript ::: W3C DOM - (Wide Web Consortium) Document Object Model ::: Navegação e Pesquisa de Nós (Nodes)

Como usar a propriedade parentNode para obter o objeto pai de um elemento na hierarquia do DOM do JavaScript

Quantidade de visualizações: 10343 vezes
Em algumas situações precisamos verificar o objeto pai do elemento atual na hierarquia do DOM (Document Object Model). Para isso podemos usar a propriedade parentNode.

Veja um trecho de código no qual temos um elemento <a> (um link) dentro de um elemento div. Note como usamos uma função para obter o elemento pai do link e exibir seu nome de tag e valor da propriedade id:

<html>
<head>
<title>Estudos JavaScript</title>

<script type="text/javascript">
  function obterParentNode(){
    // vamos obter o link com o id "link"
    var no = document.getElementById("link");

    // vamos obter o nó pai deste link
    var noPai = no.parentNode;

    // vamos exibir o nome da tag e id do nó pai
    window.alert("A tag do nó pai é: " + noPai.tagName);

    // vamos exibir o valor da propriedade id do nó pai
    window.alert("O id do nó pai é: " + noPai.id);
  }  
</script>

</head>
<body>

<div id="container">
  <a id="link" href="http://www.google.com">Sou um link</a>
</div>

<br>
<button onclick="obterParentNode()">Obter Nó Pai do Link</button>

</body>
</html>

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

A tag do nó pai é: DIV
O id do nó pai é: container

Veja que o nome da tag do elemento pai é obtido por meio da propriedade tagName. Note também que a propriedade parentNode de um elemento HTML é somente-leitura, ou seja, não podemos alterar seu valor durante a execução de nossos códigos.

Esta dica foi escrita e testada no Google Chrome 127.0.6533.122 (Versão oficial) 64 bits.

Carregar Publicações Anteriores


Nossas 20 dicas & truques de programação mais populares

Você também poderá gostar das dicas e truques de programação abaixo

Nossas 20 dicas & truques de programação mais recentes

Últimos Projetos e Códigos Fonte Liberados Para Apoiadores do Site

Últimos Exercícios Resolvidos

E-Books em PDF

E-Book 350 Exercícios Resolvidos de Java - PDF com 500 páginas
Domine lógica de programação e a linguagem Java com o nosso E-Book 350 Exercícios Exercícios de Java, para você estudar onde e quando quiser.

Este e-book contém exercícios resolvidos abrangendo os tópicos: Java básico, matemática e estatística, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book
E-Book 650 Dicas, Truques e Exercícios Resolvidos de Python - PDF com 1.200 páginas
Domine lógica de programação e a linguagem Python com o nosso E-Book 650 Dicas, Truques e Exercícios Exercícios de Python, para você estudar onde e quando quiser.

Este e-book contém dicas, truques e exercícios resolvidos abrangendo os tópicos: Python básico, matemática e estatística, banco de dados, programação dinâmica, strings e caracteres, entrada e saída, estruturas condicionais, vetores e matrizes, funções, laços, recursividade, internet, arquivos e diretórios, programação orientada a objetos e muito mais.
Ver Conteúdo do E-book

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á 21 usuários muito felizes estudando em nosso site.