2015-1: Algoritmos e Lógica de Programação (Qua): Laboratório 1

Problema 1:

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    // Problema
    // Entrada: um número inteiro digitado pelo usuario (raio)
    // Saída: exibir a circunferência e a área do círculo
    
    
    // descricao textual
    // 1) Solicitar do usuario o numero inteiro (raio)
    // 2) Calcular a circunferencia do circulo (2PiR)
    // 3) Calcular a área do circulo (PiRxR)
    // 4) Exibir a circunferencia do circulo
    // 5) Exibir a area do circulo
    
    // Algoritmo estruturado
    // Var R: inteiro    
    int r;
    //     C, A: real
    float c, a;
    const float PI = 3.14158;
    // Inicio
    // Escrever "Digite um numero inteiro: (raio)"
    cout << "Digite um numero inteiro: (raio)" << endl;
    // Ler R
    cin >> r;
    // C <- 2 * 3,14 * R
    c = 2 * PI * r;
    // A <- 3,14 * R * R
    a = PI * r * r; // potenciacao
    // Escrever "Circunferencia: " C
    cout << "Circunferencia: " << c << endl;
    // Escrever "Area: " A
    cout << "Area: " << a << endl;
    // Fim
              
    system("PAUSE");
    return EXIT_SUCCESS;

}

Problema 2:


#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    // Problema
    // Entrada: três números inteiros digitados pelo usuario
    // Saída: informar a média dos três numeros
    
    // Descricao textual
    //
    
    // Algoritmo estruturado
                
    // testes:
    // 1, 2, 3
    // 0, 0, 1
    // 7, 3, 1
    // 1, 1, 1
                    
    system("PAUSE");
    return EXIT_SUCCESS;
}

AED2- ferramentas

https://www.dropbox.com/sh/577soayw0x3j0oy/AABFcXEg8PdW0i8dnWuOtcGPa?dl=0

2014/2 - ALP - 2014.11.22 - Laboratório de Funções em C++

Problema 1

#include <cstdlib>
#include <iostream>

using namespace std;

  // Algoritmo calcularQuadrado
  float calcularQuadrado(float n){
  // Param N: real
    float r;// Var R: real
  // Inicio
    r = n * n;//   R <- N * N
    return r; //   Retornar R
  }// Fim


int main(int argc, char *argv[])
{
  // Problema - projeto1-funcoes
  // Entrada: um número real digitado pelo usuario
  // saída: calcular o quadrado do numero
  //        informado via funcao
 
  // descricao textual
  // 1) Ler do usuario o numero real (N)
  // 2) Calcular o quadrado do numero
  // 3) Exiir o resultado encontrado
 
 
  // Algoritmo estruturado
  float n, q;// Var N, Q: real
  // Inicio
  //   Escrever "Digite um numero real:"
  cout << "Digite um numero real:" << endl;
  //   Ler N
  cin >> n;
  //   Q <- calcularQuadrado(N)
  q = calcularQuadrado(n);
  //   Escrever "Resultado: " Q
  cout << "Resultado: " << q << endl;
  // Fim
 
  system("PAUSE");
  return EXIT_SUCCESS;
}

Problema 2

#include <cstdlib>
#include <iostream>

using namespace std;

    // algoritmo caractereEhVogal
    // Param C: caractere
    // Var
    // Inicio
    //   Se C == 'A' || C == 'E' ||
    //      C == 'I' || C == 'O' ||
    //      C == 'U' Entao
    //     Retornar VERDADEIRO
    //   Fim Se
    //   Retornar FALSO
    // Fim
    bool caractereEhVogal(char c){
         if (c == 'A' || c == 'E' ||
         c == 'I' || c == 'O' ||
         c == 'U'){
           return true;
         }
         return false;
    }
   
    // algoritmo substituir caractere em vetor
    // Params F: conjunto [1..100]: caractere
    //   I: inteiro
    //   C: caractere
    // Var
    // Inicio
    //   F[I] <- C
    // Fim
    void substituirCaractereEmVetor(
      char []f, int i, char c){
      f[i] = c;
    }
   
    // algoritmo imprimirVetor
    // Params F: conjunto [1..100]: caractere
    //   T: inteiro
    // Var: C: inteiro
    // Inicio
    //   Para C De 1 Até T Passo 1 Faça
    //     Escrever F[C]
    //   Fim Para
    // Fim
   
    void imprimirVetor(char [] F, int t){
      int c;
      for (c =0; c < t; c++){
          cout << f[c];
      }    
      cout << endl;
    }

int main(int argc, char *argv[])
{
    // projeto2-funcoes
    // Problema
    // Entrada: uma frase digitada pelo usuario
    // Saída: substituir todas as vogais da
    //        frase por '*',
    //        imprimir a frase final
   
    // descricao textual
    // 1) Ler a frase informada pelo usuario
    // 2) Para cada caractere na frase
    // 2.1) Se o caractere for um vogal
    // 2.1.1) Substituir o caractere por *
    // 3) Exibir a frase final
   
   
   
    system("PAUSE");
    return EXIT_SUCCESS;
}

2014-2/ALP: 2014.11.12 - Laboratório de Cadeia de Caracteres

#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    // PRoblema
    // Entrada: uma frase digitada pelo usuário
    // Saída: exibir a frase digitada na tela
    
    // descricao textual
    // 1) Ler uma frase digitada pelo usuario
    // 2) Exibir a frase na tela
    
    // Algoritmo estruturado
    // VAr  N: conjunto [1..100]: caractere
     // string n;
    char buf[100];
    // Inicio
    //   Escrever "Digite uma frase:"
    cout << "Digite uma frase:" << endl;
    //   Ler N
   // cin >> n;    
    cin.get(buf, 100);
    //   Escrever N
    cout << buf << endl;
    // Fim
    system("PAUSE");
    return EXIT_SUCCESS;
}




#include <cstdlib>
#include <iostream>
#include <cstring>

using namespace std;

int main(int argc, char *argv[])
{
    // Problema 2
    // Entrada: uma frase digitada pelo usuário
    // Saída: imprimir a frase invertida
    
    // descricao textual
    // 1) LEr a frase do usuario
    // 2) Para cada letra na frase comecando do final até o inicio
    // 2.1) Escrever o caractere na tela
    
    // Algoritmo estruturado
    // Var C, T: inteiro
    int c, t;
    //     N: conjunto [1..100]: caractere
    char n[100];
    // Inicio
    //   Escrever "Digite uma frase:"
    cout << "Digite uma frase:" << endl;
    //   Ler N
    cin.get(n, 100);
    //   T <- Tamanho(N)
    t = strlen(n);
    //   Para C De 100 Até 1 Passo -1 Faca
    for (c = t-1; c >=0; c--){
    //     Escrever N[C] 
      cout << n[c];
    }//   Fim Para
    cout << endl;
    // Fim
    system("PAUSE");
    return EXIT_SUCCESS;
}


#include <cstdlib>
#include <iostream>

using namespace std;

int main(int argc, char *argv[])
{
    // http://www.cplusplus.com/forum/beginner/13866/
    // problema
    // entrada: uma frase e um caractere digitado pelo usuario
    // saída: informar se o caractere ocorre na frase digitada
    
    
    system("PAUSE");
    return EXIT_SUCCESS;
}

2014-2 - OdA: Processador de Arquivo Direto

package br.pitagoras.oda.orgarq;

import java.util.List;
import java.util.Map;

import br.pitagoras.oda.orgarq.util.OrgArquivosUtil;

public class ProcessadorDeArquivoDireto extends OrgArquivoAbstrato implements OrgArquivosInterface{

private int tamanho;

public ProcessadorDeArquivoDireto(int tamanho) {
this.tamanho = tamanho;
}

@Override
public RegistroDeArquivo buscar(String chave) {
RegistroDeArquivo reg = null;
try {
Map<String, String> tabelaHash = OrgArquivosUtil.obterMapaRegistrosDiretosDoArquivo(getNomeArquivoDados());
String valor = tabelaHash.get(chave);
if (valor != null && !valor.trim().isEmpty()){
reg = new RegistroDeArquivo(valor);
}
} catch (Exception e) {

}

return reg;
}

@Override
public void inserir(RegistroDeArquivo registro) {
// verificar se o registro já existe na posicao calculada
RegistroDeArquivo reg = buscar(registro.getId());
try {
if (reg != null){ // se sim
//   lancar um erro
System.out.println("error");
} else { // senao
//   inserir na tabela hash
Map<String, String> tabelaHash = OrgArquivosUtil.obterMapaRegistrosDiretosDoArquivo(getNomeArquivoDados());
tabelaHash.put(registro.getId(), registro.obterCampos());
//   salvar a tabela no arquivo
OrgArquivosUtil.escreverMapaRegistrosDiretosEmArquivo(getNomeArquivoDados(), tabelaHash);
}
} catch (Exception e) {
}
}

@Override
public void atualizar(String chave, String valorAtual, String novoValor) {
// obter o registro
RegistroDeArquivo reg = null;
try {
reg = buscar(chave);
if (reg == null){
System.out.println("Error");
} else {
// atualizar o registro
reg.atualizar(valorAtual, novoValor);
// salvar o registro
Map<String, String> tabelaHash = OrgArquivosUtil.obterMapaRegistrosDiretosDoArquivo(getNomeArquivoDados());
tabelaHash.put(chave, reg.obterCampos());
OrgArquivosUtil.escreverMapaRegistrosDiretosEmArquivo(getNomeArquivoDados(), tabelaHash);
}
} catch (Exception e) {

}
}

@Override
public List<RegistroDeArquivo> pesquisar(String valor) {
List<RegistroDeArquivo> registros = pesquisarRegistrosEmArquivoDeDados(valor);


// TODO Auto-generated method stub
return registros;
}

@Override
public void excluir(String chave) {
try {
// buscar a tabela hash
Map<String, String> tabelaHash = OrgArquivosUtil.obterMapaRegistrosDiretosDoArquivo(getNomeArquivoDados());
// verificar se o registro existe
if (tabelaHash.get(chave) == null){
// se nao
//   lancar erro
} else {// senao
//   remover o registro da tabela
String reg = tabelaHash.get(chave);
tabelaHash.remove(reg);
//   salvar a tabela de dados em arquivo
OrgArquivosUtil.escreverMapaRegistrosDiretosEmArquivo(getNomeArquivoDados(), tabelaHash);
}
} catch (Exception e) {
}

}

}

2014-2-Oda: Organizador de Arquivos Abstrato

package br.pitagoras.oda.orgarq;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import br.pitagoras.oda.orgarq.util.OrgArquivosUtil;

public abstract class OrgArquivoAbstrato {

private String nomeArquivoDados;
private String nomeArquivoIndices;

protected RegistroDeArquivo buscarEmArquivoDeDados(String chave){
RegistroDeArquivo registro = null;

        try {
BufferedReader br = new BufferedReader(new FileReader(nomeArquivoDados));
String s = br.readLine();
String colunas = null;
if (s != null){
colunas = s;
}
s = br.readLine();
while (s != null) {
if (chave.equals(s.split(";")[0])){
registro = new RegistroDeArquivo(s);
break;
}
s = br.readLine();
}
br.close();
} catch (Exception e) {
System.err.println("ERRO ao realizar a busca pela chave " + chave);
throw new RuntimeException("ERRO ao realizar a busca pela chave ", e);
} 
return registro;
}

public void setNomeArquivoDados(String nomeArquivoDados) {
this.nomeArquivoDados = nomeArquivoDados;
}

public void setNomeArquivoIndices(String nomeArquivoIndices) {
this.nomeArquivoIndices = nomeArquivoIndices;
}

public String getNomeArquivoDados() {
return nomeArquivoDados;
}

public String getNomeArquivoIndices() {
return nomeArquivoIndices;
}

public List<RegistroDeArquivo> listarRegistros() {

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar listar registros";
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

public List<RegistroDeArquivo> pesquisarRegistrosEmArquivoDeDados(String valor) {

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
if (s.contains(valor)){
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar listar registros";
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

public List<String> listarIndices(){
try {
return OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoIndices());
} catch (Exception e) {
String msg = "ERRO ao tentar listar os indices do arquivo";
System.err.println(msg);
throw new RuntimeException(msg, e);
}
}

}

2014/2 - OdA: Organização Básica de Arquivos: Arquivo Indexado

package br.pitagoras.oda.orgarq;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import br.pitagoras.oda.orgarq.util.OrgArquivosUtil;
import br.pitagoras.oda.orgarq.util.StringUtil;

public class ProcessadorDeArquivoIndexado extends OrgArquivoAbstrato implements OrgArquivosInterface {


public ProcessadorDeArquivoIndexado(String nomeArquivoDeIndices, String nomeArquivoDeDados) {
this.setNomeArquivoDados(nomeArquivoDeDados);
this.setNomeArquivoIndices(nomeArquivoDeIndices);
System.out.println("Criando um processador de arquivo indexado . . .");
System.out.println("Arquivo de índices: " + nomeArquivoDeIndices);
System.out.println("Arquivo de dados: " + nomeArquivoDeDados);
}

String buscarNoIndice(String chave) throws FileNotFoundException, IOException{
// buscar no arquivo de indices
Map<String, String> mapaIndices = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
//   obter o indice associado a chave
String indice = mapaIndices.get(chave);
// se o indice existir
return indice;
}

@Override
public RegistroDeArquivo buscar(String chave){
RegistroDeArquivo reg = null;

try {
// buscar no arquivo de indices
String indice = buscarNoIndice(chave);
// se o indice existir
if (indice != null){
//   obter o registro associado ao indice
int pos = Integer.parseInt(indice);
List<String> dadosDoArquivo = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
reg = new RegistroDeArquivo(dadosDoArquivo.get(pos));
//   retornar o registro encontrado
}
} catch (Exception e) {
String msg = "ERRO: busca pela chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return reg;
}

@Override
public void inserir(RegistroDeArquivo registro){

// realizar a busca pelo registro
try {
String chave = registro.getId();
String indice = buscarNoIndice(chave);
// se ele existir
if (indice != null){
//   informar que o registro já existe
System.out.println("AVISO: o registro com chave " + chave + " já existe.");
} else { // senão
//  adicionar o registro novo no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
listDados.add(registro.obterCampos());
int pos = listDados.indexOf(registro.obterCampos());
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
System.out.println("Arquivo de dados salvo com sucesso: " + listDados.size());
// adicionar o registro novo no arquivo de indices
Map<String, String> mapaRegistros = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
mapaRegistros.put(registro.getId(), String.valueOf(pos));
OrgArquivosUtil.escreverMapaRegistrosEmArquivo(getNomeArquivoIndices(), mapaRegistros);
System.out.println("Arquivo de indices salvo com sucesso: " + mapaRegistros.size());
}
} catch (Exception e) {
String msg = "ERRO ao tentar inserir um novo registro " + registro;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

}

@Override
public void atualizar(String chave, String valorAtual, String valorNovo){

try {
// buscar pelo registro
String indice = buscarNoIndice(chave);
// se o registro nao for encontrado
if (indice == null){
//   mostrar mensagem de erro
} else { // senão
//   obter o registro do arquivo de dados
RegistroDeArquivo registro = buscarEmArquivoDeDados(chave);
//   atualizar o campo
registro.atualizar(valorAtual, valorNovo);
//   salvar o novo registro
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
int pos = Integer.parseInt(indice);
listDados.set(pos, registro.obterCampos());
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
}
} catch (Exception e) {
String msg = "ERRO ao tentar atualizar um registro com chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

}

@Override
public List<RegistroDeArquivo> pesquisar(String valor){

List<RegistroDeArquivo> registros = new ArrayList<RegistroDeArquivo>();
RegistroDeArquivo reg = null;

try {
// Para cada registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
for (String s: listDados){
//   se o registro possuir o valor
if (s.contains(valor)){
//     adiciona-lo na lista de resultados
reg = new RegistroDeArquivo(s);
registros.add(reg);
}
}
// retornar a listagem de resultados
} catch (Exception e) {
String msg = "ERRO ao tentar pesquisar por um registro com valor " + valor;
System.err.println(msg);
throw new RuntimeException(msg, e);
}

return registros;
}

@Override
public void excluir(String chave){
try {
// verificar se a chave existe no arquivo de indices
String indice = buscarNoIndice(chave);
// se sim
if (StringUtil.isEmpty(indice)){
System.out.println("AVISO: o registro com chave " + chave + " não existe.");
} else {
//   buscar o registro no arquivo de dados
List<String> listDados = OrgArquivosUtil.obterRegistrosDoArquivo(getNomeArquivoDados());
int pos = Integer.parseInt(indice);
//   remover o registro do arquivo
listDados.remove(pos);
// atualizar o arquivo
OrgArquivosUtil.escreverRegistrosEmArquivo(getNomeArquivoDados(), listDados);
//   remover o registro do arquivo de indices
Map<String, String> mapaIndices = OrgArquivosUtil.obterMapaRegistrosDoArquivo(getNomeArquivoIndices());
mapaIndices.remove(chave);
OrgArquivosUtil.escreverMapaRegistrosEmArquivo(getNomeArquivoIndices(), mapaIndices);
}
} catch (Exception e) {
String msg = "ERRO ao tentar excluir um registro com chave " + chave;
System.err.println(msg);
throw new RuntimeException(msg, e);
}
}
}