Melhorias dos sistemas

[roscibely]

---

1. Análise o código e explique o algoritmo de busca/ordenação que estar sendo utilizado e como ele funciona e sua complexidade de tempo.

2. Explique como o código/sistema estar estruturado (divisão de arquivos, compilação, TADs e structs.)

3. Verifique se o sistema está fazendo o uso do que foi visto em sala (Alocação dinâmica, TADS, arquivos)

4. Avalie a documentação fornecidade. Ela é suficiente? Avalie em uma escalda de 0-5. Justifique.

5. Propor melhorias no código (abrindo ISSUES).

6. Implemente as melhorias propostas.

---

[Oluaphenrique]

Busca de String com Busca Binária

1. Análise o código e explique o algoritmo de busca/ordenação que estar sendo utilizado e como ele funciona e sua complexidade de tempo.
   O código busca binaria por funcionários tem como o objetivo, fazer o cadastro de funcionários (onde será introduzido os parâmetros de nome, cargo e documento).

2. Explique como o código/sistema estar estruturado (divisão de arquivos, compilação, TADs e structs.)
   O código está divido em 3 partes (Funcionario.c , funcionario.h, main.c). O código aparentemente está seguindo todas as recomendações que foi passado, onde deveria ser criado o arquivo .c, .h e main.c ,
   conta com structs (nome, cargo e documento).
   na parte executável, conta com todos os implantes necessário conta com menu de 3 opções (Cadastrar Funcionários, Buscar funcionário e Sair) e dentro da opção de busca 2 (busca por funcionário, também a outro caso de busca onde ele pede para usuário informa qual tipo de busca deseja fazer (Nome ou documento).
   Ainda dentro dos casos, também foi colocado a função de tempo, onde mostra o tempo gasto para excursão.

3.Verifique se o sistema está fazendo o uso do que foi visto em sala (Alocação dinâmica, TADS, arquivos)
Pelo que conseguir verificar no código dele está implementado tudo que vimos em sala de aula que seria TAD'S, arquivos (abertura e fechamento de arquivos) e alocação dinâmica.
O arquivo de TAD'S está implementado no no arquivo funcionario.h , alocação dinâmica está implementada em funcionario.c na linha 117, função para escrita está implantado na linha 68, o a função para abertura do arquivo está implantando na linha 124, e a função de fechar arquivo está na linha 141.

4. Avalie a documentação fornecida. Ela é suficiente? Avalie em uma escalda de 0-5. Justifique.
   Avaliação 5. A documentação a qual foi fornecida (README.md), mim pareceu muito bem detalhada, fazendo a explicação do passo a passo, desde do que seria o problema, como executar, o que seria busca binaria (passo a passo) e Análise de Complexidade(por nome e documento).

5. Propor melhorias no código (abrindo ISSUES).
   Sugestões de melhoria  BuscaBinariaFuncionarios#3

6. Implemente as melhorias propostas.

https://github.com/Oluaphenrique/BuscaBinariaFuncionarios

[roscibely]

1. 0,3
2. 0,6
3. 0,5
4. 0,5
5. 0,7
6. 0,5

[johanpq]

InsertionSort

1. Em um loop ele vai percorrer um vetor até o penúltimo índice (tamanho - 1), e dentro desse loop existe outro códigos tais como:

Uma condição que compara se a parâmetro da struct(nome) é maior do que o outro nome um índice a frente ( i + 1), caso seja verdade acontece:

Uma variável do tipo funcionario para auxiliar e receber o outro funcionario no indice a frente do auxiliar que no caso é i + 1.

A variável funcionario[ i + 1 ] recebe funcionario[ i ] ou seja, na posição anterior.

A variável funcionario[ i ] recebe o auxiliar.

Então o que ele faz é: caso a condição seja verdadeira a variável auxiliar recebe o índice a frente, o índice a frente recebe o índice a baixo do que ele (porque ele é maior do que o índice que estava na frente, por isso eles estão trocando de posição) e o índice que está atrás( que só recebe ( i ) como índice ) recebe a variável auxiliar.

Agora há uma variável que recebe o índice anterior para checar os itens menores e maiores para fazer a troca.

Dentro do while ( em que j (variável) tem que ser >= 0 ) há uma condição para checar se o nome que o auxiliar aponta é menor do que o nome no índice j que o ponteiro de ponteiro funcionario aponta para o nome. Caso a condição seja verdadeira, o valor menor do item anterior fará a troca o valor maior.

A variável funcionario na posição a frente ( j + 1) receberá funcionario no índice anterior ( j) e a variável no índice ( j ) receberá o auxiliar.

Caso a condição não seja verdadeira, o loop será encerrado.

COMPLEXIDADE

c1
c2
c3( n - 1)
c4( n - 1)
c5( n - 1)
c6( n - 1)
c7( n - 1)
c8 ( n - 1)
c9 n( n -1)
c10 n( n - 1)
c11n( n - 1)
c12n( n - 1)
c13n( n - 1)

T(n) = (c3 + c4 + c5 + c6 + c7 + c8)n - 1 + (c9 + c10 + c11 + c12 + c13 )n² + c1 + c2
T(n) = an² + bn + c
T(n) = O(n²)

============================================================

2. Há um arquivo (.h) para ter os protótipos das funções, um arquivo (.c) para ter as funções do programa e o outro arquivo (main.c) que é o principal, para poder fazer uso das funções. Que no caso, são módulos como também Tads.

Sobre a Struct, ela é declarada no ( .c ) e o protótipo dela no ( .h ) podendo renomear no ( . h ).

A compilação será usada a ( gcc -o main main.c ) onde não precisa compilar os arquivos separadamente.

============================================================

3. funcionario.c = linhas 7, 17, 78, 87, 100, 110
   main.c = linhas 30, 33, 97, 100

===========================================================

4. 5. Pois para quem não tem nenhum conhecimento sobre é bem fácil de entender o funcionamente da função. E o propósitio do projeto por si só.

===========================================================

5. Ficaria melhor se as funções que estão no arquivo principal (main.c) fossem implementadas no arquivo ( .c ) e os seus protótipos no ( .h ). Por questões de manutenção e organização.

===========================================================

6. https://github.com/johanpq/InsertionSortEmployee

[roscibely]

1. 1
2. 0,9
3. 0,5
4. 0,5
5. 1
6. 1

[natanielbispo12]

1. Análise o código e explique o algoritmo de busca/ordenação que estar sendo utilizado e como ele funciona e sua complexidade de tempo.
   A função está comparando o nome do primeiro elemento do vetor com o segundo elemento em ordem crescente até o penúltimo elemento, pois nesse momento não vai mais existir posições no vetor para serem comparadas, ele faz o uso da palavra reservada "strcmp" da biblioteca de string.h responsável por essa comparação entre as strings em cada elemento do vetor, dessa forma com o uso de uma variável auxiliar chamada de "aux", ele faz as trocas de posições e ordena a lista de funcionários em ordem alfabética, no segundo laço ele faz o próprio uso da própria variável auxiliar e compara com o item anterior da posição atribuída a variável "aux". Analisando a função, notei que a complexidade que em um pior caso da função InsertSort será quadrática O(n^2), quando a lista tiver desordenada, assim, os dois laços encadeados vão ser utilizados. Em um melhor caso a lista já vai está ordenada e não será preciso entrar no segundo laço "while", então a complexidade será O(n).

2. Explique como o código/sistema estar estruturado (divisão de arquivos, compilação, TADs e structs.)
   O projeto na linguagem C foi dividido em 3 classes, a classe "funcionario.h" onde ficou o cabeçalho da strucut "Funcionario" com seus atributos, como também o cabeçalho de 5 outras funções, uma para cadastrar os funcionários, a função InsertionSort para fazer a ordenação, uma função para abrir o arquivo .txt, uma função para gravar os dados digitados pelo usuário no arquivo de texto, e por fim, a função para imprimir os dados procurados no arquivo de texto no console do terminal. Na classe "funcionario.c" foi incluída a classe "funcionario.h" e implementado o código de cada função e da struct "Funcionario". Na classe "main.c" foi incluída a classe "funcionario.c", implentado um menu com 3 opções: 1 - Cadastrar, 2 - Listar e 3 - Sair, na opção 1 o sistema pede os dados do funcionário e passa como parâmetro na função "cria_funcionarios", na opção 2 o sistema faz uma condição para saber se existe funcionários cadastrados, caso sim, ele lista todos esses funcionários, por fim, a opção 3 saí da aplicação.

3. Verifique se o sistema está fazendo o uso do que foi visto em sala (Alocação dinâmica, TADS, arquivos)
   Na linha 5 da classe "funcionario.h" está sendo feito o uso da palavra reservada typedef, na qual permite renomear a struct para "Funcionario", facilitando o uso dessa estrutura na implementação restante do sistema, não precisando de utilizar a palavra reservada "struct", apenas "Funcionario". Na linha 79 da classe "funcionario.c" está sendo feito a tratativa para verificar se o arquivo de texto "funcionarios.txt" foi aberto corretamente caso ele seja diferente de nulo. Na linha 100 da classe "main.c" está sendo feita a liberação de memória alocada durante a execução do sistema, mais um conceito que foi visto em sala de aula.

4. Avalie a documentação fornecidade. Ela é suficiente? Avalie em uma escalda de 0-5. Justifique.
   Acredito que poderia ter sido feito um detalhamento melhor do funcionamento da função InsertionSort implementada no sistema criado, foram dados exemplos do funcionamento de modo geral, mas poderia ser sido detalhado melhor na função criada, então, de 0 a 5, um 4.

5. Propor melhorias no código (abrindo ISSUES).
   Sugestões de Melhorias InsertionSortEmployee#13

6. Implemente as melhorias propostas.
   https://github.com/natanielbispo12/InsertionSortEmployee

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 0,7
6. 0,5

[TheFonci]

1°Questão: A Busca de string com busca binaria é bastante eficiente na busca de de elementos em uma lista já organizada, dividindo o processo pela metade buscando o elemento na lista com base no seu valor, se for um valor mais baixo, ele descarta as opções de valores mais altos e começa uma varredura pelos valores mais inferiores da lista até encontrar com o mesmo selecionado, o mesmo pare valores elevados. quando se busca a um elemento que se encontra pelo meio da lista, o processor chega a ser mais rápido pois ele parte do meio da lista verificando uma quantidade bem menor de elementos, ao invés de percorrer pela lista toda.
Sua complexidade é de log₂(n) ou seja, é uma função linear onde sempre vai tá reduzindo as probabilidades pela metade até chegar ao resultado desejado.

---

2°Questão: Este código está estruturado em três partes Funcionário.c, Funcionário.h e main.c. onde a funcionários.c estão todas as funções do código incluindo a struct para abrir um vetor onde será armazenado os dados dos funcionários, uma função de manipulação de arquivos que abre uma pasta .txt em append para preencher com as informações do funcionários, e outra para abrir um arquivo de leitura de texco com os dados que foram implementados nele. e o tad para separar as funções em um modulo, tornando mais fácil a manipulação e correção de bugs.

---

3°Questão: O código faz uso de todas as funções vistas em sala de aula como na linha 59 onde ele faz uso da alocação dinâmica para adicionar novos funcionários a lista, as TADS é visível na formatação e a criação de arquivos nas linhas 95 e 124 do modulo funcionario.c
Trecho do código: arquivo = fopen("funcionarios.txt", "rt");
if(arquivo == NULL){
printf("Erro ao abrir!\n");
exit(1);
}

---

arquivo = fopen("funcionarios.txt", "rt");
if(arquivo == NULL){
printf("Erro ao abrir o arquivo!\n");
exit(1);
}

---

void registraFuncionario(Funcionario *funcionario, FILE *arquivo, char *nome, char *cargo, char *documento)
{
//Aloca memória para um novo funcionário
funcionario = (Funcionario *) malloc(sizeof(Funcionario));
if(funcionario == NULL){
printf("Erro ao abrir o arquivo!\n");
exit(1);
}

---

4°Questão: Para o que foi pedido, ela atende bem, de forma simples e interativa, avalio com uma nota 4.

---

5°Questão: é possível implementar funções de reorganização de nomes compostos com letras maiúsculas, e também é possível mover todas as bibliotecas usadas no código para a funcionario.h, deixando o código mais limpo adicionando somente a seguinte biblioteca #include"funcionario.h" na main.c e na funcionario.c.

[roscibely]

1. 0,6
2. 0,6
3. 0,5
4. 0,5
5. 1
6. 0

[felipehidequel]

1. No presente trabalho, o método de ordenação Selection sort está sendo utilizado para ordenar um array do tipo Estruturado Funcionário, ordenando em ordem alfabética os nomes dos funcionários. O método posiciona iterativamente o menor valor do conjunto em análise na primeira posição do vetor, em seguida o segundo maior valor é colocado na segunda posição, esse procedimento acontece iterativamente, de forma sequencial. Para realizar as comparações, no selection_sort é implementada 2 laços aninhados, um laço externo para percorrer os índices do vetor e um laço interno que vai realizar as comparações entre as strings. A complexidade de tempo do algoritmo de ordenação é ditada pelo tamanho do vetor. Considerando o tempo constante, no pior e no melhor dos casos, o laço interior seria executado n(n-1), por um laço depender do outro, MAX = O(N^2).

2. O código possui uma TAD para um o tipo estruturado Funcionário. A struct Funcionario possui os seguintes campos: tag, nome, cargo e documento. As funções implementadas em funcionario.h são as seguintes:

• uma função que cadastra os funcionario, preenchendo seus campos de forma dinâmica
• uma função que libera a memória alocada para um tipo estruturado Funcionario
• uma função que compara o tamanho de 2 strings
• uma função que ordena um array funcionários por nome utilizando o selection sort
• uma função que lê os dados de um arquivo de texto e os grava em um array de funcionario
• uma função que imprime os funcionários cadastrados
• uma função que busca um funcionário por documento em um array do tipo funcionario
• uma função que importa os dados em um arquivo de texto existente e armazena em uma struct funcionario

3. O código possui um arquivo main.c que linka a interface de usuário ao TAD Funcionário. Para o usuário, o sistema oferece as seguintes funcionalidades:

• Cadastrar funcionario
• Listar funcionarios
• Importar funcionarios
• Teste de execução Selection Sort
• Buscar funcionario
• Encerrar

4. O sistema utiliza um array de Funcionarios alocado dinamicamente para armazenar os dados dos funcionarios em tempo de execução:

• linha 36 em main.c: Funcionario funcionario = (Funcionario) calloc(MAX_FUNC,sizeof(Funcionario*));

• O sistema utiliza um TAD para representar o tipo estruturado Funcionario (funcionario.h e funcionario.c)

• Também foi utilizado manipulação de arquivos para guardar e carregar os dados dos funcionarios:
  --func_leia na em funcionario.c, linha 100;
  --func_salva em funcionario.c, linha 141;

5. Os comentários nos protótipos das funções em funcionario.h dão uma boa noção do funcionamento de cada função. O readme do projeto explana bem o funcionamento do selection_sort, no entanto, faltou um tópico mostrando com os pré-requisitos para executar o sistema e um tutorial de compilação/instalação. Nota 3.

6. Sugestão de melhorias:

• remover a pasta com configurações do vscode (.vscode)

• Em funcionario.c, linha 28 e 29:
  -- strcpy(funcionario->nome, strupr(nome));
  -- strcpy(funcionario->cargo, strupr(cargo));
  -- Em funcionario.c, linha 48
  -- return strcmp(strupr(nome1), strupr(nome2));
  -- A função strupr() que está sendo usada para deixar uma string maiuscula, não funciona em sistemas de distribuição linux, o ideal seria escrever uma função que itera a string e retorna a mesma maiuscula.

exemplo de função:

/converte string para maiusculo/
void maiusculo(char *s1, char *s2){
int i = 0;
while(s1[i] != '\0'){
s2[i] = toupper(s1[i]);
i++;
}
s2[i] = '\0';
}

6. https://github.com/felipehidequel/SelectionSortEmployee

[roscibely]

1. 0,9
2. 1
3. 0,5
4. 0,5
5. 1
6. 1

[Gustavo-A-Mendes]

Análise do código do Projeto "QuickSortEmployee":

1. No projeto analisado consiste em um código de ordenação de nomes, em ordem alfabética, de uma lista de nomes de funcionários cadastrados, sendo utilizando o algoritmo de ordenação "Quick Sort".

O Quick sort é um algoritmo de ordenação que divide os dados em subgrupos, para aumentar sua eficiência. Essa divisão é feita a partir de um pivô, ordena os subgrupos, e depois os combina, obtendo uma lista ordenada, portanto, a forma de escolha do pivô é fundamental para o bom funcionamento do algoritmo. Seu funcionamento é dividido em três etapas:

• Escolha do pivô: seleciona um elemento da lista, para servir de "pivô";
• Divisão: reorganiza a lista a partir do pivô, colocando os dados menores que ele à esquerda, e os maiores, a direita;
• Recursão: a repetição da etapa de divisão nos subgrupos criados, até que todos os elementos estejam ordenados.

Sua complexidade de tempo depende do pivô escolhido.

• MELHOR CASO: o pivô escolhido representa o valor médio da lista ou da sublista, sua complexidade é logarítmica, O(n*log(n));
• PIOR CASO: o pivô escolhido é o menor valor, ou o maior valor, da lista ou da sublista, sua complexidade é quadrática, O(n²).

2. O sistema do projeto analisado é organizado em três arquivos:

• funcionario.h: TAD do sistema. Contém os protótipos das funções, com comentário definindo sua utilidade, e a declaração da struct Funcionario;
• funcionario.c: Arquivo que contém as declaração das funções utilizadas no sistema, que está relacionado ao arquivo "funcionario.h", que possui os protótipos das funções, e que é utilizada para chamar elas no arquivo "main.c";
• main.c: Área principal do sistema. Gerencia o menu de opções, que realiza as chamadas das funções usadas, quando necessárias.

A compilação é do "main.c" deve ser feita junto do arquivo "funcionario.c".

3. Utilização dos assuntos vistos em aula:

• Alocação dinâmica: Em "funcionario.c", na função "ordenarLinhasArquivo()" -> linha 132;
• TAD: O arquivo "funcionario.h", que contém a declaração da struct e os protótipos das funções;
• Arquivos: Em "funcionario.c", na função "imprimirArquivos()" -> linhas 48, 57; na função "criarArquivo()" -> linhas 68, 73, 82, 85, 95 a 105.

4. NOTA: 5
   A documentação do fornecida é bem completa, possuindo um breve resumo sobre o uso que cada arquivo do projeto, e as funções utilizadas no programa, explicando a forma de utilizá-las. Além disso, apresenta o algoritmo de ordenação implementado, falando sobre seu funcionamento, desempenho, vantagens e desvantagens.

5. Melhorias no programa:
   5. Sugestão de Melhoria QuickSortEmployee#3 (comment)

6. Implementação:
   https://github.com/Gustavo-A-Mendes/QuickSortEmployee

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 1

[karlloscosta]

Questão 1.
O codigo funciona da seguinte forma:
#Na primeira linha é passado os funcionarios desde o segundo armazenado[1] até o ultimo
Na segunda linha é passado o funcionario no indice i a uma variavel
terceira linha um novo indice recebe o primeiro decrementado
Na quarta linha (WHILE) vem o teste para organização, que vai comparar lexicograficamente os dois em posição na lista
Na quinta linha, caso a primeira seja verdadeira é feito a atribuição para ser testado novamente
Na quinta linha j é decremetado mais uma vez para testar com o fncionário a sua esquerda na lista
e pot ultimo quando a condição deixa de ser atendida o algoritmo aatribui a posição correta algo a funcionário e assim ordena a lista nome por nome.

def insertion_sort(funcionarios):
for i in range(1, len(funcionarios)): #O(n-1) ou (n)
chave = funcionarios[i] #O(1)
j = i - 1 #O(1)
while j >= 0 and chave.nome.upper() < funcionarios[j].nome.upper(): #O(n-1)
funcionarios[j + 1] = funcionarios[j] #O(1)
j -= 1 #O(1)
funcionarios[j + 1] = chave #O(1)

Com isso a complexidade de tempo do algoritmo é quadrática O(n²) no pior caso, que é quando a lista não esta ordenada.
Quando a lista ja vem ordenada o algoritmo não entra no segundo loop(While) e como isso sua complexidade é linear O(n)

Questão 2.
O arquivo esta dividido em módulos e classes:
Modulo Arquivo: responsável por abrir e ler dados de um arquivo depois adicionar os dados lidos em uma lista depois e reescreve no arquivo lido
Modulo Funcionario: Responsável por as funções de manipulação do funcionário, abriga a classe Funcionário e o algoritmo de busca e ordenação
Modulo Main: É o modulo principal da função, onde fica o menu de interação com o usuário e a chamada das funções omportadas dos outros módulos

Questão 3.
Sim, o algoritmo faz uso de tudo que foi visto em sala de aula

Questão 4.
Documentação bem elaborada, o fato de usar exemplos do cotidiano ajuda a compreensão, porém a falta de uma orientação mais formal faz falta para compreensão, apresentação das implementações tanto em Python como em C ajuda, principalmente a parte de C já que é totalmente comentado, já python, por mais que seja a mesma ideia também deveria ter a orientação por parte dos criadores, já na parte da complexidade algoritmo, esta muito bom, calculo feito em todas as linhas e a explicação do melhor e do pior caso, além disso seria legal apresentar situações onde esse tipo de algoritmo é usado no dia dia, no mais é uma boa documentação
--> Avaliação 3/5

Questão 5.
classroom-ufersa/InsertionSortEmployee#12

Questão 6.
https://github.com/karlloscosta/InsertionSortEmployee

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 0,5

[MichelyFelix]

o selection sort é um algoritmo de ordenação onde pode se ordenar tanto em ordem crescente como decrescente, ele analisa o menor valor e o coloca na primeira posição do vetor, depois ele faz a analisa do próximo valor e se esse valor for maior que o primeiro e menor do os outros valores do vetor esse valor será colocado em segundo, essa analise será feita até ter todos os elementos do vetor ordenados ou em ordem crescente ou decrescente.
void func_ordena(Funcionario **func, int count)
{
int i, primeiroID, j; //c1
Funcionario *valor_teste;//c2

for (i = 0; i < count; i++) //c3*n
{

    valor_teste = func[i]; // funciona como uma variável auxiliar e recebe o valor que o índice aponta c4*n

    primeiroID = i;//c5*n
    for (j = i + 1; j < count; j++)//laço para comparar o próximo valor c6*(n-1)/2
    {
        if (func_compara(func[primeiroID]->nome, func[j]->nome) == 1)// faz a verificação se o nome que está em func[primeiroID] é maior que funci[j] c7*(n-1)/2
        {
            primeiroID = j;// realiza a troca c8*(n-1)/2
        }
    }

    if (primeiroID != i)// se a troca não aconteceu ele entra no if e troca os valores c9*n
    {
        func[i] = func[primeiroID];// c10*n
        func[primeiroID] = valor_teste;c11*n
    }
}

}

O big O dele será T(n) = O n^2 e o melhor e o pior caso será n^2.

O código está estruturado em três partes: funcionario.c, funcionario.h e main.c. funcionario.h.
funcionario.h está a TAD do sistema com os cabeçalhos das funções.
funcionario.c está a implementação das funções.
main.c está a chama das funções e a função principal que é fundamental para o programa executar.
foi utilizada a Struct Funcionario com os campos: int tag; char nome[31]; char cargo[41] e long long documento.O menu contém 6 opções( criar funcionario, listar funcionario, importar funcionarios, teste de execução do selection sort, buscar funcionario e encerrar).

3. Alocação dinâmica: funcionario.c, (22, 272); main.c ( 36);
   arquivos: funcionario.c (108-137; 141-158; 205-230; 266-293); main.c (17,18);
   TAD: funcionario.c (5); main.c ( 6 , 125-131, 139-155,246-258,260-268).

4. nota 5. A função selection sort foi bem apresentada, explicanda detalhadamente como a função funciona, porém a utilização de comentários na função ajudaria no melhor entendimento de como o algoritmo funciona.

5. Nenhuma sugestão de melhoria

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 0,5
6. 0

[srlv]

1. O Selection Sort é um algoritmo de ordenação de strings ou valores, onde ele analisa os dados de um vetor a partir de sua primeira posição. Ele funciona da seguinte forma: é criado dois laços de repetição para um depender do outro, a medida que uma string seja maior do que a outra, o codigo ordena de um modo sequencial onde se substitui a primeira posição do vetor pelo caracter da string com menor valor, após essa substituição, a função implementa +1 para comparar a próxima posição do vetor, se para compara se se esse valor é maior ou menor, caso seja se repete o processo.

COMPLEXIDADE:

Após a análise, tem-se o resultado de que o Big O seria T(n)=O(n²).
resultado:
T(n)=(c1+c2+c3)+(c3+c4+c5+c9+c10+c11)(n)+(c6+c7+c8)n(n-1)/2 ou n²-n/2
T(n)=( a )+( bn ) +(cn²-n)/2
T(n)= O(n²)

2. O código apresenta três arquivos em formas de TAD e struct, (funcionario.h), (funcionario.c) e (main.c), a compilação funciona no main.c onde se faz as funções de cadastrar, listar os funcionários cadastrados e buscar funcionário, apresentando assim os requisitos pedidos.
   =========================================================
3. Os arquivos TAD'S podem ser encontrados no funcionario.h na linha 4, a alocação dinâmica pode ser pode ser encontrada no funcionario.c na linha 22, a função de abrir arquivo pode ser encontrado funcionario.c na linha 108 e para fechar na linha 137.
   ========================================================================================
4. A documentação implementada atende os requisitos propostos para o determinado código, onde apresenta o que é o Selection Sort de forma clara, demostra perfeitamente como a complexidade e como implementar a determinada função.
   avaliação: 5.
   ========================================================================================
   5 e 6
   melhorias SelectionSortEmployee#3 (comment)

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 0

[Gabriellk28]

Questão 1. O algoritmo de busca Bubble Sort recebe como parâmetros o vetor e o seu tamanho. Dentro do corpo da função as primeiras instruções são as declarações de duas variáveis para servirem de contadores e outra variável do tipo dos dados a serem ordenados no vetor. Em seguida entra-se dentro de laço de repetição for em que a condição é o primeiro contador ser menor do que o tamanho do vetor, e dentro deste for vem outro laço de repetição for com a condição do segundo contador ser menor do que o tamanho do vetor menos 1. Dentro do segundo laço de repetição existe uma instrução de comparação if onde a comparação a ser feita é se o valor do vetor é maior do que o valor do vetor no índice a frente, se não for então estão ordenados, já caso não seja a variável auxiliar recebe o valor do vetor que é maior e no índice deste valor é colocado valor que é menor, e para finalizar o índice do menor valor recebe o conteúdo da variável auxiliar. A complixade do algoritmo Bubble Sort é calculada da seguinte forma: T(n) = c1+c2+c3+c4*(n)+c5*(n)(n-1)+c6(n)(n-1)+c7(n)(n-1)+c8(n)(n-1)+c9(n)(n-1) = T(n) = a+b(n)+c5*(n²-n)+c6*(n²-n)+c7*(n²-n)+c8*(n²-n)+c9*(n²-n) = T(n) = a+bn+c*(n²-n) = T(n) = a+bn+cn²-cn = T(n) = bn+cn²-cn = T(n) = cn² = T(n) = n². Na notação Big-o a complexidade de tempo é O(n) = n². Questão 2. O sistema está estruturada com a seguinte divisão de arquivos: README.md , funcionario.c, funcionario.h e main.c. Em relação a compilação, não existe instruções de como o sistema deve ser compilado. E em ralação a TAD e a struct, existe a TAD funcionario com a struct contendo os seguintes seguintes campos: nome, cargo e documento. e existem funções para criar um novo funcionário, ordenar o vetor, exibir o menu de opções, formatar string, limpar o buffer. Questão 3. Arquivo main.c: ponteiro para ponteiro na linha 7, abertura de arquivo na linha 10 e 30, alocação dinâmica na linha 63 . Arquivo funcionario.c: declaração de struct na linha 3, alocação dinâmica na linha 10, leitura de arquivo na linha 89, alocação dinâmica na linha 103 e 134, ponteiro para ponteiro a linha 119 e escrita em arquivo na linha 160. Questão 4. Sim, a documentação é suficiente. Minha avaliação é 4. Porque falta descrever como executar o sistema, falta terminar de comentar as funções no arquivo funcionario.h e no arquivo funcionario.c falta terminar a implementação de uma função e a pela presença de um arquivo main. Questão 5. classroom-ufersa/BubbleSortEmployee#44

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 0

[GabasDev]

1- busca sequencial com strings é um algoritmo que funciona da seguinte forma, é percorrido cada elemento de um vetor onde está sendo armazenado os dados dos funcionários fazendo comparações até encontrar o nome desejado pelo usuário. Sua complexidade de tempo é O(n) no melhor melhor caso pois, só contem um laço simples de repetição portando é linear.

2- está sendo divido em três partes funcionario.h, funcionario.c e a main. Na funcionario.h está contendo todas as funções utilizadas do código com o seus paramentos, Funcionario.c é aonde está sendo feita a implementações das funções contendo uma struct tendo nome, cargo e numero do documento, na main está sendo feito um menu com 4 opções para o usuario cadastrar,buscar por nome, documento e encerrar o programa, também tem as chamadas das funções criadas tudo isso dentro de um do while com switch case. O código não está sendo compilado apresenta alguns erros na função atualizarArquivo.

3-o algoritmo está sim fazendo uso do que foi visto em sala, alocando dinamicamente na função cria funcionário também com as TADS e fazendo uso da manipulação de arquivo nas funções funcionario_salva, lerarquivo, atualizarArquivo.

4-Está bem claro, explica bem como a Busca sequencial com strings funciona, porém, faltou algo que ilustrasse melhor, daria um 4.

5-classroom-ufersa/BuscaSequencialFuncionarios#4
6-classroom-ufersa/BuscaSequencialFuncionarios#4

[roscibely]

1. 0,9
2. 1
3. 0,5
4. 0,5
5. 1
6. 0,3

[CarlosNatyel]

1. O Quicksort é um algoritmo de ordenação a onde a lista é dividida em subgrupos onde esses grupos são arrumados em relação a um pivô e depois são combinados para se obter a lista ordenada. Sua complexidade vai variar dependendo do seu pivô variando de O(n log n) nos melhores dos casos até O(n^2) nos piores casos

2. O código esta divido em três partes:
   Funcionario.c: Os dados são preenchidos e ordenados e onde ocorre a manipulação de arquivos

funcionario.h: É onde estão as definições de estrutura e os protótipos das funções utilizados no funcionario.c

main.c: É onde esta função main, o menu principal e as operações do programa.

3. Fazendo uso de structs: nas linhas 10 a 15 no funcionario.h
   Fazendo uso de alocação dinâmica : na linhas 51/132 na main.c/funcionario.c
   Fazendo o uso de aquivo: nas linhas 48/68/85/112/148 no funcionario.c

4. Avaliação nota 5
   O documento estava bem informativo e organizado , com a explicações da funções do código , instruções de como utiliza-lo, complexidade e com as vantagens e desvantagens do quicksort.

5.Melhorias no programa
Faltou uma função para que o nome e o documento aceite apenas números e letras.

6. como não deu tempo de implementar, a função era essa:

int verificaString(char nome[21])
{
int i;
for(i = 0; i < strlen(nome); i++){
if (!isalnum(nome[i]))

[roscibely]

1. 0,9
2. 0,6
3. 0,5
4. 0,5
5. 0,8
6. 0,3

[Libhinny]

1. O algoritmo se trata da busca de strings de forma sequencial, onde a implementação da busca sequencial vai inicialmente percorrer todo o vetor, com a finalidade de encontrar a string desejada. Que é o que acontece no loop presente na implementação da busca sequencial, ele faz a varredura no vetor e faz a comparação entre os elementos, se a comparação for igual a 0, ou seja, se os elementos forem iguais ele vai retornar o elemento respectivo ao índice. Já a complexidade deste sistema, que é o tempo que se leva para realizar a sua execução, se trata de uma complexidade linear, posto que ele apresenta apenas um loop com um tempo de c*n, sendo este o de maior grau apresentado. Dessa forma, temos que T(n) = O(n). E, para ambos os casos, sua complexidade será linear.

T(n) = c1 + c2n + c3n + c4n + c5
T(n) = a + bn
T(n) = b*n
T(n) = O(n)

2. O sistema está dividido em funcionario.h, o cabeçalho do sistema, onde apresenta as funções e a struct que será necessária para o armazenamento dos dados, funcionario.c que vai conter as funções expandidas, bem como a struct com os campos de nome, cargo e documento, e seu funcionamento. E a main, onde as funções são chamadas e realizando o que o sistema precisa para fazer a busca sequencial de strings.
3. Em funcionario. c, é feito o uso da alocação dinâmica, na linha 16. Na função funcionario_salva, presente na linha 31, faz-se o uso das funções de manipulação de arquivos, como fopen, fprintf, fclose, assim como na função lerarquivo, linha 54, também se vê o uso de funções presentes na manipulação de arquivos. Por fim, o sistema usa TAD ao dividir seu sistema em três arquivos: funcionario.h, funcionario.c e a main.c.
4. Numa escala de 1-5, seria 3.5, pois seria interessante incluir na documentação um exemplo de como funciona a busca sequencial além de que, apesar de sua complexidade ser linear, acredito que o cálculo presente na documentação esteja incorreto. Como i = 0, no laço, seria c2n ao invés de c2(n-1).
5. Sugestões de Melhorias BuscaSequencialFuncionarios#3 (comment)
6. https://github.com/Libhinny/BuscaSequencialFuncionarios/tree/main

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 1

[nestorfranca]

1. Primeiro o quicksort recebe 3 parâmetros, o vetor que deve ser ordenado, o número de termo que tem sua esquerda e o número termos que tem sua direita. Em seguida, é escolhido qual o pivô, que será o termo base da ordenação, após isso começa a ordenação dos termo com base no pivô, os que forem maiores que o pivô ficaram do seu lado direito e os que forem menores ficaram do seu lado direito. Quando o primeiro pivô está em seu lugar, a lista é dividida em duas, lado esquerdo e lado direito do pivô e, é aplicado a ordenação novamente, escolhendo um novo pivô e verificando se os outros termos são maiores ou menores que ele, esse processo acontece de ambos os lados de forma recursiva, ou seja, até o vetor está todo ordenado.
   No melhor caso o quicksort terá complexidade O(n log(n)), e no seu pior caso será O(n²), que será quando entrar nos dois quicksort em todos os casos.
2. o código está dividido em três arquivos, sendo eles o funcionario.h, onde se encontrada a declaração das funções e a struct que armazena os dados da execução, o Funcionario.c, que contém a implementação das funções declaradas no funcionario.h e o arquivo main.c, que é onde está a implementação do código em si e onde as funções são chamadas para execução.
3. A alocação dinâmica está sendo realizada nos arquivos main.c e Funcionario.c nas linhas 51 e 132 respectivamente com a função realloc.
   TADS foram usadas para conectar as partições do programa, que seriam os arquivos funcionario.h, Funcionario.c e main.c, e doram usados nas linhs 1, 2, 1, 1 dos três arquivos.
   A manipulação de arquivos foi realizadas nos arquivos Funcionario.c nas linhas 48, 57, 62, 68, 73, 82, 95, 96, 100, 101, 102, 105, 112 124, 139, 148, 155, 156, 161 e 165.
4. Classifico a documentação do código com 5. Está muito bem escrita e detalhada, tendo todos os parâmetros da função quicksort, além da maneira de executar o programa e as vantagens e desvantagens de seu uso.
5. Sugestão de melhorias:Sugestão de melhorias QuickSortEmployee#5
   6.LINK:https://github.com/nestorfranca/QuickSortEmployee

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 0,9

[pedrohraulino]

1 - A função Bubble Sort funciona da seguinte maneira:

Ela percorre todos os elementos de um vetor da esquerda para a direita comparando todas as strings, caso o primeiro vetor da comparação seja maior que o segundo, a função faz a troca de posições. Esse processo ocorre N vezes até que o vetor esteja completamente ordenado. A complexidade de tempo é n^2 devido a utilização de 2 laços em cascata, onde no primeiro for ele percorre o vetor e no segundo faz a comparação dos elementos.

2- O programa está dividido em 3 arquivos que devem estar juntos para que o programa obtenha sucesso na hora da execução. Estes arquivos são:

main.c Arquivo onde temos a função principal e dentro dela chamamos as demais funções presentes no arquivo funcionario.c.

funcionario.c: Nele temos a criação da estrutura das funções.
-Struct funcionario: responsável por armazenar o nome, cargo e documento do funcionário.
-void menu: Exibe no terminar as opções disponíveis no programa, são elas: Cadastrar, Listar e Sair
-Ordenar: Nesta função é onde está sendo feito o uso da Bubble Sort para fazer a ordenação da lista de funcionários presentes no arquivo.

• salvaDados: Nesta função o while percorre o arquivo para verificar se o usuário já existe, caso não exista ele armazena os dados do funcionário.
• AdicionarNovosDados: nesta função é feita a verificação se o funcionário já exista na struct, se não existir ele faz o armazenamento dos dados do novo funcionário.
• OrdenarEAtualizarArquivo: Responsável por abrir o arquivo e chamar a função ordenar para fazer a ordenação dos dados.
  -LimpaBuffer: Executa a liberação de memória ocupada pelos vetores.
  -FormatarString: Faz a estilização dos caracteres para que a primeira letra das strings sejam maiúsculas e o restante minúsculas;

funcionario.hcontém as definições de estrutura e protótipos de função utilizados em funcionario.c.

3- Arquivos
main.c linhas: 10, 30.
funcionario.c linhas: 89, 150

Alocação dinâmica:
main.c linhas: 63.
funcionario.c linhas: 10, 104, 103, 134, 135

4 - Sobre a documentação a nota que sugiro é 3, ela explica bem sobre a função mas deixa a desejar sobre outro itens do código como por explicação de funcionamento do programa e das funções

5 - Sugestão de melhoria: Apagar todo o conteúdo que está comentado no texto para ter uma melhor organização, outra sugestão é que na linha 14 função salvar dados está errada e acaba quebrando a execução inicial do programa, outra coisa que percebi é que ao ler os dados funcionário os dados estão sendo armazenados em uma variável ao invés de serem armazenados na struct. Infelizmente pela falta de tempo não é possível fazer o código rodar perfeitamente

6-https://github.com/pedrohraulino/BubbleSortEmployee.git

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 1

[diegonascimento2023]

1. O algoritmo de ordenação de strings com Bubble Sort tem como objetivo organizar em uma certa ordem uma sequencia de elementos (sejam eles números, strings e etc). A ordem pode mudar, o tipo de elemento pode mudar, porém em qualquer função que se utilize da ordenação Bubble Sort, o funcionamento nunca irá mudar. Esse tipo de ordenação funciona da seguinte maneira, ela começa examinando a sequencia de elementos da esquerda para direita, depois de verificar o primeiro elemento da sequência, ela pula para o próximo e verifica se o segundo elemento está mantendo a certa ordem que ela foi designada a ordenar os elementos. Se o segundo elemento não estiver na ordem correta ela inverta a posição do primeiro e segundo elemento, após isso ele pula para o terceiro elemento e compara com o elemento da posição dois e assim ela percorre toda a sequencia de elementos até deixar na ordem que ela foi designada a ordenar. Veja a baixo um exemplo de uma função com Bubble Sort.

void bubbleSort(int *vetor, int tamanho) {
int i, j, aux;
for (i = 0; i < tamanho; i++) {

    for (j = 0; j < tamanho - 1; j++) { 

        if (vetor[j] > vetor[j + 1]) { 

            aux = vetor[j]; 

            vetor[j] = vetor[j + 1]; 

            vetor[j + 1] = aux; 

        }

    }

}

}

A função mostrada anteriormente recebe como parâmetros um vetor de ponteiros do tipo inteiro e um tamanho também do tipo inteiro. São declaradas as varáveis que serão utilizadas nos dois laços de repetição e uma variável auxiliar, todas do tipo inteiro. O primeiro laço inicia em zero e vai até o tamanho passado com parâmetro. O segundo laço está contido no primeiro laço e vai de zero até o tamanho passado como parâmetro menos um, isso ocorre que ele percorre a sequencia uma vez a menos que o primeiro laço. Dentro do segundo laço a uma condição que verifica se o elemento que vem depois do elemento que esta na variável j é menor do que esta na posição da variável j. Se for ele armazena o elemento da posição j na variável auxiliar e o vetor da posição j recebe o elemento que está logo após o elemento da posição j. Assim como o elemento que está na posição j+1 recebe o que estava na variável auxiliar o elemento da posição j, finalizando a função. Caso não entre na condição quer dizer que os elementos estão na ordem correta. A complexidade de tempo tanto no melhor caso quanto no pior irá resultar em T(n) = O(n²), pela justificativa de que se tem dois laços de repetição onde um está contido no outro..

3. O código está estruturado em três arquivos: funcionario.c, funcionario.h e main.c. No arquivo funcionario.h estão todos os protótipos das funções, protótipo da struct funcionario e as bibliotecas inclusas no código. No arquivo funcionario.c está a struct e seus campos, a função para criar e alocar a memoria dinamicamente para armazenar os dados dos funcionarios, está também o menu com as opções que o usuário poderá executar no programa e algumas outras funçoes de ordenação, adicionar novos dados, limpar o buffer e formatar string. No arquivo main.c está a função principal para executar as funções do arquivo funcionario.c. É na main.c que é aberto o arquivo .txt que serão salvos os dados dos funcionários e são executadas as funções do menu.

4. Sim. O sistema está está fazendo o uso do que foi visto em sala o sistema divide o código em três arquivos: funcionario.c, funcionario.h e main.c, colocando em prática o que foi visto em TADs. Além disso, o sistema aloca memória de forma dinâmica no arquivo funcionario.c na linha 10 e verifica na linha 11 se a memoria foi alocada corretamente. Assim como, no arquivo main.c é aberto um arquivo .txt para alteração na linha 10 e verifica se o arquivo existe ou não. Colocando em prática uma boa parte do conteúdo visto na segunda unidade.

5. Achei a documentação fornecida boa. Porem, acredito que o código deveria ser mais bem explicado. Principalmente no que diz respeito a função que possui a ordenação Bubble Sort. Além disso, deveriam ter explicado melhor a complexidade do código.

6. Propondo melhorias BubbleSortEmployee#45

7.https://github.com/diegonascimento2023/BubbleSortEmployee/blob/main/main.c

[roscibely]

1. 1
2. 1
3. 0,5
4. 0,5
5. 1
6. 1