KXSY

O seu erro foi basicamente na hora de converter para binário Eu não entendi muito bem essa parte se era para converte para binário não é bem assim, aqui uma conversão rápida. /* Conversão decimal binario */ #include <stdio.h> /* E/S padrão */ #include <stdlib.h> /* LIB padrão */ /* Constantes */ #define TAMANHO_MAXIMO 10 int main() { unsigned short valor; char resultado[TAMANHO_MAXIMO],auxiliar[TAMANHO_MAXIMO]; unsigned char contador=0; /* Pega o valor a ser convertido */ printf("\nDigite um número inteiro não negativo.\t"); scanf("%hu",&valor); getchar(); /* Retira o new line do buffer do teclado */ /* Converte para binario */ do { if(valor%2) resultado[contador]='1'; else resultado[contador]='0'; contador++; valor/=2; }while(valor); resultado[contador]=0; /* Termina a string com \0 */ contador--; /* Invete a string */ for(valor=0; resultado[valor]; valor++) { auxiliar[valor]=resultado[contador]; contador--; } auxiliar[valor]=0; /* Termina a string com \0 */ /* Mostra o resultado */ printf("\nO valor convertido :\t%s",auxiliar); getchar(); /* Pausa o programa */ return(0); }

@VitinhoBBK Não sei se isso ajuda, mas eu fiz um jogo da velha em C puro alguns meses atrás. aqui o código. /* 3=tabs ██ ██ ███████ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ █████ ██ ███████ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ████ ███████ ███████ ██ ██ ██ ██ Feito em 07/03/2019 By Brinck */ /* Cabeçalhos */ #include <stdio.h> #include <stdlib.h> /* Constantes */ /* Objetos */ #define VAZIO 0 #define XIS 1 #define BOLA 2 #define VELHA 3 /* Medidas da grade */ #define LARGURA 3 #define ALTURA 3 /* Tipos */ typedef unsigned short int TGrade; /* ██████ ██████ ██████ ██████ ███████ ██████ ██ ███ ███ ███████ ███ ██ ████████ ██████ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ████ ██ ████ ██ ██ ██ ██ ██ ██████ ██████ ██ ██ ██ █████ ██ ██ ██ ██ ████ ██ █████ ██ ██ ██ ██ ██ ██ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██████ ██████ ███████ ██████ ██ ██ ██ ███████ ██ ████ ██ ██████ ███████ */ /* Limpa a grade do jogo */ void LimpaGrade(TGrade grade[][LARGURA]); /* Pega a jogada do úsuario */ void PegaJogada(TGrade grade[][LARGURA], int *vez); /* Mostra o jogo */ void MostraGrade(const TGrade grade[][LARGURA]); /* ███████ ██ ██ ███ ██ ██████ ██████ ███████ ███████ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ █████ ██ ██ ██ ██ ██ ██ ██ ██ █████ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██████ ██ ████ ██████ ██████ ███████ ███████ */ int ChecaVitoria(const TGrade grade[][LARGURA]); /* ██████ ██████ ██ ███ ██ ██████ ██ ██████ █████ ██ ██ ██ ██ ██ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██████ ██████ ██ ██ ██ ██ ██ ██ ██████ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██████ ██ ██ ██ ██ ███████ */ int main() { TGrade grade[ALTURA][LARGURA]; int vez,a; /*Marca a vez*/ /*Loop secundário*/ do { a=0; /*Decide quem vai com o que*/ printf("\nEscolha com o que você vai 1=X 2=O\n:"); do { scanf("%i",&a); }while(!(a>0&&a<=2)); vez=a; LimpaGrade(grade); /*Loop principal do jogo*/ do { MostraGrade(grade); PegaJogada(grade,&vez); a=ChecaVitoria(grade); }while(a<1); MostraGrade(grade); /*Mostra o ultimo movimento*/ /*Mostra quem ganhou*/ switch(a) { case XIS: printf("\n\n\n\tX Ganhou.\n"); break; case BOLA: printf("\n\n\n\tO Ganhou.\n"); break; case VELHA: printf("\n\n\n\tDeu velha.\n"); break; } getchar(); getchar(); /*Pergunta se deseja ir novamente*/ printf("\nIr de novo digite 1 ou 2 para sair\n"); scanf("%i",&a); }while(a==1); return(0); } /* ██ ███ ███ ██████ ██ ███████ ███ ███ ███████ ███ ██ ████████ █████ ██████ ██████ ███████ ███████ ██ ████ ████ ██ ██ ██ ██ ████ ████ ██ ████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ████ ██ ██████ ██ █████ ██ ████ ██ █████ ██ ██ ██ ██ ███████ ██ ██ ██ █████ ███████ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ██ ███████ ███████ ██ ██ ███████ ██ ████ ██ ██ ██ ██████ ██████ ███████ ███████ */ void LimpaGrade(TGrade grade[][LARGURA]) { unsigned char a,b; /* Variavéis genericas */ for(a=0; a<ALTURA; a++) for(b=0; b<LARGURA; b++) grade[a][b]=VAZIO; } void PegaJogada(TGrade grade[][LARGURA],int *vez) { unsigned short int tecla,bandeira=1; printf("\nDigite onde você quer jogar. "); do { /*Pega onde sera jogado*/ do { scanf("%hu",&tecla); if(!(tecla>0&&tecla<10)) printf("\nJogada inválida."); }while(!(tecla>0&&tecla<10)); /*Testa se a jogada e valida*/ switch(tecla) { case 1: if(grade[2][0]==VAZIO) { grade[2][0]=*vez; bandeira=0; } break; case 2: if(grade[2][1]==VAZIO) { grade[2][1]=*vez; bandeira=0; } break; case 3: if(grade[2][2]==VAZIO) { grade[2][2]=*vez; bandeira=0; } break; case 4: if(grade[1][0]==VAZIO) { grade[1][0]=*vez; bandeira=0; } break; case 5: if(grade[1][1]==VAZIO) { grade[1][1]=*vez; bandeira=0; } break; case 6: if(grade[1][2]==VAZIO) { grade[1][2]=*vez; bandeira=0; } break; case 7: if(grade[0][0]==VAZIO) { grade[0][0]=*vez; bandeira=0; } break; case 8: if(grade[0][1]==VAZIO) { grade[0][1]=*vez; bandeira=0; } break; case 9: if(grade[0][2]==VAZIO) { grade[0][2]=*vez; bandeira=0; } break; } if(bandeira==1) printf("\nEsse local já está ocupado.\n"); }while(bandeira!=0); if(*vez==XIS) *vez=BOLA; else *vez=XIS; } void MostraGrade(const TGrade grade[][LARGURA]) { unsigned short int a,b; /* uso no loop */ for(a=0; a<ALTURA; a++) { for(b=0; b<LARGURA; b++) if((grade[a][b]==XIS)||(grade[a][b]==BOLA)) if(grade[a][b]==XIS) printf("X "); else printf("O "); else printf("_ "); printf("\n"); } } int ChecaVitoria(const TGrade grade[][LARGURA]) { unsigned char a,b,cont=0; /* Variavéis genericas */ /*Checa as linhas*/ for(a=0; a<ALTURA; a++) if((grade[a][0]==grade[a][1])&&(grade[a][1]==grade[a][2])) if(grade[a][0]) return(grade[a][0]); /*Checa as colunas*/ for(a=0; a<ALTURA; a++) if((grade[0][a]==grade[1][a])&&(grade[1][a]==grade[2][a])) if(grade[0][a]) return(grade[0][a]); /*Checa na diagonal*/ if((grade[0][0]==grade[1][1])&&(grade[1][1]==grade[2][2])) if(grade[0][0]) return(grade[0][0]); if((grade[0][2]==grade[1][1])&&(grade[1][1]==grade[2][0])) if(grade[0][2]) return(grade[0][2]); for(a=0; a<ALTURA; a++) for(b=0; b<LARGURA; b++) if(grade[a][b]) cont++; if(cont<9) return(0); else return(VELHA); }

É o código do seu professor está certo, simplesmente faça por cima desse código que vai funcionar. #include <stdio.h> #include <stdlib.h> #include <math.h> /*Dicas:PotC*ncia: pow(base, expoente) */ //ProtC3tipo das funC'C5es int grau; float multi[7]; //Indice 0 a 6 float f (float valor); /* Isso era uma função foi mal aí não sabia porque não tinha visto a declaração */ int main () /* Sempre devolva alguma coisa na função principal */ { int i; //Receber o grau da funC'C#o entre 2 a 6 printf ("Informe o grau da funcao (2 a 6): "); scanf ("%i", &grau); //Receber os multiplicadores. Dica: Armazenar os valores em um vetor. //aX^0 + bX^1 + cX^2 --->Indice do vetor igual ao expoente for (i = 0; i <= grau; i++) { printf ("Informe o fator multiplicador de x^%i: ", i); scanf ("%f", &multi[i]); } //Exibindo a funC'C#o recebida printf ("A funcao recebida foi: "); for (i = 0; i <= grau; i++) { printf ("%.2fx^%i", multi[i], i); if (i < grau) printf (" + "); else printf (" = 0"); } //AQUI //-----------------------INICIO----------------------- //Implementar o Algoritmo da Regra dos TrapC)zios Repetida //Criar as variC!veis necessC!rias //Utilizar ponteiros //------------------------FIM------------------------- /* system ("pause"); */ getchar(); /* getchar aqui e mais seguro para pausar o programa */ return(0); } //Funcao que realiza o calculo em em determinado ponto float f (float valor) { int i; float resultado; resultado = 0; for (i = 0; i <= grau; i++) { resultado = resultado + multi[i] * pow (valor, i); } return resultado; } você vai ter que compilar usando -lm ex:gcc main.c -o main -lm isso faz a biblioteca math.h ser ligada ao programa que vai retirar o erro de "undefined pow function"

Sim, sim, nessa parte aqui você está usando f como uma função, eu acho que você tirou parcialmente de outro código porque se tirou vai ter que copiar do outro código para funcionar corretamente. uma boa dica é tente fazer na calculadora e depois tente passar para um algoritmo.

O erro é basicamente essa variável com esse cast maluco e essa função f() que não existe. se você tem uma conexão de internet razoável utilize o (https://repl.it/languages/c) para programar programas pequenos, é também porque ele utiliza o clang que tem as mensagens bem fáceis de entender.

Você já sabe usar ponteiros? se sim tente listas encadeadas /* Listas encadeadas */ #include <stdio.h> #include <stdlib.h> /* Constantes */ #define TAMANHO_NOME 20 /* Tipos */ typedef struct { char nome[TAMANHO_NOME]; unsigned short idade; unsigned short matricula; float media; }TFicha; typedef struct Aluno { TFicha ficha; struct Aluno *proximo; }TAluno; /* Procedimentos */ void Limpa(TAluno *p); /* Funções */ TAluno *CriaNo(TAluno *p, const TFicha *f); int main() { TAluno *inicio=NULL,*ponteiro=NULL; char tecla=0; /* Cria a lista encadeada */ do { TFicha ficha; puts("Digite o nome do aluno"); fgets(ficha.nome,TAMANHO_NOME,stdin); puts("Digite a idade do aluno"); scanf("%hu",&ficha.idade); getchar(); puts("Digite a matricula do aluno"); scanf("%hu",&ficha.matricula); getchar(); puts("Digite a nota do aluno"); scanf("%f",&ficha.media); getchar(); if(!inicio) { inicio=CriaNo(NULL,&ficha); ponteiro=inicio; } else ponteiro=CriaNo(ponteiro,&ficha); puts("Digite S para sair ou qualquer tecla para continuar."); scanf("%c",&tecla); getchar(); }while(tecla!='s'); /* Mostra a lista */ ponteiro=inicio; while(ponteiro) { printf("\nNome:\t%s",ponteiro->ficha.nome); printf("\nIdade:\t%hu",ponteiro->ficha.idade); printf("\nN° matricula:\t%hu",ponteiro->ficha.matricula); printf("\nMedia:\t%f\n\n",ponteiro->ficha.media); ponteiro=ponteiro->proximo; } printf("\nPass..."); /* Limpa todos os registros da lista */ Limpa(inicio); return(0); } void Limpa(TAluno *p) { TAluno *auxiliar=p->proximo; do { free(p); p=auxiliar; auxiliar=p->proximo; }while(auxiliar); } TAluno *CriaNo(TAluno *p, const TFicha *f) { if(!p) { p=malloc(sizeof(TAluno)); if(!p) { fprintf(stdout,"\nErro.\n"); exit(EXIT_FAILURE); } p->ficha=(*f); p->proximo=NULL; return(p); } else { TAluno *auxiliar; p->proximo=malloc(sizeof(TAluno)); if(!p->proximo) { fprintf(stdout,"\nErro.\n"); exit(EXIT_FAILURE); } auxiliar=p->proximo; auxiliar->ficha=(*f); auxiliar->proximo=NULL; return(p->proximo); } } Aqui um material de fácil entendimento http://www.ic.unicamp.br/~ra069320/PED/MC102/1s2008/Apostilas/Cap10.pdf https://www.cprogressivo.net/2013/10/Lista-simplesmente-encadeada-com-cabeca-em-C-Inserindo-nos-no-inicio-e-fim.html Algumas outros coisas interessantes no seu código é isso preenche o campo do vetor com 0 (depende do sistema NULL nem sempre e zero) não apaga efetivamente o elemento do vetor. outra coisa interessante é evite usar conio.h porque a maioria dos compiladores não o suporta mais ou suporta parcialmente, também usar system pode acarretar alguns problemas para sistemas unix like use getchar();

O seu problema está um pouco abstrato, digamos assim isso já deveria estar contido no próprio arquivo, porque pelo que eu entendi o arquivo vem de um local externo. como por exemplo a urna, então fica um pouco difícil de ajudar.

Cara, eu não entendi muito bem o seu código mas uma dica é use estruturas e vetores. assim: #include <stdio.h> struct TCandidato { char nome[10]; int voto; }; struct TCandidato candidato[QUANTIDA_DE_CANDIDATOS]; int main() { return(0); } ficaria bem mais simples do que fazer assim

Muito obrigado, Eu sempre pensei que fosse alguma coisa do compilador ou algum tipo de syntax sugar. a tabela de precedência que eu tenho aqui esta meia certa no borland c++ (uma das versões que me fugiu da memória) que fazer isso também dará um segment fault ou simplesmente configurar o compilador para C89 resolveria o problema.

O operador unário * sendo simplesmente colocado em "d" não altera o valor e sim o ponteiro. Ex: #include <stdio.h> #include <stdlib.h> /* Constantes */ #define MAX 10 int main() { int *d=malloc(sizeof(int)); if(!d) return(1); for(*d=0; *d<MAX; *d++) printf("\n\t%i",*d); getchar(); free(d); return(0); } Assim estaria certo Ex: #include <stdio.h> #include <stdlib.h> /* Constantes */ #define MAX 10 int main() { int *d=malloc(sizeof(int)); if(!d) return(1); for((*d)=0; (*d)<MAX; (*d)++) printf("\n\t%i",(*d)); getchar(); free(d); return(0); } alguém saberia porque o primeiro estaria errado sendo que parece certo?

Tá ai, a resposta /* 3=tabs */ #include <stdio.h> /* Constantes */ #define MAX_C 10 #define MAX_PESSOAS 10 /* Quantidade de pessoas */ /* Tipos */ struct pessoa { char nome[MAX_C]; long pontuacao; }; int main() { struct pessoa pessoas[MAX_PESSOAS]; unsigned char contador,trocas=1; puts("Insira os nomes e as pontuacoes dos participantes."); /* Pega o nome e a pontuação */ for(contador=0; contador<MAX_PESSOAS; contador++) { printf("\nNome:\t"); fgets(pessoas[contador].nome,MAX_C,stdin); printf("\nPontuacao:\t"); scanf("%li",&pessoas[contador].pontuacao); fflush(stdin); /* Libera o buff do teclado. */ } /* Organisa o vetor */ while(trocas) { struct pessoa auxliar; trocas=0; for(contador=0; contador<(MAX_PESSOAS-1); contador++) if(pessoas[contador].pontuacao>pessoas[contador+1].pontuacao) { auxliar=pessoas[contador]; pessoas[contador]=pessoas[contador+1]; pessoas[contador+1]=auxliar; trocas=1; } } /* Mostra todos os participantes */ for(contador=0; contador<MAX_PESSOAS; contador++) if(contador==MAX_PESSOAS-1) { printf("\n\n\tVencedor"); printf("\nNome:\t%sPontuacao\n:\t%li\n",pessoas[contador].nome,pessoas[contador].pontuacao); } else printf("\nNome:\t%sPontuacao\n:\t%li\n",pessoas[contador].nome,pessoas[contador].pontuacao); getchar(); /* Espera o usuario */ return(0); /* Finaliza o programa */ } tá cheio de bugs, então aprenda como funciona é conserte.