C Problema em c juntar listas e mais

isrnick · 30 de abril de 2020

Não é que está em direção ao centro, é que todos os valores são diferentes (não tem repetidos), e todos os valores estão inclusos no intervalo (não pula nenhum número entre o maior e o menor número), e a altura de cada ponto indica qual é maior, então acaba que o maior fica no canto superior direito e o menor no canto inferior esquerdo, com todos os outros em ordem crescente no meio (ou seja estão ordenados), o que acaba formando uma reta na diagonal.

Simon Viegas · 30 de abril de 2020

@isrnick, perfeito!!! Agora deu para entender!!!

arfneto · 30 de abril de 2020

Se fossem barras seria mais fácil de entender. São pontos no plano cartesiano (x,y) sendo classificados pelo valor de y

No eixo x tem digamos 200 pontos e as alturas deles vão de 1 a 200. O algoritmo classifica pela altura deles, que vai de 1 a 200, no exemplo. Não contei quantos são

Note que os valores vão descendo ao contrário do que uma bolha faria. Essa foi a razão da minha aposta e do lance de âncora versus bolha. Era para subir, classificando primeiro os menores.

adicionado 2 minutos depois

Na verdade os primeiros deses que vi eram com as barras mesmo, sólidas até a altura. Devem ter mudado pela performance

Simon Viegas · 30 de abril de 2020

Nesse tópico falamos um poucos sobre:

https://www.clubedohardware.com.br/forums/topic/1410608-não-consigo-implementar-o-bubble-sort-no-meu-código/

Lá tem um vídeo utilizando barras...

arfneto · 30 de abril de 2020

7 horas atrás, Simon Viegas disse:

Nesse tópico falamos um poucos sobre:

https://www.clubedohardware.com.br/forums/topic/1410608-não-consigo-implementar-o-bubble-sort-no-meu-código/

Lá tem um vídeo utilizando barras...

Muito bom! Foi nesse tópico que falei aqui desse lance âncora/bolha que eu não consigo aceitar! Grato pela lembrança

Mas o vídeo do círculo é bobinho e não ajuda nada. Nada sobre inversões e comparações. Eu acho que exatamente aquela animação da wikipedia era inicialmente feita com barras verticais e acho que alguém achou os pontos mais animados e rápidos e mudou.

O do heap hort ainda tem as barras e é genial. Mostra os segmentos e tenta de fato ensinar algo. Veja lá em https://pt.wikipedia.org/wiki/Heapsort

isrnick · 30 de abril de 2020

2 horas atrás, arfneto disse:

Foi nesse tópico que falei aqui desse lance âncora/bolha que eu não consigo aceitar!

Tem mais de um jeito de interpretar o nome Bubble Sort . Pode considerar que os elementos maiores vão flutuando para o fim da lista a cada ciclo do loop.

Ou também dá para considerar o fato de que somente 1 par de elementos adjacentes é considerada a cada operação de ordenação, ignorando o restante da lista, com se houvesse uma bolha isolando/destacando os 2 elementos adjacentes do resto da lista. Esse GIF até ilustra a suposta "bolha" em vermelho:

Matheus Maldi · 30 de abril de 2020

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char turma[100];
    char nome[100];
    int idade;
} Pessoa;

int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->idade > p2->idade)
        return 1;
    else if (p1->idade < p2->idade)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

int main()
{
    char buffer[8192];
    scanf("%s", buffer);
    
    size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        memcpy(turma1[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma1[i].nome), &(turma1[i].idade));
    }

    scanf("%s", buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);
    Pessoa* turma2 = (Pessoa*)calloc(turma2_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma2_length; i++)
    {
        memcpy(turma2[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma2[i].nome), &(turma2[i].idade));
    }

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)calloc(turma1e2_length, sizeof(Pessoa));

    memcpy(turma1e2, turma1, turma1_length * sizeof(Pessoa));
    memcpy(turma1e2 + turma1_length, turma2, turma2_length * sizeof(Pessoa));

    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_cmp);

    for (size_t i = 0; i < turma1e2_length; i++)
        printf("%s %d %s\n", turma1e2[i].turma, turma1e2[i].idade, turma1e2[i].nome);

    free(turma1);
    free(turma2);
    free(turma1e2);

    return 0;
}

Este é o Código, funcionou para o input apresentado.

arfneto · 30 de abril de 2020

50 minutos atrás, isrnick disse:

Tem mais de um jeito de interpretar o nome Bubble Sort . Pode considerar que os elementos maiores vão flutuando para o fim da lista a cada ciclo do loop.

Ou também dá para considerar o fato de que somente 1 par de elementos adjacentes é considerada a cada operação de ordenação, ignorando o restante da lista, com se houvesse uma bolha isolando/destacando os 2 elementos adjacentes do resto da lista. Esse GIF até ilustra a suposta "bolha" em vermelho

Eu sei exatamente como é. Apenas entenda que uma bolha não afunda: ela sobe porque o gás tem menor densidade. E nas implementações e desenhos clássicos do bubble sort esse par de comparações afunda ao invés de subir. É só isso.

Veja a animacão do programa que eu escrevi e vai entender. Eu implementei os dois: a âncora que afunda e a bolha que sobe. Só que a apresentação usual do bubble sort é a da "âncora" digamos.

Esse gif está na horizontal, como sabe. Se girar para o sentido horário 90 graus terá a âncora. No sentido anti-horário horário terá a bolha. Se ler o código terá quase sempre a bolha afundando, que é uma coisa que acho folclórica há décadas.

isrnick · 30 de abril de 2020

@arfneto Uma bolha não necessariamente flutua para cima, bolhas também podem afundar, depende da diferença de densidade entre os 2 fluidos.

A característica que define a existência de uma bolha é a separação/isolamento dos fluidos, ou seja o fato deles não se misturarem, e não importa a direção que se move ou se fica estática.

Ansi C · 30 de abril de 2020

2 horas atrás, isrnick disse:

Esse GIF até ilustra a suposta "bolha" em vermelho:

é uma tipo de convecção relacionada a ordem, tão somente. Ou seja...

Se crescente, o menor número tem mais energia e sobe; acontece a troca.

Se decrescente, o maior número tem mais energia e sobe; acontece a troca.

* Um estado arbitrário ocorre quando a relação de energia já está em equilibro, ou seja, o mais energético está na sua posição lógica natural e nada acontece.

Uma função com três estados (-1, 0, 1), ainda acredito que é como bolha(s).

arfneto · 30 de abril de 2020

@Matheus Maldi

typedef struct
{
    char turma[100];
    char nome[100];
    int idade;
} Pessoa;

Talvez não seja uma boa ideia replicar um código com 100 bytes em todos os alunos sabendo desde o início que são apenas DUAS turmas.

int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->idade > p2->idade)
        return 1;
    else if (p1->idade < p2->idade)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

Seu compilador não se queixou de nada tipo "unreachable code" com esse return perdido ao final do código?

size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        memcpy(turma1[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma1[i].nome), &(turma1[i].idade));
    }

    scanf("%s", buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);
    Pessoa* turma2 = (Pessoa*)calloc(turma2_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma2_length; i++)
    {
        memcpy(turma2[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma2[i].nome), &(turma2[i].idade));
    }

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)calloc(turma1e2_length, sizeof(Pessoa));

Esse trecho também pode melhorar.

Você alocou um array para a turma 1 toda, e depois volta lá apenas para replicar o código da turma que já sabia desde o início. E copia 100 bytes com o nome da turma, replicado em cada aluno ao invés de apenas um char com o índice de uma das DUAS turmas. E depois faz a mesma coisa para a turma 2 para depois copiar tudo para uma nova área alocada e começar a preencher. E só ao final libera a memória para os dois vetores que não vai usar mais.

No entanto o conceito de turma serve apenas para entrar na listagem classificada final.

Porque não usar simplesmente um indicador de a qual das duas turmas pertence o aluno? E se quer alocar dinamicamante , que não era requerimento de um exercício tão simples, porque não alocar o necessário para a turma 1, preencher e depois chamar realloc() uma única vez e reajustar o tamanho para incluir a segunda turma e terminar de preencher o vetor de alunos?

Confesso que sequer compilei seu programa, mas está certo de que ele usaria o critério de classificação que sequer foi passado para a rotina de comparação, no caso de classificar por nome de aluno?

adicionado 3 minutos depois

56 minutos atrás, isrnick disse:

A característica que define a existência de uma bolha é a separação/isolamento dos fluidos, ou seja o fato deles não se misturarem, e não importa a direção que se move ou se fica estática

Não é a questão do possível. É a questão da memória coletiva. Já entendeu o que quero dizer. Eu entendi o que quer dizer. Quando um sujeito lembra de uma bolha vai lembrar do simples: do copo de refrigerante, da champagne, da água no lago. Quando você tem uma bolha que desce você até cria um produto...

Matheus Maldi · 30 de abril de 2020

10 minutos atrás, arfneto disse:
@Matheus Maldi
typedef struct
{
    char turma[100];
    char nome[100];
    int idade;
} Pessoa;
Talvez não seja uma boa ideia replicar um código com 100 bytes em todos os alunos sabendo desde o início que são apenas DUAS turmas.
int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->idade > p2->idade)
        return 1;
    else if (p1->idade < p2->idade)
        return -1;

    return strcmp(p1->nome, p2->nome);
}
Seu compilador não se queixou de nada tipo "unreachable code" com esse return perdido ao final do código?
size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        memcpy(turma1[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma1[i].nome), &(turma1[i].idade));
    }

    scanf("%s", buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);
    Pessoa* turma2 = (Pessoa*)calloc(turma2_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma2_length; i++)
    {
        memcpy(turma2[i].turma, buffer, 100 * sizeof(char));
        scanf("%s%d", &(turma2[i].nome), &(turma2[i].idade));
    }

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)calloc(turma1e2_length, sizeof(Pessoa));
Esse trecho também pode melhorar.

Você alocou um array para a turma 1 toda, e depois volta lá apenas para replicar o código da turma que já sabia desde o início. E copia 100 bytes com o nome da turma, replicado em cada aluno ao invés de apenas um char com o índice de uma das DUAS turmas. E depois faz a mesma coisa para a turma 2 para depois copiar tudo para uma nova área alocada e começar a preencher. E só ao final libera a memória para os dois vetores que não vai usar mais.

No entanto o conceito de turma serve apenas para entrar na listagem classificada final.

Porque não usar simplesmente um indicador de a qual das duas turmas pertence o aluno? E se quer alocar dinamicamante , que não era requerimento de um exercício tão simples, porque não alocar o necessário para a turma 1, preencher e depois chamar realloc() uma única vez e reajustar o tamanho para incluir a segunda turma e terminar de preencher o vetor de alunos?

Confesso que sequer compilei seu programa, mas está certo de que ele usaria o critério de classificação que sequer foi passado para a rotina de comparação, no caso de classificar por nome de aluno?

Coloquei 100 caracteres para o titulo da TURMA, devido a falta o enunciado, mas precavi que poderia ser passado em vez de TURMA1 e TURMA2 for passado MATEMATICA e FISICA

Seu compilador não se queixou de nada tipo "unreachable code" com esse return perdido ao final do código?

Se a idade for IGUAL, não vai entrar em nenhum dos IFs, ele returna a comparação do texto. o Codigo é localizavel.

Referente a alocação da turma, está certo, tem excesso de copias.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char* turma;
    char nome[100];
    int idade;
} Pessoa;

int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->idade > p2->idade)
        return 1;
    else if (p1->idade < p2->idade)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

int main()
{
    char turma1_buffer[100];
    scanf("%s", turma1_buffer);
    
    size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        turma1[i].turma = turma1_buffer;
        scanf("%s%d", &(turma1[i].nome), &(turma1[i].idade));
    }

    char turma2_buffer[100];
    scanf("%s", turma2_buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);
    Pessoa* turma2 = (Pessoa*)calloc(turma2_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma2_length; i++)
    {
        turma2[i].turma = turma2_buffer;
        scanf("%s%d", &(turma2[i].nome), &(turma2[i].idade));
    }

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)calloc(turma1e2_length, sizeof(Pessoa));

    memcpy(turma1e2, turma1, turma1_length * sizeof(Pessoa));
    memcpy(turma1e2 + turma1_length, turma2, turma2_length * sizeof(Pessoa));

    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_cmp);

    for (size_t i = 0; i < turma1e2_length; i++)
        printf("%s %d %s\n", turma1e2[i].turma, turma1e2[i].idade, turma1e2[i].nome);

    free(turma1);
    free(turma2);
    free(turma1e2);

    return 0;
}

isrnick · 30 de abril de 2020

@arfneto Eu penso na bolha de sabão e a direção muda dependendo do gás que põe dentro.

E quem deu o nome foram os americanos que usam bolha (Bubble) cotidianamente para indicar isolamento, tem até uma expressão "living in a bubble" (vive numa bolha) para indicar alguém vivendo fora da realidade.

arfneto · 30 de abril de 2020

6 minutos atrás, Matheus Maldi disse:

Coloquei 100 caracteres para o titulo da TURMA, devido a falta o enunciado, mas precavi que poderia ser passado em vez de TURMA1 e TURMA2 for passado MATEMATICA e FISICA

Seu compilador não se queixou de nada tipo "unreachable code" com esse return perdido ao final do código?

Se a idade for IGUAL, não vai entrar em nenhum dos IFs, ele returna a comparação do texto. o Codigo é localizavel.

Referente a alocação da turma, está certo, tem excesso de copias

Sugiro considerar realloc() para a alocação depois de ler o tamanho da segunda turma. E pode usar algo simples como

    char    turma[2][20]; // as turmas

para salvar os nomes das turmas e gravar apenas o índice na estrutura de alunos. Na hora de mostrar a tabela classificada você usa esse índice para acessar a modesta tabela onde estão os nomes das classes como foram lidos

E talvez deva rever quanto à classificação por nome...

Matheus Maldi · 30 de abril de 2020

6 minutos atrás, arfneto disse:
Sugiro considerar realloc() para a alocação depois de ler o tamanho da segunda turma. E pode usar algo simples como
    char    turma[2][20]; // as turmas
para salvar os nomes das turmas e gravar apenas o índice na estrutura de alunos. Na hora de mostrar a tabela classificada você usa esse índice para acessar a modesta tabela onde estão os nomes das classes como foram lidos

Com realoc, reduzindo grande quantidade de código:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char* turma;
    char nome[100];
    int idade;
} Pessoa;

int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->idade > p2->idade)
        return 1;
    else if (p1->idade < p2->idade)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

int main()
{
    char turma1_buffer[100];
    scanf("%s", turma1_buffer);
    
    size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        turma1[i].turma = turma1_buffer;
        scanf("%s%d", &(turma1[i].nome), &(turma1[i].idade));
    }

    char turma2_buffer[100];
    scanf("%s", turma2_buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)realloc(turma1, sizeof(Pessoa) * (turma1e2_length));

    for (size_t i = turma1_length; i < turma1e2_length; i++)
    {
        turma1e2[i].turma = turma2_buffer;
        scanf("%s%d", &(turma1e2[i].nome), &(turma1e2[i].idade));
    }

    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_cmp);

    for (size_t i = 0; i < turma1e2_length; i++)
        printf("%s %d %s\n", turma1e2[i].turma, turma1e2[i].idade, turma1e2[i].nome);

    free(turma1e2);

    return 0;
}

arfneto · 30 de abril de 2020

1 hora atrás, Matheus Maldi disse:

Com realoc, reduzindo grande quantidade de código:

Muito melhor parece. E bem mais legível que antes. Para usar o código e classificar por nome usando qsort() acho que vai precisar de uma gambiarra como uma variável global com o critério de classificação

Matheus Maldi · 30 de abril de 2020

8 minutos atrás, arfneto disse:

Muito melhor parece. E bem mais legível que antes. Para usar o código e classificar por nome usando qsort() acho que vai precisar de uma gambiarra como uma variável global com o critério de classificação

Não precisa, o algoritmo que fiz está ordenando perfeitamente, primeiro os numeros e se forem igual por nome.

arfneto · 30 de abril de 2020

agora, Matheus Maldi disse:

Não precisa, o algoritmo que fiz está ordenando perfeitamente, primeiro os numeros e se forem igual por nome

Acho que não entendeu essa parte: se o critério for "nome" classifica a lista por nome do aluno

adicionado 2 minutos depois

Assim foi definido

Matheus Maldi · 30 de abril de 2020

16 minutos atrás, arfneto disse:

Acho que não entendeu essa parte: se o critério for "nome" classifica a lista por nome do aluno

Se o criterio fosse nome e depois idade(aquele inteiro considerei como idade):

int pessoa_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;
	
    int strcmp_result = strcmp(p1->nome, p2->nome);
    if (strcmp_result > 0)
        return 1;
    if (strcmp_result < 0)
        return -1;

    if (p1->idade > p2->idade)
        return 1;
    if (p1->idade < p2->idade)
        return -1;

    return 0;
}

Bom, acho que está havendo algum mal entendido, mas considerando o codigo original, considere a entrada:

//////  ENTRADA:
TURMA1
2
TIAGO 3
ANA 9
TURMA2
3
MARCELO 3
CAROL 10
JOSE 3

/////  SAIDA:

TURMA2 3 JOSE
TURMA2 3 MARCELO
TURMA1 3 TIAGO
TURMA1 9 ANA
TURMA2 10 CAROL

Ele ordenou primeiro pelo numero, e depois pelo nome

isrnick · 30 de abril de 2020

@Matheus Maldi

Você não considerou o último comando da imagem da entrada onde está escrito "cod" esse comando serve para dizer que deve ordenar pelo código (idade no seu caso), alternativamente ao invés de "cod" poderia escolher digitar "nome" e nesse caso indicaria para o programa ordenar por nome.

Leia o enunciado completo postado pela Julia Leite:

Note também que cod é um identificador único, então não terá 2 cods iguais (o que não é o caso de idade).

Matheus Maldi · 30 de abril de 2020

6 minutos atrás, isrnick disse:

@Matheus Maldi

Você não considerou o último comando da imagem da entrada onde está escrito "cod" esse comando serve para dizer que deve ordenar pelo código (idade no seu caso), alternativamente ao invés de "cod" poderia escolher digitar "nome" e nesse caso indicaria para o programa ordenar por nome.

Leia o enunciado completo postado pela Julia Leite:

É realmente, não havia lido enunciado. Agora sim:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char* turma;
    char nome[100];
    int cod;
} Pessoa;

int pessoa_cod_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->cod > p2->cod)
        return 1;
    if (p1->cod < p2->cod)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

int pessoa_nome_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    int nome_cmp = strcmp(p1->nome, p2->nome);

    if (nome_cmp > 0)
        return 1;
    if (nome_cmp < 0)
        return -1;

    if (p1->cod > p2->cod)
        return 1;
    if (p1->cod < p2->cod)
        return -1;

    return 0;
}

int main()
{
    char turma1_buffer[100];
    scanf("%s", turma1_buffer);

    size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        turma1[i].turma = turma1_buffer;
        scanf("%s%d", turma1[i].nome, &(turma1[i].cod));
    }

    char turma2_buffer[100];
    scanf("%s", turma2_buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)realloc(turma1, sizeof(Pessoa) * (turma1e2_length));

    for (size_t i = turma1_length; i < turma1e2_length; i++)
    {
        turma1e2[i].turma = turma2_buffer;
        scanf("%s%d", turma1e2[i].nome, &(turma1e2[i].cod));
    }
    char prioridade[20];
    scanf("%s", prioridade);

    if (strcmp("COD", prioridade) == 0)
        qsort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_cod_cmp);
    else if (strcmp("NOME", prioridade) == 0)
        qsort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_nome_cmp);

    for (size_t i = 0; i < turma1e2_length; i++)
        printf("%s %d %s\n", turma1e2[i].turma, turma1e2[i].cod, turma1e2[i].nome);

    free(turma1e2);

    return 0;
}

arfneto · 30 de abril de 2020

43 minutos atrás, Matheus Maldi disse:

Bom, acho que está havendo algum mal entendido, mas considerando o codigo original, considere a entrada

Sim.

Eu postei o link para o enunciado. @isrnick reproduziu o enunciado. E você cortou parte da amostra de execução, aquela diminuta onde está escrito cod.

Eu sei que se inverter sua condição de comparação vai comparar, digamos, invertido . Mas precisa injetar o critério de classificação lá. Ou trocar a rotina de comparação simplesmente. Só isso já serve:

if ( criterio == NOME)
    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), comapara_nome);
else
    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), comapara_cod);

E eu sei que é só um exemplo, mas sabe que o enunciado especifica o uso de Bubble Sort para classificar os alunos...

adicionado 1 minuto depois

pois é... simples assim

Matheus Maldi · 30 de abril de 2020

1 minuto atrás, arfneto disse:
Sim.

Eu postei o link para o enunciado. @isrnick reproduziu o enunciado. E você cortou parte da amostra de execução, aquela diminuta onde está escrito cod.

Eu sei que se inverter sua condição de comparação vai comparar, digamos, invertido . Mas precisa injetar o critério de classificação lá. Ou trocar a rotina de comparação simplesmente. Só isso já serve:
if ( criterio == NOME)
    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), comapara_nome);
else
    qsort(turma1e2, turma1e2_length, sizeof(Pessoa), comapara_cod);
E eu sei que é só um exemplo, mas sabe que o enunciado especifica o uso de Bubble Sort para classificar os alunos...

Eu não havia lido o enunciado. Fiz exatamente isso no post anterior.

Bom, acha de devo escrever um bubble sort genérico?

arfneto · 30 de abril de 2020

8 minutos atrás, Matheus Maldi disse:

Eu não havia lido o enunciado. Fiz exatamente isso no post anterior.

Bom, acha de devo escrever um bubble sort genérico?

sim eu vi quando voltou a imagem do meu post e por isso postei aquilo um minuto depois...

Eu postei um link para uma coisa assim que eu postei meses atrás, que tem até uma animação das inversões e comparações em duas modalidades. Está no #18 aqui acima. E no #20 @Simon Viegas reproduziu exatamente o trecho daquele exemplo que eu escrevi, no #20. Então juntando o que você postou e o que está lá acho que é um bom material.

Talvez a gente deva esperar o autor postar algum tipo de nova dúvida ou o andamento do código da parte do do autor

Essa implementação não é a convencional

int bubbleUp_sort(int vetor[], int N)
{
   int passo, elemento, temp;
  
   for (passo = 0; passo < N - 1; passo = passo + 1)
   {
      int mudou_algo = 0;
      
      for (elemento = N - 1; elemento > passo; elemento = elemento - 1)
      {
         if (vetor[elemento] < vetor[elemento - 1])
         {
            temp = vetor[elemento];
            vetor[elemento] = vetor[elemento - 1];
            vetor[elemento - 1] = temp;
            mudou_algo = 1;
         }
      }
   
      if (mudou_algo == 0)
         return passo + 1;
    }
  
   return passo + 1;
};

E sim essa


int		bubble_sort(int vetor[], int N)
{
	int passo, elemento, temp;
	for (passo = 0; passo < N - 1; passo = passo + 1)
	{
		int mudou_algo = 0;	// se nao muda nada no passo ja terminou
		for (elemento = 0; elemento < (N - 1 - passo); elemento = elemento + 1)
		{
			if (vetor[elemento] > vetor[elemento + 1])
			{
				temp = vetor[elemento];
				vetor[elemento] = vetor[elemento + 1];
				vetor[elemento + 1] = temp;
				mudou_algo = 1;
			}	// if
		}	// for
		if (mudou_algo == 0)
			return passo + 1;	// economizou uns passos
	}	// for
	return passo + 1;
};

As duas funcionam no entanto.

Matheus Maldi · 30 de abril de 2020

O desafio está completo

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct
{
    char* turma;
    char nome[100];
    int cod;
} Pessoa;

int pessoa_cod_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    if (p1->cod > p2->cod)
        return 1;
    if (p1->cod < p2->cod)
        return -1;

    return strcmp(p1->nome, p2->nome);
}

int pessoa_nome_cmp(const void* pessoa1, const void* pessoa2)
{
    Pessoa* p1 = (Pessoa*)pessoa1;
    Pessoa* p2 = (Pessoa*)pessoa2;

    int nome_cmp = strcmp(p1->nome, p2->nome);

    if (nome_cmp > 0)
        return 1;
    if (nome_cmp < 0)
        return -1;

    if (p1->cod > p2->cod)
        return 1;
    if (p1->cod < p2->cod)
        return -1;

    return 0;
}

static inline void swap (void* l, void* r, size_t size)
{
    char *l_ptr = l, *r_ptr = r;
    do
    {
        char tmp = *l_ptr;
        *l_ptr++ = *r_ptr;
        *r_ptr++ = tmp;
    } while (--size > 0);
}

void bubble_sort (const void * pbase, size_t total_elems, size_t size_of_elem,
     int (*cmp)(const void*, const void*))
{
    if (total_elems < 1)
        return;

    void* last = (void*)pbase + (total_elems * size_of_elem) - size_of_elem;

    for (void* curr = (void*)pbase; curr < last; curr += size_of_elem)
    {
        void* next = curr + size_of_elem;
        if (cmp(curr, next) > 0)
            swap(curr, next, size_of_elem);
    }
    bubble_sort(pbase, total_elems - 1, size_of_elem, cmp);
}


int main()
{
    char turma1_buffer[100];
    scanf("%s", turma1_buffer);

    size_t turma1_length;
    scanf("%lu", &turma1_length);
    Pessoa* turma1 = (Pessoa*)calloc(turma1_length, sizeof(Pessoa));

    for (size_t i = 0; i < turma1_length; i++)
    {
        turma1[i].turma = turma1_buffer;
        scanf("%s%d", turma1[i].nome, &(turma1[i].cod));
    }

    char turma2_buffer[100];
    scanf("%s", turma2_buffer);
    size_t turma2_length;
    scanf("%lu", &turma2_length);

    size_t turma1e2_length = turma1_length + turma2_length;
    Pessoa* turma1e2 = (Pessoa*)realloc(turma1, sizeof(Pessoa) * (turma1e2_length));

    for (size_t i = turma1_length; i < turma1e2_length; i++)
    {
        turma1e2[i].turma = turma2_buffer;
        scanf("%s%d", turma1e2[i].nome, &(turma1e2[i].cod));
    }
    char prioridade[20];
    scanf("%s", prioridade);

    if (strcmp("COD", prioridade) == 0)
        bubble_sort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_cod_cmp);
    else if (strcmp("NOME", prioridade) == 0)
        bubble_sort(turma1e2, turma1e2_length, sizeof(Pessoa), pessoa_nome_cmp);

    for (size_t i = 0; i < turma1e2_length; i++)
        printf("%s %d %s\n", turma1e2[i].turma, turma1e2[i].cod, turma1e2[i].nome);

    free(turma1e2);

    return 0;
}