Lucca Rodrigues

@oromotoceu Não está. Veja o enunciado: Ele menciona "espaços em branco", e isso pode ser espaço comum ( ' ' ), tabulação horizontal ( '\t' ), carriage return ( '\r' ), newline ( '\n' ), tabulação vertical ( '\v' ) ou formfeed ( '\f' ). isspace() da ctype verifica se o caractere passado como argumento é um caractere de espaço em branco, retorna um valor diferente de 0 caso seja e 0 caso não seja. Use ela ou então faça sua própria função, em geral é a mesma ideia que implementou: uma string com todos os caracteres de espaço em branco e um loop pra verificar se algum deles corresponde a um caractere em questão da string que o usuário digitou. gets() é obsoleta, melhor evitar. Você poderia usar fgets(), scanf() ou alguma outra função, veja: char str[101]; /* Usando fgets */ if(fgets(str, sizeof(str), stdin) != NULL) { if(str[strlen(str) - 1] == '\n') { // '\n' na penultima posição da string str[strlen(str) - 1] = '\0'; } else { int ch; while((ch = fgetc(stdin)) != '\n' && ch != EOF); } } /* Usando scanf */ int ch; while(scanf("%100[^\n]", str) < 1) { // Lendo o que ha de resto while((ch = fgetc(stdin)) != '\n' && ch != EOF); // Informando o usuario printf("Entrada invalida!\nDigite novamente:\n"); } // Lendo o que ha de resto while((ch = fgetc(stdin)) != '\n' && ch != EOF);

@Ninja Teleporte Sim, você inicializou saida com o valor 1, e a condição de persistência do loop é saida != 1. Enquanto saida for diferente de 1 o loop persiste, mas sempre vai ser igual a 1. Veja, você não precisa de uma variável pra isso: você pode definir a condição como menu != 9, já que a opção 9 é Sair, então o loop persistiria enquanto essa opção não fosse escolhida.

@Ninja Teleporte Se tiver um código e um problema, pode postar que tentamos ajudar. Não podemos fazer suas atividades.

@Ninja Teleporte Sim, com certeza alguém consegue fazer esse código completo Veja, a atividade é sua... Tentou começar? Comece definindo as estruturas, veja como será o protótipo das funções, acredito que deverá criar uma para cada funcionalidade. Ao final, pode criar o menu. Que dúvidas tem?

Em geral o resultado é o mesmo para o caso, só que não uso fgetc() porque tenho que teclar Enter duas vezes. Dá pra chamar read() com o mesmo esquema, desabilitando echo e line input: char LerChar(void) { DWORD mode; int total = 0; int c = 0; HANDLE h = GetStdHandle(STD_INPUT_HANDLE); if(h == NULL) { // GetStdHandle() falhou return '\0'; } GetConsoleMode(h, &mode); SetConsoleMode(h, mode & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT)); ReadConsole(h, &c, 1, (LPDWORD)&total, NULL); SetConsoleMode(h, mode); if(total > 0) { if(c == '\r') c = '\n'; return (char)c; } else { // não leu nada return '\0'; } } LerInt() e LerFloat() do código que postei avaliam o caractere digitado que é inserido na string caso o valor resultante após a inserção esteja dentro do intervalo.

Esse tipo de coisa acontece, daí a gente aplica os mínimos cuidados com a scanf(): verifica o retorno, lê a besteira que o usuário digitou se o retorno não for o esperado e informa que a entrada não é válida. No mais, é o que foi dito no outro tópico por você: Acho que é o mais adequado, mas foram poucas as vezes que vi alguém aplicar em uma atividade acadêmica ou coisa do tipo. Eu tinha feito isso há um tempo, só não sei se o comportamento da peek() ou da wait() muda entre os compiladores. Testei com o GCC: #include <stdio.h> #include <stdlib.h> #include <windows.h> char LerChar(void); int LerInt(int minval, int maxval); float LerFloat(float minval, float maxval); int main() { printf("Digite algum numero inteiro entre -300 e 300: "); int x = LerInt(-300, 300); printf("\n\nDigite algum numero real entre -1.2 e 5.6: "); float y = LerFloat(-1.2f, 5.6f); printf("\n\nValor inteiro: %d\nValor real: %f\n", x, y); return 0; } char LerChar(void) { INPUT_RECORD record; HANDLE console = GetStdHandle(STD_INPUT_HANDLE); int total = 0; // Tecla char c = 0; do { FlushConsoleInputBuffer(console); WaitForSingleObject(console, INFINITE); /* Se PeekConsoleInput() for bem-sucedida, o valor retornado será diferente de zero */ if(!PeekConsoleInput(console, &record, 1, (LPDWORD)&total)) return 1; if(total > 0) if(record.EventType == KEY_EVENT && record.Event.KeyEvent.bKeyDown) { c = record.Event.KeyEvent.uChar.AsciiChar; FlushConsoleInputBuffer(console); if(c == '\r') c = '\n'; return c; } } while(1); } int LerInt(int minval, int maxval) { char str[12]; int x = 0; int i = 0; int ch; while((ch = LerChar()) != EOF && ch != '\n') { if(i == 0 && ch == '-') { // '-' no início putchar(ch); str[i++] = ch; } else if(ch == '\b' && i > 0) { // Backspace printf("\b \b"); str[--i] = '\0'; } else if(ch >= '0' && ch <= '9') { // Entre '0' e '9' str[i++] = ch; str[i] = '\0'; /* Caso o primeiro número seja 0 e haja outro em sequência, o mesmo é retirado da string */ if((str[0] == '0' && str[1] == '0') || (str[0] == '-' && str[1] == '0' && str[2] == '0')) str[--i] = '\0'; else if(atoll(str) <= (long long)maxval && atoll(str) >= (long long)minval) putchar(ch); else str[--i] = '\0'; } } str[i] = '\0'; // Caso algum valor tenha sido digitado if(str[0] >= '0' || (str[0] == '-' && str[1] >= '0')) x = atoi(str); return x; } float LerFloat(float minval, float maxval) { int aloc = 101; char* str = (char*)malloc(aloc); float x = 0.0f; int pnt = -1; int i = 0; int ch; while((ch = LerChar()) != EOF && ch != '\n') { if(i == (aloc - 1)) { aloc += 100; str = (char*)realloc(str, aloc); } if(i == 0 && ch == '-') { // '-' no início putchar(ch); str[i++] = ch; } else if(pnt == -1 && ch == '.') { // '.' pnt = i; putchar(ch); str[i++] = ch; } else if(ch == '\b' && i > 0) { // Backspace printf("\b \b"); str[--i] = '\0'; if(i == pnt) pnt = -1; } else if(ch >= '0' && ch <= '9') { // Entre '0' e '9' str[i++] = ch; str[i] = '\0'; /* Caso o primeiro número seja 0 e haja outro em sequência, o mesmo é retirado da string */ if((str[0] == '0' && str[1] == '0') || (str[0] == '-' && str[1] == '0' && str[2] == '0')) str[--i] = '\0'; else if(strtold(str, NULL) <= (long double)maxval && strtold(str, NULL) >= (long double)minval) putchar(ch); else str[--i] = '\0'; } } str[i] = '\0'; // Caso algum valor tenha sido digitado if(str[0] >= '0' || (str[0] == '-' && str[1] >= '0') || (str[0] == '-' && str[1] == '.' && str[2] >= '0')) x = strtof(str, NULL); return x; } Desse jeito o usuário não consegue digitar um valor fora do intervalo, nem zoar o programa digitando letras ou coisa do tipo.

@MarianaN Você pode fazer o seguinte, se quer limitar a quantidade de caracteres lidos no formato de float: int ch = 0; // Limitado a ler 3 caracteres <d.d> scanf("%3f", &notas[c]); // Lendo o que ha de resto while((ch = fgetc(stdin)) != '\n' && ch != EOF); Isto é, se tem certeza de que a nota é composta por somente um dígito antes da vírgula, e nesse caso não vão ocorrer arredondamentos: Em geral não tem muito sentido em cobrar a nota dessa forma, acho que vale mais a pena ler a nota do jeito que o usuário inserir e arredondar na hora de imprimir, como você já fez: Se quer testar o retorno da scanf(), pode usar um loop: while(scanf("%3f", &notas[c]) < 1) { // Lendo o que ha de resto while((ch = fgetc(stdin)) != '\n' && ch != EOF); // Informando o usuario printf("Entrada invalida!\nDigite a nota %d: ", c + 1); } A scanf() retorna a quantidade de itens lidos e gravados, então nesse caso deveria ser 1. Se for 0, não gravou nada.

Talvez seja algo assim: Os vetores têm o mesmo tamanho. @maria paiva Mostre o que já fez antes de chegar nesse ponto. De certa forma, basta um loop onde é feito o produto dos elementos dos vetores. A forma de armazenar no terceiro vetor você pode implementar com dois contadores: um começando de 0 e sendo incrementado e outro começando de tamanho do vetor - 1 e sendo decrementado, daí faça o uso deles alternadamente

@Fabiano da Rosa Muller Sem um contexto fica meio difícil entender os parâmetros de uma moldura, eu (eu) nunca mexi com isso. aresta a = aresta c e aresta b = aresta d, considerando um retângulo. Se a entrada é a largura e o comprimento da moldura, então são apenas 2 variáveis. Como você disse, uma das entradas é a quantidade de travas, então elas têm um tamanho fixo eu imagino, você só não disse qual é. E como esse reforço é posicionado? Como é esse reforço afinal? E de que se trata esse perfil exatamente? E como vai ser definida essa sobra? Uma das entradas é o tamanho do perfil a ser utilizado, então eu imagino que esse tal perfil seja uma peça retilínea ou algo assim. Isto é, se o perímetro > perfil? Se for um programa interativo, informe o usuário e peça os dados novamente. Mostre os cálculos para que ele veja onde errou. Ou então use outro perfil para um eventual restante, não sei exatamente como você quer que funcione. Qual o critério que determina o melhor aproveitamento? O que se deseja obter? Você pode criar. Poderia ser algo assim: typedef struct { double larg; // Largura moldura double comp; // Comprimento moldura int trava; // Quantidade de travas double perfil; // Tamanho do perfil int mold; // Quantidade de molduras } MOLDURA; Defina o tamanho para a trava. Você criaria um vetor dessa estrutura caso tivesse mais de um conjunto de parâmetros. C não é só isso

@Pedroernesto64 O que acontece é que `n` é incrementado em um loop infinito: Certo caractere em questão não tem como tornar as 4 condições falsas para que o valor total da expressão seja 0: 0 OU 0 OU 0 OU 0 = 0. O que você estabeleceu é que caso um caractere seja diferente de + ou de - ou de * ou de /, `n` é incrementado. Você pode tornar uma das condições falsas, não as quatro de uma vez, dessa forma você acaba acessando memória além da que foi alocada para a string conforme `n` é incrementado. Sim, é isso mesmo. Enquanto certo caractere em questão for diferente dos 4 operadores, você incrementa `n`, e assumindo que os operadores estão posicionados após os demais caracteres, pode usar `n` como índice na string. No mais, esqueça gets(), é obsoleta. Duas possíveis substitutas aqui pra você: char cadeia[50]; // Usando fgets if(fgets(cadeia, sizeof(cadeia), stdin) != NULL) { if(cadeia[strlen(cadeia) - 1] == '\n') { // '\n' na penultima posição da string cadeia[strlen(cadeia) - 1] = '\0'; } else { int ch; while((ch = fgetc(stdin)) != '\n' && ch != EOF); } } // Usando scanf scanf(" %49[^\n]%*c", cadeia); @RPGStreamer Acho que assim se está contando os operadores.

@Victor Jardim Parece ser uma questão um pouco extensa. Comece definindo as estruturas. Veja, pode ser algo no seguinte formato: // Codigo, nome, valor unitario e quantidade em estoque typedef struct { int cod; char nome[101]; double valun; int qtd; } PRODUTO; Uma estrutura apenas nomeada, sem rótulo. Se tem um limite para produtos cadastrados use um vetor estático, caso contrário, um dinâmico: // Vetor estatico de PRODUTO com espaco para 50 cadastros // não ha como alterar o tamanho do bloco de memoria alocado PRODUTO prod[50]; // Vetor dinamico de PRODUTO com espaco para 50 cadastros // Chame realloc para alterar o tamanho do bloco de memoria alocado PRODUTO* prod = (PRODUTO*)malloc(50*sizeof(PRODUTO)); E isso é só um jeito de fazer, você pode usar estruturas de dados, uma lista por exemplo. A parte do menu acho que não vai ter dificuldades, basta um loop com o comando switch: int op; do { printf("Exemplo de menu\n" "1. Opcao 1\n" "2. Opcao 2\n" "3. Sair\n" "Escolha: "); scanf(" %d", &op); switch(op) { case 1: printf("\nOpcao 1 escolhida\n\n"); break; case 2: printf("\nOpcao 2 escolhida\n\n"); break; case 3: printf("\nSaindo...\n"); break; default: printf("\nOpcao invalida\n\n"); } } while(op != 3); Bem, veja o que pode fazer por enquanto, de que jeito vai fazer e com quais recursos. São 9 funções que vai implementar aparentemente...

@Victor Jardim Realmente, o começo do código está em falta Tentou começar? Não tem segredo... Crie as estruturas com os tais campos... Uma função pra cada operação... E um menu na função principal que chama cada função. Que dúvidas tem?

@234122 É só escolher algum algoritmo de ordenação e usar. Pra comparar as strings use strcmp(), e pra copiar o conteúdo de uma string para outra, pode usar strcpy(). Por selection sort: // QTD eh a quantidade de strings // str eh o vetor de strings // aux eh uma string auxiliar for (j = 0; j < (QTD - 1); j++) { for (i = (j + 1); i < QTD; i++) { if (strcmp(str[i], str[j]) < 0) { strcpy(aux, str[i]); strcpy(str[i], str[j]); strcpy(str[j], aux); } } }

@Eduardo de Quadros Como @Andreas Karl disse, provavelmente esses aparelhos devem suportar uns 5% de variação na tensão de entrada. Eu (eu) diria que é desnecessário tentar fazer alguma redução, mas você pode tentar seguir a ideia de @.if e colocar algo em série pra testar.

@Ninenome Você não precisa atribuir membro por membro da estrutura. Assim como atribuiu o retorno de lerDados() à dados[i], faça o mesmo para apro e repr, porém use cont e cont1 como índice: apro[cont] = dados[i]; cont++; //... repr[cont1] = dados[i]; cont1++; Afinal, só incrementamos o contador para estes quando for encontrada uma nota num intervalo específico, assim como estabeleceu com o comando if. /* 11. Faca um programa que leia os dados de 10 alunos (Nome, matricula, Media Final), armazenando em um vetor. Uma vez lidos os dados, divida estes dados em 2 novos vetores, o vetor dos aprovados e o vetor dos reprovados, considerando a media mınima para a aprovacao como sendo 5.0. Exibir na tela os dados do vetor de aprovados, seguido dos dados do vetor de reprovados. */ #include <iostream> #include <cstring> using namespace std; struct Alunos { char nome[40]; int matricula; double mediaFinal; }; Alunos lerDados(); void imprimirDados(Alunos ap[], Alunos rp[], int c, int c1); int main() { int i, cont = 0, cont1 = 0; Alunos dados[3]; Alunos apro[3]; Alunos repr[3]; for(i = 0; i < 3; i++) { dados[i] = lerDados(); } for(i = 0; i < 3; i++) { if(dados[i].mediaFinal > 5.0) { apro[cont] = dados[i]; cont++; } } for(i = 0; i < 3; i++) { if(dados[i].mediaFinal < 5.0) { repr[cont1] = dados[i]; cont1++; } } imprimirDados(apro, repr, cont, cont1); return 0; } Alunos lerDados() { Alunos p; char nl[6]; int n1, n2, n3; cout<<"Nome do aluno: "<<endl; cin.getline(p.nome,40); cin.sync(); cout<<"Matricula: "<<endl; cin>>p.matricula; cin.sync(); cout<<"Digite as notas 1, 2, 3: "<<endl; cout<<"Nota 1: ";cin>>n1; cout<<"Nota 2: ";cin>>n2; cout<<"Nota 3: ";cin>>n3; cin.sync(); cout<<endl; p.mediaFinal = (n1 + n2 + n3)/3; cin.getline(nl,6); return p; } void imprimirDados(Alunos ap[], Alunos rp[], int c, int c1) { int i; for(i = 0; i < c; i++) { cout<<"--------APROVADO--------"<<endl; cout<<"Nome.......: "<<ap[i].nome<<endl<<endl; cout<<"Matricula..: "<<ap[i].matricula<<endl<<endl; cout<<"Media final: "<<ap[i].mediaFinal<<endl<<endl; } for(i = 0; i < c1; i++) { cout<<"--------REPROVADO--------"<<endl; cout<<"Nome.......: "<<rp[i].nome<<endl<<endl; cout<<"Matricula..: "<<rp[i].matricula<<endl<<endl; cout<<"Media final: "<<rp[i].mediaFinal<<endl<<endl; } }

@Eduardo de Quadros Que aparelhos são esses? Em geral na prática não faz diferença, está na mesma faixa de tensão.

@Pietra Ester Não use acentuação para dar nome a variáveis, funções ou qualquer coisa do tipo. Pode funcionar na sua máquina, mas veja, na minha não funcionou. Perceba também que você colocou a declaração das funções fácil() e linha() seguida da definição, e a main() está no final do arquivo. Sempre coloque a main() como primeira. Nesse trecho você criou uma função que não recebe e nem retorna nada para chamar a printf(), em geral é desnecessário. F_LIN e F_COL são constantes simbólicas. #define associa esses identificadores à constante 4. Não se trata de uma biblioteca ou algo do tipo. Você não precisa chamar a printf() 3 vezes, só uma chamada já basta: printf("> NÍVEL : Fácil\n" "> JOGADOR: %s\n" "> PONTOS : %d pts\n", nome[i], pts); Você não precisa necessariamente de goto nesse caso. Se precisa repetir algo como iniciar uma nova jogada, você poderia criar um loop. fácil() deveria retornar char, mas ao final da função não há return. Não funciona bem assim, e você não precisa disso em nenhuma ocasião para o stream de entrada. Inclusive essa função só tem comportamento definido para fluxos de saída. Muitas variáveis globais, e não parece necessário. Você tem 2 funções além da main(), que tal passar algo como argumento na chamada delas caso precise? Declare-as na main(). gets() é obsoleta, você pode usar scanf(), fgets() ou alguma outra função: scanf(" %49[^\n]", nome[i]); Inclusive você não inicializou o índice i: Acredito que não está incrementando o valor de i também, para armazenar os demais nomes. Acredito que no primeiro caso, a dificuldade seria fácil. E veja, você está imprimindo essas estatísticas tanto na main() quanto na função fácil(). Resultado: Ele não imprime o nome do jogador na função fácil() porque você usou o índice i em um loop, então o valor dele muda. Acredito que basta atualizar a tela para mostrar as cartas escolhidas. Você pode seguir a ideia de @mauro_b Enfim, Só alterei certas coisas no código segundo o que fui anotando acima: #define F_LIN 4 //constante de quantidade de linhas nivel fácil #define F_COL 4 //constante de quantidade de colunas nivel fácil #include <stdio.h> //biblioteca padrão #include <stdlib.h> //biblioteca da alocação dinâmica #include <locale.h> //biblioteca de idiomas #include <time.h> //biblioteca de aleatória #include <string.h> //biblioteca para strings #include <windows.h>//biblioteca do sleep //PROTÓTIPOS DE FUNÇÕES void fácil(); // Mudei o retorno para void para testar //variavel global int lin, col, lin2, col2, pts=0; char nome[50][50]; //FUNÇÃO PRINCIPAL int main() { //variaveis int difi, opcao, i = -1; //idioma em português setlocale(LC_ALL, "Portuguese"); //cor do sistema system("color 1e"); do{ //menu printf("-------------------------------------------------\n"); printf(" ****** BEM VINDO AO JOGO DA MEMÓRIA ******\n"); printf("-------------------------------------------------\n"); printf("\n\t\t[1] JOGAR\n"); printf("\t\t[2] TUTORIAL\n"); printf("\t\t[3] SAIR\n\n"); printf("\t\tOpção: "); scanf(" %d", &opcao); printf("-------------------------------------------------\n"); switch (opcao) { case 1: //lê o nome do jogador system("cls"); printf("-------------------------------------------------\n"); printf("> NOME DO JOGADOR > "); i++; // Caso sejam 50 jogadores no máximo, faça uma condição que verifica isso com base no valor de i scanf(" %49[^\n]", nome[i]); printf("-------------------------------------------------\n"); system("Pause"); system("cls"); do { //jogador escolhe o nível da dificuldade printf("> %s, escolha o nível de dificuldade: \n\n", nome[i]); printf("\t\t[1] fácil\n"); printf("\t\t[2] Médio\n"); printf("\t\t[3] Difícil\n\n"); printf("\t\tOpção: "); scanf(" %d", &difi); printf("-------------------------------------------------\n"); //menu de opções de níveis de dificuldade switch (difi) { case 1: system("cls"); printf("> NÍVEL : Fácil\n"); printf("> JOGADOR: %s\n", nome[i]); printf("> PONTOS : %d\n", pts); //imprime o tabuleiro fácil(); printf("-------------------------------------------------\n"); break; case 2: system("cls"); printf("> NÍVEL : Médio\n"); printf("> JOGADOR: %s\n", nome[i]); printf("> PONTOS : %d\n", pts); printf("-------------------------------------------------\n"); //medio(); printf("-------------------------------------------------\n"); break; case 3: system("cls"); printf("> NÍVEL : Difícil\n"); printf("> JOGADOR: %s\n", nome[i]); printf("> PONTOS : %d\n", pts); printf("-------------------------------------------------\n"); //difícil(); printf("-------------------------------------------------\n"); break; default: system("cls"); printf("> Opção invalida!\n"); printf("-------------------------------------------------\n"); } } while(difi > 1 || difi < 3); break; case 2: system("cls"); printf(" > TUTORIAL:\n"); printf("-------------------------------------------------\n"); printf(" # O objetivo do jogo é achar um par de cada carta.\n # Alcançar 800 pontos no nível fácil.\n # Alcançar 3200 pontos no nível médio. \n # Alcançar 5000 pontos no nível difícil.\n\n # Boa sorte! :)\n\n"); system("Pause"); system("cls"); break; case 3: system("cls"); printf("> SAINDO DO PROGRAMA...\n"); exit(0); default: system("cls"); printf("> Opção invalida!\n"); } } while(opcao > 1 || opcao < 3); return 0; } //FUNÇÃO QUE GERA TABULEIRO DE NÍVEL FÁCIL void fácil() { char** tabuleiro; char cartas[F_LIN * F_COL / 2] = {'a', 'b', 'c', 'd', 'e', 'f','g','h'};//'i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','!','$','/','+','-','?'}; int i, j, c=0, cont=0, k = 0; // Use k para imprimir o nome do jogador srand(time(NULL)); // aloca um vetor de F_LIN ponteiros para as linhas tabuleiro = (char**) malloc (F_LIN * sizeof (char*)) ; // aloca cada uma das linhas (vetores de F_COL char) for (i=0; i < F_LIN; i++) { tabuleiro[i] = (char*) malloc (F_COL * sizeof (char)) ; } //preenche com caracteres aleatórios for (i=0; i<F_LIN; i++) { for (j=0; j<F_COL;j++) { tabuleiro [i][j]='*'; } } while (c<F_LIN*F_COL/2) { i = rand() % F_LIN; j = rand() % F_COL; if (tabuleiro[i][j] == '*') { tabuleiro [i][j] = cartas[c]; cont= cont + 1; } else { continue; } if (cont==2) { c=c+1; cont=0; } } //âncora para nova jogada jogada: system("cls"); //status do jogo printf("-------------------------------------------------\n"); printf("> NÍVEL : Fácil\n" "> JOGADOR: %s\n" "> PONTOS : %d pts\n", nome[k], pts); printf("-------------------------------------------------\n"); //imprime a matriz printf(" "); for(i=0; i<4; i++) { printf("%d ", i); } printf("\n"); for (i=0; i < F_LIN; i++) { printf(" %d | ", i); for (j=0; j < F_COL; j++) { //esconde o tabuleiro if(pts < 800) { printf(" | "); } else { printf("%c | ", tabuleiro[i][j]); } } printf("\n"); } printf("-------------------------------------------------\n"); //lógica do jogo while (pts < 800) { printf("\n> Digite a linha e coluna respectivamente: "); scanf(" %d %d", &lin, &col); printf("> Digite a linha e coluna respectivamente: "); scanf(" %d %d", &lin2, &col2); if (lin <0 || lin > 4 || col < 0 || col > 4) { printf("-------------------------------------------------\n"); printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n"); system("pause"); goto jogada; } else if (lin2 <0 || lin2 > 4 || col2 < 0 || col2 > 4) { printf("-------------------------------------------------\n"); printf("\t\t JOGADA INVÁLIDA!\n\t\t*Digite números de 0 a 4.\n\n"); system("pause"); goto jogada; } else if(lin == lin2 && col == col2) { printf("-------------------------------------------------\n"); printf("\t\t JOGADA INVÁLIDA!\n\t\t*Lugar ocupado!\n\n"); Sleep(2000); goto jogada; } else if(tabuleiro[lin][col] == tabuleiro[lin2][col2]) { printf("\n\t\t BOOAAA!\n \t\t*Ganhou +100 pts!\n\n"); Sleep(2000); pts = pts + 100; goto jogada; } else if (tabuleiro[lin][col] != tabuleiro[lin2][col2]) { printf("\n\t\tERROU!!!\n\n"); Sleep(2000); goto jogada; } } if(pts == 800) { printf("\n ***PARABÉNS %s você alcançou os 800 pontos!*\n ***Sua memória é muito boa!!!* 8)\n", nome[i]); printf("\t\t _1_ \n"); printf("\t\t |o| \n\n"); system("pause"); system("cls"); exit(0); } // libera a memória da matriz for (i=0; i < F_LIN; i++) { free(tabuleiro[i]); } free(tabuleiro); return; //?? }

No caso é matriz dinâmica, ponteiro de ponteiro pra float, e a função retorna isso também, acaba apontando pro local de memória alocado pra C... Caso tivesse sido alocado @Pedro Fernandess Na parte que você gera valores aleatórios pras matrizes A e B, faltou imprimir o valor gerado: A[x][y] = rand() % 15; printf("A[%d][%d] = %.2f\n", x+1,y+1, A[x][y]); E não deu muito certo sua ideia de imprimir a matriz, acabou imprimindo cada elemento em uma linha, tente isso: for(x = 0; x < linA; x++) { for(y = 0; y < linA; y++) { if(y !=(colA - 1)) printf("|%6.2f", A[x][y]); else printf("|%6.2f", A[x][y]); } printf("|\n"); } Como @devair1010 disse, você precisa alocar memória antes de usar... Dá uma olhada: #include <stdio.h> #include <stdlib.h> #include <time.h> float** multiplicaMatriz (int linA, int colA, int linB, int colB); void desalocaMatriz (float** C, int nlinhas); int main(void) { srand(time(NULL)); int linA, colA, linB, colB; float** C; int i; int j; printf("\n\nInforme o numero de linhas para a matriz A = "); scanf("%d", &linA); printf("\nInforme o numero de colunas para a matriz A = "); scanf("%d", &colA); printf("\nInforme o numero de linhas para a matriz B = "); scanf("%d", &linB); printf("\nInforme o numero de colunas para a matriz B = "); scanf("%d", &colB); if(colA != linB) { printf("\n\nATENCAO: O produto das matrizes informadas não eh possível!\n"); printf("Isso acontece pois o numero de colunas da matriz A eh diferente do numero de linhas da matriz B.\n\n"); exit(0); } C = multiplicaMatriz(linA, colA, linB, colB); for(i = 0; i < linA; i++) { for(j = 0; j < colB; j++) { printf("%f\n", C[i][j]); } } desalocaMatriz(C, linA); return 0; } float** multiplicaMatriz(int linA, int colA, int linB, int colB) { int i; int x, y, a1, a2; float temp; float A[linA][colA]; float B[linB][colB]; // float C[linA][colB]; float** C = (float**)malloc(sizeof(float*) * linA); /* Aloca matriz C */ printf("Alocando matriz C"); for(i = 0; i < linA; i++) { C[i] = (float*)malloc(sizeof(float) * colB); } // Gera matriz A printf("\n GERANDO MATRIZ A \n\n"); for(x = 0;x < linA; x++) { for(y = 0;y < colA; y++) { A[x][y] = rand() % 15; printf("A[%d][%d] = %.2f\n", x+1,y+1, A[x][y]); } } // Gera matriz B printf("\n GERANDO MATRIZ B \n"); for(x = 0;x < linB; x++) { for(y = 0;y < colB; y++) { B[x][y] = rand() % 15; printf("B[%d][%d] = %.2f\n", x+1,y+1, B[x][y]); } } // Imprime matriz A printf("\n MATRIZ A \n\n"); for(x = 0; x < linA; x++) { for(y = 0; y < linA; y++) { if(y !=(colA - 1)) printf("|%6.2f", A[x][y]); else printf("|%6.2f", A[x][y]); } printf("|\n"); } // Imprime matriz B printf("\n MATRIZ B \n\n"); for(x = 0; x < linB; x++) { for(y = 0; y < linB; y++) { if(y !=(colB-1 - 1)) printf("|%6.2f", B[x][y]); else printf("|%6.2f", B[x][y]); } printf("|\n"); } for(a1 = 0; a1 < linA; a1++) { for(a2 = 0; a2 < colB; a2++) { temp=0.0; for(x = 0; x < colA; x++) { temp = temp+A[a1][x]*B[x][a2]; } C[a1][a2] = temp; } } printf("\n MATRIZ C = A x B \n \n"); for(x = 0; x < linA; x++) { for(y = 0; y < colB; y++) { if(y!=(colB-1)) { printf("|%6.2f",C[x][y]); } else { printf("|%6.2f",C[x][y]); } } printf("|\n"); } printf("\n\n"); return C; } void desalocaMatriz(float **C, int nlinhas) { int i; for(i = 0; i < nlinhas; i++) { free(C[i]); } }

Você pode declarar duas variáveis pra contagem e incrementar se baseando no sexo inserido. Pra isso, você tem que saber o total de pessoas. Você pode declarar outro contador e incrementar se a pessoa X tem experiência profissional. Daí é só calcular o percentual. Novamente, saiba o total de pessoas e incremente um contador se baseando na idade inserida. Para o restante a ideia é a mesma, contadores e avaliar certas condições...

@Luccas Fernando indi começa em 0, e indj é decrementado até atingir o valor de indi. Sua condição: Conclusão: não vai dar pra acessar o valor de índice -1 do vetor. Pra solucionar, você pode fazer indj ser decrementado até atingir indi + 1.

@patopaloro Lista não é algo que se aprende no começo, então você já deve ter uma noção de estruturas, ponteiros e alocação dinâmica, isso é a base. Aloque um ponteiro para Node do tamanho de Node mesmo, sendo o campo str a string do nó e nextP o ponteiro para o próximo nó, você pode inicializar com NULL. Node* novoP = malloc(sizeof(Node)); Você vai precisar de um ponteiro para o nó anterior para fazer ele apontar para o novo nó, e um para o nó atual, inicialmente apontado para onde o ponteiro do início da lista aponta: Node* anteriorP = NULL; Node* atualP = *startP; Assim, basta um loop percorrendo a lista a partir de atualP, verificando o critério de colocação do nó e atualizando anteriorP. Já que anteriorP aponta para NULL inicialmente, se ele continuar apontando para NULL, você vai ter que fazer a inserção no início: o campo nextP de novoP aponta para onde o ponteiro do início da lista aponta, e o ponteiro do início da lista aponta para esse novoP. Caso contrário, o campo nextP de anteriorP aponta para novoP e o campo nextP de novoP aponta para atualP.

struct node { char str[101]; // dado struct node* nextP; // ponteiro para o proximo no }; typedef struct node Node; // encurtar o nome Só corrigindo minha bobagem aí. Depois de 1h o fórum não deixa mais editar a postagem Tem alguma ideia de como seguir com o programa? O ponteiro para o começo da lista você declara na main. Consegue fazer a função de inserção? Tem alguma ideia de como fazer?

@patopaloro Você tem uma lista simplesmente encadeada, então pode considerar algo assim: struct node { char str[101]; // dado struct listNode* nextP; // ponteiro para o proximo no }; typedef struct node Node; // encurtar o nome Você só vai ter um ponteiro em cada nó, que aponta para o próximo nó. O ponteiro para o começo da lista então seria: Node* startP = NULL; O protótipo da função de inserção poderia ser algo assim: int insert(Node** startP, char* str);

@Andreygabs Que valor tá sendo atribuído pra maior e menor? Leia um primeiro valor e então faça essa atribuição.

@Ana987546 Poste o código pra gente dar uma olhada