Para aquelas pessoas que precisam de partituras personalizadas, temos este site:
>> http://www.blanksheetmusic.net
Neste website podemos criar vários tipos de partituras(guitarra, violão,tablatura,piano,baixo).
O mais legal, se você está no nivel de mais de um instrumento nas composições, posui uma opção(format staves per set) aonde pode-se dizer quantos instrumentos estão tocando no momento.
Ferramenta porreta!!
A noção popular de que as pessoas que usam óculos são nerds ou geeks não corresponde com os resultados de um novo estudo…
Um novo estudo australiano olhou para a associação entre a introversão (pessoas tímidas ou ensimesmadas) e a miopia, mal que afeta 20% dos estado-unidenses.
se ela fosse uma nerdzinha assim até eu me chamava de NERD…
Por isso que todos amam o Brasil…
Uma vez eu encontrei uma cela dessas… mas não sabia que banco era uma prisão…
ahh agora entendi…
banco deve ser a prisão do meu dinheiro.
tudo se encaixa agora (yeah!)
Pow assim até eu queria ser preso…
Porque quem te dar flores não tem como fazer o mal.
E assim gera a certeza de ser livre denovo.
Preso assim só por aqui mesmo (yeah!).
Brasil adorado Brasil
Quando vi isto me caguei de rir… XP
Chuck Norris no mundo da informática.
1 - Chuck Norris é o controlador de domínio;
2 - Chuck Norris tem o IP 0.0.0.0 e a porta padrão é 0;
3 - Chuck Norris dá o comando ping 256.256.256.256 e consegue resposta;
4 - Chuck Norris consegue invadir QUALQUER banco com seu palmtop - desligado!;
5 - Chuck Norris usa o Windows XP no seu MAC;
6 - O erro 404 nunca apareceu para Chuck Norris;
7 - Chuck Norris é fluente em linguagem de máquina;
8 - O processador do computador do Chuck Norris não tem cooler;
9 - Chuck Norris lê e grava DVD no drive de disquete;
10 - Chuck Norris é o dono da internet;
11 - Chuck Norris consegue inserir imagens no Notepad;
12 - A impressora matricial do Chuck Norris imprime fotos… coloridas… a uma página por segundo(frente e verso);
13 - Todos os programas pedem desculpas para Chuck Norris antes de mostrar um erro;
14 - Chuck Norris usa o Notepad como banco de dados;
15 - Chuck Norris deu um roundhouse kick no modem de 14400 kbps e agora ele tem ADSL;
16 - Chuck Norris extrai arquivos compactados apenas com o olhar;
17 - Chuck Norris tem um processador AMD em uma placa-mãe Intel;
18 - Chuck Norris nunca recebeu um SPAM;
Postando um exemplo de arvores aonde criamos 2 arvores com o intúito de auxiliar a prova.
Primeiro temos uma forma de revisarmos como fazer o script de criar uma arvore específica.
Segundo caso é o de criar uma arvore defeituosa e em seguida deixar-la perfeita (seria pegar os espaços em branco, pedaços aonde não possuem folhas e adicionar aonde falta).
#include <stdio.h>
#include <stdlib.h>
#include “arvore.h”
int main()
{
int maior=NULL;
int menor=NULL;
arvore auxDaArvore;
arvore novaArvore;
system(”cls”);
novaArvore = inicializa();
auxDaArvore = novaArvore ;
// criando a raiz da árvore
novaArvore = constroi(1);
// criando 2 folhas esquerda e direita
criafilhoesquerdo(novaArvore,2);
criafilhodireito(novaArvore,3);
//vamos andar um nível(esquerda) para baixo da árvore, para andarmos na árvore usamos o Auxiliar da Arvore(auxDaArvore)
// local aonde vai receber a posicao = função do lado a se locomover ( posicao atual );
auxDaArvore = filhoesq(novaArvore);
// agora que nos locomovemos para esqueda e um nivel a mais podemos criar os outros elementos (4,5)
criafilhoesquerdo(auxDaArvore,4);
criafilhodireito(auxDaArvore,5);
//agora que acabamos de locomovermos pelo lado esquerdo da árvore temos que voltar a raiz para podermos
//ir para o lado direito da árvore
auxDaArvore = novaArvore;
//temos que locomovermos uma posicao para continuar a adição de elementos pois já existe o elemento da
//direita da arvore(folha direita da raiz)
auxDaArvore=filhodir(novaArvore);
//agora estamos prontos para criar os filhos esquerdo e direito (7,6)
criafilhoesquerdo(auxDaArvore,7);
criafilhodireito(auxDaArvore,6);
//agora vamos imprimir em todos os tipos, informaremos como argumento a árvore (novaArvore)
printf(”Imprimindo em PREORDEM \n”);
preordem(novaArvore);
printf(”\n\nImprimindo em INORDEM\n”);
inordem(novaArvore);
printf(”\n\nImprimindo em POSORDEM\n”);
posordem(novaArvore);
printf(”\n\n\n\n”);
verificaSeMaiorOuMenor(novaArvore,&maior,&menor);
printf(”Item de maior valor : %d \n”,maior);
printf(”Item de menor valor : %d \n”,menor);
printf(”\n\n\n\n\n\n\n\n\n”);
printf(”Criando esta arvore \n”
“ 3 \n”
“ / \\ \n”
“ 5 6 \n”
“ / \\ / \\ \n”
“ 11 2 9 21 \n”
“ \\ \\ \n”
“ 40 22 \n”);
arvore arv;
arvore aux;
arv = inicializa();
arv = constroi(3);
aux = arv;
criafilhoesquerdo(aux,5);
criafilhodireito(aux,6);
aux = filhoesq(arv);
criafilhoesquerdo(aux,11);
criafilhodireito(aux,2);
aux = filhodir(aux);
criafilhodireito(aux,40);
aux = filhodir(arv);
criafilhoesquerdo(aux,9);
criafilhodireito(aux,21);
aux = filhodir(aux);
criafilhodireito(aux,22);
printf(”Imprimindo em PREORDEM \n”);
preordem(arv);
printf(”\n\nImprimindo em INORDEM\n”);
inordem(arv);
printf(”\n\nImprimindo em POSORDEM\n”);
posordem(arv);
printf(”\n\n\n\n”);
verificaSeMaiorOuMenor(arv,&maior,&menor);
printf(”Item de maior valor : %d \n”,maior);
printf(”Item de menor valor : %d \n”,menor);
printf( “\nDepois tornando ela perfeita\n”
“ 3 \n”
“ / \\ \n”
“ 5 6 \n”
“ / \\ / \\ \n”
“ 11 2 9 21 \n”
“ / \\ / \\ / \\ / \\ \n”
“ 12 13 39 40 10 12 23 22 \n”);
aux = filhoesq(arv);
aux = filhoesq(aux);
criafilhoesquerdo(aux,12);
criafilhodireito(aux,13);
aux = filhoesq(arv);
aux = filhodir(aux);
criafilhoesquerdo(aux,39);
aux = filhodir(arv);
aux = filhoesq(aux);
criafilhoesquerdo(aux,10);
criafilhodireito(aux,12);
aux=filhodir(arv);
aux =filhodir(aux);
criafilhoesquerdo(aux,23);
printf(”Imprimindo em PREORDEM \n”);
preordem(arv);
printf(”\n\nImprimindo em INORDEM\n”);
inordem(arv);
printf(”\n\nImprimindo em POSORDEM\n”);
posordem(arv);
printf(”\n\n\n\n”);
verificaSeMaiorOuMenor(arv,&maior,&menor);
printf(”Item de maior valor : %d \n”,maior);
printf(”Item de menor valor : %d \n”,menor);
return 0;
}
#include “arvore.h”
noarv* inicializa(void) {
return NULL;
}
//Verificar se a árvore está vazia
int vazia(arvore arv) {
return (arv == NULL);
}
//Criação de um nó da árvore
/* cria um novo no do tipo arvore e retorna um ponteiro para a arvore criada */
noarv* constroi(int info){
noarv *novo;
if ((novo = aloca()) == NULL)
return NULL;
novo->dado = info;
novo->esq = NULL;
novo->dir = NULL;
return(novo);
}
//Criar filho esquerdo
/* Verifica se a arvore nao esta nula ou se se tem filho esquerdo.
Caso nao tenha filho esquerdo, sera construido um novo no a partir da
arvore passada como parametro */
int criafilhoesquerdo(arvore arv, int info){
noarv *novo;
if (arv == NULL)
return ERRO;
else if (arv->esq != NULL)
return ERRO;
else {
novo = constroi(info);
arv->esq = novo;
}
return OK;
}
//Alocar um nodo para a árvore
noarv* aloca(void) {
return ( (noarv*) malloc(sizeof(noarv)));
}
//Criar filho direito
/* Verifica se a arvore nao esta nula ou se se tem filho direito. Caso nao
tenha filho direito, sera construido um novo no a partir da arvore passada
como parametro */
int criafilhodireito(arvore arv, int info){
noarv *novo;
if (arv == NULL)
return ERRO;
else if (arv->dir != NULL)
return ERRO;
else {
novo = constroi(info);
arv->dir = novo;
}
return OK;
}
//Ir para o filho esquerdo
/* Caminha para o filho esquerdo da arvore passada como parametro, retornando
o endereco deste no’ */
noarv* filhoesq(arvore arv) {
if (vazia(arv))
return NULL;
else
return ( arv->esq );
}
//Ir para o filho direito de uma árvore
/* Caminha para o filho direito da arvore passada como parametro, retornando
o endereco deste no’ */
noarv* filhodir(arvore arv) {
if (vazia(arv))
return NULL;
else
return ( arv->dir );
}
//Pesquisar um nodo
int busca( arvore arv, int info ) {
if (vazia(arv))
return ERRO; // Nao encontrou o nodo
if ( info == arv->dado)
return OK;
else if (busca(arv->esq, info))
return OK;
else
return busca(arv->dir, info);
}
//Imprimir a árvore em pré-ordem
/* Esta procedure deve percorrer recursivamente a arvore, visitando todos
os nos e imprimindo sua informação, segundo o percurso em pré-ordem */
void preordem(arvore arv) {
if (!vazia(arv)) {
printf(”%d\t”, arv->dado);
preordem(arv->esq);
preordem(arv->dir);
}
}
//Imprimir a árvore em in-ordem
/* Esta procedure deve percorrer recursivamente a arvore, visitando todos
os nos e imprimindo sua informação, segundo o percurso em in-ordem */
void inordem(arvore arv) {
if (!vazia(arv)) {
inordem(arv->esq);
printf(”%d\t”, arv->dado);
inordem(arv->dir);
}
}
//Imprimir a árvore em pós-ordem
/* Esta procedure deve percorrer recursivamente a arvore, visitando todos
os nos e imprimindo sua informação, segundo o percurso em pós-ordem */
void posordem(arvore arv) {
if (!vazia(arv)) {
posordem(arv->esq);
posordem(arv->dir);
printf(”%d\t”, arv->dado);
}
}
int buscarMaior(arvore arv , int *maior){
if (vazia(arv)) return 0;
if (maior ==NULL)
maior = arv->dado;
if (*maior < arv->dado)
*maior = arv->dado;
buscarMaior(arv->esq,maior);
buscarMaior(arv->dir,maior);
return 1;
}
int verificaSeMaiorOuMenor(arvore novaArvore,int *maior,int *menor){
if(vazia(novaArvore))
return 0;
if (*maior == NULL && *menor==NULL){
*maior = *menor = novaArvore ->dado;
}
if(novaArvore->dado > *maior){
*maior= novaArvore->dado;
}else{
if(novaArvore->dado < *menor){
*menor= novaArvore->dado;
}
}
verificaSeMaiorOuMenor(novaArvore->esq, maior,menor);
verificaSeMaiorOuMenor(novaArvore->dir,maior,menor);
return 1;
}
#include<malloc.h>
#include<stdio.h>
#define ERRO 0
#define OK 1
typedef struct stnoarvore {
int dado;
struct stnoarvore *esq;
struct stnoarvore *dir;
}noarv;
typedef noarv* arvore;
noarv* inicializa(void);
int vazia(arvore);
noarv* constroi(int);
int criafilhoesquerdo(arvore,int);
noarv* aloca(void);
int criafilhodireito(arvore,int);
noarv* filhoesq(arvore);
noarv* filhodir(arvore);
int busca(arvore,int);
void preordem(arvore);
void inordem(arvore);
void posordem(arvore);
int verificaSeMaiorOuMenor(arvore,int *,int *);
int buscarMaior(arvore,int*);
Trabalhos de FSI
E-health
E-Learning
BI
EDI
E-GOVERNMENT
Ética
Segurança
SCM
Seria a integração dos participantes do canal de distribuição com propósito de interligar as diversas unidades organizacionais e os membros do canal, desde o consumidor final até o fornecedor de matérias primas.
Seria um conjunto de processos que interligam a cadeia de suprimentos que unidos com o marketing, pesquisa e desenvolvimento, fabricação e logística geram uma redução de custos.
ECR (utilizado na atualidade)
JIT (JUST IN TIME)
QR (QUICK RESPONSE)
ECR – QR – JIT
JIT – QR
MARKETING INTEGRADO
SELF-SERVICE
Um canal de distribuição podem ser classificados em 2 grupos: membros primários e membros especializados.
Membros primários
Membros secundários
Processo de desverticalização
Também olhem o link do professor da UFMG passado em um post anterior.
//criar um nó, seria criar o primeiro elemento da lista
// mais na frente vamos ter TlistaEnc l e TlistaEnc *l
// Vamos usar o l* quando queremos manipular um dado(inserir, remover…), pois estamos pegando o endereço dele.
// Vamos usar o l quando queremos queremos pegar uma cópia do valor e quem vai ser manipulado é a cópia.
int instrucoes(void){
int i;
system(”cls”);
printf(”Editor de Listas\n”
“————————\n”
” (0) Criar Lista\n”
” (1) Exibir Lista\n”
” (2) Inserir\n”
” (3) Remover\n”
” (4) Exibir Elemento\n”
” (5) Exibir Posicao\n”
” (6) Esvaziar Lista\n”
” (7) Sair\n\n “
” Opcao -> “);
scanf(”%d%*c”,&i);
return i;
}
int verificaSePossivel(int x){
return (x==1); // se for == 1 ele retorna verdadeiro != 0, senão ele retorna 0.
}
//como estamos criando o nó precisamos do endereço dele, então colocamos o l(sem asterisco), pois vamos alocar um espaço na memória.
/****************************************************************************
Criamos esta função para conseguir criar um nó para manipularmos encadeamente
1)Enviamos como argumento uma lista (TlistaEnc l), e não o seu endereço,
isto é apenas o molde.
2)logo em seguida com o molde podemos alocar dinamicamente a memória
necessária para o nó
****************************************************************************/
int criarNo(TlistaEnc *l){
if(l=(no*)malloc(sizeof(no)!=0)) return 1;
return 0;
}
/****************************************************************************
Criamos esta função para conseguirmos Criar um lista
1)Para criar uma lista precisamos aponta-la para null
2)Informamos o endereço de memória de uma lista “TlistaEnc *l”
3)Como temos que mudar o valor da variável da lista temos que usar o * antes
da variável para modificar o valor no endereço(TlistaEnc *l) fornecido
para o valor null, com o intuito de criar a lista.
****************************************************************************/
void criarLista(TlistaEnc *l){
//preparando o elemento para adicionar = colocar a lista apontando para null
*l=null;
}
/****************************************************************************
Criamos esta função para conseguir verificar se a lista está Vazia
1)Ela verifica se l==null, se for retorna 1 se não for retorna 0.
2)E a função retorna o valor retornado da comparação l==null(1 ou 0)
****************************************************************************/
int listaVazia(TlistaEnc l){
return(l==null); /* forma não compacta if(l==null){ return 1; } return 0; */
}
/****************************************************************************
Criamos esta função para conseguirmos o tamanho da estrutura.
1)insere na função uma variavel com o endereço da lista
2)É verificado se no inicio aponta para nulo, se for
retorna o tamanho 0, pois a lsita está vazia
3)Retorna o tamanho, qualquer que for, se ela estiver vazia
retorna 0 se possuir valores retorna o valor
***************************************************************************/
int tamanhoDaLista(TlistaEnc *l){
int tamanho =0;
while(l!=null){
l=l->prox;
tamanho+;
}
return tamanho;
}
/****************************************************************************
Criamos esta função para conseguirmos retornar o valor na posição
solicitada
1)Informamos uma lista sem o “*”, pois não vamos modificar o seu valor
apenas queremos verificar seua existência, então iremos ler os dados.
2)Informamos a posição desejada a encontrar o dado.
3)Enviamos o endereço de uma variável para que possamos retornar dentro
dela o valor a ser amostrado. Praticamente copiamos para o endereço
dessa variável o valor do dado nesta posição.
4)É verificado se a posição é válida: posição não pode ser menor que 0
e não pode ser maior que o tamanho da lista, pois se é maior que a
lista não existe!(ou existe lixo de memória!).
5)Também é verificado se a lista não está vazia passando a função
listaVazia( umaLista ),criada acima para verificação.
6)Processo de busca se dá quando verificamos se ela não é nula e se
a posicaoAtual de busca é menor que a posição solicitada para busca
7)Enquanto ocorre o processo de busca sempre enquanto for diferente de
nulo ou posicaoAtual menor que posição ele captura o valor do próximo
e executa a incrementação da posição atual(posicaoAtual++).
8)Por fim ele vai inserir o valor de lista->dado naa variável dadoFornecido
*****************************************************************************/
int elementoNaPosicao(TlistaEnc l, int posicao, int *dadoFornecido){
int posicaoAtual=1;
if(posicao<=0 || listaVazia(l) || posicao>tamanhoDaLista(l) ) return 0; //return 0 = erro, não pode…
while( (l!=null) && (posicaoAtual<posicao) {
l = l->prox;
posicaoAtual++;
}
*dadoFornecido = l->dado;
return 1;
}
/****************************************************************************
Criamos esta função para conseguir procurar a posicao de um elemento(um dado)
fornecido. comparando-os(dado fornecido com os dados da lista).
1)Informamos a lista(TlistaEnc l), como só informamos e não vamos modificar
enviamos apenas o l sem o simbolo “*” e um dado para comparação(int dado).
2)Comerçamos com a posicao=1, pois é a primeira posição a ser pesquizada,
lembre que posição é diferente de indice!!!
3)Comparamos se a lista é vazia, que entra na condição de invalidez, não
possui este item informado na lista,pois a lista não possui nenhum item
ai tem que retornar 0 = não possui este item na lista!!!!
4)O loop é feito da seguinte maneira, enquanto a lista for diferente
de nulo(isto significa “Enquanto a lista existir”).
5)A comparação é feita da seguinte maneira, se o dado for diferente do dado
da lista capture o endereço da proximo nó(l=l->prox) e incremente 1 na
posicao, pois estamos agora em outra posição da lista. Se encontrarmos
significa que o dado fornecido não é diferente do dado atual
(dado==l->dado), ele entra no else agora e retorna sua posição. Caso não
encontre ele não entra no else, acaba a lista e ativa a única condição do
while(funciona até chegar no final da lista) e acaba retornando 0.
****************************************************************************/
int posicaoDoElemento(TlistaEnc l , int dado){
int posicao=1;
if(listaVazia(l)) return 0;
while(l!=null){
if (dado!=l->dado){
l=l->prox;
posicao++;
}
else return posicao;
}
return 0; // o retorno 0 tanto pode ser pq a lista está vazia, quanto que não existe na lista, pois se ela está
// vazia não existe na lista, não existe nada.
}
/****************************************************************************
Criamos essa função para poder inserirmos um dado (int dado) em uma estrutura
possui 3 condições :
–> (1a) Inserir em uma lista vazia.
–> (2a) Inserir na primeira posição.
–> (3a) Inserir em qualquer posição.
–>Para todas as as condições precisamos:
enviar um ponteiro da lista (TlistaEnc *l), uma posição de entrada de dado
(int posicao) e o dado propiarmente dito (int dado).
um no devemos criar(no *novo), e um tipo lista(TlistaEnc *l), com “*”, pois
vamos adicionar(manipular) um valor. E por fim um contador aonde iremos
ter a posicao atual em procura na lista.
1)Inserir em uma lista vazia :
1.1)Precisamos verificar se ela está vazia, se ela estiver podemos continuar
1.2)Verificamos se a posicao é menor e igul a 0, pois não existe.
1.3)Obedecendo essas regras acima podemos agora adicionar o dado.
1.4)Primeiro adicionamos ao no auxiliar em sua parte de dado o dado enviado
(int dado)
1.5)Depois setamos o valor de prox(ponteiro da estrutura) em null, para que
ele possa depois adicionar mais valores a lista.
1.6)Agora ao conteudo(*nome da lista) da lista(TlistaEnc *l) iremos adicionar
o novo nó criado para isto.
2)Inserir Na Primeira Posição
2.1)Verificamos se a posição é igual a 1, pois é a condição.
2.2)Alocamos memória para o no.
2.3)Tendo memória livre, podemos continuar, agora capiturando o dado para
o espaço reservado a dados no no auxiliar
2.4)Apontamos agora o no auxiliar para quem a lista aponta(*l)
//obs. se quiserssemos apontar para a lista seria l, mas como queremos
//apontar para quem ela aponta colocamos o *l.
2.5)agora temos que colocar a lista para apontar para o no auxiliar, jun-
tando os elementos e ordenando a lista.
3)Inserir em qualquer Posição
3.1)Criamos uma lista auxiliar para usar agora nessa opção, primeiramente
colocamos ela para apontar para quem a lista enviada(TlistaEnc l) aponta
3.2)Depois utilizamos o while para percorrer a lista auxiliar com intuito de
chegar na posição anterior(contador<posicao) a qual queremos adicionar
o elemento, e verificamos se a auxiliar não é null, pois teria acabado
os elementos da lista. A variável contador serve apénas para chegar uma
posição antes da desejada.
3.3)Alocamos memória para o nó auxiliar(no* novo).
3.4)Jogamos o dado fornecido(int dado) para a posição de dados do
nó auxiliar (novo->dado).
3.5)Mandamos este nó auxiliar apontar para quem a lista auxiliar aponta
>>queremos adicionar no indice 3
>>lista->n1->n2->n3->n4
>>listaAux=>n2->n3->n4 lista auxiliar se torna n2 ela tem o dado e
>> controle de quem aponta
//noAux=>listaAux=>n2->n3->n4 === noAux->n3->n4
3.6)Agora para finalizar apotamos a lista Auxiliar(TlistaEnc aux) para o no
auxiliar(no * novo), selando a lista.vizualmente é assim :
// lista=>n1->( listaAux == n2 )->n3->n4
noAux-|
// lista=>n1->( listaAux == n2 ) (se desfaz pois agora listaAux aponta para noAux) n3->n4
|—————————————————–> noAux-|
>>terminando assim :
// lista=>n1->( listaAux == n2 ) n3->n4
|—-> noAux-|
>> Lista aponta sempre para n1, lista auxiliar se transforma em n2
>> (posição antecedente a que queremos inserir), em seguida o nó Auxiliar
>> que aponta para n3 e n3 aponta para n4, terminando a lsita encadeada.
>> lista=>n1->( listaAux == n2 ) —>noAux–> n3->n4
****************************************************************************/
int inserirElemento(TlistaEnc *l, int posicao, int dado){
no * novo;
TlistaEnc aux;
int contador=1;
if(listaVazia(*l)){
if ( (posicao!=1) || novo=(no*)malloc(sizeof(no))==null){ return 0; }
else {
novo->dado = dado;
novo->prox ==null;
*l=novo;
return 1;
}
}
if(posicao==1){
if(novo=(no*)malloc(sizeof(no))==null){ return 0; }
else {
novo->dado = dado;
novo->prox = *l;
*l = novo;
return 1;
}
}
// preciso só chegar na posição anterior &&(contador<posicao)
aux = *l; // diz que o auxiliar é igual a lista (uma cópia)
while( (aux!=null) &&(contador<posicao) ){
aux = aux->prox;
contador++;
}
if(novo = (no*)malloc(sizeof(no))==null)
return 0;
else{
novo->dado = dado;
novo->prox = aux->prox;
aux->prox = novo;
}
}
/****************************************************************************
Criamos essa função para poder remover um dado (int *dado) em uma estrutura
colocamos o * em dado pois queremos devolver este dado para que ele não seja
perdido, apenas removido, podemos querer manipula-lo mais a frente.
Criamos uma list auxiliar(TlistaEnc aux) e um nó(no * anterior)
criamos um contador para controlar a posição certa para a remoção
1)Primeiro verificamos se a lista não está vazia,pois em lista vazia não
possui membros a serem deletados.
2)colocamos nossa lista auxiliar(TlistaEnc aux) apontar para quem nossa
lista enviada aponta(TlistaEnc *l).
3)Percorremos a lista enviada com a lista auxiliar, e com o um nó chamado
anterior(no *anterior), capituramos a variavel anterior e com ela podemos
criar o elo com outros termos da lista, e em seguida a lista auxiliar anda
para a posição de remorção.
4)Verificamos se lista Auxiliar não é nula
5)Jogamos a nossa variavel dado o valor a ser removido(aux->dado)
6)Mas se a posição de remorção for 1 só precisamos pedir para a lista apontar
para a lista auxiliar proxima posição, removendo o da 1a posição.
7)Removendo o auxiliar da memória damos um free(auxiliar).
****************************************************************************/
int removerElemento(TlistaEnc *l, int posicao, int *dado){
TlistaEnc aux;
no * anterior;
int contador=1;
if (listaVazia(*l)||posicao<0) return 0 ;
aux = *l;
while( (aux!=null)&& (contador<posicao) ){
anterior = aux;
aux=aux->prox;
contador++;
}
if(aux==null) return 0; // ele chegou no ultimo elemento e passou para o próximo
*dado = aux->dado;
if(posicao==1){ *l= aux->prox; }
else{ anterior->prox = aux->prox; }
free(aux);
return 1;
//região de memória sempre dê um free!!! != de variavel comum
}
/****************************************************************************
Criamos essa função para poder remover um dado (int *dado) em uma estrutura
A única coisa exclusiva criada foi um inteiro indice para imprimir o indice
de cada elemento da lista.
1)verificamos se a lsita está vazia.
2)criamos algo para aparecer antes e imprimimos no while toda a lista
3)A unica preoculpação é no while colocar a lista = lista->proximo, para
incrmentar uma posição e passar para o próximo elemento.
****************************************************************************/
int imprimirLista(TlistaEnc l){
int indice =1;
if(listaVazia(l)) return 0;
printf(”———————-\n”);
printf(”Indice | Dado \n”);
while(!listaVazia(l)){
printf(”%d | %d\n”,indice,l->dado); //verificar se indice ++ imprime o indice depois incrementa
indice++;
// está alterando a nova, pois ela é uma cópia, pois não tem o *
l=l->prox;
}
printf(”———————-\n”);
return 1;
}
Site do professor da UFMG, Gilberto Miranda,Junior. Na classe de qualificação educacional profissional é classificado como professor excelente!
.http://www.dep.ufmg.br/professores/miranda/InAlgol/Listas.pdf
Consegui reparar uma coisa interessante, nas minhas buscas por material encontrei vários sites com diversos professores diferentes e cheguei a uma conclusão.
“Um professor só pode ser dito como professor, aquele que se preocupa com todas as variáveis de problema de um aluno”. Conclui isto pois alguns professores possuem recursos e um destes observados foi o site.
Primeiro caso é possui um site e não explicam direito.
Já um segundo caso tem o site explicam mas a linguagem pode ser difícil(até chego a creditar que é intencional).
Possui o terceiro caso que possui a classe dos professores que tem o site e não colocam o material, de opinião própia esses são os enganadores, mas não enganam os alunos, enganam a si mesmo. Pois os alunos sabem que ele não está afim de ministrar aula e ele se engana pois ele que vai perder no futuro, porque “o bom aluno” acaba levantando “o bom professor”, a fama de um “bom professor” quem elege é simplesmente o aluno.
E para aqueles que não possuem conhecimento ou vontade de criar um site, podem fazer outros meios de auxilio ao aluno, hoje o mundo é conectado a web, acredito que esta maneira(sites) seria a mais prática e simples de auxiliar. Mas para aqueles que não se interessam em nada é recomendado procurar uma nova profissão, é recomendado…
José Rafael Mendes.
Procrurar no livro de tanebaum:
>1> Trabalho (Para Quem não tem Tanebaum)
>2> Nome iniciado com a Letra
>1> P III( pentium III )
>2> A - I
>1> Ultra Espark II
>2> J
>1> JVM( Pico Java II )
>2> Os Outros
primeiro programiha em java aqui!
//main.java
package principal;
import javabasico.io.Entrada;
import principal.metodos.Metodos;
public class Main {
public static void main(String args[]){
Metodos rafael = new Metodos();
//pq nao funfa ?????
//joao.setNome(string nome = Entrada.in.lerLinha(”informe seu nome : “););
//lendo uma string
//setando a string nova criada para a variavel do modelo rafael.Aluno = string do nome
rafael.setNome(Entrada.in.lerLinha(”Digite um nome : “));
System.out.println(rafael.getNome());
int num = 0;
while(rafael.getTamanho()>num){
boolean passar =true;
double nota;
do{
nota = Entrada.in.lerdouble(”Digite uma nota \n–> “);
if ( (nota >=0) && (nota <=10) ) {
passar = true;
rafael.setNota(nota,num);
num++;
}
else {
System.out.println(”Nota inválida ! redigite por favor \n”);
passar = false;
}
}while(passar ==false);
}
System.out.println(”\n\n”);
num = 0;
while(rafael.getTamanho()>num){
System.out.println(”A Nota “+(num+1)+” é = “+ rafael.getNota(num)+”\n”);
num++;
}
if(rafael.getMedia()>7){
System.out.println(”Aluno aprovado! com media “+rafael.getMedia());
}
else System.err.println(”Aluno Reprovado ! com media “+rafael.getMedia());
}
}
//metodos está em uma pasta (pacote) “Metodos”
//metodos.java
package principal.metodos;
public class Metodos {
// metodo set = capiturar item
// metodo get = mostrar na tela
String Aluno;
private double nota[]= new double[3];
public int getTamanho(){
return nota.length;
}
// o “e”ALUNO e nota”E” -> são de dados enviados
public void setNota(double notaE, int indice){
this.nota[indice] = notaE;
}
public double getNota(int indice){
return this.nota[indice];
}
public String setNome( String nome){
this.Aluno = nome;
return nome;
}
public String getNome(){
return Aluno;
}
public double getMedia(){
return (nota[0]+nota[1]+nota[2])/3;
}
}
