<?
  // constrói um novo objeto mysqli chamado conexao
  $conexao = new mysqli("localhost", "root",
    "osmar1234", "estudos");
 
  // testa se a conexão foi efetuada com sucesso
  if(mysqli_connect_errno()){
    die("Houve um erro de conexão: " . mysqli_connect_error());
  } 
  else{
    print "Conexão com " . $conexao->host_info 
      . " efetuada com sucesso.";
  } 

  // fecha a conexão com o banco de dados
  $conexao->close(); // fecha a conexão
?>

#include <iostream>

using namespace std;

// função principal do programa
int main(int argc, char *argv[]){
  // gravidade terrestre em m/s2
  double gravidade = 9.80665;
  // massa do corpo
  double massa = 2; // em kg
  // altura do corpo em relação ao chão
  double altura = 1.5; // em metros
  
  // vamos calcular a energia potencial gravitacional
  double epg = massa * gravidade * altura;
  
  // mostramos o resultado
  cout << "A Energia Potencial Gravitacional é: " << epg << "J";
		
  cout << "\n" << endl;
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

Algoritmo "Como resolver uma equação do 2º grau usando VisuAlg"

Var
  // variáveis usadas na resolução do problema
  // os coeficientes
  a, b, c: real
  // as duas raizes, a imaginaria e o discriminante
  raiz1, raiz2, imaginaria, discriminante: real

Inicio
  // vamos pedir para o usuário informar os valores dos coeficientes
  escreva("Valor do coeficiente a: ")
  leia(a)
  escreva("Valor do coeficiente b: ")
  leia(b)
  escreva("Valor do coeficiente c: ")
  leia(c)

  // vamos calcular o discriminante
  discriminante <- (b * b) - (4 * a * c)

  // a equação possui duas soluções reais?
  se discriminante > 0 então
    raiz1 <- (-b + raizq(discriminante)) / (2 * a)
    raiz2 <- (-b - raizq(discriminante)) / (2 * a)
    escreva("Duas raizes: x1 = ", raiz1, " e x2 = ", raiz2)
  senão
    // a equação possui uma única solução real?
    se discriminante = 0 então
      raiz1 <- -b / (2 * a)
      raiz2 <- -b / (2 * a)
      escreva("Duas raizes iguais: x1 = ", raiz1, " e x2 = ", raiz2)
    // a equação não possui solução real?
    senão
      raiz1 <- -b / (2 * a)
      raiz2 <- -b / (2 * a)
      imaginaria <- raizq(-discriminante) / (2 * a)
      escreva("Existem duas raízes complexas: ")
      escreva("x1 = ", raiz1, " + " ,imaginaria, " e x2 = ", raiz2, " - ", imaginaria)
    fimse
  fimse

Fimalgoritmo

class Cliente{
  private String nome;

  // Um método que permite definir um valor
  // para a variável privada nome
  public void setNome(String nome){
    this.nome = nome;
  }

  // Um método que permite obter o valor
  // da variável privada nome
  public String getNome(){
    return this.nome;
  }
}

static void Main(string[] args){
  // Cria uma instância da classe Cliente
  Cliente c = new Cliente();

  // Define um nome para o cliente
  c.setNome("Osmar J. Silva");

  // Obtém o nome do cliente
  string nome = c.getNome();
  Console.WriteLine(nome);

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

procedure TForm3.Button3Click(Sender: TObject);
var
  nRegistro: Integer;
begin
  // obtém o número do registro atual no TClientDataSet
  nRegistro := ClientDataSet1.RecNo;

  // mostra o resultado
  ShowMessage('O número do registro atual é: ' + IntToStr(nRegistro));
end;

#include <string>
#include <iostream>

using namespace std;

// função personalizada para substituir todas as ocorrências
// de uma substring em uma string
void substituir_string(string& str, const string de, 
  const string para){
  
  // variáveis auxiliares
  int i = 0, indice;
  
  // a string está vazia?
  if(str.empty()){
    str = de;
    return;
  }
  
  // fazemos as substituições da substring
  while(i < str.size()){
    indice = str.find(de, 0);
    
    if(indice >= 0){ 
      str.replace(indice, de.length(), para);
    }
    else{
      return;
    }
	
    i++;
  }
}

// função principal do programa
int main(int argc, char *argv[]){
  // vamos criar uma string
  string frase = "Java? Gosto de Java, Java!";
  cout << "A frase original é: " << frase << endl;	
	
  // Substitui as ocorrências de "Java" por "PHP"
  substituir_string(frase, "Java", "PHP"); 
	 
  // e mostramos o resultado	 
  cout << "Depois da substituição: " << frase << endl; 
	 
  system("PAUSE"); // pausa o programa
  return EXIT_SUCCESS;
}

class Pessoa{ 
  public Pessoa(){
    System.out.println("Fui criado.");
  }
}
 
public class Estudos{ 
  public static void main(String args[]){ 
    // cria um objeto da classe Pessoa
    Pessoa p = new Pessoa();
  } 
}

class Pessoa{ 
  public String nome;
 
  public Pessoa(String nome){
    this.nome = nome;
  }
}
 
public class Estudos{ 
  public static void main(String args[]){ 
    // cria um objeto da classe Pessoa
    Pessoa p = new Pessoa("Osmar J. Silva");
    System.out.println(p.nome);
  } 
}

#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

def main():
  # cria uma lista de nomes
  nomes = ['Carlos', 'Amanda', 'Osmar', 'Fernanda']
 
  # exibe a lista na ordem original
  print(nomes)
 
  # ordena a lista
  nomes.sort()
 
  # exibe a lista ordenada
  print(nomes)

if __name__== "__main__":
  main()

export class Aluno{
  id: number = 0;
  matricula: number;
  nome: string;
  curso: string;
  
  constructor(matricula: number, nome: string,
    curso: string, id?: number) {
    this.matricula = matricula;
    this.nome = nome;
    this.curso = curso;
  }
}

import {Injectable} from '@angular/core';

// precisamos do serviço HTTP para fazer a requisição AJAX
import {HttpClient, HttpErrorResponse, HttpParams} from '@angular/common/http';

// precisamos também do Observable, do map e catchError
import {Observable, throwError} from 'rxjs';
import {map, catchError} from 'rxjs/operators';

// precisamos também da classe Aluno
import {Aluno} from '../aluno';

@Injectable({
  providedIn: 'root'
})
export class AlunoService {
  // url base do endereço do serviço remoto
  baseUrl = 'http://localhost/servicos';
  // vetor de alunos já gravados
  alunos: Aluno[] = [];
  
  // vamos fazer uma injeção de dependência aqui
  constructor(private http: HttpClient){}

  // método que permite fazer uma requisição HTTP e gravar
  // o novo aluno
  cadastrar(aluno: Aluno): Observable<Aluno[]> {
    const dados = {
      nome: aluno.nome, matricula: aluno.matricula, 
      curso: aluno.curso,
    };

    return this.http.post(`${this.baseUrl}/gravar_aluno.php`, {dados: aluno})
      .pipe(map((res) => {
        // adiciona o novo aluno no vetor de alunos
        this.alunos.push(res['dados']);
        // e o retorna para o chamador deste método
        return this.alunos;
      }),
      
      catchError(this.tratarErro));
  }

  private tratarErro(error: HttpErrorResponse) {
    // vamos mostrar o erro no console
    console.log(error);

    // e vamos matar a aplicação aqui, pois não há mais nada
    // a fazer
    return throwError('Houve um erro: ' + error);
  }
}

import {Component} from '@angular/core';

// importamos a classe Aluno
import {Aluno} from './aluno';
// importamos o serviço AlunoService
import {AlunoService} from './cadastros/aluno.service';

@Component({
  selector: 'app-root',
  templateUrl: './app.component.html',
  styleUrls: ['./app.component.css']
})
export class AppComponent {
  alunos: Aluno[] = [];
  // criamos uma nova instância da classe Aluno
  aluno = new Aluno(0, '', '', 0);
  erro = '';
  sucesso = '';

  // fazemos uma injeção de dependência aqui
  constructor(private alunoService: AlunoService) {}

  // aqui temos o método que permitirá cadastrar um novo aluno
  cadastrarAluno(f) {
    this.alunoService.cadastrar(this.aluno)
      .subscribe(
        (res: Aluno[]) => {
          // recebemos a lista atualizada de alunos
          this.alunos = res;

          // enviamos um ok para o formulário
          this.sucesso = 'Aluno cadastrado com sucesso.';

          // finalmente resetamos o formulário
          f.reset();
        },
        (err) => this.erro = err
      );
  }
}

<h3>Cadastrar Novo Aluno</h3>

<form #f="ngForm" name="cadastrarForm">
<table width="200" border="0" cellspacing="3" cellpadding="3">
    <tr>
      <td>Matrícula:</td>
      <td><input type="text" name="matricula" [(ngModel)]="aluno.matricula"></td>
    </tr>
    <tr>
      <td>Nome:</td>
      <td><input type="text" name="nome" [(ngModel)]="aluno.nome"></td>
    </tr>
    <tr>
      <td>Curso:</td>
      <td><input type="text" name="curso" [(ngModel)]="aluno.curso"></td>
    </tr>
    <tr>
      <td>&nbsp;</td>
      <td><button (click)="cadastrarAluno(f)">Gravar</button></td>
    </tr>
  </table>
</form>

<div *ngIf="erro" class="alert alert-danger">{{erro}}</div>
<div *ngIf="sucesso" class="alert alert-success">{{sucesso}}</div>

<ul *ngFor="let aluno of alunos; let i = index;">
    <li>{{i + 1}}; {{aluno.matricula}}; {{aluno.nome}}; {{aluno.curso}}</li>
</ul>

CREATE TABLE `alunos` (
  `id` int(11) NOT NULL,
  `matricula` int(11) NOT NULL,
  `nome` varchar(100) NOT NULL,
  `curso` varchar(100) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1;

<?php
  // não deixe quebra de linha nos headers abaixo
  header('Access-Control-Allow-Origin: *');
  header('Access-Control-Allow-Methods: POST, GET, 
    PUT, DELETE, OPTIONS');
  header('Access-Control-Allow-Headers: Origin, 
    X-Requested-With, Content-Type, Accept');
  header("Content-Type: application/json; charset=utf-8");

  // vamos obter os dados vindo do formulário
  // atenção: em um código real temos que validar
  $dados = file_get_contents("php://input");
  
  // a requisição foi post?
  if(isset($dados) && !empty($dados)){
    $request = json_decode($dados);
    $nome = $request->dados->nome;
    $matricula = $request->dados->matricula;
    $curso = $request->dados->curso;

    // vamos efetuar a conexão com o banco
    $con = new mysqli("localhost", "root",
      "osmar1234", "estudos");
   
    // conexão efetuada com sucesso?
    if($con->connect_errno){
      echo "Não foi possível efetuar a conexão: " . 
        $mysqli->connect_error;
      exit(); // vamos sair daqui 
    }   
  
    // comando sql
    $query = "INSERT INTO alunos(id, matricula, nome, 
      curso) VALUES (null, '$matricula', '$nome', '$curso')";

    // vamos disparar o comando sql
    if(mysqli_query($con, $query)){
      http_response_code(201);
      $aluno = [
        'matricula' => $matricula,
        'nome' => $nome,
        'curso' => $curso,
        'id' => mysqli_insert_id($con)
      ];
  
      // vamos retornar o aluno recém cadastrado
      echo json_encode(['dados'=>$aluno]);
    }
    else{
      http_response_code(422);
    }
  }
?>