arfneto

Mas o exemplo que mostrou apenas identifica um ponto no espaço. Mas pode usar o exemplo que te mostrei. Não estou certo do que seja um vetor assim. Do modo como escreveu (x1,y1,z1) é um ponto e (x2,y2,z2) outro ponto e definem um segmento no espaço 3D

Entendeu o que eu expliquei? Não perguntou nadinha...

Seu programa não está bom. Você tem um livro? Um manual? Talvez deva ler a definição de scanf() com cuidado ou usar outra função. Quando você diz "ler e buscar" um cadastro está considerando que toda vez vai digitar tudo de novo ou vai ler de um arquivo? Entenda que vai precisar de algum lugar para guardar esse cadastro na memória. O mais comum é agrupar os campos do cadastro em uma struct{} e declarar um vetor delas. Sabe o que são essas coisas?

Um pouco confuso isso que descreveu. Tem um enunciado mais preciso? Seu programa está um pouco confuso e difícil de ler e acho que não atende ao lance dos vetores e struct. Não sei o que são "vetores em struct" ao certo Se você não tem nada mais específico, veja como pode ser mais simples: struct origem { int n; int vetor1[100]; int vetor2[100]; }; struct destino { int resultado[100]; }; int produto_escalar(int N, int* vetor1, int* vetor2, int* resultado); Na struct origem tem os vetores vetor1 e vetor2 de tamanho n. E você vai calcular o produto escalar e gravar no destino na struct destino usando a função produto_escalar. Claro que só vai usar um n e aparentemente igual a 3 fixo no seu caso Entenda que você pode declarar os vetores assim: struct origem de = { 3, { 2,4,6 }, { 3,6,9 } }; struct destino para; E já testar sua função, antes de perder seu tempo digitando coisas para testar. Seu enunciado diz que tem que ler do teclado? Não acha mais simples? São vetores, estão dentro de structs, estão inicializados e pode chamar sua função diretamente: int v = produto_escalar(3, de.vetor1, de.vetor2, para.resultado); E a função recebe os ponteiros e faz as contas. Claro que os 3 vetores tem a mesma dimensão e N não passando de 100 assim vai estar bem.

Porque criou um novo tópico para o mesmo problema? do{ Node* lista=NULL; printf("Escolha a opção\n"); printf("0. Sair\n"); printf("1. Apagar todos o ... Com esse primeiro comando no loop fica difícil para seu programa... A primeira coisa que ele faz antes de mostrar o menu é..... APAGAR A LISTA. Node* inserir_fim(Node * Lista, int dia, int mes, const* string); Não se costuma escrever assim para inserir. O mais produtivo é Lista* inserir_fim(Node* Lista, Lista* Lista); // ou no seu caso Node* inserir_fim(Node* evento, Node* Lista); O que você quer fazer é inserir um node na lista. E devolver o novo endereço de início porque ele pode ter mudado. E você não quer ter que alterar inserir() para cada lista que você escreve, certo? O processo é o mesmo então só está arrumando problemas ao vincular inserir() ao layout do nó. Ainda sobre inserir, se você só insere no fim o novo nó sempre vai apontar para NULL... if(Lista==NULL) { novo->prox=NULL; Lista=novo; } else { Node* aux = Lista; while(aux->prox!=NULL) { aux = aux->prox; } novo->prox=NULL; aux->prox=novo; } Como vê com seu código mais alinhadinho, tem o mesmo comando no if nas duas condições... Se você só insere no fim, porque não salva esse endereço afinal? É o seu programa. A sua lista. As suas funções. Você pode fazer o que quiser. Faça o simples: Crie uma estrutura Agenda com uma lista de eventos, um contador atualizado, um ponteiro para o inicio e um ponteiro para o fim. Tudo fica mais fácil. Assim poderia inserir um item na lista escrevendo o simples: Agenda* = inserir_fim(Node* evento, Agenda* agenda); E até pra ler fica mais fácil. Nunca escreva na tela dentro dessas rotinas que manipulam a lista. E muito menos leia valores. Apenas retorne status indicativo assim sabe que não vai mexer nisso. Por exemplo ao remover retorne algo para indicar que não achou o item. Só isso. Não escreva na tela.

Você abriu outro tópico com o mesmo problema. Entenda que se quer a união de A e B só para imprimir não precisar colocar em A... for(int i = 0; i < nelementosB; i++){ uniao[i + cont] = conjuntoB[i]; cont++; } Mas se vai colocar provavelmente não vai querer colocar na união elementos duplicados então deve fazer como faria no papel: para cada elemento de B compara com todos de A e se não estiver lá, e apenas nesse caso, coloca na união. Entenda que se vai só imprimir pode imprimir assim que descobrir cada elemento que faz parte da união. Ainda mais que como declarou um vetor de união --- que não está usando na verdade --- dentro da função, assim que você retornar de uniao() esse vetor vai sumir para sempre. Então pra que gravar afinal ? E se vai usar retorne o endereço dele e o total, mudando os argumentos da função. Com esse número de elementos não perca seu tempo colocando em ordem. Pra valer a pena hoje em dia teria que ter ao menos uns 1000 int em cada vetor. Os processadores de hoje em dia são muito muito rápidos em comparar int em vetores na memória então chamar funções e ficar trocando e comparando não faz sentido. Muito menos se vai usar um printf() para cada item depois.

faça pequenos programas para você se acostumar com essas coisas Pensando de novo no seu programa, entendi que a eleição não é uma simulação de verdade. O valor da margem de A não é uma probabilidade como numa eleição. É um número fixo e isso simplifica umas coisas. Por outro lado devo te lembrar que os valores são baseados em números aleatórios então não vai ter um valor igual aos do enunciado. Ao achar o ponto limite usando a tal bissecta() por outro lado pode conferir usando a mesma função prob_erro() e ver se o valor retornado por bissecta() é mesmo um ponto limite em relação à tolerância...

Crie um classe e compile para uma biblioteca. Use um include com o header para compilar e o arquivo .a que contem a biblioteca na hora de gerar os programas

porque esse é só um trecho de código para mostrar o loop de simulações e o de votos. A mecânica da coisa, como está escrito lá. Não é algo sério. Trata-se de uma constante para ver se você de fato ao menos leu programa. E você leu! Você rodou o programa? Aí temos um problema mesmo. Essa é precisamente a raiz da solução Se Então o tal f da função de sorteio, que é um número entre 0 e 1 também, será menor que esse que veio de sorteia_real() com a probabilidade f. Ou não? E você pode escrever int sorteia_voto_com_falha(double f) { return (sorteia_real() < f); }; porque como eu te expliquei em C ZERO é falso. Te mostrei exemplos também. Então essa função vai retornar zero se sorteia_real() for maior que f. Assim ficaria mais fácil de entender? int sorteia_voto_com_falha2(double f) { int i = rand() % 100; int j = (int)(f * 100); if (i < j) return 1; else return 0; }; adicionado 24 minutos depois faça pequenos programas para você se acostumar com essas coisas for (int v = 0; v < N; v += 1) { // cada voto if (sorteia_real() < a) { // voto em A if (!sorteia_voto_com_falha(f)) votos_em_A += 1; } else { // voto em B if (sorteia_voto_com_falha(f)) votos_em_A += 1; }; // if() }; // for() fim da eleicao Esse loop seria uma eleição computando os votos de acordo com os parâmetros. Pense nisso. Ao final se você tem votos_em_A maior que a metade dos votos, N/2, quer dizer que deu erro

no caso de f = 1 dentro de uma certa tolerância tol número estimado de falhas, não número real. E não é uma indução, é o objetivo: calcular a possibilidade de uma eleição ter o resultado invertido por excesso de erros da urna. Você poderia calcular com o perdedor. Tanto faz. O que importa é se o resultado foi invertido em relação às margens ou não. Em C não. Isso se chama polimorfismo e existe em outras linguagens como java e C++ Sua dificuldade eu não entendi. Pode tentar explicar de outro modo? Isso é a simples busca binária por um valor no intervalo. Você rodou o programa que te mostrei? Entendeu o código? Não tem nenhuma dúvida?

Você vai ter uma lista de coisas onde cada elemento é uma estrutura. Nesse caso é um evento. Não faz diferença o que tem dentro.

Estou vendo isso durante o café Isso está errado. f = 1 significa que a urna vai inverter TODOS os votos e isso não quer dizer que "B vencerá de forma incorreta" mas sim que as margens serão invertidas e a eleição vai sempre inverter o vencedor. "O resultado será sempre incorreto" seria o certo de se afirmar. E o cara errou o nome da constante...

Isso que eu te mostrei não é exatamente a solução. É só pra você entender a mecânica

Li o enunciado. Parece muito texto para pouco problema. Entendeu que pode criar um arquivo desses com o Google Sheet ou o Excel e que tenha os dados dos tipos que precisa. Aí você exporta ele para o formato csv na sua máquina e faz um programa que lê. Quando o programa estiver ok você vai lá no site do governo e escolhe um arquivo. E faz a mesma coisa. A parte do sort não acrescenta nada, afinal você vai ler do disco o arquivo csv que baixou do site do governo. Cria uma estrutura com um registro para cada registro do tal arquivo. Identifica qual o algoritmo que vai usar e classifica o vetor. Depois pode gravar de volta o csv no disco pra conferir. Entendeu melhor? Ou eu perdi uma parte do problema?

Sim. Mas não depende de nada Veja esse resultado Para 10000 testes e f=0.10 a funcao retornou 934 falhas Agora umas eleicoes pra ver a mecanica 100 simulacoes N = 10000 votantes Margem A = 0.51 Taxa de erro f = 0.01 [ 1 de 100]: 91 erros. Media de erros apos 1 eleicoes: 91.000 [ 2 de 100]: 85 erros. Media de erros apos 2 eleicoes: 88.000 [ 3 de 100]: 99 erros. Media de erros apos 3 eleicoes: 91.667 [ 4 de 100]: 98 erros. Media de erros apos 4 eleicoes: 93.250 [ 5 de 100]: 96 erros. Media de erros apos 5 eleicoes: 93.800 [ 6 de 100]: 83 erros. Media de erros apos 6 eleicoes: 92.000 [ 7 de 100]: 105 erros. Media de erros apos 7 eleicoes: 93.857 [ 8 de 100]: 98 erros. Media de erros apos 8 eleicoes: 94.375 [ 9 de 100]: 98 erros. Media de erros apos 9 eleicoes: 94.778 [ 10 de 100]: 90 erros. Media de erros apos 10 eleicoes: 94.300 [ 11 de 100]: 107 erros. Media de erros apos 11 eleicoes: 95.455 [ 12 de 100]: 96 erros. Media de erros apos 12 eleicoes: 95.500 [ 13 de 100]: 83 erros. Media de erros apos 13 eleicoes: 94.538 [ 14 de 100]: 106 erros. Media de erros apos 14 eleicoes: 95.357 [ 15 de 100]: 96 erros. Media de erros apos 15 eleicoes: 95.400 [ 16 de 100]: 98 erros. Media de erros apos 16 eleicoes: 95.563 [ 17 de 100]: 103 erros. Media de erros apos 17 eleicoes: 96.000 [ 18 de 100]: 100 erros. Media de erros apos 18 eleicoes: 96.222 [ 19 de 100]: 117 erros. Media de erros apos 19 eleicoes: 97.316 [ 20 de 100]: 102 erros. Media de erros apos 20 eleicoes: 97.550 [ 21 de 100]: 102 erros. Media de erros apos 21 eleicoes: 97.762 [ 22 de 100]: 119 erros. Media de erros apos 22 eleicoes: 98.727 [ 23 de 100]: 114 erros. Media de erros apos 23 eleicoes: 99.391 [ 24 de 100]: 109 erros. Media de erros apos 24 eleicoes: 99.792 [ 25 de 100]: 111 erros. Media de erros apos 25 eleicoes: 100.240 [ 26 de 100]: 94 erros. Media de erros apos 26 eleicoes: 100.000 [ 27 de 100]: 103 erros. Media de erros apos 27 eleicoes: 100.111 [ 28 de 100]: 101 erros. Media de erros apos 28 eleicoes: 100.143 [ 29 de 100]: 88 erros. Media de erros apos 29 eleicoes: 99.724 [ 30 de 100]: 99 erros. Media de erros apos 30 eleicoes: 99.700 [ 31 de 100]: 103 erros. Media de erros apos 31 eleicoes: 99.806 [ 32 de 100]: 100 erros. Media de erros apos 32 eleicoes: 99.813 [ 33 de 100]: 103 erros. Media de erros apos 33 eleicoes: 99.909 [ 34 de 100]: 110 erros. Media de erros apos 34 eleicoes: 100.206 [ 35 de 100]: 92 erros. Media de erros apos 35 eleicoes: 99.971 [ 36 de 100]: 106 erros. Media de erros apos 36 eleicoes: 100.139 [ 37 de 100]: 92 erros. Media de erros apos 37 eleicoes: 99.919 [ 38 de 100]: 101 erros. Media de erros apos 38 eleicoes: 99.947 [ 39 de 100]: 103 erros. Media de erros apos 39 eleicoes: 100.026 [ 40 de 100]: 97 erros. Media de erros apos 40 eleicoes: 99.950 [ 41 de 100]: 100 erros. Media de erros apos 41 eleicoes: 99.951 [ 42 de 100]: 88 erros. Media de erros apos 42 eleicoes: 99.667 [ 43 de 100]: 87 erros. Media de erros apos 43 eleicoes: 99.372 [ 44 de 100]: 91 erros. Media de erros apos 44 eleicoes: 99.182 [ 45 de 100]: 99 erros. Media de erros apos 45 eleicoes: 99.178 [ 46 de 100]: 101 erros. Media de erros apos 46 eleicoes: 99.217 [ 47 de 100]: 96 erros. Media de erros apos 47 eleicoes: 99.149 [ 48 de 100]: 99 erros. Media de erros apos 48 eleicoes: 99.146 [ 49 de 100]: 111 erros. Media de erros apos 49 eleicoes: 99.388 [ 50 de 100]: 105 erros. Media de erros apos 50 eleicoes: 99.500 [ 51 de 100]: 105 erros. Media de erros apos 51 eleicoes: 99.608 [ 52 de 100]: 96 erros. Media de erros apos 52 eleicoes: 99.538 [ 53 de 100]: 101 erros. Media de erros apos 53 eleicoes: 99.566 [ 54 de 100]: 98 erros. Media de erros apos 54 eleicoes: 99.537 [ 55 de 100]: 102 erros. Media de erros apos 55 eleicoes: 99.582 [ 56 de 100]: 106 erros. Media de erros apos 56 eleicoes: 99.696 [ 57 de 100]: 112 erros. Media de erros apos 57 eleicoes: 99.912 [ 58 de 100]: 119 erros. Media de erros apos 58 eleicoes: 100.241 [ 59 de 100]: 102 erros. Media de erros apos 59 eleicoes: 100.271 [ 60 de 100]: 103 erros. Media de erros apos 60 eleicoes: 100.317 [ 61 de 100]: 105 erros. Media de erros apos 61 eleicoes: 100.393 [ 62 de 100]: 101 erros. Media de erros apos 62 eleicoes: 100.403 [ 63 de 100]: 106 erros. Media de erros apos 63 eleicoes: 100.492 [ 64 de 100]: 86 erros. Media de erros apos 64 eleicoes: 100.266 [ 65 de 100]: 107 erros. Media de erros apos 65 eleicoes: 100.369 [ 66 de 100]: 103 erros. Media de erros apos 66 eleicoes: 100.409 [ 67 de 100]: 103 erros. Media de erros apos 67 eleicoes: 100.448 [ 68 de 100]: 102 erros. Media de erros apos 68 eleicoes: 100.471 [ 69 de 100]: 112 erros. Media de erros apos 69 eleicoes: 100.638 [ 70 de 100]: 87 erros. Media de erros apos 70 eleicoes: 100.443 [ 71 de 100]: 101 erros. Media de erros apos 71 eleicoes: 100.451 [ 72 de 100]: 97 erros. Media de erros apos 72 eleicoes: 100.403 [ 73 de 100]: 114 erros. Media de erros apos 73 eleicoes: 100.589 [ 74 de 100]: 104 erros. Media de erros apos 74 eleicoes: 100.635 [ 75 de 100]: 100 erros. Media de erros apos 75 eleicoes: 100.627 [ 76 de 100]: 97 erros. Media de erros apos 76 eleicoes: 100.579 [ 77 de 100]: 106 erros. Media de erros apos 77 eleicoes: 100.649 [ 78 de 100]: 107 erros. Media de erros apos 78 eleicoes: 100.731 [ 79 de 100]: 91 erros. Media de erros apos 79 eleicoes: 100.608 [ 80 de 100]: 97 erros. Media de erros apos 80 eleicoes: 100.563 [ 81 de 100]: 97 erros. Media de erros apos 81 eleicoes: 100.519 [ 82 de 100]: 90 erros. Media de erros apos 82 eleicoes: 100.390 [ 83 de 100]: 96 erros. Media de erros apos 83 eleicoes: 100.337 [ 84 de 100]: 103 erros. Media de erros apos 84 eleicoes: 100.369 [ 85 de 100]: 111 erros. Media de erros apos 85 eleicoes: 100.494 [ 86 de 100]: 93 erros. Media de erros apos 86 eleicoes: 100.407 [ 87 de 100]: 103 erros. Media de erros apos 87 eleicoes: 100.437 [ 88 de 100]: 95 erros. Media de erros apos 88 eleicoes: 100.375 [ 89 de 100]: 106 erros. Media de erros apos 89 eleicoes: 100.438 [ 90 de 100]: 99 erros. Media de erros apos 90 eleicoes: 100.422 [ 91 de 100]: 95 erros. Media de erros apos 91 eleicoes: 100.363 [ 92 de 100]: 97 erros. Media de erros apos 92 eleicoes: 100.326 [ 93 de 100]: 69 erros. Media de erros apos 93 eleicoes: 99.989 [ 94 de 100]: 89 erros. Media de erros apos 94 eleicoes: 99.872 [ 95 de 100]: 116 erros. Media de erros apos 95 eleicoes: 100.042 [ 96 de 100]: 105 erros. Media de erros apos 96 eleicoes: 100.094 [ 97 de 100]: 105 erros. Media de erros apos 97 eleicoes: 100.144 [ 98 de 100]: 115 erros. Media de erros apos 98 eleicoes: 100.296 [ 99 de 100]: 108 erros. Media de erros apos 99 eleicoes: 100.374 [ 100 de 100]: 105 erros. Media de erros apos 100 eleicoes: 100.420 Final Para esse programa #include <stdio.h> #include <stdlib.h> #include <time.h> #define BISSEC_TOL (1e-6) void ativa_sorteador(); double prob_erro(int, double, double, int); double sorteia_real(); int sorteia_voto_com_falha(double); int sorteia_voto_com_falha2(double); int main(int argc, char** argv) { double f = 0.1; int falhas = 0; int r = 0; int testes = 10000; ativa_sorteador(); for (int i = 0; i < testes; i += 1) { r = sorteia_voto_com_falha(f); if (r != 0) falhas = falhas + 1; }; printf("Para %d testes e f=%4.2f a funcao retornou %d falhas\n", testes, f, falhas); printf("\n\nAgora umas eleicoes pra ver a mecanica\n\n\n"); int votantes = 10000; double margemA = 0.51; double falha = 0.01; testes = 100; double erro = prob_erro(votantes, margemA, falha, testes); //printf("prob_erro() retornou %f\n", erro); return 0; }; void ativa_sorteador() { #ifdef RANDOM_SEED srand(RANDOM_SEED); #else //srand(time(NULL)); srand(20200805); #endif }; double prob_erro(int N, double a, double f, int T) { /* estima a probabilidade de erro de uma eleição com N votantes, dos quais uma fração a vota no candidato A, e com probabilidade de falha f, utilizando T simulações.Os limites dos parâmetros são como no exemplo de entrada e saída */ int erros = 0; // erros int sim = 0; // simulacoes int v = 0; // votos printf("\n%d simulacoes\n", T); printf(" N = %d votantes\n", N); printf(" Margem A = %.2f\n", a); printf(" Taxa de erro f = %.2f\n\n\n\n", f); double grande_total = 0; for (int sim = 1; sim <= T; sim += 1) { // executa T simulacoes erros = 0; for (int v = 0; v < N; v += 1) { // N votos if (sorteia_voto_com_falha(f)) erros += 1; }; printf("[%4d de %4d]: %4d erros. ", sim, T, erros); grande_total += erros; printf("Media de erros apos %4d eleicoes: %.3f\n", sim, grande_total / sim); }; // for() printf("Final\n"); return 1.234; }; /* devolve um real sorteado uniformemente no intervalo [0,1] */ double sorteia_real() { return (double)rand() / RAND_MAX; }; int sorteia_voto_com_falha(double f) { return (sorteia_real() < f); }; int sorteia_voto_com_falha2(double f) { int i = rand() % 100; int j = (int)(f * 100); return (i < j); }; Veja se entende esse e vai estar bem mais perto do resultado... Rode em sua maquina. adicionado 12 minutos depois Não sei se estamos nos entendendo. Entendeu que eu acho que o enunciado está errado? O texto não considera o outro lado da história: a mesma taxa de erro se aplica aos eleitores de B e é preciso computar isso lá. Até está escrito lá. Entendeu isso?

vou ver o texto de novo lá da simulação adicionado 11 minutos depois você rodou o programa que te enviei ontem?

Tomar um coice pode ser irrelevante desde que ele te dê uma resposta ... Eu estudei no IME em São Carlos, da USP. A filial. adicionado 0 minutos depois Tente escrever uma simulação. É só um loop afinal, e uma tabela pra gravar os valores

Acho que você entendeu bem o lance. Acho que é isso mesmo. Mas esse é um problema chato e o enunciado não está muito bom, Você não pode escrever direto ao professor ou TA (monitor, assistente?) ? Não tem algo como um monitor, um cara que ajuda os alunos? Eu entendo que no caso da eleição a chance de B ser eleito ao invés de A é a margem de B mais os votos que eram para A mas deram erro menos os votos de B que deram erro e foram pro outro lado. Ao simular a eleição você tenta se aproximar dessa conta. Fazendo essa conta igual ao total de votos mais 1 você tem uma equação cujo resultado é o valor que Bissecta() deve aproximar.

Sinto muito. É um problema chato mesmo. Mas talvez não tenha ainda familiaridade com a linguagem C para resolver isso. Já escreveu muitos programas? Conseguiu simular uma eleição? Rodou em sua máquina o programa que escrevi pra você?

no caso de formato de arquivos e padrões talvez não o YouTube mas o W3C e o IETF que é onde moram os padrões. Como o RFC 4180 https://tools.ietf.org/html/rfc4180 que está no site da LOC porque faz parte do programa Sustainability of Digital Formats: Planning for Library of Congress Collections da biblioteca do congresso e que cataloga todo tipo de documento sobre formatos de conteúdo digital. Não podia não ter um dos primeiros formatos de intercâmbio digital de todos.

Vá no site recomendado no enunciado e baixe alguns desses csv e abra no bloco de notas pra se familiarizar com o que é. Depois importe no Excel ou no Google Sheets e veja o que acontece. Assim terá noção de causa e efeito. Se tiver acesso a um banco de dados veja como ele lê csv. E se entende inglês.. Direto da Biblioteca do Congresso dos EUA Essa é a referência para csv no planeta: https://www.loc.gov/preservation/digital/formats/fdd/fdd000323.shtml Resumo csv é uma matriz [MxN] e usa um delimitador que em geral é a vírgula, comma separated values, afinal. Comma é a própria: vírgula. M linhas, N colunas TODAS as colunas tem o mesmo número de elementos chamados de campos. A ausência de um campo não elimina o delimitador. Tres campos pode ser a,b,c ou a,, ou ,,. Ou vai ter problemas de portabilidade. Cada linha é chamada registro porque esse é o formato padrão de importação de dados para os bancos ... bancos de dados. Desde os anos '60. E de lá vem a nomenclatura TABLE com RECORDS e RECORDS com FIELDS Os campos podem ser envolvidos em "" por razões óbvias, coma aquela em em que o campo tem vírgulas A primeira linha pode ser diferente: ela tem os nomes dos campos. HEADER é um nome comum para ela nesses casos Eu postei aqui neste forum arquivos csv e programas que criam e leem essas coisas eu acho. Procure no conteúdo das coisas que eu postei no forum Exemplo cor, r,g,b vermelho,255,, verde,0,255,0 azul,0,0,255 Gera Usando Google Sheets e File | Import E aí está Viu o que a primeira linha faz? Já pode por exemplo classificar clicando em r Depois de entender isso vai ficar fácil implementar seu exercício. É um formato genial. Simples, mas esperto. E é apenas uma tabela MxN Veja um comando pra importar um desses num banco de dados LOAD DATA INFILE 'c:/tmp/discounts.csv' INTO TABLE discounts FIELDS TERMINATED BY ',' ENCLOSED BY '"' LINES TERMINATED BY '\n' IGNORE 1 ROWS; em https://www.mysqltutorial.org/import-csv-file-mysql-table/ Não estou recomendando nada só pesquisei um agora/ Só para mostrar o lance de TABLE, FIELDS, RECORDS. Records aqui são as linhas claro. E ignora a primeira. Porque? Porque a tabela já existe então os campos já tem nomes...

faça o simples: peque um papel e desenhe o tal coração e sobre o desenho coloque as linhas e colunas e faça um programa simples que copia um texto. No texto você coloca algo como um ponto onde quer imprimir algo. Papel milimetrado seria uma opção hein?

struct Calendario{ char lembrete[200][30]; int dia[30]; int mes[30]; struct Calendario *prox; }; typedef struct Calendario calendario; int tam; int menu(void); void inicia(calendario *PILHA); void opcao(calendario *PILHA, int op); void exibe(calendario *PILHA); void exibe(calendario *PILHA); void imprime_mes(calendario *PILHA, int meses); void libera(calendario *PILHA); void adicionar(calendario *PILHA); calendario *deletar(calendario *PILHA); Olhando apenas para a estrutura de dados, talvez não haja razão para ter fixos 200 lembretes de 30 posições para cada dia. É quase inútil e difícil de testar sem ter memória. Talvez deva implementar antes de tudo uma função para ler o calendário do disco e outra para salvar na saída. São umas poucas linhas e vai te ajudar pra caramba O próprio calendário não é em si uma lista, mas tem propriedades, podia ter um nome, uma quantidade de eventos, uma data de criação, sei lá. E DENTRO dele está uma lista. De eventos. Onde cada evento tem um dia e mes, quem sabe hora? E as funções deveriam retornar algo. Cada vez que escreve um void perde uma oportunidade de retornar algo útil. inicia() em geral retorna o endereço de início ou NULL adicionar() também retorna o endereço de início ou NULL exibe() retorna o total de itens ou -1 em caso de erro libera retorna 0 se não achou o cara. Zero é falso em C Quando a implementar, creio que pilha não é uma boa opção: estamos falando de eventos. O normal é uma lista com ponteiros para frente e para trás. Porque? Óbvio: você que navegar pelos eventos, e um ponteiro para o anterior e o próximo é uma boa ajuda certo? Lógico que como só seu programa insere eventos você vai inserir já na ordem cronológica de evento... Apenas sugestões.

Nem sei se está errado. E você pode escrever assim digamos de fora pra dentro. No entanto acho que é melhor o contrário e se preocupar em simular as eleições primeiro, depois de entender bem como simular cada voto. E aí sim tentar usar bissecta() para identificar a margem ideal

Você entendeu o que eu expliquei? dessa vez e da anterior? Do modo que você imaginou não vai funcionar/ BISSECTA simplesmente manipula valores para as chamadas às rotinas anteriores para manter o erro dentro da tolerância. Você muda os parâmetros e vai simulando eleições até chegar ao valor certo via BISSECTA()