Assunto_ Fórum de Dúvidas_Respostas

Prévia do material em texto

03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 1/16
 
Fórum de Dúvidas
Todas as turmas
57 127
Marcellus 
Olá estudante,
Este espaço o seu Professor irá esclarecer as suas dúvidas.
Bons estudos!!!
Não lido  Assinado
(https:// MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050)
24 de ago de 2022
#include <stdio.h> 
#include <string.h> 
#include <conio.h> 
#include <stdlib.h> 
typedef struct cel 
 { 
 int conteudo; 
 struct cel *prox; 
 }No; 
 
 No *inicio=NULL;
void CriaLista() 
{ 
 inicio = NULL; 
}
int Insere(int dado) 
{ 
https://uva.instructure.com/courses/29595/users/34050
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 2/16
 No *p; 
 p = (No *) malloc(sizeof(No)); 
 if (p==NULL) 
 { 
 printf("Erro de alocacao\n"); 
 return 0; 
 } 
 p->conteudo = dado; 
 p->prox = NULL; 
 if (inicio==NULL) 
 inicio = p; 
 else { 
 p->prox = inicio; 
 inicio = p; 
 } 
 return 1; 
}
int RemoveDoInicio() 
{ 
 No *ptr; 
 if (inicio==NULL) 
 return 0; 
 else 
 { 
 ptr = inicio; 
 inicio = inicio->prox; 
 free(ptr); 
 return 1; 
 } 
}
void Imprime() 
{ 
 No *ptr; 
 if (inicio == NULL) 
 { 
 printf("--- fim da lista ---\n\n"); 
 return; 
 } 
 
 ptr = inicio; 
 while (ptr !=NULL) { 
 printf("Conteudo = %d\n",ptr->conteudo); 
 ptr = ptr->prox; 
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 3/16
 } 
 printf("--- fim da lista ---\n\n"); 
}
No *BuscaDado(int dado) 
{ 
 No *ptr; 
 if (inicio == NULL) 
 { 
 return NULL; 
 } 
 
 ptr = inicio; 
 while (ptr !=NULL) { 
 if (ptr->conteudo == dado) 
 return (ptr); 
 
 else ptr = ptr->prox; 
 } 
 return NULL; 
}
int RemoveDado(int dado) 
{ 
 No *ptr, *antes; 
 if (inicio==NULL) 
 { 
 return 0; 
 } 
 else 
 { 
 ptr = inicio; 
 antes = inicio; 
 while (ptr !=NULL) 
 { 
 if (ptr->conteudo == dado) 
 { 
 if (ptr == inicio) 
 { 
 inicio = inicio->prox; 
 free(ptr); 
 return 1; 
 } 
 else 
 { 
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 4/16
Visualizar no fórum
 antes->prox = ptr->prox; 
 free(ptr); 
 return 1; 
 } 
 } 
 else 
 { 
 antes = ptr; 
 ptr = ptr->prox; 
 } 
 } 
 return 0; 
 } 
}
Obs: código sem a main() e a implementação de menu (com um switch case, por exemplo)
para seleção de funções.
(https:// MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050)
31 de ago de 2022
#include <stdio.h> 
#include <stdlib.h>
struct Pilha { 
 int topo; 
 int capa; 
 float *pElem; 
};
typedef struct Pilha node;
int menu(void); 
void inicia(node *STACK); 
void opcao(node *STACK, int op); 
void exibe(node *STACK); 
void libera(node *STACK); 
void push(node *STACK); 
node *pop(node *STACK);
int main(void) { 
 node *STACK = (node *) malloc(sizeof(node));
 if(!STACK) { 
 printf("Sem memoria disponivel!\n"); 
https://uva.instructure.com/courses/29595/users/34050
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 5/16
 exit(1); 
 } else { 
 inicia(STACK); 
 int opt;
 do { 
 opt=menu(); 
 opcao(STACK,opt); 
 } while(opt);
 free(STACK); 
 return 0; 
 } 
}
void inicia(node *STACK) { 
 STACK->pElem = NULL; 
 STACK->capa = 0; 
}
int menu(void) { 
 int opt;
 printf("Escolha a opcao\n"); 
 printf("0. Sair\n"); 
 printf("1. Zerar PILHA\n"); 
 printf("2. Exibir PILHA\n"); 
 printf("3. PUSH\n"); 
 printf("4. POP\n"); 
 printf("Opcao: "); 
 scanf("%d", &opt);
 return opt; 
}
void opcao(node *STACK, int op) { 
 node *tmp; 
 switch(op) { 
 case 0: 
 libera(STACK); 
 break;
 case 1: 
 libera(STACK); 
 inicia(STACK); 
 break;
 case 2: 
 exibe(STACK); 
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 6/16
 break;
 case 3: 
 push(STACK); 
 break;
 case 4: 
 tmp= pop(STACK); 
 if(tmp != NULL) 
 break;
 default: 
 printf("Comando invalido\n\n"); 
 } 
}
int vazia(node *STACK) { 
 if(STACK->pElem == NULL) 
 return 1; 
 else 
 return 0; 
}
node *aloca() { 
 node *novo=(node *) malloc(sizeof(node)); 
 float num, *aux; 
 aux = &num;
 if(!novo) { 
 printf("Sem memoria disponivel!\n"); 
 exit(1); 
 } else { 
 printf("Novo elemento: "); 
 scanf("%f", &num); 
 return novo; 
 } 
}
void exibe(node *STACK) { 
 float num, *aux; 
 aux = &num; 
 if(vazia(STACK)) { 
 printf("PILHA vazia!\n\n"); 
 return ; 
 } 
 node *tmp; 
 tmp = STACK->pElem; 
 printf("PILHA:"); 
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 7/16
 while( tmp != NULL) { 
 printf("%f", *aux); 
 tmp = tmp->pElem; 
 }
} 
void libera(node *STACK) { 
 if(!vazia(STACK)) { 
 node *proxNode, 
 *atual;
 atual = STACK->pElem; 
 while(atual != NULL) { 
 proxNode = atual->pElem; 
 free(atual); 
 atual = proxNode; 
 } 
 } 
}
void push(node *STACK) { //Empilha 
 node *novo=aloca(); 
 novo->pElem = NULL;
 if(vazia(STACK)) 
 STACK->pElem=novo; 
 else { 
 node *tmp = STACK->pElem;
 while(tmp->pElem != NULL) 
 tmp = tmp->pElem;
 tmp->pElem = novo; 
 } 
}
node *pop(node *STACK) { //Desempilha{ 
 if(STACK->pElem == NULL) { 
 printf("PILHA ja vazia\n\n"); 
 return NULL; 
 } else { 
 node *ultimo = STACK->pElem, 
 *penultimo = STACK;
 while(ultimo->pElem != NULL) { 
 penultimo = ultimo; 
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 8/16
Visualizar no fórum
 ultimo = ultimo->pElem; 
 }
 penultimo->pElem = NULL; 
 return ultimo; 
 } 
}
(https:// MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050)
5 de set de 2022
Solução>>>
#include<stdio.h> 
#include<stdlib.h>
int i, tam, *v; 
char s;
void Pai(int x) { 
 x = (int)x/2; 
 if(x==0) { 
 printf("\nElemento Raiz, nao possui Pai: %d", v[x]); 
 } else { 
 printf("\nElemento Pai: %d", v[x-1]); 
 } 
}
void FilhoEsq (int x) { 
 x = 2*x; 
 if(x > tam) { 
 printf("\nElemento nao possui filho a esq"); 
 } else { 
 printf("\nElemento filho a esq: %d", v[x-1]); 
 } 
}
void FilhoDir (int x) { 
 x = (2*x)+1; 
 if(x > tam){ 
 printf("\nElemento nao possui filho a dir"); 
 }else{ 
 printf("\nElemento filho a dir: %d", v[x-1]); 
 } 
https://uva.instructure.com/courses/29595/users/34050
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 9/16
Visualizar no fórum
 
}
int main() {
 
 printf("Digite o tamanho do HEAP: "); 
 scanf("%d", &tam);
 v = (int*)malloc(sizeof(int)*tam);
 for(i=0; i<tam; i++) { 
 printf("DigiteValor para posicao %d: ", i+1); 
 scanf("%d", &v[i]); 
 }
 printf("\nConfrencia de vetor... \n...........\n");
 for(i=0; i<tam; i++) { 
 printf("Posicao %d: %d ", i+1, v[i]); 
 }
 do {
 printf("\n\nDigite qual posicao do elemento deseja info\nOu digite 0 para sair: "); 
 scanf("%d", &i); 
 
 if((i == 0) || (i > tam)) {
 printf("Posicao fora do HEAP");
 } else { 
 printf("\nValor do elemento: %d", v[i-1]);
 Pai(i); 
 FilhoEsq(i); 
 FilhoDir(i); 
 } 
 } while(i != 0); 
 
 free(v); 
 
}
(https:// MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050)
https://uva.instructure.com/courses/29595/users/34050
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 10/16
12 de set de 2022
#include<stdio.h> 
#include<stdlib.h>
int i, tam, *v; 
int pos=0; 
char s;
void Pai(int x) { 
 x = (int)x/2; 
 if(x==0) { 
 printf("\nElemento Raiz, nao possui Pai: %d", v[x]); 
 } else { 
 printf("\nElemento Pai: %d", v[x-1]); 
 } 
}
void FilhoEsq (int x) { 
 x = 2*x; 
 if(x > tam) { 
 printf("\nElemento nao possui filho a esq"); 
 } else { 
 printf("\nElemento filho a esq: %d", v[x-1]); 
 } 
}
void FilhoDir (int x) { 
 x = (2*x)+1; 
 if(x > tam) { 
 printf("\nElemento nao possui filho a dir"); 
 } else { 
 printf("\nElemento filho a dir: %d", v[x-1]); 
 }
}
void troca(int a, int b, int* v) { 
 int f = v[a]; 
 v[a] = v[b]; 
 v[b] = f; 
}
void corrige_abaixo(int pos) { 
 int pai = pos; 
 int filho_esq, filho_dir, filho; 
 while (2*pai+1 < tam) { 
 filho_esq=2*pai+1; 
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 11/16
 filho_dir=2*pai+2; 
 if (filho_dir >= tam) filho_dir=filho_esq; 
 if (v[filho_esq] > v[filho_dir]) 
 filho = filho_esq; 
 else 
 filho = filho_dir; 
 if (v[pai] < v[filho]) 
 troca(pai,filho,v); 
 else 
 break; 
 pai = filho; 
 } 
}
void corrige_heap(int pos) { 
 int pai; 
 while (pos > 0) { 
 pai = (pos-1)/2; 
 if (v[pai] < v[pos]) 
 troca(pos,pai,v); 
 else 
 break; 
 pos=pai; 
 } 
}
void cria_Heap() { 
 printf("Digite o TAMANHO do HEAP: "); 
 scanf("%d", &tam); 
 v = (int*)malloc(sizeof(int)*tam); 
 for(i=0; i < tam; i++) { 
 v[i] = -1; 
 } 
}
void insere() { 
 do { 
 printf("Digite Valor para posicao %d: ", pos+1); 
 scanf("%d", &v[pos]); 
 corrige_heap(pos); 
 pos++; 
 } while(pos<tam); 
 printf("Heap CHEIO!\n");
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 12/16
 printf("\nConfrencia de vetor... Ajustando Heap \n...........\n"); 
 for(i=0; i<tam; i++) { 
 printf("Posicao %d: %d ", i+1, v[i]); 
 }
 printf("\nHEAP AJUSTADO... \n...........\n"); 
}
 
void menu_Principal() {
 int x; 
 printf("Digite 1- para incluir no Heap\nDigite 2- para remover do Heap: \n"); 
 scanf("%d", &x);
 switch(x) {
 case 1: 
 insere(); 
 break; 
 case 2: 
 remove(); 
 break; 
 default: 
 printf("\nMenu Principal\n"); 
 menu_Principal(); 
 } 
}
void remove() { 
 if (pos > 0) { 
 v[0] = v[pos-1]; 
 pos--; 
 corrige_abaixo(pos); 
 } else { 
 printf("Heap VAZIO!"); 
 menu_Principal(); 
 } 
} 
void menu_Secundario() {
 do {
 printf("\nDigite qual POSICAO do elemento deseja info\n"); 
 scanf("%d", &i);
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 13/16
Visualizar no fórum
 
 if((i == 0) || (i > tam) || (i == -1)) {
 printf("Posicao fora do HEAP");
 } else {
 printf("\nValor do elemento: %d", v[i-1]);
 Pai(i); 
 FilhoEsq(i); 
 FilhoDir(i); 
 } 
 printf("\nDeseja sair? s = sim / n = nao: \n"); 
 scanf("%s", &s); 
 } while(s != 's' );
 free(v); 
}
 
int main() {
 cria_Heap(); 
 menu_Principal(); 
 menu_Secundario();
}
(https:// MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050)
18 de set de 2022
Definição
Uma função hash é um algoritmo que mapeia dados de entrada de comprimento variável
para dados de comprimento fixo. Os valores retornados por uma função hash são chamados
de valores hash ou simplesmente hash.
A função hash é usada para resolver o princípio de integridade da criptografia, garantindo
que a mensagem não foi alterada durante a transmissão.
Características
As principais características de uma função hash são:
Saída (hash) de tamanho fixo: as funções hash recebem uma mensagem (entrada) de
qualquer tamanho e sempre produzem o mesmo tamanho de saída. Geralmente são de
https://uva.instructure.com/courses/29595/users/34050
https://uva.instructure.com/courses/29595/users/34050
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 14/16
tamanho menor que o dado de entrada, sendo uma representação do dado original
(também conhecido como digest).
Eficiência da operação: as funções hash devem ser eficientes na sua computação, já
que são normalmente usadas para verificação de dados.
Determinística: uma mensagem sempre vai gerar o mesmo valor de hash.
Como funciona?
Uma função hash é uma função matemática que opera em dois blocos de tamanhos fixos de
dados para criar um hash. Esta função forma uma parte do algoritmo de hash.
O tamanho de cada bloco varia de acordo com o algoritmo. Geralmente, entre 128 a 512
bits.
O algortimo de hash envolve diversas rodadas dessa função em cadeia. Cada rodada pega
uma entrada de tamanho fixo, normalmente uma combinação de uma parte da mensagem
mais recente e a saída da última rodada. Este processo é repetido quantas vezes for
necessário para que toda a mensagem tenha sido processada.
Dessa forma, o hash do primeiro bloco se torna uma entrada para a segunda operação de
hash, cuja saída se torna uma entrada para a terceira e assim sucessivamente, até o término
da mensagem. Este efeito é conhecido como efeito avalanche e resulta em valores
totalmente diferentes de hash para duas mensagens que variam por apenas um bit de dado.
Funções populares
Message Digest (MD)
Foi uma das funções mais usadas por vários anos (e ainda é em alguns casos). A família
MD possui as funções MD2, MD4, MD5 e MD6, tendo sido adotada como um padrão da
internet por muito tempo. Possui um hash de 128 bits.
A função MD5 foi muito utilizada no mundo de software para garantir a integridade de
arquivos. Por exemplo, um servidor pode prover um valor hash MD5 de um arquivo já pré-
calculado para o usuário possa comparar quando tiver realizado o download dele.
Em 2004 foram achadas vulnerabilidades nesse algoritmo e ele não é mais recomendado.
Secure Hash Function (SHA)
A família do SHA consiste em quatro algoritmos: SHA-0, SHA-1, SHA-2 e SHA-3. Embora
sejam da mesma família, são estruturalmente diferentes.
A versão original do SHA-0, de 160 bits, foi publicada em 1993. Por ter algumas falhas, não
se tornou popular.
A versão SHA-1 foi amplamente utilizada na internet em aplicações e protocolos como o SSL
durante muito tempo (em 2016, o SHA-2 se tornou o padrão SSL).
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 15/16
A família do SHA-2 contém quatro variações: SHA-224, SHA-256, SHA-384 e SHA-512,dependendo do número final de bits do hash.
Em 2012, o algoritmo Keccak foi escolhido como o novo padrão SHA-3.
RIPEMD
O algoritmo RIPEMD é um acrônimo para “RACE Integrity Primitives Evaluation Message
Digest”. Esta família de funções foi projetada por uma comunidade de pesquisadores e
inclui hashes de tamanhos 128, 160, 256 e 320 bits, sendo a versão RIPEMD-160 a mais
comum.
A versão RIPEMD original e também RIPEMD-128 são consideradas não seguras devido ao
tamanho e ao design.
Whirpool
Projetado por um co-criador do AES, é uma versão derivada do próprio AES (algoritmo de
encriptação).
Tem três versões lançadas, conhecidas como WHIRLPOOL-0, WHIRLPOOL-T e
WHIRPOOL, todas contendo um hash de 512 bits.
Aplicações
Integridade de documentos
Verificar a integridade de documentos / arquivos / mensagens. Você já deve ter visto em
alguns sites de downloads que contém um valor de hash ao lado do arquivo (MD5 ou SHA-2,
por exemplo).
Assim que baixar o arquivo, você pode comparar o seu hash original com o hash do arquivo
que você baixou. Nesse caso, por exemplo, você pode usar o comando sha256sum no
Ubuntu para verificar o hash de um arquivo.
Salvar senhas
Salvamento e verificação de senhas é outra das aplicações. Ao invés de guardar a senha em
claro em um banco de dados, os desenvolvedores normalmente salvam os hashes das
senhas ou um valor mais complexo derivado da senha (usando salt ou outros passos).
Gerar um ID único
Gerar um ID (quase) único de certo documento ou mensagem, já que uma
função hash criptográfica conseguem gerar um único valor a partir do conteúdo de um
documento. Na teoria, as colisões são possíveis em qualquer função hash, mas é bem
improvável de acontecer, então a maioria dos sistemas assumem que o hash que eles
utilizam seja livre de colisão.
03/10/2022 14:14 Assunto: Fórum de Dúvidas
https://uva.instructure.com/courses/29595/discussion_topics/159772 16/16
Editado por MARCELLUS SIMÕES DA ROCHA (https://uva.instructure.com/courses/29595/users/34050) em 18 Set em 17:52
Visualizar no fórum
Por exemplo, o Git usa um hash (SHA-1) para identificar cada commit que é feito no
repositório. Depois, caso você queira ir para um commit específico ou referenciar ele de
algum modo, você pode usar esse valor para identificar ele no sistema.
Algoritmos de provas-de-trabalho (Proof-of-Work)
Protocolo utilizado para a prevenção de ataques cibernéticos como o DDoS e Spams. Para
que um usuário realize uma ação, ele deve ser capaz de provar que realizou uma tarefa.
Essa prova é a garantia que o usuário gastou tempo para gerar uma resposta que satisfaça
uma condição do avaliador. Outro uso bastante conhecido desse sistema é em blockchains.
A maioria dos algoritmos usados calculam um valor de hash que é maior que um certo valor
definido (conhecido como dificuldade de mineração). Para encontrar esse valor hash, os
mineradores devem calcular bilhões de diferentes hashes até encontrar aquele que satisfaz
a condição. Por exemplo, um protocolo pode definir que só aceita um número p tal que
o hash(x+p) contenha os 10 primeiros bits como zero.
Fonte:
https://medium.com/prognosys/fun%C3%A7%C3%B5es-hash-ou-hashing-b2c90ac5c398
(https://medium.com/prognosys/fun%C3%A7%C3%B5es-hash-ou-hashing-b2c90ac5c398)
https://uva.instructure.com/courses/29595/users/34050
https://medium.com/prognosys/fun%C3%A7%C3%B5es-hash-ou-hashing-b2c90ac5c398