Ansi C

Olá, tudo bem? Espero que esteja bem. Se habilita os alerta do compilador, o primeiro seria sobre o variável `N` que foi usada, porém, não inicializada. Dê oportunidade para edução via compilador com ativação de alerta. Se o n. itens positivos não é menor que negativos deverá um resultado que depende de duas médias: a média (dos itens) e a média somente dos positivos. * Destrave, pense no problema dissociado da questão, faça do problema um sub-exercício e depois importe o que aprendeu. * Codifique uma solução (numa função se preferir) que itera os itens de um vetor e imprime no terminal *, re-codifique a solução anterior para não só imprimir como também adicionar e retornar a soma dos itens *, por último, use a solução para definir a média aritmética; com a divisão de retorno pela quantia de itens Verá código análogo a esta Pode até ser mais|menos verborrágico com relação os nomes das variáveis, o que importa é a lógica. E no caso, existe adição dos itens de `vetPos` em tot, após se calcula o quociente (real) da soma pela quantidade de itens, ou simplesmente, a média.

O como se faz pode ser MELHOR que só fazer Acredito que uma responda deve ser conforme o que estudou antes do exercício (essa é a regra geral) Então * Recorde quais eram os assuntos abordados pré-enunciado do exercício. * Não utilize recursos da linguagem de programação Python que ainda não estudou, ainda que tenha (de alguma forma) conhecimento deles. * Contemple uma solução no mínimo com os assuntos vistos antes desse exercício e também de anteriores: se de algum modo entendeu que serve para o atual. VEJA Acredito que o processo é semelhante ao que se discute no tópico: uma conversão de base 10 (decimal) de inteiro positivo. Cheguei nessa conclusão rapidamente, bastou-me averiguar os exemplos ¹entrada e ³saída do programa. ENTRADA(inputs) 1 5 4 5 8 -1 A saída não é apenas os dígitos juntinhos, é sim um número inteiro (aka) dígitos convertidos numa variável inteiro e impressos após o fim do ‘loop’. RESPOSTA(outputs) print(resposta) #para imprimir o inteiro resposta 15458

Olá, tudo bem? Espero que esteja bem. * Tenho duas suposições. Talvez interessa os recursos na linguagem de programação para responder à pergunta e não escrever uma solução explicita. Do contrário, interessa a uma solução explicita de classificação e não usar uma combinação de métodos do objeto List de C#. * Buscar na documentação C# uma solução que retorne a sub-lista das repetições e com ela determinar as ocorrências e o número de ocorrências. * Iterar a List e no processo usar vetor auxiliar com capacidade igual ao último índice dela e garantir a contagem que não repete o incremento de ocorrências de um número. Para esse objetivo, atribuir valor lógico nos índices do vetor auxiliar após cada nova contagem e ocorrência de valor, uma indicação (lógica) de que o índice da ocorrência será ignorado na próxima contagem. Sugestões.

Olá, de novo. Observe atentamente as saídas (linha por linha). Notará que as sequências são necessárias nas duas últimas saídas. Saídas (resultados) Para não recalcular os termos nas saídas soma e subtração são necessárias variáveis para memorizar as sequências em PA e PG, nesse caso se usa vetor. Caso não queira vetores, repita as expressões que calculam as sequências para produzir esses últimos dois resultados. Os Termos da PG estão arranjados e separados com vírgula (não por nova linha [\n]) #include"stdio.h" int main(void){ int n = 5 , a1 = 1 , q = 2 , an = a1; printf("PG: %d",a1); for(int i = 1; i<n; ++i){ an *= q; printf(",%d",an); } putchar('\n'); return 0; }

Olá, tudo bem? Espero que esteja bem. Para auxiliar a discussão na melhor forma, descreva seu objetivo, exponha quais eram|são as etapas|rotinas|operações do programa e os valores ideais|perfeitos de entrada e saída. No caso de ser um exercício escolar, compartilhe o 'print screen' do enunciado (completo), descreva quais pensa ser as etapas de uma solução e os assuntos que estudou, @chokex Caso tenha dúvida, compartilhe sua versão do código-fonte com dúvida.

Quer a impressão do contador, não somente a cada acúmulo de 1kk e sim também a cada incremento dele? Ao utilizar a impressão usual encheio a tela do terminal de caracteres, para contornar esse formato use o retorno ao inicial da linha com impressão carriage return ('\r'). #include"stdio.h" int main(void){ int contador = 0; while(contador<3000000){ ++contador; printf("\r%d",contador); if((contador%1000000)==0){ printf("\t%d\n",contador); } } return 0; } Assim ou estou viajando, @Thmpv

Olá, não esqueça de contemplar o máximo de comandos numa solução. São tantos comandos que obriga à dispensa das funções padrão para escrever essas rotinas na base de getchar() e putchar(). O que é, etc.? Talvez do, operador condicional (ternário), switch e goto, que corroboraria com a hipótese acima, @gabiz

@Gabrielbxs Existem milhares de coisas mais estimulantes que linguagem de programação, ninguém é punido por não lembrar|procrastinar um exercício no final de período principalmente de c! Solução é pedir adiamento, se ainda não pediu... peça até antes do início do período ou inserção de notas finais. Assista um desses vídeos de 5 horas de duração que existe no YouTube que lá pela metade terá compreendido o necessário para entregar esse trabalho e voltar a viver.

@Thmpv Ola, Aplicada as correções para esse exercício, espero que tenha iniciado a variável de controle do loop , reconheço em novos programadores algumas práticas que vejo em livros velhos encardidos de linguagem c que na atualidade são desnecessárias. Sugiro que declare, doravante, as variáveis junto a seu bloco lógico. Fora as questões estéticas, uma resposta tem seu código-fonte como este: #include"stdio.h" int main(void){ int contador = 1; while(contador<=3000000){ if((contador%1000000)==0){ printf("%d ", contador); } ++contador; } putchar('\n'); return 0; } OU #include <stdio.h> int main(void){ int contador = 1; while(contador<=3000000){ if((contador%1000000)==0){ printf("%d ", contador); } ++contador; } putchar('\n'); return 0; } Tentar é divertido, além humanamento impossível ter o registro exato, existe também a possibilidade de sua impressão ("1000000 2000000 3000000 ") não ocorrer número por número e sim de uma só vez; na saída do loop ou do programa. — É isso!

@Lipeco Aaaah! Meus Parabéns

Precisa de ajuda? Tem o esquema montadinho... agora é resolver cada ‘item’ igualmente o exemplo da atribuição da variável val; notou que existe uma curva da val a variável pr_b[1]? Essa é a deixa para o modus operandi do exercício. Exemplo: j) *(&ptr_b[1] - 2) + 3 Gabarito Tem dúvida pergunte @Lipeco

Penso que é um exercício de imaginação imaginativo, mas dessa maneira é necessário o(s) valor(es) inicial(is)|ou esquema(s) das alíneas. Tem isso ou estou viajando, @Lipeco

Foram boas postagens com temas que não entendia porque não respondia essa pergunta: No final, o Sr. respondeu! Se digo "No final" quero dizer penso que hoje de madrugada. Sinto muito, como assim? Sente muito, por quê? Por demostrar algo inútil e perigoso?

Então diga qual a versão que gostaria de ter visto, certamente não aquele que usou no programa abaixo (de tua autoria): int main(void) { int* de = (int[5]){1, 2, 3, 4, 5}; int* ate = de + 3; exibir_numeros(de, ate); exibir_numeros(ate, de); // tenta ao contrario return 0; } int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", *p); printf(" ]\n"); return 0; } A saída tem "0x0x..." porque a string de formato tem um padrão fora do especificador! Qual o compilador que gera programas sem esse padrão para justificar eles na printf? Então (eu penso que) não pode ou nem sequer deveria tentar, já que é inútil e perigoso. Olhe! Eu sinceramente desisto, não é possível entender seus comentários. — Eu agradeço! Agora sei, entendi... tudo faz muito sentido. Tks! Obrigado!

Está dizendo que as versões instaladas (compiladores) não são escritas conforme uma norma! Esse comentário ficou estranho. — para mim já temos o bastante de discussão sobre main, parâmetros, argumentos e variáveis não utilizadas. FUI!

Poise, eu também!

Tá! Mas, essa é uma resposta a uma pergunta que ser que fiz. Bom! O mesmo que entendi, não a razão para escrever main com parâmetros em sistemas simples ou quando não pretende utilizar. — Legal!

Não faz sentiddo uma norma iso C, não ter nada a ver com C. Então, que tivesse dito com o que tem a ver, senão com C. Com Java, tudo tem a ver com JAVA mesmo OK! Mas, como isso explica o porquê declarar ou não parâmetros na função main, caso tenha sido uma tentativa de explicar refaço a pergunta. Qual o sentido para declarar parâmetro|variável e não utilizá-la? Ata! Também não, por isso perguntei talvez tivesse algo a mais especialista, porém não há razão fundamental. Ainda sim, não existem parâmetros (na função), não difere tanto assim de int main (void). Ok! Mas, que justificativa é essa (principalmente porque não entendi). Então, experimentemos isso fora do prompt, e daí será que essa tal filosofia|religião tem mais adeptos (online). Por exemplo, com solicitação na impressão de arquivo. Outro no prompt — Filosofia...

A norma é complicada ou será que precisa de hábitos de leitura para acostumar com seu conteúdo, é muito formal|normal Caso tenha "leiteiros" iguais a mim que também não clicam em links de postagem, mas curte imagens|recortes de uma Normal (rascunho de Normal 2021), segue abaixo. Cansei de encontrar exemplos com argumento vazio ou indeterminado, nenhum desses exemplos tinha por objetivo escrever chamada recursiva da int main! A impressão que tiro dos exemplos é educar para não declarar desnecessariamente parâmetros|variáveis. Esse recorte é do especificar de impressão "%p" [Tradução]: Logo, se ativa o alerta (avisos) o compilador deve ter uma recomendação semelhante. Mas, curioso mesmo é a Norma deixar a impressão por conta da implementação, porque algumas podem corretamente escrever 0x... e outras não, daí fica o questionamento... não por quê? - ???

Penso que talvez esclareça melhor se falar o que significa não usar um variável|parâmetro|argumento?

Discordo que esteja pouco fora do tópico. É o contrário... a discussão é pertinente não somente às dúvidas com ponteiros: fragilidade, riscos e problematização de programar com linguagem de baixo nível igual à linguagem C (objeto primeiro da discussão), como também expressa importantes informações acerca de compiladores, protótipos de função, desperdício de memória, experimento de sintaxe, etc. A verdade, é que tudo está relacionado. Ou seja, a main não difere muito de outras funções: se tem argumento são alocados, senão... obvio não se reserva nada, tal qual todas as outras funções... logo quem programou o compilador tem razão, como é de se esperar. A escolha de palavras é típica de pessoa com muito idade (pensando bem isso não é preconceito é conceito), mas se ficou ofendido, eu retiro o que disse e permaneço dizendo que, refira-se ao meu nick name do mesmo modo que faz com os outros. De fato, não há nada de especial, muito comum.

Senhor..., que isso..., haja cordialidade..., além disso, evidente que és mais velho, logo dirija-se a meu nick name da mesma maneira que faz com demais. Com relação aos seus exemplos, agradeço muitíssimo, são tão caprichosos, nota-se o esforço para escrever sempre o melhor. O que digo: parabéns! Essa é uma informação pertinente, obrigado por compartilhar que eu não devo usar MSVC, se bem que nunca usei mesmo, então é soma de zeros. Na próxima vez vou simplesmente ignorar. Seria interessante, talvez antes de postar seus resultados, informasse também no topo qual o modelo do compilador, considere isso! É claro que eu notei sua intenção, e fiz igual mesmo... mostrei um exemplo análogo ao seu, no mínimo reforçando sua intenção, agora não resta dúvida quanto a fragilidade|usabilidade dos ponteiros. Ponteiros são velozes, mas sua usabilidade tem risco. Alguém ainda tem dúvida disso? Sabemos que isso está relacionado ao grau de liberdade dos ponteiros não existe maneira mais frágeis ou menos frágeis. Só frágeis: usei um exemplo que utiliza pilha, a falha não é imediata talvez não acontecesse desde que ficasse na pilha, um espaço alocado. Penso que, foi isso. Nota agora que apenas não considero interessante utilizar memória heap (alocação dinâmica de variáveis) para um experimento de risco, apesar de baixo. Só isso! MINHA OPINIÃO? Seja honesto... porque a opinião não é somente minha, mas também daqueles que implementam compiladores, o aviso não é exclusivo para alertar o desperdício de variável com assinaturas e argumentos da main, como está pretendendo educar com seu discursa dirigido à terceira pessoa, mas sim para desperdícios no programa. Ainda que não fossem ativados, pense... qual o sentido de escrever o protótipo da main com argumentos que não pretende utilizar? Apenas para reforça um correto, assim a maioria dos códigos iniciantes, a proposito quase sempre desse fórum, escreveríamos exemplos com dois argumentos e não com nenhum, sendo nenhum a maioria. Em resumo são 4 protótipos: 1. int main(int, int **); 2. int main(int, int *[]); 3. int main(void); 4. int main(); Quando não se dar utilidade para argumentos, recomenda (aviso) utilizar as assinaturas 3, 4 Aviso pega até os desperdícios menores: Desperdício e desperdício não importa o tamanho. Só observo seu conhecimento acerca da elite! Não entendi!

Ps.: Apenas por curiosidade: o for difere tanto assim de WHILE. Escolher entre um e outro é o quê? int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", *p); printf(" ]\n"); return 0; } --------------------------------------------------------------------------------- .LC0: .string "\nMostra valores de 0x%p a 0x%p (inclusive)\n" .LC1: .string "\nx: 0x%p e maior que u_: 0x%p\n" .LC2: .string "Valores: [" .LC3: .string " %d" .LC4: .string " ]" exibir_numeros: push rbp mov rbp, rsp sub rsp, 32 mov QWORD PTR [rbp-24], rdi mov QWORD PTR [rbp-32], rsi cmp QWORD PTR [rbp-24], 0 jne .L2 mov eax, -1 jmp .L3 .L2: cmp QWORD PTR [rbp-32], 0 jne .L4 mov eax, -1 jmp .L3 .L4: mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC0 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] cmp rax, QWORD PTR [rbp-32] jbe .L5 mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC1 mov eax, 0 call printf mov eax, -1 jmp .L3 .L5: mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-16], rax mov edi, OFFSET FLAT:.LC2 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-8], rax jmp .L6 .L7: mov rax, QWORD PTR [rbp-8] mov eax, DWORD PTR [rax] mov esi, eax mov edi, OFFSET FLAT:.LC3 mov eax, 0 call printf add QWORD PTR [rbp-8], 4 .L6: mov rax, QWORD PTR [rbp-8] cmp rax, QWORD PTR [rbp-32] jbe .L7 mov edi, OFFSET FLAT:.LC4 call puts mov eax, 0 .L3: leave ret --------------------------------------------------------------------------------- --------------------------------------------------------------------------------- int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim); return -1; } printf("Valores: ["); { int* p = ini; while (p <= fim){ printf(" %d", *p); ++p; } } printf(" ]\n"); return 0; } ----------------------------------------------------------------------------------- .LC0: .string "\nMostra valores de 0x%p a 0x%p (inclusive)\n" .LC1: .string "\nx: 0x%p e maior que u_: 0x%p\n" .LC2: .string "Valores: [" .LC3: .string " %d" .LC4: .string " ]" exibir_numeros: push rbp mov rbp, rsp sub rsp, 32 mov QWORD PTR [rbp-24], rdi mov QWORD PTR [rbp-32], rsi cmp QWORD PTR [rbp-24], 0 jne .L2 mov eax, -1 jmp .L3 .L2: cmp QWORD PTR [rbp-32], 0 jne .L4 mov eax, -1 jmp .L3 .L4: mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC0 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] cmp rax, QWORD PTR [rbp-32] jbe .L5 mov rdx, QWORD PTR [rbp-32] mov rax, QWORD PTR [rbp-24] mov rsi, rax mov edi, OFFSET FLAT:.LC1 mov eax, 0 call printf mov eax, -1 jmp .L3 .L5: mov edi, OFFSET FLAT:.LC2 mov eax, 0 call printf mov rax, QWORD PTR [rbp-24] mov QWORD PTR [rbp-8], rax jmp .L6 .L7: mov rax, QWORD PTR [rbp-8] mov eax, DWORD PTR [rax] mov esi, eax mov edi, OFFSET FLAT:.LC3 mov eax, 0 call printf add QWORD PTR [rbp-8], 4 .L6: mov rax, QWORD PTR [rbp-8] cmp rax, QWORD PTR [rbp-32] jbe .L7 mov edi, OFFSET FLAT:.LC4 call puts mov eax, 0 .L3: leave ret

— Dica final: ative os alerta do compilador, lembre-se, ele foi/é desenvolvido com ajuda da Elite da Programação.

O acesso é desreferenciar seguindo de leitura|gravação, isto é, se não desreferenciar um ponteiro com endereço ainda não alocado, não acontece a falha de segmentação, evidente que nada impede o programador de passar um endereço desalocado e com isso causar falha por engano|intencional|experimental. Uma estratégia é definir limite logicamente inválido: Como é o caso das ‘strings’ com ‘byte’ 0, outro exemplo é uma lista de idades com idade negativo, até mesmo fornecer o capacidade|tamanho|quantidade das variáveis vizinhas (vetor). Nesse último caso, o primeiro elemento do vetor (primeira variável) tem o seu tamanho e a implementação (função que operará esse vetor) tem potencial para captar esse tamanho, ainda assim, nada impediria um argumento qualquer nessas funções de causar falha lógica ou intencional. Não é O protótipo da main, mas sim UM protótipo da main, essa diferença é importante, apesar de parecer uma pouco pedante... A elite de programadores em C chegou no consenso de que há situações em que esses argumentos são dispensáveis, por conta disso tanto a norma quando os compiladores modernos são inflexíveis quando à declaração int main(...). Sendo main(int argc, char *arg[]) Sendo main(void) Sendo main() Sendo main(int argc, char **arg) Sendo que dois explicitamente descarta argumentos para aquelas situações em que são descartáveis. Observe que na sua exemplificação de como causar uma falha modificou o índice de um ponteiro. Nesse caso: Veja seu análogo: int exibir_numeros(int* ini, int* fim) { if (ini == NULL) return -1; if (fim == NULL) return -1; printf("\nMostra valores de 0x%p a 0x%p (inclusive)\n", ini, fim[100]); if (ini > fim) { printf("\nx: 0x%p e maior que u_: 0x%p\n", ini, fim[100]); return -1; } int* p = ini; printf("Valores: ["); for (int* p = ini; p <= fim; p += 1) printf(" %d", p[100]); printf(" ]\n"); return 0; } Nada difere em nada . Com relação os argumentos da função pensei o mesmo que a Elite da Programação, porém com há discussão de duplos ponteiros continuei seguindo contagiado. Concordo não haver garantia.