Ansi C

Há solução que utiliza a raiz do dividendo (o número a ser dividido) para reduzir a quantidade de divisões|multiplicações|iterações explicitas, sendo uma razão para importar, em específico, math.h sqrt(x) -- calcular a raiz quadrada de seu argumento x -- Observe No caso, a pergunta foi|é se n (número de divisores de x) é igual a 1, ou seja, estaria|está x fora do grupo dos números compostos ou simplesmente é primo. Em tese: * Se x é par x é composto. * Se x>2 tem raiz inteira x é composto. * Se x tem divisores entre x+1 e sua raiz ele é composto. Logo Em duas de três condições a raiz de x é útil para uma solução que corrobora na importação da biblioteca math.h Advirto que às vezes uma resposta não é melhor que o como responde, sendo necessário contemplar o máximo de quesitos estudado|visto|anotados|lidos|etc na aula para ter uma resposta válida, ou seja, um resultado que funciona no fórum não é garantia de resultado. Pergunte mais sobre Observe tuas anotações, há exemplo com uso de funções dessa biblioteca (math)? Se sim, é porque deve ser feito com elas.

A entrada acima, relaciona-se à (a>=b>=c) sendo a primeira instrução IF. Em tese, para uma entrada do tipo: 3 2 1 a saída será: 3 2 1. Conforme o primeiro IF

Um compilador moderno acusaria alguns alerta relacionados com a construção|codificação acima, entre eles estaria o uso de variáveis não inicializadas como número repetição imprevisível. São falhas de semântica|lógica. Comece por avaliar a expressão de fluxo de controle e repetição -- FOR. Lá diz que PARA `i` (indefinido) ENQUANTO `result_joao` (indefinido) MENOR IGUAL `result_ze`(indefinido) FAZ blah, blah,blah, i = i + 1 É definidamente um loop às vezes infinito.

Execute direto no prompt Navegue até a pasta do programa, abra o prompt e o chame diretamente. Se resolver, reinstale o Code :: Block. Experimente o código em IDEs Online, apenas para confirmar que o programa não é o problema.

Olá tudo bem, espero que esteja bem! Seu enunciado, quando eu leio, impressiona ser sobre vetores (type array in c). Fica evidente com a construção abaixo. Veja `t1-10` é, usualmente, um problema de expressão de array: são 10 variáveis contíguas|vizinhas, sendo analiticamente o que define um tipo vetor. A título de curiosidade, o endereço da variável `t10` é menor que `t1` na maioria das implementações e sua diferença (`t1` - `t10`) tem resultado 9. Observe Assim como em um vetor &t10 + 9 = &t1; Logo Esse enunciado fica simples|conveniente, se implementar sobre vetores, penso ser o caso. Porque valor médio (mediana), quase sempre é a média dos valores centrais de uma lista de valores, implicando vetor. Mesmo assim, depende ainda dos assuntos|matérias que estudou.

O separador (.) existe somente no formato de saída, o processo e a entrada permanecem inalterados, independentes dele. Se entender todos os filtros, uma saída sera semelhante à: 86.65 86.62 86.61 86.60 86.56 86.52 86.51 86.50 86.26 86.25 86.22 86.21 86.20 86.16 86.15 86.12 86.11 86.10 86.06 86.05 86.02 86.01 85.66 85.62 85.61 85.60 85.26 85.22 85.21 85.20 85.16 85.12 85.11 85.10 85.06 85.02 85.01 82.66 82.65 82.62 82.61 82.60 82.56 82.52 82.51 82.50 82.26 82.25 82.21 82.20 82.16 82.15 82.12 82.11 82.10 82.06 82.05 82.02 82.01 81.66 81.65 81.62 81.61 81.60 81.56 81.52 81.51 81.50 81.26 81.25 81.22 81.21 81.20 81.16 81.15 81.12 81.11 81.10 81.06 81.05 81.02 81.01 80.66 80.65 80.62 80.61 80.56 80.52 80.51 80.26 80.25 80.22 80.21 80.16 80.15 80.12 80.11 68.66 68.65 68.62 68.61 68.60 68.56 68.52 68.51 68.50 68.26 68.25 68.22 68.21 68.20 68.16 68.15 68.12 68.11 68.10 68.06 68.05 68.02 68.01 66.86 66.85 66.82 66.81 66.80 66.58 66.56 66.52 66.51 66.50 66.28 66.26 66.25 66.22 66.21 66.20 66.18 66.16 66.15 66.12 66.11 66.10 66.08 66.06 66.05 66.02 66.01 65.86 65.82 65.81 65.80 65.68 65.66 65.62 65.61 65.60 65.28 65.26 65.22 65.21 65.20 65.18 65.16 65.12 65.11 65.10 65.08 65.06 65.02 65.01 62.86 62.85 62.82 62.81 62.80 62.68 62.66 62.65 62.62 62.61 62.60 62.58 62.56 62.52 62.51 62.50 62.28 62.26 62.25 62.21 62.20 62.18 62.16 62.15 62.12 62.11 62.10 62.08 62.06 62.05 62.02 62.01 61.86 61.85 61.82 61.81 61.80 61.68 61.66 61.65 61.62 61.61 61.60 61.58 61.56 61.52 61.51 61.50 61.28 61.26 61.25 61.22 61.21 61.20 61.18 61.16 61.15 61.12 61.11 61.10 61.08 61.06 61.05 61.02 61.01 60.86 60.85 60.82 60.81 60.68 60.66 60.65 60.62 60.61 60.58 60.56 60.52 60.51 60.28 60.26 60.25 60.22 60.21 60.18 60.16 60.15 60.12 60.11 58.66 58.62 58.61 58.60 58.26 58.22 58.21 58.20 58.16 58.12 58.11 58.10 58.06 58.02 58.01 56.86 56.82 56.81 56.80 56.68 56.62 56.61 56.60 56.28 56.26 56.22 56.21 56.20 56.18 56.16 56.12 56.11 56.10 56.08 56.06 56.02 56.01 52.86 52.82 52.81 52.80 52.68 52.66 52.62 52.61 52.60 52.28 52.26 52.21 52.20 52.18 52.16 52.12 52.11 52.10 52.08 52.06 52.02 52.01 51.86 51.82 51.81 51.80 51.68 51.66 51.62 51.61 51.60 51.28 51.26 51.22 51.21 51.20 51.18 51.16 51.12 51.11 51.10 51.08 51.06 51.02 51.01 50.86 50.82 50.81 50.68 50.66 50.62 50.61 50.28 50.26 50.22 50.21 50.18 50.16 50.12 50.11 28.66 28.65 28.62 28.61 28.60 28.56 28.52 28.51 28.50 28.26 28.25 28.22 28.21 28.20 28.16 28.15 28.12 28.11 28.10 28.06 28.05 28.02 28.01 26.86 26.85 26.82 26.81 26.80 26.68 26.65 26.62 26.61 26.60 26.58 26.56 26.52 26.51 26.50 26.28 26.26 26.25 26.22 26.21 26.20 26.18 26.16 26.15 26.12 26.11 26.10 26.08 26.06 26.05 26.02 26.01 25.86 25.82 25.81 25.80 25.68 25.66 25.62 25.61 25.60 25.28 25.26 25.22 25.21 25.20 25.18 25.16 25.12 25.11 25.10 25.08 25.06 25.02 25.01 22.86 22.85 22.82 22.81 22.80 22.68 22.66 22.65 22.62 22.61 22.60 22.58 22.56 22.52 22.51 22.50 22.18 22.16 22.15 22.12 22.11 22.10 22.08 22.06 22.05 22.02 22.01 21.86 21.85 21.82 21.81 21.80 21.68 21.66 21.65 21.62 21.61 21.60 21.58 21.56 21.52 21.51 21.50 21.28 21.26 21.25 21.22 21.21 21.20 21.18 21.16 21.15 21.12 21.11 21.10 21.08 21.06 21.05 21.02 21.01 20.86 20.85 20.82 20.81 20.68 20.66 20.65 20.62 20.61 20.58 20.56 20.52 20.51 20.28 20.26 20.25 20.22 20.21 20.18 20.16 20.15 20.12 20.11 18.66 18.65 18.62 18.61 18.60 18.56 18.52 18.51 18.50 18.26 18.25 18.22 18.21 18.20 18.16 18.15 18.12 18.11 18.10 18.06 18.05 18.02 18.01 16.86 16.85 16.82 16.81 16.80 16.68 16.65 16.62 16.61 16.60 16.58 16.56 16.52 16.51 16.50 16.28 16.26 16.25 16.22 16.21 16.20 16.18 16.16 16.15 16.12 16.11 16.10 16.08 16.06 16.05 16.02 16.01 15.86 15.82 15.81 15.80 15.68 15.66 15.62 15.61 15.60 15.28 15.26 15.22 15.21 15.20 15.18 15.16 15.12 15.11 15.10 15.08 15.06 15.02 15.01 12.86 12.85 12.82 12.81 12.80 12.68 12.66 12.65 12.62 12.61 12.60 12.58 12.56 12.52 12.51 12.50 12.28 12.26 12.25 12.21 12.20 12.18 12.16 12.15 12.12 12.11 12.10 12.08 12.06 12.05 12.02 12.01 11.86 11.85 11.82 11.81 11.80 11.68 11.66 11.65 11.62 11.61 11.60 11.58 11.56 11.52 11.51 11.50 11.28 11.26 11.25 11.22 11.21 11.20 11.18 11.16 11.15 11.12 11.11 11.10 11.08 11.06 11.05 11.02 11.01 10.86 10.85 10.82 10.81 10.68 10.66 10.65 10.62 10.61 10.58 10.56 10.52 10.51 10.28 10.26 10.25 10.22 10.21 10.18 10.16 10.15 10.12 10.11 8.66 8.65 8.62 8.61 8.60 8.56 8.52 8.51 8.50 8.26 8.25 8.22 8.21 8.20 8.16 8.15 8.12 8.11 8.10 8.06 8.05 8.02 8.01 6.86 6.85 6.82 6.81 6.80 6.68 6.65 6.62 6.61 6.60 6.58 6.56 6.52 6.51 6.50 6.28 6.26 6.25 6.22 6.21 6.20 6.18 6.16 6.15 6.12 6.11 6.10 6.08 6.06 6.05 6.02 6.01 5.86 5.82 5.81 5.80 5.68 5.66 5.62 5.61 5.60 5.28 5.26 5.22 5.21 5.20 5.18 5.16 5.12 5.11 5.10 5.08 5.06 5.02 5.01 2.86 2.85 2.82 2.81 2.80 2.68 2.66 2.65 2.62 2.61 2.60 2.58 2.56 2.52 2.51 2.50 2.28 2.26 2.25 2.21 2.20 2.18 2.16 2.15 2.12 2.11 2.10 2.08 2.06 2.05 2.02 2.01 1.86 1.85 1.82 1.81 1.80 1.68 1.66 1.65 1.62 1.61 1.60 1.58 1.56 1.52 1.51 1.50 1.28 1.26 1.25 1.22 1.21 1.20 1.18 1.16 1.15 1.12 1.11 1.10 1.08 1.06 1.05 1.02 1.01

Leia o que tiver à mão sobre os vetores (array) e Assista vídeos que contemple a ordenação (sort) Terá o suficiente para construir uma resposta com ordenação em que o maior e menor número estão nos extremos do vetor e o intermediário no meio dele.

Essas operações (acima) são figurativamente esteiras que puxa e empurra todos os bits. Tua meta é ligar e desligar bit em `number` sem empurrar ou puxar o `number` Veja Ao puxar com left `number` (na direção do menos significativo|dividir por 2) a máquina transforma a estrutura. Se persistir nessa estratégia, não aplique no destino (`number`) e de atenção para qual direção vai à tração dos bits porque ela é conforme o índice do bit na constante. Observe Se `number` = (0), e faz `number` &= 1, `number` será 00000000000000000000000000000000, Se `number` = (1), e faz `number` &= 1, `number` será 00000000000000000000000000000001, Se puxar `number`, a máquina fará operações que sobrepõe os bits mais significativos na direção do menos: Logo `number` >>= 1, será 00000000000000000000000000000000 Portanto,

Diz que é esperado o fecha chaves } a partir da linha 43 coluna 6 do arquivo main.cpp e assim concluir o bloco de código aberto na definição da função main() { linha 4 coluna 11.

Tudo bem, eu posso explicar tantas vezes quanto for necessário para entender. Veja As operações (funções) de fila uteis|essências para uma solução|algoritmo foram definidas (abaixo): Tudo que precisa, digo isso porque tenho uma solução, são delas, @oJunior1384 Existe uma lista inicial com duas operações -- enfileirar e desenfileirar, respectivamente no início e no fim da fila. Logo Tua meta será|é construir uma combinação de ‘loops’ e operações (funções) que rotaciona essa lista tantas vezes quanto necessário for para copiar o último termo de cada rotação para uma lista auxiliar. Rotação: é posicionar o último termo da fila na primeiro posição dela, para isso é necessário desenfileira e enfileira n-vezes, ou seja, o tamanho da fila - 1. Observe que Se A é uma fila tipo: A [1 2 3 4 5] E aplicar uma rotação em A, cujo tamanho é 5, fará em um ‘loop’ de 4 repetições que tornará a composição da fila A igual à [5 1 2 3 4], isso porque a cada repetição sua máquina faz `a` = início da fila A, desenfileira A e enfileira `a` em A e repete até o fim do ‘loop’-rotação. Em seguida, no fim da ‘loop’-rotação: basta enfileirar na fila B o início da fila A e desenfileirar A. Assim Nesse ponto B = [5] e A = [1 2 3 4]. Construa o programa para repetir o processo dessa observação até que a fila A fique com tamanho 0. Sendo assim, precisa de 2 loops. Quando o tamanho da fila A é 0 o loop externo para e a composição será: A = [] e B = [5 4 3 2 1], por tanto, B é A inversa.

Uma resposta em três etapas/loops Loop 1. Iterar sobre a lista e imprimir os valores menores que 0, depois Loop 2. Iterar sobre a lista e imprimir os valores igual 0, depois Loop 3. Iterar sobre a lista e imprimir os valores maiores que 0.

Existe uma lista inicial com duas operações -- retirar e colocar termos, respectivamente no início e no fim da lista. Tua meta será|é construir uma combinação de ‘loops’ e operações (funções) que rotaciona essa lista tantas vezes quanto necessário for para copiar o último termo de cada rotação para uma lista auxiliar. Uma rotação é retirar e colocar o termo retirado da lista n-vezes, tal que n é o tamanho da lista - 1, ou seja, no final de uma rotação o primeiro termo dela era seu último. Notará que na última rotação a lista inicial terá 1 único termo que também é|foi o seu primeiro, que ao colocar na lista auxiliar ficará na sua última posição, enquanto a inicial fica vazia, pois a auxiliar é uma cópia invertida dela. Daí a inicial é vazia e auxiliar é|será a nova inicial invertida. @oJunior1384 é isso?

No caso em questão, fez alocação dinâmica e estática do vet. E segue bipolar, conflita entre alocações estática e dinâmica do vetor `vet` em todas as funções. Seria|será|é sábio escolher uma das abordagens. Penso que alocação estática tem mais indicações para o caso de estrutura simples como os vetores.

Eu entendi (fica fácil perceber) que |seria|foi uma exigência|quesito do exercício contemplar a while na solução, mas desse modo é basicamente utilizar o 'loop' para copiar 1 a 1 o valor em `conta` para `x`, sendo um exercício completamente diferente que gasta energia para realizar atribuição de valor. Se a meta é|seria|foi encontrar o valor `x` da equação por intermédio de algo um pouco assemelha à "busca por força bruta", então a `conta` não existe para solução, incrementa-se x no ‘loop’ e sua condição seria|é [Y < função de x] (conforme postagens anteriores).

Ola! Consegue converter e mostrar o resultado duma pessoalmente, isso é: sem eletrificar|construir|codificar em c, somente via notepad ou (papel e lápis) com base em lógica de operações de pilha? Sendo elas: empilhar(stack,push) desempilhar(stack,pop) Isso não é realmente necessário, mas esclarecerá o problema. Veja: Acima, eu observo as pilhas: operadores, operandos, tradução e adequação, sendo essa última a tradução na ordem de entrada. Ou seja, eu espero que no fim da tradução a expressão fique na ordem inversa do formato de entrada, desse jeito: [* - 4 6 + 2 4] Assim, ao desempilhar tradução em adequação terei uma pilha na ordem inversa dos itens (acima): sendo a ordem do formato de entrada, desse jeito: [4 2 + 6 4 - *] Sei também que o operador adição (+) ficou em seguida dos operandos (4 e 2) porque durante a tradução abriu e fechou parenteses, isso é, todos os operadores exceto e antes do abre, que estão na pilha de operadores, foram desempilhados para tradução, nesse caso foi somente o operador adição (+) e, logicamente, os [abre e fecha] parenteses são descartes. É isso,@Lipeco ?

Ola, Função recursiva (Recursion) : são quase instruções ‘loops’ que empilham n-chamadas de si até a conquista da resposta. Exemplo /* Exibir os itens via iteração sobre vetor -- recursiva -- */ void//retorno nulo show(int n,int *array) { if(0<n){ printf("%d ",*array); show(n - 1,array + 1);} } Nota que suas chamadas (internas) decrementam `n` enquanto incrementam o `array` semelhante ao ‘loop’ que percorre o vetor: /* Exibir os itens via iteração sobre vetor */ void//retorno nulo show(int n,int *array) { for(; 0<n ;){ printf("%d ",*array); n = n - 1,array = array + 1;} } Sua tarefa é|seria adaptação de laço para recursiva (from loop to recursion).

Eu penso que esse é um dos problemas, pois ainda não poderia compilar se tem falhas de sintaxe. Veja `valor` é nome de 1 byte. Mas, na expressão abaixo tem as assinaturas de uma matriz. `valor` não é matriz e não há matriz alocada para os valores desejados. Logo um bom compilador, não compila esse programa.

Ola, @Fídias Torres Qual é|foi a pergunta? Se fosse para adivinhar, o meu palpite é|seria algo semelhante à: /* *PERGUNTA * Construa em lingagem de programação c++ um programa *que [1]solicite as dimensões de uma matriz de tipo string *[2], colete suas strings e [3]exiba com formato de tabela no terminal. */ Ative os alerta do compilador, eles fornecem instruções quase sempre precisas do problema quando aponta falhas de sintaxe, e os modernos de sintaxe e lógica, sendo o suficiente para maioria de nós (os iniciantes). Caso não queira, fale mais sobre o problema|pergunta|questão.

Se o tamanho máximo de uma string chegar igual a 100, sua capacidade é igual a 101, isso porque nas funções que operam essa estrutura ela termina logicamente no caractere nulo (0 ou '\0'). A primeira vista esse detalhe aparenta pouco|nenhuma importância, mas produz resultados imprevisíveis.

Olá, tudo bem? Espero que esteja bem! (Para mim) a impressão é que você partiu para construção do código as cegas. Veja O que é a variável p e o que significa vet[p] na declaração (acima)? Qual o sentido|razão para definir|capturar um valor em p depois que já declarou a VLA vet, por que uma variável que alberga a capacidade de um 'array type' se chama 'p'? Essa rotina (acima) funcionou, testou, ativou os alerta do compilador e não teve alerta? Logo Informe mín-máx da capacidade|variáveis no vetor, mas aloque o máximo permitido ou se utilizar de VLA, construa na ordem correta sendo primeiro a captura do número de capacidade em seguida a declaração do vetor, semelhante à: 1 /* Club-do-Hardware: Operação sobre vetores; VLA */ 2 #include"stdio.h" 3 int 4 main( void ){ 5 printf("%s","Ola, por favor informe o tamanho do vetor [1-100]: "); 6 int tamanho_vetor = 0; 7 scanf("%d",&tamanho_vetor); 8 if(tamanho_vetor<0){ 9 tamanho_vetor = (-tamanho_vetor) % 100;} 10 else if(tamanho_vetor>100){ 11 tamanho_vetor %= 100;} 12 else if(tamanho_vetor==0){ 13 tamanho_vetor = 100;} 14 int vetor_vla[tamanho_vetor]; 15 vetor_vla[tamanho_vetor - 1] = 2022; 16 printf("%s\n","Operação-sucedida!"); 17 printf("%s%d%s%d\n", 18 "Vetor[",tamanho_vetor,"] = ",vetor_vla[tamanho_vetor - 1]); 19 return 0;} OU 1 /* Club-do-Hardware: Operação sobre vetores; VLA */ 2 #include"stdio.h" 3 int 4 main( void ){ 5 printf("%s","Ola, por favor informe o tamanho do vetor [1-100]: "); 6 int tamanho_vetor = 0; 7 scanf("%d",&tamanho_vetor); 8 if(tamanho_vetor<0){ 9 tamanho_vetor = -tamanho_vetor % 100;} 10 else if(tamanho_vetor>100){ 11 tamanho_vetor %= 100;} 12 else if(tamanho_vetor==0){ 13 tamanho_vetor = 100;} 14 static int vetor[100]; 15 vetor[tamanho_vetor - 1] = 2022; 16 printf("%s\n","Operação-sucedida!"); 17 printf("%s%d%s%d\n", 18 "Vetor[",tamanho_vetor,"] = ",vetor[tamanho_vetor - 1]); 19 return 0;} Nesse caso há uma escolha (VLA ou static) que depende do assunto que estudou.

Olá, tudo bem? Espero que esteja bem! Sendo um exercício, o melhor é responder somente com os auxílios existentes no livro|apostila|apontamento|páginas eletrônicas ou aplicativo com conteúdo que antecede o exercício e esse enunciado está confuso (pelo menos para mim). Veja O que é saída nesse contexto? Desempilhar e copiar, separadamente, parecem duas funções e a última expressão (copiar na saída) faz-me pensar em escrever no terminal ou qualquer outro destino de saída, daí o motivo da confusão porque o resultado (outputs) é como sugeriu baixo: Existem duas linhas para entrada e saída. Logo Construa sua TDA Pilha conforme o apontamento|livro do exercício que em tese tem as dicas-instruções para conseguir uma interpretação|compreensão desse enunciado.

As funções, quase sempre são definidas a termos de outras funções. Se construir uma função para cada conversão de base numérica sendo o contrário de todas as conversões de uma só vez, no final terá o necessário para agrupar essas soluções num único procedimento intuitivo. Os exemplos de funções de conversão existem, aos montes, e não tenho nada acrescentar àquelas que existem.

Olá tudo bem? Eu espero que esteja bem! Depende dos assuntos anteriormente estudados sendo um caso em que o como responde é MELHOR que só responder e a lógica (que eu sei) não é distante da realidade|natural dos fatos, experimente porque é simples, responda à pergunta (sem código). Notará uma contagem crescente|decrescente a partir da ocorrência do 0, que reinicia sempre que encontra 1, do contrário responde com a posição que iniciou sua contagem, além disso, se atingir o limite da lista antes de terminar, a resposta não é uma posição porque falhou.

Olá, tudo bem? Espero que esteja bem. Tua programação demostra os recursos da linguagem c necessários para construção duma solução. Porém, sem o enunciado completo com exemplos ideias|perfeitos de entrada e saída, torna-se irracional auxiliar essa|qualquer discussão. Veja Etiquetar com ‘media_ponderada’ ou até mesmo com ‘media_ponderada_da_matriz’ é natural porque diz, desse modo, tudo sobre a função e sobre estado de espírito do programador. Logo Antes de postar o enunciado completo com exemplos ideias|perfeitos de entrada e saída, faça uma revisão da pergunta, especificamente, das partes que compõe um cálculo de média ponderada e só assim poste o enunciado completo da questão.

E não! Mas, não há nada sofisticado ou sequer inédito! Veja seria|foi|é uma adaptação que usei para casos de variáveis int Logo #include"stdio.h" /* scanf printf */ #include"float.h" /* FLT_MAX FLT_MIN */ int main(void){ float n1,maior,menor; int cont; menor = FLT_MAX; maior = FLT_MIN; for(cont=1; cont<=5; cont++) { printf("Digite %iº número: ",cont); scanf("%f",&n1); if(n1>maior) maior = n1; if(n1<menor) menor = n1; } printf("O maior número é: %g.\nO menor número é: %g.",maior,menor); } * No seu caso, tuas variáveis são de float e os macros são FLT_MAX, FLT_MIN Resultado