de todas as soluções inteiras não negativas da equação x + y = 7, quantas são formadas por números primos
os valores que x e y podem assumir são:



desse conjunto de números, os únicos números que são primos são: 

se x=2, então y=5 ( verdadeiro, e ambos números primos)

se x=3, então y=4 ( verdadeiro, mas 4 não é um número primo)

se x=5, então y=2 ( verdadeiro, e ambos números primos)

se x=7, então y=0 ( verdadeiro, mas 0 não é um número primo)

sendo assim, apenas duas soluções são formadas por números primos:




conclusão:

portanto, para a equação , temos apenas duas soluções formadas por números primos, que são:



contextualização:

números primos são os números naturais que têm apenas dois divisores diferentes: o 1 e ele mesmo.

exemplos:

1) 2 tem apenas os divisores 1 e 2, portanto 2 é um número primo.

2) 17 tem apenas os divisores 1 e 17, portanto 17 é um número primo.

3) 10 tem os divisores 1, 2, 5 e 10, portanto 10 não é um número primo.

observações:

1 não é um número primo, porque ele tem apenas um divisor que é ele mesmo.

2 é o único número primo que é par.


resolução:

como x e y devem ser números inteiros não negativos, e a soma de
3x+2y=39 2x-3y=0 multiplicamos a primeira equação por 3 e a segunda por 2 9x+6y=117 4x-6y=0 somamos para cancelar o y 9x+4x=117 13x=117 x=117/13 x=9 substituímos em 2x-3y=0 2.9-3y=0 18-3y=0 18=3y y=18/3 y=6 vai ter que ser letra e (mas os valores estão na ordem invertida: y e x nesta opção) oi peter, tudo certo? a camila falou muito bem sobre ser convergente, vou mandar só como eu faria para descobrir essas informações. 
 [[11]](//www.mesalva.com/forum/uploads/default/original/2x/4/47f2cce4419b12c3655aa99bc7d487ca902bad18.jpeg "whatsapp image 2019-11-20 at 15.54.11.jpeg")
espero que faça sentido! se somarmos todos os valores (soma infinita) vemos para onde essa série vai resultar. 
abraço! <h2>7 bits ascii?</h2><p>se o seu tardis acabou de chegar em 1963, e você quer apenas o 7 bit imprimível ascii chars, você pode copiar tudo de 0 a 31 e 127 a 255 com isto:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f-\xff]/', '', $string); </code></pre><p>ele corresponde a qualquer coisa no intervalo de 0 a 31, 127 a 255 e remove-o. </p><h2>8 bits estendido ascii?</h2><p>você caiu em um time machine hot tub, e você está de volta nos anos oitenta. se você tem alguma forma de ascii de 8 bits, então você pode querer manter os caracteres no intervalo de 128-255. um ajuste fácil - basta olhar para 0-31 e 127</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/', '', $string); </code></pre><h2>utf-8?</h2><p>ah, bem vindo de volta ao século 21. se você tem uma string codificada em utf-8, então o <code>/u</code> <a href="http://php.net/manual/en/reference.pcre.pattern.modifiers.php">modifier</a> pode ser usado no regex</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f]/u', '', $string); </code></pre><p>isso apenas remove 0-31 e 127. isso funciona em ascii e utf-8 porque ambos compartilham o <a href="http://www.fileformat.info/info/charset/utf-8/list.htm">mesmo intervalo de conjunto de controles</a> (como observado por mgutt abaixo). estritamente falando, isso funcionaria sem o modificador <code>/u</code>. mas isso facilita a vida se você quiser remover outros caracteres ...</p><p>se você está lidando com unicode, existem <a href="https://stackoverflow.com/questions/3770117/what-is-the-range-of-unicode-printable-characters">potencialmente muitos elementos não-imprimíveis</a> , mas vamos considerar um simples: <a href="https://unicode-table.com/en/00a0/">no-break space (u + 00a0)</a> </p><p>em uma string utf-8, isso seria codificado como <code>0xc2a0</code>. você pode procurar e remover essa sequência específica, mas com o modificador <code>/u</code> no lugar, você pode simplesmente adicionar <code>\xa0</code> à classe de caractere:</p><pre><code>$string = preg\_replace('/[\x00-\x1f\x7f\xa0]/u', '', $string); </code></pre><h2>adenda: e sobre str\_replace?</h2><p>preg\_replace é bastante eficiente, mas se você está fazendo esta operação muito, você pode construir uma matriz de caracteres que você deseja remover, e usar str\_replace como observado por mgutt abaixo, por exemplo.</p><pre><code>//build an array we can re-use across several operations $badchar=array( // control characters chr(0), chr(1), chr(2), chr(3), chr(4), chr(5), chr(6), chr(7), chr(8), chr(9), chr(10), chr(11), chr(12), chr(13), chr(14), chr(15), chr(16), chr(17), chr(18), chr(19), chr(20), chr(21), chr(22), chr(23), chr(24), chr(25), chr(26), chr(27), chr(28), chr(29), chr(30), chr(31), // non-printing characters chr(127) ); //replace the unwanted chars $str2 = str\_replace($badchar, '', $str); </code></pre><p>intuitivamente, isso parece que seria rápido, mas nem sempre é o caso, você deve definitivamente comparar para ver se você economiza alguma coisa. fiz alguns benchmarks em vários comprimentos de string com dados aleatórios, e esse padrão surgiu usando o php 7.0.12</p><pre><code> 2 chars str\_replace 5.3439ms preg\_replace 2.9919ms preg\_replace is 44.01% faster 4 chars str\_replace 6.0701ms preg\_replace 1.4119ms preg\_replace is 76.74% faster 8 chars str\_replace 5.8119ms preg\_replace 2.0721ms preg\_replace is 64.35% faster 16 chars str\_replace 6.0401ms preg\_replace 2.1980ms preg\_replace is 63.61% faster 32 chars str\_replace 6.0320ms preg\_replace 2.6770ms preg\_replace is 55.62% faster 64 chars str\_replace 7.4198ms preg\_replace 4.4160ms preg\_replace is 40.48% faster 128 chars str\_replace 12.7239ms preg\_replace 7.5412ms preg\_replace is 40.73% faster 256 chars str\_replace 19.8820ms preg\_replace 17.1330ms preg\_replace is 13.83% faster 512 chars str\_replace 34.3399ms preg\_replace 34.0221ms preg\_replace is 0.93% faster 1024 chars str\_replace 57.1141ms preg\_replace 67.0300ms str\_replace is 14.79% faster 2048 chars str\_replace 94.7111ms preg\_replace 123.3189ms str\_replace is 23.20% faster 4096 chars str\_replace 227.7029ms preg\_replace 258.3771ms str\_replace is 11.87% faster 8192 chars str\_replace 506.3410ms preg\_replace 555.6269ms str\_replace is 8.87% faster 16384 chars str\_replace 1116.8811ms preg\_replace 1098.0589ms preg\_replace is 1.69% faster 32768 chars str\_replace 2299.3128ms preg\_replace 2222.8632ms preg\_replace is 3.32% faster </code></pre><p>os tempos próprios são para 10000 iterações, mas o que é mais interessante são as diferenças relativas. até 512 chars, eu estava vendo preg\_replace sempre vencer. no intervalo de 1-8kb, o str\_replace tinha um edge marginal. </p><p>eu pensei que era um resultado interessante, então incluí-lo aqui. <em>o importante é não pegar este resultado e usá-lo para decidir qual método utilizar, mas para fazer benchmark com seus próprios dados e depois decidir.</em></p> i = 2,47 a <p>resolvido!</p> 1)a)49/64 b)27/125 2)a)1/6 b)3/5 c)1/2 Pra mim chegou hoje a nova versao do android 7.0 pro j7 prime. Mt feliz <p>estou divulgando isso, caso outra pessoa tenha esse problema.</p><p>o chipset intel está integrado. descobri que a razão para a resolução ruim no windows 7 era que a memória para compartilhar com a placa de vídeo estava definida para 1 mb no bios. eu mudei isso para 8 mb (o máximo) e depois que o pc reiniciou eu pude selecionar uma resolução mais alta.</p> gt 710 é menos ruinzinha kkk <p>oi thiago tudo bem?</p>
<p>você tem que usar o laço for para fazer o código. veja como eu fiz e tente fazer depois sozinho.</p>
<pre class="prettyprint"><code>#include &lt;stdio.h&gt;

int main()
{ 

 int a;
 printf(&#34;entre um número inteiro positivo\n&#34;);
 scanf(&#34;%d&#34;, &amp;a);

 int b;
 printf(&#34;entre um outro número inteiro positivo\n&#34;);
 scanf(&#34;%d&#34;, &amp;b);

 int soma&#61;0;
 int contador;
 for(contador &#61; a&#43;1; contador &lt; b; contador&#43;&#43;)
 {
 soma&#61;soma&#43;contador;
 }


 printf(&#34;a soma é %d\n&#34;, soma);
 return 0;
}
</code></pre><p>espero ter ajudado!!!</p>