package arquivodecodigos;

public class Estudos{
  public static void main(String[] args){
    double radianos = 1.5;
    double graus = radianos * (180 / Math.PI);
 
    System.out.println(radianos + " radianos convertidos para " +
      "graus é " + graus);

    System.exit(0);
  }
}

int negativos = 0; // guardará a quantidade de valores negativos

public static void main(String[] args){
  // para este exercício você deverá importar a classe
  // Scanner. Ela está no pacote java.util.*;
    
  // vamos construir um objeto da classe Scanner para ler a
  // entrada do usuário
  Scanner entrada = new Scanner(System.in);

  int valor; // guarda o valor lido
  int negativos = 0; // guardará a quantidade de valores negativos

  // vamos pedir ao usuário que informe 10 valores inteiros
  for(int i = 0; i < 10; i++){
    System.out.print("Informe o " + (i + 1) + "º valor: ");
    valor = Integer.parseInt(entrada.nextLine());

    // vamos verificar se o valor informado é negativo
    if(valor < 0){
      negativos++;
    }
  }

  // vamos exibir a quantidade de números negativos lidos
  System.out.println("\nVocê informou " + negativos + " valores negativos.\n");
}

// Vamos importar a biblioteca dart:io
import "dart:io";

// vamos importar a biblioteca dart:math
import "dart:math";

// vamos declarar a classe Circulo
class Circulo{
  double xc;
  double yc;
  double raio;
   
  // construtor da classe Circulo 
  Circulo(double xc, double yc, double raio){
    this.xc = xc; // x do centro
    this.yc = yc; // y do centro
    this.raio = raio; // raio do círculo
  }
}

// agora vamos declarar a classe Ponto
class Ponto{
  double x;
  double y;
   
  // construtor da classe Ponto 
  Ponto(double x, double y){
    this.x = x; // coordenada x
    this.y = y; // coordenada y 
  }
}

void main(){
  // variáveis que vamos usar na resolução do problema
  Circulo c;
  Ponto p;
  double dx, dy;
  
  // vamos criar um objeto Circulo
  c = new Circulo(205, 166, 115);
  // vamos criar um objeto Ponto
  p = new Ponto(140, 90);
   
  // vamos verificar se o ponto está dentro do
  // círculo
  dx = p.x - c.xc;
  dy = p.y - c.yc;
  if((pow(dx, 2) + pow(dy, 2)) < pow(c.raio, 2)){
    stdout.write("O ponto está dentro do círculo");  
  }
  else{
    stdout.write("O ponto NÃO está dentro do círculo");  
  }
}

using System;

namespace Estudos{
  class Program{
    static void Main(string[] args) {
      string frase = "Gosto muito de C#";
      Console.WriteLine("Com espaços: " + frase);

      // remove todos os espaços
      frase = frase.Replace(" ", "");
      Console.WriteLine("Sem espaços: " + frase);

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

package arquivodecodigos;

// Este exemplo mostra como remover todos os espaços
// duplicados de uma string

import java.util.regex.*;

public class Estudos{
  public static void main(String[] args){
    String frase = "Programar   em  Java  e   bom";
    System.out.println("Com espaços em excesso: " + frase);
    
    frase = removerEspacosDuplicados(frase);
    
    System.out.println("Sem espaços em excesso: " + frase);
    
    System.exit(0);
  }
  
  public static String removerEspacosDuplicados(String str){
     String patternStr = "\\s+";
     String replaceStr = " ";
     Pattern pattern = Pattern.compile(patternStr);
     Matcher matcher = pattern.matcher(str);
     return matcher.replaceAll(replaceStr);
  }
}  

Com espaços em excesso: Programar   em  Java  é   bom
Sem espaços em excesso: Programar em Java é bom

// Algoritmo que calcula porcentagem em Delphi
program estudos_delphi;

{$APPTYPE CONSOLE}

uses
  SysUtils, Math;

var
  // variáveis usadas na resolução do problema
  valor, percentual, valor_final: double;

begin
  valor := 178.00; // valor original
  percentual := 15.0 / 100.0; // 15%
  valor_final := valor + (percentual * valor);

  // mostra o resultado
  WriteLn('O valor final do produto é: ' + FloatToStr(valor_final));

  // O resultado será 204,70

  WriteLn;
  Write('Pressione Enter para sair...');
  ReadLn;
end.

// Algoritmo que calcula porcentagem em Delphi
program estudos_delphi;

{$APPTYPE CONSOLE}

uses
  SysUtils, Math;

var
  // variáveis usadas na resolução do problema
  valor, percentual, valor_final: double;

begin
  valor := 250.00; // valor original
  percentual := 8.0 / 100.0; // 8%
  valor_final := valor - (percentual * valor);

  // mostra o resultado
  WriteLn('O valor final do produto é: ' + FloatToStr(valor_final));

  // O resultado será 230,00

  WriteLn;
  Write('Pressione Enter para sair...');
  ReadLn;
end.

// Algoritmo que calcula porcentagem em Delphi
program estudos_delphi;

{$APPTYPE CONSOLE}

uses
  SysUtils, Math;

var
  // variáveis usadas na resolução do problema
  perguntas, acertos: double;

begin
  perguntas := 90.0;
  acertos := 72.0;

  // mostra a porcentagem de acertos
  WriteLn('Porcentagem de acertos: ' +
    FloatToStr((acertos / perguntas) * 100) + '%');

  // mostra a porcentagem de erros
  WriteLn('Porcentagem de erros: ' +
    FloatToStr(((perguntas - acertos) / perguntas) * 100) + '%');

  // Os resultados serão 80% e 20%

  WriteLn;
  Write('Pressione Enter para sair...');
  ReadLn;
end.

// Algoritmo que calcula porcentagem em Delphi
program estudos_delphi;

{$APPTYPE CONSOLE}

uses
  SysUtils, Math;

var
  // variáveis usadas na resolução do problema
  valor_anterior, novo_valor, porcentagem_lucro: double;

begin
  valor_anterior := 300.0; // valor anterior
  novo_valor := 340.0; // valor novo

  // calcula a porcentagem de lucro
  // efetua o cálculo
  porcentagem_lucro := ((novo_valor * 100) / valor_anterior) - 100;

  WriteLn('A porcentagem de lucro foi de: ' +
    FloatToStr(porcentagem_lucro) + '%');

  // O resultado será 13,33

  WriteLn;
  Write('Pressione Enter para sair...');
  ReadLn;
end.

// Algoritmo que calcula porcentagem em Delphi
program estudos_delphi;

{$APPTYPE CONSOLE}

uses
  SysUtils, Math;

var
  // variáveis usadas na resolução do problema
  valor, percentual, comissao: double;

begin
  valor := 70.0; // valor do produto
  percentual := 5.0 / 100.0; // 5%

  // calcula a comissão
  comissao := percentual * valor;

  // mostra o resultado
  WriteLn('O valor repassado ao vendedor é: '
    + FloatToStr(comissao));

  // O resultado será 3,5

  WriteLn;
  Write('Pressione Enter para sair...');
  ReadLn;
end.

System.Object 
  System.MarshalByRefObject 
    System.Drawing.Graphics

private void button1_Click(object sender, EventArgs e){
  // vamos obter o Graphics do formulário
  Graphics g = this.CreateGraphics();

  // vamos desenhar uma linha horizontal de 300 pixels na
  // cor preta e espessura de 1 pixel
  g.DrawLine(new Pen(Color.Black, 1), new Point(20, 80), 
    new Point(320, 80));

  // vamos liberar o objeto Graphics
  g.Dispose();
}

static void Main(string[] args){
  // vamos verificar se o ano 2008
  // é bissexto
  int ano = 2008;

  if(DateTime.IsLeapYear(ano)){
    Console.WriteLine("O ano informado é bissexto");
  }
  else{
    Console.WriteLine("O ano informado NÃO é bissexto");
  }

  // pausa o programa
  Console.ReadKey();
}

// função que permite remover um nó no fim
// da lista, ou seja, o último nó da lista.
// A função retorna um ponteiro para o início da lista
struct No *remover_final(struct No *inicio){
  struct No *n; // nó que será removido
  
  // nó que antecede o nó a ser removido. Isso
  // faz sentido, já que ele será o último nó
  // agora
  struct No *anterior;
  n = inicio; // aponta para o início da lista
  
  // varremos os nós da lista e paramos um nó antes do
  // nó a ser excluído
  while(n->proximo != NULL){
    anterior = n; // anterior assume o lugar de n
    n = n->proximo; // e n assume o seu próximo  
  }
  
  // anterior passa a ser o último nó agora
  anterior->proximo = NULL;
  
  // mostra o nó removido
  printf("\nNo removido: %d\n", n->valor);
  
  free(n); // libera o nó que antes era o último
  
  return inicio;
} 

#include <stdio.h>
#include <stdlib.h>
 
// estrutura Nó
struct No{
  int valor;
  struct No *proximo;
};
// fim da estrutura Nó
 
// função que permite exibir os valores de
// todos os nós da lista
void exibir(struct No *n){
  if(n != NULL){
    do{
      printf("%d\n", n->valor);
      n = n->proximo;
    }while(n != NULL);
  }
  else
    printf("A lista esta vazia\n\n");
}
 
// função que permite remover um nó no fim
// da lista, ou seja, o último nó da lista.
// A função retorna um ponteiro para o início da lista
struct No *remover_final(struct No *inicio){
  struct No *n; // nó que será removido
  
  // nó que antecede o nó a ser removido. Isso
  // faz sentido, já que ele será o último nó
  // agora
  struct No *anterior;
  n = inicio; // aponta para o início da lista
  
  // varremos os nós da lista e paramos um nó antes do
  // nó a ser excluído
  while(n->proximo != NULL){
    anterior = n; // anterior assume o lugar de n
    n = n->proximo; // e n assume o seu próximo  
  }
  
  // anterior passa a ser o último nó agora
  anterior->proximo = NULL;
  
  // mostra o nó removido
  printf("\nNo removido: %d\n", n->valor);
  
  free(n); // libera o nó que antes era o último
  
  return inicio;
} 
 
// função que permite inserir nós no
// final da lista.
// veja que a função recebe o valor a ser
// armazenado em cada nó e um ponteiro para o
// início da lista. A função retorna um
// ponteiro para o início da lista
struct No *inserir_final(struct No *n, int v){
  // reserva memória para o novo nó
  struct No *novo = (struct No*)malloc(sizeof(struct No));
  novo->valor = v;
 
  // verifica se a lista está vazia
  if(n == NULL){
    // é o primeiro nó...não deve apontar para
    // lugar nenhum
    novo->proximo = NULL;
    return novo; // vamos retornar o novo nó como sendo o início da lista
  }
  else{ // não está vazia....vamos inserir o nó no final
    // o primeiro passo é chegarmos ao final da lista
    struct No *temp = n; // vamos obter uma referência ao primeiro nó
    // vamos varrer a lista até chegarmos ao último nó
    while(temp->proximo != NULL){
      temp = temp->proximo;
    }
    // na saída do laço temp aponta para o último nó da lista
   
    // novo será o último nó da lista...o campo próximo dele deve
    // apontar para NULL
    novo->proximo = NULL;
    // vamos fazer o último nó apontar para o nó recém-criado
    temp->proximo = novo;
    return n; // vamos retornar o início da lista intacto
  }
}
 
int main(int argc, char *argv[])
{
  // declara a lista
  struct No *inicio = NULL;
 
  // vamos inserir quatro valores no final
  // da lista
  inicio = inserir_final(inicio, 45);
  inicio = inserir_final(inicio, 3);
  inicio = inserir_final(inicio, 98);
  inicio = inserir_final(inicio, 47);
 
  // vamos exibir o resultado
  printf("Valores presentes na lista ligada antes da remocao:\n");
  exibir(inicio);
 
  // vamos remover o nó no fim da lista
  if(inicio != NULL){
    inicio = remover_final(inicio);
  }
  
  // vamos exibir o resultado
  printf("\nValores presentes na lista ligada apos a remocao:\n");
  exibir(inicio);
  
  system("pause");
  return 0;
}

Valores presentes na lista ligada antes da remocao:
45
3
98
47

No removido: 47

Valores presentes na lista ligada apos a remocao:
45
3
98

Pressione qualquer tecla para continuar. . .

#include <stdio.h>
#include <stdlib.h>
 
int main(int argc, char *argv[]){
  // vamos declarar e construir uma matriz de três linhas
  // e três colunas
  int linhas = 3, colunas = 3;
  int matriz[linhas][colunas];
  // guarda a soma dos elementos na diagonal principal
  int soma_diagonal = 0;
  int i, j;
	   
  // vamos ler os valores para os elementos da matriz
  for(i = 0; i < linhas; i++){ // linhas
    for(j = 0; j < colunas; j++){ // colunas
      printf("Informe o valor para a linha %d e coluna %d: " 
        , i, j);
      scanf("%d", &matriz[i][j]);       
    }       
  }
     
  // vamos mostrar a matriz da forma que ela
  // foi informada
  printf("\n");
  // percorre as linhas
  for(i = 0; i < linhas; i++){ 
    // percorre as colunas
    for(j = 0; j < colunas; j++){ 
      printf("%d    ", matriz[i][j]);
    }
    // passa para a próxima linha da matriz
    printf("\n");
  }
     
  // vamos calcular a soma dos elementos da diagonal   
  // principal
  for(i = 0; i < linhas; i++){
    for(j = 0; j < colunas; j++){
      if(i == j){
        soma_diagonal = soma_diagonal + matriz[i][j];
      }
    }
  }
     
  // finalmente mostramos a soma da diagonal principal
  printf("\nA soma dos elementos da diagonal principal é: %d" 
   , soma_diagonal);
  
  printf("\n\n");
  system("PAUSE");
  return 0;
}

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