arfneto

Rodando o programa como postado Digite a quantidade de pessoas [max.2147483647]: 4 M s M S F f f n O n·mero de pessoas que responderam sim e: 0. O n·mero de pessoas que responderam nÒo e: 0. A percentagem de pessoas do sexo feminino que responderam sim e: 0.000000. A percentagem de pessoas do sexo masculino que responderam nÒo e: 0.000000. como usou acentos e não se preocupou com a configuração de locale e coisas assim alguns acentos e caracteres da lingua portuguesa podem não ser impressos. como testou o retorno de scanf --- apenas em um ponto e não em todos --- comparando com EOF ao invés de usar o número de especificadores, seu programa falha se teclar algo diferente de 1 e 0, que foi a interpretação que usou para SIm e Não. Seis casas decimais para uma porcentagem de pesquisa de 4 opções talvez seja exagerado. E um sinal % seria bem-vindo Sei que julgou lindinho e belezinha e que está satisfeito julgando você mesmo o teor de sua resposta --- muito normal para um forum --- mas talvez pudesse ainda considerar que: o que está bom pode melhorar informar ao usuário que ele pode digitar até 2,14 bilhões de questões talvez seja um exagero. Incluir limits.h somente para poder usar INT_MAX talvez seja menos efetivo do que usar um limite mais perto de uns 10 elementos, ao invés de INT_MAX, que pode ser considerado exagerado para um programa interativo. Afinal alguém vai ficar lá digitando. E se passar de uma tela fica ruim pra conferir os valores. algum tipo de instrução ao usuário sobre o que se espera que ele digite até esse limite seria uma cortesia interessante, e aceitar minúsculas e maiúsculas seria também cortês. E trocar "S/N" por "1/0" não parece somar nada ao código ou à experiência de uso dele. Talvez devesse se ater ao enunciado. contar as respostas, algo como "1 de 2147483647" ajudaria a lembrar ao usuário quanto falta para terminar, ou a se posicionar se estiver copiando as respostas de uma lista numerada. desconsiderar respostas inválidas pode ser efetivo, para manter as porcentagens auditáveis e evitar a fúria de um usuário ao errar na 10a de 11 respostas. outros não é usado para nada, podia assim não existir. o programa usa 4 acumuladores e depois soma ao final para conseguir o total por sexo. Só que o enunciado pede apenas o total por sexo e o total positivo para feminino e o total negativo para masculino. Assim ao acumular femnao e mascnao o programa faz uma soma final sem necessidade. Ao invés de if (sexo == 'f') { if (resp == '1') femsim++; if (resp == '2') femnao++; } else if (sexo == 'm') { if (resp == '1') mascsim++; if (resp == '2') mascnao++; } else outros++; Prefira por exemplo if ((resp == 's') || (resp == 'S')) { if ((sexo == 'f') || (sexo == 'F')) ++i, ++sim, ++fem_sim; else if ((sexo == 'm') || (sexo == 'M')) ++i, ++sim; } else { if ((resp == 'n') || (resp == 'N')) { if ((sexo == 'm') || (sexo == 'M')) ++i, ++não, ++masc_nao; else if ((sexo == 'f') || (sexo == 'F')) ++i, ++não; } } Que só avança se a resposta for válida. aceita SNsnMFmf. conta as respostas não cancela se o cara digitar errado. int outros = 0; int femnao = 0, mascnao = 0; int femsim = 0, mascsim = 0; Todos esses valores são quantidades (não-negativos) e estariam melhor representados como unsigned. Sobre putchar('\n'); int resps = mascsim + femsim; int respn = mascnao + femnao; int fem = femsim + femnao; int masc = mascsim + mascnao; printf( "O número de pessoas que responderam sim e: %d.\n" "O número de pessoas que responderam não e: %d.\n" "A percentagem de pessoas do sexo feminino que " "responderam sim e: %f.\n" "A percentagem de pessoas do sexo masculino que " "responderam não e: %f.\n", resps, respn, (femsim * 100.0) / (fem > 0 ? fem : 1), (mascnao * 100.0) / (masc > 0 ? masc : 1)); putchar('\n'); É difícil entender duas chamadas a putchar apenas para gravar '\n' na saída. Porque não estão esses '\n' na mesma chamada a printf? São só dois símbolos. Prefira printf( "\n\ %d pessoas responderam sim.\n\ %d pessoas responderam não.\n\ %6.2f%% das pessoas do sexo feminino responderam sim.\n\ %6.2f%% das pessoas do sexo masculino responderam não\n\n", sim, não, (fem_sim * 100.0) / (sim > 0 ? sim : 1), (masc_nao * 100.0) / (não > 0 ? não : 1)); Que mostra algo como 2 pessoas responderam sim. 2 pessoas responderam não. 50.00% das pessoas do sexo feminino responderam sim. 50.00% das pessoas do sexo masculino responderam não Que é a mesma coisa mas é mais fácil de ler e de alinhar, e não tem as duas chamadas a putchar, simplesmente porque os dois '\n' estão na (única) chamada a printf. E parece mais fácil de ler na saída e no código. Entenda que não tem controle sobre onde vão usar seu programa, então se vai usar acentos e caracteres de algum idioma particular deve chamar locale e configurar a página de código de acordo. Veja no início desse post que a saída não ficou assim ok em algum computador. Sobre esse trecho int n = -1; /* valor negativo sendo uma não quantidade */ scanf("%d", &n); if (n <= 0) return 1; // ... for (int i = 0; i < n; i++) { int r = scanf(" %c %c", &sexo, &resp); if (r == EOF) break; Considere É sabido então que scanf retorna um int. Usou n = -1 inicialmente para poder encerrar o programa se scanf não ler nada, por exemplo porque o usuário teclou uma letra por engano. Só que na chamada seguinte declarou e usou r para receber o retorno de scanf. Por uma questão de consistência, no mínimo, deveria fazer a mesma coisa nos 2 pontos: ou trata o retorno de scanf ou coloca um valor sentinela numa das variáveis de scanf. entenda que ao usar o especificador " %c %c" scanf pode retornar -1, 0, 1 ou 2, já que é um scanner e pode ler apenas uma letra, e aí seu programa já era. Teste sempre o retorno de scanf comparando com o total de especificadores, 2 nesse caso. Use: if (r != 2) break; considere uma mensagem de erro. Considere também usar continue ao invés de break e simplesmente ignorar essa entrada. Imagine você mesmo digitando 10 de 12 números e aí erra na hora de digitar a resposta. Não seria melhor ignorar, ou avisar o usuário? Esse é um comportamento de programa que enfurece o usuário, ou mesmo o autor do programa tentando testar... Entenda que "%c %c" também aceita as duas letras juntas, como SM ou m0 no seu caso Isso está correto printf( "%s%d%s", "Digite a quantidade de pessoas [max.", INT_MAX, "]: "); mas é 'difícil de ler e alinhar, e mais lerdo: está passando 3 parâmetros, incluídas duas constantes, para printf. Se escreve por uma nota ou em um trabalho ou entrevista prefira o simples e mais legível printf( "Digite a quantidade de pessoas [max = %d]: ", MAX_RESP); porque é muito mais rápido, e simples de alterar sem ter que ficar procurando campos.´É assim em java, Python, C# e C++ por exemplo. Deve ter uma razão. EXEMPLO Considerando o que eu disse e alterando um pouco o seu programa, uma possível implementação seria: (saída de uma execução) Digite a quantidade de pessoas [max = 12]: 4 Vai ler 4 respostas SsNn MnFf Use uma linha para cada resposta, com 'S' ou 's' para gostei, 'N' ou 'n' para não gostei, e 'M' 'm' 'F' 'f' para o sexo [1 de 4]: s Y [1 de 4]: Y s [1 de 4]: s m [2 de 4]: s F [3 de 4]: N m [4 de 4]: n F 2 pessoas responderam sim. 2 pessoas responderam não. 50.00% das pessoas do sexo feminino responderam sim. 50.00% das pessoas do sexo masculino responderam não Note que pode usar maiúsculas ou minúsculas para as respostas apenas respostas válidas são consideras prompts de instrução são mostrados ao usuário a formatação é mais simples. O código do exemplo, completo #define MAX_RESP 12 #define DEF_RESP 4 #include <stdio.h> int main(void) { unsigned n = 0; unsigned res = 0; printf( "Digite a quantidade de pessoas [max = %u]: ", MAX_RESP); res = scanf("%ud", &n); if (res != 1) return -1; if (n > MAX_RESP) n = DEF_RESP; printf("Vai ler %d respostas\n", n); char sexo = 0; char resp = 0; unsigned masc_nao = 0; unsigned fem_sim = 0; unsigned sim = 0; unsigned não = 0; printf( "\ SsNn MnFf\n\ Use uma linha para cada resposta, com 'S' ou 's' para gostei,\n\ 'N' ou 'n' para não gostei, e 'M' 'm' 'F' 'f' para o sexo\n\n\n"); for (unsigned i = 1; i <= n;) // incrementa apenas se for valida { printf("[%u de %u]: ", i, n); res = scanf(" %c %c", &resp, &sexo); if (res != 2) continue; if ((resp == 's') || (resp == 'S')) { if ((sexo == 'f') || (sexo == 'F')) ++i, ++sim, ++fem_sim; else if ((sexo == 'm') || (sexo == 'M')) ++i, ++sim; } else { if ((resp == 'n') || (resp == 'N')) { if ((sexo == 'm') || (sexo == 'M')) ++i, ++não, ++masc_nao; else if ((sexo == 'f') || (sexo == 'F')) ++i, ++não; } } } printf( "\n\ %d pessoas responderam sim.\n\ %d pessoas responderam não.\n\ %6.2f%% das pessoas do sexo feminino responderam sim.\n\ %6.2f%% das pessoas do sexo masculino responderam não\n\n", sim, não, (fem_sim * 100.0) / (sim > 0 ? sim : 1), (masc_nao * 100.0) / (não > 0 ? não : 1)); }

Não é o caso. Esse RE200 poderia estender uma rede mesh, mas o C80 não pode prover uma para ser estendida. Mas o RE200 pode estender a rede wifi do C80 ou a rede da VIVO que você desabilitou. Se usa TV ou telefone no aparelho da VIVO vai mesmo ter problemas se usar bridge, porque bridge é exatamente isso: ponte. O aparelho da VIVO passa a operar apenas como um conversor de midia, oferecendo uma conexão IP do outro lado da fibra. E você deve transferir, como jã sabe, a autenticação PPPoE para o roteador escolhido para ligar nessa conexão IP que vem do aparelho da VIVO. No geral isso não é produtivo em uma casa. Os aparelhos mais ou menos modernos da VIVO de até uns 3 anos de uso, tem 3 ou 4 portas ethernet e wifi dual-band mais ou menos na classe AC1800, 400 + 1400 mbps wifi 5 dual band. Tenho uns desses contratados. Os mais novos (desse ano) podem ter wifi6 e já vem com pontos mesh na instalação. Ainda não usei nenhum desses. Numa casa. em especial se for comprida ou tiver vários pisos, usar bridge é uma coisa estranha e não sei de onde vem a ideia de que isso possa ajudar. Eis o que acontece, juntando a simples aritmética e as leis da física: Ao usar por exemplo o C80 e um ASkey de 4 portas da VIVO você tem 6 portas ethernet para usar, e pode por 3 em cada piso. Se usar bridge vai ter 4 em um só lugar e pode precisar de cabos muito compridos (mesmo) para atingir ambientes distantes. A performance não muda quase nada porque a capacidade de comutação dos dois é de 2gbps por porta. Se usar bridge perde a metade delas. Aritmética. A questão do wifi é similar: os dois aparelhos são dual band. Já deve ter percebido que wifi a 5ghz é super rápido, o C80 pode conectar a 433mbps ou mais via wifi 5ghz, por exemplo. E o aparelho da VIVO também. Mas deve ter percebido também que 5ghz raramente presta a partir de duas paredes... E 2.4 vai longe mas é muito mais lerdo.... Se você usar bridge vai ter que usar antenas em um lugar só. e vai perder toda a banda que o VIVO ofereceria. Se ele for tipo AC1800 é isso que vai perder. Todos os 1800 e mais a cobertura das antenas dele. Isso quer dizer que se usasse os dois um em cada piso poderia ter 5ghz a 433 mbps em locais opostos da casa. o que não pode nem com o VIVO nem com o C80. O repetidor não acrescenta nada, porque ele vai comer da banda do aparelho cuja rede ele estiver repetindo. Mas bem posicionado melhora a cobertura. Não é por isso. Esse aparelho não oferece isso. Tente um AX73 por exemplo, ou mesmo um AX10 ou AX12 dessa marca. Mas o repetidor, como eu disse, vai usar da banda que esses aparelhos oferecem, como todo repetidor. A única coisa que a rede mesh vai oferecer, em troca de uma boa grana, é essa transitividade transparente. Se isso é de fato importante pode usar um Deco X20 dessa marca, e projetar uma rede wifi nele e colocar no outro piso. E mesmo assim manter os dois roteadores para usar os cabos. Em geral o fato de ter mais de uma rede wifi não é importante, porque esse "roaming" do mesh só afeta mesmo o cara que quer fica andando com o celular pela casa sem ter que eventualmente mudar de rede porque o algoritmo do aparelho ainda não percebeu a ruína do sinal do térreo e passou para a rede wifi do outro piso. As senhas em si já estarão memorizadas nos aparelhos e a vida segue normal. Os maiores consumidores de banda são as TV e os computadores, em especial se usa games online. E nesses casos mesh de nada resolve e pode até ser ruim porque os aparelhos mesh baratos se conectam via wifi, um contra-senso total. O simples em casas é colocar um roteador ao lado de cada TV, assim usa cabos curtos de rede. E interligar os pisos via cabo. E ligar todos os aparelhos via LAN ao roteador principal. Uma única rede IP. Um servidor DHCP em cada roteador deixa a conexão inicial muito mais ágil porque diminui a latência e já serve de backup. Em geral casas construídas a partir dos anos 60 tem um duto para telefone que segue pela casa toda. Lugares mais modernos tem muito mais opções, com dutos para automação, alarme. TV e tal, de modo que passar os cabos não é problemático.

Se os exemplos e a explicação que eu deixei nos post anteriores (que achei até detalhada) --- e quem sabe o debugger em seu computador --- não foram capazes de te fazer entender talvez deva fazer abrir um tópico e fazer uma pergunta objetiva. Não estou de fato respondendo individualmente a você, então não vou mais fugir do assunto PA. Se mais usuários tiverem dúvida semelhante à sua, nesse tópico, voltamos a isso. O forum não é, claro, suporte individualizado, e a pergunta vem de junho de 2022, de outro usuário, @DanielC4 A fonte é a realidade: scanf não aloca memória, espera apenas um ponteiro para onde transferir os dados obtidos. Se vai ler algo usando um especificador em hexadecimal esses dados vão ser transportados linearmente para aquele endereço e vão ser interpretados dependendo do tipo de dado cujo endereço foi passado. Por isso pode ainda precisar considerar coisas como alinhamento de memória e endianess, porque vai ser feita uma transferência cega, como um memcpy, se acaso conhece. Entendeu a razão dessa linha const char ansi[20] = "49534E4100"; gerar "ANSI", no exemplo? Rode o programa que te mostrei. Se mesmo assim não entender tente o debugger e veja a memória. Ou poste uma questão, para não fugir do tópico aqui. Em mais uma tentativa de explicar isso, veja um exemplo usando o debugger da MS: com o programa rodando, veja a memória no printf() logo depois da chamada a scanf. Não sei de sua experiência com essas coisas, seus posts não foram suficientes para eu ter uma ideia, mas imagino que saiba usar o gdb além do gcc, por exemplo. const char valor[] = "42280000"; float v_float = 0.; res = sscanf(valor, "%8x", (unsigned int *)&v_float); printf("res: %d, float: %f\n", res, v_float); Essa linha mostra o endereço de v_float num debugger, com o programa parado nessa linha: Então você vai lá na memória e examina esse endereço: e vê que o valor da string em hexa foi simplesmente lido como valores abstratos e copiado para o endereço de v_float no endereço terminando em D4... scanf fez isso, na linha anterior: antes dela v_float valia zero. Entenda que esse é o modelo de memória x64, então os ponteiros tem 64bits, e o programa está rodando numa máquina Intel não Itanium, então Little Endian. Se não souber o que são essas coisas abra outros tópicos. Essa é a "fonte". Espero que possa entender. No caso de o alvo ser um int daria na mesma: os bytes são apenas transferidos. scanf() é uma mão na roda. Sobre o tópico e a pergunta original vou apenas repetir os comentários e as funções que já expliquei: // busca 'valor' na 'pa' de 'n_termos` int busca(int pa[], unsigned n_termos, int valor); // mostra 'pa' na tela. 'msg' = mensagem opcional int mostra( int pa[], unsigned n_termos, int razao, const char* msg); // calcula os valores e preenche os 'n_termos' da pa // de razao 'razao' iniciando em 'inicial' int preenche( int pa[], unsigned n_termos, int inicial, int razao); e como usar? Isso no exemplo do post #8 preenche(pa, 10, -22, -22); mostra(pa, 10, -22, "teste com r = -22\n"); gera teste com r = -22 termo inicial: -22, razao: -22 10 termos: -22 -44 -66 -88 -110 -132 -154 -176 -198 -220 Ainda tem mesmo uma pergunta sobre esse tópico? Entendeu que é uma PA de razão -22 a partir de -22? E como busca um valor na PA? De novo do exemplo res = busca(pa, 10, -22); printf("res = %d\n", res); res = busca(pa, 10, 0); printf("res = %d\n", res); gera res = 1 res = 0 e isso quer dizer que -22 foi encontrado e 0 não foi... Espero ter ajudado a quem ainda não tenha entendido isso. Sei que já perguntei antes 2x e não respondeu, mas isso foge da minha compreensão. Se alguém entendeu e puder explicar tem meu interesse. Sobre densidade de colunas e conexão de valores nesse contexto.

Use o trecho que te mostrei. 0xff. Não é um inteiro. É um valor abstrato. Eu te mostrei 3 exemplos. E está ao final do código do exemplo, então você pode testar por si mesmo. E pode ler o que escrevi, em português, explicando o porque está errado. Esse é um forum, estilos e opiniões são ok, mas ainda o tema é C, C++ e C#. Uso essas linguagens regularmente e elas não são afeitas a opiniões, por outro lado. Em C constantes em hexadecimal estão descritas no standard. Mas isso é para programas em C, para compilar o código. Quando se usa um especificador como %8x em scanf para ler um valor hexadecimal é só isso: um valor abstrato. Entenda que scanf não aloca memória então espera um endereço para onde transferir o valor. E vai fazer isso: scan formatted, afinal é de onde vem o nome da função. E o valor eventualmente escaneado vai ser transferido para o endereço passado. Nada mais. Por isso mostrei 3 exemplos usando float e char*. Usar int nada acrescentaria. Se tem dúvida ainda, use um debugger e avalie. Não depende de minha opinião ou da sua. Pois é. Sobre não compilar sei que é frustrante copiar algum código de terceiros e não conseguir sequer compilar, mas o que posso te dizer é que isso é bobagem. Do compilador ou das opções de compilação de eventualmente usou. Postei também a saída do programa e incluí esse trecho que expliquei apenas para dar um exemplo de como usar, em 3 opções, como eu havia explicado. É difícil imaginar que um programa assim não compilasse... Imagino que saiba ler as mensagens do compilador que usou. Num primeiro momento tratar todos eventuais avisos como erros pode até ser saudável, em especial para iniciantes, mas pode se transformar num exagero. Você não se deu ao trabalho de mostrar as opções de compilação que usou. Não sei como reproduzir exatamente essa saída que conseguiu, e nem acho importante. Vendo essa linha por exemplo: Vou explicar isso aqui porque outros podem ter dúvida: se ler o exemplo verá que v_float é float se ver o manual vai entender que scanf espera algo do tipo unsigned int* para carregar algo lido com %x &v_float é float* que por certo não é unsigned int* e é isso que seu compilador está reclamando. Isso seria um Warning e deveria gerar o código normalmente. Afinal reclamar de um ponteiro int* não ser unsigned int* é mesmo pedante. mesmo o (int*) antes de &v_float já é um tanto exagerado. Não por acaso algumas das opções de compilação que tratam disso contém essa palavra... -Wpedantic --pedantic errors -Werror apenas não compile com essas opções, ou complete o cast com unsigned um ponteiro pós-anos90 em windows depende apenas do modelo de memória, x86 ou x64, e terá o mesmo comprimento. apontando para qualquer coisa: 4 ou 8 bytes nessas máquinas comuns. Um cast para mudar o tipo só é chato. Devia ter usado Ao usar uma opção fora do padrão deve se preparar para resultados assim. E, por uma questão de isenção, acho que se usa uma opção assim em um forum público devia deixar isso explícito ao postar código ou ao sinalizar códigos de outros como não-compiláveis. E se preparar para alterar códigos que copie de forums. E considere que há dezenas de compiladores disponíveis e dizer simplesmente que não compila com o único que usou pode ser ingênuo ou exagerado. Até tentei reproduzir aqui, mas a única máquina que está livre agora e com esse compilador tem a versão 13.2.1 de outubro de 2023, e não dá nenhum erro. TL;DR Para quem nem leu, nem entendeu ou nem quer pensar nisso, pode usar esse trecho apenas para entender o que eu expliquei sobre scanf e entrada em hexadecimal #include <stdio.h> int main(void) { const char valor[] = "42280000"; float v_float = 0.; int res = sscanf(valor, "%8x", (unsigned int*)&v_float); printf("res: %d, float: %f\n", res, v_float); const char ansi[20] = "49534E4100"; char str[8] = {0}; res = sscanf(ansi, "%8x", (unsigned int*)str); printf("res: %d, string: \"%s\"\n", res, str); const char* xff = "0xff"; res = sscanf(xff, "%s", str); printf("res: %d, string: \"%s\"\n", res, str); return 0; } E a saída deve ser res: 1, float: 42.000000 res: 1, string: "ANSI" res: 1, string: "0xff" Essa parada de opções de compilação e plataformas e sistemas é importante. Conheça seu ambiente e seu compilador. que significa? densidade de coluna e conexão entre valores nesse caso? Ainda estou curioso pelo que seriam esses conceitos, se relacionados à pergunta. Acha mesmo que um programa com essas funções incluídas // busca 'valor' na 'pa' de 'n_termos` int busca(int pa[], unsigned n_termos, int valor); // mostra 'pa' na tela. 'msg' = mensagem opcional int mostra( int pa[], unsigned n_termos, int razao, const char* msg); // calcula os valores e preenche os 'n_termos' da pa // de razao 'razao' iniciando em 'inicial' int preenche( int pa[], unsigned n_termos, int inicial, int razao); Não tem a ver com o enunciado? E com a saída que mostrei teste com r = 1 termo inicial: 1, razao: 1 10 termos: 1 2 3 4 5 6 7 8 9 10 teste com r = -22 termo inicial: -22, razao: -22 10 termos: -22 -44 -66 -88 -110 -132 -154 -176 -198 -220 res = 1 res = 1 res = 0 res: 1, float: 42.000000 res: 1, string: "ANSI" res: 1, string: "0xff" Com duas PA? Talvez eu não tenha me explicado bem afinal.

Muito está errado nesse programa, com problemas na lógica, no modo de escrever um programa nessa linguagem, no uso de `scanf` e mesmo na compreensão do que é uma Progressão Aritmética, do ensino fundamental. As respostas até parecem não endereçar esses problemas e até criam outros, então pode haver utilidade em alguma discussão agora, para uma questão de '22 Porque deu errado? Esse trecho do programa tenta primeiro mostrar a PA e depois calcular os valores. Sem sentido. for (i = 0; i <= 9; i++){ printf ("\n%d\n", sequencia[i]); } while (sequencia[0] <= sequencia[9]){ printf ("%d\n", sequencia[0]); sequencia[0] += r; } esse não é o conceito de PA. Isso --- que está na ordem errada --- também está errado. Isso levaria apenas a p[0] = p[0] + 9r; só que a definição de PA 'de termos p e razão r é p[i+1] = p[i] + r; e claramene iria deixar o resto da sequência sem qualquer alteração. Como o valor sequer foi inicializado então o resultado é indefinido, UB na literatura. é claro que se a razão for negativa sequencia[0] só vai diminuir, e o programa vai entrar em loop até cancelar levou uns anos pra arrumarem isso em C mas foi feito nos anos 70 e as variáveis de controle de um loop podem e devem ser declaradas no loop --- claro, a menos que a lógica impeça --- em especial para nomes ingênuos como i evite as chaves desnecessárias a menos que sua empresa ou escola obrigue seu uso use funções. `C` é inútil sem funções: você precisa de uma função para: preencher uma PA mostrar uma PA obter razão, termo inicial e termo a pesquisar na série uma função para pesquisar na PA Usando funções você simplifica tudo. Pode testar em separado e usar em outros programas. E é pra isso que se escreve código. mais sobre o código original Isso é até eficiente nesse caso: if (n != sequencia[0] && n != sequencia[1] && n != sequencia[2] && n != sequencia[3] && n != sequencia[4] && n != sequencia[5] && n != sequencia[6] && n != sequencia[7] && n != sequencia[8] && n != sequencia[9]) { printf( "\nO número %d não se encontra na sequência.\n", n); } else { printf( "\nO número %d se encontra na sequência.\n", n); } Mas tem pouco sentido. E se fossem 10 mil termos? Use um loop. não escreva programas interativos. Coloque essa parte depois que o programa estiver pronto. Só perde tempo com isso, inventando números a cada teste não inclua headers que não usa. Espere precisar deles e então inclua. @devair1010 pra que serviria isso no exemplo? int prototipo(int, int, int*); Sobre esse trecho #define _WIN32_WINNT 0x600 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <windows.h> Isso praticamente limita o uso do exemplo a maquinas rodando Windows. Pode ser exagerado para um programa simples de busca em vetor. Alguns leitores usam MAC ou Linux for (i = 0; i < 10; i++) /// esse modo eh mais normal { printf( " Sequencia[%d]= %3d \n", i, sequencia[i]); /// aqui sem inicializar o vetor } /// as posições acima de zero contem valores /// desconhecidos , lixo de memória while (sequencia[0] <= sequencia[9]) { printf("sequEncia[0] = %d\n", sequencia[0]); sequencia[0] += r; } Sei que em do original, mas como eu disse, isso está errado. Teste seu programa. Teste seu programa com valor inicial = -42 e razão -42. Sem surpresas ele entra em loop... ret = scanf("%d", &sequencia[0]); /// apenas um numero será armazenado no vetor printf("Ret= %d\n",ret); if(ret != 1)return 0; printf("Digite uma razAo: "); scanf ("%d", &r); printf("Digite um nUmero a ser pesquisado na sequEncia: "); scanf ("%d", &n); Se testou uma vez o retorno de `scanf` é porque sabe a razão. Porque não usou nas outras chamadas? @Ansi C que significa? densidade de coluna e conexão entre valores nesse caso? Não funciona assim. 0xff não é um inteiro. Zero é um inteiro. E é isso que vai ser lido. A "oportunidade de ler um segundo" não viria mesmo, mas não é por isso. É preciso consumir esses dados antes de chamar scanf de novo. Digite um termo inicial: 0xff Digite uma razão: Digite um número a ser pesquisado na sequência: ``` Se perguntasse a um romano na idade média ele diria que XLII é 42, inteiro. `scanf` pode ler valores em hexadecimal ou octal, mas não serão inteiros. E não pode resolver na hora da entrada como os valores serão lidos, porque tem que mudar o especificar de scanf e o programa que já está rodando deveria ser compilado de novo... De todo modo usando especificadores %x serão valores abstratos e convertidos para o tipo dado pelo argumento para `scanf`. - Se ler 49534E4100 usando %08x em uma máquina comum Intel e ler em um char[8] vai ver que leu "ANSI", sem surpresas - Se ler 0x42280000 usando %4x na mesma máquina vai ler 42. em um float. - Se ler 0xff em um char[8] usando %s vai ler "0xff" como esperado. Uma string. - Se ler 0xff em um int usando %i vai ler 0. Nada mais. EXEMPLO: Esse trecho de programa const char valor[] = "42280000"; float v_float = 0.; res = sscanf(valor, "%8x", (int*)&v_float); printf("res: %d, float: %f\n", res, v_float); const char ansi[20] = "49534E4100"; char str[8] = {0}; res = sscanf(ansi, "%8x", (int*)str); printf("res: %d, string: \"%s\"\n", res, str); const char* xff = "0xff"; res = sscanf(xff, "%s", str); printf("res: %d, string: \"%s\"\n", res, str); mostra os 3 casos res: 1, float: 42.000000 res: 1, string: "ANSI" res: 1, string: "0xff" Pode ser sim. ## EXEMPLO ## Dois anos depois, um exemplo de como fazer isso usando as práticas comuns em Escrevendo em torno dos dados: Preenchendo os termos da P.A int preenche( int pa[], unsigned n_termos, int inicial, int razao) { pa[0] = inicial; for (unsigned i = 1; i < n_termos; i += 1) pa[i] = pa[i - 1] + razao; return 0; } Mostrando na tela a tal PA int mostra( int pa[], unsigned n_termos, int razao, const char* msg) { if (msg != NULL) printf("%s", msg); printf( "\ termo inicial: %i, razao: %i\n\ %u termos:\n", pa[0], razao, n_termos); for (unsigned i = 0; i < n_termos; i += 1) printf("%d ", pa[i]); printf("\n"); return 0; } Buscando um termo na PA e retornando 1 se ele for encontrado, ou zero em caso contrário: int busca(int pa[], unsigned n_termos, int valor) { for (unsigned i = 0; i < n_termos; i += 1) if (pa[i] == valor) return 1; // achou return 0; } Usando isso esse programa faz o simples int main(void) { int pa[10]; preenche(pa, 10, 1, 1); mostra(pa, 10, 1, "teste com r = 1\n"); preenche(pa, 10, -22, -22); mostra(pa, 10, -22, "teste com r = -22\n"); int termo = -220; int res = busca(pa, 10, termo); printf("res = %d\n", res); res = busca(pa, 10, -22); printf("res = %d\n", res); res = busca(pa, 10, 0); printf("res = %d\n", res); e mostra teste com r = 1 termo inicial: 1, razao: 1 10 termos: 1 2 3 4 5 6 7 8 9 10 teste com r = -22 termo inicial: -22, razao: -22 10 termos: -22 -44 -66 -88 -110 -132 -154 -176 -198 -220 res = 1 res = 1 res = 0 O exemplo completo #include <stdio.h> // busca 'valor' na 'pa' de 'n_termos` int busca(int pa[], unsigned n_termos, int valor); // mostra 'pa' na tela. 'msg' = mensagem opcional int mostra( int pa[], unsigned n_termos, int razao, const char* msg); // calcula os valores e preenche os 'n_termos' da pa // de razao 'razao' iniciando em 'inicial' int preenche( int pa[], unsigned n_termos, int inicial, int razao); int main(void) { int pa[10]; preenche(pa, 10, 1, 1); mostra(pa, 10, 1, "teste com r = 1\n"); preenche(pa, 10, -22, -22); mostra(pa, 10, -22, "teste com r = -22\n"); int termo = -220; int res = busca(pa, 10, termo); printf("res = %d\n", res); res = busca(pa, 10, -22); printf("res = %d\n", res); res = busca(pa, 10, 0); printf("res = %d\n", res); const char valor[] = "42280000"; float v_float = 0.; res = sscanf(valor, "%8x", (int*)&v_float); printf("res: %d, float: %f\n", res, v_float); const char ansi[20] = "49534E4100"; char str[8] = {0}; res = sscanf(ansi, "%8x", (int*)str); printf("res: %d, string: \"%s\"\n", res, str); const char* xff = "0xff"; res = sscanf(xff, "%s", str); printf("res: %d, string: \"%s\"\n", res, str); return 0; } int busca(int pa[], unsigned n_termos, int valor) { for (unsigned i = 0; i < n_termos; i += 1) if (pa[i] == valor) return 1; // achou return 0; } int mostra( int pa[], unsigned n_termos, int razao, const char* msg) { if (msg != NULL) printf("%s", msg); printf( "\ termo inicial: %i, razao: %i\n\ %u termos:\n", pa[0], razao, n_termos); for (unsigned i = 0; i < n_termos; i += 1) printf("%d ", pa[i]); printf("\n"); return 0; } int preenche( int pa[], unsigned n_termos, int inicial, int razao) { pa[0] = inicial; for (unsigned i = 1; i < n_termos; i += 1) pa[i] = pa[i - 1] + razao; return 0; }

Considere o que eu escrevi no post #6 No site da Intel, como esperado, pode conseguir tudo que precisa sobre essa placa (menos a foto eu acho), em placa-mãe e uma placa de rede compatível, da mesma marca. Versões mais novas de placas 10G não servem. Apenas PCIx versão 2. como eu disse antes

A máscara de rede + o endereço IP é que determina a rede. Se o gateway padrão é esse e usa essa máscara então tem uma rede só. Sua rede 192.168.0.0/23, que é outra maneira de escrever isso, tem o dobro de possíveis hosts do que teria se usasse a máscara comum, 255.255.255.0, ou /24. Podia usar 254 hosts com /24, e pode usar 510 nessa aí com 23 bits para a rede. A diferença aparece porque sempre deve reservar dois hosts, o .0 para endereço de rede e o 511 para endereço de broadcast. Assim sua rede vai de 192.168.0.0 até 192.168.1.254 De nada adianta um reset nos roteadores. Pelo contrário, quanto mais canais ativos mais razões para deixar a negociação no automático. Em todos.

No post #3 ele apenas disse que o técnico da Claro disse que ele precisaria de uma placa Gigabit. O técnico da Claro pode não saber de alguma razão para o dono do computador --- com placa e processador de servidor --- precisar de uma placa 10G. De todo modo, se precisa de Gigabit não precisa ser PCI-Express como você disse... Pode tranquilamente usar uma placa PCI.

Onde procurou por isso? Tentou no site da Intel? Lá tem isso bem explicado. Precisa de uma placa 10.000mbps, 10G, ou digitou errado? Se precisa de 10G entenda que sua placa, de 2011, usa PCI-x versão 2 então precisa de uma placa desse padrão. A intel tem dessas, e pode "pesquisar" no site da intel mesmo. Acho que essa X520-da1 &nbsp;nos slots x8 ou x16 serve. Se gigabit, 1.000 mbps serve ra você então considere que Gigabi é de 1.999 e sua placa de 2.011 então pode usar qualquer uma e em qualquer slot, mesmo o PCI. Placa de rede nada tem a ver com internet. Só vai ligar na LAN. Pode ter rede a 10G e não ter sequer conexão com a internet. Se precisa de uma placa assim para acessar a internet pode usar qualquer uma Gigabit, PCI --- no slot branco --- ou PCI-x x1, que usa encaixa num desses slots escuro. É só encaixar. O sistema faz o resto. Mas se for usar 10G precisa de mais coisas.

4 anos e 5 meses depois, espero que tenha concluído seu programa. @Ana Clara Alves Nunes Com o programa mostrado dá pra entender que não tenha consiguido. A única referência ao tal vetor C está nesta linha: int veta[200], vetb[200], vetc[200]; Sobre o programa postado e uma razão para outro exemplo Mesmo o mínimo código que postou tem muitos problemas (comuns de ver aqui) e então pode servir, mesmo depois de tanto tempo, ter MAIS UM exemplo de como tratar uma questão dessas. O enunciado é um pouco ingênuo. Precisa mostrar os dois vetores originais ou nem você vai saber se o programa funcionou. Claro que gerar os dois vetores é fazer duas vezes a mesma coisa. E mostrar os 3 vetores é fazer 3 vezes a mesma coisa. E uma vez gerado o segundo vetor o terceiro já está definido. C sem funções de nada serve. Desde a primeira aula esse conceito devia ser explicado. Se vai fazer várias vezes a mesma coisa escreva uma função --- e teste em separado. A vida fica muito mais simples: mostrar um vetor, uma função. preencher o vetor, uma funçào, lançar uma espaçonave, uma função void main() isso está errado, main retorna um int. Não há razão para mudar isso. E se não vai usar os argumentos declare int main(void) int veta[200], vetb[200], vetc[200]; declare uma variável por linha. É grátis. Nem todos seus programas vão ter 20 linhas e logo vai descobrir que é um inferno ficar procurando declarações. srand(time(NULL)); for (int i = 0; i < 200; i++) { veta[i] = 1000 + rand()%(9999 - 1000 + 1); } printf("Vetor A:"); for (int i = 0; i < 200; i++) { printf("[%d]", veta[i]); Isso está duplicado no programa e então são 4 loops quando podia ser 1 só. E não precisa --- não deve --- chamar srand() mais que uma vez no início do programa. E provavelmente nesses casos também não deve usar time() para iniciar rand(): use um valor constante e conhecido. Está testando um programa --- que na prática nem fez ainda --- e é melhor poder usar os mesmos valores. @devair1010 srand(time(NULL)); /* basta uma vez no código todo */ for(i = 0; i < 200; i++)/* apenas huma linha não precisa das chaves */ veta[i] = rand()%9000 + 1000; /* gera números de 0 até 8999 e soma 1000 a eles */ printf("Vetor A:"); for(i = 0; i < 200; i++)/* apenas huma linha não precisa das chaves */ printf("[%d]", veta[i]); for(i = 0; i < 200; i++)/* apenas huma linha não precisa das chaves */ vetb[i] = rand()%9000 + 1000; /* gera números de 0 até 8999 e soma 1000 a eles */ printf("\nVetor B:"); for(i = 0; i < 200; i++)/* apenas huma linha não precisa das chaves */ printf("[%d]", vetb[i]); for(i=0; i<200; i++) /* apenas huma linha não precisa das chaves */ if( veta[i] < vetb[i]) /* apenas huma linha não precisa das chaves */ vetc[i] = vetb[i]; else /* apenas huma linha não precisa das chaves */ vetc[i] = veta[i]; printf("\n\n imprimiu os vetores A e B Tecle . . . !"); Notou que é tudo igual? Só muda o nome do vetor e o texto do printf @Ansi C /* declarar, definir matriz como números pseudoaleatórios */ double snumero[2][100]; size_t znumeroi= sizeof snumero/ sizeof(snumero[0]); size_t znumeroj= sizeof snumero[0]/ sizeof(snumero[0][0]); for (size_t i= 0 ; znumeroi>i ; ++i) for (size_t j= 0 ; znumeroj>j ; ++j) { snumero[i][j]= (double) 1000+ rand ()% (9999- 1000)+ 1; } Considere que isso pode ter tem pouco sentido: Não há razão para usar double se o enunciado é claro sobre valores inteiros. E rand() já retorna valores inteiros. E o uso de loops aninhados para um caso em que o primeiro índice é constante é no mínimo curioso. i vale 0 ou 1. Essas divisöes e chamas a sizeof() nada acrescentam. Só fica mais lerdo e difícil de ler. E talvez não precisasse repetir numero toda hora: é fato conhecido que todo double é um n;úmero. Prefira o simples, como está no enunciado: Esse trecho por exemplo já define e preenche os vetores, incluído o último, em um único loop: int a[200] = {0}; int b[200] = {0}; int c[200] = {0}; const int limite = 9999 - 1000 + 1; srand(240501); for (size_t j = 0; j < 200; ++j) { a[j] = 1000 + rand() % limite; b[j] = 1000 + rand() % limite; if (a[j] > b[j]) c[j] = a[j]; else c[j] = b[j]; }; Evite deixar para o compilador a missão de evitar uma conta em toda iteração do loop. Calcule `9999 - 1000 + 1` fora do loop. Deixe claro que pensou nisso, mesmo sendo aqui apenas constantes. Considere uma função assim: int mostra(int M[], size_t tam, const char* msg) E pode acrescentar mostra(a, 25, "\nVetor A:\n"); mostra(b, 25, "\nVetor B:\n"); mostra(c, 25, "\nVetor C com os maiores valores:\n"); ao código acima, e ver na tela: ```none Vetor A: 5749 2787 6645 4752 9809 3318 8100 6954 5900 4974 1251 4423 7854 5606 6799 9437 5318 1956 3536 4308 1974 5949 2194 7595 2693 Vetor B: 9220 5437 3498 8460 5638 5531 3558 9801 2851 5271 6468 7831 2700 7936 3017 2552 5447 5057 6732 6727 1509 1192 5425 6477 1204 Vetor C com os maiores valores: 9220 5437 6645 8460 9809 5531 8100 9801 5900 5271 6468 7831 7854 7936 6799 9437 5447 5057 6732 6727 1974 5949 5425 7595 2693 sem repetir as coisas. Note que o tamanho está limitado a 25 no exemplo porque não leva a nada mostrar centenas de números aqui. Esse exemplo completo #include <stdio.h> #include <stdlib.h> int mostra(int M[], size_t tam, const char* msg); int main(void) { int a[200] = {0}; int b[200] = {0}; int c[200] = {0}; const int limite = 9999 - 1000 + 1; srand(240501); for (size_t j = 0; j < 200; ++j) { a[j] = 1000 + rand() % limite; b[j] = 1000 + rand() % limite; if (a[j] > b[j]) c[j] = a[j]; else c[j] = b[j]; }; mostra(a, 25, "\nVetor A:\n\n"); mostra(b, 25, "\nVetor B:\n\n"); mostra(c, 25, "\nVetor C com os maiores valores:\n\n"); return 0; } int mostra(int M[], size_t tam, const char* msg) { printf("\n"); if (msg != NULL) printf("%s", msg); for (size_t i = 0, c = 0, nc = 10; i < tam; i += 1) { if (++c < nc) printf("%4i ", M[i]); else printf("%4i\n", M[i]),c = 0; } return 0; } A saída do exemplo está acima... Sobre esse trecho, @Ansi C Construções assim sugerem que o código seja parte do código postado pelo usuário citado na primeira parte (logo acima) e só levam a confusão. Ao reviver um tópico de 4 anos atrás talvez fosse mais produtivo para os leitores do forum fazer o simples e útil postar algum código compilável, completo int sep = 0; size_t m = 0; double smaior[znumeroj] = {0}; while (znumeroj > m) { printf("%c%.f", sep, smaior[m]); sep = ((++m) % 10UL) ? ' ' : '\n'; } Sobre esse trecho, entenda que isso é apenas um for, onde m é o valor inicial, znumero é o limite e ++m é o incremento. E o printf() usando uma expressão ternária para alimentar um caractere em um %c tem o único efeito de pular de linha a cada 10 números. Isso não deve gerar boa nota, não pega bem em uma entrevista de emprego, não fica bem em um estágio ou emprego, e deve ir contra qualquer convenção de codificação de empresa que eu já tenha visto, então não passaria pela revisão de jeito nenhum, em uma empresa grande. Note também, que na literatura e nos exemplos em geral quando se compara uma variável com um limite em um loop o limite vem depois. Pode ver isso em qualquer site de referência ou livro. como esse exemplo em aqui em Tutorials Point ou em aqui em FreeCodeCamp Pode ser divertido fazer tudo ao contrário do comum, mas isso não costuma dar certo em programação de computadores. Esse trecho #define DIM_V 20 double M[DIM_V] = {0}; // mostra o vetor, 10 numeros por linha for (size_t i = 0, c = 0, nc = 10; i < DIM_V; i += 1) { if (++c < nc) printf("%.f ", M[i]); else printf("%.f\n", M[i]), c = 0; } Tem o mesmo efeito, mudando de linha a cada 10 valores. Só que roda 10x mais rápido --- chamar % toda hora é lento e reavaliar sep toda vez dentro do loop é desnecessário --- e é simples de ler e entender Teste nesse programa: #include <stdio.h> #include <stdlib.h> int main(void) { #define znumeroj 20 int sep = 0; size_t m = 0; double smaior[znumeroj] = {0}; while (znumeroj > m) { printf("%c%.f", sep, smaior[m]); sep = ((++m) % 10UL) ? ' ' : '\n'; } printf("\n\noutro\n\n"); #define DIM_V 20 double M[DIM_V] = {0}; for (size_t i = 0, c = 0, nc = 10; i < DIM_V; i += 1) { if (++c < nc) printf("%.f ", M[i]); else printf("%.f\n", M[i]), c = 0; } return 0; }

Esse é um cenário E esse é outro. Se tem redes separadas que não devem se enxergar já sabe de tudo que não vai funcionar, aquelas coisas que eu expliquei. E não importa em seu cenário. Então não precisa de roteadores desse tipo, e não precisa de NAT. Não vai achar supresa que não possa usar uma impressora em mais de uma dessas redes. Ou que não possa comparitlhar pastas de uma certa máquina. Pode usar subnets ou switches gerenciáveis e não as ter perdas decorrentes de NAT. Mas não deve usar aparelhos domésticos como esses roteadores, que são simples adaptadores LAN/WAN através de NAT. Apenas precisa de uma rede estruturada, como era uma rede nos 90, com gateways e tabelas de rotas.

C não tem passagem por referência. Apenas por valor. Todo array em C é um ponteiro para uma área de memória de um certo tamanho. Na literatura procure por "array to pointer decay". Provavelmente, mesmo sendo um forum onde pode ir escrevendo o que quiser, não devia colocar SUA opinião como definitiva sobre o que seja "confuso" ou "complicante". Deve mesmo ser confuso chamar a matriz de M e o minimo de minimo e o maximo de maximo, como está aí acima... main() com 10 linhas parece bem complexo com essas funções de nomes curtos e enigmáticos, como mostra, define e minimo: define(mat, -1000, 1000); mostra(mat, "\n\nintervalo: [-1000,1000]\t"); minimo(mat); minimo_i(mat); Acho que entende que minimo() sem usar indices é um exemplo e que minimo_i() é o trivial para encontrar os valores que o enunciado pede, ou não? int minimo_i(int M[][DIM_N]) { int maior = M[0][0]; size_t i = 0; size_t linha = 0; for (i = 0; i < DIM_M; i += 1) for (int j = 0; j < DIM_N; j += 1) if (maior < M[i][j]) maior = M[i][j], linha = i; printf( "\n\tMaior valor = %i [na linha %llu]\n", maior, linha); int menor = M[linha][0]; for (size_t j = 1; j < DIM_N; j += 1) if (menor > M[linha][j]) menor = M[linha][j]; printf("\tMenor valor nessa linha = %i\n", menor); return menor; } Você que está lendo isso e tem a mesma dúvida de @Ansi C entenda que a matriz no exemplo é suposta MxN, e assim essas constantes complicadas DIM_M e DIM_N dão a dimensão que a matriz vai ter no programa. Seria possível definir dinâmicamente ou usar uma matriz limite como 10x10, mas esse é um programa exemplo para iniciantes. É pelo valor dessas constantes que o programa usa uma matriz 5x8. Se não ficou claro com esses nomes estranhos, mostra() mostra a matriz na tela e aceita um título. É uma comodidade como pode ver no exemplo, Evita que nos testes use mensagens para explicar um teste ou outtro. define() apenas carrega a matriz com valores aleatórios entre minimo e maximo inclusive. É por isso que os argumentos são minimo e maximo. minimo() é uma função que mostr na tela os valores que o programa pede. Apenas a título de exemplo tem 2 versões. A primeira não usa índices [a][b] e a segunda, minimo_i() usa o trivial. Claro que pode usar apenas uma e apagar a outra. Obrigado por clarificar esse conceito. Pode parecer um tanto pedante você insistir nisso, mas assim é: rand() gera números pseudo-aleatórios!!!

Passados quase 3 anos acho que uma resposta mais completa pode ajudar a outros O programa original int main() { int i, j, mat1[4][4] = {0, 0, 0, 0, 0, 0, 0, 0, 0}; srand(time(NULL)); for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) mat1[i][j] = rand() % 1000; } for (i = 0; i < 4; i++) { for (j = 0; j < 4; j++) printf("%5d ", mat1[i][j]); printf("\n"); } printf("\n--> %d\n", RAND_MAX); return 0; } O programa não está nada bom, e não fez quase nada do exercício. declare uma variável por linha. Linhas são grátis. declare as variáveis de controle do loop DENTRO do loop nunca use globais, em especial com esses nominhos ingênuos tipo `i` e `j`. não precisa de `time`. E `time` é uma função e está em `stdlib`. Não é "do computador" não precisa de `srand` mas se quer usar seria melhor usar um valor conhecido, já que está testando o programa e se imagina que vá completar isso alguma hora. Repetir os valores até ter certeza é vantagem. não há razão alguma para imprimir `RAND_MAX` que é uma constante se não vai usar os argumentos da linha de comando declare `main` como `main(void)` O enunciado é fraco e nada diz sobre limites e dimensões. ## um exemplo ## Então sabe um minimo do que deve fazer. Considere funções que pode usar e testar em separado. É muito mais simples. Precisa no minimo preencher a matriz com números aleatórios mostrar a matriz encontrar o máximo e mínimo como pedido e mostrar ### preencher a matriz ### Considere esse exemplo int define(int M[][DIM_N],int minimo,int maximo) { int* p = (int*)M; if (minimo > maximo) maximo = minimo + 1000; for (size_t i = 0; i < DIM_M * DIM_N; i += 1) *(p + i) = minimo + rand() % (maximo - minimo + 1); return 0; } Tem só 4 linhas e preenche a matriz com valores aleatórios entre `minimo` e `maximo` inclusive. No programa exemplo (código ao final), que faz dois testes, é chamada assim define(mat,-1000,1000); // e define(mat,0,100); // outro teste ### mostrando a matriz ### int mostra(int M[][DIM_N], const char* msg) { if (msg != NULL) printf("%s", msg); printf("matriz [%i,%i]\n\n", DIM_M, DIM_N); for (size_t i = 0; i < DIM_M; i += 1) { for (size_t j = 0; j < DIM_N; j += 1) printf("%5i ", M[i][j]); printf("\n"); } return 0; } Essa função faz o simples e mostra a matriz. Os valores de máximo e mínimo não são mostrados aqui porque é muito possível se querer mostrar a matriz sem mostrar esses valores. A função aceita uma mensagem opcional, poruqe ajuda nos testes e elimina clássicas chamadas a printf() para identificar cada teste. ### calculando o máximo e mínimo como pedido ### Isso é trivial, basta um loop pelos índices para achar o maior valor e mostrar junto com o número da linha. Sabendo o número da linha é trivial em um outro loop identificar o menor valor e mostrar. Eis uma possível função para identificar esses valores, sem usar índices: int minimo(int M[][DIM_N]) { int* p = (int*)M; int* limite = (int*)M; // limite eh o maior for (size_t i = 1; i < DIM_M * DIM_N; i += 1) if (*limite < *(p + i)) limite = p + i; // em que linha esta isso? int linha = (int)(limite - (int*)M) / DIM_N; printf( "\n\tMaior valor = %i [na linha %i]\n", *limite, linha); // qual o menor nessa linha? p = p + linha * DIM_N; limite = p; // limite agora eh o menor for (size_t i = 1; i < DIM_N; i += 1) if (*limite > *(p + i)) limite = p + i; printf("\tMenor valor nessa linha = %i\n", *limite); return *limite; } Usar os índices e a notação `[a][b]` é trivial. Uma implementação bem linear poderia ser essa: int minimo_i(int M[][DIM_N]) { int maior = M[0][0]; size_t i = 0; size_t linha = 0; for (i = 0; i < DIM_M; i += 1) for (int j = 0; j < DIM_N; j += 1) if (maior < M[i][j]) maior = M[i][j], linha = i; printf( "\n\tMaior valor = %i [na linha %llu]\n", maior, linha); int menor = M[linha][0]; for (size_t j = 1; j < DIM_N; j += 1) if (menor > M[linha][j]) menor = M[linha][j]; printf("\tMenor valor nessa linha = %i\n", menor); return menor; } ### main para o exemplo ### Essa função no exemplo usa matrizes 5x8 int main(void) { int mat[DIM_M][DIM_N] = {0}; int* p = (int*)mat; srand(240429); define(mat, -1000, 1000); mostra(mat, "\n\nintervalo: [-1000,1000]\t"); minimo(mat); minimo_i(mat); define(mat, 0, 100); // outro teste mostra(mat, "\n\nintervalo: [0,100]\t"); minimo(mat); minimo_i(mat); return 0; } ### saida do exemplo para uma matriz 5x8 ### intervalo: [-1000,1000] matriz [5,8] 499 -244 -491 -186 -349 -330 28 605 -625 305 -47 360 720 862 744 -365 313 -51 225 -341 -477 947 698 -701 -987 -344 -518 331 190 845 -270 -212 318 -563 -667 111 -412 715 299 371 Maior valor = 947 [na linha 2] Menor valor nessa linha = -701 Maior valor = 947 [na linha 2] Menor valor nessa linha = -701 intervalo: [0,100] matriz [5,8] 42 66 17 87 63 79 75 23 63 49 62 74 39 71 19 34 42 7 12 21 88 70 60 71 31 85 22 62 81 12 26 9 95 22 69 44 48 63 39 13 Maior valor = 95 [na linha 4] Menor valor nessa linha = 13 Maior valor = 95 [na linha 4] Menor valor nessa linha = 13 Note que o programa chama as duas funções que mostram o máximo e o mínimo. É um teste afinal. ### o programa completo ### #define DIM_M (int)5 #define DIM_N (int)8 #include <stdio.h> #include <stdlib.h> int minimo(int M[][DIM_N]); int minimo_i(int M[][DIM_N]); int define(int M[][DIM_N], int, int); int mostra(int M[][DIM_N], const char*); int main(void) { int mat[DIM_M][DIM_N] = {0}; int* p = (int*)mat; srand(240429); define(mat, -1000, 1000); mostra(mat, "\n\nintervalo: [-1000,1000]\t"); minimo(mat); minimo_i(mat); define(mat, 0, 100); // outro teste mostra(mat, "\n\nintervalo: [0,100]\t"); minimo(mat); minimo_i(mat); return 0; } int mostra(int M[][DIM_N], const char* msg) { if (msg != NULL) printf("%s", msg); printf("matriz [%i,%i]\n\n", DIM_M, DIM_N); for (size_t i = 0; i < DIM_M; i += 1) { for (size_t j = 0; j < DIM_N; j += 1) printf("%5i ", M[i][j]); printf("\n"); } return 0; } int minimo(int M[][DIM_N]) { int* p = (int*)M; int* limite = (int*)M; // limite eh o maior for (size_t i = 1; i < DIM_M * DIM_N; i += 1) if (*limite < *(p + i)) limite = p + i; // em que linha esta isso? int linha = (int)(limite - (int*)M) / DIM_N; printf( "\n\tMaior valor = %i [na linha %i]\n", *limite, linha); // qual o menor nessa linha? p = p + linha * DIM_N; limite = p; // limite agora eh o menor for (size_t i = 1; i < DIM_N; i += 1) if (*limite > *(p + i)) limite = p + i; printf("\tMenor valor nessa linha = %i\n", *limite); return *limite; } int minimo_i(int M[][DIM_N]) { int maior = M[0][0]; size_t i = 0; size_t linha = 0; for (i = 0; i < DIM_M; i += 1) for (int j = 0; j < DIM_N; j += 1) if (maior < M[i][j]) maior = M[i][j], linha = i; printf( "\n\tMaior valor = %i [na linha %llu]\n", maior, linha); int menor = M[linha][0]; for (size_t j = 1; j < DIM_N; j += 1) if (menor > M[linha][j]) menor = M[linha][j]; printf("\tMenor valor nessa linha = %i\n", menor); return menor; } int define(int M[][DIM_N], int minimo, int maximo) { int* p = (int*)M; if (minimo > maximo) maximo = minimo + 1000; for (size_t i = 0; i < DIM_M * DIM_N; i += 1) *(p + i) = minimo + rand() % (maximo - minimo + 1); return 0; }

Pois é. Os soquetes nesses aparelhos são CAT5e. Os conetores CAT6 e superior são diferentes, tem muito mais metal e blindagem e são mais duros. Pode não encaixar direito e depois encaixar direito, como no seu caso. O simples é usar cabos e conectores e soquetes da mesma categoria... E mais barato.

Esse não é o forum para definir aleatório mas, de https://www.dicio.com.br/aleatorio/ E isso não parece condizer com o enunciado. E da? Eu não chamaria de refinamento uma "aplicação" para fazer sua solução condizente com o enunciado. Seria uma correção. Memória é algo linear. Em C há apenas arrays, e arrays de arrays e assim por diante. Uma "mariz 4x4" é só uma região contínua na memória. Pelo enunciado só é preciso definir a linha em que está o maior elemento, para depois identificar o menor valor nessa linha. Não precisa de índices para isso. Vou me ater ao tópico e enunciado, de 2021.

Talvez deva rever... Não chamaria de refinamento, mas o enunciado deixa claro que se trata de uma matriz de números aleatórios e não constantes. Salvar os índices numa matriz que é usada uma única vez não é provavelmente "auxiliar a produção". Apenas usa mais tempo e memória e letrinhas. No fundo sequer precisa dos índices.

@Rosa Muitas soluções grátis e mesmo pagas navegam em torno de um produto grátis chamado OpenVPN. Tem muitas maneiras grátis de usar, por exemplo usando um trem chamado CloudConexa que pode usar usado legalmente de graça para até 5 dispositivos. Uso sem problemas há uns 15 anos. Tem roteadores modernos que vem com algo assim embutido e é só preencher um formulário na configuração. E isso é Linux (que um dia era Unix) e então você pode baixar e instalar em qualque r máquina, real ou virtual, e usar. Hamachi, da LogMeIn é grátis para até 5 hosts e cria túneis criptografados. Bem simples. RouterOS, esse que roda nos Mikrotik, também é grátis e pode ser baixado para qualquer máquina. E Linux e Windows server tem previsão para criar túneis criptografados direto no boot, usando PPTP e outras coisas. OpenVPN e RouterOS são distribuições Linux afinal, ainda que especializadas. Se sua rede cair, ou o servidor parar, a VPN vai parar também. Ou de pouco vai servir já que não tem os servidores ou a VPN. Entre o grátis e o pago tem muitos tons. E no final tudo cai na administração da coisa. Tudo recai na experiência de quem administra, se é que tem alguém.

Essa condição é, digamos, uma bobagem: if (x > 3) y = x * 1500; else y = x * 1000; Esse programa foi, segundo o autor (post #3), baseado em Provavelmente isso foi copiado desse post no Stack Overflow, de 2017. Só que lá o objetivo era listar os números até um limite Escreva o programa para calcular todos os números friends de 2 para N. Exemplo: Se a entrada for N = 1500 a saída deverá ser: (284, 220), (1210, 1184) Só que, sem entender a diferença entre os enunciados, o "cara" copiou até o 1500, a constante exemplo do programa original. Depois, vendo que a conta não batia alguém colocou uma "correção de curso" e usou `1000` para `x<3`. Veja na planilha: O problema é que para x = 2 o original daria `4500` e acabaria mostrando 3 números e não dois, já que 2620 < 4500 < 5020 Mas parou aí. Não houve preocupação em parar o programa em 9 números, ou mesmo em parar o programa um dia... Claro que a mesma preocupação não apareceu para testa os valores digitados e nem para decidir sobre o final do programa em 9 ou `N` pares de amigos. sobre essa nova versão @devair1010 Claro que temos progressos, tem até uma educada mensagem avisando o usuário do que ele deve digitar... Mas: deixou o tal `r` lá sem uso, apesar do compilador ter avisado criou um contador mas não apagou essa fórmula bobinha e simplesmente usou `cont` para... contar os números já listados, sem fazer o simples e parar o programa na hora certa não corrigiu os erros nos especificadores de `printf` para os valores que foram trocados de `int` para `size_t` não declarou `n` no próprio corpo do `for`, algo que foi corrigido em `C` ainda nos anos 80. Ou mesmo `divisor` entenda esse código: for (divisor = 2; divisor <= n / 2; divisor++) { if (n % divisor == 0) soma1 += divisor; //calcula a soma dos divisores } soma2 = 1; if (soma1 != n) for (divisor = 2; divisor <= soma1 / 2; divisor++) { if (soma1 % divisor == 0) soma2 += divisor; //calcula a soma dos divisores } é claro que é o mesmo código nos dois for: dado um número retorna a soma de seus divisores. Evite a todo custo repetir código assim, logo na linha de baixo. Use funções, como eu mostrei. Isso se chama de princípio DRY na literatura: Don't Repeat Yourself. Do exemplo que eu escrevi: size_t is_friend(size_t val) { size_t soma = soma_div(val); if (soma <= val) return 0; if (soma_div(soma) == val) return soma; return 0; } É mais simples de entender, e continua tendo a função `soma()` para outros usos. E considera o par na primeira vez em que aparece, `[a,b]` quando `a<b` e já despreza o egocêntrico caso dos números que são amigos deles próprios, como `6` e `28`. Use a linha de comando. é muito chato rodar o programa e ficar esperando ele perguntar algo se já sabe o que ele vai perguntar. como eu já disse, `scanf()` retorna um `int`. Use. É mais esperto. Se o cara digitar `x` seu programa vai fazer o que? `scanf` é --- dá pra ver pelo nome --- um _scanner_ e é normal não ler nada. O esperado em `C` desde o `Unix` é receber os argumentos na linha de comando e ter um padrão para o caso de o usuário não digitar nada, ou chamar uma função mostrando como usar. `usage()` é o nome clássico dessa função desde os anos 70. Imagine se o compilador perguntasse a cada vez: Quantos programas deseja compilar? Forneça o nome dos programas, um por linha e tecle ENTER... Outro EXEMPLO Mudando um pouco do que escreveram, para ter algo mais configurável e correto: Usando isso, que é o mesmo código, não precisa repetir o loop, e fica muito mais legível a determinação de números amigos: inline size_t soma_div(const size_t val) { size_t soma = 1; for (size_t divisor = 2; divisor <= val / 2; divisor += 1) if (val % divisor == 0) soma += divisor; return soma; } size_t eh_amigo(size_t val) { size_t soma = soma_div(val); if (soma <= val) return 0; if (soma_div(soma) == val) return soma; return 0; } Claro que se salvasse os números que tem amigos poderia salvar a inútil computação dele na segunda vez... main() para o exemplo Na prática esse é o programa principal. Só isso: for (size_t par = 0, N = 2, outro = 0; par < n_pares;) { if ((outro = eh_amigo(N)) != 0) printf("%4llu: [%llu,%llu]\n", 1 + par, N, outro), ++par; ++N; // proximo candidato }; // for A saída desse exemplo Supondo o programa como amigos.exe... C:\Clube do Hardware>_ ./amigos Listando os primeiros 9 pares de numeros amigos 1: [220,284] 2: [1184,1210] 3: [2620,2924] 4: [5020,5564] 5: [6232,6368] 6: [10744,10856] 7: [12285,14595] 8: [17296,18416] 9: [63020,76084] Fim C:\Clube do Hardware>_ ./amigos 1 Listando os primeiros 1 pares de numeros amigos 1: [220,284] Fim C:\Clube do Hardware>_ ./amigos 3 Listando os primeiros 3 pares de numeros amigos 1: [220,284] 2: [1184,1210] 3: [2620,2924] Fim C:\Clube do Hardware>_ ./amigos 13 Listando os primeiros 13 pares de numeros amigos 1: [220,284] 2: [1184,1210] 3: [2620,2924] 4: [5020,5564] 5: [6232,6368] 6: [10744,10856] 7: [12285,14595] 8: [17296,18416] 9: [63020,76084] 10: [66928,66992] 11: [67095,71145] 12: [69615,87633] 13: [79750,88730] Fim Tendo um valor padrão --- e um limite interno --- e aceitando outros valores direto na linha de comando fica muito menos chato de usar. E pode usar em um script. Nunca escreva programas interativos. Só atrasa. E é chato. Programa completo #define LIMITE_PADRAO 9 #define MAX_PARES 80 #include <stdio.h> #include <stdlib.h> inline size_t soma_div(const size_t val); size_t eh_amigo(size_t val); int main(int argc, char **argv) { size_t n_pares = LIMITE_PADRAO; size_t temp = 0; if (argc > 1) { temp = atoi(argv[1]); if ((temp != 0) && (temp <= MAX_PARES)) n_pares = temp; } printf("\nListando os primeiros %llu pares de numeros " "amigos\n\n", n_pares); for (size_t par = 0, N = 2, outro = 0; par < n_pares;) { if ((outro = eh_amigo(N)) != 0) printf("%4llu: [%llu,%llu]\n", 1 + par, N, outro), ++par; ++N; // proximo candidato }; // for printf("\nFim\n"); return 0; } inline size_t soma_div(const size_t val) { size_t soma = 1; for (size_t divisor = 2; divisor <= val / 2; divisor += 1) if (val % divisor == 0) soma += divisor; return soma; } size_t eh_amigo(size_t val) { size_t soma = soma_div(val); if (soma <= val) return 0; if (soma_div(soma) == val) return soma; return 0; }

Sim, se pode usar um vetor para isso, mas também pode mostrar o par apenas na primeira ou segunda vez em que ele aparece, já que os elementos são diferentes em cada par. @jaireugenio use o botão code, como está explicado no primeiro post desse forum. Veja a diferença Pois é: esse é o código de "um cara", como você citou, usando o tal botão code: #include <stdio.h> int main() { int n, divisor, r, soma1, soma2, y, x; scanf("%d", &x); if (x > 3) { y = x * 1500; } else y = x * 1000; for (n = 2; n <= y; n++) { soma1 = 1; for (divisor = 2; divisor <= n / 2; divisor++) { if (n % divisor == 0) soma1 += divisor; // calcula a soma dos // divisores } soma2 = 1; if (soma1 != n) for (divisor = 2; divisor <= soma1 / 2; divisor++) { if (soma1 % divisor == 0) soma2 += divisor; // calcula a soma dos // divisores } if (soma2 == n) // verificar se a soma dos // divisores eh igual ao numero { printf("(%d,%d)\n", n, soma1); } } return 0; } O código "adaptado" como você disse #include <stdio.h> int main() { int n, divisor, r, soma1, soma2, y, x; scanf("%d", &x); if (x > 3) { y = x * 1500; } else y = x * 1000; for (n = 2; n <= y; n++) { soma1 = 1; for (divisor = 2; divisor <= n / 2; divisor++) { if (n % divisor == 0) soma1 += divisor; // calcula a soma dos // divisores } soma2 = 1; if (soma1 != n) for (divisor = 2; divisor <= soma1 / 2; divisor++) { if (soma1 % divisor == 0) soma2 += divisor; // calcula a soma dos // divisores } if (soma2 == n && n < soma1) // verificar se a soma dos divisores // eh igual ao numero { printf("(%d,%d)\n", n, soma1); } } return 0; } A sua adaptação: Essa é a tela do IDE do Visual Studio mostrando as diferenças entre o programa de "um cara que estava tendo uma questão parecida com a minha" como disse, e o seu programa solução: acrescentou o comentário e a condição no if. Muito bem. Do post #9: E aaí está a condição. Sobre o código FINAL Bom que conseguiu adaptar o programa e chegar a uma solução, mudando apenas 2 linhas! if (x > 3) { y = x * 1500; } else y = x * 1000; Sabe explicar de onde vem esses números? Não seria mais simples contar os pares, de um em um? Seu professor pode querer saber... Sei que é a solução de "um cara" mas você ao copiar podia usar chaves de um modo mais consistente. Não precisa delas em nenhuma das condições, mas se vai usar use duas ou nenhuma... if (x > 3) y = x * 1500; else y = x * 1000; // ou if (x > 3) { y = x * 1500; } else { y = x * 1000; } leia o manual: scanf() retorna um int. TESTE. Seu professor pode teclar um 'x' lá só pra ver se você pensou nisso. é muito chato ficar olhando para uma tela onde não tem nada escrito e imaginar que tem que digitar um número inteiro positivo entre 1 e 9 ( inclusive). Já pensou em escrever isso numa mensagem, usando aquele comando printf explicando o que o cara deve digitar? Leu o que eu expliquei sobe ser esperado digitar o número JUNTO com o nome do programa? para que serve 'r'? Seu professor pode querer saber. Veja as mensagens de seu compilador. Sabe o que acontece se o cara digitar por exemplo 500? Testou "seu" programa?

Então você acha que é a pior, mas não tem você uma justificativa técnica, apenas um palpite? uma sensação? Vai encontrar aqui gente dizendo a mesma coisa sobre a Net e a VIVO, que está claro que uma ou outra não presta e que por isso precisam colocar o aparelho da operadora em modo bridge e tal... E em geral também, nos posts aqui, sem uma razão técnica ou um argumento sólido.

[ligeiramente off-topic ] @Ansi C Sabe o que é a "coleção schaum"? Passados 10 dias da pergunta achei que podia ter uma referência aqui sobre essa questão e sobre o modo de escrever isso. Na minha opinião você está diminuindo a capacidade dos iniciantes. Sempre tem os caras que não vão nem tentar fazer antes de tentar copiar de toda possível parte. O forum é uma possível parte, por definição e missão. As pessoas vem para o forum --- e empresas que anunciam no site --- por essa razão. Stack Overflow e o Stack Exchange em geral são a referência do planeta para isso. Mas tem gente que aprende com referências. Pode usar o exemplo que eu escrevi e salvar tal lista para até onde size_t comporta. Para números maiores pode só reescrever esse programa em uma linguagem que tenha inteiros de maior tamanho, como Python ou java, ou escrever (ou usar de alguém) uma biblioteca de aritmética para inteiros em C. Não é complicado.

Entendo. Mas um servidor de autenticação não é um roteador. E não é pra ser um peso mas sim um benefício. É muito mais simples de administrar. Provavelmente não em essa necessidade porque seus dispositivos estão sempre na rede e nem geram tráfego. Se atendesse 70 dispositivos de um universo de 500 cadastrados, como celulares, tablets e notebooks, veria a dificuldade em manter essas listas atualizadas. Por isso se usa algo como RADIUS e LDAP. Tem um script para substituir um roteador desses em caso de pane, por exemplo? Pois é. Se esse roteador morre tem um programa para recarregar essas listas?

Mais ou menos como está no enunciado, aposta --- ou sorteio manual --- é quando por exemplo o sujeito vai na lotérica, pega o formulário e marca entre 6 e 15 dezenas. Aí ele vai ao caixa e registra o tal sorteio_manual e paga pelo sorteio manual. Ou aposta. O próximo passo é aguardar o sorteio, aqui chamado de exibe_numeros_sorteio(). Depois disso tem a fase da conferência, aqui sendo uma opção de exibe_numeros_sorteio(), ao que parece.

Então o problema postado como de C++ é um programa em C `sorteio_manual()` é o que se costuma chamar de aposta `exibe_numeros_sorteio()` é, ou inclui, o que se costuma chamar de sorteio e a conferência da aposta está embutida em `exibe_numeros_sorteio()` usando um parâmetro E como está o código agora?

Amizade entre números Esse nome é um tanto estranho e não corresponde à noção de amizade: Um número é dito amigo se a soma de seus divisores é igual à soma dos divisores do valor dessa soma. Assim, se um número é amigo ele tem um único amigo. Nada social. E aparentemente um número não pode ser amigo dele mesmo, caso do óbvio 1 e do 28 por exemplo, já que 28 tem 1,2,4,7 e 14 como divisores e a soma é... 28. Claro que a amizade é comutativa, já que a igualdade é comutativa. O primeiro par de amigos seria [220,284], sem considerar [1,1] e [28,28]: os divisores de 220 são 1, 2, 4, 5, 10, 11, 20, 22, 44, 55 e 110, e a soma é 284 os divisores de 284 são 1, 2, 4, 71 e 142, e a soma é 220 Assim se `a` é amigo de `b`, então `b` é amigo de `a`. E eles não tem outros amigos... De volta ao código original int amigo(int n1, int n2) { int div1 = 1, div2 = 1, soma1 = 0, soma2 = 0; while (n1 >= div1 * 2) { if (n1 % div1 == 0) { soma1 = soma1 + div1; } div1++; } while (n2 >= div2 * 2) { if (n2 % div2 == 0) { soma2 = soma2 + div2; } div2++; } if (soma1 == n2 && soma2 == n1) { // neste caso sao amigos return 1; } return 0; } Isso parece que está certo na determinação da relação, mas a lógica nem tanto. Não sou eu que vou corrigir isso, mas considere: Se um número é amigo está claro de quem ele é amigo. Ou tem um ou não tem nenhum. Não é nada esperto procurar um por um. Veja o caso do tal 220: a soma é 284. A única chance de ser esse um número amigo é de a soma dos divisores de 284 dar 220. E é. Então esse loop no programa não tem muito sentido: int main() { int x, y, f = 220, k, num1, num2; scanf("%d", &x); for (y = 1; y <= x; y++) { // repetir a quant de amigos a procurar num1 = f; num2 = num1; while (num1) { while (num2) { // printf("%d %d\n",num1, num2); num2++; if (amigo(num1, num2) == 1) { f = num1; k = num2; printf("(%d,%d)", num1, num2); num1 = 0; num2 = 0; } } num1++; } } return 0; } De nada adianta testar amigo(num1, num2) para todos os pares possíveis se só tem uma possível solução... exemplo Essa função retorna a soma dos divisores de um número. Note que em C size_t é melhor que int. Não há sinal nesses números. size_t soma_div(size_t val) { size_t n_div = 1; size_t soma = 1; // os pares a*b size_t div = 2; size_t q = 0; do { q = val / div; if (q * div == val) { // quadrado perfeito? if (q != div) soma += div; soma += q; } div += 1; } while (q >= div); return soma; } Se ela retorna a soma então essa outra size_t is_friend(size_t val) { size_t soma = soma_div(val); if (soma <= val) return 0; if (soma_div(soma) == val) return soma; return 0; } retorna 0 se o número não é amigo, ou retorna o número amigo. Mais simples de ler e entender. E evita a repetição dos pares, e também casos como o do 28, amigo de si mesmo. Basta uma linha a mais. exemplo completo #define DEF_LIMITE 81 #include<stdio.h> #include <stdlib.h> size_t is_friend(size_t val); size_t soma_div(size_t n); int main(int argc, char** argv) { size_t n_pares = 10; size_t temp = 0; if (argc > 1) { // limita o total de pares para não ter que esperar muito // nem pensar em overflow temp = atoi(argv[1]); if ((temp != 0) && (temp < DEF_LIMITE)) n_pares = temp; } printf( "\nListando os primeiros %llu pares de numeros " "amigos\n\n", n_pares); size_t outro = 0; size_t N = 2; for (size_t par = 0; par < n_pares;) { outro = is_friend(N); if (outro != 0) { printf( "%4llu: [%llu,%llu]\n", 1 + par, N, outro); ++par; }; ++N; // proximo candidato }; // for return 0; } size_t is_friend(size_t val) { size_t soma = soma_div(val); if (soma <= val) return 0; if (soma_div(soma) == val) return soma; return 0; } inline size_t soma_div(size_t val) { size_t n_div = 1; size_t soma = 1; // os pares a*b size_t div = 2; size_t q = 0; do { q = val / div; if (q * div == val) { // quadrado perfeito? if (q != div) soma += div; soma += q; } div += 1; } while (q >= div); return soma; } saída do exemplo C:\Clube\p.exe Listando os primeiros 10 pares de numeros amigos 1: [220,284] 2: [1184,1210] 3: [2620,2924] 4: [5020,5564] 5: [6232,6368] 6: [10744,10856] 7: [12285,14595] 8: [17296,18416] 9: [63020,76084] 10: [66928,66992] C:\Clube\p.exe 80 Listando os primeiros 80 pares de numeros amigos 1: [220,284] 2: [1184,1210] 3: [2620,2924] 4: [5020,5564] 5: [6232,6368] 6: [10744,10856] 7: [12285,14595] 8: [17296,18416] 9: [63020,76084] 10: [66928,66992] 11: [67095,71145] 12: [69615,87633] 13: [79750,88730] 14: [100485,124155] 15: [122265,139815] 16: [122368,123152] 17: [141664,153176] 18: [142310,168730] 19: [171856,176336] 20: [176272,180848] 21: [185368,203432] 22: [196724,202444] 23: [280540,365084] 24: [308620,389924] 25: [319550,430402] 26: [356408,399592] 27: [437456,455344] 28: [469028,486178] 29: [503056,514736] 30: [522405,525915] 31: [600392,669688] 32: [609928,686072] 33: [624184,691256] 34: [635624,712216] 35: [643336,652664] 36: [667964,783556] 37: [726104,796696] 38: [802725,863835] 39: [879712,901424] 40: [898216,980984] 41: [947835,1125765] 42: [998104,1043096] 43: [1077890,1099390] 44: [1154450,1189150] 45: [1156870,1292570] 46: [1175265,1438983] 47: [1185376,1286744] 48: [1280565,1340235] 49: [1328470,1483850] 50: [1358595,1486845] 51: [1392368,1464592] 52: [1466150,1747930] 53: [1468324,1749212] 54: [1511930,1598470] 55: [1669910,2062570] 56: [1798875,1870245] 57: [2082464,2090656] 58: [2236570,2429030] 59: [2652728,2941672] 60: [2723792,2874064] 61: [2728726,3077354] 62: [2739704,2928136] 63: [2802416,2947216] 64: [2803580,3716164] 65: [3276856,3721544] 66: [3606850,3892670] 67: [3786904,4300136] 68: [3805264,4006736] 69: [4238984,4314616] 70: [4246130,4488910] 71: [4259750,4445050] 72: [4482765,5120595] 73: [4532710,6135962] 74: [4604776,5162744] 75: [5123090,5504110] 76: [5147032,5843048] 77: [5232010,5799542] 78: [5357625,5684679] 79: [5385310,5812130] 80: [5459176,5495264] É mais simples --- e esperado --- usar a linha de comando para argumentos óbvios, e ter um padrão para quando o cara não digita nada. Esse exemplo assume 10 pares se o cara não digitar nada, e limita em 80 o total máximo, porque demora e o total de pares nada muda para o programa.