#include <stdio.h>
#include <stdlib.h>
/* 1 - ESCREVA UM PROGRAMA QUE DECLARE UM INTEIRO, UM REAL E UM CHAR, E PONTEIROS PARA INTEIRO, REAL, E CHAR. ASSOCIE AS VARIÁVEIS AOS PONTEIROS(USE &). MODIFIQUE OS VALORES DE CADA VARIÁVEL USANDO PONTEIROS. IMPRIMA OS VALORES DAS VARIÁVEIS ANTES E APÓS A MODIFICAÇÃO.*/
main (void){
int num = 15;
double valor= 20.77;
char letra = 'h';
int *Endint = #
float *Endfloat = &valor;
char *Endchar = &letra;
printf("Variavel inteiro = %d \nEndereco ponteiro inteiro = %i\n\n", num, Endint);
printf("Variavel float = %.2f\nEndereco do ponteiro float = %i\n\n",valor, Endfloat);
printf("Variavel char = %c\nEndereco do ponteiro char = %i\n\n",letra, &letra);
printf("\tAPOS MODIFICACAO:\n");
*Endint = 22;
*Endfloat = 50.35;
*Endchar = 'k';
printf("\nEndereco do ponteiro: %d\nAlterado para o valor: %d\n\n", Endint, *Endint);
printf("Endereco do ponteiro: %d\nAlterado para o valor: %d\n\n", Endfloat, *Endfloat);
printf("Endereco do ponteiro: %i\nAlterado para o caracter: %c\n\n", Endchar, *Endchar);
return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
/*2- ESCREVA UM PROGRAMA QUE CONTENHA DUAS VARIÁVEIS INTEIRAS.COMPARE
SEUS ENDEREÇOS E EXIBA O MAIOR ENDEREÇO.*/
int main (void){
int a = 27, b = 77;
int *EndA = &a , *EndB = &b;
printf("\tA = %d B = %d\n\n",a, b);
printf("Endereco de A = %d\nEndereco de B = %d\n",EndA, EndB);
if(EndA > EndB){
if(&a > &b)
printf("\n\nEndereco %d de A eh maior: \n",EndA);
//printf("\n\nEndereco %d de A eh maior: \n", &a);
}else{
printf("\n\nEndereco %d de B eh maior: \n",EndB);
//printf("\n\nEndereco %d de B eh maior: \n",&b);
}
//ou
/*if(&a > &b){
printf("\n\nEndereco %d de A eh maior: \n", &a);
}else{
printf("\n\nEndereco %d de B eh maior: \n",&b);
}
printf("\n");*/
return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
/* 3 - Escreva um programa que contenha 2 variaveis inteiras. Leia
essas variavéis do teclado. Em seguida, compare seus endereços
e exiba o maior endereço.*/
int main (void){
int a, b;
printf("\tDigite o valor de a: ");
scanf("%d",&a);
printf("\n\tDigite o valor b: ");
scanf("%d",&b);
printf("\nValor de a = %i\nValor de b = %i\n\n",a, b);
int *EndA = &a, *EndB = &b;
printf("Endereco de a = %i\nEndereco de b = %i\n\n",EndA, EndB);
if(EndA > EndB){
printf("\n\nEndereco %d de a eh maior:",EndA);
}else{
printf("\n\nEndereco %d de b eh maior:", EndB);
}
printf("\n\n");
return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
#define SIZE 5
/*4 - CRIE UM PROGRAMA QUE CONTENHA UM ARRAY DE 5 ELEMENTOS INTEIROS. lEIA
ESSE ARRAY DO TECLADO E IMPRIMA O ENDERECO DE POSICOES CONTENDO VALORES PARES.*/
int main (void){
int vet[SIZE], i;
int *Endvet;
Endvet = vet;
printf("\tDigite %d elementos:\n",SIZE);
for(i = 0; i < SIZE; i++){
printf("%d: ",i+1);
scanf("%d", &vet[i]);
}
printf("\n\tELEMENTOS:\n\n");
for(i = 0; i < SIZE; i++){
printf("%d ",vet[i]);
}
printf("\n\nENDERECOS DO ARRAY:\n");
for(i = 0; i < SIZE; i++){
printf("%i : %i : %i\n",i+1, vet[i], Endvet++);
}
printf("\nENDERECOS DO ARRAY PAR:\n");
Endvet = vet;
for(i = 0; i < SIZE; i++){
if(vet[i] %2 == 0){
printf("\nNumero %d eh par : Posicao = %d",vet[i], Endvet);
}
Endvet++;
}
return EXIT_SUCCESS;
}
#include <stdio.h>
#include <stdlib.h>
#define SIZE 10
/* 5 - CRIE UM PROGRAMA QUE CONTENHA UM ARRAY DE FLOAT CONTENDO 10 ELEMENTOS.
IMPRIMA O ENDERECO DE CADA POSICAO DESSE ARRAY.*/
int main (void){
float vet[SIZE];
int i, *Endvet;
Endvet = vet;
printf("\tELEMENTOS:\n\n");
for(i = 0; i < SIZE; i++){
printf("[%.2f] ", (vet[i] = 10 + rand() %100) / 3.27);
}
printf("\n\nENDERECOS DO ARRAY:\n\n");
for(i = 0; i < SIZE; i++){
printf("%i : %.2f : %i\n",i+1, vet[i]/3.27, Endvet++);
}
return EXIT_SUCCESS;
}
Conteúdos acadêmicos para estudos e conhecimento em geral
27/04/2018
18/03/2018
Algoritmo Jogo da MEGA-SENA C/C++
#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;
}
#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;
}
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");
}
}
}
}
Assinar:
Postagens (Atom)