#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <time.h>
#define SIZE 5
//função de ordenação
void Ordena(int vet[SIZE]){
int aux;
for(int i = 0; i < SIZE; i++){
for (int j = 0; j < SIZE-1; j++){
if(vet[j] > vet[j+1]){
aux = vet[j];
vet[j] = vet[j+1];
vet[j+1] = aux;
}
}
}
for(int i = 0; i < SIZE; i++){
printf("\t%d", vet[i]);
}
}
int main() {
int vetor[SIZE]= {13, 21, 7, 5, 45};
//int vetor[SIZE];
int aleatorio[SIZE], x[SIZE];
int cont;
/*
printf("\nDigite 5 numeros de 0 a 60: \n");
for(int i = 0; i < SIZE; i++){
printf("%d: ",i+1);
scanf("%d", &vetor[i]);
}*/
printf("\n\tNUMEROS JOGADOS: \n\n");
Ordena(vetor);
printf("\n\n\tNUMEROS SORTEADOS: \n\n ");
//sorteando os numeros aleatorios
srand(time(NULL));// não gerar os mesmos numeros aleatorios repetidos a cada compilação
for(int i = 0; i < SIZE; i++){
aleatorio[i] = 0 + (rand()%60);
}
Ordena(aleatorio);
printf("\n\n");
for(int i = 0; i < SIZE; i++){
x[i] = aleatorio[i];
if(x[i] == vetor[i]){
cont++;
printf("Voce acertou o %d numero: [%d]\n", i+1, x[i]);
}
}
printf("\n\n");
return 0;
}
Conteúdos acadêmicos para estudos e conhecimento em geral
18/03/2018
Decodificador CI HC4511
* 4 Resistor 10Ω
* 1 Display 7 Segmento - Catodo
* 1 CI 4511
* 1 Protoboord
* 1 DIP Switch 6 Vias
 |
| Tabela do datasheet CI 4511 |
 |
| Circuito: Decodificador com CI 4511 |
 |
| Projeto de um decodificador com CI 4511 |
16/03/2018
Detector de metal usando CI 555
| COMPONENTES |
| U1,1," 555 Timer " |
| C1, C2,2,"2.2 uF, 16 V Polarized Capacitor " |
| C3,1,"10 uF, 16 V Polarized Capacitor " |
| PIEZO1,1," Piezo " |
| R2,1,"47 kohm Resistor " |
| L1,1,"150 uH Inductor " |
| BAT1,1," 9V Battery " |
 |
| Circuito : Detector de metal com CI 555 |
 |
| Detector de metal no protoboord |
09/03/2018
Buzina com CI 555
| COMPONENTES |
| 1 CI 555 " 555 Timer " |
| 1 Capacitor "10 uF Capacitor " |
| 1 - Auto Falante " Piezo " |
| 1 - Bateria 9V " 9V Battery " |
| 1 - Push Butoon " Pushbutton " |
| 1 - Led "Green LED " |
| 1 - Resistor "10 kohm Resistor " |
07/03/2018
Placa sinalizadora usando CI 555
06/03/2018
TEMPORIZADOR NOTURNO COM CI LM555
| COMPONENTES |
| U CI 555,1," 555 Timer " |
| C1,1,"10 nF Capacitor " |
| RResistor, RResistor 3,2,"1 kohm Resistor " |
| RResistor 2,1,"350 kohm Resistor " |
| DLed 1,1,"Green LED " |
| BATBateria 1,1," 9V Battery " |
 |
| Temporizador noturno com CI LM555 |
03/03/2018
Display de 7 segmentos
Eletrônica Digital
Mini teste 3
1) Projete um circuito lógico que tenha quatro entradas e a saída só vai para alto quando a maioria das entradas estiverem em baixo (deve ser implementado utilizando o 74151) ou se o número for múltiplo de cinco.
Resolução:
2) Nas placas de som existem conversores ADs de 16 bits. Determine a resolução desses conversores nas palavras binaria que representa 4,3V se 12V nesse conversor é igual ao máximo valor.
Resolução:
12 / 12-16 = 0,0000183 = 1,83 x 10-4
12 __> 653536
4,3 __> X
X = (4,3 . 65536) / 12 = 23484
A palavra binária = 0101 1011 1011 1100
1) Projete um circuito lógico que tenha quatro entradas e a saída só vai para alto quando a maioria das entradas estiverem em baixo (deve ser implementado utilizando o 74151) ou se o número for múltiplo de cinco.
 |
| Mux de 8 entradas 74151 |
Resolução:
2) Nas placas de som existem conversores ADs de 16 bits. Determine a resolução desses conversores nas palavras binaria que representa 4,3V se 12V nesse conversor é igual ao máximo valor.
Resolução:
12 / 12-16 = 0,0000183 = 1,83 x 10-4
12 __> 653536
4,3 __> X
X = (4,3 . 65536) / 12 = 23484
A palavra binária = 0101 1011 1011 1100
28/02/2018
Mesclar e centralizar uma lista vinculada em C++
//Programa C para mesclar uma lista vinculada em outro nas
//posições alternativas
#include <stdio.h>
#include <stdlib.h>
// Um nó da lista aninhada
struct Node{
int data;
struct Node *next;
};
/* Função para inserir um nó no início*/
void push(struct Node ** head_ref, int new_data){
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
/* Função de utilitário para imprimir uma lista ligada individualmente */
void printList(struct Node *head)
{
struct Node *temp = head;
while (temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
// Função principal que insere nós da lista vinculada q em p em
// posições alternativas. Como o chefe da primeira lista nunca muda
// e o cabeçalho da segunda lista pode mudar, precisamos de um único ponteiro
// para primeira lista e ponteiro duplo para a segunda lista.
void merge(struct Node *p, struct Node **q){
struct Node *p_curr = p, *q_curr = *q;
struct Node *p_next, *q_next;
// Embora existam posições disponíveis em p
while (p_curr != NULL && q_curr != NULL)
{
// Salve os ponteiros seguintes
p_next = p_curr->next;
q_next = q_curr->next;
//
q_curr->next = p_next; // Alterar o próximo ponteiro de q_curr
p_curr->next = q_curr; // Alterar o próximo ponteiro de p_curr
//Atualize as dicas atuais para a próxima iteração
p_curr = p_next;
q_curr = q_next;
}
*q = q_curr; //Atualize o ponteiro principal da segunda lista
}
//Programa de driver para testar funções acima
int main()
{
struct Node *p = NULL, *q = NULL;
push(&p, 3);
push(&p, 2);
push(&p, 1);
printf("Primeira lista vinculada:\n");
printList(p);
push(&q, 8);
push(&q, 7);
push(&q, 6);
push(&q, 5);
push(&q, 4);
printf("Segunda lista vinculada :\n");
printList(q);
merge(p, &q);
printf("\nPrimeira lista alterada modificada :\n\n");
printList(p);
printf("\nSegunda lista vinculada modificada :\n");
printList(q);
getchar();
return 0;
}
//posições alternativas
#include <stdio.h>
#include <stdlib.h>
// Um nó da lista aninhada
struct Node{
int data;
struct Node *next;
};
/* Função para inserir um nó no início*/
void push(struct Node ** head_ref, int new_data){
struct Node* new_node =
(struct Node*) malloc(sizeof(struct Node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
/* Função de utilitário para imprimir uma lista ligada individualmente */
void printList(struct Node *head)
{
struct Node *temp = head;
while (temp != NULL)
{
printf("%d ", temp->data);
temp = temp->next;
}
printf("\n");
}
// Função principal que insere nós da lista vinculada q em p em
// posições alternativas. Como o chefe da primeira lista nunca muda
// e o cabeçalho da segunda lista pode mudar, precisamos de um único ponteiro
// para primeira lista e ponteiro duplo para a segunda lista.
void merge(struct Node *p, struct Node **q){
struct Node *p_curr = p, *q_curr = *q;
struct Node *p_next, *q_next;
// Embora existam posições disponíveis em p
while (p_curr != NULL && q_curr != NULL)
{
// Salve os ponteiros seguintes
p_next = p_curr->next;
q_next = q_curr->next;
//
q_curr->next = p_next; // Alterar o próximo ponteiro de q_curr
p_curr->next = q_curr; // Alterar o próximo ponteiro de p_curr
//Atualize as dicas atuais para a próxima iteração
p_curr = p_next;
q_curr = q_next;
}
*q = q_curr; //Atualize o ponteiro principal da segunda lista
}
//Programa de driver para testar funções acima
int main()
{
struct Node *p = NULL, *q = NULL;
push(&p, 3);
push(&p, 2);
push(&p, 1);
printf("Primeira lista vinculada:\n");
printList(p);
push(&q, 8);
push(&q, 7);
push(&q, 6);
push(&q, 5);
push(&q, 4);
printf("Segunda lista vinculada :\n");
printList(q);
merge(p, &q);
printf("\nPrimeira lista alterada modificada :\n\n");
printList(p);
printf("\nSegunda lista vinculada modificada :\n");
printList(q);
getchar();
return 0;
}
27/02/2018
Algoritmo Lista em C/C++
Objetivo : Inserir elementos no inicio da lista, no fim da lista, inserir em posição qualquer da lista, remover em posição qualquer da lista.
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
typedef struct celulalista{
int informacao;
struct celulalista *proximo;
}celula;
void iniciar_Lista(celula *pRecebido);
void inserir_Inicio(celula *pRecebido);
void Consultar(celula *pRecebido);
void remove_inicio(celula *pRecebido);
int levalor(int *valorrecebido);
void insere_qualquer(celula *pRecebido);
void busca_e_remove(celula *pRecebido);
void insert_Fim(celula *pRecebido);
void remove_Fim(celula *pRecebido);
void removeElementoListaFim(celula **pRecebido);
int main()
{
//Declaracoes
celula *pLista;
int opcao=0;
//pLista = (celula *)malloc(sizeof(struct celulalista));
pLista = new celulalista;
iniciar_Lista(pLista);
for(;;)
{
cout<<"\n\t1 - Inserir no inicio: ";
cout<<"\n\t2 - Consultar : ";
cout<<"\n\t3 - Remover no inicio: ";
cout<<"\n\t4 - Inserir em posicao qualquer : ";
cout<<"\n\t5 - Remover em posicao qualquer : ";
cout<<"\n\t6 - Inserir no final : ";
cout<<"\n\t7 - Remover no final : ";
cout<<"\n\t8 - Sair : \n\t";
cin>>opcao;
opcao = levalor(&opcao);
switch(opcao)
{
case 1:
inserir_Inicio(pLista);
break;
case 2:
Consultar(pLista);
break;
case 3:
remove_inicio(pLista);
break;
case 4:
insere_qualquer(pLista);
break;
case 5:
busca_e_remove(pLista);
break;
case 6:
insert_Fim(pLista);
break;
case 7:
removeElementoListaFim(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
Inicializacao da lista encadeada
*/
void iniciar_Lista(celula *pRecebido){
(pRecebido)->proximo = NULL;
}
/*
Funcao para insercao no inicio
*/
void inserir_Inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
int valor;
//Instrucoes
cout<<"\n\tInforme um valor a ser inserido : ";
cin>>valor;
temporario = (celula * )malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (pRecebido)->proximo;
(pRecebido)->proximo = temporario;
}
/*
Funcao para percorrer elementos
*/
void Consultar(celula *pRecebido){
//Declaracoes
celula *temporario;
int i=0;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\tLista Vazia!\n";
}else{
temporario = (celula * )malloc(sizeof(celula));
temporario = (pRecebido)->proximo;
system("cls");
while(temporario!=NULL){
cout<<"\n\t"<<(i= i+1)<<": Valor : "<<temporario->informacao<<"\n";
temporario = temporario->proximo;
}
}
}
/*
Remove elemento da cabeca
*/
void remove_inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\n\tLista Vazia!";
}else{
temporario = (pRecebido)->proximo;
(pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}
int levalor(int *valorrecebido){
//Declaracoes
//Instrucoes
while((*valorrecebido > 8 )|| (*valorrecebido < 1)){
cout<<"\n\tOpcao Invalida. Informe novamente : \n";
scanf("%d", &(*valorrecebido));
}
return (*valorrecebido);
}
// COMECEI A IMPLEMENTAR A PARTIR DAQUI
void insere_qualquer(celula *pRecebido){
// Declarações
celula *aux1, *aux2, *temporario;
int posicao, valor;
// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
cout<<"\n\tDigite o valor a ser inserido apos o valor :";cin>>posicao;
cout<<"\n\tDigite o valor a ser inserido :";cin>>valor;
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
while (aux2 != NULL && aux2->informacao != posicao) {
aux1 = aux2;
aux2 = aux2->proximo;
}
temporario->proximo = aux2;
aux1->proximo = temporario;
}
}
void busca_e_remove(celula *pRecebido){
// Declarações
celula *aux1, *aux2;
int posicao;
// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
cout<<"\n\tDigite o valor a ser removido : "; cin>>posicao;
while (aux2 != NULL && aux2->informacao != posicao){
aux1 = aux2;
aux2 = aux2->proximo;
}
if(aux2 != NULL){
aux1->proximo = aux2->proximo;
free(aux2);//liberar e evitar esvaziamento de memoria
}
}
}
void insert_Fim(celula *pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;
if((pRecebido)->proximo == NULL){
(pRecebido)->proximo = temporario;
}else{
celula *tmp = (pRecebido)->proximo;
while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}
void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);
while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;
typedef struct celulalista{
int informacao;
struct celulalista *proximo;
}celula;
void iniciar_Lista(celula *pRecebido);
void inserir_Inicio(celula *pRecebido);
void Consultar(celula *pRecebido);
void remove_inicio(celula *pRecebido);
int levalor(int *valorrecebido);
void insere_qualquer(celula *pRecebido);
void busca_e_remove(celula *pRecebido);
void insert_Fim(celula *pRecebido);
void remove_Fim(celula *pRecebido);
void removeElementoListaFim(celula **pRecebido);
int main()
{
//Declaracoes
celula *pLista;
int opcao=0;
//pLista = (celula *)malloc(sizeof(struct celulalista));
pLista = new celulalista;
iniciar_Lista(pLista);
for(;;)
{
cout<<"\n\t1 - Inserir no inicio: ";
cout<<"\n\t2 - Consultar : ";
cout<<"\n\t3 - Remover no inicio: ";
cout<<"\n\t4 - Inserir em posicao qualquer : ";
cout<<"\n\t5 - Remover em posicao qualquer : ";
cout<<"\n\t6 - Inserir no final : ";
cout<<"\n\t7 - Remover no final : ";
cout<<"\n\t8 - Sair : \n\t";
cin>>opcao;
opcao = levalor(&opcao);
switch(opcao)
{
case 1:
inserir_Inicio(pLista);
break;
case 2:
Consultar(pLista);
break;
case 3:
remove_inicio(pLista);
break;
case 4:
insere_qualquer(pLista);
break;
case 5:
busca_e_remove(pLista);
break;
case 6:
insert_Fim(pLista);
break;
case 7:
removeElementoListaFim(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
Inicializacao da lista encadeada
*/
void iniciar_Lista(celula *pRecebido){
(pRecebido)->proximo = NULL;
}
/*
Funcao para insercao no inicio
*/
void inserir_Inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
int valor;
//Instrucoes
cout<<"\n\tInforme um valor a ser inserido : ";
cin>>valor;
temporario = (celula * )malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (pRecebido)->proximo;
(pRecebido)->proximo = temporario;
}
/*
Funcao para percorrer elementos
*/
void Consultar(celula *pRecebido){
//Declaracoes
celula *temporario;
int i=0;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\tLista Vazia!\n";
}else{
temporario = (celula * )malloc(sizeof(celula));
temporario = (pRecebido)->proximo;
system("cls");
while(temporario!=NULL){
cout<<"\n\t"<<(i= i+1)<<": Valor : "<<temporario->informacao<<"\n";
temporario = temporario->proximo;
}
}
}
/*
Remove elemento da cabeca
*/
void remove_inicio(celula *pRecebido){
//Declaracoes
celula *temporario;
//Instrucoes
if((pRecebido)->proximo == NULL){
cout<<"\n\tLista Vazia!";
}else{
temporario = (pRecebido)->proximo;
(pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}
int levalor(int *valorrecebido){
//Declaracoes
//Instrucoes
while((*valorrecebido > 8 )|| (*valorrecebido < 1)){
cout<<"\n\tOpcao Invalida. Informe novamente : \n";
scanf("%d", &(*valorrecebido));
}
return (*valorrecebido);
}
// COMECEI A IMPLEMENTAR A PARTIR DAQUI
void insere_qualquer(celula *pRecebido){
// Declarações
celula *aux1, *aux2, *temporario;
int posicao, valor;
// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
cout<<"\n\tDigite o valor a ser inserido apos o valor :";cin>>posicao;
cout<<"\n\tDigite o valor a ser inserido :";cin>>valor;
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
while (aux2 != NULL && aux2->informacao != posicao) {
aux1 = aux2;
aux2 = aux2->proximo;
}
temporario->proximo = aux2;
aux1->proximo = temporario;
}
}
void busca_e_remove(celula *pRecebido){
// Declarações
celula *aux1, *aux2;
int posicao;
// Instruções
if((pRecebido)->proximo == NULL){
printf("\nA lista esta vazia!");
}else{
aux1 = (pRecebido);
aux2 = (pRecebido)->proximo;
cout<<"\n\tDigite o valor a ser removido : "; cin>>posicao;
while (aux2 != NULL && aux2->informacao != posicao){
aux1 = aux2;
aux2 = aux2->proximo;
}
if(aux2 != NULL){
aux1->proximo = aux2->proximo;
free(aux2);//liberar e evitar esvaziamento de memoria
}
}
}
void insert_Fim(celula *pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;
if((pRecebido)->proximo == NULL){
(pRecebido)->proximo = temporario;
}else{
celula *tmp = (pRecebido)->proximo;
while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}
void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);
while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}
MÉTODO 2
#include <cstdlib>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
typedef struct celulaLista{
int informacao;
struct celulaLista *proximo;
}celula;
void initLista(celula **pRecebido);
void insertListaInicio(celula **pRecebido);
void insertListaFim(celula **pRecebido);
void insertListaPosicao(celula **pRecebido);
void buscaListaSimples(celula **pRecebido);
void removeElementoListaInicio(celula **pRecebido);
void removeElementoListaFim(celula **pRecebido);
void removeElementoListaPosicao(celula **pRecebido);
int leValor(int *valorRecebido);
int main(){
// Declarações
celula *pLista;
int opcao = 0;
//pLista = (celula *)malloc(sizeof(struct celulaLista));
pLista = new celulaLista;
initLista(&pLista);
for(;;){
printf("\n1 - Inserir no Inicio: ");
printf("\n2 - Inserir no Final: ");
printf("\n3 - Inserir em qualquer posicao: ");
printf("\n4 - Consultar: ");
printf("\n5 - Remover do Inicio");
printf("\n6 - Remover do Final");
printf("\n7 - Remover de qualquer posicao");
printf("\n8 - Sair\n");
scanf("%d", &opcao);
opcao = leValor(&opcao);
switch(opcao)
{
case 1:
insertListaInicio(&pLista);
break;
case 2:
insertListaFim(&pLista);
break;
case 3:
insertListaPosicao(&pLista);
break;
case 4:
buscaListaSimples(&pLista);
break;
case 5:
removeElementoListaInicio(&pLista);
break;
case 6:
removeElementoListaFim(&pLista);
break;
case 7:
removeElementoListaPosicao(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
Inicialização da Lista Encadeada
*/
void initLista(celula **pRecebido){
(*pRecebido)->proximo = NULL;
}
/*
Função para Inserção no Início
*/
void insertListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario;
}
/*
Função para Inserção no Fim
*/
void insertListaFim(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;
if((*pRecebido)->proximo == NULL){
(*pRecebido)->proximo = temporario;
}else{
celula *tmp = (*pRecebido)->proximo;
while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}
/*
Função para Inserção em Qualquer Posicao
*/
void insertListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q, *temporario;
int posicao;
int valor;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
printf("\nInserir apos a posicao : ");
scanf("%d", &posicao);
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
p = (*pRecebido);
q = (*pRecebido)->proximo;
while (q != NULL && q->informacao != posicao) {
p = q;
q = q->proximo;
}
temporario->proximo = q;
p->proximo = temporario;
}
}
/*
Função para Percorrer Elementos
*/
void buscaListaSimples(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista Vazia!\n");
}
else{
temporario = (celula *)malloc(sizeof(celula));
temporario = (*pRecebido)->proximo;
while(temporario != NULL){
printf("Valor : %d\n", temporario->informacao);
temporario = temporario->proximo;
}
}
}
/*
Remove Elemento do Inicio
*/
void removeElementoListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}
else{
temporario = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}
/*
Remove Elemento do Fim
*/
void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);
while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}
/*
Remove Elemento de Qualquer Posicao
*/
void removeElementoListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q;
int posicao;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
p = (*pRecebido);
q = (*pRecebido)->proximo;
printf("\nRemover o valor : ");
scanf("%d", &posicao);
while (q != NULL && q->informacao != posicao){
p = q;
q = q->proximo;
}
if(q != NULL){
p->proximo = q->proximo;
free(q);
}
}
}
/*
Opção para Validação da Entrada
*/
int leValor(int *valorRecebido){
// Declarações
// Instruções
while((*valorRecebido > 8) || (*valorRecebido < 1)){
printf("Opcao Invalida. Informe novamente : \n");
scanf("%d", &(*valorRecebido));
}
return(*valorRecebido);
}
#include <stdio.h>
#include <stdlib.h>
using namespace std;
typedef struct celulaLista{
int informacao;
struct celulaLista *proximo;
}celula;
void initLista(celula **pRecebido);
void insertListaInicio(celula **pRecebido);
void insertListaFim(celula **pRecebido);
void insertListaPosicao(celula **pRecebido);
void buscaListaSimples(celula **pRecebido);
void removeElementoListaInicio(celula **pRecebido);
void removeElementoListaFim(celula **pRecebido);
void removeElementoListaPosicao(celula **pRecebido);
int leValor(int *valorRecebido);
int main(){
// Declarações
celula *pLista;
int opcao = 0;
//pLista = (celula *)malloc(sizeof(struct celulaLista));
pLista = new celulaLista;
initLista(&pLista);
for(;;){
printf("\n1 - Inserir no Inicio: ");
printf("\n2 - Inserir no Final: ");
printf("\n3 - Inserir em qualquer posicao: ");
printf("\n4 - Consultar: ");
printf("\n5 - Remover do Inicio");
printf("\n6 - Remover do Final");
printf("\n7 - Remover de qualquer posicao");
printf("\n8 - Sair\n");
scanf("%d", &opcao);
opcao = leValor(&opcao);
switch(opcao)
{
case 1:
insertListaInicio(&pLista);
break;
case 2:
insertListaFim(&pLista);
break;
case 3:
insertListaPosicao(&pLista);
break;
case 4:
buscaListaSimples(&pLista);
break;
case 5:
removeElementoListaInicio(&pLista);
break;
case 6:
removeElementoListaFim(&pLista);
break;
case 7:
removeElementoListaPosicao(&pLista);
break;
case 8:
exit(0);
}
}
return 0;
}
/*
Inicialização da Lista Encadeada
*/
void initLista(celula **pRecebido){
(*pRecebido)->proximo = NULL;
}
/*
Função para Inserção no Início
*/
void insertListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
temporario->proximo = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario;
}
/*
Função para Inserção no Fim
*/
void insertListaFim(celula **pRecebido){
// Declarações
celula *temporario;
int valor;
// Instruções
temporario = (celula *)malloc(sizeof(celula));
if(!temporario){
printf("Lista Cheia!\n");
exit(1);
}else{
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
}
temporario->informacao = valor;
temporario->proximo = NULL;
if((*pRecebido)->proximo == NULL){
(*pRecebido)->proximo = temporario;
}else{
celula *tmp = (*pRecebido)->proximo;
while(tmp->proximo != NULL)
tmp = tmp->proximo;
tmp->proximo = temporario;
}
}
/*
Função para Inserção em Qualquer Posicao
*/
void insertListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q, *temporario;
int posicao;
int valor;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
printf("\nInserir apos a posicao : ");
scanf("%d", &posicao);
printf("\nInforme um Valor a ser Inserido : ");
scanf("%d", &valor);
temporario = (celula *)malloc(sizeof(celula));
temporario->informacao = valor;
p = (*pRecebido);
q = (*pRecebido)->proximo;
while (q != NULL && q->informacao != posicao) {
p = q;
q = q->proximo;
}
temporario->proximo = q;
p->proximo = temporario;
}
}
/*
Função para Percorrer Elementos
*/
void buscaListaSimples(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista Vazia!\n");
}
else{
temporario = (celula *)malloc(sizeof(celula));
temporario = (*pRecebido)->proximo;
while(temporario != NULL){
printf("Valor : %d\n", temporario->informacao);
temporario = temporario->proximo;
}
}
}
/*
Remove Elemento do Inicio
*/
void removeElementoListaInicio(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}
else{
temporario = (*pRecebido)->proximo;
(*pRecebido)->proximo = temporario->proximo;
free(temporario);
}
}
/*
Remove Elemento do Fim
*/
void removeElementoListaFim(celula **pRecebido){
// Declarações
celula *temporario;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("Lista vazia\n\n");
}else{
celula *ultimo = (*pRecebido)->proximo,
*penultimo = (*pRecebido);
while(ultimo->proximo != NULL){
penultimo = ultimo;
ultimo = ultimo->proximo;
}
penultimo->proximo = NULL;
}
}
/*
Remove Elemento de Qualquer Posicao
*/
void removeElementoListaPosicao(celula **pRecebido){
// Declarações
celula *p, *q;
int posicao;
// Instruções
if((*pRecebido)->proximo == NULL){
printf("\nLista Vazia!");
}else{
p = (*pRecebido);
q = (*pRecebido)->proximo;
printf("\nRemover o valor : ");
scanf("%d", &posicao);
while (q != NULL && q->informacao != posicao){
p = q;
q = q->proximo;
}
if(q != NULL){
p->proximo = q->proximo;
free(q);
}
}
}
/*
Opção para Validação da Entrada
*/
int leValor(int *valorRecebido){
// Declarações
// Instruções
while((*valorRecebido > 8) || (*valorRecebido < 1)){
printf("Opcao Invalida. Informe novamente : \n");
scanf("%d", &(*valorRecebido));
}
return(*valorRecebido);
}
26/02/2018
Algoritmo método de Gauss Seidel C/C++
#include <stdio.h>
#include <math.h>
#define ERROR 0.001 // erro, precissao
#define N 3 // Tamanho da matriz (linhas do sistema linear)
void main (){
int i, j;
// Declara a matriz com os coeficientes e respostas
float A[N][N] = {{3, -0.1, -0.2},
{0.1, 7, -0.3},
{0.3, -0.2, 10}};
// Declara matriz com os resultados
float b[N][1] = {{7.85},
{-19.3},
{71.4},
{15}};
// Declarar o vetor de chute inicial
float x[N][1] = {{0},
{0},
{0},
{0}};
// Declara o vetor do x velho para calcular o erro
float xAntigo[N][1] = {{0},
{0},
{0},
{0}};
// Declara bandeira que indica quando parar
float xError[N][1] = {{0},
{0},
{0},
{0}};
// Erro que vai pra 1 quando todos os esrros forem no minimo menor que o ERROR
int erro = 0;
// Loop do metodo
do {
// Loop para
for (i = 0; i < N; i++) {
float s = 0;
// Calculando o somatorio do conjunto x das iterações
//usando a regra de cramer
for (j = 0; j < N; j++) {
if (j != i)
s = s + A[i][j]*x[j][0];//lop para calcular o Ax
}
// Faz (bi - s) / Aii ser o x
x[i][0] = ((b[i][0] - s)/ A[i][i]);//lop para calcular o B-somatorio / A
}
//criterio da convergencia
for (i = 0; i<N; i++){
xError[i][0] = (fabs((x[i][0]- xAntigo[i][0]) / x[i][0])) * 100;
if (xError[i][0] >= ERROR){
erro = 1;//erro como uma questão de parada
}else{
erro = 0;
}
xAntigo[i][0] = x[i][0];
}
printf("\n");
for (i = 0; i <N; i++){
printf("X%i = %f\t |Er| = %f\n",i+1, x[i][0], xError[i][0]);
}
} while (erro != 0);
}
25/02/2018
Algoritmo método de Gauss C/C++
#include <stdio.h>
#include <stdlib.h>
#define N 3 //O numero de equações (linhas do sistema linear)
void main (){
int i, j, k;
float fator, soma;
float X[N];
float M[N][N+1] = {{3, -0.1, -0.2, 7.85},
{0.1, 7, -0.3, -19.3},
{0.3, -0.2, 10, 71.4}};
for(i = 0; i<N; i++){
for(j = 0; j<=N; j++){
printf("|%.3f\t", M[i][j]);
}
printf("\n");
}
// ELIMINACAO PROGRESSIVA
for(k = 0; k<N-1; k++){//Laco exterior se refere a coluna pivo que se altera. (linha pivo ou equacao pivo = equacao referencial para as eliminacoes)
for(i = (k+1); i<N; i++){//Este laco se refere as linhas que sofrerao as eliminacoes, que sempre iniciarao na linha seguinte da linha pivo
fator = M[i][k] / M[k][k];//fator de correcao que sera multiplicada pela linha pivo
for(j=0; j<=N; j++){//loco interno se refere a cada coluna da linha que sofrerao modificacoes da linha i
M[i][j] = M[i][j] - fator*M[k][j];
}
}
}
X[N-1] = M[N-1][N] / M[N-1][N-1]; // Primeria variavel que obtamos
//Test
printf("\n");
for(i = 0; i<N; i++){
for(j = 0; j<=N; j++){
printf("|%.3f\t", M[i][j]);
}
printf("\n");
}
// SUBSTITUICAO PROGRESSIVA
for(i=N-2; i>=0; i--){ //Laco exterior se refere a linha que recebera os valores das variaveis ja encontradas para descobrirmos as outras. Ela se inicia na penultima linha e vai ate a primeira
soma = 0;
for(j=(i+1); j<N; j++){ //Laco interno se refere as colunas da linha i
soma = soma + M[i][j]*X[j]; // soma todos os numeros da linha que ja tem o valor de x
}
X[i] = (M[i][N] - soma)/M[i][i]; // Calcula o x da coluna i
}
printf("\nResultado: " );
for(i=0; i<N; i++)
printf("\nX%d = %f\n", i+1, X[i]);
}
23/02/2018
Algoritmo Método da Bissecção C/C++
Em engenharia elétrica geralmente usam-se a leis de Kirchhoff para estudar o comportamento estacionário (que não varia com o tempo ) de circuitos elétricos. Um outro problema importante envolve os circuitos que são transientes por natureza e em que ocorrem variações temporais súbitas. Tal situação ocorre depois do fechamento da chave da figura abaixo.
A duração desse período está intimamente ligada às propriedades de armazenamento do capacitor e do indutor. O fluxo da corrente através do resistor causa uma queda de voltagem (VR) dada por:
VR = iR
Onde i é a corrente e R é a resistência do resistor.
Um indutor “resiste” a variações na corrente, de modo que a queda de tensão VL através dele é:
A queda de tensão no capacitor VC depende da carga (q) nele:
Onde C é a capacitância.
A segunda lei de Kirchhoff afirma que a soma algébrica das quedas de voltagem em torno de um circuito fechado é zero. Depois que a chave é fechada, tem-se:
Entretanto, a corrente está relacionada com a carga por:
Portanto,
Trata-se de uma equação diferencial ordinária linear de segunda ordem. A solução é dada por:
Na qual t = 0, q = q0 =V0C e V é voltagem fornecida pela bateria. A equação (1) descreve a variação no tempo na carga do capacitor.
Um problema de projeto típico em engenharia ( elétrica, controle, computação) poderia envolver a determinação do resistor apropriado para dissipar energia a uma taxa específica , com valores conhecidos para L e C. Para esse Problema, suponha que a carga deve ser dissipada a 1% do seu valor original (q/q0 = 0,01) em t=0,05s, com L = 5 H e C = 10-3 F
PS: Use o método da Bissecção. O método de Newton-Raphson pode ser inconveniente em virtude do cálculo da derivada de (1) ser trabalhoso.
A variável implícita da equação é R.
Resolução:
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
main(){
int opcao = 0 ,k =0 ;
float x = 0, y = 0, p = 0, M = 0, Fy = 0, Fyy = 0, Fm = 0, aux =0 , aux1=0 , er = 0, e =0.;
opcao = 0;
while(opcao != 2){
printf("\n\n\t\t");
printf("************\n \n \t");
printf("MENU DE OPCOES");
printf("\n\n\t");
printf("1 - Inserir Chute para o metodo.");
printf("\n\n\t");
printf("2 - Sair");
printf("\n\n\t");
printf("Escolha Opcao: ");
scanf("%d", &opcao);
switch(opcao){
case 1:{
printf("\n\n\t\t");
printf("************\n \n \t");
printf( "Digite valor de A:" );
scanf( "%f", &x );
printf("\n\n\t");
printf( "Digite valor de B:" );
scanf( "%f", &y );
printf("\n\n\t");
printf( "Digite a precisao desejada:" );
scanf( "%f", &p );
printf("\n");
k=0;
do{
M = ( x + y ) / 2;
Fy = (pow(M_E,-0.005*x)*cos(sqrt(2000-0.01*pow(x,2))*(0.05)))-0.01;
Fm = (pow(M_E,-0.005*M)*cos(sqrt(2000-0.01*pow(M,2))*(0.05))) -0.01;
Fyy = (pow(M_E,-0.005*y)*cos(sqrt(2000-0.01*pow(y,2))*(0.05)))-0.01;
aux = Fy*Fm ;
aux1 = Fyy*Fm ;
if ( aux < 0 ){
y = M;
}
else if ( aux1 < 0){
x = M;
}
if (x > 447 || y > 447)
break;
if ( aux > 0 && aux1 > 0 ){
printf("\n\n\t");
printf(" Entre as variaveis A e B não possuem raizes .");
break ;
}
k++;
printf("\n\n\t");
printf( "iteracao = %d\n", k );
printf( "A = %.20f\nB = %.20f\n", x, y );
} while( y - x >= p || Fy >= p || Fyy >= p );
er = y - x ;
e = (y+x)/2;
if (er < 0)
er = er*-1;
printf("\nO erro e = %.20f\n", er);
printf( "A valor de R e: %.20f\n", e );
break;
}
case 2:{
printf("\n\n\t");
printf("Voce SAIU com SUCESSO");
printf("\n\n");
break;
}
default:{
printf("\n\n\t");
printf("Opcao INVALIDA");
printf("\n\n");
}
}
}
}
17/02/2018
Lista vinculada e ordenada em C++
#include <iostream>
#include <cstdio>
using namespace std;
/* um nó da lista unicamente ligada */
struct Node
{
int data;
struct Node *next;
};
/* Uma função de utilidade para inserir um nó no início da lista vinculada */
void push(struct Node** head_ref, int new_data)
{
/* alocar o nó */
struct Node* new_node = new Node;
/* coloque os dados */
new_node->data = new_data;
/* vincule a lista antiga do novo nó */
new_node->next = (*head_ref);
/* mova a cabeça para apontar para o novo nó */
(*head_ref) = new_node;
}
/* Uma função de utilidade para imprimir lista vinculada */
void printList(struct Node *node)
{
while (node != NULL)
{
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
//Retorna o último nó da lista
struct Node *getTail(struct Node *cur)
{
while (cur != NULL && cur->next != NULL)
cur = cur->next;
return cur;
}
//Particiona a lista tomando o último elemento como o pivô
struct Node *partition(struct Node *head, struct Node *end,
struct Node **newHead, struct Node **newEnd)
{
struct Node *pivot = end;
struct Node *prev = NULL, *cur = head, *tail = pivot;
//Durante a partição, tanto a cabeça como o final da lista podem mudar
//que é atualizado nas variáveis newHead e newEnd
while (cur != pivot)
{
if (cur->data < pivot->data)
{
// Primeiro nó que tem um valor menor que o pivô - torna-se
// a nova cabeça
if ((*newHead) == NULL)
(*newHead) = cur;
prev = cur;
cur = cur->next;
}
else // Se o nó cur for maior do que o pivô
{
// Mova o nó cur para a próxima cauda e troque a cauda
if (prev)
prev->next = cur->next;
struct Node *tmp = cur->next;
cur->next = NULL;
tail->next = cur;
tail = cur;
cur = tmp;
}
}
// Se os dados de pivô forem o elemento mais pequeno da lista atual,
// pivô torna-se a cabeça
if ((*newHead) == NULL)
(*newHead) = pivot;
//Atualize newEnd para o último nó atual
(*newEnd) = tail;
//Retornar o nó pivô
return pivot;
}
//aqui a classificação acontece sem o nó final
struct Node *quickSortRecur(struct Node *head, struct Node *end)
{
// base condition
if (!head || head == end)
return head;
Node *newHead = NULL, *newEnd = NULL;
// Participar na lista, newHead e newEnd serão atualizados
// pela função de partição
struct Node *pivot = partition(head, end, &newHead, &newEnd);
//Se o pivô é o elemento mais pequeno - não há necessidade de recorrer
//a parte esquerda.
if (newHead != pivot)
{
//Defina o nó antes do nó pivô como NULL
struct Node *tmp = newHead;
while (tmp->next != pivot)
tmp = tmp->next;
tmp->next = NULL;
//Recorrer para a lista antes do pivô
newHead = quickSortRecur(newHead, tmp);
//Mude o próximo último nó da metade esquerda para girar
tmp = getTail(newHead);
tmp->next = pivot;
}
//Recorrer para a lista após o elemento de pivô
pivot->next = quickSortRecur(pivot->next, newEnd);
return newHead;
}
//A principal função para quicksort. Este é um invólucro sobre recursivo
// funcão quickSortRecur()
void quickSort(struct Node **headRef)
{
(*headRef) = quickSortRecur(*headRef, getTail(*headRef));
return;
}
int main()
{
struct Node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
cout << "\nLista vinculada antes de ordenar \n";
printList(a);
quickSort(&a);
cout << "\n\nLista vinculada apos a classificacao \n";
printList(a);
return 0;
}
#include <cstdio>
using namespace std;
/* um nó da lista unicamente ligada */
struct Node
{
int data;
struct Node *next;
};
/* Uma função de utilidade para inserir um nó no início da lista vinculada */
void push(struct Node** head_ref, int new_data)
{
/* alocar o nó */
struct Node* new_node = new Node;
/* coloque os dados */
new_node->data = new_data;
/* vincule a lista antiga do novo nó */
new_node->next = (*head_ref);
/* mova a cabeça para apontar para o novo nó */
(*head_ref) = new_node;
}
/* Uma função de utilidade para imprimir lista vinculada */
void printList(struct Node *node)
{
while (node != NULL)
{
printf("%d ", node->data);
node = node->next;
}
printf("\n");
}
//Retorna o último nó da lista
struct Node *getTail(struct Node *cur)
{
while (cur != NULL && cur->next != NULL)
cur = cur->next;
return cur;
}
//Particiona a lista tomando o último elemento como o pivô
struct Node *partition(struct Node *head, struct Node *end,
struct Node **newHead, struct Node **newEnd)
{
struct Node *pivot = end;
struct Node *prev = NULL, *cur = head, *tail = pivot;
//Durante a partição, tanto a cabeça como o final da lista podem mudar
//que é atualizado nas variáveis newHead e newEnd
while (cur != pivot)
{
if (cur->data < pivot->data)
{
// Primeiro nó que tem um valor menor que o pivô - torna-se
// a nova cabeça
if ((*newHead) == NULL)
(*newHead) = cur;
prev = cur;
cur = cur->next;
}
else // Se o nó cur for maior do que o pivô
{
// Mova o nó cur para a próxima cauda e troque a cauda
if (prev)
prev->next = cur->next;
struct Node *tmp = cur->next;
cur->next = NULL;
tail->next = cur;
tail = cur;
cur = tmp;
}
}
// Se os dados de pivô forem o elemento mais pequeno da lista atual,
// pivô torna-se a cabeça
if ((*newHead) == NULL)
(*newHead) = pivot;
//Atualize newEnd para o último nó atual
(*newEnd) = tail;
//Retornar o nó pivô
return pivot;
}
//aqui a classificação acontece sem o nó final
struct Node *quickSortRecur(struct Node *head, struct Node *end)
{
// base condition
if (!head || head == end)
return head;
Node *newHead = NULL, *newEnd = NULL;
// Participar na lista, newHead e newEnd serão atualizados
// pela função de partição
struct Node *pivot = partition(head, end, &newHead, &newEnd);
//Se o pivô é o elemento mais pequeno - não há necessidade de recorrer
//a parte esquerda.
if (newHead != pivot)
{
//Defina o nó antes do nó pivô como NULL
struct Node *tmp = newHead;
while (tmp->next != pivot)
tmp = tmp->next;
tmp->next = NULL;
//Recorrer para a lista antes do pivô
newHead = quickSortRecur(newHead, tmp);
//Mude o próximo último nó da metade esquerda para girar
tmp = getTail(newHead);
tmp->next = pivot;
}
//Recorrer para a lista após o elemento de pivô
pivot->next = quickSortRecur(pivot->next, newEnd);
return newHead;
}
//A principal função para quicksort. Este é um invólucro sobre recursivo
// funcão quickSortRecur()
void quickSort(struct Node **headRef)
{
(*headRef) = quickSortRecur(*headRef, getTail(*headRef));
return;
}
int main()
{
struct Node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
cout << "\nLista vinculada antes de ordenar \n";
printList(a);
quickSort(&a);
cout << "\n\nLista vinculada apos a classificacao \n";
printList(a);
return 0;
}
Assinar:
Postagens (Atom)