arfneto

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  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.

Nada tem a ver uma coisa com a outra. Talvez não tenha definido o endereço dele antes de mudar o modo de operação. Qualquer modo de operação que habilite as antenas vai ter o mesmo alcance e performance no wifi. Nada tem a ver DHCP ou modo de operação com isso. E nem a faixa de IP na verdade. E não é surpresa o sinal do wifi ser melhor, já que esse aparelho é bem mais moderno que o outro, tem mais capacidade de processamento e memória e usa uma versão mais moderna de wifi. Acho que até vi um desses tutoriais que explicam a grande vantagem de usar um roteador em modo AP, a partir de uma recomendação de um usuário aqui do forum. E o que dizem esses sites é ingênuo e muitas vezes errado, como nesse vídeo que vi no youtube com mais de 1 milhão de visualizações e cheio de erros e inconsistências. Usar como ponto de acesso não vai distribuir wifi de modo diferente. E não traz nada de especial. Em resumo, não entendo que haja grande vantagem em usar isso, se alguma. Eu uso um assim até, em minha casa. Mas é um roteador que está dentro do forro (desde 2019 eu acho) e que era pra ser mesmo um AP, só que ele já estava lá parado então acabou indo pro telhado, um AX10 da marca TP-Link. O roteador deve funcionar ok em modo roteador, o simples. Colocar o roteador que já em em modo bridge não é em geral esperto ou conveniente. Roteadores comuns que a claro usa são da classe AC1800 ou superior, e tem 4 portas ethernet. Entenda que ao colocar o modem em modo bridge (ponte) ele desaparece da rede e passa a ser, sem surpresas, uma ponte de rede. Não vai ter endereço IP na LAN, já que vai atuar apenas como conversor de mídia, oferencendo uma conexão RJ45 ethernet a partir de uma conexão via cabo coaxial. Não vai ter wifi nem ethernet via cabo. E em sua rede ao usar 192.168.31.0 E 192.168.0.0 está usando duas redes IP separadas --- estaria, já que como expliquei o modo bridge não tem endere;co na LAN --- e acredite, você não quer isso: só dá problema e perda de banda. O aparelho da Claro em modo bridge É muito comum usar bridge em empresas porque muitas vezes se tem mais de um provedor de acesso esses aparelhos por vezes perdem a configuração, em especial durante tempestades e quedas seguidas de energia, o que qualquer um que more no litoral deve ter visto com a NET/Claro nesse início do ano, em que choveu muito. E em 2023 que foi o caos no litoral de SP, onde estou. muitas empresas não tem suporte local permanente e fica muito caro e arriscado ficar dependendo de um aparelho assim, se por acaso a configuração padrão dele não atende. vários AP e roteadores em paralelo podem ser mais convenientes e simples de controlar Mas em uma rede doméstica faz pouco sentido porque esses aparelhos da Claro são dual band da classe AC1800, com uns 300+1500 mbps em wifi e 4 portas ethernet. E você não pode por as antenas de seu AX5400 em dois lugares ao mesmo tempo. Obviamente a cobertura de wifi vai diminuir. Em números absolutos vai cair 25% certo? De 7200 para 5400 mbps e a cobertura não tem mágica: pode ter um roteador em cada piso, um do lado norte um do lado sul da casa, ou algo assim. acho que sabe que wifi a 5ghz raramente passa duas paredes antes de se tornar inútil, então desligar a antena de 5Ghz da Claro é no mínimo esquisito se pode usar um de cada lado da casa se usar os dois roteadores terá 6 portas ethernet. Usando só um vai ter quantas? 4. 33% menos e se usar ethernet em um lugar só ao invés de 2 dá pra imaginar que pode precisar de cabos muito mais compridos Não por acaso o simples é usar um roteador perto de cada TV que tenha na casa, já que TV são grandes consumidoras de banda hoje em dia e são grandes. Muitas vezes o roteador pode ficar pendurado atrás delas mesmo, ou naqueles móveis compridos que muita gente usa... Postei aqui por exemplo muitos roteiros de como configurar isso, mas parei de repetir ainda em 2023. Pode ver no meu conteúdo se interesar, ou me avise e posta aqui uma lista que não tenho agora. DHCP e rede IP O mais esperto é deixar DHCP ativo nos dois, para diminuir as latências e manter a rede funcionando se um dlees parar. Não dá pra crer que existam tantos "tutoriais" sugerindo manter 1 único serviço desses. E a redundância? E as latências na rede do outro aparelho? Deve usar uma única rede IP ou via ser um pesadelo o espelhamento de tela, compartilhamento de arquivos, uso de impressoras wifi e a p. do mútiplo NAT que pode comer até 40% da banda na segunda rede...

Acho que está "nadando contra a correnteza" e isso cansa muito. Esses aparelhos não foram feitos para isso e, a menos que tenha escrito scripts de automação para controlar --- a manutenção de uma coisa dessas é chata, impossível, para dizer o mínimo. Considere um servidor de autenticação. Pode ser um micro antigo rodando Linux, ou RouterOS que é Linux. RADIUS é o serviço de que precisa, e fi criado exatamente para isso. Acho que todo aparelho relativamente moderno é compatível com isso, e todos esses dessa marca TP-Link. E do modo como está tentando a performance vai cair muito na segunda rede, E trazer muitos outros problemas, com encaminhameno de portas, streaming, impressoras e tal. Se isso está indo bem pra você divida os dispositivos em dois grupos de 64 e deixe uma única rede IP. Não use as portas WAN. O simples. Use DHCP nos dois e uma white list em cada um. Vai ter muito menos trabalho e muito melhor performance. Mas o simples é usar um servidor Radius.

@Binhaolinux10 O marketing criou novos significados para QoS. Entenda que QoS tem a ver com priorização de tráfego, e não controle ou limitação de banda por dispositivo. QoS serve por exemplo para priorizar o tráfego de VOIP na rede para ter melhor audio nas ligações. Ou para priorizar pacotes de streaming de vídeo na rede. Se você tem um dispositivo que "redefine" o que é QoS, talvez apresentando uma tabela de valores em mbps para upload e download por dispositivo, então deve ver na documentação desse aparelho o que eles entendem por QoS e como usar. Ou dizer aqui que aparelho é esse, de modo que alguém por exemplo que tenha um possa opinar.

@Caiocaf1 Ver uma ponta só do cabo não ajuda muito. É sim fora do padrão, mas se do outro lado estiver igualzinho não faz mesmo diferença para essas curtas distâncias. Até onde eu sei os aparelhos de TV (set top box) da VIVO operam em FE, 100mbits. E não precisam mesmo de mais que isso. Assim poderiam usar mesmo cabos de 4 vias e estaria ok. CAT5E é o adequado para seu uso, com até 95+5m de cabo. 100 ou 300 ou 3 mbps de contrato com o provedor nada tem a ver com sua rede local. É natural e esperado que a velocidade na LAN seja muito maior. Não é estranho ter uma LAN a 25 ou 100G e nem ter conexão permanente com a internet. Teste sua rede dentro de sua rede. É mais simples. Não misture as coisas. Algo comum é usar um arquivo grande, ou uma pasta com vários gigabytes, e transferir entre as estações e ver tempos e estabilidade. Sobre a velocidade, veja o que o sistema reporta e não esses testes de velocidade com a internet, que são outra coisa e apenas recebem dados sem sentido e que não vão ser processados.

Cabo de rede nada tem a ver com a internet. Só vai usar para ligar o seu PC com outro aparelho. Não foi por isso. Esse cabo deve estar com defeito. Cat6 deve ir até uns 10.000 mbps com esse cabo até 95+5m dependendo claro do que tiver em cada ponta. Usando o cabo direto entre dois aparelhos e até uns 20m pode conseguir algo mais até. Mas com seus aparelhos não vai além de 1.000 mbps.