arfneto

Sim, está invertido. 18 é o máximo: 2 * 9 = 18. E se os ms forem importantes pode evitar a divisão escrevendo soma_par += parcela % 10; if (parcela >= 10) soma_par += 1; já que se a parcela for maior que 9 pode ser apenas 2*5 = 10 2*6 = 12 2*7 = 14 2*8 = 16 2*9 = 18

acho mesmo que papel e caneta seriam o melhor começo, como os pedaços que mostrei, com o perdão da letra ruim. Quando você tem um algoritmo que dá pra reproduzir assim o caminho mais simples é treinar um pouco. ANTES de escrever um programa Sem considerar o número fixo de 4 dígitos e sem considerar o número em si, ganhei uma aposta com o programa abaixo. Ele calcula o dígito para qualquer comprimento sem saber qual era o número É só um brinquedo. Teste com a conta do banco #include <stdio.h> #include <string.h> int main(int argc, char** argv) { int digito = 0; char valor = 0; int soma_par = 0; int peso_par = 1; int soma_impar = 0; int peso_impar = 2; int parcela = 0; printf("Entre com o numero e tecle ENTER: "); while (valor != '\n') { valor = getc(stdin); if (valor < '0') break; if (valor > '9') break; digito = valor - '0'; parcela = digito * peso_par; if (parcela >= 10) // soma os digitos se for > 10 soma_par += parcela / 10 + parcela % 10; else soma_par += parcela; if (peso_par == 2) // gira os pesos peso_par = 1; else peso_par = 2; parcela = digito * peso_impar; if (parcela >= 10) // soma os digitos se for > 10 soma_impar += parcela / 10 + parcela % 10; else soma_impar += parcela; if (peso_impar == 2) // gira os pesos peso_impar = 1; else peso_impar = 2; }; // while() // peso_impar comeca de 2 // se peso impar = 2 entao era um numero par de digitos: 1212 // vamos usar a soma_par para calcular o DV if (peso_impar != 2) soma_par = soma_impar; digito = soma_par % 10; if (digito > 0) digito = 10 - digito; printf("DV = %d\n", digito); return 0; }; // main() Postei porque é só um exemplo e o cálculo já está acima em papel. Apesar de funcionar claro para 4 dígitos não há necessidade de escrever assim se sabe que o número de dígitos é par. Se alguém ficou curioso, o problema de atribuir os pesos da direita para a esquerda e não o contrário fica claro no programa acima: se os pesos fossem, atribuídos da direita para a esquerda não seria preciso manter as duas somas: bastaria alternar os pesos. Pode considerar somar assim if (parcela >= 10) // soma os digitos se for > 10 soma_par += parcela / 10 + parcela % 10; else soma_par += parcela; um pouco mais legível. adicionado 2 minutos depois E não precisa do %10 na primeira linha porque result[0] é no máximo 81 certo?

Olá Seu problema não é com a linguagem ainda. Apenas com o método. Antes de programar você devia pegar uma folha de papel e tentar alguns cálculos. Isso faria sua vida mais simples. módulo 10 e módulo 11 são os métodos mais comuns de calcular DV em uso. Pode conferir com sua conta no banco que usa módulo 10 e seu CPF que usa módulo 11. Postei uns cálculos para o CPF como parte de um exemplo de uso de scanf() meses atrás aqui se quiser ver o outro lado. A diferença entre os dois é que módulo 11 usa pesos crescentes e módulo 10 usa pesos 2 e 1 alternados. Módulo 11 soma os valores e módulo 10 soma os dígitos das parcelas ok ok off-topic . Era só uma referência. De volta ao módulo 10 e a folha de papel Para 1234 Para 56789 Entenda que os pesos são alternados, 2 e 1 a partir da direita. Uma sacanagem do ***** que deixou isso ficar comum porque se fosse a partir da esquerda seria muito mais simples: não faria diferença o número de dígitos. Então seguindo o exemplo: você aplica os pesos da direita para a esquerda, a partir das unidades. Primeiro peso = 2 você multiplica os dígitos pelos pesos e consegue os produtos, uma para cada dígito você soma os produtos, só que soma OS DÍGITOS então 18 vira 1+8 - 9, 14 vira 5 e 10 vira 1 a soma você calcula o resto módulo 10, um jeito chique de dizer que você pega a unidade e aí calcula o dígito que é zero se o resto for 0 ou 10 - o resto nos outros casos. Se o autor colocou todo o enunciado quero cumprimentar o gênio que escreveu esse exemplo Não é sempre que a gente vê um exemplo que não mostra o resultado ou nada a respeito do tal 1588!!! Para 1588 Veja se ficou mais claro assim. E se precisa de algo com a programação podemos continuar ajudando. Já ganhei uma aposta com isso adicionado 1 minuto depois Estava no caminho certo até a conta 8*1 = 1

Não. Não. Nem me importo com essas coisas. Mas eu instalei e usei minimamente e achei bem modesto. O IDE. O compilador gcc pode ser um inferno ou um bônus dependendo do contexto. Mais para inferno mesmo. CL é o óbvio se escreve para Windows e precisa simplesmente entregar o trabalho e receber. Eu não conhecia sequer o ambiente do Code::Blocks até o ano passado. Fui a conhecer de ler pessoas falando disso aqui neste forum. Tentei usar e não me causou assim uma boa impressão. Parece antiquado e lento. E estou acostumado a facilidades e dificuldades de outros ambientes que sou obrigado a usar. E o ambiente do Visual Studio da Microsoft para desenvolver para Windows da Microsoft integrado ao GitHub, que agora é da Microsoft é algo digamos sólido. É muito produtivo. O debugger é muito bom. O ambiente tem de tudo. Refactoring pode não ser como os do IntelliJ mas é ok. IntelliSense é o máximo. Live Share para rever um projeto com até 30 caras em tempo real vendo o mesmo código pode não ser o CISCO WEbEx mas é bem interessante. E se você usa isso é maior a chance de se comunicar com alguém para escrever algo porque do outro lado também deve ter isso, seja num banco, numa indústria ou na NASA. Usei Dev-C++ e me pareceu muito mais rápido e interessante. Mas se você usa Eclipse ou Netbeans porque é o IDE do cliente, ou Visual Studio, Ou IDEA ou o super moderno VS Code fica difícil se emocionar pleo Code::Blocks. Mesmo editores como Sublime Text e Atom, alguma disciplina e um grupo de Makefiles são uma opção, eu acho. Mas Visual Studio com um emulador do vi do Linux como o https://marketplace.visualstudio.com/items?itemName=JaredParMSFT.VsVim é o ambiente que eu usaria no Windows se pudesse escolher. Para hobby ou para estudantes provavelmente Visual Studio Code tem a interface mais legal. E tem outras vantagens se usar WSL. E o CLion se tiver acesso na escola pode ser uma grande aposta. A empresa que escreve isso escreve para desenvolvedores. E são muito muito bons. Parece que eles adivinham as coisas de que você precisa num projeto, os caras da JetBrains. Só é um pouco caro. Quase 9 dólares por mes para uso individual quando você pode ter Visual Studio Community por nada. VS Enterprise custa em torno de $45

@isrnickImagino que não tenha lido o que escrevi acima. A versão 20.03 saiu em 19 de março de 2020. Por falar na distribuição nuwen, direto da documentação: Para quem está aprendendo C++ e usa Windows o autor da distribuição recomenda o simples: usar 2 compiladores. A última versão de gcc e a de MS Visual C++. O jeito mais simples de ter o compilador da Microsoft é baixar Microsoft C++ Build Tools. Claro que o Visual Studio pode incluir o compilador C/C++, basta marcar no formulário Mas para quem precisa apenas do compilador essa é a opção recomendada. Pela Microsoft. O lar do gcc é https://gcc.gnu.org/install/binaries.html @vangodp Acho que sabe a diferença entre Releases e Nightly Builds. Isso aqui abaixo está lá no site do Code::Blocks hoje e o passado não vai mudar: Ninguém faz nada sério com Nightly Builds... Bem, até onde eu sei. E se tivesse nesses 3 anos algo de qualidade para liberar você deve imaginar que os autores o teriam feito entre 2017 e 2020. Por exemplo atualizar para uma versão compilada usando uma versão mais atual de wxWidgets que era o freio mais óbvio na performance do Code::Blocks E incluir versões mais novas de gcc teria sido uma cortesia pelo menos. Isso acho uma preguiça sem tamanho, porque mudar o download a cada versão maior de gcc não seria assim difícil. E deixar para o usuário é um sinal de descaso: até a versão 20 sempre incluia o gcc 5 Se isso conta, então estou errado. Me desculpe. Na verdade eu não me lembro de problemas mesmo. Ao menos de problemas causados pelo compilador e não por mim ou pelos projetos em si. Mas nesses casos são coisas para Linux desenvolvidas em Linux. Mas a partir de um problema de usuário desse forum tive um problema do com o gcc em Windows e deixei pra lá. Tudo em torno de usar clock_gettime(); e timespec. Claro que o equivalente timespec_get(); funciona perfeitamente em Windows e deixei pra lá. Não gosto de perder mas era algo secundário e eu desisti de tentar usar essa função ou alguma irmã no gcc em Windows. E também um programa de décadas atrás que chama muitas funções de console como FillConsoleOutputAttribute() e eu deixei pra lá. O problema do usuário não era esse e eu confesso que DESISTI dos dois casos. É o mesmo caso no mundo acadêmico. Visual Studio é a ferramenta comum. Em pesquisa e na indústria muitos usam as ferramentas da Intel e os kits SDK das GPU claro. E o Qt Creator no caso dos clientes do framework, que não são poucos, como no mundo automotivo e de instrumentação. E tem as empresas clientes da Embarcadero, que tem acesso ao C++ Builder, bem refinado por sinal. O VCL é um conceito e tanto. No mundo dos games acho que não muda muito também já que os engines gravitam todos em torno de DirectX e builds especializados dentro do Visual Studio. Claro, tem ferramentas alternativas excelentes, mas não acho que Code::Blocks entraria em nenhum lugar. Nunca vi ao menos. Mesmo nos cursos iniciais no Brasil eu acho estranho. Não sei explicar. Eclipse e Netbeans são muito bons e você pode encontrar empresas usando. E se pode usar de graça Visual Studio Code é algo interessante e vem ganhando usuários muito rápido nos cursos e escolas. As ferramentas de debug multiplataforma são impressionantes. Há muito material online sobre isso. Você pode escrever para Linux ou Mac no Windows, usar o debugger do Linux ou do Windows, e fazer umas coisas impressionantes mesmo com Windows e WSL por exemplo. E como é grátis e o mercado de extensões é aberto já tem centenas delas. Lembra o ecossistema npm/node. Claro, muito longe ainda. JetBrains cria IDEs fantásticos e agora você pode usar CLion. E para escolas é grátis, então seria uma opção a considerar. Eu uso O IDEA, IDE para java, e é muito produtivo. E todo mundo usa. Imagino que CLion seja do mesmo nível. Nunca usei na verdade, mas imagino que empresas que usam IDEA e java vão passar a usar CLion ou ao menos testar para desenvolver em C++. A licença adicional é barata e tem um preço para poder todos os IDE JetBrains com uma licença só. Eu sei que nunca entrei em um banco, uma indústria ou universidade que não usasse largamente Visual Studio em Windows. Não vou dizer há quanto tempo entro nesses lugares para estudar, ensinar ou prestar serviço para não ficar deprimido. Ainda mais hoje em dia com essa história de pandemia e grupos de risco E nunca entrei em uma empresa, mesmo um escritório pequeno de contabilidade ou algo assim, que usasse code:Blocks para algo.

Se você instalou depois de 2017 e antes de 19 de março de 2020 o compilador incluído era o 5.1. Esse ambiente não é atualizado com frequência como vê... Podia ter perguntado em qual versão foi compilado o exemplo pelo autor do post. Seria o simples. Era o CL 19.25 o compilador Se não mudou a versão do compilador ou não instalou outro, já sabe qual teria: 5.1 até 19 de março ou 8.2. Eu instalei esses outro dia nesse Code::Blocks por causa de uma questão de um usuário nesse mesmo forum e por isso ainda estão nessa máquina que uso. E por isso me lembro Não. Não é. Apenas o ambiente de trabalho no Windows. E por isso evito mudanças. Ou usar máquinas que tenham coisas de clientes. Não tenho problemas com elas mesmo. Mas não tenho problemas no Windows também.

???? Nenhum comentário? Não rodou em sua máquina? Se está preocupado com os warnings mude o tipo do parâmetro em seu arquivo. Eu me prometi usar sempre o mesmo ambiente quando uso o forum, e não usar outros compiladores. Apesar de não me importar muito com Warnings meu compilador parece satisfeito com esseE aqui roda sem problemas. Uso sempre Windows 10 e Visual Studio Claro que em tempos de confinamento e para checar uma dúvida de um usuário aqui acabei instalando um certo Dev-C++ e um Code::Blocks e gcc 5.1 e 8.2. Mas daí a eu usar será outro passo... Tenho máquinas Linux aqui. Meu servidor VOIP fica na mesma mesa até e roda Centos. Tem SUSE e UBUNTU no WSL, tem o bd com UBUNTU 18 ou 17 sei lá, mas não quero mexer nessas máquinas. Então uso só essa velhinha aqui com VS Code e Visual Studio mesmo. Quando escrevo algo e posto nesse forum sempre é a partir dessa máquina. Se deixo o programa online apenas posto o link do git porque meu ambiente já deia o programa lá então não preciso fazer nada. Mas talvez fosse legal usar só Linux e gcc e postar os programas e o makefile como nos velhos tempos. Exceto que nos velhos tempos não tinha esse lance de postar

Esse não é um site de "desafios". Há muitos desses online com problemas mais complexos e possivelmente interessantes. Trata-se aqui apenas de ajudar o autor, autora @Julia Leite, em um exercício para iniciantes, que lê duas listas com os mesmos atributos e classifica o resultado do conjunto de dados na saída. Não era o caso de escrever versões do programa e postar antes dela postar algo mais concreto do que ela est;a escrevendo. Os moderadores muitas vezes removem esses tópicos. Mas mostrou uma solução boa eu acho. No entanto para o tipo de enunciado talvez não fosse o caso de usar coisas como ponteiros const void, casts complicados, funções inline estáticas e coisas assim. Ainda que façam parte de seu dia a dia acho que provavelmente é melhor usar um vocabulário mais reduzido de comandos e expressões. size_t pouco acrescenta a um iniciante exceto talvez mais uma dúvida. E para um problema tão simples declarar funções como static inline void apenas para trocar dois elementos de posição pode ser um exagero. Não me leve a mal. É só um palpite num forum de palpites. Eu escrevi ontem um programa desses completo. Dividi o progresso em 5 fases para que fosse fácil de entender. Mas não postei nenhuma das 5 porque acho que pode nem ser preciso. Quando eu tenho tempo em geral eu faço isso adicionado 7 minutos depois Para um programa de 150 linhas poderia postar aqui ao menos em linhas gerais e poderia ajudar alguém... Esse trecho abaixo é bem parecido com a primeira versão postada por @Matheus Maldi a tarde. E vou perguntar a mesma coisa //ler nome da turma scanf("%s", turma); // quantidade de alunos na turma scanf("%d",&TAM1); t1 = malloc(TAM1*sizeof(Aluno)); for(i=0;i<TAM1;i++){ leAluno(&t1[i]); strcpy(t1[i].turma, turma); } //ler nome da turma scanf("%s", turma); // quantidade de alunos na turma scanf(" %d",&TAM2); t2 = malloc(TAM2*sizeof(Aluno)); for(i=0;i<TAM2;i++){ leAluno(&t2[i]); strcpy(t2[i].turma, turma); } //Unir as duas turmas em uma unica lista: // quantidade de alunos TAMu = TAM1 + TAM2; tu = malloc(TAMu*sizeof(Aluno)); //Copia t1 for(i=0;i<TAM1;i++){ tu[i] = t1[i]; } //Copia t2 for(i=TAM1;i<TAMu;i++){ tu[i] = t2[i-TAM1]; } Para que alocar memória e ler as duas turmas em separado e depois alocar outra estrutura e copiar tudo de novo? A separação entre as turmas é irrelevante: pelo contrário elas serão reunidas para classificar e mostrar os resultados em ordem, com todos os alunos. É mais simples alocar o necessário na primeira vez, carregar os alunos, ler o tamanho da segunda turma, redimensionar a área para o total geral de alunos usando uma única chamada a realloc() e continuar lendo. Só isso. Como @Matheus Maldi fez na segunda versão. E você não liberou a área correspondente a nenhum dos 3 vetores. É um programa para estudantes e podem perder pontos ao não fazer isso ao final...

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.

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

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

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

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 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 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...

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.

Devo lembrar que além de programadores de profissão existem doutores e pesquisadores em estruturas de dados, programação, linguagens, algoritmos, lógica e matemática. Há muito software é ciência. E estruturas de dados e Álgebra antes disso. Para seu registro George Boole, um ícone da lógica a ponto de ter a lógica binária conhecida como álgebra de Boole, em 1840 foi condecorado por seus trabalhos em Lógica. Veja em BrasilEscola pode ser sugestivo. Bem antes dos computadores e de seus ilustres leitores. Se apresentar para os ilustres doutores em química ao julgar essa questão, talvez. Afinal aparentemente não estudou ou dá valor a isso como ciência. Já abriu um livro de estrutura de dados? Lógica? Análise? Desenvolvimento de sistemas complexos em grupos? Em linguagens como C++ e java essas funções retornam sempre verdadeiro ou falso e assim o autor imaginou aqui. Podia ter usado 3 estados, mas só para complicar a vida de todo mundo que chama isso. Você sabe o que é um rvalue? Uma simplificação seria dizer que é algo que pode ser usado em uma expressão. Um if não pode. Uma função que retorna um entre 3 estados também não. Usar isso criaria um problema. Esse já é novamente um tom que eu acho arrogante. Eis a realidade de quem usa isso: lista_vazia(NULL) retornar false para lista vazia é simples filosofia e é perigoso porque leva a conclusões nocivas por parte de quem chamou. O programa vai cancelar logo mais por uma razão que você vê claramente e que pode levar usuários a "fazer você andar descalço no alfalto. Ou pode custar seu emprego. Ou seu estágio. Ou o seu pagamento. Por outro lado retornar true pode levar simplesmente o cara a chamar insere() na próxima linha, e insere() pode implicitamente criar a lista quando o ponteiro for nulo. Não por acaso muitas versões de insere() devolvem o novo endereço da lista como parâmetro, assim como criar(). É o inofensivo. Software é caro. Cancelar um programa é caro. E como eu te expliquei a conta fecha de modo mais simples fazendo assim: em geral essas funções não são escritas por quem usa e tem uma reputação a zelar, e não é junto aos doutores em física: é junto a quem usa, ou a quem paga. Como eu te disse, é o comum. Na prática. As listas são implementadas assim pelas razões que tentamos te explicar. Sua opinião não duraria nada na prática ou na academia. A menos que fosse para os seus doutores ilustres imagino. Isso não me parece educado, mas não sou moderador. Acho que sequer leu o enunciado direito, porque nesse caso a lista é estática: não há alocação de memória. Por isso acho que você só quer mostrar um ponto. Entendo. Mesmo que tenha escrito "consiente" adicionado 5 minutos depois Sim. Em geral dá certinho. Inserir retorna o novo endereço da lista e em muitos casos sequer há uma função para criar a lista. A operação é implicitamente executada ao tentar adicionar o primeiro elemento. Tem gente que acha desnecessário ter uma função para criar a lista, e por um argumento bem razoável: para inserir tem que existir. Para que criar se não vai inserir? Então ao inserir o primeiro cria a estrutura. Implicitamente.

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

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

foi o que eu disse pode não explicar nada mas é bonitinho. O que eu escrevi é mais instrutivo e o objetivo era outro: mostrar a "bobagem" da bolha de afunda. Ganhei uma aposta até. Âncora versus Bolha. Eu implementei "direito": a bolha que sobe. E a animação das duas opções: a que afunda, como a da wikipedia aqui acima e a outra, mais de acordo com o que se espera de uma bolha, que sobe para a superfície... Abraço a todos

Pobre aluno que tentar acompanhar esse gif de oito dias... Muito lerdo.Pelo menos no meu programa as comparações são mais dinâmicas e o intervalo é parametrizável. O da wikipedia é mais legal. pode não ensinar nada mas é bonitinho!

Você entendeu o argumento. O autor do tópico até tentou ir por um terceiro caminho retornando -1 que é uma solução em muitas rotinas de biblioteca, mas essas rotinas não tem a clara intenção de retornar verdadeiro/falso. @isrnick te deu um bom argumento também. Encerrar o programa e "tratar profissionalmente" o problema pode ser uma postura arrogante e já te expliquei porque: quem chama sua rotina pode ver como inofensivo a lista estar "vazia" fora da sua concepção ternária: existe vazia/existe não vazia/ não existe para uma situação de dois estados apenas. E se você retornar falso para lista_vazia(NULL) porque a sua concepção de universo não abrange tal liberalidade, o infeliz que vai abrir uma rotina que grava todas as transações da lista no banco de dados vai sim cancelar um série de processos porque o ponteiro que ele recebeu era NULL e não havia nada a transmitir. E ninguém vai ser gentil quando você começar a explicar que a documentação claramente abrange os fatos necessários e tal e tal e tal... Me lembra de sua discussão de tempos atrás sobre o que era um arquivo csv. Muito válida e filosófica até alguém te pagar para ler um ou escrever um. Não te pagar, na verdade. E pode não ser sua atribuição decidir isso. Abortar um programa a partir de uma rotina auxiliar por algo que você deixou claro na documentação não vai durar um dia e você vai ter que se entender com alguém. Mas você não trabalha para mim nem é meu aluno, claro. E respeito sua posição, apesar de achar folclórica.

que tal algo assim: se for lido "cod" na última linha um certo int declarado ? int criterio = 0; continua a valer zero e caso contrário passa a valer 1? E aí uma rotina de comparação declarada assim int compara(int primeiro, int segundo, int criterio, Aluno aluno[]); faz o sort com a ordem esperada? Não é original mas funciona. Todos os algoritmos fazem assim, sem querer ou de propósito. Os meus também. int compara(int primeiro, int segundo, int criterio, Aluno aluno[]) { // criterio 0 classifica pela ordem de codigo do aluno if (criterio == 0) return(aluno[primeiro].cod > aluno[segundo].cod); // criterio nao zero vai usar a ordem de nome return strcmp(aluno[primeiro].nome, aluno[segundo].nome); }; // compara() Assim resolve Sábias palavras. Leia tudo e prepare os dados. Como são só dois, o outro seria "não esse". Não "cod". adicionado 4 minutos depois Vai ganhar tempo se fizer isso @Julia Leite O sort vai ser feito no próprio vetor de alunos: É assim que o bubble sort funciona. Se chama in-place sorting na literatura. Então se você tiver os valores lá certinhos estará quase tudo pronto. E se não tiver não adianta nada querer se arriscar com o algoritmo no meio de um outro problema...

Não é necessário: só há dois critérios e poderia ser um único bit: 0 para COD e 1 para nome por exemplo. E para a classificação não faz diferença tampouco. Só é usado na comparação afinal... Meses atrás eu postei aqui eu acho uma rotina que classifica um vetor com esse bubble sort, com uma animação para mostrar algo sobre as comparações. Acho que era uma aposta aqui e uma discussão aí sobre essa nomenclatura besta de bolha quando na implementação normal a bolha desce ao invés de subir... De todo modo o programa pode servir de algo porque eu implementei dos dois "modos": o modo "âncora" convencional e o modo "bolha" mesmo, e os dois com uma animação como aquelas de aparecem na Wikipedia. Só que esse que eu escrevi ilustra melhor as comparações e as trocas. Aos moderadores: há já um número enorme de implementações disso em várias linguagens na internet de modo que não acrescenta muito em falar disso aqui ou postar um programa. E meu programa tem esse aspecto didático de ilustrar as comparações e trocas... O programa é um único arquivo em C e a parte do sort é mínima. Pode ser baixado aqui ou visto aqui ou esquecido aqui ;)

? Não faz diferença, certo? Um char vai de 0 a 255, sem sinal, ou de -128 a 127 com sinal. E o que significa Matemática para um char? 'M'? e biologia 'B'? é só uma convenção. E no enunciado diz "TURMA 1" e "TURMA 2"...

Essa observação foi essencial. Adorei. Mas é só uma progressão a partir do elemento na primeira coluna