property OnDrawCell: TDrawCellEvent;

TDrawCellEvent = procedure(Sender: TObject; ACol, ARow: Longint; 
  Rect: TRect; State: TGridDrawState) of object;

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
var
  conteudo: String;
begin
  // vamos obter o conteúdo da célula
  conteudo := StringGrid1.Cells[ACol, ARow];

  // vamos colorir a célula na segunda linha e terceira
  // coluna com o fundo amarelo
  if (ACol = 2) and (ARow = 1) then
    begin
      StringGrid1.Canvas.Brush.Color := clYellow;
      StringGrid1.Canvas.FillRect(Rect);
      StringGrid1.Canvas.TextRect(Rect, Rect.Left, Rect.Top,
        conteudo);
    end;
end;

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
var
  conteudo: String;
begin
  // vamos obter o conteúdo da célula
  conteudo := StringGrid1.Cells[ACol, ARow];

  // vamos definir a cor vermelha para o texto das células
  // contendo valores menores que 10
  if (conteudo <> '') and (StrToInt(conteudo) < 10) then
    begin
      StringGrid1.Canvas.Font.Color := clRed;
      StringGrid1.Canvas.FillRect(Rect);
      StringGrid1.Canvas.TextRect(Rect, Rect.Left, Rect.Top,
        conteudo);
    end;
end;

from datetime import datetime

class Pessoa:
  # construtor da classe Pessoa
  def __init__(self, nome, data_nascimento, altura):
    self._nome = nome
    self._data_nascimento = data_nascimento
    self._altura = altura

  # método que imprime todos os dados da pessoa
  def imprimir_dados(self):
    print("Nome:", self._nome, "\nData de Nascimento:" ,
      self._data_nascimento, "\nAltura:", self._altura)

  # método que calcula a idade da pessoa
  def calcular_idade(self):
    # vamos obter o ano da data de hoje
    ano_data_atual = datetime.today().year
    
    # agora vamos obter o ano de nascimento da pessoa
    partes_data_nascimento = self._data_nascimento.split("/")
    ano_nascimento = partes_data_nascimento[2]
    
    # agora mostramos a idade da pessoa
    anos = ano_data_atual - int(ano_nascimento)
    print("A pessoa tem", anos, "anos.")

  # método que define o nome da pessoa
  def set_nome(self, nome):
    self._nome = nome

  # método que obtém o nome da pessoa
  def get_nome(self):
    return self._nome

  # método que define a data de nascimento da pessoa
  def set_data_nascimento(self, data_nascimento):
    self._data_nascimento = data_nascimento

  # método que obtém a data de nascimento da pessoa
  def get_data_nascimento(self):
    return self._data_nascimento

  # método que define a altura da pessoa
  def set_altura(self, altura):
    self._data_altura = altura

  # método que obtém a altura da pessoa
  def get_altura(self):
    return self._altura      

# importa a classe Pessoa
from pessoa import Pessoa

def main():
  # cria um novo objeto da classe Pessoa
  pessoa = Pessoa("Amanda Rodrigues", "12/03/1972", 1.65)

  # exibe os dados da pessoa
  pessoa.imprimir_dados()

  # mostra a idade da pessoa
  pessoa.calcular_idade()
  
if __name__== "__main__":
  main()

private void button1_Click(object sender, EventArgs e){
  // vamos criar o novo formulário e exibí-lo
  NovoForm nf = new NovoForm();
  nf.Show();
}

# vamos importar as bibliotecas necessárias
import pygame, sys
from pygame.locals import *
import math
from datetime import datetime

# função que faz a correção dos ângulos
def corrigir_angulo(angulo):
  return abs(angulo % 360)

# inicializa a biblioteca
pygame.init()

# quantidade de frames por segundo
FPS = 30
# construímos o timer
timer = pygame.time.Clock()

# obtém a superfície do jogo e define o tamanho da tela
janela = pygame.display.set_mode((600, 400))
  
# vamos definir o título da janela do jogo
pygame.display.set_caption('Relógio Analógico no Pygame')

# vamos definir alguns parâmetros
fonte = pygame.font.Font(None, 36)
VERMELHO = (200, 0, 0)
BRANCO = (255, 255, 255)
raio = 150
x_inicial = 300
y_inicial = 200
distancia_aro = 20
  
# e aqui nós entramos no loop do game
while True:
  # vamos pintar a tela toda de branco
  janela.fill(BRANCO)
  
  # monitoramos os eventos
  for evento in pygame.event.get():
    # se o evento foi um pedido para sair
    if evento.type == QUIT:
      # fechamos a tela do jogo 
      pygame.quit()
      # e saimos do programa
      sys.exit()
  
  # vamos desenhar um circulo não preenchido (maior)
  pygame.draw.circle(janela, VERMELHO, (x_inicial, y_inicial), raio, 2)
  # vamos desenhar um circulo não preenchido (menor)
  pygame.draw.circle(janela, VERMELHO, (x_inicial + 1, y_inicial + 1), 5, 0)

  # vamos desenhar os números do relório (1-12)
  for n in range(1, 13):
    # calcula o ângulo dessa hora
    angulo = math.radians((n * (360 / 12)) - 90)
    # agora convertemos o ângulo e o raio para coordenadas cartesianas
    if len(str(n)) > 1:
      x = math.cos(angulo) * (raio - distancia_aro) - 18
    else:
      x = math.cos(angulo) * (raio - distancia_aro) - 10
    y = math.sin(angulo) * (raio - distancia_aro) - 10
    texto_numero = fonte.render(str(n), True, VERMELHO)
    janela.blit(texto_numero, (x_inicial + x, y_inicial + y))

  # vamos obter as horas, minutos e segundos atuais
  hoje = datetime.today()
  horas = hoje.hour % 12
  minutos = hoje.minute
  segundos = hoje.second
  
  # ajustamos as horas para tratar a hora decimal (com frações de horas)
  horas = horas + (minutos * (1 / 60)) + (segundos * (1 / 3600))

  # desenha o ponteiro das horas
  angulo_horas = corrigir_angulo(horas * (360 / 12) - 90)
  angulo_horas = math.radians(angulo_horas)
  hora_x = math.cos(angulo_horas) * (raio - 60)
  hora_y = math.sin(angulo_horas) * (raio - 60)
  coord_finais = (x_inicial + hora_x, y_inicial + hora_y)
  pygame.draw.line(janela, VERMELHO, (x_inicial, y_inicial), coord_finais, 4)

  # desenha o ponteiro dos minutos
  angulo_minutos = corrigir_angulo(minutos * (360 / 60) - 90)
  angulo_minutos = math.radians(angulo_minutos)
  minutos_x = math.cos(angulo_minutos) * (raio - 40)
  minutos_y = math.sin(angulo_minutos) * (raio - 40)
  coord_finais = (x_inicial + minutos_x, y_inicial + minutos_y)
  pygame.draw.line(janela, VERMELHO, (x_inicial, y_inicial), coord_finais, 3)

  # desenha o ponteiro dos segundos
  angulo_segundos = corrigir_angulo(segundos * (360 / 60) - 90)
  angulo_segundos = math.radians(angulo_segundos)
  segundos_x = math.cos(angulo_segundos) * (raio - 30)
  segundos_y = math.sin(angulo_segundos) * (raio - 30)
  coord_finais = (x_inicial + segundos_x, y_inicial + segundos_y)
  pygame.draw.line(janela, VERMELHO, (x_inicial, y_inicial), coord_finais, 1)

  # redesenha a tela continuamente 
  pygame.display.update()

  # aciona o disparo do timer
  timer.tick(FPS)

Inserindo valores no final da lista

Informe o valor (-1 para sair): 3
Informe o valor (-1 para sair): 9
Informe o valor (-1 para sair): 1
Informe o valor (-1 para sair): 5
Informe o valor (-1 para sair): 2
Informe o valor (-1 para sair): -1

Valores na lista: 3 -> 9 -> 1 -> 5 -> 2 -> null

package estudos;
  
import java.util.Scanner;

// classe interna usada para representar um
// nó na lista ligada
class No {
  int valor; // valor do nó
  No proximo; // aponta para o novo nó
 
  // construtor da classe No
  No(int valor, No proximo) {
    this.valor = valor;
    this.proximo = proximo;
  }
}

public class Estudos { 
  public static void main(String args[]){
    // para ler a entrada do usuário
    Scanner entrada = new Scanner(System.in);
    
    // vamos criar uma referência para o início da lista
    No inicio = null;
    
    // agora vamos pedir para o usuário informar
    // valores inteiros. O valor -1 sai do laço
    int valor;
    System.out.println("Inserindo valores no final da lista\n");
    do {
      System.out.print("Informe o valor (-1 para sair): ");
      valor = Integer.parseInt(entrada.nextLine());
      if (valor != -1) {
        inicio = inserirFinal(inicio, valor);
      }
    } while(valor != -1);
    
    // vamos exibir os valores na lista ligada
    System.out.print("\nValores na lista: ");
    exibirLista(inicio);
  }
  
  // função que permite adicionar um nó no final da
  // lista ligada
  public static No inserirFinal(No inicio, int valor) {
    // vamos apontar para o nó inicial
    No atual = inicio;
    // criamos um novo nó
    No novo = criarNo(valor);
 
    // a lista ligada ainda está vazia?
    if (atual == null){
      // inicio recebe o novo nó
      inicio = novo;
    }    
    else { // temos um ou mais nós na lista ligada
      // vamos localizar o último nó
      while (atual.proximo != null) {
        atual = atual.proximo;
      }
      
      // encontramos o último nó. Agora vamos inserir
      // o novo nó depois dele
      atual.proximo = novo;
    }
    
    // e retornamos o início da lista
    return inicio;
  }
  
  // função usada para construir e retornar um novo nó
  public static No criarNo(int valor) {
    // cria o novo nó
    No no = new No(valor, null);
    // retorna o nó criado
    return no;
  }
  
  // função usada para percorrer a lista ligada e
  // exibir os valores contidos em seus nós
  public static void exibirLista(No inicio) {
    // vamos apontar para o início da lista
    No temp = inicio;
    
    // a lista está vazia?
    if (temp == null) {
      System.out.println("A lista está vazia.");
    }
    else {
      // esse laço se repete enquanto tempo for
      // diferente de null
      while (temp != null) {
        // vamos mostrar o valor desse nó
        System.out.print(temp.valor + " -> ");
        // avança para o próximo nó
        temp = temp.proximo;
      }
    
      // mostra o final da lista
      System.out.println("null");
    }
  }
}

<html>
<head>
   <title>Obtendo a latitude e longitude usando a API
     Geolocation</title>
</head>
<body>

<script type="text/javascript">
  function mostrarPosicao(posicao) {
    document.writeln("<h1>Latitude: " + posicao.coords.latitude + 
      "; Longitude: " + posicao.coords.longitude + "</h1>");
  }
  
  // não se esqueça de testar se o navegador web suporta a API
  // Geolocation do HTML5 
  if(window.navigator.geolocation) {
    // chamamos o método getCurrentPosition() fornecendo a função
    // JavaScript que receberá o objeto de coordenadas   
    navigator.geolocation.getCurrentPosition(mostrarPosicao);
  }
  else{
    document.writeln("A API Geolocation foi encontrada.");  
  }
</script>

</body>
</html>

Latitude: -16.7143838; Longitude: -49.2327622

<!doctype html>
<html>
<head>
  <title>O método setInterval() do JavaScript</title>
</head>
  
<body>

<script type="text/javascript">
  // vamos criar um novo conjunto
  var linguagens = new Set();
  
  // vamos adicioar 4 linguagens
  linguagens.add("Java");
  linguagens.add("PHP");
  linguagens.add("C++");
  linguagens.add("Python");
  
  // vamos percorrer os elementos do conjunto
  for(var linguagem of linguagens){
    document.writeln(linguagem + "<br>");
  }
</script>
  
</body>
</html>

Informe o valor do carro sem desconto: 25000
Informe o ano do carro: 2010
Desconto concedido: 1750
Valor do carro com desconto: 23250
Deseja adicionar mais carros? [S, N]: S

Informe o valor do carro sem desconto: 30500
Informe o ano do carro: 1985
Desconto concedido: 3660
Valor do carro com desconto: 26840
Deseja adicionar mais carros? [S, N]: S

Informe o valor do carro sem desconto: 16800
Informe o ano do carro: 1990
Desconto concedido: 2016
Valor do carro com desconto: 14784
Deseja adicionar mais carros? [S, N]: N

Total de carros com ano até 2000: 2
Total geral a pagar: 64874

algoritmo "Cálculo de desconto nos preços de vários veículos"

var
  // variáveis usadas na resolução do problema
  valor_carro, valor_desconto, valor_carro_desconto: real
  total_geral: real
  ano: inteiro
  total_carros_ano_2000: inteiro
  resposta: caractere

inicio
  // vamos inicializar os valores de algumas variáveis
  total_geral <- 0
  total_carros_ano_2000 <- 0

  // repete até que o usuário informe o valor "N"
  repita
    // vamos ler o valor do carro sem desconto
    escreva("Informe o valor do carro sem desconto: ")
    leia(valor_carro)

    // vamos ler o ano do carro
    escreva("Informe o ano do carro: ")
    leia(ano)

    // o ano é menor ou igual a 2000
    se ano <= 2000 entao
      valor_desconto <- valor_carro * (12.0 / 100.0)
      // vamos somar mais este carro
      total_carros_ano_2000 <- total_carros_ano_2000 + 1
    senao
      valor_desconto <- valor_carro * (7.0 / 100.0)
    fimse

    // calculamos o valor do carro com o desconto
    valor_carro_desconto <- valor_carro - valor_desconto
    escreval("Desconto concedido: ", valor_desconto)
    escreval("Valor do carro com desconto: ", valor_carro_desconto)

    // somamos mais este valor ao total geral
    total_geral <- total_geral + valor_carro_desconto

    // perguntamos se o usuário deseja adicionar mais carros
    escreva("Deseja adicionar mais carros? [S, N]: ")
    leia(resposta)

    // adiciona uma quebra de linha
    escreval()
  ate resposta = "N"

  // mostramos os resultados
  escreval("Total de carros com ano até 2000: ", total_carros_ano_2000)
  escreval("Total geral a pagar: ", total_geral)

fimalgoritmo

// dois vetores de 5 inteiros cada
int a[] = {50, -2, 9, 5, 17};
int b[] = new int[5];

Valores no vetor a: 50   -2   9   5   17   
Valores no vetor b: -20   32   21   25   13

package estudos;

public class Estudos {
  public static void main(String[] args) {
    // dois vetores de 5 inteiros cada
    int a[] = {50, -2, 9, 5, 17};
    int b[] = new int[5];
    
    // vamos preencher o segundo vetor de forma que a soma dos
    // valores de seus elementos seja 30
    for(int i = 0; i < b.length; i++){
      b[i] = 30 - a[i];  
    }
    
    // vamos mostrar o resultado
    System.out.print("Valores no vetor a: ");
    for(int i = 0; i < a.length; i++){
      System.out.print(a[i] + "   ");  
    }
    
    System.out.print("\nValores no vetor b: ");
    for(int i = 0; i < b.length; i++){
      System.out.print(b[i] + "   ");  
    }
    
    System.out.println();
  }
}

<!DOCTYPE html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
 
<title>A interface MediaDevices</title>
  
</head>
<body>

<script type="text/javascript">
  async function obterMediaUsuario(){
    // vamos obter o stream
    var stream = null;
    try{
      stream = await navigator.mediaDevices.getUserMedia({video: true});
      window.alert("A mídia para vídeo foi obtida com sucesso.");
      // agora podemos fazer algo com o stream aqui
    }
    catch(erro){
      window.alert("Houve um erro: " + erro);
    }  
  }
  
  // o browser suporta o MediaDevices?
  if(navigator.mediaDevices){
    obterMediaUsuario()
  }
  else{
    window.alert("O navegador não suporta o MediaDevices");  
  }
</script> 
  
</body>
</html>