kgin

Você pode fazer uma matriz só para os nomes da matriz e uma matriz só para os valores. int valores[linhas][colunas]; char nomes[linhas][colunas][64]; eh minha praia e outra, tô mais pra programação de jogos e embarcados

Qual é a especificação do sistema? Pode ser uma gama de fatores como resolução muito alta, o programa tentando usar a GPU ao invés da CPU ou produto pirata. Uma solução se caso for a resolução muito alta seria usar proxys para editar em uma resolução baixa, e só depois desativar para renderizar em uma resolução alta.

@Fídias Torres Poder ajudar eu até posso, mas eu literalmente não estou entendendo quase nada do seu algoritmo. isso seria simples dependendo do compilador que você está usando, você poderia usar VLAs. Exemplo #include <stdio.h> int main() { /* Pega o tamanho da matriz */ int q_linhas, q_colunas; printf("Digite o quantidade de linhas da matriz:"); scanf("%d%*c", &q_linhas); printf("Digite o quantidade de colunas da matriz:"); scanf("%d%*c", &q_colunas); /* Declara a matriz */ int matriz_quadrados[q_linhas][q_colunas]; int linhas, colunas; for (linhas = 0; linhas < q_linhas; linhas++) { for (colunas = 0; colunas < q_colunas; colunas++) { matriz_quadrados[linhas][colunas] = (linhas+1)*(colunas+1); } } printf("Quadrados da matriz\n"); for (linhas = 0; linhas < q_linhas; linhas++) { for (colunas = 0; colunas < q_colunas; colunas++) { printf("%d, ", matriz_quadrados[linhas][colunas]); } printf("\n"); } return(0); } Veja no navegador! Ou usar alocação dinâmica de memória.

@Fídias Torres Isso funciona? as informações do seu programa estão muito espalhadas, coisas como você poderia declarar assim float som[10]; e acessar assim som[0] = 33.0f; som[1] = 13.49f Usar estruturas (structs) ajudaria também para organizar o código.

Veja que aqui você usou a vírgula "," sendo que o certo seria o ponto "." Em C a vírgula e um operador e um separador. Saiba mais em Operador de vírgula: ,

Mas você quer fazer para o windows 10? No windows 10 você tem que chamar uma função do sistema, mas no msdos que foi o que você fez você chamaria uma interrupção da BIOS. Exemplo em dos ; Declarações DOSSEG .MODEL SMALL .STACK 200h .DATA .CODE START: ; Codigo mov dx,OFFSET mensagem mov ax,SEG mensagem mov ds,ax mov ah,9h int 21h ; Encerra o programa mov ax,4c00h int 21h mensagem db "Hell world!$" END START Eu tenho quase certeza que funciona no dos com o TASM (utilize o dosbox para testar).

@Vitor0244 qual é a plataforma?

@gcrestudante Meu matematiquês tá meio ruim, mas eu acho que seria algo assim #include <stdio.h> int main(void) { int numero, maiorQ, quadrado = 0; /* Escreva um algoritmo que leia um número inteiro, positivo N */ do { printf("Informe N\n"); scanf("%i%*c", &numero); if (numero < 0) { printf("Digite um numero positivo!\n"); } } while (numero < 0); /* calcule e mostre o maior quadrado menor ou igual a N */ maiorQ = 0; while (maiorQ < numero) { maiorQ = quadrado*quadrado; printf("%i=%i*%i\n", maiorQ, quadrado, quadrado); if (maiorQ < numero) { quadrado++; } else if ( maiorQ > numero) { quadrado--; } } printf("O maior quadrado calculavel é %i\n", quadrado); printf("%i=%i*%i\n", quadrado*quadrado, quadrado, quadrado); return(0); }

@gcrestudante Qual seria a sua duvida exatamente? Seu algoritmo cumprindo alguns critérios do enunciado. #include <stdio.h> #define TAM 10 int main () { int vet[TAM], contador, numero, impares = 0; /* Elabore um algoritmo que leia um vetor de 10 posições */ for (contador = 0; contador < TAM; contador++) { printf("Digite um numero para a posicao %i do vetor:", contador); scanf("%i%*c", &vet[contador]); } /* e em seguida um valor X qualquer */ printf("Informe X:"); scanf("%i", &numero); /* Seu algoritmo deverá dizer qual a quantidade de números ímpares maiores que X */ //conta impares for (contador = 0; contador < TAM; contador++) { if (vet[contador]%2 == 1) { //testa se impar impares++; } } printf ("Quantidade de impares:%i\n", impares); return(0); } Utilize o botão code <> para postar no fórum.

Poste o que você já fez.

Você pode colocar na terceira posição da matriz. exemplo for (i = 0; i < 15; i++) { mat[i][2] = mat[i][0]/mat[i][1]; } Mas eu daria preferência para criar constantes ao invés de digitar as posições. exemplo #include <stdio.h> #include <stdlib.h> #define QUANTIDADE_PESSOAS 15 #define QUANTIDADE_MEDIDAS 3 #define PESO 0 #define ALTURA 1 #define IMC 2 int main(int argc, char *argv[]) { float informacao_pessoas[QUANTIDADE_PESSOAS][QUANTIDADE_MEDIDAS]; int linhas, colunas; /* Pega o peso e a altura */ for(linhas = 0;linhas < QUANTIDADE_PESSOAS; linhas++) { for (colunas = 0; colunas < QUANTIDADE_MEDIDAS-1; colunas++) { switch (colunas) { case PESO: printf("Digite o peso da pessoa %i em Kilos:", linhas+1); scanf("%f%*c", &informacao_pessoas[linhas][colunas]); break; case ALTURA: printf("Digite a altura da pessoa %i em metros:", linhas+1); scanf("%f%*c", &informacao_pessoas[linhas][colunas]); break; } } } /* Calcula o IMC */ for (linhas = 0; linhas < QUANTIDADE_PESSOAS; linhas++) { informacao_pessoas[linhas][IMC] = informacao_pessoas[linhas][PESO]/informacao_pessoas[linhas][ALTURA]; } /* Mostra o IMC de cada pessoa */ for (linhas = 0; linhas < QUANTIDADE_PESSOAS; linhas++) { printf("O imc da pessoa %i e de %.2f\n", linhas+1, informacao_pessoas[linhas][IMC]); } printf("Pressione enter para continuar....\n"); getchar(); return 0; }

@Robs156 Não tem muito o que melhorar, a sua lógica está muito boa. você deveria usar constantes e evitar usar letras soltas. exemplo algoritmo "semnome" const QUANTIDADE_PESSOAS = 3 var idade: vetor [1..QUANTIDADE_PESSOAS] de inteiro contador, maior, posicao_maior: inteiro soma_idades: real inicio maior <- 0 Para contador <- 1 ate QUANTIDADE_PESSOAS faca EscrevaL("Digite sua idade: ") Leia(idade[contador]) soma_idades <- soma_idades + idade[contador] Se (idade[contador] > maior) entao maior <- idade[contador] posicao_maior <- contador Fimse FimPara EscrevaL("A média de idade foi: ", soma_idades/QUANTIDADE_PESSOAS) EscrevaL("A maior idade digitada foi: ", maior) EscrevaL("Temos pessoas com mais de 25 anos nas posições: ") Para contador <- 1 ate QUANTIDADE_PESSOAS faca Se (idade[contador] > 25) entao EscrevaL("Posição: ",contador) FimSe FimPara EscrevaL("A maior idade foi digitada na posição: ", posicao_maior) fimalgoritmo Indentação é sempre importante também!

E possível fazer isso, mas isso depende de varias coisas (principalmente do sistema operacional). O caminha mais fácil seria utilizar ncurses ou pdcurses.

Um deles é esse aqui Você errou quando criou a função criaPilha() na inicialização da pilha. Aqui o erro E quando você utiliza a função tamanho() ela vai desempilhar e utilizar esse valor, mas o valor e desconhecido pelo fato que ele não foi inicializado na função criaPilha(). Aqui a saída do gdb mostrando o erro Veja que no endereço anterior ele era um endereço valido, mas no ultimo endereço ele aponta para lugar nenhum fazendo o programa ter SEGV e abortando. Outra coisa que eu acho que você deveria fazer e deixa o programa principal lidar com um erro ao invés de abortar o programa. você deveria só fazer algo assim. struct st_pilha *pilha_cria(void) { struct st_pilha *pilha = malloc(sizeof(*pilha)); if (pilha != NULL) { pilha->tamanho = 0; pilha->pilha = NULL; return(pilha); } return(NULL); } Só verificando o erro na função principal. Aqui o resto do algoritmo de exemplo #include <stdio.h> #include <stdlib.h> struct st_lista { int valor; struct st_lista *anterior; }; struct st_pilha { struct st_lista *pilha; int tamanho; }; void pilha_destroi(struct st_pilha **pilha); struct st_pilha *pilha_cria(void); int pilha_empilha(struct st_pilha *pilha, int valor); int pilha_desempilha(struct st_pilha *pilha); int pilha_tamanho(struct st_pilha *pilha); int main(void) { struct st_pilha *pilha = pilha_cria(); if (pilha == NULL) { printf("deu problema!\n"); exit(EXIT_FAILURE); } pilha_empilha(pilha, 10); pilha_empilha(pilha, 11); pilha_empilha(pilha, 12); pilha_empilha(pilha, 13); printf("O tamanho da pilha e %i\n", pilha_tamanho(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("Valor na pilha %i\n", pilha_desempilha(pilha)); printf("O tamanho da pilha agora e %i\n", pilha_tamanho(pilha)); pilha_destroi(&pilha); getchar(); return(0); } void pilha_destroi(struct st_pilha **pilha) { if (*pilha != NULL) { while ((*pilha)->pilha != NULL) { struct st_lista *tmp = (*pilha)->pilha->anterior; free((*pilha)->pilha); (*pilha)->pilha = tmp; } (*pilha)->pilha = NULL; free(*pilha); } *pilha = NULL; } struct st_pilha *pilha_cria(void) { struct st_pilha *pilha = malloc(sizeof(*pilha)); if (pilha != NULL) { pilha->tamanho = 0; pilha->pilha = NULL; return(pilha); } return(NULL); } int pilha_empilha(struct st_pilha *pilha, int valor) { struct st_lista *no = malloc(sizeof(*no)); if (no != NULL) { no->valor = valor; no->anterior = pilha->pilha; pilha->pilha = no; pilha->tamanho++; return(1); } return(0); } int pilha_desempilha(struct st_pilha *pilha) { if (pilha->pilha != NULL) { int valor = pilha->pilha->valor; struct st_lista *tmp = pilha->pilha->anterior; free(pilha->pilha); pilha->pilha = tmp; pilha->tamanho--; return(valor); } return(0); } int pilha_tamanho(struct st_pilha *pilha) { return(pilha->tamanho); } Recomendo ler esse blog para entender como identificar os erros. https://sergioprado.org/identificando-problemas-de-acesso-memoria-com-o-addresssanitizer/

Procurei por todo canto e não achei nada sobre constantes. Pensei que nem existissem no visualG. Eh erro meu isso aí, não seria um exemplo muito bom pra que tá aprendendo a programar. Mas em C ou pascal dependendo da arquitetura e a quantidade de memória isso não seria um problema. a recursão poderia ser feita até umas 64 vezes em C (no pior dos casos) ou umas 128 vezes em pascal se obedece-se algumas regras. Eu achei incrível isso tenha funcionado no visualG.

tem muitos, muitos erros. Mas o principal é aqui Você não reservou a memória para o próximo elemento na pilha.

@Cristian Herchonvicz Achei meio vago o enunciado. tente fazer dessa maneira. algoritmo "loteamentos" var // Reserva dos lotes lotes_disponiveis:vetor [1..14] de inteiro // Nomes dos compradores dos lotes lotes_nomes:vetor [1..14] de caractere // Quantidade de lotes QUANTIDADE_LOTES:inteiro contador:inteiro LOTE_DISPONIVEL, LOTE_RESERVADO, LOTE_VENDIDO:inteiro procedimento mostraLotes var contador:inteiro inicio escreval("Lotes disponivies") para contador de 1 ate QUANTIDADE_LOTES faca // Mostra se o lote está disponível se lotes_disponiveis[contador] = LOTE_DISPONIVEL entao escreval("[", contador,"]-Lote disponiviel") fimSe se lotes_disponiveis[contador] = LOTE_RESERVADO entao escreval("[", contador,"]-Lote reservado para ", lotes_nomes[contador]) fimSe se lotes_disponiveis[contador] = LOTE_VENDIDO entao escreval("[", contador,"]-Lote vendido para ", lotes_nomes[contador]) fimSe fimPara fimProcedimento procedimento reservaLote var indice:inteiro opcao:inteiro inicio // Mostra os lotes mostraLotes escreval("Digite um lote para reservar ou comprar") leia(indice) // Checa se o valor do lote e valido se (indice >= 1) e (indice <= QUANTIDADE_LOTES) entao // Verifica se o lote está disponível se lotes_disponiveis[indice] = 0 entao escreval("Digite seu nome para confirmar a reserva") leia(lotes_nomes[indice]) escreval("Digite 1 para reservar o lote ou 2 para comprar") leia(opcao) se opcao = 1 entao lotes_disponiveis[indice] <- LOTE_RESERVADO seNao lotes_disponiveis[indice] <- LOTE_VENDIDO fimSe seNao se lotes_disponiveis[indice] = LOTE_RESERVADO entao escreval("Lote ja reservado") seNao escreval("O lote ja foi comprado") fimSe escreval("Deseja tentar reservar ou comprar outro lote?") escreval("Digite 1 para cadastrar novamente ou 2 para sair") leia(opcao) se opcao = 1 entao reservaLote fimSe fimSe seNao escreval("Essa opcao não existe") escreval("Deseja tentar reservar ou comprar outro lote") escreval("Digite 1 para cadastrar novamente ou 2 para sair") leia(opcao) se opcao = 1 entao reservaLote fimSe fimSe fimProcedimento inicio // Quantidade total de lotes QUANTIDADE_LOTES <- 14 // Constantes do status do lote LOTE_DISPONIVEL <- 0 LOTE_RESERVADO <- 1 LOTE_VENDIDO <- 2 // Inicia o vetor para contador de 1 ate QUANTIDADE_LOTES faca lotes_disponiveis[contador] <- 0 fimPara reservaLote mostraLotes fimAlgoritmo

Poste o enunciado.

Pode ser algo na versão que você está desenvolvendo agora. Poste novamente o algoritmo.

@Lauro Viana Aqui tá normal e não existe disciplina 0 Porque está tão complicado se é só um programa de media?

Poste o enunciado e descreva o seu problema.

Ele provavelmente está com algum problema, vá na aba problemas (ou problems caso você esteja usando em inglês) que ele vai apontar qual o erro. Se isso não der certo tente ir nas configurações do intellisense. O certo seria aparecer um erro assim quando você erra-se na sintaxe. Se você está aprendendo deixar o autocompletar desligado e uma opção interessante, mas a verificação de código aí já não acho muito interessante para o aprendizado.

Geralmente o próprio intellicense faz isso, você tem instalado?

Já tentou fazer um "chmod +x prog2" no terminal?

@DanielSantos_20 Agora sim ficou bacana! Só inclua a biblioteca ctype para usar a função toupper() #include <ctype.h> No devC++ ele provavelmente vai funcionar, mas se você compilar em outro lugar vai dar erro porque está faltando a biblioteca.