// função principal do programa Rust
fn main() {
  // vamos criar um array com 5 elementos
  let valores = [7, 3, 4, 9, 1];
  
  // agora vamos obter o tamanho do array
  let tamanho = valores.len();
  
  // e mostramos o resultado
  println!("O array possui {} elementos", tamanho);
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>  
  
int main(int argc, char *argv[]){
  printf("Seno de 0 = %f", sin(0));
  printf("\nSeno de 1 = %f", sin(1));
  printf("\nSeno de 2 = %f", sin(2)); 
   
  printf("\n\n");
  system("PAUSE");
  return 0;
}

// superclasse
class Pessoa{
  protected String nome;

  public String getNome(){
    return this.nome;
  }
}

// subclasse
class Aluno extends Pessoa{
  public Aluno(){
    this.nome = "Osmar J. Silva";
  }
}

public class Estudos{ 
  public static void main(String args[]){ 
    // Cria um objeto da classe Aluno
    Aluno a = new Aluno();
    System.out.println(a.getNome());
  } 
}

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

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;
  }
}

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);
    }
  }
}

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");
  }
}

static void Main(string[] args){
  // vamos obter o valor mínimo de um short
  short minimo = short.MinValue;

  // vamos obter o valor máximo de um short
  short maximo = short.MaxValue;
  
  // vamos mostrar o resultado
  Console.WriteLine("A faixa de valores de um short é: " + minimo +
    " até " + maximo);

  // vamos pausar a execução
  Console.ReadKey();
}

static void Main(string[] args){
  // a linha abaixo não vai compilar
  short valor = 35767;

  // vamos pausar a execução
  Console.ReadKey();
}

static void Main(string[] args){
  int valor = 35767;

  // vamos forçar a conversão para short
  short valor2 = (short)valor;
 
  // vamos mostrar o resultado
  Console.WriteLine("Valor após o cast: " + valor2);

  // vamos pausar a execução
  Console.ReadKey();
}

static void Main(string[] args){
  // vamos obter o valor mínimo de um ushort
  ushort minimo = ushort.MinValue;

  // vamos obter o valor máximo de um ushort
  ushort maximo = ushort.MaxValue;
  
  // vamos mostrar o resultado
  Console.WriteLine("A faixa de valores de um ushort é: " + minimo +
    " até " + maximo);

  // vamos pausar a execução
  Console.ReadKey();
}

static void Main(string[] args){
  // não esqueça
  // using System.IO;
  
  // caminho e nome atual do arquivo
  string antigo = "C:\\estudos_csharp\\arquivo.txt";
  
  // caminho e novo nome do arquivo
  string novo = "C:\\estudos_csharp\\arquivo2.txt";

  // vamos renomear o arquivo
  File.Move(antigo, novo);
  Console.WriteLine("Arquivo renomeado com sucesso.");

  Console.WriteLine("\n\nPressione uma tecla para sair...");
  Console.ReadKey();
}

package arquivodecodigos;
 
import java.util.Scanner;
 
public class Estudos{
  public static void main(String[] args) {
    // vamos fazer a leitura usando a classe Scanner
    Scanner entrada = new Scanner(System.in);
     
    // vamos declarar e construir uma matriz de três linhas e três colunas
    int matriz[][] = new int[3][3];
    int soma_diagonal = 0; // guarda a soma dos elementos na diagonal principal
     
    // vamos ler os valores para os elementos da matriz
    for(int i = 0; i < matriz.length; i++){ // linhas
      for(int j = 0; j < matriz[0].length; j++){ // colunas
        System.out.print("Informe o valor para a linha " + i + " e coluna " 
          + j + ": ");
        matriz[i][j] = Integer.parseInt(entrada.nextLine());       
      }       
    }
     
    // vamos mostrar a matriz da forma que ela
    // foi informada
    System.out.println();
    // percorre as linhas
    for(int i = 0; i < matriz.length; i++){ 
      // percorre as colunas
      for(int j = 0; j < matriz[0].length; j++){ 
        System.out.printf("%5d ", matriz[i][j]);
      }
      // passa para a próxima linha da matriz
      System.out.println();
    }
     
    // vamos calcular a soma dos elementos da diagonal   
    // principal
    for(int i = 0; i < matriz.length; i++){
      for(int j = 0; j < matriz[0].length; j++){
        if(i == j){
          soma_diagonal = soma_diagonal + matriz[i][j];
        }
      }
    }
     
    // finalmente mostramos a soma da diagonal principal
    System.out.println("\nA soma dos elementos da diagonal principal é: " 
      + soma_diagonal);
  }
}

Informe o valor para a linha 0 e coluna 0: 3
Informe o valor para a linha 0 e coluna 1: 7
Informe o valor para a linha 0 e coluna 2: 9
Informe o valor para a linha 1 e coluna 0: 2
Informe o valor para a linha 1 e coluna 1: 4
Informe o valor para a linha 1 e coluna 2: 1
Informe o valor para a linha 2 e coluna 0: 5
Informe o valor para a linha 2 e coluna 1: 6
Informe o valor para a linha 2 e coluna 2: 8

    3     7     9 
    2     4     1 
    5     6     8 

A soma dos elementos da diagonal principal é: 15

import math

# função principal do programa
def main():
  # valor em radianos
  radianos = 1.5
  # obtém o valor em graus
  graus = radianos * (180 / math.pi)
  # mostra o resultado
  print(radianos, "radianos convertidos para",
    "graus é", graus)
 
if __name__== "__main__":
  main()

package arquivodecodigos;

import java.util.regex.*;
 
public class Estudos{ 
  public static void main(String args[]){ 
    String padrao = "Java";
    Pattern regPat = Pattern.compile(padrao);
    String frase = "Java? Gosto muito de Java.";
    System.out.println("Frase original: " + frase);
    Matcher matcher = regPat.matcher(frase);
    String res = matcher.replaceAll("C++");
    System.out.println("Depois da substituição: " + res);
  } 
} 

// Este exemplo mostra como contar as palavras
// de uma string

import java.util.*;

public class Estudos{
  public static void main(String[] args){
    String frase = "Programar em Java é bom demais";
    
    StringTokenizer parser = new StringTokenizer(frase);
    int cont = parser.countTokens();
    
    System.out.println("A frase contém " + 
        cont + " palavras");
    
    System.exit(0);
  }
}