bool pode = true;
bool vencido = false;

The name 'True' does not exist in the 
current context
The name 'False' does not exist in the 
current context

bool pode = true;
Console.WriteLine(pode);

Console.WriteLine("Um boolean ocupa " + sizeof(bool) +
  " bytes no C# 2.0");

Um boolean ocupa 1 bytes no C# 2.0

int pode = 1;

if(pode)
  Console.WriteLine("OK");

Cannot implicitly convert type 'int' to 'bool'

public class Pessoa{ 
  public String nome;    
  public int idade;
}

public class Aluno extends Pessoa{ 
  public String matricula;
}

public class Estudos{ 
  public static void main(String args[]){ 
    // cria um objeto da classe Aluno
    Aluno aluno = new Aluno();
 
    aluno.nome = "Osmar J. Silva";
    aluno.idade = 36;
    aluno.matricula = "AC33-65";
 
    // Exibe o resultado
    System.out.println("Nome: " + aluno.nome + "\n" +
      "Idade: " + aluno.idade + "\n" +
      "Matrícula: " + aluno.matricula);
  } 
}

package arvore_binaria;

public class No {
  private int valor; // valor armazenado no nó
  private No esquerdo; // filho esquerdo
  private No direito; // filho direito
 
  // construtor do nó
  public No(int valor){
    this.valor = valor;
    this.esquerdo = null;
    this.direito = null;
  }

  public int getValor() {
    return valor;
  }

  public void setValor(int valor) {
    this.valor = valor;
  }

  public No getEsquerdo() {
    return esquerdo;
  }

  public void setEsquerdo(No esquerdo) {
    this.esquerdo = esquerdo;
  }

  public No getDireito() {
    return direito;
  }

  public void setDireito(No direito) {
    this.direito = direito;
  }
}

package arvore_binaria;

public class ArvoreBinariaBusca {
  private No 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 No(valor); // cria um novo nó
    }
    else{
      // localiza o nó pai do novo nó
      No pai = null;
      No noAtual = raiz; // começa a busca pela raiz
  
      // enquanto o nó atual for diferente de null
      while(noAtual != null){
        // o valor sendo inserido é menor que o nó atual?
        if(valor < noAtual.getValor()) {
          pai = noAtual;
          // vamos inserir do lado esquerdo
          noAtual = noAtual.getEsquerdo();
        }
        // o valor sendo inserido é maior que o nó atual
        else if(valor > noAtual.getValor()){
          pai = noAtual;
          // vamos inserir do lado direito
          noAtual = noAtual.getDireito();
        }
        else{
          return false; // um nó com este valor foi encontrado
        }
      }
        
      // cria o novo nó e o adiciona como filho do nó pai
      if(valor < pai.getValor()){
         pai.setEsquerdo(new No(valor));
      }
      else{
        pai.setDireito(new No(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 No 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 No pesquisar(No 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.getValor()){
      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.getValor()){
      return pesquisar(noAtual.getEsquerdo(), valor);
    }
    // ainda não encontramos...vamos disparar uma nova 
    // chamada para a sub-árvore da direita
    else{
      return pesquisar(noAtual.getDireito(), valor);
    }
  }
}

package arvore_binaria;

import java.util.Scanner;

public class ArvoreBinariaTeste {
  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("Não foi possível inserir." +
          " 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
    No 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");
  }
}

var
  valores: array[1..10] of Integer;

procedure TForm1.Button1Click(Sender: TObject);
var
  valores: array[1..10] of Integer;
begin
  valores[5] := 20;
end;

procedure TForm1.Button1Click(Sender: TObject);
var
  valores: array[1..5] of Integer;
  i, soma: Integer;
begin
  // vamos preencher o array com os valores de 1 a 5
  for i := 1 to 5 do
    begin
      valores[i] := i;
    end;

  // vamos percorrer o array novamente e obter a soma dos
  // valores de seus elementos
  soma := 0;
  for i := 1 to 5 do
    begin
      soma := soma + valores[i];
    end;

  // vamos exibir o resultado
  ShowMessage('A soma dos valores é: ' + IntToStr(soma));
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  valores: array[1..5] of Integer = (3, 2, 6, 12, 9);
var
  i, soma: Integer;
begin
  // vamos percorrer o array novamente e obter a soma dos
  // valores de seus elementos
  soma := 0;
  for i := 1 to 5 do
    begin
      soma := soma + valores[i];
    end;

  // vamos exibir o resultado
  ShowMessage('A soma dos valores é: ' + IntToStr(soma));
end;

procedure TForm1.Button1Click(Sender: TObject);
const
  letras: array[1..5] of Char = ('O', 's', 'm', 'a', 'r');
var
  i: Integer;
  resultado: String;
begin
  resultado := '';

  // vamos exibir a palavra na forma normal
  for i := 1 to 5 do
    resultado := resultado + letras[i];

  // exibe o resultado
  ShowMessage(resultado);

  // vamos exibir a palavra invertida
  resultado := '';
  for i := 5 downto 1 do
    resultado := resultado + letras[i];

  // exibe o resultado
  ShowMessage(resultado);
end;

def main():
  primo = True # vamos assumir que o número é primo

  # vamos solicitar um número inteiro positivo
  numero = int(input("Informe um número inteiro positivo: "))

  # o número é negativo?
  if numero < 0:
    print("Número inválido.")
  # é 0 ou 1?
  elif (numero == 0) or (numero == 1):
    print("Número válido, mas não é primo.")
  # passou até aqui. Vamos testar se o número é primo
  else:
    for i in range(2, int((numero / 2))):
      # se passar no teste, não é primo
      if numero % i == 0:
        primo = False # recebe false
        break

    if primo:
      print("O número informado é primo")
    else:
      print("O número informado não é primo")
    
if __name__== "__main__":
  main()