Feliz Natal!

:)

Boliche!

Quando: Amanhã (15 de dezembro);

Horário: 18:30 ~ 19:00 hs

Local:Dragon Bowling Shopping Colinas.

Boraa!!!

Código Fonte - Projeto II

Se alguém quiser baixar o código fonte do projeto, esta aí!

Download

Parabéns pra você, nessa data querida... ^^

Tirando todos os dias 11000 do ano, hoje é oficialmente o niver do Negão! xD

Parabéns para o premiado da nossa turma.

Semana de Provas!

Estudem! oO

Projeto II - Fase 4

Se alguém quiser baixar o projeto, esta aí!

Download

Banco de Dados I - 12

Interbase - Parte III
Interbase - Parte VI

Exercício XX:

1) Selecionar todos os registros de todas as tabelas;

select * from Usuarios
select * from Dependentes
select * from Funcionario
select * from Area
select * from Cargo
select * from Cidade
select * from Estado_Civil

2) Selecionar os campos nome, nome do pai, nome da mãe para os usuários do sexo feminino;

select Nome, Nome_do_Pai, Nome_da_Mae from Usuarios where Sexo = "F"

3) Selecionar os campos nome, endereço, ddd e telefone para os usuários do sexo masculino que moram no Jardim Damasco;

select Nome, Endereco, DDD, Telefone from Usuarios where Sexo = "M" and Bairro = "Jardim Damasco"

4) Selecionar todos os registros das tabelas de funcionários com seus dependentes;

select * from Funcionario t1, Dependentes t2 where t1.CodUsuario = t2.CodUsuario

5) Selecionar todos os funcionários que trabalham na Área de Engenharia e no Financeiro;

select * from Funcionarios t1, Area t2 where t1.CodArea = t2.CodArea and (t2.Nome = "Engenharia" or t2.Nome = "Financeiro")

6) Selecionar todos os funcionários que são secretárias, engenheiros e gerentes;

select * from Funcionario t1, Cargo t2 where t1.CodCargo = t2.CodCargo and (t2.Nome = "Secretária" or t2.Nome = "Engenheiro" or t2.Nome = "Gerente")

7) Selecionar os dependentes das secretárias;

select t1.CodDependente, t1.Nome, t1.Data_Nascimento, t1.Parentesco, t1.Sexo from Dependentes t1, Funcionario Func, Cargo t3 WHERE t2.CodDependente = t1.CodDependente and t2.CodCargo = t3.CodCargo and t3.Nome = "Secretaria"

8) Selecionar os funcionários com salário maior ou igual a R$ 1000,00;

select * from Funcionario where Salario >= 1000

9) Selecionar os usuários Casados da cidade de São José dos Campos;

select * from Usuarios t1, Cidade t2, Estado_Civil t3 where t1.CodCidade = t2.CodCidade and Cid.Cidade = "São José dos Campos" and t1.CodCivil = t3.CodCivil and t3.Descricao = "Casado"

10) Selecionar os dependentes dos funcionários cujos usuários são do sexo feminino;

select * from Dependentes t1, Funcionario t2, Usuarios t3 where t1.CodDependente = t2.CodDependente and t2.CodUsuario = t3.CodUsuario and t3.Sexo = "F"

11) Incluir mais 4 funcionários, sendo dois com salário maior que R$ 1000,00 e dois com salário menor que R$ 1000,00;

insert into Funcionarios values (1,1,1,1,1001,"19/11/2009","",1)
insert into Funcionarios values (2,2,2,2,1002,"19/11/2009","",1)
insert into Funcionarios values (3,3,3,3,999,"19/11/2009","",1)
insert into Funcionarios values (4,4,5,998,"19/11/2009","",1)

12) Selecionar os dependentes dos funcionários que ganham mais de R$ 1000,00 e cujos usuarios são do sexo masculino;

select * from Dependentes t1, Funcionario t2, Usuarios t3 where t1.CodDependente = t2.CodDependente and t2.CodUsuario = t3.CodUsuario and t3.Sexo = "M" and t3.Salario > 1000

Banco de Dados I - 11

Introdução ao Interbase
Interbase - Parte II

Exercício XX:

Escrever os comandos para criação das tabelas e executá-las no Interbase

Área:

CREATE TABLE AREA
(
"CODAREA" INTEGER NOT NULL,
"NOME" VARCHAR(50),
PRIMARY KEY ("CODAREA")
);

Cargo:

CREATE TABLE CARGO
(
"CODCARGO" INTEGER NOT NULL,
"NOME" VARCHAR(50),
PRIMARY KEY ("CODCARGO")
);

Cidade:

CREATE TABLE CIDADE
(
"CODCIDADE" INTEGER NOT NULL,
"CIDADE" VARCHAR(50),
"UF" VARCHAR(2),
PRIMARY KEY ("CODCIDADE")
);

Dependentes:

CREATE TABLE DEPENDENTES
(
"CODDEPENDENTE" INTEGER NOT NULL,
"NOME" VARCHAR(50),
"DATANAS" DATE,
"PARENTESCO" VARCHAR(50),
"SEXO" CHAR(1) NOT NULL,
PRIMARY KEY ("CODDEPENDENTE")
);

Estado Civil:

CREATE TABLE ESTADO_CIVIL
(
"CODCIVIL" INTEGER NOT NULL,
"DESCRICAO" VARCHAR(255),
PRIMARY KEY ("CODCIVIL")
);

Funcionário:

CREATE TABLE FUNCIONARIO
(
"CODFUNCIONARIO" INTEGER NOT NULL,
"CODUSUARIO" INTEGER,
"CODAREA" INTEGER,
"CODCARGO" INTEGER,
"SALARIO" FLOAT,
"DATAADM" DATE,
"DATADEM" DATE,
"CODDEPENDENTE" INTEGER,
PRIMARY KEY("CODFUNCIONARIO")
);

Usuários:

CREATE TABLE USUARIOS
(
"CODUSUARIO" INTEGER NOT NULL,
"NOME" VARCHAR(50),
"DATANAS" DATE,
"NOMEPAI" VARCHAR(50),
"NOMEMAE" VARCHAR(50),
"CODCIVIL" INTEGER,
"ENDERECO" VARCHAR(70),
"BAIRRO" VARCHAR(70),
"CODCIDADE" INTEGER,
"CEP" VARCHAR(9),
"DDD" INTEGER,
"TELEFONE" INTEGER,
"SEXO" CHAR(1) NOT NULL,
"CPF" VARCHAR(14),
"RG" VARCHAR(12),
PRIMARY KEY ("CODUSUARIO")
);

Ordenação Utilizando Filas de Prioridade

Implemente os algoritmos Insertion-Sort e Selection-Sort utilizando um TAD Fila de Prioridade que também deve ser desenvolvido.

Classes:

Fila:

import java.util.ArrayList;

abstract class Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public Fila(){
}

abstract public void InsereItem(int Chave, Object Elemento);

abstract public Item RemoveMin();

abstract public int MinKey();

abstract public Object MinElement();

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Item:

public class Item {

private int Chave;
private Object Elemento;

public Item(int Chave, Object Elemento){
this.Chave = Chave;
this.Elemento = Elemento;
}

public void setChave(int Chave){
this.Chave = Chave;
}

public void setElemento(int Elemento){
this.Elemento = Elemento;
}

public int getChave(){
return Chave;
}

public Object getElemento(){
return Elemento;
}

}

Sort:

import java.util.ArrayList;

public class Sort {

private Fila fila;
private ArrayList<Item> Array;

public Sort(ArrayList<Item> Array, Fila fila){
this.Array = Array;
this.fila = fila;
}

public ArrayList<Item> SortList(){
ArrayList<Item> ArrayOrdenado = new ArrayList<Item>();

for(int i = 0; i < Array.size(); i++)
fila.InsereItem(Array.get(i).getChave(), Array.get(i).getElemento());

int Tamanho = fila.Size();

for(int i = 0; i < Tamanho; i++)
ArrayOrdenado.add(fila.RemoveMin());

return ArrayOrdenado;
}

}

Selection-Sort:

import java.util.ArrayList;

public class SelectionSort extends Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public SelectionSort(){
}

public void InsereItem(int Chave, Object Elemento){
Array.add(new Item(Chave, Elemento));
}

public Item RemoveMin(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
Array.remove(menor);
return menor;
}

public int MinKey(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
return menor.getChave();
}

public Object MinElement(){
Item menor = Array.get(0);
for(int i = 0; i < Array.size(); i++){
if(Array.get(i).getChave() < menor.getChave())
menor = Array.get(i);
}
return menor.getElemento();
}

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Insertion-Sort:

import java.util.ArrayList;

public class InsertionSort extends Fila{

private ArrayList<Item> Array = new ArrayList<Item>();

public InsertionSort(){
}

public void InsereItem(int Chave, Object Elemento){
Array.add(new Item(Chave, Elemento));

int posicao = 1;
if(Array.size() >= 1){
while(posicao < Array.size()){
for(int i = posicao; i > 0; i--){
if(Array.get(i).getChave() < Array.get(i - 1).getChave())
SwapElements(Array.get(i), Array.get(i - 1));
}
posicao++;
}
}
}

public Item RemoveMin(){
Item temp = Array.get(0);
Array.remove(temp);
return temp;
}

public int MinKey(){
return Array.get(0).getChave();
}

public Object MinElement(){
return Array.get(0).getElemento();
}

private void SwapElements(Item Elemento1, Item Elemento2){
int index1 = Array.indexOf(Elemento1);
int index2 = Array.indexOf(Elemento2);

Array.set(index1, Elemento2);
Array.set(index2, Elemento1);
}

public int Size(){
return Array.size();
}

public boolean IsEmpty(){
return Array.isEmpty();
}

}

Main:

import java.util.ArrayList;


public class Main {

public static void main(String Args[]){

SelectionSort Sel = new SelectionSort();
InsertionSort Ins = new InsertionSort();

ArrayList<Item> ArraySel = new ArrayList<Item>();

ArraySel.add(new Item(5, "Elemento 5"));
ArraySel.add(new Item(4, "Elemento 4"));
ArraySel.add(new Item(2, "Elemento 2"));
ArraySel.add(new Item(3, "Elemento 3"));
ArraySel.add(new Item(1, "Elemento 1"));

Sort SelSort = new Sort(ArraySel, Sel);

ArrayList<Item> ArrayIns = new ArrayList<Item>();

ArrayIns.add(new Item(10, "Elemento 10"));
ArrayIns.add(new Item(9, "Elemento 9"));
ArrayIns.add(new Item(8, "Elemento 8"));
ArrayIns.add(new Item(7, "Elemento 7"));
ArrayIns.add(new Item(6, "Elemento 6"));

Sort InsSort = new Sort(ArrayIns, Ins);

ArrayList<Item> ArrayRetornoSel = SelSort.SortList();

for(int i = 0; i < ArrayRetornoSel.size(); i++)
System.out.printf("%d ", ArrayRetornoSel.get(i).getChave());

System.out.printf("\n");

ArrayList<Item> ArrayRetornoIns = InsSort.SortList();

for(int i = 0; i < ArrayRetornoIns.size(); i++)
System.out.printf("%d ", ArrayRetornoIns.get(i).getChave());

}

}

TAD Árvore Binária

Objetivo: Escreva um programa que leia uma seqüência de números e monte uma Árvore Binária.

O programa deve ter as seguintes opções:

• Ler números digitados pelo usuário e montar a Árvore Binária ordenada;
• Remover um determinado elemento da árvore;
  Obs: Para simplificar permita remover somente "folhas".
• Verificar se a árvore está vazia;
• Percorrer a árvore pelos modos: preorder, inorder e posorder;
• Exibir a árvore na tela, de modo que a estrutura binária da árvore possa ser visualizada, ou seja, de maneira que possamos conferir a estrutura da árvore;
• Retornar a altura da árvore.

Classes:

Árvore:

import java.util.ArrayList;

public class Arvore {

// Atributo
private Elemento Raiz;

// Construtor recebe um Elemento Raiz para criar a árvore
public Arvore(Elemento Raiz){
this.Raiz = Raiz;
}

// Método SET
public void setRaiz(Elemento Raiz){
this.Raiz = Raiz;
}

// Método GET
public Elemento getRaiz(){
return this.Raiz;
}

// Método para inserir um novo elemento na árvore
public void InserirElemento(int Valor){

// O caminhamento na arvore vai começar a partir da raiz
Elemento ElementoAux = Raiz;

// Cria um novo elemento com o valor a ser inserido
Elemento NovoElemento = new Elemento(Valor);

// Inicia o caminhamento na árvore
while(ElementoAux != null){

// Verifica se o valor a ser inserido é maior que o valor do elemento atual
if(Valor > ElementoAux.getValor()){
// Verifica se elemento direito é diferente de nulo
if(ElementoAux.getElementoDireito() != null) // Se sim, pega o elemento direito para continuar a busca
ElementoAux = ElementoAux.getElementoDireito();
else{ // Se não, insere o elemento como o elemento direito
ElementoAux.setElementoDireito(NovoElemento);
ElementoAux = null;
}
// Valor a ser inserido menor que o valor do elemento atual
} else {
// Verifica se elemento esquero é diferente de nulo
if(ElementoAux.getElementoEsquerdo() != null) // Se sim, pega o elemento esquerdo para continuar a busca
ElementoAux = ElementoAux.getElementoEsquerdo();
else{ // Se não, insere o elemento como o elemento esquerdo
ElementoAux.setElementoEsquerdo(NovoElemento);
ElementoAux = null;
}
}
}
}

// Método para fazer o caminhamento "PreOrder"
public void PreOrder(Elemento Elemento){
if(Elemento != null){
System.out.printf("%d ", Elemento.getValor());
if(Elemento.Interno()){
PreOrder(Elemento.getElementoEsquerdo());
PreOrder(Elemento.getElementoDireito());
}
}
}

// Método para fazer o caminhamento "PostOrder"
public void PostOrder(Elemento Elemento){
if(Elemento != null){
if(Elemento.Interno()){
PostOrder(Elemento.getElementoEsquerdo());
PostOrder(Elemento.getElementoDireito());
}
System.out.printf("%d ", Elemento.getValor());
}
}

// Método para fazer o caminhamento "InOrder"
public void InOrder(Elemento Elemento){
if(Elemento != null){
if(Elemento.Interno()){
InOrder(Elemento.getElementoEsquerdo());
}
System.out.printf("%d ", Elemento.getValor());
if(Elemento.Interno()){
InOrder(Elemento.getElementoDireito());
}
}
}

// Método para remover um elemento
// Recebe como parâmetro um elemento e o valor a ser removido
public boolean Remover(Elemento Elemento, int Valor){
// Verifica se elemento é diferente de nulo
if(Elemento != null){
// Verifica se o valor do elemento é igual ao valor a ser removido
if(Elemento.getValor() == Valor){
// Verifica se o elemento é um elemento externo
if(!Elemento.Interno()) // Se sim, retorna verdadeiro, pois pode ser removido
return true;
else // Se não, retorna falso, pois não pode ser removido
return false;

// Se valor do elemento atual for diferente do valor a ser removido...
} else {

// Verifica se o elemento atual é um elemento interno
if(Elemento.Interno()){

boolean flag; // Flag para verificar se foi removido o elemento

flag = Remover(Elemento.getElementoEsquerdo(), Valor); // Chama a função remover recursivamente enviando o elemento esquerdo

// Verifica se foi removido o elemento
if(flag){
Elemento.setElementoEsquerdo(null); // Remove a ligação com o elemento
return false;
} else {

flag = Remover(Elemento.getElementoDireito(), Valor); // Chama a função remover recursivamente enviando o elemento direito

// Verifica se foi removido o elemento
if(flag){
Elemento.setElementoDireito(null); // Remove a ligação com o elemento
return false;
} else
return false;
}
}
}
}
return false;
}

// Método chamado para calcular Altura da árvore
public int Altura(){
return CalculaAltura(this.Raiz, 0);
}

// Método para calcular a Altura da árvore
// Recebe como parâmetro um elemento e a altura atual da contagem
private int CalculaAltura(Elemento Elemento, int Altura){
// Verifica se elemento é diferente de nulo
if(Elemento != null){

// Verifica se elemento atual é um elemento interno
if(Elemento.Interno()){
int AlturaAux1, AlturaAux2;
// Chama o método para Calcular altura recursivamente, enviando o elemento esquerdo e a altura atual + 1
AlturaAux1 = CalculaAltura(Elemento.getElementoEsquerdo(), Altura + 1);

// Chama o método para Calcular altura recursivamente, enviando o elemento direito e a altura atual + 1
AlturaAux2 = CalculaAltura(Elemento.getElementoDireito(), Altura + 1);

// Verifica qual dos lados teve a maior altura e retorna
if(AlturaAux1 > AlturaAux2)
return AlturaAux1;
else
return AlturaAux2;

// Se elemento atual é um elemento externo, apenas retorna a altura recebida
} else {
return Altura;
}
}
return 0;
}

// Método Auxiliar do método para imprimir
// Método Cria um Array onde cada posição do array representa um nível da arvore.
private ArrayList<object> BuscaPai(){

// Cria um array de niveis
ArrayList<object> ArrayNiveis = new ArrayList<object>();

// Cria um array auxiliar para fazer o laço
ArrayList<object> ArrayAux = new ArrayList<object>();
ArrayAux.add(this.Raiz); // Inicia o array com o elemento Raiz

ArrayNiveis.add(ArrayAux); // Adiciona no array de niveis o array contendo o elemento raiz

// Percorre o array auxiliar
while(ArrayAux.size() >= 1){

// Cria um array para receber o array do método BuscaFilhos
ArrayList<object> Array = new ArrayList<object>();

// Recebe o array do método BuscaFilhos
Array = BuscaFilhos(ArrayAux);

// Adiciona o array recebido no array de níveis
ArrayNiveis.add(Array);

// Verifica se o conteudo do array recebido tem algum elemento válido, não nulo
boolean Flag = false;
for(int i = 0; i < Array.size(); i++){
if(Array.get(i) != null){
Flag = true; // Existe elemento válido
break;
}
}

// Se existe elemento válido, seta o array auxiliar com o array recebido pelo método BuscaFilhos
if(Flag)
ArrayAux = Array;
else{ // Se não existe elemento válido, remove esse último array do array de níveis
ArrayNiveis.remove(ArrayNiveis.indexOf(Array));
break;
}
}

// Retorna o array de níveis para a impressão
return ArrayNiveis;
}

// Método Auxiliar do Método BuscaPai
// Método cria um array de filhos de acordo com o array passado
private ArrayList<object> BuscaFilhos(ArrayList<object> Array){

// Cria um novo array de filhos
ArrayList<object> ArrayNovo = new ArrayList<object>();

// Percorre o array passado, adicionando no novo array o filho da esquerda e da direita
for(int i = 0; i < Array.size(); i++){
// Recupera o elemento do array
Elemento ElementoAux = (Elemento)Array.get(i);

// Verifica se elemento é diferente de nulo
if(ElementoAux != null){ // Se sim, adiciona o elemento esquerdo e direito no novo array
ArrayNovo.add(ElementoAux.getElementoEsquerdo());
ArrayNovo.add(ElementoAux.getElementoDireito());
} else { // Se não, adiciona dois valores nulos no novo array, indicando que não tem filhos
ArrayNovo.add(null);
ArrayNovo.add(null);
}
}

// Retorna o novo array de filhos para a função BuscaPai
return ArrayNovo;
}

// Método para imprimir a árvore
public void Imprimir(){

// Chama a função BuscaPai que retornará o array de níveis da arvore
ArrayList<object> Array = BuscaPai();

// Verifica o tamanho do array da ultima posição do array de níveis
ArrayList<object> ArraySize = (ArrayList<object>) Array.get(Array.size() - 1);

// Cria uma variavel de tamanho
int Tamanho = ArraySize.size();

// Percorre o array de níveis
for(int i = 0; i < Array.size(); i++){

// Recupera o array da posição atual do array de niveis
ArrayList<object> Array2 = (ArrayList<object>) Array.get(i);

// Divide o tamanho pela metade, que é o número de espaços que serão utilizados para o nivel atual
Tamanho = Tamanho/2;

if(i == Array.size() - 1)
System.out.printf(" ");

for(int j = 0; j < Array2.size(); j++){

int Espacos; // Variavel que conterá quantos "\t" serão necessários para desenhar o nível atual

if(j == 0) // Se for o primeiro índice do FOR, recebe o próprio tamanho
Espacos = Tamanho;
else // Se não, recebe o tamanho * 2
Espacos = Tamanho * 2;

// Percorre o número de espaços tabulando a impressão
for(int k = 1; k <= Espacos; k++)
System.out.printf("\t");

// Verifica se é o último nível que está sendo impresso na tela
if((i == Array.size() - 1) && (j != 0))
System.out.printf("\t "); // Se sim, insere alguns espaços depois da tabulação

// Recupera o elemento para recuperar o valor
Elemento NovoElemento = (Elemento)Array2.get(j);

// Se elemento diferente de nulo...
if(NovoElemento != null)
System.out.printf("%d", NovoElemento.getValor()); // Imprime o valor do elemento
else
System.out.printf("-"); // Imprime um traço
}
System.out.printf("\n"); // Pula de linha a cada nível
}

}

}

Elemento:

public class Elemento {

// Atributos
private int Valor;
private Elemento ElementoDireito;
private Elemento ElementoEsquerdo;

// Contrutor recebe um valor como parâmetro
public Elemento(int Valor){
this.Valor = Valor;
this.ElementoDireito = null;
this.ElementoEsquerdo = null;
}

// Métodos SET
public void setValor(int Valor){
this.Valor = Valor;
}

public void setElementoEsquerdo(Elemento ElementoEsquerdo){
this.ElementoEsquerdo = ElementoEsquerdo;
}

public void setElementoDireito(Elemento ElementoDireito){
this.ElementoDireito = ElementoDireito;
}

// Métodos GET
public int getValor(){
return this.Valor;
}

public Elemento getElementoEsquerdo(){
return this.ElementoEsquerdo;
}

public Elemento getElementoDireito(){
return this.ElementoDireito;
}

// Método para verificar se nodo é interno
public boolean Interno(){
if((ElementoEsquerdo != null) || (ElementoDireito != null))
return true;
return false;
}

}

Main:

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

public static void main(String Args[]){

int Opcao;

Scanner input = new Scanner(System.in);

// Cria um novo elemento que será o elemento Raiz
Elemento elemento = new Elemento(25);

// Cria a nova árvore, enviando o elemento Raiz
Arvore arvore = new Arvore(elemento);

// Insere os elementos na árvore
arvore.InserirElemento(15);
arvore.InserirElemento(20);
arvore.InserirElemento(10);
arvore.InserirElemento(13);
arvore.InserirElemento(30);
arvore.InserirElemento(28);
arvore.InserirElemento(35);
arvore.InserirElemento(14);

Opcao = 1;

while((Opcao >= 0) && (Opcao <= 7)){
Menu();
Opcao = input.nextInt();

if((Opcao >= 0) && (Opcao <= 7)){
int Valor;
switch(Opcao){
case 1 : ;
System.out.printf("\nDigite o valor do elemento a ser inserido: ");
Valor = input.nextInt();
arvore.InserirElemento(Valor);
break;
case 2 : System.out.printf("\nDigite o valor do elemento a ser removido: ");
Valor = input.nextInt();
arvore.Remover(arvore.getRaiz(), Valor);
break;
case 3 : System.out.printf("\nAltura da árvore: %d", arvore.Altura());
break;
case 4 : System.out.printf("\nPreOrder: ");
arvore.PreOrder(arvore.getRaiz());
break;
case 5 : System.out.printf("\nPostOrder: ");
arvore.PostOrder(arvore.getRaiz());
break;
case 6 : System.out.printf("\nInOrder: ");
arvore.InOrder(arvore.getRaiz());
break;
case 7 : arvore.Imprimir();
break;
}

}

}

}

private static void Menu(){
System.out.printf("\n");
System.out.printf("\n");
System.out.printf("0 - Sair\n");
System.out.printf("1 - Inserir Elemento\n");
System.out.printf("2 - Remover Elemento\n");
System.out.printf("3 - Verificar Altura\n");
System.out.printf("4 - Caminhamento PreOrder\n");
System.out.printf("5 - Caminhamento PostOrder\n");
System.out.printf("6 - Caminhamento InOrder\n");
System.out.printf("7 - Imprimir Árvore\n");
System.out.printf("Digite Sua Opção: ");
}

}

CMMI

Introdução

Hoje em dia, com a intensa demanda de softwares nas mais variadas áreas do mercado, muitos softwares têm sido desenvolvidos para atender essa demanda. Mas, muitos deles não são produzidos segundo uma norma, uma vez que seus desenvolvedores estão focados somente em satisfazer as necessidades inicias de seus clientes, negligenciando assim alguns aspectos de manutenção e durabilidade do software. Gerando então preocupações consideráveis quanto à qualidade desses produtos.

Para resolver este problema, foram criados os Modelos de Qualidade de Software cujo objetivo principal é garantir a qualidade do produto através da definição e normatização de processos de desenvolvimento. Os modelos mais conhecidos atualmente são: ISO, CMM, CMMI.

O CMMI (Capability Maturity Model Integration), desenvolvido pelo SEI (Sofware

Engineering Institute), é uma evolução do CMM (Capability Model Integration) que tenta suprir problemas de integração deste.

Para atender aos diversos setores da indústria de software, o SEI divulgou diversos documentos derivados do CMM. Mas, essa diversidade gerou problemas de integração e custo de treinamento, já que cada modelo possui características específicas. Com intuito de unificar os modelos baseados no CMM, o SEI desenvolveu o CMMI.

Será apresentado neste trabalho o Modelo de Qualidade CMMI, sua definição, bem como suas características e seus objetivos. Serão esplanadas também as representações do CMMI: continua e em estágios, algumas empresas brasileiras que possuem qualificações CMMI, e por fim, serão feitas as considerações finais sobre o assunto.

Definição

O CMMI é um modelo de referência que contém práticas: Genéricas ou Específicas necessárias à maturidade em disciplinas específicas. Desenvolvido pelo SEI (Software Engineering Institute) da Universidade Carnegie Mellon, o CMMI é uma evolução do CMM e procura estabelecer um modelo único para o processo de melhoria corporativo, integrando diferentes modelos e disciplinas.

Características

Como seus antecessores, o CMMI não define como o processo deve ser implementado, mas prescreve suas características estruturais e semânticas em termos de objetivos e de grau de qualidade com que o trabalho deve ser realizado.

O CMMI constitui tanto um modelo de capacidade como um modelo de maturidade. O modelo dentro de uma empresa pode ser alcançado em etapas consecutivas, representando a idéia de maturidade ou também de maneira contínua, onde é mensurada a capacidade em práticas individuais.

Quando uma organização atinge um nível de maturidade, considera-se que seus processos alcançaram uma determinada capacidade, ou seja, têm mecanismos que garantem a repetição sucessiva de bons resultados futuros relacionados principalmente à qualidade, custos e prazos.

É de grande importância conhecer os processos definidos da organização para que possam se reconhecer os pontos fortes e pontos em que possa haver melhorias e assim seguir alguns passos genéricos para a implementação de CMMI:

• Iniciar o compromisso organizacional para se estabelecer um ambiente propício ao ciclo de melhoria;


• Diagnosticar os pontos fortes e as oportunidades de melhoria utilizando um método de avaliação;


• Estabelecer um plano de ação;


• Implementar o plano de ação e controlar seu progresso, tomando atitudes corretivas necessárias de maneira oportuna. Uma forma de controlar o estado de institucionalização do processo é mediante processos de auto-avaliação ou uma nova avaliação;


• Propagar a institucionalização na organização revisando problemas ou lições aprendidas no caminho, preparando-se para o próximo ciclo.

Objetivos do CMMI

Redução do custo da implementação de melhoria de processo multidisciplinar baseada em modelo por meio de:

• Eliminação de inconsistências, redução de duplicidades


• Melhoria da clareza e entendimento


• Utilização de terminologia comum e estilo consistente


• Estabelecimento de regras de construção uniformes


• Manutenção de componentes comum


• Consistência com a futura norma ISSO/ IEC 15504


• Sensibilidade às implicações dos esforços legados

Para que esses objetivos sejam alcançados é necessário que a empresa tenha um foco, um objetivo a ser alcançado, onde a partir daí um avaliador capacitado faz todas as entrevistas e avaliações possíveis para com isso dar um retorno a empresa lhe indicando o seu nível de maturidade e pontos a serem melhorados para que a empresa possa se desenvolver.

Representações do CMMI

O CMMI contém duas representações: contínua e por estágios. Elas permitem à organização utilizar diferentes caminhos para a melhoria de acordo com seu interesse.

A contínua permite que uma organização selecione uma área (ou um grupo de áreas) de processo e melhore os processos relacionados. Ela usa níveis de capacidade para caracterizar melhorias relativas a uma área de processo individual.

A estagiada usa conjuntos pré-definidos de áreas de processo (KPA's) para definir um caminho para uma organização, caracterizado por níveis de maturidade. Cada nível contém um conjunto de áreas de processo que caracterizam diferentes comportamentos organizacionais, correspondendo à capacidade da empresa de realizar projetos grandes e complexos.

Representação Continua

Na representação contínua, o enfoque ou componentes principais são as áreas de processo. Existem metas e práticas de dois tipos: específicas a uma determinada área de processo e genéricas aplicáveis indistintamente a todas as áreas de processo. A partir da avaliação e do atendimento dessas práticas e metas é possível classificar o nível de capacidade de cada área de processo, em níveis de zero a cinco:

Nível 0 - Incompleto: Quando um processo é parcialmente realizado ou não realizado. Um ou mais objetivos específicos do processo não estão satisfeitos.

Nível 1 - Realizado: Quando um processo realizado satisfaz todos os objetivos específicos da área de processo e produz algum trabalho.

Nível 2 - Gerenciado: Quando um processo de capacidade nível dois é um processo realizado (nível um) que também é planejado e executado de acordo com políticas pré-definidas. Emprega pessoas hábeis com os recursos adequados para produzir saídas adequadas, envolve os stakeholders (“qualquer pessoa ou entidade que afeta ou é afetada pelas atividades de uma empresa”) principais e é monitorado, controlado, revisto e avaliado quanto à aderência à sua descrição. A gerência do processo é relacionada com a realização de objetivos específicos estabelecidos para o processo, como custo, cronograma e qualidade.

Nível 3 - Definido: Quando um processo definido é um processo gerenciado e ajustado para o conjunto padrão de processos da organização de acordo com suas políticas de conduta. Esse conjunto é estabelecido e melhorado com o tempo e descreve os elementos fundamentais de processos que são esperados nos processos definidos.

Nível 4 - Gerenciado quantitativamente: um processo neste nível é definido e controlado com a ajuda de técnicas quantitativas e estatísticas. A qualidade e o desempenho do processo são compreendidos em termos estatísticos e são geridos durante sua vida. Objetivos quantitativos para qualidade e desempenho de processos são estabelecidos e usados como critério na gerência do processo.

Nível 5 - Otimizado: um processo otimizado é gerenciado quantitativamente, alterado e adaptado para atender aos objetivos de negócio atuais e projetados.

Vantagens da representação contínua

• Maior flexibilidade para focar em áreas de processo específicas de acordo com as metas e objetivos de negócio;


• Estrutura familiar para os que migram da comunidade de engenharia de sistemas.

Representação por estágios

A representação em estágios oferece uma abordagem estruturada e sistemática para a melhoria de um estágio por vez. Atingir um estágio significa que uma estrutura de processo adequada foi estabelecida como base para o próximo estágio.

As áreas de processo são organizadas por níveis de maturidade (1 a 5), que definem o caminho de melhoria que uma organização deve seguir do nível inicial ao nível otimizado. Dentro de cada nível, existem áreas de processo que contêm metas, características comuns e práticas.

Na representação em níveis, as práticas são caracterizadas pelos atributos: compromisso para execução (práticas que garantem que o processo seja estabelecido e apoiado); habilidade para execução (práticas que criam condições para que o processo seja estabelecido completamente) e atividade para execução (práticas que implementam diretamente o processo); controle e verificação de implementação. A transição entre os níveis resulta em melhorias incrementais e duradouras.

Os estágios de maturidade são:

Nível 1 - Inicial: Neste nível em geral, as organizações desse nível têm processos imprevisíveis que são pobremente controlados e reativos. Nesse nível de maturidade os processos são normalmente “ad hoc” (“para um fim específico”) e caóticos. A Organização geralmente não fornece um ambiente estável. Neste nível não há KPA's.

Nível 2 – Gerenciado: No nível de maturidade dois os projetos da organização têm a garantia de que os requisitos são gerenciados, planejados, executados, medidos e controlados. Quando essas práticas são adequadas, os projetos são executados e controlados de acordo com o planejado. O foco, neste nível, é o gerenciamento básico de projetos e tem as seguintes KPA's desse nível são: gerenciamento de requisitos; planejamento do projeto; controle e monitoração do projeto; gerenciamento de suprimentos; avaliação e análise; garantia da qualidade do processo; configuração do gerenciamento.

Nível 3 – Definido: No nível de maturidade três, em que todos os objetivos específicos e genéricos atribuídos para os níveis de maturidade dois e três foram alcançados, os processos são mais bem caracterizados e entendidos e são descritos em padrões, procedimentos, ferramentas e métodos. O foco neste nível é a padronização do processo, tendo como KPA's: requisitos de desenvolvimento; soluções técnicas; integração de produtos; verificação; validação; foco no processo organizacional; definição do processo organizacional; treinamento organizacional; gerenciamento de projeto integrado; gerenciamento de riscos; integração da equipe de trabalho; gerenciamento integrado de suprimentos; análise de decisões; ambiente organizacional para integração.

Nível 4 - Quantitativamente Gerenciado: No nível de maturidade quatro, em que os objetivos específicos atribuídos para os níveis de maturidade 2, 3 e 4 e os objetivos genéricos atribuídos para os níveis de maturidade 2 e 3 foram alcançados, os processos são medidos e controlados. O foco neste nível é o gerenciamento quantitativo e possui as seguintes KPA's: performance organizacional do processo; gerenciamento quantitativo de projetos.

Nível 5 – Otimizado: No nível de maturidade cinco, o mais alto nível de maturidade CMMI, uma organização atingiu todos os objetivos específicos atribuídos para os níveis de maturidade 2, 3, 4 e 5, e os objetivos genéricos atribuídos para os níveis de maturidade 2 e 3. Os processos são continuamente aperfeiçoados, e baseados em um entendimento quantitativo em que a variação de um processo existe devido às interações, normais e presumidas, entre os componentes desse processo. Esse nível de maturidade tem como objetivo a melhoria contínua do processo. As KPA's desse nível são: inovação organizacional e análise de causas e resoluções.

Vantagens da representação por estágios

• Fornece um mapa para implementação:


• Grupos de áreas de processos


• Seqüência da implementação


• Estrutura familiar para os que migram do SW-CMM.

Considerações Finais

A utilização de metodologias em desenvolvimento de software como o CMMI é de grande importância no desenvolvimento das organizações para torná-las mais competitivas no mercado de trabalho obtendo melhorias nos seus processos assim fazendo com que alcancem a qualidade necessária de seus produtos e melhores resultados em seus negócios com cumprimento de prazos.

Para garantir essa qualidade e que seus processos estejam sendo executados de maneira correta é necessária uma avaliação contínua dos processos da organização, verificando assim se a organização está em desenvolvimento ou até mesmo em outro nível, mas para isso é exigido um número de avaliações por um período de tempo.

Referências Bibliográficas

[1] Ministério da Ciência e Tecnologia Secretaria de Política de Informática Qualificação CMM e CMMI no Brasil:
www.mct.gov.br/upd_blob/0009/9238.pdf
Acessado em 26/10/09.
[2] Comércio Eletrônico: Uma Análise da Aplicabilidade de Modelos de Qualidade de Software:
www.lbd.dcc.ufmg.br:8080/colecoes/sbqs/2002/009.pdf
Acessado em 26/10/09.
[3] Uma visão geral do CMMI:
www.dromostg.com.br/CMMI.PDF
Acessado em 26/10/09.
[4] Análise de uma Organização de Software utilizando o Modelo CMMI/SEI v1.0:
www2.dem.inpe.br/ijar/Qualidade%20de%20Software/PDFs/CMMI-Artigo.pdf
Acessado em 26/10/09.
[5] Gerência de Risco em Processos de Qualidade de Software: uma Análise Comparativa:
www.sbc.org.br/bibliotecadigital/download.php?paper=235
Acessado em 26/10/09.
[6] Departamento de Produção POLI O novo modelo CMMI
www.spinsp.org.br/apresentacao/new_cmmi.pdf
Acessado em 26/10/09.
[7] ISO/IEC 15504:
www.cin.ufpe.br/~processos/TAES3/slides-2006.2/ISO15504_V02.ppt
Acessado em 26/10/09.
[8] CMM - Dificuldades de implantação do modelo; sua aplicação no setor financeiro:
www.mbis.pucsp.br/monografias/Monografia_-_Mauro_Dias.pdf
Acessado em 26/10/09.
[9] ISD Brasil:
www.isdbrasil.com.br/default.asp
Acessado em 26/10/09.
[10] Wikipedia Capability Maturity Model Integration:
en.wikipedia.org/wiki/CMMI
Acessado em 26/10/09.
[11] Expandindo o Agile para se adequar ao CMMI Nível 3:
msdn.microsoft.com/pt-br/library/cc517970.aspx
Acessado em 26/10/09.

Banco de Dados I - 10

Normalização

Exercício X:

Primeiro

Segundo

ps. Não sei se está correto, não entendi quase nada do era para fazer... ^^

Banco de Dados I - 09

Banco de Dados III

Exercício IX:

Utilizando os dois exercícios feitos na Aula 8, passar do modelo conceitual para o modelo lógico relacional, conforme o exemplo da aula da Vídeo Locadora.

Resolução em breve. :P

Função "CAPS" do YouTube ™ by Negão.

Clique na imagem para ampliá-la

Banco de Dados I - 08

Banco de Dados I
Banco de Dados II

Exercício VIII:

1) Uma Empresa possui funcionários. Um funcionário trabalha em uma Empresa.



2) Os Atletas participam de competições. Em uma competição participam vários atletas.



3) Deseja-se fazer um banco de dados para uma rede de hotelaria. Um hotel possui quartos. Cada quarto pertence a apenas um hotel.



4) Um soldado, que possui as características nome, Registro Militar (RM), data de nascimento, possui armas. Uma arma, que possui as características de série, registro e calibre, é de um soldado. Uma arma é limpa por vários soldados. Um soldado limpa várias armas.



5) Um médico trata de pacientes. Do médico deseja-se saber CRM, nome e suas especializações. Um paciente, no qual há a necessidade de sabermos seu nome, endereço e idade, é tratado por vários médicos. Um paciente realiza vários tipos de exames. Um tipo de exame, destes há a necessidade de guardar seu número, data e descrição, é feito por vários paciente.



6) Construir um DER de uma Companhia de Seguros - Slide



7) Crie um Diagrama de ER com as seguintes informações:

Um cliente faz pedidos de produtos. Os produtos são fornecidos por produtores que se encontram em várias cidades do país.
Cada cliente nasceu e mora em uma Cidade. A empresa produtora tem funcionários que trabalham no período diurno e noturno.
Os clientes podem utilizar para pagamento cartões de crédito e cartão de débito como também boleto bancário.

Banco de Dados I - 07

Banco de Dados - Introdução

Exercício VII:

1.O que é um SGBD?

Sistema Gerenciador de Banco de Dados é um conjunto de dados que se associam a um conjunto de programas para acesso a esses dados, ou seja, o SGBD proporciona um ambiente tanto conveniente quanto eficiente para a recuperação e armazenamento das informações do banco de dados, além de prover compartilhamento e segurança das mesmas.

2.Cite 3 vantagens de um SGBD?

Consistência de dados e independência de dados;
Facilitam a proteção contra a perda de dados, através de recursos de backup;
Promovem a adoção de padrões para toda a empresa.

3.Quais as principais funções e responsabilidades de um DBA?

O DBA (Database Administrator) é responsável pelo acesso à base de dados, coordenar e monitorar o uso da base de dados, por problemas, tais como, quebra de segurança ou baixo desempenho, ou seja, é o administrador maior da base de dados.

4.Defina: Processamento de Consultas, Administração de Armazenamento de dados e Implementação física do sistema.

- Processamento de Consultas é composto por: Compilador DML - traduz os comandos de baixo nível (DML); Pré-compilador para comandos DML - pré-compilam os comandos DML;

Componentes para o tratamento de consultas - executam as instruções geradas por esse compilador DML.

- Administração de Armazenamento de dados é composto por: Gerenciamento de autorizações e integridade - gerencia as autorizações dos usuários e a integridade dos dados;

Gerenciamento de transações - gerencia as transações garantindo que o banco de dados permaneça em estado constante a despeito de falhas;

Administração de arquivos - administra os arquivos gerenciando a alocação de espaço no armazenamento em disco Administração de buffer, responsável pela intermediação de dados do disco para a memória principal e pela decisão de quais dados colocar em memória cache;

- Implementação física do sistema é composto por: Arquivo de dados - que armazena o próprio banco de dados;

Dicionário de dados - que armazena os meta-dados relativos à estrutura do banco de dados;

Índices - que proporcionam acesso rápido aos itens de dados que são associados a valores determinados;

Estatística de Dados - que armazenam informações estatísticas relativas aos dados contidos no banco de dados. Essas informações são usadas pelo processador de consultas para seleção de meios eficientes para execução de uma consulta.

<span> ? </span> - 3

Será?

<span> ? </span> - 2

Optei?

No Aula.

Hoje dia 19/10, não terá aula.

o.O'

Não sabemos o por que, mas, é um bom começo de semana, não acham? ^^

III INIC Júnior / XIII INIC / IX EPG - FOTOS

Dalton

























Felipe Cardoso



















Felipe Cardoso

Trabalho Pre miado

O orgulho da nossa turma. ^^

III INIC Júnior / XIII INIC / IX EPG

Dias 15 e 16 de outubro de 2009

1° Maratona de Programação - UNIVAP

A maratona será hoje, 14/10/2009, quem ainda não se inscreveu, ainda da tempo:

http://www1.univap.br/alberto/maratona

Notas!

Quando será que vão sair as notas??
Alguém tem a prova de sábado?
=p

<span> ? </span> - 1

Sr.(a) [email]? o.O

Semana de Provas!

TENSO!

Engenharia de Software I - 03

Capítulo 4: Fase Requisitos de Software RS

Fase Requisitos de Software RS (SW I) - Download
Documento liberável DRS - Download

Banco de Dados I - 06

UML - Parte II

Exercício VI:

1 - Com suas palavras definam os 9 diagramas usados nas fases da UML:

Diagrama de use case: Descreve um cenário que mostra as funcionalidades do sistema do ponto de vista do usuário e tem o objetivo de auxiliar a comunicação entre os analistas e o cliente. O cliente deve ver no diagrama de Use Cases as principais funcionalidades de seu sistema.

Diagrama de classes: Tem como objetivo descrever os vários tipos de classes ou objetos no sistema e o relacionamento entre eles. Um diagrama de classes contém entidades e relacionamentos.

Diagrama de objeto: É uma variação do diagrama de classes e utiliza quase à mesma notação. O diagrama de objetos é como se fosse o perfil do sistema em certo momento de sua execução.

Diagrama de estado: Um diagrama de estado mostra os possíveis estados de um objeto e as transações responsáveis pelas suas mudanças de estado.
Diagrama de seqüência: Consiste em um diagrama que tem o objetivo de mostrar como as mensagens entre os objetos são trocadas no decorrer do tempo para a realização de uma operação.

Diagrama de colaboração: A grande diferença entre um diagrama de colaboração e um de seqüência consiste no fato de que o tempo não é mais representado por linhas verticais, mas sim através de uma numeração.

Diagrama de atividade: O objetivo do diagrama de atividades é mostrar o fluxo de atividades em um único processo. O diagrama mostra como uma atividade depende uma da outra.

Diagrama de componente: Os diagramas de componentes representam, de forma estática, aspectos físicos do sistema sendo modelado. Os diagramas mostram um conjunto de componentes e seus relacionamentos.

Diagrama de execução: Exibe a arquitetura física do hardware e do software no sistema. Pode mostrar os atuais computadores e periféricos, juntamente com as conexões que eles estabelecem entre si e pode mostrar também os tipos de conexões entre esses computadores e periféricos.

2 - Faça um Diagrama de Use-case e um Diagrama de Classes de um sistema a sua escolha.
( Não sei se estão certos!) :P

Diagrama de Use-case - Biblioteca

Diagrama de Classes - Biblioteca

Obs. Ninguém vai conseguir entregar na data certa: Data de entrega: quarta, 24 setembro 2008, 22:55... =/

Programação III, PROVA ADIADA!

Olá a Todos!!!

Adiada prova de Programação III que seria realizada no dia 03 (Três) de Outubro.

Devido ao fato de alguns alunos do curso realizarem, no dia 03 (Três) e 04 (Quatro) de Outubro, a prova do ENEM (Exame Nacional do Ensino Médio) a prova de Programação III será adiada para o dia 10 (Dez) de Outubro. Porém, no dia 03 de Outubro haverá aula normal cujo assunto será a interligação do Visual Basic 6.0 com Banco de Dados (Introdução).

Atenciosamente
Felipe Antonio Cardoso
Representante da matéria de Programção III.

TAD Sequência com Arranjo Circular

Implemente o TAD sequência baseado em um arranjo variável usado de forma circular de maneira que as inserções no início e no fim da sequência executem em tempo constante.

Classes:

Posição:

public class Posicao
{
// indice no vetor
private int indice;

// referencia para o elemento
private Object elemento;

// construtor
public Posicao(int indice, Object elemento)
{
this.indice = indice;
this.elemento = elemento;
}

// retorna indice
public int index()
{
return indice;
}

// retorna elemento
public Object element()
{
return elemento;
}
}

Interador:

public class Iterador
{
// armazena elementos
private Posicao[] elementos;

// controla posicao no array
private int pos;

// construtor
public Iterador(Posicao[] elementos)
{
this.elementos = elementos;
pos = 0;
}

// retorna objeto corrente do array
public Posicao object()
{
return elementos[pos];
}

// verifica se tem proximo elemento
public boolean hasNext()
{
if(pos == elementos.length)
return false;

return true;
}

// move para o proximo elemento
public Posicao nextObject()
{
if(hasNext())
return elementos[pos++];

return null;
}

// volta ao começo
public void reset()
{
pos = 0;
}
}

Sequência:

public class Sequencia
{
// no. max. de elementos
private final int MAX_ELEMENTOS = 100;

// array de posicoes
private Posicao[] sequencia;

// variaveis de controle
private int first;
private int last;
private int N;

// construtor
public Sequencia()
{
sequencia = new Posicao[MAX_ELEMENTOS];
first = 0;
last = 0;
N = MAX_ELEMENTOS;
}

// insere elemento na primeira posicao
public void insertFirst(Object o)
{
// calcula possivel indice
int pos = first - 1;

// verifica se menor que limite
if(pos < 0)
pos = N - 1; // circular

// verifica se sequencia esta cheia
if(pos == last)
{
aumentar();
// chama funcao novamente apos aumentar
insertFirst(o);
}
else
{
// cria nova posicao
Posicao posicao = new Posicao(pos, o);

// insere na posicao candidata
sequencia[pos] = posicao;
// atualiza indice da primeira posicao
first = pos;
}
}

// insere elemento na ultima posicao
public void insertLast(Object o)
{
// cria nova posicao
Posicao posicao = new Posicao(last, o);

// insere na ultima posicao
sequencia[last] = posicao;

int pos;

// atualiza indice da ultima posicao
pos = (last + 1) % N;

// verifica se sequencia esta cheia
if(pos == first)
aumentar();
else
last = pos; // atualiza indice da ultima posicao
}

// duplica tamanho da sequencia
public void aumentar()
{
// cria nova sequencia com dobro do tamanho
Posicao[] temp = new Posicao[2*sequencia.length];

// contadores auxiliares
int pos = first;
int i = 0;

// copia todos os elementos para nova sequencia
while(pos != last)
{
temp[i] = new Posicao(i, sequencia[pos].element());
i++;
pos = (pos + 1) % N;
}

// atualiza indices
first = 0;
last = i;
sequencia = temp;
N = sequencia.length;
}

public int size()
{
return (N - first + last) % N;
}

public Iterador elements()
{
// cria array de elementos a serem retornados
Posicao[] elementos = new Posicao[size()];

// contadores auxiliares
int pos = first;
int i = 0;

// copia todos os elementos para array de saida
while(pos != last)
{
elementos[i] = sequencia[pos];
i++;
pos = (pos + 1) % N;
}

// cria iterador auxiliar e passa elementos
Iterador iterador = new Iterador(elementos);

// retorna iterador
return iterador;
}

// insere elemento antes de posicao p
public void insertBefore(Posicao p, Object o)
{
// indice para ultima posicao (valor corrente)
int pos = last;

// desloca todos os elementos depois de p
do
{
sequencia[pos] = new Posicao(pos, sequencia[pos-1].element());
pos--;

// verifica limite inferior
if(pos < 0)
pos = N-1;
}
while(pos > p.index());

// insere novo elemento
sequencia[pos] = new Posicao(pos, o);

// atualiza indice para ultimo elemento
last = (last + 1) % N;

// verifica necessidade de crescimento
if(size() == N)
aumentar();
}

}

Testa Sequência:

public class SequenciaApp
{
public static void main(String args[])
{
Posicao p = null;
Iterador it;
Sequencia seq = new Sequencia();

seq.insertLast("Bola");
seq.insertLast("Caixa");
seq.insertLast("Chave");
seq.insertFirst("Lapis");

it = seq.elements();
while(it.hasNext())
{
p = it.nextObject();
System.out.println((String)p.element());
}

seq.insertBefore(p, "Controle Remoto");
System.out.println();

it = seq.elements();
while(it.hasNext())
{
p = it.nextObject();
System.out.println((String)p.element());
}
}
}

Banco de Dados I - 05

UML - Parte I

Exercício V:
Responder as perguntas abaixo:

1)Quais as fases do desenvolvimento de sistemas utilizados na UML? Explique-os.

2)A UML é composta por quais partes?

3) Quantas visões, diagramas e modelos de elementos são utilizados nas fases de análise de requisitos, análise e design?

4) Quais as visões que compõem um sistema? Explique 2 deles.

5)Quais são os diagramas utilizados pela UML? Explique 2 deles.
Possível Resolução

Banco de Dados I - 04

Exercício IV-a:
Responda as questões abaixo:

1) Quem são os criadores do UML e quais metodologias cada um deles criou?

2) Quais os conceitos que Coad, Yourdon, Pressman apresentaram?

3) O que diz as metodologias de Booch, OMT, OOSE e Objectory?

4) Quais os principais objetivos da UML?

5) A UML pode ser utilizada por vários tipos de sistemas, quais são?

6) Utilizando a Internet, cite 4 softwares de mercado para modelagem de UML?
Possível Resolução

Exercícios Programação III - 03 e 04

Execício 03 - Download

Crie um gráfico igual a figura abaixo, onde a equação da reta da linha verde é y=x*3 e a equação da reta da linha vermelha é y=x^2:

Execício 04 - Download

Calcular a equação do 2º grau e plotar o gráfico da função.

Banco de Dados I - 03

História dos Bancos de Dados
UML - Introdução

Exercício IV:
1) Quais as diferenças entre os Modelos de Banco de Dados Hierárquico, Redes, Relacional e OO ?

2) Olhando as regras de Codd, diga qual delas é a mais importante e por quê?

3) Olhando a História do Banco de Dados, o que podemos esperar para o futuro?

4) Quais os Bancos de Dados utilizados no Brasil e no Mundo. Colocar em ordem de utilização.
Possível Resolução

Engenharia de Software I - Exercícios

Capítulo I

1 – A razão é que os sistemas estão cada vez mais complexos e o volume de dados cada vez maior e com freqüentes modificações, com isso dificultando a tomada de decisões através dos dados recolhidos sem um sistema para auxiliar e navegar entre esses dados.
2 - SUMIU! :(
3 – Programas de computador, procedimentos e documentação possivelmente associados e dados relativos ao funcionamento de um sistema computador.
4 - A aplicação de uma sistemática e disciplinada, quantificável para o desenvolvimento, operação e manutenção de software, ou seja, a aplicação da engenharia de software.
5 - Um padrão planejado e sistemático de todas as ações necessárias para fornecer confiança adequada ao software que está em conformidade com os requisitos técnicos estabelecidos. Um conjunto de atividades destinadas a avaliar o processo pelo qual os produtos são desenvolvidos ou fabricados.
6 - O conjunto completo de programas de computador, procedimentos e documentação possivelmente associados e dados designados para entrega a um usuário.
7 – Projeto é uma concepção mental ou idéia de um produto, geralmente representada por modelos. É a representação de um sistema de software criada para facilitar análise,
planejamento e tomada de decisão.
8 - Por Processo entende-se uma série de ações ou passos, planejados cuidadosamente, a serem seguidos pelos desenvolvedores de software, sistematizando, disciplinando e
permitindo gerenciar o desenvolvimento de sistemas computadorizados.
9 – Atividades Executivas são atividades executadas nas fases:
Fase Requisitos do Usuário – RU, Fase Requisitos de Software – RS, Fase Projeto Arquitetural – PA, Fase Projeto Detalhado e Produção – PD, Fase Transferência – TR, Fase Operações e Manutenção – OM.
10 – Atividades Gerenciais são atividades como:
Gerência de Projeto, Gerência de Configuração, Gerência de Verificação e Validação e Gerência de Qualidade.

Capítulo II

1 -
* Fase Requisitos Do Usuario - RU;
* Fase Requisitos Do Software - RS;
* Fase Projeto Arquitetural - PA;
* Fase Projeto Detalhado E Produção - PD;
* Fase Projeto Transferencia - TR;
* Fase Operações E Manutenção - OM;
2 -
* DRU - Documento Requisitos Do Usuário;
* DRS - Documento Requisitos Do Software;
* DRA - Documento Projeto Arquitetural;
* DPD - Documento Projeto Detalhado;
* MUS - Manual Do Usuário;
* DTR - Documento De Transferencia;
* DHP - Documento Historico Do Projeto
3 - Começa quando o DRU é liberado pelo usario para uma revisao formal e termina quando o produto é descartado.
4 - Começa na RS (definição dos requisitos de software) termina no PD (projeto detalhado)
5 - Para os usuários definirem o que eles desejam e para os desenvolvedores definirem o que eles entenderam que o usuário deseja.
6 - Uma abordagem em cascata é adequada quando existe um projeto simples com fases seqüencial, o que torna essa abordagem simplificada e popular, requisitos estáveis e de alta qualidade, a duração do projeto seja de no máximo 2 anos (ou 4000 horas) e permite retomar etapas para correção.
7 - Abordagem incremental é utilizada quando a liberação se faz necessário para estar acordado com os requisitos, fazer integração com sistema já existente ou parte do sistema e oferecer uma prévia que o software será suficiente para resolver o problema.
8 - Abordagem evolucionária é uma série de projetos menores, onde cada projeto aproveita a experiência da liberação anterior e deve ser usada quando requisitos do usuário são de difícil implementação, pois podem depender de tecnologias futuras ou não são totalmente conhecidos, alguns requisitos podem atrasar a liberação do software, portanto necessita um acompanhamento evolucionário para a integração.
9 - Abordagem em cascata é utilizada para o desenvolvimento de software em curto prazo, quando são necessárias apenas pequenas correções e aperfeiçoamento, essas que são feitas na fase de Operação e Manutenção (OP).
10 - A execução simultânea ocorre quando a elaboração do projeto está em andamento e novos requisitos de software são apresentados, resultando em um maior tempo de desenvolvimento e necessidade de uma nova elaboração do projeto. O recomendado para esse projeto seria abordado o Método Cascata com Liberação Incremental.

Capítulo III

1 – O responsável pelo RU é o próprio Usuário junto ao desenvolvedor, onde ele especifica o que o seu sistema deve fazer.
2 – É aceitável desde que o desenvolvedor faça esse documento junto com o usuário e com a aprovação do mesmo.
3 – Os tipos são: Capacidade, Define o que o software deve fazer; Restritivos, Coloca restrições de como o software deve ser construído e operado.
4- Os requisitos do usuário se estruturam da seguinte forma:
– Capturar os Requisitos do Usuário;
– Determinar o ambiente operacional;
– Especificar os Requisitos do Usuário;
– Escrever o Plano dos Testes de Aceitação;
– Escrever os planos para a fase Requisitos de Software;
– Rever os Requisitos do Usuário.
5 – a) O usuário deve ser capaz de gerar relatórios através do software, não o software por si só gerar um relatório.
b) A especificação em relação à boa interface com o usuário está muito genérica, irá depender do ambiente operacional do software.
c) Falhas não é um requisito de usuário, nenhum usuário irá pedir que seu software tenha uma média de falha em 3 horas.
d) Está correto.
e) Este argumento não é um requisito de usuário, é um requisito de software.
6- Cada requisito de usuário deve conter pelo menos as seguintes características: Identificador, Necessidade, Prioridade, Fonte e Estabilidade.
7 – As interfaces para sistemas externos devem estar descritas nas características de restrição no requisito de usuário.
8 – Um sistema com em média 700 requisitos é considerado um sistema de porte Médio enquanto deveria ser desenvolvido com até 20 pessoas.ano, com apenas 2 pessoas.ano pode ser desenvolvido um software de porte pequeno de até 100 requisitos.
9 – O objetivo é sempre mostrar a opção mais adequada para o usuário, mas se o mesmo insistir em utilizar a interface escolhida por ele, assim deve ser feito.
10 – Não se deve colocar especificações desse tipo em um documento de requisitos de usuário, deve ser colocado especificações com uma linguagem menos técnica.

Algoritmos e Estruturas de Dados I - Será?

interface estruturaLinear {
// verifica se a estrutura tem elementos
public boolean estaVazia();
// devolve a quantidade de elementos da estrutura
public int tamanho();
// insere um elemento no início da estrutura
public void inserir(Object p0);
// insere um elemento no fim da estrutura
public void inserirCauda(Object p0);
// remove um elemento do início da estrutura
public Object remover();
// remove um elemento do fim da estrutura
public Object removerCauda();
}

/****************/

public class ArrayCircularList implements estruturaLinear {
protected Object[] array;
protected int start,end,number;

public void pArrayList(int maxsize){
array = new Object[maxsize];
start = end = number = 0;
}
public boolean estaVazia(){
return number == 0;
}
public boolean isFull(){
return number >= array.length;
}
public int tamanho(){
return number;
}
public void inserir(Object o){
if(number < array.length){
array[start = (++start % array.length)] = o;
number++;
}
}
public void inserirCauda (Object o){
if(number < array.length){
array[end] = o;
end = (--end + array.length) % array.length;
number++;
}
}
public Object remover(){
if(estaVazia())
return null;
number--;
int i = start;
start = (--start + array.length) % array.length;
return array[i];
}
public Object removerCauda(){
if(estaVazia())
return null;
number--;
return array[end = (++end % array.length)];
}
}

WAR?

Algoritmos e Estruturas de Dados I - Aula 02

Apostila 03 : Vetores, Listas e Sequências - Download
Apostila 04 : Árvores - Download
Apostila 05 : Filas de Prioridade - Download

Atividades terça, 25 de agosto de 2009:

FIFO Ganho (ou Perda) de Capital

Quando um lote de ações de uma companhia é vendido, o ganho de capital (ou, às vezes, a perda) é a diferença entre o preço de venda do lote e o preço originalmente pago por ele. Essa regra é fácil de entender para um único lote, mas se vendermos múltiplos lotes comprados em tempos diferentes temos de identificar os lotes sendo vendidos. Um método usado para identificar que lotes são vendidos é usar uma estrutura que suporte o protocolo FIFO, na qual os lotes vendidos são aqueles que temos há mais tempo (este é o método usado em vários softwares de finanças pessoais). Por exemplo, suponha que compramos 100 lotes a $20 cada no dia 1, 20 lotes a $24 no dia 2, 200 lotes a $36 no dia 3 e vendemos 150 lotes no dia 4 a $30 cada. Aplicando o protocolo FIFO, significa que dos 150 lotes vendidos, 100 foram comprados no dia 1, 20 foram comprados no dia 2 e 30 foram comprados no dia 3. O ganho de capital neste caso seria 100.10+20.6+30.(-6), ou $940.

Escreva um programa que recebe como entrada uma sequência de transações da forma

• compre x lotes a y cada
  ou
• venda x lotes a y cada

assumindo que as transações ocorrem em dias consecutivos e que os valores x e y são inteiros. Dada esta sequência de entradas, a saída deve ser o ganho total (ou perda) de capital para a sequência completa, usando o protocolo FIFO para identificar os lotes.

Baixar Possível Resolução

Para baixar o JCreator clique aqui.

Banco de Dados I - 02

Engenharia da Informação
Engenharia da Informação - Leitura

Exercício I:
Pesquisa em Laboratório
Pesquise os Softwares de Banco de Dados atuais (no mínimo 8).
Nome:
Empresa:
Plataforma:
Duas empresas que utilizam:
Notícia atual:
% de Mercado:
Colocar a Bibliografia (Sites com data e hora de acesso)
Possível Resolução

Exercício II:
Considerando o assunto exposto, pesquise e responda:

1) O SI segundo o Suporte a Decisões é dividido em quais tipos? Explique-os e dê exemplos.
2) Quais as diferenças entre os SI: Pessoal, Gurpal ou Departamental, Organizacional e Interorganizacional.
3) Explique os SI Informatizados e Automatizados. Dê exemplos.
4) A Empresa que você trabalha tem quais tipos de Sistema de Informação? Explique suas escolhas.
Possível Resolução

Exercício III:
Imaginando que você é o Diretor de uma empresa dê sua opinião sobre estas frases abaixo (recebidas de seus subordinados):

1. Queixas:
a. “A construção de sistemas toma muito tempo e o custo é muito alto”.
b. “As dificuldades de manutenção são enormes”.
c. “Os administradores não conseguem obter as informações do computador quando são necessárias”.
d. “Os dados são redundantes e o acesso a estes é caótico”.
e. “Muitos programas são um emaranhado frágil de código”.
2. “A informática é uma ferramenta crítica na competição do mundo dos negócios, torna-se cada vez mais, fundamental desenvolver aplicações rapidamente e alterá-las também rapidamente”.
3. “É preciso construir, em pouco tempo, a um baixo custo, aplicações que são altamente complexas, de alta qualidade, e que atendam totalmente as necessidades dos usuários finais".
Possível Resolução