isrnick

Mude: scanf("%c",&sexo); Para: scanf(" %c",&sexo); Ou seja, incluindo o espaço antes do %c no scanf, para descartar o caractere nova linha '\n' (e qualquer outro caractere vazio como espaço, tabulação, etc, que tiver) que ficou sobrando do scanf anterior (o caractere é adicionado à entrada quando você aperta Enter no terminal/cmd), assim o %c no scanf não vai mais ler esse caractere nova linha como a entrada digitada pelo usuário.

Sim. Bom, minha função na verdade deveria se chamar IBMfloattoSystemfloat, afinal numa máquina que não use o formato IEEE754 para o tipo float ela converteria para esse outro formato de tipo float (e imprimiria o número correto de qualquer maneira). Eu não tentei, mas converter no sentido oposto pode não ser tão trivial.

@Mauro Britivaldo Elabore nos motivos de escolher char * e como usaria no lugar do int.

Sim, eu não quis dizer que usar uma variável static em uma função recursiva seria um erro. Eu estava dizendo que se está acompanhando a posição numa variável estática deve ter um modo de sempre colocar o caractere na posição correta diretamente, e fazer a função sem ter que copiar várias vezes. Entendi. Aqui está minha melhor versão até agora, usando uma variável static para contar o número de bits, e usa o retorno do ponteiro para ir avançando pelo vetor para mover para a posição correta para colocar o respectivo caractere 0 ou 1 do bit, e usa a variável contadora para saber quando deve parar de avançar. E mais importante não tem ciclos de repetição percorrendo o vetor várias vezes e nem faz cópias, cada posição da string só é atribuída um caractere uma vez. char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int count = 0; char *p; if (b){ count++; p = binarystr(bin, b >> 1); *p = (b & 1) ? '1' : '0'; if(p-bin+1 < count) return p+1; else count = 0; } else if (count == 0){ bin[0] = '0'; bin[1] = '\0'; } else { bin[count] = '\0'; } return bin; }

Não entendi... Esse strcat copia apenas 2 bytes toda vez. Seria o mesmo que fazer: int i; for(i=0; bin[i]; i++); bin[i] = c[0]; //bin[i] = (b & 1) ? '1' : '0'; bin[i+1] = c[1]; //bin[i+1] = '\0'; adicionado 10 minutos depois @arfneto Aqui deixa eu reescrever a função sem usar funções da biblioteca string.h para ficar mais claro: char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int notzero = 0; if (b){ notzero = 1; binarystr(bin, b >> 1); size_t i; for(i=0; bin[i]; i++); bin[i] = (b & 1) ? '1' : '0'; bin[i+1] = '\0'; } else if(notzero) { *bin = '\0'; } else { bin[0] = '0'; bin[1] = '\0'; } notzero = 0; return bin; }

@Mauro Britivaldo Sua solução é meio complicada, atualizando uma variável static para saber onde está, e também fazendo várias cópias para mover os caracteres para a direita... Segue minha solução para preencher um vetor de char com a string do número binário: #include <string.h> char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int notzero = 0; char c[] = {'\0','\0'}; if (b){ notzero = 1; c[0] = (b & 1) ? '1' : '0'; binarystr(bin, b >> 1); strcat(bin, c); } else if(notzero) { *bin = '\0'; } else { bin[0] = '0'; bin[1] = '\0'; } notzero = 0; return bin; } E um exemplo de programa utilizando a função: #include <stdio.h> #include <limits.h> #include <string.h> char *binarystr(char *bin, long long int n){ unsigned long long int b = (unsigned long long int)n; static int notzero = 0; char c[] = {'\0','\0'}; if (b){ notzero = 1; c[0] = (b & 1) ? '1' : '0'; binarystr(bin, b >> 1); strcat(bin, c); } else if(notzero) { *bin = '\0'; } else { bin[0] = '0'; bin[1] = '\0'; } notzero = 0; return bin; } int main() { long long int n; char s[1 + 8*sizeof n]; printf(" Decimal -> Binario\n"); n = 12; printf("%20lld -> %s\n", n, binarystr(s, n)); n = 1; printf("%20lld -> %s\n", n, binarystr(s, n)); n = -1; printf("%20lld -> %s\n", n, binarystr(s, n)); n = LLONG_MAX; printf("%20lld -> %s\n", n, binarystr(s, n)); n = LLONG_MIN; printf("%20lld -> %s\n", n, binarystr(s, n)); return 0; }

Onde está o enunciado? De qualquer maneira se é estritamente n > 0 então deveria ser unsigned long int n , mas ainda assim não dá pra retornar todos os valores possíveis de long int n para n > 0 como uma representação decimal do número binário, visto que mesmo para o tipo short só cabe no tipo long long int . Nesse caso seria melhor fazer uma função que imprime o binário ao invés de retornar um número decimal que representa o binário, pois assim poderia converter corretamente qualquer tamanho de número binário, nesse caso a função ficaria assim (também fiz funcionar para números negativos): #include <stdio.h> #include <limits.h> void printbinary(int a){ unsigned int b = (unsigned int)a; static int notzero = 0; if (b){ notzero = 1; printbinary(b >> 1); printf("%d", b & 1); } else if (notzero){ notzero = 0; } else { printf("0"); } } int main() { long int n; printf(" Decimal -> Binario\n"); n = 12; printf("%20ld -> ", n); printbinary(n); n = 1; printf("\n%20ld -> ", n); printbinary(n); n = LONG_MAX; printf("\n%20ld -> ", n); printbinary(n); return 0; } Ou então teria que fazer uma função que recebe um vetor de char como parâmetro e o preenche com uma string que compõe o número binário, mas aí teria que passar 2 parâmetros para a função recursiva: o vetor e o número a ser convertido.

Nenhuma das funções apresentadas até agora funcionam para números negativos (números grandes também seria um problema). Segue uma solução que funciona para números negativos: #include <stdio.h> #include <limits.h> unsigned long long int binary(short a){ unsigned short b = (unsigned short)a; if (b){ return (unsigned long long int) binary(b >> 1) * 10LLU + (b & 1); } return 0LLU; } int main() { short n = 12; printf("Decimal -> Binario\n"); printf(" %6hd -> %16llu\n", n, binary(n)); n = -12; printf(" %6hd -> %16llu\n", n, binary(n)); n = 1; printf(" %6hd -> %16llu\n", n, binary(n)); n = -1; printf(" %6hd -> %16llu\n", n, binary(n)); n = SHRT_MAX; printf(" %6hd -> %16llu\n", n, binary(n)); n = SHRT_MIN; printf(" %6hd -> %16llu\n", n, binary(n)); return 0; } Note que o parâmetro da função precisa ser do tipo short (para limitar a 16 bits) e que o retorno da função precisa ter tipo unsigned long long int para caber o número decimal com 16 casas que representa o número binário no valor retornado.

Não, strcmp() não ignora espaços. Precisa remover os espaços da string também.

@userpc_2020 @AdrianoSiqueira Nenhum dos 2 programas atendem aos requisitos do enunciado, pois de acordo com o enunciado o programa deve ser capaz de ler frases inteiras, e analisar se são palíndromos eliminando os espaçamentos e pontuação antes de inverter e checar se é igual ao sentido normal. Outro problema é que os programas não consideram que pode ter letras maiúsculas e letras minúsculas na frase, e por isso ele pode acusar que não é palíndromo quando realmente é palíndromo, pois em C o caractere de uma letra maiúscula não é considerado igual ao caractere dessa mesma letra minúscula. Eu e o @Mauro Britivaldo postamos soluções mais completas para esse problema nesse tópico: Esse é um exercício comum, segue outro tópico com o mesmo problema:

Segue uma lista do que tem que corrigir no código original postado no tópico: 1 - Incluir as bibliotecas stdio.h e math.h 2 - Mudar o tipo da função calcularhipotenusa para double para retornar um número double 3 - Mudar os tipos dos parâmetros da função c1 e c2 para double ao invés de int 4 - Corrigir a equação para calcular a hipotenusa corretamente usando c1 e c2 5 - Corrigir o tipo da função main trocando o tipo de void para int 6 - Corrigir o especificador de tipo nas funções scanf para usar o especificador correto para o tipo double ( %lf ) 7 - Corrigir o último comando da função main para retornar 0 (zero) ao invés de retornar a função calcularhipotenusa

if(nota > maior){ nota = maior; } else if(nota < menor){ nota = menor; } Estão errados, não é nota que deve receber maior (ou menor), é o contrário, maior (ou menor) deve receber o valor da nota. adicionado 5 minutos depois Não faz sentido usar valores máximos e mínimos do tipo int para variáveis float, se vai usar esse método é melhor usar os valores máximo e mínimo do tipo float. @kampa896 De qualquer maneira recomendo usar a primeira nota digitada como valores maior e menor iniciais.

@devair1010 É que ele chama "alterar um vetor recebido por um ponteiro parâmetro da função" de "retornar através do parâmetro". Retornar não está se referindo a usar a palavra chave return nesse caso.

@XIXX posta o que você tentou fazer e não deu certo.

Sim, nesse caso poderia ler diretamente para o aux, mas deixei separado para deixar claro no código o ponto que eu mencionei de assumir o primeiro número como o máximo inicial. O objetivo era ensinar a lógica não fazer o código mais eficiente possível. Entendendo a lógica fica mais fácil adaptar para casos parecidos com alguma diferença, como no caso em que guardaria todos números digitados em um vetor para serem usados posteriormente no código, nesse caso seria melhor não guardar o número diretamente na variável aux, mas sim colocar no vetor primeiro. Não faz diferença na prática, mas pode sim ser mais fácil de entender para quem está lendo o enunciado e analisando o código. Exato. É bom o programador C saber que os tipos da linguagem são limitados, e aprender sobre as constantes da biblioteca limits.h . Mas essa solução colocando o menor valor int possível como número fixo inicial não é ideal, pois matematicamente isso teria o mesmo problema de colocar o número 0 como valor fixo inicial. É sempre melhor fazer de modo que dependa apenas de comparar os números sendo analisados.

Faça dois vetores um com 5 posições para armazenar o número mínimo para cada linha respectivamente, e outro com 7 posições para armazenar o máximo de cada coluna respectivamente. Aí faz 2 loops aninhados para comparar cada mínimo de linha com todos os máximos das colunas, se encontrar um mínimo na linha e máximo na coluna iguais então checa se a posição da matriz com nessa linha e coluna é a posição que tem esse valor, se for então é sela.

Não precisa saber qual é o menor número possível para o tipo, até porque o tamanho do tipo int varia, pois o int deve ter tamanho de no mínimo 2 bytes, então nesse caso o número menor possível seria −32768, e não -2147483648 (= menor valor possível quando int tem 4 bytes). O melhor método de fazer isso é assumir o primeiro número digitado como o valor máximo inicial, e aí ir comparando os próximos números com o máximo atual e substituir se aparecer um número maior: #include <iostream> #include <locale> using namespace std; int main(){ setlocale(LC_ALL, ""); int num, i, aux; cout << "\nDigite o número 1:"; cin >> num; aux = num; for(i = 2; i < 16; i++){ cout << "\nDigite o número " << i << ":"; cin >> num; if(num > aux){ aux = num; } } cout << "O maior número da lista é: " << aux << "."; return 0; }

Não, não tem o mesmo efeito, o segundo nem pode ser feito. Esse asterisco está no lugar errado, e provavelmente geraria erro. Um ponteiro é declarado assim: int *vari; E o seu problema parece ser que você ainda não aprendeu o que são ponteiros e como usá-los. Tentar dar uma explicação completa sobre ponteiros em C aqui no fórum seria complicado, mas você deve achar explicações pesquisando online. Então vou apenas passar alguns conceitos básicos. Um ponteiro é um tipo de variável que serve apenas para armazenar endereços de memória, e dizemos que "um ponteiro aponta para o local do endereço de memória guardado nele". Para obter o endereço de memória de uma variável usamos o operador & (operador "endereço de") antes do nome da variável, e então esse endereço pode ser guardado num ponteiro. int a = 10; int *ponteiro; ponterio = &a; Note que você já usa o operador & frequentemente na função scanf, ou seja você está passando o endereço da variável para a função scanf, e na função esse endereço é guardado num ponteiro. Uma vez que o ponteiro aponta para um local da memória podemos usar o operador * (operador de indireção ou operador de desreferenciamento) para acessar o valor do local para onde o ponteiro aponta. Então no exemplo acima acessar o local fazendo *ponteiro vai retornar o valor guardado na variável a, ou seja 10, e se alterar o valor deste local da memória fazendo uma atribuição como *ponteiro = 5; vai alterar o valor da variável a para 5 pois esse lugar da memória é onde é guardado o valor de a. Então numa função como scanf, ela pode alterar dentro da função o valor do local do endereço de memória da variável que foi passado para ela, e quando sair da função esta variável vai estar com o novo valor. O tipo do ponteiro indica como os dados guardados no local da memória para onde ele aponta devem ser interpretados, e também qual o tamanho em bytes deste tipo de dado, afinal na memória tanto um valor int quanto um float (ou qualquer outro tipo de dado) são guardados como agrupamentos (bytes) de 0s e 1s indicando estado binário de 1 bit da memória (1 byte = 8bits). Um cast como (float *) serve para converter um endereço de memória de outro tipo em um endereço de memória do tipo float. E esse tipo de cast só deve ser usado para converter endereços de memória. Você tem que usar esse botão para postar códigos no fórum:

Está faltando um argumento ao chamar a função getBaseAdress, você não passou o valor do parâmetro pid . Obs: Address se escreve com 2 Ds.

Isso não faz sentido. O que estaria tentando fazer aqui? Converter um valor inteiro para um ponteiro e armazenar o endereço de memória em uma variável inteira? (float *) é um cast para converter um endereço de memória que aponta para valores de outro tipo, em um endereço de memória que aponta para valores float. Ou seja, ao dar cast de um endereço de memória usando (float *) basicamente está dizendo: Transforme o endereço de memória a seguir em um endereço de memória que quando for desreferenciado (com o operador *) o valor para o qual o ponteiro aponta seja interpretado como um número do tipo float. malloc retorna um ponteiro do tipo void * , em C esse tipo de ponteiro pode ser automaticamente convertido para qualquer outro tipo automaticamente, na verdade possibilitar conversão automática para outro ponteiro é o motivo pelo qual ele existe, logo dar cast no malloc em C é besteira (isso pode até atrapalhar pois tem situações que gerariam warning durante a compilação te avisando que existe algo errado, mas que não vão ser detectados se você tiver usado cast no retorno de malloc).

ponteiro-> é um jeito mais curto de escrever de (*ponteiro). , é uma abreviação mais legível. Na função operacao_lista por exemplo você recebe um ponteiro l para uma struct lista como parâmetro: struct lista* l Então para acessar a struct para a qual o ponteiro l aponta seria necessário desreferenciar o ponteiro fazendo *l , e aí pode acessar campos da struct usando o operador de acesso ponto ( . ) desse jeito: (*l).inicio Mas isso não é algo prático de digitar, e dependendo se isso estiver dentro de outros parênteses ou expressões pode afetar a legibilidade do código. Então criaram um operador com outra simbologia para fazer a mesma coisa, que é a seta -> . Logo, o mesmo campo da struct apontada pelo ponteiro l também pode ser acessado assim: l->inicio

Dá pra usar as lógicas de algoritmos de ordenação, veja os códigos usando o 3 algoritmos de ordenação mais simples: > Insertion Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //INSERTION SORT: //Deve inserir cada novo numero na lista tal que mantem a lista ordenada, //movendo os numeros ja na lista para frente caso necessario, para abrir //espaco para inserir o numero na posicao correta. //Insere o primeiro numero na lista ordenada menor = num1; //Insere o segundo numero na lista ordenada if(menor > num2){ inter = menor; menor = num2; } else { inter = num2; } //Insere o terceiro numero na lista ordenada if(inter > num3){ maior = inter; if (menor > num3){ inter = menor; menor = num3; } else { inter = num3; } } else{ maior = num3; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; } > Bubble Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior, temp; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //BUBBLE SORT: //Vai comparando cada 2 posições consecutivas e trocando caso os numeros //estejam fora de ordem, quando chega ao fim das posições volta para //comparar as 2 primeiras posições. //Poe os numeros na lista desornados menor = num1; inter = num2; maior = num3; //Compara primeiras 2 posições consecutivas e troca se tiver fora de ordem if(menor > inter){ temp = menor; menor = inter; inter = temp; } //Compara proximas 2 posições consecutivas e troca se tiver fora de ordem if(inter > maior){ temp = inter; inter = maior; maior = temp; } //O maior dos 3 ja foi movido para o local correto, agora so falta //ordenar as 2 primeiras posições. //Compara primeiras 2 posições consecutivas e troca se tiver fora de ordem if(menor > inter){ temp = menor; menor = inter; inter = temp; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; } > Selection Sort: #include <stdio.h> int main() { int num1, num2, num3, menor, inter, maior, temp; printf("DIGITE UM NUMERO: "); scanf("%d", &num1); printf("DIGITE UM SEGUNDO NUMERO: "); scanf("%d", &num2); printf("DIGITE UM TERCEIRO NUMERO: "); scanf("%d", &num3); printf("\n"); if ((num1 == num2) || num1 == num3 || num2 == num3){ printf("DIGITE NUMEROS DISTINTOS!!"); return 0; } else { //SElECTION SORT: //Vai para cada posicao procura e seleciona o menor dos valores ainda //nao ordenados e poe nessa posicao. //Poe os numeros na lista desornados menor = num1; inter = num2; maior = num3; //Deve selecionar o menor dos valores desordados para colocar no menor. //Se o valor intermediario for menor que menor atual faz a troca if(menor > inter){ temp = menor; menor = inter; inter = temp; } //Se o valor maior for menor que menor atual faz a troca if(menor > maior){ temp = menor; menor = maior; maior = temp; } //O menor dos 3 ja foi selecionado e movido para o local correto, agora //so falta selecionar o menor entre os 2 numeros que ainda nao foram //ordenados e por como valor intermediario. //Se o valor maior for menor que intermediario atual faz a troca if(inter > maior){ temp = inter; inter = maior; maior = temp; } } printf("MENOR = %d \n", menor); printf("INTERMEDIARIO = %d \n", inter); printf("MAIOR = %d \n", maior); return 0; }

Aqui, eu fui no embalo e já fiz uma função para converter os 4 bytes = 32 bits do float IBM para IEEE754: #include <stdio.h> #include <stdint.h> #include <math.h> float IBMfloattoIEEE754 (uint32_t n){ int sig = (n >> 31) ? -1 : 1; uint32_t pot = (n & 0x7F000000) >> 24; double frac = (double) (n & 0x00FFFFFF) / 0x01000000; return (float) (sig * frac * pow(16.0, pot-64.0)); } int isBigEndian() { int test = 1; char *p = (char*)&test; return p[0] == 0; } uint32_t litEndianUint32_t(uint32_t value){ uint32_t copy = value; if( isBigEndian() ){ copy = ((copy >> 24) & 0xFF) | ((copy >> 8) & 0xFF00) | ((copy & 0xFF00) << 8) | (copy << 24); } return copy; } int main() { uint32_t n = 0x45AFC050; float num = IBMfloattoIEEE754(n); printf("Numero decimal: %f\n" " Hex IEEE754: %X\n" " Hex IBM float: %X\n" "Int do Hex IBM: %u\n", num, litEndianUint32_t(*(uint32_t *)&num), n, n); return 0; }

@gellox Não sei se tem biblioteca que faz isso facilmente disponível. Vou explicar a conversão desse exemplo, e você vê se consegue entender para fazer o algoritmo, ou se te ajuda a entender algum algoritmo pronto que você possa aplicar para o seu caso: O código hexadecimal é: 45AFC050 Ou separando cada byte: 45 AF C0 50 Que em binário fica com 32 bits fica: 01000101 10101111 11000000 01010000 Segundo a especificação IBM temos 1 bit para o sinal, 7 bits para o expoente, e 24 bits para a parte fracionária. Sendo que o número é representado como: (-1)sinal x 0.fração x 16(expoente-64) Então separando os bits no formato 1 - 7 - 24 temos: 0 1000101 101011111100000001010000 Logo: Sinal = 0 = 0 hex Expoente = 1000101 = 45 hex Fração = 10101111 11000000 01010000 = AF C0 50 hex Converter o expoente para decimal é simples: 45hex = (4dec x 161dec) + (5dec x 160dec) = 69 dec Já o número hexadecimal com parte fracionária é mais complicado: 0.AFC050hex = (0decx160dec) + (10decx16-1dec) + (15decx16-2dec) + (12decx16-3dec) + (0decx16-4dec) + (5decx16-5dec) + (0decx16-6dec) = = 0.68652820587158203125dec Logo o número é: (-1)0 x 0.68652820587158203125 x 16(69-64) = (-1)0 x 0.68652820587158203125 x 165 = 719877

@gellox Em geral o formato IEEE754 é o formato usado para armazenar números com parte inteira e fracionária na forma binária, o formato IBM de números com ponto flutuante só é usado em mainframes IBM (e mesmo neles IEEE754 também é usado). O software que você está usando está interpretando o conteúdo do arquivo usando o formato IBM (pela imagem aparentemente pode configurar para usar outro formato), usando este formato os bytes usados como exemplo quando convertidos para um número decimal resultarão no número 719877, mas usando o formato IEEE754 resultariam em outro número na forma decimal. A questão é se você está usando o formato correto ao interpretar esse arquivo. Os números foram armazenados no arquivo usando o formato IBM? Se sim você vai ter que implementar o código para fazer a conversão nesse formato.